Subscenes

src/dawn/scene/Scene.hpp

@@ -10,6 +10,7 @@
 
 namespace Dawn {
   class DawnGame;
+  class RenderPipeline;
 
   class Scene {
     private:
@@ -127,5 +128,7 @@ namespace Dawn {
        * Destroys a previously initialized Scene.
        */
       ~Scene();
+
+      friend class RenderPipeline;
   };
 }

src/dawn/scene/components/CMakeLists.txt

@@ -7,4 +7,5 @@
 add_subdirectory(display)
 add_subdirectory(example)
 add_subdirectory(physics)
+add_subdirectory(scene)
 add_subdirectory(ui)

src/dawn/scene/components/Components.hpp

@@ -11,7 +11,11 @@
 #include "scene/components/display/Material.hpp"
 #include "scene/components/display/PixelPerfectCamera.hpp"
 #include "scene/components/display/TiledSprite.hpp"
+#include "scene/components/display/SimpleRenderTargetQuad.hpp"
 
 #include "scene/components/example/ExampleSpin.hpp"
 
+#include "scene/components/scene/SubSceneController.hpp"
+#include "scene/components/scene/SubSceneCameraAlign.hpp"
+
 #include "scene/components/ui/UICanvas.hpp"

src/dawn/scene/components/display/CMakeLists.txt

@@ -13,4 +13,5 @@ target_sources(${DAWN_TARGET_NAME}
     MeshRenderer.cpp
     PixelPerfectCamera.cpp
     TiledSprite.cpp
+    SimpleRenderTargetQuad.cpp
 )

src/dawn/scene/components/display/PixelPerfectCamera.cpp

@@ -41,7 +41,13 @@ void PixelPerfectCamera::updateDimensions() {
       break;
     
     case CAMERA_TYPE_PERSPECTIVE:
-      assertDeprecated();
+      this->transform->lookAtPixelPerfect(
+        glm::vec3(0, 0, 0),
+        glm::vec3(0, 0, 0),
+        target->getHeight() / this->scale,
+        this->camera->fov
+      );
+      // this->transform->lookAt(glm::vec3(360, 360, 360), glm::vec3(0, 0, 0));
       break;
     
     default:

src/dawn/scene/components/display/PixelPerfectCamera.hpp

@@ -19,7 +19,7 @@ namespace Dawn {
       void updateDimensions();
 
     public:
-      float_t scale = 4.0f;
+      float_t scale = 1.0f;
 
       /**
        * Create a new PixelPerfectCamera Component.

src/dawn/scene/components/display/SimpleRenderTargetQuad.cpp

@@ -0,0 +1,81 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SimpleRenderTargetQuad.hpp"
+#include "scene/Scene.hpp"
+
+using namespace Dawn;
+
+SimpleRenderTargetQuad::SimpleRenderTargetQuad(SceneItem *i) :
+  SceneItemComponent(i)
+{
+}
+
+void SimpleRenderTargetQuad::onRenderTargetResized(
+  RenderTarget *target, float_t w, float_t h
+) {
+  assertTrue(target == this->renderTarget);
+  // Update mesh
+  QuadMesh::bufferQuadMesh(
+    &this->meshHost->mesh,
+    glm::vec2(0, 0), glm::vec2(0, 0),
+    glm::vec2(w, h), glm::vec2(1, 1),
+    0, 0
+  );
+}
+
+
+void SimpleRenderTargetQuad::setRenderTarget(RenderTarget *rt) {
+  assertTrue(rt != this->renderTarget);
+
+  // Remove old event listener
+  if(this->renderTarget != nullptr) {
+    this->renderTarget->eventRenderTargetResized.removeListener(
+      this, &SimpleRenderTargetQuad::onRenderTargetResized
+    );
+  }
+
+  this->renderTarget = rt;
+
+  // Add new event listener.
+  if(rt != nullptr) {
+    rt->eventRenderTargetResized.addListener(
+      this, &SimpleRenderTargetQuad::onRenderTargetResized
+    );
+  }
+}
+
+std::vector<SceneItemComponent*> SimpleRenderTargetQuad::getDependencies() {
+  return std::vector<SceneItemComponent*>{
+    (this->meshHost = this->item->getComponent<MeshHost>())
+  };
+}
+
+void SimpleRenderTargetQuad::onStart() {
+  assertNotNull(this->meshHost);
+
+  // Create quad mesh
+  this->meshHost->mesh.createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
+
+  // Perform first resize.
+  if(this->renderTarget != nullptr) {
+    QuadMesh::bufferQuadMesh(
+      &this->meshHost->mesh,
+      glm::vec2(0, 0),
+      glm::vec2(0, 0),
+      glm::vec2(this->renderTarget->getWidth(), this->renderTarget->getHeight()),
+      glm::vec2(1,1),
+      0, 0
+    );
+  }
+}
+
+SimpleRenderTargetQuad::~SimpleRenderTargetQuad() {
+  if(this->renderTarget != nullptr) {
+    this->renderTarget->eventRenderTargetResized.removeListener(
+      this, &SimpleRenderTargetQuad::onRenderTargetResized
+    );
+  }
+}

src/dawn/scene/components/display/SimpleRenderTargetQuad.hpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/components/display/MeshHost.hpp"
+#include "display/RenderTarget.hpp"
+#include "display/mesh/QuadMesh.hpp"
+
+namespace Dawn {
+  class SimpleRenderTargetQuad : public SceneItemComponent {
+    protected:
+      MeshHost *meshHost = nullptr;
+      RenderTarget *renderTarget = nullptr;
+
+      void onRenderTargetResized(RenderTarget *target, float_t w, float_t h);
+
+    public:
+      /**
+       * Creates a SimpleRenderTargetQuad scene item component. This component
+       * will update the attached MeshHost any time the render target provided
+       * is updated / resized.
+       * 
+       * @param item Item that this component is attached to.
+       */
+      SimpleRenderTargetQuad(SceneItem *item);
+
+      /**
+       * Sets the render target to use for this quad. Can be set to nullptr when
+       * you no longer wish to listen for resize events.
+       * 
+       * @param rt Render target to attach to.
+       */
+      void setRenderTarget(RenderTarget *rt);
+      
+      std::vector<SceneItemComponent*> getDependencies() override;
+      void onStart() override;
+      
+      ~SimpleRenderTargetQuad();
+  };
+}

src/dawn/scene/components/scene/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    SubSceneCameraAlign.cpp
+    SubSceneController.cpp
+)

