Updated more scene item coponents to state system

src/dawn/display/RenderPipeline.cpp

@@ -34,7 +34,7 @@ void RenderPipeline::renderScene(Scene *scene) {
   auto subSceneControllers = scene->findComponents<SubSceneController>();
   auto itSubScene = subSceneControllers.begin();
   while(itSubScene != subSceneControllers.end()) {
-    auto subScene = (*itSubScene)->getSubScene();
+    Scene *subScene = (Scene *)((*itSubScene)->subScene);
     if(subScene == nullptr) {
       ++itSubScene;
       continue;

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

@@ -19,24 +19,20 @@ SceneItem * ExampleSpin::create(Scene *scene) {
   CubeMesh::buffer(mr->mesh, glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3(1, 1, 1), 0, 0);
   auto mat = item->addComponent<SimpleTexturedMaterial>();
   item->addComponent<ExampleSpin>();
-
   return item;
 }
 
 ExampleSpin::ExampleSpin(SceneItem *item) :
   SceneItemComponent(item)
 {
-  getScene()->eventSceneUnpausedUpdate.addListener(this, &ExampleSpin::onUnpausedUpdate);
 }
 
-void ExampleSpin::onUnpausedUpdate() {
+void ExampleSpin::onStart() {
-  auto quat = this->transform->getLocalRotation();
+  useEventLegacy([&]{
-  quat = glm::rotate(quat, getGame()->timeManager.delta, glm::vec3(0, 1, 0));
+    auto quat = this->transform->getLocalRotation();
-  quat = glm::rotate(quat, getGame()->timeManager.delta / 2.0f, glm::vec3(1, 0, 0));
+    quat = glm::rotate(quat, getGame()->timeManager.delta, glm::vec3(0, 1, 0));
-  quat = glm::rotate(quat, getGame()->timeManager.delta / 4.0f, glm::vec3(0, 0, 1));
+    quat = glm::rotate(quat, getGame()->timeManager.delta / 2.0f, glm::vec3(1, 0, 0));
-  this->transform->setLocalRotation(quat);
+    quat = glm::rotate(quat, getGame()->timeManager.delta / 4.0f, glm::vec3(0, 0, 1));
-}
+    this->transform->setLocalRotation(quat);
-
+  }, getScene()->eventSceneUnpausedUpdate);
-void ExampleSpin::onDispose() {
-  getScene()->eventSceneUnpausedUpdate.removeListener(this, &ExampleSpin::onUnpausedUpdate);
 }

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

@@ -13,7 +13,6 @@ namespace Dawn {
       static SceneItem * create(Scene *scene);
 
       ExampleSpin(SceneItem *item);
-      void onUnpausedUpdate();
+      void onStart() override;
-      void onDispose() override;
   };
 }

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

@@ -7,18 +7,11 @@
 
 using namespace Dawn;
 
-SubSceneCameraAlign::SubSceneCameraAlign(SceneItem *i) : SceneItemComponent(i) {
+SubSceneCameraAlign::SubSceneCameraAlign(SceneItem *i) :
-
+  SceneItemComponent(i),
-}
+  camera(nullptr),
-
+  renderTarget(nullptr)
-void SubSceneCameraAlign::onRenderTargetResize(
+{
-  RenderTarget *target, float_t w, float_t h
-) {
-  this->realign();
-}
-
-void SubSceneCameraAlign::onCameraResize(float_t w, float_t h) {
-  this->realign();
 }
 
 void SubSceneCameraAlign::realign() {
@@ -27,7 +20,7 @@ void SubSceneCameraAlign::realign() {
   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();
+  float_t myRatio = this->camera->getAspect();
   
   this->camera->type = CAMERA_TYPE_ORTHONOGRAPHIC;
   this->camera->transform->lookAt(glm::vec3(0, 0, 10), glm::vec3(0, 0, 0));
@@ -49,57 +42,27 @@ void SubSceneCameraAlign::realign() {
   }
 }
 
-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->eventRenderTargetResized.removeListener(
-      this, &SubSceneCameraAlign::onCameraResize
-    );
-  }
-
-  this->camera = camera;
-  this->realign();
-
-  if(this->camera != nullptr) {
-    this->camera->eventRenderTargetResized.addListener(
-      this, &SubSceneCameraAlign::onCameraResize
-    );
-  }
-}
-
 void SubSceneCameraAlign::onStart() {
-  this->realign();
+  auto cameraEffect = useEffectWithTeardown([&]{
-}
+    if(camera == nullptr) return evtCameraResized = [&] {};
 
-void SubSceneCameraAlign::onDispose() {
+    this->realign();
-  if(this->renderTarget != nullptr) {
+
-    this->renderTarget->eventRenderTargetResized.removeListener(
+    return evtCameraResized = useEvent([&](float_t w, float_t h){
-      this, &SubSceneCameraAlign::onRenderTargetResize
+      this->realign();
-    );
+    }, this->camera->event2RenderTargetResized);
-  }
+  }, this->camera);
-  if(this->camera != nullptr) {
+
-    this->camera->eventRenderTargetResized.removeListener(
+  auto renderEffect = useEffectWithTeardown([&]{
-      this, &SubSceneCameraAlign::onCameraResize
+    if(renderTarget == nullptr) return evtRenderResized = [&]{};
-    );
+
-  }
+    this->realign();
+
+    return evtRenderResized = useEventLegacy([&](RenderTarget *t, float_t w, float_t h) {
+      this->realign();
+    }, renderTarget->eventRenderTargetResized);
+  }, this->renderTarget);
+
+  cameraEffect();
+  renderEffect();
 }

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

@@ -11,11 +11,8 @@
 namespace Dawn {
   class SubSceneCameraAlign : public SceneItemComponent {
     protected:
-      TextureRenderTarget *renderTarget = nullptr;
+      std::function<void()> evtCameraResized;
-      Camera *camera = nullptr;
+      std::function<void()> evtRenderResized;
-
-      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.
@@ -23,6 +20,9 @@ namespace Dawn {
       void realign();
 
     public:
+      StateProperty<Camera*> camera;
+      StateProperty<TextureRenderTarget*> renderTarget;
+
       /**
        * Create the sub scene camera align component. This will align a camera
        * to match a render target quad (Refer SimpleRenderTargetQuad)
@@ -31,21 +31,6 @@ namespace Dawn {
        */
       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;
-      void onDispose() override;
   };
 }

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

@@ -11,35 +11,18 @@ 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);
-}
 
-void SubSceneController::onDispose() {
+  useEventLegacy([&]{
-  auto myScene = this->getScene();
+    if(!this->onlyUpdateUnpaused) return;
-  myScene->eventSceneUnpausedUpdate.removeListener(this, &SubSceneController::onSceneUnpausedUpdate);
+    if(this->subScene == nullptr) return;
-  myScene->eventSceneUpdate.removeListener(this, &SubSceneController::onSceneUpdate);
+    this->subScene->update();
+  }, myScene->eventSceneUnpausedUpdate);
+
+  useEventLegacy([&]{
+    if(this->onlyUpdateUnpaused) return;
+    if(this->subScene == nullptr) return;
+    this->subScene->update();
+  }, myScene->eventSceneUpdate);
 }

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

@@ -8,21 +8,12 @@
 
 namespace Dawn {
   class SubSceneController : public SceneItemComponent {
-    protected:
-      Scene *subScene = nullptr;
-
-      void onSceneUpdate();
-      void onSceneUnpausedUpdate();
-
     public:
+      Scene *subScene = nullptr;
       bool_t onlyUpdateUnpaused = false;
 
       SubSceneController(SceneItem *item);
 
-      Scene * getSubScene();
-      void setSubScene(Scene *scene);
-
       void onStart() override;
-      void onDispose() override;
   };
 }

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

@@ -15,39 +15,11 @@ UICanvas * UICanvas::create(Scene *scene) {
   return item->addComponent<UICanvas>();
 }
 
-UICanvas::UICanvas(SceneItem *item) : SceneItemComponent(item) {
+UICanvas::UICanvas(SceneItem *item) :
-}
+  SceneItemComponent(item),
-
+  camera(nullptr),
-void UICanvas::onRenderTargetResize(float_t w, float_t h){
+  currentMenu(nullptr)
-  auto it = this->children.begin();
+{
-  while(it != this->children.end()) {
-    (*it)->updatePositions();
-    ++it;
-  }
-}
-
-void UICanvas::onSceneUpdate() {
-  if(this->currentMenu != nullptr) {
-    this->currentMenu->onTick();
-  }
-}
-
-void UICanvas::setCamera(Camera *camera) {
-  assertTrue(camera != this->camera);
-  
-  if(this->camera != nullptr) {
-    this->camera->eventRenderTargetResized.removeListener(
-      this, &UICanvas::onRenderTargetResize
-    );
-  }
-
-  this->camera = camera;
-  
-  if(this->camera != nullptr) {
-    this->camera->eventRenderTargetResized.addListener(
-      this, &UICanvas::onRenderTargetResize
-    );
-  }
 }
 
 float_t UICanvas::getWidth() {
@@ -64,34 +36,47 @@ float_t UICanvas::getHeight() {
   return this->camera->getRenderTarget()->getHeight();
 }
 
-struct UIMenu * UICanvas::getCurrentMenu() {
-  return this->currentMenu;
-}
-
 void UICanvas::setCurrentMenu(struct UIMenu *menu) {
-  if(this->currentMenu != nullptr) this->currentMenu->onInactive();
-  this->currentMenu = menu;
-  if(menu != nullptr) menu->onActive();
 }
 
 void UICanvas::onStart() {
-  if(this->camera == nullptr) {
+  useEffectWithTeardown([&]{
-    auto camera = this->getScene()->findComponent<Camera>();
+    if(this->camera == nullptr) return evtCamResize = [&]{};
-    this->setCamera(camera);
-  }
     
-  this->getScene()->eventSceneUpdate.addListener(this, &UICanvas::onSceneUpdate);
+    auto it = this->children.begin();
+    while(it != this->children.end()) {
+      (*it)->updatePositions();
+      ++it;
+    }
+
+    return evtCamResize = useEvent([&](float_t w, float_t h){
+      auto it = this->children.begin();
+      while(it != this->children.end()) {
+        (*it)->updatePositions();
+        ++it;
+      }
+    }, camera->event2RenderTargetResized);
+  }, camera);
+
+  useEffectWithTeardown([&]{
+    if(currentMenu != nullptr) currentMenu->onActive();
+    
+    return [&] {
+      if(currentMenu == nullptr) currentMenu->onInactive();
+    };
+  }, this->currentMenu);
+
+  // Scene Update
+  useEventLegacy([&]{
+    if(this->currentMenu == nullptr) return;
+    this->currentMenu->onTick();
+  }, getScene()->eventSceneUpdate);
+
+  // Find Camera if we need to.
+  if(camera == nullptr) camera = this->getScene()->findComponent<Camera>();
 }
 
 void UICanvas::onDispose() {
-  if(this->camera != nullptr) {
-    this->camera->eventRenderTargetResized.removeListener(
-      this, &UICanvas::onRenderTargetResize
-    );
-  }
-
-  this->getScene()->eventSceneUpdate.removeListener(this, &UICanvas::onSceneUpdate);
-  
   auto it = this->children.begin();
   while(it != this->children.end()) {
     delete *it;

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

@@ -20,13 +20,14 @@ namespace Dawn {
 
   class UICanvas : public SceneItemComponent {
     protected:
-      Camera *camera = nullptr;
+      std::function<void()> evtCamResize;
-      struct UIMenu *currentMenu = nullptr;
 
       void onRenderTargetResize(float_t w, float_t h);
-      void onSceneUpdate();
 
     public:
+      StateProperty<struct UIMenu*> currentMenu;
+      StateProperty<Camera*> camera;
+
       /**
        * Creates a UI Canvas Scene Item Element, and attaches it to the provided
        * scene.
@@ -47,13 +48,6 @@ 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.
        * 

src/dawn/state/StateProperty.hpp

@@ -18,8 +18,6 @@ namespace Dawn {
        */
       void setInternal(V val) {
         if(val == this->_realValue) return;// TODO: can I omit this? kinda bad tbh.
-        this->previous = this->_realValue;
-        this->_realValue = val;
 
         // Run the teardowns
         auto itTeardown = this->_effectTeardowns.begin();
@@ -29,6 +27,10 @@ namespace Dawn {
         }
         this->_effectTeardowns.clear();
 
+        // Update the values
+        this->previous = this->_realValue;
+        this->_realValue = val;
+
         // Notify the effect listeners
         auto itEffect = this->_effectListners.begin();
         while(itEffect != this->_effectListners.end()) {

src/dawn/ui/UIMenu.cpp

@@ -120,8 +120,6 @@ void UIMenu::onTick() {
 }
 
 UIMenu::~UIMenu() {
-  if(this->canvas->getCurrentMenu() == this) {
+  if(this->canvas->currentMenu == this) this->canvas->currentMenu = nullptr;
-    this->canvas->setCurrentMenu(nullptr);
-  }
   memoryFree(this->items);
 }