aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/crepe/CMakeLists.txt8
-rw-r--r--src/crepe/ComponentManager.cpp25
-rw-r--r--src/crepe/ComponentManager.h55
-rw-r--r--src/crepe/ComponentManager.hpp134
-rw-r--r--src/crepe/Components.cpp13
-rw-r--r--src/crepe/Components.h39
-rw-r--r--src/crepe/GameObject.cpp9
-rw-r--r--src/crepe/GameObject.h22
-rw-r--r--src/crepe/GameObject.hpp15
9 files changed, 320 insertions, 0 deletions
diff --git a/src/crepe/CMakeLists.txt b/src/crepe/CMakeLists.txt
index 208ba1f..5840208 100644
--- a/src/crepe/CMakeLists.txt
+++ b/src/crepe/CMakeLists.txt
@@ -2,12 +2,20 @@ target_sources(crepe PUBLIC
Asset.cpp
Sound.cpp
SoundContext.cpp
+ ComponentManager.cpp
+ Components.cpp
+ GameObject.cpp
)
target_sources(crepe PUBLIC FILE_SET HEADERS FILES
Asset.h
Sound.h
SoundContext.h
+ ComponentManager.h
+ ComponentManager.hpp
+ Components.h
+ GameObject.h
+ GameObject.hpp
)
add_subdirectory(api)
diff --git a/src/crepe/ComponentManager.cpp b/src/crepe/ComponentManager.cpp
new file mode 100644
index 0000000..b7a1bea
--- /dev/null
+++ b/src/crepe/ComponentManager.cpp
@@ -0,0 +1,25 @@
+#include "ComponentManager.h"
+
+using namespace crepe;
+
+ComponentManager & ComponentManager::get_instance() {
+ static ComponentManager instance;
+ return instance;
+}
+
+void ComponentManager::DeleteAllComponentsOfId(std::uint32_t id) {
+ // Loop through all the types (in the unordered_map<>)
+ for (auto & [type, componentArray] : components) {
+ // Make sure that the id (that we are looking for) is within the boundaries of the vector<>
+ if (id < componentArray.size()) {
+ // Clear the components at this specific id
+ componentArray[id].clear();
+ }
+ }
+}
+
+void ComponentManager::DeleteAllComponents() {
+ // Clear the whole unordered_map<>
+ components.clear();
+}
+
diff --git a/src/crepe/ComponentManager.h b/src/crepe/ComponentManager.h
new file mode 100644
index 0000000..003cd0b
--- /dev/null
+++ b/src/crepe/ComponentManager.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <typeindex>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "Components.h"
+
+namespace crepe {
+
+class ComponentManager {
+public:
+ // Singleton
+ static ComponentManager & get_instance();
+ ComponentManager(const ComponentManager &) = delete;
+ ComponentManager(ComponentManager &&) = delete;
+ ComponentManager & operator=(const ComponentManager &) = delete;
+ ComponentManager & operator=(ComponentManager &&) = delete;
+
+public:
+ //! Add a component of a specific type
+ template <typename T, typename... Args> void AddComponent(std::uint32_t id, Args &&... args);
+ //! Deletes all components of a specific type and id
+ template <typename T> void DeleteComponentsById(std::uint32_t id);
+ //! Deletes all components of a specific type
+ template <typename T> void DeleteComponents();
+ //! Deletes all components of a specific id
+ void DeleteAllComponentsOfId(std::uint32_t id);
+ //! Deletes all components
+ void DeleteAllComponents();
+
+ //! Get a vector<> of all components at specific type and id
+ template <typename T> std::vector<std::reference_wrapper<T>> GetComponentsByID(std::uint32_t id) const;
+ //! Get a vector<> of all components of a specific type
+ template <typename T> std::vector<std::reference_wrapper<T>> GetComponentsByType() const;
+
+private:
+ ComponentManager() = default;
+
+ /*
+ * 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:
+ * The std::unordered_map<> has a key and value. The key is a std::type_index and the value is a std::vector. So, a new std::vector will be created for each new std::type_index.
+ * 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>>>> components;
+};
+
+}
+
+// #include "ComponentManager.hpp"
+
diff --git a/src/crepe/ComponentManager.hpp b/src/crepe/ComponentManager.hpp
new file mode 100644
index 0000000..602490e
--- /dev/null
+++ b/src/crepe/ComponentManager.hpp
@@ -0,0 +1,134 @@
+#pragma once
+
+#include "ComponentManager.h"
+
+namespace crepe {
+
+template <typename T, typename... Args>
+void ComponentManager::AddComponent(std::uint32_t id, Args &&... args) {
+ // Determine the type of T (this is used as the key of the unordered_map<>)
+ std::type_index type = typeid(T);
+
+ // Check if this component type is already in the unordered_map<>
+ if (components.find(type) == components.end()) {
+ //If not, create a new (empty) vector<> of vector<unique_ptr<Component>>
+ components[type] = std::vector<std::vector<std::unique_ptr<Component>>>();
+ }
+
+ // Resize the vector<> if the id is greater than the current size
+ if (id >= components[type].size()) {
+ // Initialize new slots to nullptr (resize does automatically init to nullptr)
+ components[type].resize(id + 1);
+ }
+
+ // Create a new component of type T using perfect forwarding and store its
+ // unique_ptr in the vector<>
+ components[type][id].push_back(std::make_unique<T>(std::forward<Args>(args)...));
+}
+
+template <typename T>
+void ComponentManager::DeleteComponentsById(std::uint32_t id) {
+ // Determine the type of T (this is used as the key of the unordered_map<>)
+ std::type_index type = typeid(T);
+
+ // Find the type (in the unordered_map<>)
+ if (components.find(type) != components.end()) {
+ // Get the correct vector<>
+ std::vector<std::vector<std::unique_ptr<Component>>> & componentArray = components[type];
+
+ // Make sure that the id (that we are looking for) is within the boundaries of the vector<>
+ if (id < componentArray.size()) {
+ // Clear the whole vector<> of this specific type and id
+ componentArray[id].clear();
+ }
+ }
+}
+
+template <typename T>
+void ComponentManager::DeleteComponents() {
+ // Determine the type of T (this is used as the key of the unordered_map<>)
+ std::type_index type = typeid(T);
+
+ // Find the type (in the unordered_map<>)
+ if (components.find(type) != components.end()) {
+ // Clear the whole vector<> of this specific type
+ components[type].clear();
+ }
+}
+
+template <typename T>
+std::vector<std::reference_wrapper<T>>
+ComponentManager::GetComponentsByID(std::uint32_t id) const {
+ // Determine the type of T (this is used as the key of the unordered_map<>)
+ std::type_index type = typeid(T);
+
+ // Create an empty vector<>
+ std::vector<std::reference_wrapper<T>> componentVector;
+
+ // Find the type (in the unordered_map<>)
+ if (components.find(type) != components.end()) {
+ // Get the correct vector<>
+ const std::vector<std::vector<std::unique_ptr<Component>>> & componentArray = components.at(type);
+
+ // Make sure that the id (that we are looking for) is within the boundaries of the vector<>
+ if (id < componentArray .size()) {
+ // Loop trough the whole vector<>
+ for (const std::unique_ptr<Component> & componentPtr : componentArray[id]) {
+ // Cast the unique_ptr to a raw pointer
+ T * castedComponent = static_cast<T *>(componentPtr.get());
+
+ // Ensure that the cast was successful
+ if (castedComponent) {
+ // Add the dereferenced raw pointer to the vector<>
+ componentVector.push_back(*castedComponent);
+ }
+ }
+ }
+ }
+
+ // Return the vector<>
+ return componentVector;
+}
+
+template <typename T>
+std::vector<std::reference_wrapper<T>>
+ComponentManager::GetComponentsByType() const {
+ // Determine the type of T (this is used as the key of the unordered_map<>)
+ std::type_index type = typeid(T);
+
+ // Create an empty vector<>
+ std::vector<std::reference_wrapper<T>> componentVector;
+ // Set the id to 0 (the id will also be stored in the returned vector<>)
+ // std::uint32_t id = 0;
+
+ // Find the type (in the unordered_map<>)
+ if (components.find(type) != components.end()) {
+
+ // Get the correct vector<>
+ const std::vector<std::vector<std::unique_ptr<Component>>> & componentArray = components.at(type);
+
+ // Loop through the whole vector<>
+ for (const std::vector<std::unique_ptr<Component>> & component : componentArray) {
+ // Loop trough the whole vector<>
+ for (const std::unique_ptr<Component> & componentPtr : component) {
+ // Cast the unique_ptr to a raw pointer
+ T * castedComponent = static_cast<T *>(componentPtr.get());
+
+ // Ensure that the cast was successful
+ if (castedComponent) {
+ // Pair the dereferenced raw pointer and the id and add it to the vector<>
+ componentVector.emplace_back(std::ref(*castedComponent));
+ }
+ }
+
+ // Increase the id (the id will also be stored in the returned vector<>)
+ //++id;
+ }
+ }
+
+ // Return the vector<>
+ return componentVector;
+}
+
+}
+
diff --git a/src/crepe/Components.cpp b/src/crepe/Components.cpp
new file mode 100644
index 0000000..9760daa
--- /dev/null
+++ b/src/crepe/Components.cpp
@@ -0,0 +1,13 @@
+#include "Components.h"
+#include <iostream>
+
+using namespace crepe;
+
+Component::Component() : mActive(true) {}
+
+Sprite::Sprite(std::string path) : mPath(path) {}
+
+Rigidbody::Rigidbody(int mass, int gravityScale, int bodyType)
+ : mMass(mass), mGravityScale(gravityScale), mBodyType(bodyType) {}
+
+Colider::Colider(int size) : mSize(size) {}
diff --git a/src/crepe/Components.h b/src/crepe/Components.h
new file mode 100644
index 0000000..7cb6fbb
--- /dev/null
+++ b/src/crepe/Components.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <string>
+
+namespace crepe {
+
+class Component {
+public:
+ Component();
+
+ bool mActive;
+};
+
+// TODO: these should be in separate files
+
+class Sprite : public Component {
+public:
+ Sprite(std::string path);
+
+ std::string mPath;
+};
+
+class Rigidbody : public Component {
+public:
+ Rigidbody(int mass, int gravityScale, int bodyType);
+
+ int mMass;
+ int mGravityScale;
+ int mBodyType;
+};
+
+class Colider : public Component {
+public:
+ Colider(int size);
+
+ int mSize;
+};
+
+}
diff --git a/src/crepe/GameObject.cpp b/src/crepe/GameObject.cpp
new file mode 100644
index 0000000..5ac9d7a
--- /dev/null
+++ b/src/crepe/GameObject.cpp
@@ -0,0 +1,9 @@
+#include "GameObject.h"
+
+#include "ComponentManager.h"
+
+using namespace crepe;
+
+GameObject::GameObject(std::uint32_t id, std::string name, std::string tag,
+ int layer)
+ : mId(id), mName(name), mTag(tag), mActive(true), mLayer(layer) {}
diff --git a/src/crepe/GameObject.h b/src/crepe/GameObject.h
new file mode 100644
index 0000000..71ef60d
--- /dev/null
+++ b/src/crepe/GameObject.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+namespace crepe {
+
+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);
+
+ std::uint32_t mId;
+ std::string mName;
+ std::string mTag;
+ bool mActive;
+ int mLayer;
+};
+
+}
+
diff --git a/src/crepe/GameObject.hpp b/src/crepe/GameObject.hpp
new file mode 100644
index 0000000..5a672cf
--- /dev/null
+++ b/src/crepe/GameObject.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "GameObject.h"
+
+#include "ComponentManager.h"
+
+namespace crepe {
+
+template <typename T, typename... Args>
+void GameObject::AddComponent(Args &&... args) {
+ ComponentManager::get_instance().AddComponent<T>(mId, std::forward<Args>(args)...);
+}
+
+}
+