about to add SDL and probably break everything

src/dawn/asset/AssetManager.cpp

@@ -46,7 +46,7 @@ void AssetManager::queueSwap(
   auto itUnload = oldAssets.begin();
   while(itUnload != oldAssets.end()) {
     auto inNewAssets = std::find(newAssets.begin(), newAssets.end(), *itUnload);
-    if(inNewAssets == oldAssets.end()) unload.push_back(*itUnload);
+    if(inNewAssets == newAssets.end()) unload.push_back(*itUnload);
     ++itUnload;
   }
 

src/dawn/game/_DawnGame.hpp

@@ -51,6 +51,15 @@ namespace Dawn {
        */
       virtual int32_t update(float_t delta) = 0;
 
+      /**
+       * Changes to a new scene, will dispose the currently active scene as part
+       * of that process. This assumes the other scene has already been loaded
+       * and staged.
+       * 
+       * @param scene Scene to cut over to.
+       */
+      virtual void sceneCutover(Scene *scene) = 0;
+
       /**
        * Cleanup the memory of the DawnGame instance.
        */

src/dawn/scene/Scene.cpp

@@ -37,7 +37,15 @@ SceneItem * Scene::createSceneItem() {
 }
 
 Scene::~Scene() {
+  // Early cleanup without disposing.
   auto it = this->items.begin();
+  while(it != this->items.end()) {
+    it->second->destroy();
+    ++it;
+  }
+
+  // Now dispose everything.
+  it = this->items.begin();
   while(it != this->items.end()) {
     delete it->second;
     ++it;

src/dawn/scene/SceneItem.cpp

@@ -59,8 +59,17 @@ void SceneItem::init() {
   } while(waitingOn != 0);
 }
 
+void SceneItem::destroy() {
+  auto it = this->components.begin();
+  while(it != this->components.end()) {
+    (*it)->onDispose();
+    ++it;
+  }
+}
+
 SceneItem::~SceneItem() {
   auto it = this->components.begin();
+  it = this->components.begin();
   while(it != this->components.end()) {
     delete *it;
     ++it;

src/dawn/scene/SceneItem.hpp

@@ -37,6 +37,12 @@ namespace Dawn {
        */
       void init();
 
+      /**
+       * Called by the Scene when cleanup needs to occur but before anything in
+       * the scene has been disposed.
+       */
+      void destroy();
+
       /**
        * Adds a component to this scene item. Components will only have their
        * init methods invoked on the first frame we enter the scene. If you add

src/dawn/scene/SceneItemComponent.cpp

@@ -37,6 +37,10 @@ void SceneItemComponent::onStart() {
   
 }
 
+void SceneItemComponent::onDispose() {
+
+}
+
 SceneItemComponent::~SceneItemComponent() {
 
 }

src/dawn/scene/SceneItemComponent.hpp

@@ -58,9 +58,15 @@ namespace Dawn {
        */
       virtual void onStart();
 
+      /**
+       * Intended for subclasses to detect when they need to clean themselves up
+       * but before anything has been completely free'd from memory.
+       */
+      virtual void onDispose();
+
       /**
        * Cleanup the SceneItemComponent.
        */
-      virtual ~SceneItemComponent();
+      ~SceneItemComponent();
   };
 }

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

@@ -25,6 +25,6 @@ void AnimationController::onStart() {
   getScene()->eventSceneUnpausedUpdate.addListener(this, &AnimationController::onSceneUpdate);
 }
 
-AnimationController::~AnimationController() {
+void AnimationController::onDispose() {
   getScene()->eventSceneUnpausedUpdate.removeListener(this, &AnimationController::onSceneUpdate);
 }

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

@@ -18,7 +18,6 @@ namespace Dawn {
       AnimationController(SceneItem *item);
 
       void onStart() override;
-
-      ~AnimationController();
+      void onDispose() override;
   };
 }

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

@@ -58,10 +58,13 @@ void Camera::setRenderTarget(RenderTarget *renderTarget) {
     this, &Camera::onRenderTargetResize
   );
   this->updateProjection();
+  this->eventRenderTargetResized.invoke(
+    renderTarget->getWidth(), renderTarget->getHeight()
+  );
 }
 
 float_t Camera::getAspect() {
-  RenderTarget *target = this->getRenderTarget();
+  auto target = this->getRenderTarget();
   return target->getWidth() / target->getHeight();
 }
 
@@ -71,9 +74,10 @@ void Camera::onStart() {
 
 void Camera::onRenderTargetResize(RenderTarget *target, float_t w, float_t h) {
   this->updateProjection();
+  this->eventRenderTargetResized.invoke(w, h);
 }
 
-Camera::~Camera() {
+void Camera::onDispose() {
   this->getRenderTarget()->eventRenderTargetResized.removeListener(
     this, &Camera::onRenderTargetResize
   );

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

@@ -6,7 +6,7 @@
 #pragma once
 #include "scene/SceneItemComponent.hpp"
 #include "display/RenderTarget.hpp"
-#include "scene/Scene.hpp"
+#include "scene/Scene.hpp "
 
 namespace Dawn {
   enum CameraType {
@@ -21,6 +21,8 @@ namespace Dawn {
       void onRenderTargetResize(RenderTarget *target, float_t w, float_t h);
 
     public:
+      Event<float_t, float_t> eventRenderTargetResized;
+
       static Camera * create(Scene *scene) {
         auto item = scene->createSceneItem();
         auto cam = item->addComponent<Camera>();
@@ -81,10 +83,6 @@ namespace Dawn {
        * Event triggered by the scene item when the item is added to the scene.
        */
       void onStart() override;
-
-      /**
-       * Disposes a previously initialized camera.
-       */
-      ~Camera();
+      void onDispose() override;
   };
 }

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

@@ -18,9 +18,7 @@ std::vector<SceneItemComponent*> PixelPerfectCamera::getDependencies() {
   };
 }
 
-void PixelPerfectCamera::onRenderTargetResized(
-  RenderTarget *t, float_t w, float_t h
-) {
+void PixelPerfectCamera::onRenderTargetResized(float_t w, float_t h) {
   this->updateDimensions();
 }
 
@@ -58,13 +56,13 @@ void PixelPerfectCamera::updateDimensions() {
 void PixelPerfectCamera::onStart() {
   assertNotNull(this->camera);
   this->updateDimensions();
-  camera->getRenderTarget()->eventRenderTargetResized
-    .addListener(this, &PixelPerfectCamera::onRenderTargetResized)
-  ;
+  camera->eventRenderTargetResized.addListener(
+    this, &PixelPerfectCamera::onRenderTargetResized
+  );
 }
 
-PixelPerfectCamera::~PixelPerfectCamera() {
-  camera->getRenderTarget()->eventRenderTargetResized
-    .removeListener(this, &PixelPerfectCamera::onRenderTargetResized)
-  ;
+void PixelPerfectCamera::onDispose() {
+  camera->eventRenderTargetResized.removeListener(
+    this, &PixelPerfectCamera::onRenderTargetResized
+  );
 }

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

@@ -11,7 +11,7 @@ namespace Dawn {
     protected:
       Camera *camera = nullptr;
       /** Event for when the render target is resized. */
-      void onRenderTargetResized(RenderTarget *target, float_t w, float_t h);
+      void onRenderTargetResized(float_t w, float_t h);
 
       /**
        * Updates the underlying camera's projection information.
@@ -30,7 +30,6 @@ namespace Dawn {
       
       std::vector<SceneItemComponent*> getDependencies() override;
       void onStart() override;
-
-      ~PixelPerfectCamera();
+      void onDispose() override;
   };
 }

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

@@ -72,7 +72,7 @@ void SimpleRenderTargetQuad::onStart() {
   }
 }
 
-SimpleRenderTargetQuad::~SimpleRenderTargetQuad() {
+void SimpleRenderTargetQuad::onDispose() {
   if(this->renderTarget != nullptr) {
     this->renderTarget->eventRenderTargetResized.removeListener(
       this, &SimpleRenderTargetQuad::onRenderTargetResized

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

@@ -36,7 +36,6 @@ namespace Dawn {
       
       std::vector<SceneItemComponent*> getDependencies() override;
       void onStart() override;
-      
-      ~SimpleRenderTargetQuad();
+      void onDispose() override;
   };
 }

src/dawn/scene/components/example/ExampleSpin.cpp

@@ -39,6 +39,6 @@ void ExampleSpin::onUnpausedUpdate() {
   this->transform->setLocalRotation(quat);
 }
 
-ExampleSpin::~ExampleSpin() {
+void ExampleSpin::onDispose() {
   getScene()->eventSceneUnpausedUpdate.removeListener(this, &ExampleSpin::onUnpausedUpdate);
 }

src/dawn/scene/components/example/ExampleSpin.hpp

@@ -14,6 +14,6 @@ namespace Dawn {
 
       ExampleSpin(SceneItem *item);
       void onUnpausedUpdate();
-      ~ExampleSpin();
+      void onDispose() override;
   };
 }

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

@@ -17,6 +17,10 @@ void SubSceneCameraAlign::onRenderTargetResize(
   this->realign();
 }
 
+void SubSceneCameraAlign::onCameraResize(float_t w, float_t h) {
+  this->realign();
+}
+
 void SubSceneCameraAlign::realign() {
   float_t diff;
   if(this->camera == nullptr) return;
@@ -68,8 +72,8 @@ void SubSceneCameraAlign::setCamera(Camera *camera) {
   assertTrue(this->camera != camera);
 
   if(this->camera != nullptr) {
-    this->camera->getRenderTarget()->eventRenderTargetResized.removeListener(
-      this, &SubSceneCameraAlign::onRenderTargetResize
+    this->camera->eventRenderTargetResized.removeListener(
+      this, &SubSceneCameraAlign::onCameraResize
     );
   }
 
@@ -77,8 +81,8 @@ void SubSceneCameraAlign::setCamera(Camera *camera) {
   this->realign();
 
   if(this->camera != nullptr) {
-    this->camera->getRenderTarget()->eventRenderTargetResized.addListener(
-      this, &SubSceneCameraAlign::onRenderTargetResize
+    this->camera->eventRenderTargetResized.addListener(
+      this, &SubSceneCameraAlign::onCameraResize
     );
   }
 }
@@ -87,15 +91,15 @@ void SubSceneCameraAlign::onStart() {
   this->realign();
 }
 
-SubSceneCameraAlign::~SubSceneCameraAlign() {
+void SubSceneCameraAlign::onDispose() {
   if(this->renderTarget != nullptr) {
     this->renderTarget->eventRenderTargetResized.removeListener(
       this, &SubSceneCameraAlign::onRenderTargetResize
     );
   }
   if(this->camera != nullptr) {
-    this->camera->getRenderTarget()->eventRenderTargetResized.removeListener(
-      this, &SubSceneCameraAlign::onRenderTargetResize
+    this->camera->eventRenderTargetResized.removeListener(
+      this, &SubSceneCameraAlign::onCameraResize
     );
   }
 }

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

@@ -15,18 +15,37 @@ namespace Dawn {
       Camera *camera = nullptr;
 
       void onRenderTargetResize(RenderTarget *target, float_t w, float_t h);
+      void onCameraResize(float_t w, float_t h);
 
+      /**
+       * Realigns the camera to match the render target quad.
+       */
       void realign();
 
     public:
-
+      /**
+       * Create the sub scene camera align component. This will align a camera
+       * to match a render target quad (Refer SimpleRenderTargetQuad)
+       * 
+       * @param item Scene Item that this component belongs to.
+       */
       SubSceneCameraAlign(SceneItem *item);
 
+      /**
+       * Set the render target for this alignment to use.
+       * 
+       * @param renderTarget Render target to align to.
+       */
       void setRenderTarget(TextureRenderTarget *renderTarget);
+
+      /**
+       * Sets the camera that will be aligned.
+       * 
+       * @param camera Camera to align.
+       */
       void setCamera(Camera *camera);
 
       void onStart() override;
-
-      ~SubSceneCameraAlign();
+      void onDispose() override;
   };
 }

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

@@ -38,7 +38,7 @@ void SubSceneController::onStart() {
   myScene->eventSceneUpdate.addListener(this, &SubSceneController::onSceneUpdate);
 }
 
-SubSceneController::~SubSceneController() {
+void SubSceneController::onDispose() {
   auto myScene = this->getScene();
   myScene->eventSceneUnpausedUpdate.removeListener(this, &SubSceneController::onSceneUnpausedUpdate);
   myScene->eventSceneUpdate.removeListener(this, &SubSceneController::onSceneUpdate);

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

@@ -23,7 +23,6 @@ namespace Dawn {
       void setSubScene(Scene *scene);
 
       void onStart() override;
-
-      ~SubSceneController();
+      void onDispose() override;
   };
 }

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

@@ -18,7 +18,7 @@ UICanvas * UICanvas::create(Scene *scene) {
 UICanvas::UICanvas(SceneItem *item) : SceneItemComponent(item) {
 }
 
-void UICanvas::onRenderTargetResize(RenderTarget *target, float_t w, float_t h){
+void UICanvas::onRenderTargetResize(float_t w, float_t h){
   auto it = this->children.begin();
   while(it != this->children.end()) {
     (*it)->updatePositions();
@@ -30,7 +30,7 @@ void UICanvas::setCamera(Camera *camera) {
   assertTrue(camera != this->camera);
   
   if(this->camera != nullptr) {
-    this->camera->getRenderTarget()->eventRenderTargetResized.removeListener(
+    this->camera->eventRenderTargetResized.removeListener(
       this, &UICanvas::onRenderTargetResize
     );
   }
@@ -38,7 +38,7 @@ void UICanvas::setCamera(Camera *camera) {
   this->camera = camera;
   
   if(this->camera != nullptr) {
-    this->camera->getRenderTarget()->eventRenderTargetResized.addListener(
+    this->camera->eventRenderTargetResized.addListener(
       this, &UICanvas::onRenderTargetResize
     );
   }
@@ -65,16 +65,16 @@ void UICanvas::onStart() {
   }
 }
 
-UICanvas::~UICanvas() {
+void UICanvas::onDispose() {
+  if(this->camera != nullptr) {
+    this->camera->eventRenderTargetResized.removeListener(
+      this, &UICanvas::onRenderTargetResize
+    );
+  }
+  
   auto it = this->children.begin();
   while(it != this->children.end()) {
     delete *it;
     ++it;
   }
-  
-  if(this->camera != nullptr) {
-    this->camera->getRenderTarget()->eventRenderTargetResized.removeListener(
-      this, &UICanvas::onRenderTargetResize
-    );
-  }
 }

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

@@ -21,7 +21,7 @@ namespace Dawn {
     protected:
       Camera *camera = nullptr;
 
-      void onRenderTargetResize(RenderTarget *target, float_t w, float_t h);
+      void onRenderTargetResize(float_t w, float_t h);
 
     public:
       /**
@@ -91,7 +91,6 @@ namespace Dawn {
       float_t getHeight();
 
       void onStart() override;
-
-      ~UICanvas();
+      void onDispose() override;
   };
 }

src/dawn/visualnovel/VisualNovelManager.cpp

@@ -64,15 +64,11 @@ bool_t IVisualNovelEvent::update() {
 IVisualNovelEvent * IVisualNovelEvent::end() {
   this->onEnd();
 
-  std::cout << "End";
-
   if(this->doNext != nullptr) {
-    std::cout << " Nexter" << std::endl;
     auto next = this->doNext;
     this->doNext = nullptr;
     return next;
   }
-  std::cout << " No nxt" << std::endl;
   return nullptr;
 }
 

src/dawn/visualnovel/events/VisualNovelCallbackEvent.hpp

@@ -0,0 +1,38 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "visualnovel/VisualNovelManager.hpp"
+
+namespace Dawn {
+  template<class T>
+  class VisualNovelCallbackEvent : public IVisualNovelEvent {
+    protected:
+      T *instance;
+      void (T::*callback)();
+      
+      void onStart(IVisualNovelEvent *previous) {
+
+      }
+
+      bool_t onUpdate() {
+        return false;
+      }
+
+      void onEnd() {
+        ((*this->instance).*(this->callback))();
+      }
+
+    public:
+      VisualNovelCallbackEvent(
+        VisualNovelManager *manager,
+        T *instance,
+        void (T::*callback)()
+      ) : IVisualNovelEvent(manager) {
+        this->instance = instance;
+        this->callback = callback;
+      }
+  };
+}

src/dawn/visualnovel/scene/SimpleVNScene.cpp

@@ -17,7 +17,7 @@ std::vector<Asset*> SimpleVNScene::getRequiredAssets() {
   auto assMan = &this->game->assetManager;
   std::vector<Asset*> assets;
   vectorAppend(&assets, VisualNovelTextboxPrefab::getRequiredAssets(assMan));
-  return std::vector<Asset*>();
+  return assets;
 }
 
 void SimpleVNScene::stage() {

src/dawn/visualnovel/scene/SimpleVNScene.hpp

@@ -12,6 +12,7 @@
 #include "visualnovel/events/VisualNovelTextboxEvent.hpp"
 #include "visualnovel/events/VisualNovelPauseEvent.hpp"
 #include "visualnovel/events/VisualNovelFadeEvent.hpp"
+#include "visualnovel/events/VisualNovelCAllbackEvent.hpp"
 #include "visualnovel/events/VisualNovelChangeSimpleBackgroundEvent.hpp"
 
 namespace Dawn {