src/dawn/scene/components/scene/SubSceneCameraAlign.cpp

@@ -0,0 +1,102 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SubSceneCameraAlign.hpp"
+
+using namespace Dawn;
+
+SubSceneCameraAlign::SubSceneCameraAlign(SceneItem *i) : SceneItemComponent(i) {
+
+}
+
+void SubSceneCameraAlign::onRenderTargetResize(
+  RenderTarget *target, float_t w, float_t h
+) {
+  this->realign();
+}
+
+void SubSceneCameraAlign::realign() {
+  float_t diff;
+  if(this->camera == nullptr) return;
+  if(this->renderTarget == nullptr) return;
+
+  float_t ratio = this->renderTarget->getWidth() / this->renderTarget->getHeight();
+  float_t myRatio = this->camera->getRenderTarget()->getWidth() / this->camera->getRenderTarget()->getHeight();
+  
+  this->camera->type = CAMERA_TYPE_ORTHONOGRAPHIC;
+  this->camera->transform->lookAt(glm::vec3(0, 0, 10), glm::vec3(0, 0, 0));
+
+  if(ratio > myRatio) {
+    // My Ratio is narrower
+    this->camera->orthoLeft = 0;
+    this->camera->orthoRight = this->renderTarget->getWidth();
+    diff = (this->renderTarget->getHeight() - (this->renderTarget->getWidth() / myRatio)) / 2.0f;
+    this->camera->orthoTop = this->renderTarget->getHeight() - diff;
+    this->camera->orthoBottom = diff;
+  } else {
+    // My ratio is wider
+    this->camera->orthoBottom = 0;
+    this->camera->orthoTop = this->renderTarget->getHeight();
+    diff = (this->renderTarget->getWidth() - (this->renderTarget->getHeight() * myRatio)) / 2.0f;
+    this->camera->orthoLeft = diff;
+    this->camera->orthoRight = this->renderTarget->getWidth() - diff;
+  }
+
+}
+
+void SubSceneCameraAlign::setRenderTarget(TextureRenderTarget *renderTarget) {
+  assertTrue(this->renderTarget != renderTarget);
+
+  if(this->renderTarget != nullptr) {
+    this->renderTarget->eventRenderTargetResized.removeListener(
+      this, &SubSceneCameraAlign::onRenderTargetResize
+    );
+  }
+
+  this->renderTarget = renderTarget;
+  this->realign();
+  
+  if(this->renderTarget != nullptr) {
+    this->renderTarget->eventRenderTargetResized.addListener(
+      this, &SubSceneCameraAlign::onRenderTargetResize
+    );
+  }
+}
+
+void SubSceneCameraAlign::setCamera(Camera *camera) {
+  assertTrue(this->camera != camera);
+
+  if(this->camera != nullptr) {
+    this->camera->getRenderTarget()->eventRenderTargetResized.removeListener(
+      this, &SubSceneCameraAlign::onRenderTargetResize
+    );
+  }
+
+  this->camera = camera;
+  this->realign();
+
+  if(this->camera != nullptr) {
+    this->camera->getRenderTarget()->eventRenderTargetResized.addListener(
+      this, &SubSceneCameraAlign::onRenderTargetResize
+    );
+  }
+}
+
+void SubSceneCameraAlign::onStart() {
+  this->realign();
+}
+
+SubSceneCameraAlign::~SubSceneCameraAlign() {
+  if(this->renderTarget != nullptr) {
+    this->renderTarget->eventRenderTargetResized.removeListener(
+      this, &SubSceneCameraAlign::onRenderTargetResize
+    );
+  }
+  if(this->camera != nullptr) {
+    this->camera->getRenderTarget()->eventRenderTargetResized.removeListener(
+      this, &SubSceneCameraAlign::onRenderTargetResize
+    );
+  }
+}

