Sunset old state system finally.

src/dawn/asset/Asset.hpp

@@ -13,8 +13,7 @@ namespace Dawn {
     public:
       const std::string name;
       bool_t loaded = false;
-      Event<> eventLoaded;
-      StateEvent<> event2Loaded;
+      StateEvent<> eventLoaded;
 
       /**
        * Create an abstract Asset object.

src/dawn/asset/AssetManager.cpp

@@ -15,7 +15,7 @@ void AssetManager::update() {
   this->syncTick();
 }
 
-void AssetManager::queueLoad(std::vector<Asset*> assets) {
+void AssetManager::queueLoad(const std::vector<Asset*> assets) {
   std::merge(
     this->assetsToLoad.begin(), this->assetsToLoad.end(),
     assets.begin(), assets.end(),
@@ -27,7 +27,7 @@ void AssetManager::queueLoad(Asset *asset) {
   this->assetsToLoad.push_back(asset);
 }
 
-void AssetManager::queueUnload(std::vector<Asset*> assets) {
+void AssetManager::queueUnload(const std::vector<Asset*> assets) {
   std::cout <<
     "Asset list was queued to unload, but is not yet implemented" <<
   std::endl;
@@ -46,60 +46,45 @@ void AssetManager::queueUnload(Asset *asset) {
 }
 
 void AssetManager::queueSwap(
-  std::vector<Asset*> newAssets,
-  std::vector<Asset*> oldAssets
+  const std::vector<Asset*> newAssets,
+  const std::vector<Asset*> oldAssets
 ) {
   std::vector<Asset*> unload;
   std::vector<Asset*> load;
 
   // Determine assets to unload.
-  auto itUnload = oldAssets.begin();
-  while(itUnload != oldAssets.end()) {
-    auto inNewAssets = std::find(newAssets.begin(), newAssets.end(), *itUnload);
-    if(inNewAssets == newAssets.end()) unload.push_back(*itUnload);
-    ++itUnload;
-  }
+  std::for_each(oldAssets.begin(), oldAssets.end(), [&](Asset *asset){
+    auto it = std::find(newAssets.begin(), newAssets.end(), asset);
+    if(it == newAssets.end()) unload.push_back(asset);
+  });
 
   // Determine assets to load
-  auto itLoad = newAssets.begin();
-  while(itLoad != newAssets.end()) {
-    auto inOldAssets = std::find(oldAssets.begin(), oldAssets.end(), *itLoad);
-    if(inOldAssets == oldAssets.end()) load.push_back(*itLoad);
-    ++itLoad;
-  }
+  std::for_each(newAssets.begin(), newAssets.end(), [&](Asset *asset){
+    auto it = std::find(oldAssets.begin(), oldAssets.end(), asset);
+    if(it == oldAssets.end()) load.push_back(asset);
+  });
 
   this->queueUnload(unload);
   this->queueLoad(load);
 }
 
 void AssetManager::syncTick() {
-  auto it = this->assetsToLoad.begin();
-  while(it != this->assetsToLoad.end()) {
-    auto asset = *it;
+  std::erase_if(assetsToLoad, [&](auto &asset){
     if(asset->loaded) {
-      it = this->assetsToLoad.erase(it);
       asset->eventLoaded.invoke();
-      asset->event2Loaded.invoke();
-      continue;
+      return true;
     }
 
     asset->updateSync();
     asset->updateAsync();//TODO: Make Async
 
     if(asset->loaded) {
-      it = this->assetsToLoad.erase(it);
       asset->eventLoaded.invoke();
-      asset->event2Loaded.invoke();
-      continue;
+      return true;
     }
 
-    ++it;
-  }
-  // auto it = this->assetsNotLoaded.begin();
-  // auto it2 = this->assetsToUnload.begin();
-  // while(it2 != this->assetsToUnload.end()) {
-  //   ++it2;
-  // }
+    return asset->loaded;
+  });
 }
 
 void AssetManager::syncLoad() {
@@ -109,9 +94,7 @@ void AssetManager::syncLoad() {
 }
 
 AssetManager::~AssetManager() {
-  auto it = this->assets.begin();
-  while(it != this->assets.end()) {
-    delete it->second;
-    ++it;
-  }
+  std::for_each(this->assets.begin(), this->assets.end(), [&](auto &item){
+    delete item.second;
+  });
 }

src/dawn/asset/AssetManager.hpp

@@ -30,7 +30,13 @@ namespace Dawn {
        * 
        * @param assets Assets to load.
        */
-      void queueLoad(std::vector<Asset*> assets);
+      void queueLoad(const std::vector<Asset*> assets);
+
+      /**
+       * Queue a loading of a single asset. Does not actually begin loading.
+       * 
+       * @param assets Assets to load.
+       */
       void queueLoad(Asset *assets);
 
       /**
@@ -38,7 +44,13 @@ namespace Dawn {
        * 
        * @param assets Assets to unload.
        */
-      void queueUnload(std::vector<Asset*> assets);
+      void queueUnload(const std::vector<Asset*> assets);
+
+      /**
+       * Takes a single asset to queue to unload. Does not immediately unload.
+       * 
+       * @param assets Assets to unload.
+       */
       void queueUnload(Asset* assets);
 
       /**
@@ -49,8 +61,8 @@ namespace Dawn {
        * @param oldAssets Old list of assets to no longer maintain.
        */
       void queueSwap(
-        std::vector<Asset*> newAssets,
-        std::vector<Asset*> oldAssets
+        const std::vector<Asset*> newAssets,
+        const std::vector<Asset*> oldAssets
       );
 
       /**

src/dawn/asset/IAssetLoader.cpp

@@ -7,15 +7,14 @@
 
 using namespace Dawn;
 
-IAssetLoader::IAssetLoader(std::string fileName) {
+IAssetLoader::IAssetLoader(const std::string fileName) : fileName(fileName) {
   assertTrue(
     fileName.size() > 0,
     "IAssetLoader::IAssetLoader: fileName must be greater than 0"
   );
-  this->fileName = fileName;
 }
 
-size_t IAssetLoader::setPosition(size_t position) {
+size_t IAssetLoader::setPosition(const size_t position) {
   assertTrue(
     position >= 0,
     "IAssetLoader::setPosition: position must be greater than or equal to 0"

src/dawn/asset/IAssetLoader.hpp

@@ -24,7 +24,7 @@ namespace Dawn {
        * 
        * @param fileName File name of the asset that is to be loaded.
        */
-      IAssetLoader(std::string fileName);
+      IAssetLoader(const std::string fileName);
 
       /**
        * Platform-centric method to open a file buffer to an asset.
@@ -43,7 +43,7 @@ namespace Dawn {
        * @param size Length of the data buffer (How many bytes to read).
        * @return The count of bytes read.
        */
-      virtual size_t read(uint8_t *buffer, size_t size) = 0;
+      virtual size_t read(uint8_t *buffer, const size_t size) = 0;
 
       /**
        * Get the size of the asset.
@@ -57,7 +57,7 @@ namespace Dawn {
        * @param n Count of bytes to progress the read head by.
        * @return Count of bytes progressed.
        */
-      virtual size_t skip(size_t n) = 0;
+      virtual size_t skip(const size_t n) = 0;
 
       /**
        * Rewind the read head to the beginning of the file.
@@ -70,7 +70,7 @@ namespace Dawn {
        * 
        * @param absolutePosition Absolute position to set the read head to.
        */
-      size_t setPosition(size_t absolutePosition);
+      size_t setPosition(const size_t absolutePosition);
 
       /**
        * Returns the current position of the read head.
@@ -89,13 +89,14 @@ namespace Dawn {
        * @return The count of bytes read.
        */
       template<class T>
-      size_t loadBufferedCallback(T *instance, bool_t (T::*callback)(uint8_t n)) {
+      size_t loadBufferedCallback(
+        std::function<bool_t(uint8_t n)> callback
+      ) {
         uint8_t buffer[1024];
         size_t read, length;
         int32_t i;
         bool_t result;
 
-        assertNotNull(instance, "Instance cannot be null.");
         assertNotNull(callback, "Callback cannot be null.");
 
         // Open the buffer.
@@ -107,7 +108,7 @@ namespace Dawn {
         // Buffer from input
         while((read = this->read(buffer, 1024)) != 0) {
           for(i = 0; i < read; i++) {
-            result = ((*instance).*(callback))(buffer[i]);
+            result = callback(buffer[i]);
             if(!result) {
               length += i;
               break;

src/dawn/asset/assets/LanguageAsset.cpp

@@ -64,7 +64,7 @@ void LanguageAsset::updateAsync() {
   this->loaded = true;
 }
 
-std::string LanguageAsset::getValue(std::string key) {
+std::string LanguageAsset::getValue(const std::string key) {
   assertTrue(
     this->state == LANGUAGE_ASSET_LOAD_STATE_READY_TO_READ,
     "State must be LANGUAGE_ASSET_LOAD_STATE_READY_TO_READ"

src/dawn/asset/assets/LanguageAsset.hpp

@@ -31,6 +31,6 @@ namespace Dawn {
       LanguageAsset(const std::string name);
       void updateSync() override;
       void updateAsync() override;
-      std::string getValue(std::string key);
+      std::string getValue(const std::string key);
   };
 }

src/dawn/asset/assets/TrueTypeAsset.cpp

@@ -142,13 +142,15 @@ void TrueTypeAsset::updateAsync() {
 
   // Now we are at the first byte of the first style.
   this->state = TRUE_TYPE_ASSET_STATE_ADJUSTING_OFFSETS;
-  auto itStyle = assetStyles.begin();
-  while(itStyle != assetStyles.end()) {
-    (*itStyle).dataOffset = styleListBegin;
-    styleListBegin += (*itStyle).dataSize;
-    styleListBegin += 1; // Vertical bar
-    ++itStyle;
-  }
+  std::for_each(
+    assetStyles.begin(),
+    assetStyles.end(),
+    [&](struct TrueTypeAssetStyle &style){
+      style.dataOffset = styleListBegin;
+      styleListBegin += style.dataSize;
+      styleListBegin += 1;
+    }
+  );
 
   // Init FreeType
   this->state = TRUE_TYPE_ASSET_STATE_INIT_FREETYPE;
@@ -160,7 +162,7 @@ void TrueTypeAsset::updateAsync() {
   this->loaded = true;
 }
 
-usagelockid_t TrueTypeAsset::lock(struct TrueTypeFaceTextureStyle style) {
+usagelockid_t TrueTypeAsset::lock(const struct TrueTypeFaceTextureStyle style) {
   assertTrue(this->state == TRUE_TYPE_ASSET_STATE_READY, "Asset is not ready");
 
   // Try and find an existing texture that matches this style
@@ -214,22 +216,24 @@ usagelockid_t TrueTypeAsset::lock(struct TrueTypeFaceTextureStyle style) {
   return lock;
 }
 
-TrueTypeFaceTexture * TrueTypeAsset::getTexture(usagelockid_t id) {
+TrueTypeFaceTexture * TrueTypeAsset::getTexture(const usagelockid_t id) {
   auto it = this->textureByLock.find(id);
   assertTrue(it != this->textureByLock.end(), "Could not find texture");
   return it->second;
 }
 
-void TrueTypeAsset::unlock(usagelockid_t id) {
+void TrueTypeAsset::unlock(const usagelockid_t id) {
   this->locks.removeLock(id);
 }
 
 TrueTypeAsset::~TrueTypeAsset() {
-  auto it = this->textures.begin();
-  while(it != this->textures.end()) {
-    delete (*it);
-    it++;
-  }
+  std::for_each(
+    this->textures.begin(),
+    this->textures.end(),
+    [](TrueTypeFaceTexture *texture){
+      delete texture;
+    }
+  );
 
   FT_Done_FreeType(this->fontLibrary);
 }

src/dawn/asset/assets/TrueTypeAsset.hpp

@@ -55,7 +55,7 @@ namespace Dawn {
        * @param style Style to lock.
        * @return A unique lock ID for this style.
        */
-      usagelockid_t lock(struct TrueTypeFaceTextureStyle style);
+      usagelockid_t lock(const struct TrueTypeFaceTextureStyle style);
 
       /**
        * Get a texture by a previous lock ID.
@@ -63,14 +63,14 @@ namespace Dawn {
        * @param lock Lock to get the texture of.
        * @return Matching texture by this ID.
        */
-      TrueTypeFaceTexture * getTexture(usagelockid_t lock);
+      TrueTypeFaceTexture * getTexture(const usagelockid_t lock);
 
       /**
        * Releases a previously held font lock.
        * 
        * @param lock Lock to release/unlock.
        */
-      void unlock(usagelockid_t lock);
+      void unlock(const usagelockid_t lock);
 
       ~TrueTypeAsset();
   };

src/dawn/audio/IAudioManager.cpp

@@ -7,7 +7,8 @@
 
 using namespace Dawn;
 
-IAudioManager::IAudioManager(DawnGame *game) {
-  assertNotNull(game, "Game cannot be null.");
-  this->game = game;
+IAudioManager::IAudioManager() {
+}
+
+IAudioManager::~IAudioManager() {
 }

src/dawn/audio/IAudioManager.hpp

@@ -10,16 +10,11 @@ namespace Dawn {
   class DawnGame;
 
   class IAudioManager {
-    protected:
-      DawnGame *game;
-
     public:
       /**
        * Construct a new IAudioManager.
-       * 
-       * @param game The game instance.
        */
-      IAudioManager(DawnGame *game);
+      IAudioManager();
       
       /**
        * Initializes the audio manager system.
@@ -30,5 +25,10 @@ namespace Dawn {
        * Ticks/Update the audio manager system.
        */
       virtual void update() = 0;
+
+      /**
+       * Deinitializes the audio manager system.
+       */
+      virtual ~IAudioManager();
   };
 }

src/dawn/display/RenderTarget.hpp

@@ -6,7 +6,7 @@
 #pragma once
 #include "util/flag.hpp"
 #include "display/Color.hpp"
-#include "event/Event.hpp"
+#include "state/StateEvent.hpp"
 
 #define RENDER_TARGET_CLEAR_FLAG_COLOR FLAG_DEFINE(0)
 #define RENDER_TARGET_CLEAR_FLAG_DEPTH FLAG_DEFINE(1)
@@ -14,7 +14,7 @@
 namespace Dawn {
   class RenderTarget {
     public:
-      Event<RenderTarget*, float_t, float_t> eventRenderTargetResized;
+      StateEvent<RenderTarget*, float_t, float_t> eventRenderTargetResized;
 
       /**
        * Return the width of the render target.

src/dawn/display/Transform.hpp

@@ -7,7 +7,6 @@
 #include "dawnlibs.hpp"
 #include "assert/assert.hpp"
 #include "util/flag.hpp"
-#include "event/Event.hpp"
 #include "state/StateEvent.hpp"
 
 namespace Dawn {

src/dawn/display/animation/Animation.hpp

@@ -5,8 +5,6 @@
 
 #pragma once
 #include "state/StateEvent.hpp"
-#include "Easing.hpp"
-#include "util/mathutils.hpp"
 
 namespace Dawn {
   struct Animation {
@@ -15,8 +13,7 @@ namespace Dawn {
       bool_t finished = false;
       float_t time = 0;
       float_t duration = 0;
-      Event<> eventAnimationEnd;
-      StateEvent<> event2AnimationEnd;
+      StateEvent<> eventAnimationEnd;
       
       /**
        * Ticks the animation along. Delta is whatever you want to update the
@@ -26,7 +23,7 @@ namespace Dawn {
        * 
        * @param delta Time delta (in seconds) to tick the animaiton by.
        */
-      virtual void tick(float_t delta) = 0;
+      virtual void tick(const float_t delta) = 0;
       
       /**
        * Restart a running animation.

src/dawn/display/animation/CMakeLists.txt

@@ -8,4 +8,5 @@ target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     Animation.cpp
     TiledSpriteAnimation.cpp
+    easing.cpp
 )

src/dawn/display/animation/Easing.hpp

@@ -1,78 +0,0 @@
-/**
- * Copyright (c) 2021 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-#pragma once
-#include "dawnlibs.hpp"
-
-
-typedef float_t easefunction_t(float_t t);
-
-/**
- * Returns the ease time for a given real time duration span.
- * @param start At what point in time the animation started
- * @param current The current point in time the animation is at.
- * @param duration The total duration on the animation.
- * @returns The easing time (0-1 time) that the animation is at.
- */
-static inline float_t easeTimeToEase(
-  float_t start,
-  float_t current,
-  float_t duration
-) {
-  return (current - start) / duration;
-}
-
-static inline float_t easeLinear(float_t t) {
-  return t;
-}
-
-static inline float_t easeInQuad(float_t t) {
-  return t * t;
-}
-
-static inline float_t easeOutQuad(float_t t) {
-  return t * (2 - t);
-}
-
-static inline float_t easeOutCubic(float_t t) {
-  return 1 - powf(1 - t, 3);
-}
-
-static inline float_t easeInOutQuad(float_t t) {
-  return t < .5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
-}
-
-static inline float_t easeInCubic(float_t t) {
-  return t * t * t;
-}
-
-static inline float_t easeInOutCubic(float_t t) {
-  return t < .5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-}
-
-static inline float_t easeInQuart(float_t t) {
-  return t * t * t * t;
-}
-
-static inline float_t easeOutQuart(float_t t) {
-  return 1 - (t-1)*(t-1)*(t-1)*(t-1);
-}
-
-static inline float_t easeInOutQuart(float_t t) {
-  return t < .5 ? 8*t*t*t*t : 1-8*(t-1)*(t-1)*(t-1)*(t-1);
-}
-
-static inline float_t easeInQuint(float_t t) {
-  return t*t*t*t*t;
-}
-
-static inline float_t easeOutQuint(float_t t) {
-  return 1 + (t-1)*(t-1)*(t-1)*(t-1)*(t-1);
-}
-
-static inline float_t easeInOutQuint(float_t t) {
-  return t<.5 ? 16*t*t*t*t*t : 1+16*(t-1)*(t-1)*(t-1)*(t-1)*(t-1);
-}

src/dawn/display/animation/SimpleAnimation.hpp

@@ -5,6 +5,8 @@
 
 #pragma once
 #include "Animation.hpp"
+#include "easing.hpp"
+#include "util/mathutils.hpp"
 
 namespace Dawn {
   template<typename T>
@@ -195,7 +197,6 @@ namespace Dawn {
         // Animation end.
         this->finished = true;
         this->eventAnimationEnd.invoke();
-        this->event2AnimationEnd.invoke();
       }
       
       void clear() override {

src/dawn/display/animation/TiledSpriteAnimation.cpp

@@ -13,7 +13,7 @@ TiledSpriteAnimation::TiledSpriteAnimation(TiledSprite *sprite) :
 {
 }
 
-void TiledSpriteAnimation::tick(float_t delta) {
+void TiledSpriteAnimation::tick(const float_t delta) {
   SimpleAnimation::tick(delta);
   this->sprite->tile = frame;
 }

src/dawn/display/animation/TiledSpriteAnimation.hpp

@@ -20,6 +20,6 @@ namespace Dawn {
        */
       TiledSpriteAnimation(TiledSprite *sprite);
 
-      void tick(float_t delta) override;
+      void tick(const float_t delta) override;
   };
 }

src/dawn/display/animation/easing.cpp

@@ -0,0 +1,66 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "easing.hpp"
+
+float_t easeTimeToEase(
+  const float_t start,
+  const float_t current,
+  const float_t duration
+) {
+  return (current - start) / duration;
+}
+
+float_t easeLinear(const float_t t) {
+  return t;
+}
+
+float_t easeInQuad(const float_t t) {
+  return t * t;
+}
+
+float_t easeOutQuad(const float_t t) {
+  return t * (2 - t);
+}
+
+float_t easeOutCubic(const float_t t) {
+  return 1 - powf(1 - t, 3);
+}
+
+float_t easeInOutQuad(const float_t t) {
+  return t < .5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+
+float_t easeInCubic(const float_t t) {
+  return t * t * t;
+}
+
+float_t easeInOutCubic(const float_t t) {
+  return t < .5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+}
+
+float_t easeInQuart(const float_t t) {
+  return t * t * t * t;
+}
+
+float_t easeOutQuart(const float_t t) {
+  return 1 - (t-1)*(t-1)*(t-1)*(t-1);
+}
+
+float_t easeInOutQuart(const float_t t) {
+  return t < .5 ? 8*t*t*t*t : 1-8*(t-1)*(t-1)*(t-1)*(t-1);
+}
+
+float_t easeInQuint(const float_t t) {
+  return t*t*t*t*t;
+}
+
+float_t easeOutQuint(const float_t t) {
+  return 1 + (t-1)*(t-1)*(t-1)*(t-1)*(t-1);
+}
+
+float_t easeInOutQuint(const float_t t) {
+  return t<.5 ? 16*t*t*t*t*t : 1+16*(t-1)*(t-1)*(t-1)*(t-1)*(t-1);
+}

src/dawn/display/animation/easing.hpp

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2021 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+#pragma once
+#include "dawnlibs.hpp"
+
+typedef float_t easefunction_t(const float_t t);
+
+/**
+ * Returns the ease time for a given real time duration span.
+ * @param start At what point in time the animation started
+ * @param current The current point in time the animation is at.
+ * @param duration The total duration on the animation.
+ * @returns The easing time (0-1 time) that the animation is at.
+ */
+float_t easeTimeToEase(
+  const float_t start,
+  const float_t current,
+  const float_t duration
+);
+
+float_t easeLinear(const float_t t);
+float_t easeInQuad(const float_t t);
+float_t easeOutQuad(const float_t t);
+float_t easeOutCubic(const float_t t);
+float_t easeInOutQuad(const float_t t);
+float_t easeInCubic(const float_t t);
+float_t easeInOutCubic(const float_t t);
+float_t easeInQuart(const float_t t);
+float_t easeOutQuart(const float_t t);
+float_t easeInOutQuart(const float_t t);
+float_t easeInQuint(const float_t t);
+float_t easeOutQuint(const float_t t);
+float_t easeInOutQuint(const float_t t);

src/dawn/event/Event.hpp

@@ -1,129 +0,0 @@
-// Copyright (c) 2022 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "dawnlibs.hpp"
-#include "assert/assert.hpp"
-
-namespace Dawn {
-  template<typename... A>
-  struct IEventListener {
-    /**
-     * Abstracted method for C++ template reasons. Invokes the listener.
-     * 
-     * @deprecated
-     * @param args Arguments to pass to the listener.
-     */
-    virtual void invoke(A... args) = 0;
-  };
-
-  template <class T, typename... A>
-  struct EventListener : public IEventListener<A...> {
-    T *instance;
-    void (T::*callback)(A... args);
-
-    /**
-     * Construct a new event listener structure.
-     * 
-    * @deprecated
-     * @param instance Instance that the callback belongs to.
-     * @param callback Callback method that invokes back.
-     */
-    EventListener(T *instance, void (T::*callback)(A... args)) {
-      assertNotNull(instance, "EventListener::EventListener: Instance cannot be null");
-
-      this->instance = instance;
-      this->callback = callback;
-    }
-
-    void invoke(A... args) {
-      ((*this->instance).*(this->callback))(args...);
-    }
-  };
-
-  /** @deprecated */
-  template<typename...A>
-  class Event {
-    private:  
-      std::vector<IEventListener<A...>*> listeners;
-
-    public:
-      /**
-       * Add a listener to this event.
-       * 
-       * @deprecated
-       * @tparam T The class that will receive the event.
-       * @param instance Instance of type T that will receive the callback.
-       * @param callback Callback method attached to T to receive the event.
-       * @return The initialized event listener. You don't really need this.
-       */
-      template<class T>
-      EventListener<T, A...> * addListener(
-        T *instance,
-        void (T::*callback)(A... args)
-      ) {
-        assertNotNull(instance, "Event::addListener: Instance cannot be null");
-
-        auto listener = new EventListener<T,A...>(instance, callback);
-        assertNotNull(listener, "Event::addListener: Listener could not be created (Memory filled?)");
-        this->listeners.push_back(listener);
-        return listener;
-      }
-
-      /**
-       * Removes an event listener from this event.
-       * 
-       * @deprecated
-       * @tparam T The class that was once receiving the event.
-       * @param instance Instance of type T that did receive the callback.
-       * @param callback Callback method attached to T for the event.
-       */
-      template<class T>
-      void removeListener(
-        T *instance,
-        void (T::*callback)(A... args)
-      ) {
-        auto it = this->listeners.begin();
-        while(it != this->listeners.end()) {
-          auto listener = static_cast<EventListener<T,A...>*>(*it);
-
-          if(listener->instance != instance || listener->callback != callback) {
-            ++it;
-            continue;
-          }
-
-          this->listeners.erase(it);
-          delete listener;
-          break;
-        }
-      }
-
-      /**
-       * Invokes the event and emits to all of the listeners.
-       * 
-       * @deprecated
-       * @param args Arguments for this event to pass to the listeners.
-       */
-      void invoke(A... args) {
-        auto it = this->listeners.begin();
-        while(it != this->listeners.end()) {
-          (*it)->invoke(args...);
-          ++it;
-        }
-      }
-
-      /**
-       * Disposes the event instance. Will also destroy all of the event 
-       * listeners.
-       */
-      ~Event() {
-        auto it = this->listeners.begin();
-        while(it != this->listeners.end()) {
-          delete *it;
-          ++it;
-        }
-      }
-  };
-}

src/dawn/locale/LocaleManager.cpp

@@ -21,7 +21,9 @@ void LocaleManager::init() {
     if(this->loadingAsset->loaded) {
       this->onLanguageLoaded();
     } else {
-      this->loadingAsset->eventLoaded.addListener(this, &LocaleManager::onLanguageLoaded);
+      eventTeardownLanguageLoaded = useEvent([&]() {
+        this->onLanguageLoaded();
+      }, this->loadingAsset->eventLoaded);
     }
   }
 }
@@ -38,7 +40,7 @@ void LocaleManager::setLocale(struct Locale locale) {
 
     // Are we already loading something? Stop it.
     if(this->loadingAsset != nullptr) {
-      this->loadingAsset->eventLoaded.removeListener(this, &LocaleManager::onLanguageLoaded);
+      eventTeardownLanguageLoaded();
       this->game->assetManager.queueUnload(this->loadingAsset);
       this->loadingAsset = nullptr;
     }
@@ -47,7 +49,9 @@ void LocaleManager::setLocale(struct Locale locale) {
     if(this->loadingAsset->loaded) {
       this->onLanguageLoaded();
     } else {
-      this->loadingAsset->eventLoaded.addListener(this, &LocaleManager::onLanguageLoaded);
+      eventTeardownLanguageLoaded = useEvent([&]() {
+        this->onLanguageLoaded();
+      }, this->loadingAsset->eventLoaded);
     }
   }
 }
@@ -65,7 +69,7 @@ std::string LocaleManager::getString(std::string key) {
 void LocaleManager::onLanguageLoaded() {
   // Unload the previously loaded language
   if(this->currentlyLoadedAsset != nullptr) {
-    this->currentlyLoadedAsset->eventLoaded.removeListener(this, &LocaleManager::onLanguageLoaded);
+    eventTeardownLanguageLoaded();
     this->game->assetManager.queueUnload(this->currentlyLoadedAsset);
   }
 

src/dawn/locale/LocaleManager.hpp

@@ -6,6 +6,7 @@
 #pragma once
 #include "state/StateEvent.hpp"
 #include "asset/assets/LanguageAsset.hpp"
+#include "state/StateOwner.hpp"
 
 namespace Dawn {
   class DawnGame;
@@ -14,13 +15,14 @@ namespace Dawn {
     std::string language;
   };
 
-  class LocaleManager {
+  class LocaleManager : public StateOwner {
     private:
       DawnGame *game;
       LanguageAsset *asset;
       struct Locale locale;
       LanguageAsset *currentlyLoadedAsset = nullptr;
       LanguageAsset *loadingAsset = nullptr;
+      std::function<void()> eventTeardownLanguageLoaded;
 
       /** Listens for when the pending language loads. */
       void onLanguageLoaded();

src/dawn/scene/Scene.hpp

@@ -4,7 +4,6 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "event/Event.hpp"
 #include "asset/Asset.hpp"
 #include "display/shader/ShaderManager.hpp"
 #include "scene/debug/SceneDebugLine.hpp"

src/dawn/scene/SceneItem.hpp

@@ -5,7 +5,6 @@
 
 #pragma once
 #include "display/Transform.hpp"
-#include "event/Event.hpp"
 #include "scene/Scene.hpp"
 #include "util/array.hpp"
 

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

@@ -84,7 +84,7 @@ void Camera::onStart() {
     this->eventRenderTargetResized.invoke(rt->getWidth(), rt->getHeight());
     
     // Subscribe to new render target resized.
-    return evtResized = useEventLegacy([&](RenderTarget *rt, float_t w, float_t h){
+    return evtResized = useEvent([&](RenderTarget *rt, float_t w, float_t h){
       this->projectionNeedsUpdating = true;
       this->eventRenderTargetResized.invoke(w, h);
     }, rt->eventRenderTargetResized);
@@ -102,7 +102,7 @@ void Camera::onStart() {
   // Sub to evt legacy, we don't invoke the useTeardown to avoid invoking
   // the state event for this camera when we don't need to.
   if(!this->getRenderTarget()) return;
-  evtResized = useEventLegacy([&](RenderTarget *rt, float_t w, float_t h){
+  evtResized = useEvent([&](RenderTarget *rt, float_t w, float_t h){
     this->projectionNeedsUpdating = true;
     this->eventRenderTargetResized.invoke(w, h);
   }, getRenderTarget()->eventRenderTargetResized);

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

@@ -43,7 +43,7 @@ void SimpleRenderTargetQuad::onStart() {
     );
 
     // Subscribe to resize event.
-    evtResized = useEventLegacy([&](RenderTarget *target, float_t w, float_t h){
+    evtResized = useEvent([&](RenderTarget *target, float_t w, float_t h){
       QuadMesh::bufferQuadMesh(
         &this->meshHost->mesh,
         glm::vec2(0, 0), glm::vec2(0, 0),

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

@@ -58,7 +58,7 @@ void SubSceneCameraAlign::onStart() {
 
     this->realign();
 
-    return evtRenderResized = useEventLegacy([&](RenderTarget *t, float_t w, float_t h) {
+    return evtRenderResized = useEvent([&](RenderTarget *t, float_t w, float_t h) {
       this->realign();
     }, renderTarget->eventRenderTargetResized);
   }, this->renderTarget);

src/dawn/state/StateInterfaces.hpp

@@ -5,28 +5,15 @@
 
 #pragma once
 #include "assert/assert.hpp"
-#include "event/Event.hpp"
 
 namespace Dawn {
   class IStateEvent;
 
   template<typename...A>
   class StateEvent;
-
-  template<typename ...A>
-  class StateOwnerEventLegacy;
-
-  class IStateOwnerEventLegacy {
-    public:
-      virtual void removeListener() = 0;
-      virtual void teardown() = 0;
-      virtual ~IStateOwnerEventLegacy() {}
-  };
-
   class IStateOwner {
     public:
       virtual void _stateEventDisposed(IStateEvent *evt) = 0;
-      virtual void _stateLegacyEventDisposed(IStateOwnerEventLegacy *evt) = 0;
   };
 
   template<typename...A>

src/dawn/state/StateOwner.hpp

@@ -8,42 +8,9 @@
 #include "StateProperty.hpp"
 
 namespace Dawn {
-  template<typename ...A>
-  class StateOwnerEventLegacy : public IStateOwnerEventLegacy {
-    public:
-      IStateOwner *owner;
-      Event<A...> *event;
-      std::function<void(A...)> fn;
-
-      /**
-       * Function used to simply remove the event listener from the legacy
-       * event, does not deal with the state owner. 
-       */
-      void removeListener() override {
-        event->removeListener(this, &StateOwnerEventLegacy::callback);
-      }
-
-      /**
-       * Function that can be used to tear down this legacy event.
-       */
-      void teardown() override {
-        this->removeListener();
-        owner->_stateLegacyEventDisposed(this);
-      }
-
-      /**
-       * Callbaack method that is invoked by the legacy event.
-       * @param args Arguments received by legacy event.
-       */
-      void callback(A... args) {
-        this->fn(args...);
-      }
-  };
-
   class StateOwner : public IStateOwner {
     private:
       std::vector<IStateEvent*> eventsSubscribed;
-      std::vector<IStateOwnerEventLegacy*> eventLegacyBridge;
 
     protected:
       /**
@@ -62,17 +29,9 @@ namespace Dawn {
           (*it)->_stateOwnerDestroyed(this);
           ++it;
         }
-
-        auto itBridge = this->eventLegacyBridge.begin();
-        while(itBridge != this->eventLegacyBridge.end()) {
-          (*itBridge)->removeListener();
-          delete *itBridge;
-          ++itBridge;
-        }
-
+        
         this->_stateProviderListeners.clear();
         this->eventsSubscribed.clear();
-        this->eventLegacyBridge.clear();
       }
   
     public:
@@ -95,24 +54,6 @@ namespace Dawn {
         }
       }
 
-      /**
-       * Called by legacy events when they are being disposed in a way that was
-       * not called by this state owner disposing.
-       * 
-       * @param evt Event that is being disposed.
-       */
-      void _stateLegacyEventDisposed(IStateOwnerEventLegacy *evt) override {
-        auto it = this->eventLegacyBridge.begin();
-        while(it != this->eventLegacyBridge.end()) {
-          if(*it == evt) {
-            this->eventLegacyBridge.erase(it);
-            break;
-          } else {
-            ++it;
-          }
-        }
-      }
-
       /**
        * Listen for changes to a state property and invoke the provided func
        * when the value is changed.
@@ -230,38 +171,6 @@ namespace Dawn {
 
         return listener.unsub;
       }
-    
-      /**
-       * Listen for callback of a legacy styled event. This will be removed in
-       * the future in favour of everything using State Events. This uses a lot
-       * more memory than the new state event listener.
-       * 
-       * @deprecated In favour of StateEvent<>
-       * @tparam F The type of the callback function.
-       * @tparam A Argument types for the event.
-       * @param fn Callback function to be invoked when the event is triggered.
-       * @param event Event that will be listened to.
-       * @return A method that, when invoked, will unsubscribe from the event.
-       */
-      template<typename F, typename... A>
-      std::function<void()> useEventLegacy(
-        F fn,
-        Event<A...> &event
-      ) {
-        // This is a legacy feature to make upgrading to the new useEffect a bit
-        // easier for me. For the time being I am just bodging this together to
-        // do what I need here.
-        auto bridge = new StateOwnerEventLegacy<A...>();
-        bridge->owner = this;
-        bridge->event = &event;
-        bridge->fn = fn;
-        event.addListener(bridge, &StateOwnerEventLegacy<A...>::callback);
-        eventLegacyBridge.push_back(bridge);
-
-        return std::bind([&](IStateOwnerEventLegacy *evt){
-          evt->teardown();
-        }, bridge);
-      }
 
       /**
        * State Owner teardown function. Mostly just used to remove any lingering

src/dawn/time/ITimeManager.hpp

@@ -5,8 +5,8 @@
 
 #pragma once
 #include "dawnlibs.hpp"
-#include "event/Event.hpp"
 #include "state/StateProvider.hpp"
+#include "state/StateEvent.hpp"
 
 namespace Dawn {
   struct IntervalProviderData {
@@ -23,9 +23,8 @@ namespace Dawn {
 
       StateProviderSet<float_t> timeoutProvider;
       StateProviderSet<struct IntervalProviderData> intervalProvider;
-
-      Event<> eventTimePaused;
-      Event<> eventTimeResumed;
+      StateEvent<> eventTimePaused;
+      StateEvent<> eventTimeResumed;
 
       /**
        * Constructor for the Time Manager.