ComponentRegistry.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncengine/ecs/ComponentPool.h"
#include "ncengine/ecs/EntityPool.h"
#include "ncengine/ecs/FreeComponentPool.h"
 
namespace nc::ecs
{
class ComponentRegistry : public StableAddress
{
    public:
        explicit ComponentRegistry(size_t entityCapacity)
            : m_entities{entityCapacity},
              m_freePool{entityCapacity},
              m_maxEntities{entityCapacity}
        {
            NC_ASSERT(!s_init, "There may only be one ComponentRegistry instance.");
            s_init = true;
        }
 
        ~ComponentRegistry() noexcept
        {
            std::ranges::for_each(m_refs, [](auto&& p) { *p = nullptr; });
            s_init = false;
        }
 
        template<PooledComponent T>
        void RegisterType(size_t capacity, ComponentHandler<T> handler = {})
        {
            NC_ASSERT(capacity <= m_maxEntities, "Component capacity cannot exceed entity capapcity.");
            NC_ASSERT(!s_typedPool<T>, "Type already registered.");
            SetupId(handler.id);
            SetupStorage<T>(std::make_unique<ComponentPool<T>>(capacity, std::move(handler)));
        }
 
        template<PooledComponent T>
        auto IsTypeRegistered() const noexcept -> bool
        {
            return s_typedPool<T> != nullptr;
        }
 
        auto IsTypeRegistered(size_t id) const noexcept -> bool
        {
            return std::ranges::contains(m_pools, id, [](const auto& pool) { return pool->Id(); });
        }
 
        template<PooledComponent T>
        auto GetPool() -> ComponentPool<T>&
        {
            NC_ASSERT(s_typedPool<T>, "Attempt to access an unregistered type.");
            return *s_typedPool<T>;
        }
 
        template<PooledComponent T>
        auto GetPool() const -> const ComponentPool<T>&
        {
            NC_ASSERT(s_typedPool<T>, "Attempt to access an unregistered type.");
            return *s_typedPool<T>;
        }
 
        auto GetPool(size_t id) -> ComponentPoolBase&
        {
            auto pos = std::ranges::find_if(m_pools, [id](auto&& pool) { return pool->Id() == id; });
            NC_ASSERT(pos != std::ranges::end(m_pools), "Attempt to access an unregistered type.");
            return **pos;
        }
 
        auto GetPool(size_t id) const -> ComponentPoolBase&
        {
            auto pos = std::ranges::find_if(m_pools, [id](auto&& pool) { return pool->Id() == id; });
            NC_ASSERT(pos != std::ranges::end(m_pools), "Attempt to access an unregistered type.");
            return **pos;
        }
 
        auto GetFreeComponentPool() -> FreeComponentPool& { return m_freePool; }
 
        template<std::same_as<Entity> T>
        auto GetPool() -> EntityPool& { return m_entities; }
 
        template<std::same_as<Entity> T>
        auto GetPool() const -> const EntityPool& { return m_entities; }
 
        auto GetComponentPools()
        {
            return m_pools | std::views::transform(&std::unique_ptr<ComponentPoolBase>::get);
        }
 
        auto GetMaxEntities() const noexcept { return m_maxEntities; }
 
        void CommitPendingChanges()
        {
            const auto removed = m_entities.RecycleDeadEntities();
            std::ranges::for_each(m_pools, [&removed](auto&& p) { p->CommitStagedComponents(removed); });
            m_freePool.CommitStagedComponents(removed);
        }
 
        void ClearSceneData()
        {
            std::ranges::for_each(m_pools, [](auto&& p) { p->ClearNonPersistent(); });
            m_freePool.ClearNonPersistent();
            m_entities.ClearNonPersistent();
        }
 
        void Clear()
        {
            std::ranges::for_each(m_pools, [](auto&& p) { p->Clear(); });
            m_freePool.Clear();
            m_entities.Clear();
        }
 
    private:
        std::vector<std::unique_ptr<ComponentPoolBase>> m_pools;
        EntityPool m_entities;
        FreeComponentPool m_freePool;
        std::vector<void**> m_refs;
        size_t m_maxEntities;
        size_t m_nextComponentId = std::numeric_limits<size_t>::max();
 
        template<PooledComponent T>
        inline static ComponentPool<T>* s_typedPool = nullptr;
 
        inline static bool s_init = false;
 
        void SetupId(size_t& id)
        {
            if (id == 0ull)
                id = m_nextComponentId--; // will collide and throw before underflowing
 
            if (IsTypeRegistered(id))
                throw NcError(fmt::format("ComponentId '{}' is already in use.", id));
        }
 
        template<PooledComponent T>
        void SetupStorage(std::unique_ptr<ComponentPool<T>> pool) noexcept
        {
            s_typedPool<T> = pool.get();
            m_refs.emplace_back(reinterpret_cast<void**>(&s_typedPool<T>));
            m_pools.push_back(std::move(pool));
        }
};
} // namespace nc::ecs