src/dawn/scene/components/scene/SubSceneCameraAlign.hpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/Scene.hpp"
+#include "display/TextureRenderTarget.hpp"
+#include "scene/components/display/Camera.hpp"
+
+namespace Dawn {
+  class SubSceneCameraAlign : public SceneItemComponent {
+    protected:
+      TextureRenderTarget *renderTarget = nullptr;
+      Camera *camera = nullptr;
+
+      void onRenderTargetResize(RenderTarget *target, float_t w, float_t h);
+
+      void realign();
+
+    public:
+
+      SubSceneCameraAlign(SceneItem *item);
+
+      void setRenderTarget(TextureRenderTarget *renderTarget);
+      void setCamera(Camera *camera);
+
+      void onStart() override;
+
+      ~SubSceneCameraAlign();
+  };
+}

src/dawn/scene/components/scene/SubSceneController.cpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SubSceneController.hpp"
+
+using namespace Dawn;
+
+SubSceneController::SubSceneController(SceneItem *i)  : SceneItemComponent(i) {
+
+}
+
+void SubSceneController::onSceneUpdate() {
+  if(this->onlyUpdateUnpaused) return;
+  if(this->subScene == nullptr) return;
+  this->subScene->update();
+}
+
+void SubSceneController::onSceneUnpausedUpdate() {
+  if(!this->onlyUpdateUnpaused) return;
+  if(this->subScene == nullptr) return;
+  this->subScene->update();
+}
+
+Scene * SubSceneController::getSubScene() {
+  return this->subScene;
+}
+
+void SubSceneController::setSubScene(Scene *scene) {
+  assertTrue(scene != this->subScene);
+  this->subScene = scene;
+}
+
+void SubSceneController::onStart() {
+  auto myScene = this->getScene();
+  myScene->eventSceneUnpausedUpdate.addListener(this, &SubSceneController::onSceneUnpausedUpdate);
+  myScene->eventSceneUpdate.addListener(this, &SubSceneController::onSceneUpdate);
+}
+
+SubSceneController::~SubSceneController() {
+  auto myScene = this->getScene();
+  myScene->eventSceneUnpausedUpdate.removeListener(this, &SubSceneController::onSceneUnpausedUpdate);
+  myScene->eventSceneUpdate.removeListener(this, &SubSceneController::onSceneUpdate);
+}

src/dawn/scene/components/scene/SubSceneController.hpp

