aboutsummaryrefslogtreecommitdiff
path: root/mwe/ecs-homemade/inc
diff options
context:
space:
mode:
authorLoek Le Blansch <loek@pipeframe.xyz>2024-10-06 13:22:10 +0200
committerLoek Le Blansch <loek@pipeframe.xyz>2024-10-06 13:22:10 +0200
commit7c9d3452c99fcb89ea6df55755e90f741b23cf10 (patch)
tree93fab445cd4c0ebb392c2f4def2a0bd32d2709d2 /mwe/ecs-homemade/inc
parent02d658a7ed92bacfdaed587102f0d2e5f6c5dc01 (diff)
copy homemade ECS to crepe + correct code style
Diffstat (limited to 'mwe/ecs-homemade/inc')
-rw-r--r--mwe/ecs-homemade/inc/ComponentManager.h43
-rw-r--r--mwe/ecs-homemade/inc/ComponentManager.hpp154
-rw-r--r--mwe/ecs-homemade/inc/GameObjectMax.h3
-rw-r--r--mwe/ecs-homemade/inc/GameObjectMax.hpp5
4 files changed, 125 insertions, 80 deletions
diff --git a/mwe/ecs-homemade/inc/ComponentManager.h b/mwe/ecs-homemade/inc/ComponentManager.h
index 1a58b01..d368516 100644
--- a/mwe/ecs-homemade/inc/ComponentManager.h
+++ b/mwe/ecs-homemade/inc/ComponentManager.h
@@ -2,39 +2,44 @@
#include "Components.h"
#include <cstdint>
-#include <unordered_map>
-#include <vector>
-#include <typeindex>
#include <memory>
+#include <typeindex>
+#include <unordered_map>
#include <utility>
+#include <vector>
class ComponentManager {
public:
- static ComponentManager& GetInstance(); //Singleton
+ static ComponentManager & GetInstance(); //Singleton
- ComponentManager(const ComponentManager&) = delete; //Singleton
- ComponentManager(ComponentManager&&) = delete; //Singleton
- ComponentManager& operator=(const ComponentManager&) = delete; //Singleton
- ComponentManager& operator=(ComponentManager&&) = delete; //Singleton
+ ComponentManager(const ComponentManager &) = delete; //Singleton
+ ComponentManager(ComponentManager &&) = delete; //Singleton
+ ComponentManager & operator=(const ComponentManager &) = delete; //Singleton
+ ComponentManager & operator=(ComponentManager &&) = delete; //Singleton
template <typename T, typename... Args>
- void AddComponent(std::uint32_t id, Args&&... args); //Add a component of a specific type
+ void AddComponent(std::uint32_t id,
+ Args &&... args); //Add a component of a specific type
template <typename T>
- void DeleteComponentsById(std::uint32_t id); //Deletes all components of a specific type and id
+ void DeleteComponentsById(
+ std::uint32_t id); //Deletes all components of a specific type and id
template <typename T>
- void DeleteComponents(); //Deletes all components of a specific type
- void DeleteAllComponentsOfId(std::uint32_t id); //Deletes all components of a specific id
- void DeleteAllComponents(); //Deletes all components
+ void DeleteComponents(); //Deletes all components of a specific type
+ void DeleteAllComponentsOfId(
+ std::uint32_t id); //Deletes all components of a specific id
+ void DeleteAllComponents(); //Deletes all components
template <typename T>
- std::vector<std::reference_wrapper<T>> GetComponentsByID(std::uint32_t id) const; //Get a vector<> of all components at specific type and id
+ std::vector<std::reference_wrapper<T>> GetComponentsByID(std::uint32_t id)
+ const; //Get a vector<> of all components at specific type and id
template <typename T>
- std::vector<std::reference_wrapper<T>> GetComponentsByType() const; //Get a vector<> of all components of a specific type
+ std::vector<std::reference_wrapper<T>> GetComponentsByType()
+ const; //Get a vector<> of all components of a specific type
private:
- static ComponentManager mInstance; //Singleton
+ static ComponentManager mInstance; //Singleton
- ComponentManager(); //Singleton
+ ComponentManager(); //Singleton
/*
* The std::unordered_map<std::type_index, std::vector<std::vector<std::unique_ptr<Component>>>> below might seem a bit strange, let me explain this structure:
@@ -42,7 +47,9 @@ private:
* The first std::vector<> stores another vector<>. This first vector<> is to bind the entity's id to a component.
* The second std::vector<> stores unique_ptrs. Each component can be gathered via an unique_ptr. This second vector<> allows multiple components of the same std::type_index for one entity (id).
*/
- std::unordered_map<std::type_index, std::vector<std::vector<std::unique_ptr<Component>>>> mComponents;
+ std::unordered_map<std::type_index,
+ std::vector<std::vector<std::unique_ptr<Component>>>>
+ mComponents;
};
#include "ComponentManager.hpp"
diff --git a/mwe/ecs-homemade/inc/ComponentManager.hpp b/mwe/ecs-homemade/inc/ComponentManager.hpp
index 720ee79..161ce71 100644
--- a/mwe/ecs-homemade/inc/ComponentManager.hpp
+++ b/mwe/ecs-homemade/inc/ComponentManager.hpp
@@ -1,88 +1,126 @@
template <typename T, typename... Args>
-void ComponentManager::AddComponent(std::uint32_t id, Args&&... args) {
- std::type_index type = typeid(T); //Determine the type of T (this is used as the key of the unordered_map<>)
-
- if (mComponents.find(type) == mComponents.end()) { //Check if this component type is already in the unordered_map<>
- mComponents[type] = std::vector<std::vector<std::unique_ptr<Component>>>(); //If not, create a new (empty) vector<> of vector<unique_ptr<Component>>
- }
+void ComponentManager::AddComponent(std::uint32_t id, Args &&... args) {
+ std::type_index type = typeid(
+ T); //Determine the type of T (this is used as the key of the unordered_map<>)
+
+ if (mComponents.find(type)
+ == mComponents
+ .end()) { //Check if this component type is already in the unordered_map<>
+ mComponents[type] = std::vector<std::vector<std::unique_ptr<
+ Component>>>(); //If not, create a new (empty) vector<> of vector<unique_ptr<Component>>
+ }
- if (id >= mComponents[type].size()) { //Resize the vector<> if the id is greater than the current size
- mComponents[type].resize(id + 1); //Initialize new slots to nullptr (resize does automatically init to nullptr)
- }
+ if (id
+ >= mComponents[type]
+ .size()) { //Resize the vector<> if the id is greater than the current size
+ mComponents[type].resize(
+ id
+ + 1); //Initialize new slots to nullptr (resize does automatically init to nullptr)
+ }
- mComponents[type][id].push_back(std::make_unique<T>(std::forward<Args>(args)...)); //Create a new component of type T using perfect forwarding and store its unique_ptr in the vector<>
+ mComponents[type][id].push_back(std::make_unique<T>(std::forward<Args>(
+ args)...)); //Create a new component of type T using perfect forwarding and store its unique_ptr in the vector<>
}
template <typename T>
void ComponentManager::DeleteComponentsById(std::uint32_t id) {
- std::type_index type = typeid(T); //Determine the type of T (this is used as the key of the unordered_map<>)
-
- if (mComponents.find(type) != mComponents.end()) { //Find the type (in the unordered_map<>)
- std::vector<std::vector<std::unique_ptr<Component>>>& componentArray = mComponents[type]; //Get the correct vector<>
-
- if (id < componentArray.size()) { //Make sure that the id (that we are looking for) is within the boundaries of the vector<>
- componentArray[id].clear(); //Clear the whole vector<> of this specific type and id
- }
+ std::type_index type = typeid(
+ T); //Determine the type of T (this is used as the key of the unordered_map<>)
+
+ if (mComponents.find(type)
+ != mComponents.end()) { //Find the type (in the unordered_map<>)
+ std::vector<std::vector<std::unique_ptr<Component>>> & componentArray
+ = mComponents[type]; //Get the correct vector<>
+
+ if (id
+ < componentArray
+ .size()) { //Make sure that the id (that we are looking for) is within the boundaries of the vector<>
+ componentArray[id]
+ .clear(); //Clear the whole vector<> of this specific type and id
+ }
}
}
-template <typename T>
-void ComponentManager::DeleteComponents() {
- std::type_index type = typeid(T); //Determine the type of T (this is used as the key of the unordered_map<>)
+template <typename T> void ComponentManager::DeleteComponents() {
+ std::type_index type = typeid(
+ T); //Determine the type of T (this is used as the key of the unordered_map<>)
- if (mComponents.find(type) != mComponents.end()) { //Find the type (in the unordered_map<>)
- mComponents[type].clear(); //Clear the whole vector<> of this specific type
+ if (mComponents.find(type)
+ != mComponents.end()) { //Find the type (in the unordered_map<>)
+ mComponents[type]
+ .clear(); //Clear the whole vector<> of this specific type
}
}
template <typename T>
-std::vector<std::reference_wrapper<T>> ComponentManager::GetComponentsByID(std::uint32_t id) const {
- std::type_index type = typeid(T); //Determine the type of T (this is used as the key of the unordered_map<>)
-
- std::vector<std::reference_wrapper<T>> componentVector; //Create an empty vector<>
-
- if (mComponents.find(type) != mComponents.end()) { //Find the type (in the unordered_map<>)
-
- const std::vector<std::vector<std::unique_ptr<Component>>>& componentArray = mComponents.at(type); //Get the correct vector<>
-
- if (id < componentArray.size()) { //Make sure that the id (that we are looking for) is within the boundaries of the vector<>
- for (const std::unique_ptr<Component>& componentPtr : componentArray[id]) { //Loop trough the whole vector<>
- T* castedComponent = static_cast<T*>(componentPtr.get()); //Cast the unique_ptr to a raw pointer
-
- if (castedComponent) { //Ensure that the cast was successful
- componentVector.push_back(*castedComponent); //Add the dereferenced raw pointer to the vector<>
- }
- }
- }
- }
+std::vector<std::reference_wrapper<T>>
+ComponentManager::GetComponentsByID(std::uint32_t id) const {
+ std::type_index type = typeid(
+ T); //Determine the type of T (this is used as the key of the unordered_map<>)
+
+ std::vector<std::reference_wrapper<T>>
+ componentVector; //Create an empty vector<>
+
+ if (mComponents.find(type)
+ != mComponents.end()) { //Find the type (in the unordered_map<>)
+
+ const std::vector<std::vector<std::unique_ptr<Component>>> &
+ componentArray
+ = mComponents.at(type); //Get the correct vector<>
+
+ if (id
+ < componentArray
+ .size()) { //Make sure that the id (that we are looking for) is within the boundaries of the vector<>
+ for (const std::unique_ptr<Component> & componentPtr :
+ componentArray[id]) { //Loop trough the whole vector<>
+ T * castedComponent = static_cast<T *>(
+ componentPtr.get()); //Cast the unique_ptr to a raw pointer
+
+ if (castedComponent) { //Ensure that the cast was successful
+ componentVector.push_back(
+ *castedComponent); //Add the dereferenced raw pointer to the vector<>
+ }
+ }
+ }
+ }
- return componentVector; //Return the vector<>
+ return componentVector; //Return the vector<>
}
template <typename T>
-std::vector<std::reference_wrapper<T>> ComponentManager::GetComponentsByType() const {
- std::type_index type = typeid(T); //Determine the type of T (this is used as the key of the unordered_map<>)
+std::vector<std::reference_wrapper<T>>
+ComponentManager::GetComponentsByType() const {
+ std::type_index type = typeid(
+ T); //Determine the type of T (this is used as the key of the unordered_map<>)
- std::vector<std::reference_wrapper<T>> componentVector; //Create an empty vector<>
+ std::vector<std::reference_wrapper<T>>
+ componentVector; //Create an empty vector<>
//std::uint32_t id = 0; //Set the id to 0 (the id will also be stored in the returned vector<>)
- if (mComponents.find(type) != mComponents.end()) { //Find the type (in the unordered_map<>)
+ if (mComponents.find(type)
+ != mComponents.end()) { //Find the type (in the unordered_map<>)
- const std::vector<std::vector<std::unique_ptr<Component>>>& componentArray = mComponents.at(type); //Get the correct vector<>
+ const std::vector<std::vector<std::unique_ptr<Component>>> &
+ componentArray
+ = mComponents.at(type); //Get the correct vector<>
- for (const std::vector<std::unique_ptr<Component>>& component : componentArray) { //Loop through the whole vector<>
- for (const std::unique_ptr<Component>& componentPtr : component) { //Loop trough the whole vector<>
- T* castedComponent = static_cast<T*>(componentPtr.get()); //Cast the unique_ptr to a raw pointer
+ for (const std::vector<std::unique_ptr<Component>> & component :
+ componentArray) { //Loop through the whole vector<>
+ for (const std::unique_ptr<Component> & componentPtr :
+ component) { //Loop trough the whole vector<>
+ T * castedComponent = static_cast<T *>(
+ componentPtr.get()); //Cast the unique_ptr to a raw pointer
- if (castedComponent) { //Ensure that the cast was successful
- componentVector.emplace_back(std::ref(*castedComponent)); //Pair the dereferenced raw pointer and the id and add it to the vector<>
- }
- }
+ if (castedComponent) { //Ensure that the cast was successful
+ componentVector.emplace_back(std::ref(
+ *castedComponent)); //Pair the dereferenced raw pointer and the id and add it to the vector<>
+ }
+ }
//++id; //Increase the id (the id will also be stored in the returned vector<>)
- }
- }
+ }
+ }
- return componentVector; //Return the vector<>
+ return componentVector; //Return the vector<>
}
diff --git a/mwe/ecs-homemade/inc/GameObjectMax.h b/mwe/ecs-homemade/inc/GameObjectMax.h
index f0bcec9..c88a834 100644
--- a/mwe/ecs-homemade/inc/GameObjectMax.h
+++ b/mwe/ecs-homemade/inc/GameObjectMax.h
@@ -7,8 +7,7 @@ class GameObject {
public:
GameObject(std::uint32_t id, std::string name, std::string tag, int layer);
- template <typename T, typename... Args>
- void AddComponent(Args&&... args);
+ template <typename T, typename... Args> void AddComponent(Args &&... args);
std::uint32_t mId;
std::string mName;
diff --git a/mwe/ecs-homemade/inc/GameObjectMax.hpp b/mwe/ecs-homemade/inc/GameObjectMax.hpp
index 1e952ba..91d51ea 100644
--- a/mwe/ecs-homemade/inc/GameObjectMax.hpp
+++ b/mwe/ecs-homemade/inc/GameObjectMax.hpp
@@ -1,6 +1,7 @@
#include "ComponentManager.h"
template <typename T, typename... Args>
-void GameObject::AddComponent(Args&&... args) {
- ComponentManager::GetInstance().AddComponent<T>(mId, std::forward<Args>(args)...);
+void GameObject::AddComponent(Args &&... args) {
+ ComponentManager::GetInstance().AddComponent<T>(
+ mId, std::forward<Args>(args)...);
}