registry.hpp

Go to the documentation of this file.

#pragma once
 
#include <unordered_map>
#include <queue>
#include <stdexcept>
#include <set>
#include <iostream>
 
#include "../defs.hpp"
#include "../constants.hpp"
#include "componentstorage.hpp"
 
#include <engine/core/logger.hpp>
 
// Forward declaration
namespace Engine::Scene { class Scene; }
 
namespace Engine::ECS {
    inline size_t nextComponentTypeId = 0;
    
    class Registry {
        friend class Scene::Scene;
 
        // Templates qui permettent de checker si un composant possède un ::BaseType
        template<typename, typename = std::void_t<>>
        struct HasBaseType : std::false_type {};
 
        template<typename T>
        struct HasBaseType<T, std::void_t<typename T::BaseType>> : std::true_type {};
        
        template<typename T, bool = HasBaseType<T>::value>
        struct BaseOrSelf {
            using type = T;
        };
 
        template<typename T>
        struct BaseOrSelf<T, true> {
            using type = typename T::BaseType;
        };
 
        private:
            Scene::Scene* mScene;
            
            std::unordered_map<size_t, IComponentStorage*> mStorages;
            std::unordered_map<EntityID, std::set<std::string>> mTags;
            std::queue<EntityID> mAvailableEntityIDs;
            std::set<EntityID> mLivingEntities;

            template<typename T>
            ComponentStorage<T>* GetOrCreateStorage() {
                size_t tid = GetComponentTypeID<T>();
 
                if(mStorages.find(tid) == mStorages.end()) {
                    mStorages[tid] = new ComponentStorage<T>();
                }
 
                return static_cast<ComponentStorage<T>*>(mStorages[tid]);
            }

            template<typename T>
            ComponentStorage<T>* GetStorage() {
                size_t tid = GetComponentTypeID<T>();
                
                if(mStorages.find(tid) != mStorages.end()) {
                    return static_cast<ComponentStorage<T>*>(mStorages[tid]);
                }
 
                return nullptr;
            }
 
        public:
            Registry();

            void Print();

            Scene::Scene& GetScene();
 
            /* ECS Registry Public Section => Lifecycle of entities and systems */
            
            EntityID CreateEntity();

            template<typename... Components>
            EntityID CreateEntityWith() {
                EntityID id = CreateEntity();
                (AddComponent<Components>(id), ...); // C++17 fold expression
                return id;
            }

            void DestroyEntity(EntityID entityID);

            bool IsValidEntity(EntityID entityID);

            void Clear();

            template <typename... TComponents>
            std::vector<EntityID> GetEntityIDsWith() {
                std::vector<EntityID> result;
 
                if(sizeof...(TComponents) == 0) return result;
 
                // On récupère le premier stockage pour itérer sur une base minimale
                auto* baseStorage = GetStorage<std::tuple_element_t<0, std::tuple<TComponents...>>>();
                if(!baseStorage) return result;
 
                for (const auto& [entityID, _] : baseStorage->GetRaw()) {
                    if ((HasComponent<TComponents>(entityID) && ...)) {
                        result.push_back(entityID);
                    }
                }
 
                return result;
            }

            EntityID GetEntityIDWithTag(std::string targetTag);
            
            std::vector<EntityID> GetEntityIDsWithTag(std::string targetTag);
 
            /* COMPONENT MANAGER PUBLIC SECTION */
            template <typename T, typename... Args>
            void AddComponent(EntityID entityID, Args&&... args) {
                using Base = typename BaseOrSelf<T>::type;
 
                GetOrCreateStorage<Base>()->Add(entityID, new T(std::forward<Args>(args)...));
            }

            template <typename T>
            void RemoveComponent(EntityID entityID) {
                using Base = typename BaseOrSelf<T>::type;
 
                auto storage = GetStorage<Base>();
                if (storage) {
                    storage->Remove(entityID);
                }
            }

            template <typename T>
            inline size_t GetComponentTypeID() {
                static const size_t tid = nextComponentTypeId++;
                return tid;
            }

            template <typename T>
            T& GetComponent(EntityID entityID) {
                using Base = typename BaseOrSelf<T>::type;
 
                auto* storage = GetStorage<Base>();
                if(!storage) throw std::runtime_error("Registry::GetComponent<T>: no storage for component type");
                return static_cast<T&>(storage->GetRef(entityID));
            }

            template<typename T>
            std::vector<T*> GetComponents(EntityID entityID) {
                using Base = typename BaseOrSelf<T>::type;
 
                auto* storage = GetStorage<Base>();
                if(!storage) throw std::runtime_error("Registry::GetComponents<T>: no storage for component type");
                return (storage->GetMany(entityID));            
            }

            template <typename T>
            bool HasComponent(EntityID entityID) {
                using Base = typename BaseOrSelf<T>::type;
 
                auto *storage = GetStorage<Base>();
                return storage && !!storage->Get(entityID);
            }
 
            // Tags management
            void AddTag(EntityID entityID, std::string tag);

            bool HasTag(EntityID entityID, std::string tag);

            std::set<std::string> GetTags(EntityID entityID);

            void AddChild(EntityID parentID, EntityID childID);

            void RemoveChild(EntityID parentID, EntityID childID, bool removeComponents = true);
    };
}