@@ -0,0 +1,29 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/Scene.hpp"
+
+namespace Dawn {
+  class SubSceneController : public SceneItemComponent {
+    protected:
+      Scene *subScene = nullptr;
+
+      void onSceneUpdate();
+      void onSceneUnpausedUpdate();
+
+    public:
+      bool_t onlyUpdateUnpaused = true;
+
+      SubSceneController(SceneItem *item);
+
+      Scene * getSubScene();
+      void setSubScene(Scene *scene);
+
+      void onStart() override;
+
+      ~SubSceneController();
+  };
+}

src/dawn/scene/components/ui/UICanvas.cpp

@@ -18,25 +18,7 @@ UICanvas * UICanvas::create(Scene *scene) {
 UICanvas::UICanvas(SceneItem *item) : SceneItemComponent(item) {
 }
 
-float_t UICanvas::getWidth() {
-  return this->getGame()->renderManager.getBackBuffer()->getWidth();
-}
-
-float_t UICanvas::getHeight() {
-  return this->getGame()->renderManager.getBackBuffer()->getHeight();
-}
-
-void UICanvas::onStart() {
-  this->getGame()->renderManager.getBackBuffer()->eventRenderTargetResized
-    .addListener(this, &UICanvas::onBackBufferResize)
-  ;
-}
-
-void UICanvas::onBackBufferResize(
-  RenderTarget *target,
-  float_t width,
-  float_t height
-) {
+void UICanvas::onRenderTargetResize(RenderTarget *target, float_t w, float_t h){
   auto it = this->children.begin();
   while(it != this->children.end()) {
     (*it)->updatePositions();
@@ -44,14 +26,55 @@ void UICanvas::onBackBufferResize(
   }
 }
 
+void UICanvas::setCamera(Camera *camera) {
+  assertTrue(camera != this->camera);
+  
+  if(this->camera != nullptr) {
+    this->camera->getRenderTarget()->eventRenderTargetResized.removeListener(
+      this, &UICanvas::onRenderTargetResize
+    );
+  }
+
+  this->camera = camera;
+  
+  if(this->camera != nullptr) {
+    this->camera->getRenderTarget()->eventRenderTargetResized.addListener(
+      this, &UICanvas::onRenderTargetResize
+    );
+  }
+}
+
+float_t UICanvas::getWidth() {
+  if(this->camera == nullptr) {
+    return this->getGame()->renderManager.getBackBuffer()->getWidth();
+  }
+  return this->camera->getRenderTarget()->getWidth();
+}
+
+float_t UICanvas::getHeight() {
+  if(this->camera == nullptr) {
+    return this->getGame()->renderManager.getBackBuffer()->getHeight();
+  }
+  return this->camera->getRenderTarget()->getHeight();
+}
+
+void UICanvas::onStart() {
+  if(this->camera == nullptr) {
+    auto camera = this->getScene()->findComponent<Camera>();
+    this->setCamera(camera);
+  }
+}
+
 UICanvas::~UICanvas() {
   auto it = this->children.begin();
   while(it != this->children.end()) {
     delete *it;
     ++it;
   }
-
-  this->getGame()->renderManager.getBackBuffer()->eventRenderTargetResized
-    .removeListener(this, &UICanvas::onBackBufferResize)
-  ;
+  
+  if(this->camera != nullptr) {
+    this->camera->getRenderTarget()->eventRenderTargetResized.removeListener(
+      this, &UICanvas::onRenderTargetResize
+    );
+  }
 }

src/dawn/scene/components/ui/UICanvas.hpp

@@ -6,6 +6,7 @@
 #pragma once
 #include "scene/SceneItemComponent.hpp"
 #include "display/RenderTarget.hpp"
+#include "scene/components/display/Camera.hpp"
 
 namespace Dawn {
   enum UIDrawType {
@@ -18,11 +19,9 @@ namespace Dawn {
 
   class UICanvas : public SceneItemComponent {
     protected:
-      void onBackBufferResize(
-        RenderTarget *target,
-        float_t width,
-        float_t height
-      );
+      Camera *camera = nullptr;
+
+      void onRenderTargetResize(RenderTarget *target, float_t w, float_t h);
 
     public:
       /**
@@ -45,6 +44,13 @@ namespace Dawn {
        */
       UICanvas(SceneItem *item);
 
+      /**
+       * Sets the camera used by the UI canvas.
+       * 
+       * @param camera Camera to set for the UI canvas.
+       */
+      void setCamera(Camera *camera);
+
       /**
        * Construct and append a UI item to this UI Canvas.
        *