ECS almost finished

sgf4 · sgf4 · commit 1b690aa271b9 · 2023-04-29T20:40:08.000+02:00
diff --git a/cmake/flags.cmake b/cmake/flags.cmake
@@ -8,7 +8,7 @@ set(CMAKE_CXX_FLAGS_DEBUG "-g -Og")
 set(CMAKE_CXX_FLAGS_RELEASE "-O3 -ffunction-sections -fdata-sections -fno-rtti -fvisibility=hidden -DNDEBUG")
 
 if(CMAKE_BUILD_TYPE STREQUAL "Release")
-    set(CMAKE_EXE_LINKER_FLAGS "-Wl,--gc-sections -Wl,--strip-all")
+    set(CMAKE_EXE_LINKER_FLAGS "-Wl,--gc-sections ") # -Wl,--strip-all
 endif()
 
 
diff --git a/src/Game.cpp b/src/Game.cpp
@@ -45,7 +45,7 @@ class Game::GameImpl {
             
             // Update worlds
             for (World* world : m_worlds) {
-                world->updateEntities();
+                world->updateWorld();
                 world->update();
             }
         }
diff --git a/src/World/Component/Component.cpp b/src/World/Component/Component.cpp
@@ -1,4 +1,6 @@
 #include "Component.hpp"
+#include "../Entity.hpp"
+
 #include "Transform.hpp"
 #include "Transform2D.hpp"
 #include "Physics.hpp"
