AtmosphereTestScene.cpp

#include <engine/scene/scenes/AtmosphereTestScene.hpp>

#include <engine/ui/UISystem.hpp>

#include <ACGL/ACGL.hh>

#include <ACGL/OpenGL/Objects.hh>
#include <ACGL/Base/Settings.hh>
#include <ACGL/Math/Math.hh>
#include <ACGL/OpenGL/Data/TextureLoadStore.hh>
#include <ACGL/OpenGL/Managers.hh>

#include <ACGL/OpenGL/Creator/ShaderProgramCreator.hh>
#include <ACGL/OpenGL/Creator/VertexArrayObjectCreator.hh>
#include <ACGL/OpenGL/Creator/Texture2DCreator.hh>

#include <engine/scene/Transform.hpp>
#include <engine/scene/Drawable.hpp>
#include <engine/scene/Planet.hpp>

#include <engine/events/MouseEvent.hpp>
#include <engine/events/KeyboardEvent.hpp>

#include <engine/graphics/BloomPostFX.hpp>

using namespace ACGL::OpenGL;
using namespace ACGL::Base;
using namespace ACGL::Utils;

bool AtmosphereTestScene::startup() {
  if (!Scene::startup()) {
    return false;
  }

  RESOLVE_DEPENDENCY(m_player);
  RESOLVE_DEPENDENCY(m_orbitals);

  m_renderer->addEffect<BloomPostFX>();
  {
    auto skyboxPassId = m_renderer->getRenderPassId("Skybox"_sh);
    auto vaoSkybox = VertexArrayObjectCreator("skybox.obj").create();
    auto skyboxShader = ShaderProgramFileManager::the()->get(ShaderProgramCreator("Skybox")
      .attributeLocations(vaoSkybox->getAttributeLocations())
      .fragmentDataLocations(m_renderer->getGBufferLocations()));

    auto skyboxTexture = Texture2DFileManager::the()->get(Texture2DCreator("skybox.png"));

    Geometry skyboxGeom = { vaoSkybox };
    skyboxGeom.vao->setMode(GL_PATCHES);

    Material skyboxMaterial = { glm::vec4{ 1, 1, 1, 1 }, glm::vec4{ 1, 1, 1, 1 }, skyboxTexture, nullptr, nullptr, skyboxShader, false, RenderQueue::OPAQUE, GL_BACK };

    skybox = m_sceneGraph->create();
    skybox.assign<Transform>();
    skybox.assign<Drawable>(skyboxGeom, skyboxMaterial, 0, skyboxPassId);
    skybox.assign<Light>(glm::vec4(1, 1, 1, 1), glm::vec3(1, 0, 0), false, LightType::POINT, skyboxPassId);
  }

  {
    auto mainPassId = m_renderer->getRenderPassId("Main"_sh);
    auto vaoSun = VertexArrayObjectCreator("uvsphere.obj").create();

    // load a texture:
    auto checkboardTexture = Texture2DFileManager::the()->get(Texture2DCreator("checkerboard.png"));

    // look up all shader files starting with 'PBR' and build a ShaderProgram from it:
    auto sunShader = ShaderProgramCreator("PBR")
      .attributeLocations(vaoSun->getAttributeLocations())
      .fragmentDataLocations(m_renderer->getGBufferLocations()).create();

    // Create geometry objects that point to the previously initialized vaos
    Geometry geom1 = { vaoSun };
    geom1.vao->setMode(GL_PATCHES);

    // Create a material that uses the loaded shader program
    Material sunMaterial = { glm::vec4{ 1, 1, 1, 1 }, glm::vec4{ 2, 2, 1, 20 }, checkboardTexture, nullptr, nullptr, sunShader, false, RenderQueue::OPAQUE, GL_BACK };

    // Let's create a placeholder sun
    sun = m_sceneGraph->create();
    // Add a transform component to it so we are able to position it in space
    auto sunTransform = sun.assign<Transform>();
    // Add a Drawable component to it so the renderer has something to draw
    sun.assign<Drawable>(geom1, sunMaterial, 0, mainPassId);
    float scale = m_orbitals->solarRadius * m_orbitals->scaleFactor * 0.1;
    sunTransform->scale = glm::dvec3(scale);
    sunLight = sun.assign<Light>(glm::vec4(1, 1, 1, 3), glm::vec3(1, 0, 0), false, LightType::DIRECTIONAL, mainPassId);

    // create a planet! 
    // Mass in solar masses, Radius in solar radii, Eccentricity, Semimajor axis, Inclination, Ascending Node, Arg. of Periapsis, time at perihelion
    //																mass              radius            e         a        i          N          w
    earth = m_orbitals->addPlanet(sunTransform, "Earth", 0.000002988, 0.009153735632184, 0.016713, 1.000000, 0.0000000, 0.00000, 4.93533, 0);
  }

  {
    auto cockpitPassId = m_renderer->getRenderPassId("Cockpit"_sh);
    // create cockpit 
    auto vaoCockpit = VertexArrayObjectCreator("cockpit.obj").create();
    auto cockpitShader = ShaderProgramCreator("PBR")
      .attributeLocations(vaoCockpit->getAttributeLocations())
      .fragmentDataLocations(m_renderer->getGBufferLocations()).create();

    Material cockpitMaterial{ glm::vec4{0.4, 0.4, 0.4, 1}, glm::vec4{0, 0, 0, 1}, 
      Texture2DFileManager::the()->get(Texture2DCreator("cockpit/cockpit_DefaultMaterial_AlbedoTransparency.png")),
      Texture2DFileManager::the()->get(Texture2DCreator("cockpit/cockpit_DefaultMaterial_Normal.png")), 
      Texture2DFileManager::the()->get(Texture2DCreator("cockpit/cockpit_DefaultMaterial_SpecularSmoothness.png")),
      cockpitShader,
      true, 
      RenderQueue::OPAQUE, 
      GL_BACK };

    Geometry cockpitGeom{ vaoCockpit };
    cockpitGeom.vao->setMode(GL_PATCHES);
    cockpit = m_sceneGraph->create();
    auto cockpitDrawable = cockpit.assign<Drawable>(cockpitGeom, cockpitMaterial, 0, cockpitPassId);
    auto cockpitTransform = cockpit.assign<Transform>();
    cockpitTransform->position = glm::dvec3(0, 0, 0);
    cockpitDrawable->visible = true;
    auto cockpitLight = cockpit.assign<Light>(glm::vec4(1, 1, 1, 0.2), glm::vec3(1, 0, 0), false, LightType::POINT, cockpitPassId);

    cockpitSun = m_sceneGraph->create();
    cockpitSun.assign<Transform>();
    cockpitSunLight = cockpitSun.assign<Light>(glm::vec4(1, 1, 1, 3), glm::vec3(1, 0, 0), true, LightType::DIRECTIONAL, cockpitPassId);

    auto blinkButton = m_sceneGraph->create();
    blinkButton.assign<Light>(glm::vec4(1, 0.2, 0.2, 5), glm::vec3(1, 0, 0), false, LightType::POINT, cockpitPassId);
    auto transform = blinkButton.assign<Transform>();
    transform->parent = cockpitTransform;
    transform->position = { 0.7655, -0.4545 , -1.643 };

    blinkButton = m_sceneGraph->create();
    blinkButton.assign<Light>(glm::vec4(0, 0.2, 1.0, 5), glm::vec3(1, 0, 0), false, LightType::POINT, cockpitPassId);
    transform = blinkButton.assign<Transform>();
    transform->parent = cockpitTransform;
    transform->position = { -0.7655, -0.4545 , -1.643 };
  }

  m_events->subscribe<SimulateEvent>([this](const SimulateEvent& e) {
    sunLight->dir = -glm::normalize(m_player->getWorldPosition());
    cockpitSunLight->dir = glm::vec3(glm::dvec4(sunLight->dir, 0) * m_player->getRotation());
  });

  m_events->subscribe<KeyboardEvent>([this](const KeyboardEvent& e) {
    switch (e.originalEvent.key.keysym.scancode) {
      case SDL_SCANCODE_TAB:
	if (e.originalEvent.key.type == SDL_KEYDOWN) {
	  m_player->attachToParent(earth);
	  float r = earth.component<Transform>()->scale.x;
	  m_player->setPosition(glm::vec3(0, 0, r * 1.2));
      	  m_player->setRotation(glm::mat4());
	}
	break;
      default:
	break;
    }
  });

  // Subscribe to the UI drawing event.
  // This is called once per frame
  m_events->subscribe<"DrawUI"_sh>([this]() {

    ImGui::Begin("Camera Control", 0,
      ImGuiWindowFlags_::ImGuiWindowFlags_AlwaysAutoResize);

		float r;
    if (ImGui::Button("Sun/Global", glm::vec2(100, 20))) {
      // Reset the camera to sun coords
      m_player->attachToParent(sun);
			r = sun.component<Transform>()->scale.x;
      m_player->setPosition(glm::dvec3(0, 0, r * 1.2));
      m_player->setRotation(glm::dmat4());
    }


    if (ImGui::Button("Earth", glm::vec2(100, 20))) {
      m_player->attachToParent(earth);
			r = earth.component<Transform>()->scale.x;
			m_player->setPosition(glm::dvec3(0, 0, r * 1.2));
      m_player->setRotation(glm::dmat4());
    }

    ImGui::End();
  });

  return true;
}

void AtmosphereTestScene::shutdown() {
}