Added support for "Impure" systems, which only update once per frame and contain their own logic for manipulating the world, instead of relying on a single list of components.

include/Engine/Core/System.h

@@ -7,19 +7,39 @@
 
 class System
 {
-    friend class SystemPipeline;
-
-public:
-    System(EventBroker* eventBroker, std::string componentType)
+protected:
+    System(EventBroker* eventBroker)
         : m_EventBroker(eventBroker)
-        , m_ComponentType(componentType)
     { }
 
-    virtual void Update(World* world, ComponentWrapper& component, double dt) = 0;
-
-protected:
-    std::string m_ComponentType;
     EventBroker* m_EventBroker;
 };
 
+class PureSystem : public System
+{
+    friend class SystemPipeline;
+
+protected:
+    PureSystem(EventBroker* eventBroker, std::string componentType)
+        : System(eventBroker)
+        , m_ComponentType(componentType)
+    { }
+
+    const std::string m_ComponentType;
+
+    virtual void UpdateComponent(World* world, ComponentWrapper& component, double dt) = 0;
+};
+
+class ImpureSystem : public System
+{
+    friend class SystemPipeline;
+
+protected:
+    ImpureSystem(EventBroker* eventBroker)
+        : System(eventBroker)
+    { }
+
+    virtual void Update(World* world, double dt) = 0;
+};
+
 #endif

include/Engine/Core/SystemPipeline.h

@@ -14,7 +14,7 @@ public:
     { }
     ~SystemPipeline()
     {
-        for (auto& pair : m_Systems) {
+        for (auto& pair : m_PureSystems) {
             for (auto& system : pair.second) {
                 delete system;
             }
@@ -25,17 +25,28 @@ public:
     void AddSystem(Arguments... args)
     {
         System* system = new T(m_EventBroker, args...);
-        if (!system->m_ComponentType.empty()) {
-            m_Systems[system->m_ComponentType].push_back(system);
-        } else {
-            LOG_ERROR("Failed to add system \"%s\": Missing component type!", typeid(T).name());
-            delete system;
+
+        if (std::is_base_of<PureSystem, T>::value) {
+            PureSystem* pureSystem = static_cast<PureSystem*>(system);
+            if (!pureSystem->m_ComponentType.empty()) {
+                m_PureSystems[pureSystem->m_ComponentType].push_back(pureSystem);
+            } else {
+                LOG_ERROR("Failed to add pure system \"%s\": Missing component type!", typeid(T).name());
+                if (std::is_base_of<ImpureSystem, T>::value) {
+                    delete system;
+                }
+            }
+        }
+
+        if (std::is_base_of<ImpureSystem, T>::value) {
+            ImpureSystem* impureSystem = static_cast<ImpureSystem*>(system);
+            m_ImpureSystems.push_back(impureSystem);
         }
     }
 
     void Update(World* world, double dt)
     {
-        for (auto& pair : m_Systems) {
+        for (auto& pair : m_PureSystems) {
             const std::string& componentName = pair.first;
             auto& systems = pair.second;
             const ComponentPool* pool = world->GetComponents(componentName);
@@ -44,15 +55,19 @@ public:
             }
             for (auto& component : *pool) {
                 for (auto& system : systems) {
-                    system->Update(world, component, dt);
+                    system->UpdateComponent(world, component, dt);
                 }
             }
         }
+        for (auto& system : m_ImpureSystems) {
+            system->Update(world, dt);
+        }
     }
 
 private:
     EventBroker* m_EventBroker;
-    std::unordered_map<std::string, std::vector<System*>> m_Systems;
+    std::unordered_map<std::string, std::vector<PureSystem*>> m_PureSystems;
+    std::vector<ImpureSystem*> m_ImpureSystems;
 };
 
 #endif