@@ -14,14 +16,87 @@ ComponentManager::ComponentManager() {
 void ComponentManager::update() {
     TupleForwardFn<ComponentList>([&] <typename... Ts> () {
         ([&] <typename T> () {
-            std::vector<T>& pool = *std::get<Pool<T>>(m_componentPool);
+            if (!m_loadedMask[getId<T>()]) return;
+            std::vector<T>& pool = *std::get<Pool<T>>(m_pool);
             for (T& component : pool) {
                 component.update();
             }
         }.template operator()<Ts>(), ...);
     });
 }
 
+template<typename T>
+void ComponentManager::load() {
+    m_loadedMask.set(getId<T>());
+    auto& uniq = std::get<Pool<T>>(m_pool);
+    uniq = std::make_unique<std::vector<T>>();
+    uniq->reserve(32);
+}
+
+template<typename T>
+void ComponentManager::unload() {
+    m_loadedMask.reset(getId<T>());
+    auto& uniq = std::get<Pool<T>>(m_pool);
+    uniq.reset();
+}
+
+template<typename T>
+T& ComponentManager::add(Entity& entity) {
+    std::vector<T>& pool = *std::get<Pool<T>>(m_pool);
+
+    auto& c = pool.emplace_back();
+    c.eId = entity.id;
+    entity.setComponentKey<T>(pool.size()-1);
+    entity.getComponentMask().set(getId<T>());
+    c.init();
+    return c;
+}
+
+template<typename T>
+void ComponentManager::del(Entity& entity) {
+    std::vector<T>& pool = *std::get<Pool<T>>(m_pool);
+    T& last = pool[pool.size()-1];
+    u32 componentKey = entity.getComponentKey<T>();
+    T& component = pool[componentKey];
+    component.destroy();
+    component = std::move(last);
+
+    Entity& eReplaced = component.getEntity();
+    eReplaced.setComponentKey<T>(componentKey);
+    entity.getComponentMask().reset(getId<T>());
+    pool.pop_back();
+}
+
+template<typename T>
+Entity& ComponentManager::getEntity(u32 id) {
+    std::vector<T>& pool = *std::get<Pool<T>>(m_pool);
+    return pool[id].getEntity();
+}
+
+template<typename T>
+T& ComponentManager::get(u32 id) {
+    std::vector<T>& pool = *std::get<Pool<T>>(m_pool);
+    return pool[id];
+}
+
 ComponentManager::~ComponentManager() {
 
+}
+
+template<typename C, typename R, typename... P>
+void instance(R (C::*ptr) (P...)) {
+    std::cout << ptr << std::endl;
+}
+
+void instanceTemplating() {
+    TupleForwardFn<ComponentList>([&] <typename... Ts> () { 
+        ([&] <typename T> () {
+            instance(&ComponentManager::load<T>);
+            instance(&ComponentManager::unload<T>);
+            instance(&ComponentManager::add<T>);
+            instance(&ComponentManager::del<T>);
+            instance(&ComponentManager::get<T>);
+            instance(&ComponentManager::getEntity<T>);
+        }.template operator()<Ts>(), ...);
+    });
 }
diff --git a/src/World/Component/Component.hpp b/src/World/Component/Component.hpp
@@ -17,12 +17,14 @@ constexpr u32 NComponents = std::tuple_size_v<ComponentList>;
 
 class Entity;
 struct Component {
-    u32 id;
+    u32 eId;
 
-    Component(u32 eId) : id(eId) {}
+    void init() {}
+    void update() {}
+    void destroy() {}
 
     Entity& getEntity() {
-        return WORLD.getEntity(id);
+        return WORLD.getEntity(eId);
     }
 };
 
@@ -36,49 +38,41 @@ class ComponentManager {
     template<typename... Ts>
     using MultiPool = std::tuple<Pool<Ts>...>;
 
-    TupleForward<ComponentList, MultiPool> m_componentPool;
+    TupleForward<ComponentList, MultiPool> m_pool;
 public:
 
     ComponentManager();
     ~ComponentManager();
     
     template<typename T>
-    static consteval u32 getComponentId() {
+    static consteval u32 getId() {
         return TupleGetIndex<T, ComponentList>;
     }
 
     template<typename T>
-    void loadComponent() {
-        m_loadedMask.set(getComponentId<T>());
-        
-        auto& uniq = std::get<Pool<T>>(m_componentPool);
-        uniq = std::make_unique<std::vector<T>>();
-        uniq->reserve(32);
+    void load();
+
+    template<typename T>
+    void unload();
+
+    template<typename T>
+    Entity& getEntity(u32 id);
+
+    template<typename... Ts>
+    bool isLoaded() {
+        return (m_loadedMask[getId<Ts>] && ...);
     }
 
     void update();
 
-    template<typename T, typename... Ts>
-    u32 addComponent(Ts&&... args) {
-        std::vector<T>& pool = *std::get<Pool<T>>(m_componentPool);
-        pool.emplace_back(std::forward<Ts>(args)...);
-        return pool.size();
-    }
+    template<typename T>
+    T& add(Entity&);
 
     template<typename T>
-    T& getComponent(u32 id) {
-        std::vector<T>& pool = *std::get<Pool<T>>(m_componentPool);
-        return pool[id];
-    }
+    void del(Entity&);
 
     template<typename T>
-    void delComponent(u32 id) {
-        std::vector<T>& pool = *std::get<Pool<T>>(m_componentPool);
-        T& last = pool[pool.size()-1];
-        T& replaced = pool[id];
-        replaced = std::move(last);
-        replaced.id = id;
-        pool.pop_back();
-    }
+    T& get(u32 id);
+
 };
 
diff --git a/src/World/Component/Physics.hpp b/src/World/Component/Physics.hpp
@@ -1,6 +1,7 @@
 #pragma once 
+#include "Component.hpp"
 
-class Physics {
+class Physics : public Component {
 
 public:
     void update() {}
diff --git a/src/World/Component/Shader.hpp b/src/World/Component/Shader.hpp
@@ -1,7 +1,8 @@
 #pragma once 
+#include "Component.hpp"
 #include <GL.hpp>
 
-class Shader {
+class Shader : public Component {
     
 public:
     void update() {}
diff --git a/src/World/Component/Texture.hpp b/src/World/Component/Texture.hpp
@@ -3,7 +3,7 @@
 #include "Transform2D.hpp"
 #include "Transform.hpp"
 
-class Texture {
+class Texture : public Component {
 public:
     void update() {}
 //     GL::Texture* m_texture;
diff --git a/src/World/Component/Transform.hpp b/src/World/Component/Transform.hpp
@@ -1,10 +1,11 @@
 #pragma once
 #include <GL.hpp>
 #include <glm/vec3.hpp>
+#include "Component.hpp"
 
 #define TRANSFORM ENTITY.getComponent<Transform>()
 
-class Transform {
+class Transform : public Component {
 public:
     glm::mat4 model { 1.f };
     glm::vec3 position;
diff --git a/src/World/Component/Transform2D.hpp b/src/World/Component/Transform2D.hpp
@@ -1,10 +1,10 @@
 #pragma once 
-//#include "Component.hpp"
+#include "Component.hpp"
 
 #include <glm/vec2.hpp>
 #include <GL.hpp>
 
-class Transform2D {
+class Transform2D : public Component {
 public:
     Transform2D(glm::vec2 position = {0, 0}, glm::vec2 scale = {1, 1}, float rotation = 0);
 
diff --git a/src/World/Component/Triangle.hpp b/src/World/Component/Triangle.hpp
@@ -15,8 +15,8 @@ struct TriangleLoader {
     TriangleLoader();
 };
 
-struct Triangle {
-    Triangle() {}
+class Triangle : public Component {
+public:
     void update() {}
 };
 
diff --git a/src/World/Entity.hpp b/src/World/Entity.hpp
@@ -4,33 +4,68 @@
 #include "World.hpp"
 
 #include <array>
+#include <bitset>
 
 #define ENTITY getEntity()
 
 class Entity {
     std::array<u32, NComponents> m_componentKeys;
+    std::bitset<NComponents> m_componentMask;
 public:
     u32 id;
 
-    void update() {}
+    template<typename T>
+    static consteval u32 getComponentId() {
+        return ComponentManager::getId<T>();
+    }
 
     template<typename T>
     T& addComponent() {
-        ComponentManager& cm = WORLD.getComponentManager();
-        u32 id = cm.addComponent<T>();
-        setKey(ComponentManager::getComponentId<T>(), id);
-        return cm.getComponent<T>(id);
+        if (hasComponent<T>()) throw "Component already set";
+        return WORLD.getComponentManager().add<T>(*this);
+    }
+
+    template<typename T>
+    void delComponent() {
+        WORLD.getComponentManager().del<T>(*this);
+    }
+
+    template<typename... Ts>
+    bool hasComponent() {
+        return (m_componentMask[getComponentId<Ts>()] && ...);
     }
 
     template<typename T>
     T& getComponent() {
         ComponentManager& cm = WORLD.getComponentManager();
-        return cm.getComponent<T>(m_componentKeys[ComponentManager::getComponentId<T>()]);
+        return cm.get<T>(getComponentKey<T>());
     }
 
-    void setKey(u32 k, u32 v) { m_componentKeys[k] = v; }
+    std::bitset<NComponents>& getComponentMask() { 
+        return m_componentMask;
+    }
+
+    template<typename T>
+    void setComponentKey(u32 v) { 
+        m_componentKeys[getComponentId<T>()] = v; 
+    }
+
+    template<typename T>
+    u32 getComponentKey() { 
+        return m_componentKeys[getComponentId<T>()]; 
+    }
 
     auto getId() { return id; }
     operator u32() { return getId(); }
+
+    ~Entity() {
+        TupleForwardFn<ComponentList>([&] <typename... Ts> () {
+            ([&] <typename T> () {
+                if (hasComponent<T>()) {
+                    delComponent<T>();
+                }
+            }.template operator()<Ts>(), ...);
+        });
+    }
 };
 
diff --git a/src/World/ExampleWorld.hpp b/src/World/ExampleWorld.hpp
@@ -2,13 +2,13 @@
 #include "../Loader.hpp"
 #include "World.hpp"
 #include "Entity.hpp"
-#include "Component/Triangle.hpp"
+#include "Component/Component.hpp"
 
 class ExampleWorld : public World {
 
 public:
     void init() {
-        getComponentManager().loadComponent<Triangle>();
+        getComponentManager().load<Triangle>();
         Entity& e = addEntity();
         e.addComponent<Triangle>();
     }
diff --git a/src/World/World.cpp b/src/World/World.cpp
@@ -8,16 +8,9 @@ World::World() {
 }
 
 
-void World::updateEntities() {
+void World::updateWorld() {
     current = this;
     m_time.update();
-    for (Entity& entity : m_entities) {
-        try {
-            entity.update();
-        } catch(std::string err) {
-            std::cerr << "ERROR: " << err << std::endl;
-        }
-    }
 }
 
 Entity& World::addEntity() {
diff --git a/src/World/World.hpp b/src/World/World.hpp

Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ class Game::GameImpl {`
`45`	`45`
`46`	`46`	`// Update worlds`
`47`	`47`	`for (World* world : m_worlds) {`
`48`		`- world->updateEntities();`
	`48`	`+ world->updateWorld();`
`49`	`49`	`world->update();`
`50`	`50`	`}`
`51`	`51`	`}`