Updated useEvent

src/dawn/scene/Scene.hpp

@@ -8,6 +8,7 @@
 #include "asset/Asset.hpp"
 #include "scene/debug/SceneDebugLine.hpp"
 #include "physics/ScenePhysicsManager.hpp"
+#include "state/State.hpp"
 
 namespace Dawn {
   class DawnGame;
@@ -20,7 +21,7 @@ namespace Dawn {
   template<class T>
   T * _sceneForwardGetComponent(SceneItem *item);
 
-  class Scene {
+  class Scene : public StateOwner {
     private:
       sceneitemid_t nextId;
       std::map<sceneitemid_t, SceneItem*> items;

src/dawn/scene/SceneItemComponent.hpp

@@ -76,7 +76,7 @@ namespace Dawn {
       /**
        * Cleanup the SceneItemComponent.
        */
-      ~SceneItemComponent();
+      virtual ~SceneItemComponent();
   };
 
   

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

@@ -78,7 +78,7 @@ glm::vec3 Camera::getRayDirectionFromScreenSpace(glm::vec2 screenSpace) {
 
 void Camera::onStart() {
   // Render Target
-  useEffect(renderTarget, [&]{
+  useEffect([&]{
     if(renderTarget.previous != nullptr) {
       renderTarget.previous->eventRenderTargetResized.removeListener(
         this, &Camera::onRenderTargetResize
@@ -94,21 +94,30 @@ void Camera::onStart() {
       rt->getWidth(), rt->getHeight()
     );
     this->event2RenderTargetResized.invoke(rt->getWidth(), rt->getHeight());
-  });
+  }, renderTarget);
 
   // All regular properties.
-  auto cbUpdateProj = [&]{
+  useEffect([&]{
     this->projectionNeedsUpdating = true;
-  };
+  }, {
+    &fov,
+    &type,
+    &orthoLeft,
+    &orthoRight,
+    &orthoBottom,
+    &orthoTop,
+    &clipNear,
+    &clipFar
+  });
 
-  useEffect(fov, cbUpdateProj);
+  // useEffect(fov, cbUpdateProj);
-  useEffect(type, cbUpdateProj);
+  // useEffect(type, cbUpdateProj);
-  useEffect(orthoLeft, cbUpdateProj);
+  // useEffect(orthoLeft, cbUpdateProj);
-  useEffect(orthoRight, cbUpdateProj);
+  // useEffect(orthoRight, cbUpdateProj);
-  useEffect(orthoBottom, cbUpdateProj);
+  // useEffect(orthoBottom, cbUpdateProj);
-  useEffect(orthoTop, cbUpdateProj);
+  // useEffect(orthoTop, cbUpdateProj);
-  useEffect(clipNear, cbUpdateProj);
+  // useEffect(clipNear, cbUpdateProj);
-  useEffect(clipFar, cbUpdateProj);
+  // useEffect(clipFar, cbUpdateProj);
 
   getRenderTarget()->eventRenderTargetResized.addListener(this, &Camera::onRenderTargetResize);
 }

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

@@ -55,11 +55,11 @@ void PixelPerfectCamera::onStart() {
   assertNotNull(this->camera);
   this->updateDimensions();
 
-  useEvent(this->camera->event2RenderTargetResized, [&](float_t w, float_t h){
+  useEvent([&](float_t w, float_t h){
     this->updateDimensions();
-  });
+  }, this->camera->event2RenderTargetResized);
 
-  useEffect(scale, [&]{
+  useEffect([&]{
     this->updateDimensions();
-  });
+  }, scale);
 }

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

@@ -42,7 +42,7 @@ void SimpleRenderTargetQuad::onStart() {
   // Create quad mesh
   this->meshHost->mesh.createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
   
-  useEffect(this->renderTarget, [&]{
+  useEffect([&]{
     if(this->renderTarget.previous != nullptr) {
       this->renderTarget.previous->eventRenderTargetResized.addListener(
         this, &SimpleRenderTargetQuad::onRenderTargetResized
@@ -66,7 +66,7 @@ void SimpleRenderTargetQuad::onStart() {
     ((RenderTarget*)this->renderTarget)->eventRenderTargetResized.addListener(
       this, &SimpleRenderTargetQuad::onRenderTargetResized
     );
-  });
+  }, this->renderTarget);
 
   // Perform first resize.
   if(this->renderTarget != nullptr) {

src/dawn/state/State.hpp

@@ -11,24 +11,40 @@ namespace Dawn {
   class StateOwner {
     private:
       std::vector<IStateEvent*> eventsSubscribed;
-
+  
     public:
       /**
-       * Listen for changees to a state property and involke the provided func
+       * Listen for changes to a state property and invoke the provided func
        * when the value is changed.
        * 
-       * @tparam V The type of the state property.
-       * @param property Property to listen for affect changees to.
        * @param fn The callback to be invoked when the state value changes.
+       * @param property Property to listen for affect changees to.
        */
-      template<class V>
       void useEffect(
-        StateProperty<V> &property,
+        const std::function<void()> &fn,
-        const std::function<void()> &fn
+        IStateProperty &property
       ) {
         property._effectListners.push_back(fn);
       }
 
+      /**
+       * Listen for changes to a set of state properties and invoke the provided
+       * func when any of their values are changed.
+       * 
+       * @param fn The callback to be invoked when the state value changes.
+       * @param property Vector list of properties to listen for changes to.
+       */
+      void useEffect(
+        const std::function<void()> &fn,
+        std::vector<IStateProperty*> props
+      ) {
+        auto itProp = props.begin();
+        while(itProp != props.end()) {
+          (*itProp)->_effectListners.push_back(fn);
+          ++itProp;
+        }
+      }
+
       /**
        * Listen for when an event is invoked by a state event. This is intended
        * to allow for cross-state-owner communication in a simple and effective
@@ -36,16 +52,38 @@ namespace Dawn {
        * 
        * @tparam F The type of the callback function.
        * @tparam A The arguments from the state event that are calledback.
-       * @param event The event that is being subscribed to.
        * @param fn The function to be inokved on event trigger.
+       * @param event The event that is being subscribed to.
        */
       template<typename F, typename... A>
-      void useEvent(StateEvent<A...> &event, F fn) {
+      std::function<void()> useEvent(F fn, StateEvent<A...> &event) {
-        event._eventListeners[this].push_back(fn);
+
-        this->eventsSubscribed.push_back(&event); 
+        // Create a listener structure
+        struct StateEventListener<A...> listener;
+        listener.listener = fn;
+        listener.owner = this;
+        listener.event = &event;
+        listener.unsubWithParams = [&](struct StateEventListener<A...> listener) {
+          auto itFound = listener.event->_eventListeners.begin();
+          while(itFound != listener.event->_eventListeners.end()) {
+            if(itFound->id == listener.id) {
+              listener.event->_eventListeners.erase(itFound);
+              break;
+            }
+            ++itFound++;
+          }
+        };
+        listener.id = event.stateEventId++;
+        listener.unsub = std::bind(listener.unsubWithParams, listener);
+
+        // Put that listener structure on to the event stack
+        event._eventListeners.push_back(listener);
+        this->eventsSubscribed.push_back(&event);
+
+        return listener.unsub;
       }
 
-      ~StateOwner() {
+      virtual ~StateOwner() {
         auto it = this->eventsSubscribed.begin();
         while(it != this->eventsSubscribed.end()) {
           (*it)->_stateOwnerDestroyed(this);

src/dawn/state/StateEvent.hpp

@@ -9,8 +9,28 @@
 namespace Dawn {
   class StateOwner;
 
+  template<typename...A>
+  class StateEvent;
+
+  template<typename...A>
+  struct StateEventListener {
+    uint32_t id;
+    StateOwner *owner;
+    std::function<void(A...)> listener;
+    std::function<void(StateEventListener<A...>)> unsubWithParams;
+    std::function<void()> unsub;
+    StateEvent<A...> *event;
+  };
+
   class IStateEvent {
     protected:
+      /**
+       * Received notification from a state owner to let this state event know
+       * that it wishes to unsubscribe all the event listeners that it may have
+       * attached to this event.
+       * 
+       * @param owner State owner that is being disposed.
+       */
       virtual void _stateOwnerDestroyed(StateOwner *owner) = 0;
 
       friend class StateOwner;
@@ -19,12 +39,21 @@ namespace Dawn {
   template<typename...A>
   class StateEvent : public IStateEvent {
     protected:
+      uint32_t stateEventId = 0;
+
       void _stateOwnerDestroyed(StateOwner *owner) override {
-        this->_eventListeners.erase(owner);
+        auto it = this->_eventListeners.begin();
+        while(it != this->_eventListeners.end()) {
+          if(it->owner == owner) {
+            it = this->_eventListeners.erase(it);
+          } else {
+            ++it;
+          }
+        }
       }
 
     public:
-      std::map<StateOwner*, std::vector<std::function<void(A...)>>> _eventListeners;
+      std::vector<StateEventListener<A...>> _eventListeners;
 
       /**
        * Invokes the event and emits to all of the listeners.
@@ -32,15 +61,22 @@ namespace Dawn {
        * @param args Arguments for this event to pass to the listeners.
        */
       void invoke(A... args) {
-        auto itListeners = this->_eventListeners.begin();
+        auto it = this->_eventListeners.begin();
-        while(itListeners != this->_eventListeners.end()) {
+        while(it != this->_eventListeners.end()) {
-          auto itLists = itListeners->second.begin();
+          it->listener(args...);
-          while(itLists != itListeners->second.end()) {
+          ++it;
-            (*itLists)(args...);
-            ++itLists;
-          }
-          ++itListeners;
         }
+        // auto itListeners = this->_eventListeners.begin();
+        // while(itListeners != this->_eventListeners.end()) {
+        //   auto itLists = itListeners->second.begin();
+        //   while(itLists != itListeners->second.end()) {
+        //     (*itLists)(args...);
+        //     ++itLists;
+        //   }
+        //   ++itListeners;
+        // }
       }
+
+      friend class StateOwner;
   };
 }

src/dawn/state/StateProperty.hpp

@@ -7,8 +7,13 @@
 #include "assert/assert.hpp"
 
 namespace Dawn {
+  class IStateProperty {
+    public:
+      std::vector<std::function<void()>> _effectListners;
+  };
+
   template<class V>
-  class StateProperty {
+  class StateProperty : public IStateProperty {
     private:
       /**
        * Method that is invoked every time that the value of this state property
@@ -31,7 +36,6 @@ namespace Dawn {
 
     public:
       V _realValue;
-      std::vector<std::function<void()>> _effectListners;
       V previous;
 
       /**

src/dawntictactoe/components/TicTacToeTile.cpp

@@ -25,7 +25,6 @@ void TicTacToeTile::onStart() {
     }
   };
 
-  useEffect(tileState, cb);
+  useEffect(cb, { &tileState, &hovered });
-  useEffect(hovered, cb);
   cb();
 }

src/dawntictactoe/scenes/TicTacToeScene.hpp

@@ -17,6 +17,8 @@ namespace Dawn {
   class TicTacToeScene : public Scene {
     protected:
       Camera *camera;
+      StateProperty<int32_t> age;
+      StateEvent<int32_t> ageEvent;
 
       void stage() override {
         camera = Camera::create(this);