EntityPool.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncengine/ecs/detail/HandleManager.h"
#include "ncengine/ecs/detail/PoolUtility.h"
#include "ncengine/type/StableAddress.h"
#include "ncengine/utility/SparseMap.h"
 
#include "ncutility/NcError.h"
 
#include <algorithm>
#include <vector>
 
namespace nc::ecs
{
class EntityPool : public StableAddress
{
    public:
        using value_type = Entity;
        using iterator = std::vector<Entity>::iterator;
        using const_iterator = std::vector<Entity>::const_iterator;
        using reverse_iterator = std::vector<Entity>::reverse_iterator;
 
        explicit EntityPool(size_t maxEntities)
            : m_entities{maxEntities / 4u, maxEntities} {}
 
        auto Add(Entity::layer_type layer,
                 Entity::flags_type flags,
                 Entity::user_data_type userData) -> Entity
        {
            const auto handle = m_handleManager.GenerateNewHandle(layer, flags, userData);
            m_entities.emplace(handle.Index(), handle);
            if(handle.IsPersistent())
                m_persistent.push_back(handle);
 
            return handle;
        }
 
        void Remove(Entity entity)
        {
            m_toRemove.push_back(entity);
            m_entities.erase(entity.Index());
            if (entity.IsPersistent())
                detail::EraseUnstable(m_persistent, entity);
        }
 
        bool Contains(Entity entity) const
        {
            return m_entities.contains(entity.Index());
        }
 
        auto Size() const noexcept -> size_t { return m_entities.size(); }
 
        auto RecycleDeadEntities() -> std::vector<Entity>
        {
            if(m_toRemove.empty())
                return {};
 
            m_handleManager.ReclaimHandles(m_toRemove);
            return std::exchange(m_toRemove, std::vector<Entity>{});
        }
 
        void Clear()
        {
            m_entities.clear();
            m_toRemove.clear();
            m_toRemove.shrink_to_fit();
            m_persistent.clear();
            m_persistent.shrink_to_fit();
            m_handleManager.Reset({});
        }
 
        void ClearNonPersistent()
        {
            m_toRemove.shrink_to_fit();
            m_persistent.shrink_to_fit();
            m_entities.clear();
            for (auto entity : m_persistent)
            {
                m_entities.emplace(entity.Index(), entity);
            }
 
            m_handleManager.Reset(m_persistent);
        }
 
        auto begin() noexcept { return std::ranges::begin(m_entities); }
 
        auto begin() const noexcept { return std::ranges::begin(m_entities); }
 
        auto end() noexcept { return std::ranges::end(m_entities); }
 
        auto end() const noexcept { return std::ranges::end(m_entities); }
 
        auto size() const noexcept { return m_entities.size(); }
 
        [[nodiscard]] auto empty() const noexcept { return m_entities.empty(); }
 
        auto operator[](size_t pos) noexcept -> Entity& { return m_entities.values()[pos]; }
 
        auto operator[](size_t pos) const noexcept -> const Entity& { return m_entities.values()[pos]; }
 
        auto at(size_t pos) -> Entity&
        {
            if (pos >= m_entities.size())
            {
                throw NcError{"Access out of bounds"};
            }
 
            return m_entities.values()[pos];
        }
 
        auto at(size_t pos) const -> const Entity&
        {
            if (pos >= m_entities.size())
            {
                throw NcError{"Access out of bounds"};
            }
 
            return m_entities.values()[pos];
        }
 
        auto data() noexcept { return m_entities.values().data(); }
 
        auto data() const noexcept { return m_entities.values().data(); }
 
    private:
        sparse_map<Entity> m_entities;
        std::vector<Entity> m_toRemove;
        std::vector<Entity> m_persistent;
        detail::HandleManager m_handleManager;
};
} // namespace nc::ecs