ComponentPool.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncengine/ecs/AnyComponent.h"
#include "ncengine/ecs/detail/PoolUtility.h"
#include "ncengine/ecs/detail/SparseSet.h"
#include "ncengine/type/StableAddress.h"
#include "ncengine/utility/Signal.h"
 
#include "ncutility/NcError.h"
 
#include <cassert>
#include <string_view>
 
namespace nc::ecs
{
class ComponentPoolBase : public StableAddress
{
    public:
        using entity_iterator = std::span<const Entity>::iterator;
 
        virtual ~ComponentPoolBase() = default;
 
        virtual auto Id() const noexcept -> size_t = 0;
 
        virtual auto Contains(Entity entity) const -> bool = 0;
 
        virtual auto GetAsAnyComponent(Entity entity) -> AnyComponent = 0;
 
        virtual auto Remove(Entity entity) -> bool = 0;
 
        virtual auto Size() const noexcept -> size_t = 0;
 
        virtual auto StagedSize() const noexcept -> size_t = 0;
 
        virtual auto TotalSize() const noexcept -> size_t = 0;
 
        virtual void Reserve(size_t capacity) = 0;
 
        virtual auto GetEntityPool() const noexcept -> std::span<const Entity> = 0;
 
        virtual auto GetComponentName() const noexcept -> std::string_view = 0;
 
        virtual auto HasFactory() const noexcept -> bool = 0;
 
        virtual auto HasUserData() const noexcept -> bool = 0;
 
        virtual auto HasSerialize() const noexcept -> bool = 0;
 
        virtual auto HasDrawUI() const noexcept -> bool = 0;
 
        virtual auto AddDefault(Entity entity) -> AnyComponent = 0;
 
        virtual void Serialize(std::ostream& stream, Entity entity, const SerializationContext& ctx) = 0;
 
        virtual void Deserialize(std::istream& stream, Entity entity, const DeserializationContext& ctx) = 0;
 
        virtual void ClearNonPersistent() = 0;
 
        virtual void Clear() = 0;
 
        virtual void CommitStagedComponents(const std::vector<Entity>& deleted) = 0;
};
 
template<PooledComponent T>
class ComponentPool final : public ComponentPoolBase
{
    public:
        using value_type = T;
        using iterator = std::vector<T>::iterator;
        using const_iterator = std::vector<T>::const_iterator;
        using reverse_iterator = std::vector<T>::reverse_iterator;
 
        explicit ComponentPool(size_t maxEntities, ComponentHandler<T> handler)
            : m_storage{maxEntities}, m_handler{std::move(handler)} {}
 
        template<class... Args>
        auto Emplace(Entity entity, Args&&... args) -> T&;
 
        auto Insert(Entity entity, T obj) -> T&;
 
        auto Get(Entity entity) -> T&;
 
        auto Get(Entity entity) const -> const T&;
 
        auto GetParent(const T* component) const -> Entity;
 
        auto GetComponents() noexcept -> std::span<T> { return m_storage.GetPackedArray(); }
 
        auto GetComponents() const noexcept -> std::span<const T> { return m_storage.GetPackedArray(); }
 
        auto Handler() noexcept -> ComponentHandler<T>& { return m_handler; }
 
        auto OnAdd() noexcept -> Signal<T&>&
            requires StoragePolicy<T>::EnableOnAddCallbacks
        {
            return m_onAdd;
        }
 
        auto OnCommit() noexcept -> Signal<T&>&
            requires StoragePolicy<T>::EnableOnCommitCallbacks
        {
            return m_onCommit;
        }
 
        auto OnRemove() noexcept -> Signal<Entity>&
            requires StoragePolicy<T>::EnableOnRemoveCallbacks
        {
            return m_onRemove;
        }
 
        template<std::predicate<const T&, const T&> Predicate>
        void Sort(Predicate&& compare);
 
        auto begin() noexcept { return std::ranges::begin(m_storage.GetPackedArray()); }
 
        auto begin() const noexcept { return std::ranges::begin(m_storage.GetPackedArray()); }
 
        auto end() noexcept { return std::ranges::end(m_storage.GetPackedArray()); }
 
        auto end() const noexcept { return std::ranges::end(m_storage.GetPackedArray()); }
 
        auto size() const noexcept { return Size(); }
 
        [[nodiscard]] auto empty() const noexcept { return GetComponents().empty(); }
 
        auto operator[](size_t pos) noexcept -> T& { return GetComponents()[pos]; }
 
        auto operator[](size_t pos) const noexcept -> const T& { return GetComponents()[pos]; }
 
        auto at(size_t pos) -> T& { return GetComponents().at(pos); }
 
        auto at(size_t pos) const -> const T& { return GetComponents().at(pos); }
 
        auto data() noexcept { return GetComponents().data(); }
 
        auto data() const noexcept { return GetComponents().data(); }
 
        auto Contains(Entity entity) const -> bool override;
        auto GetAsAnyComponent(Entity entity) -> AnyComponent override;
        auto Remove(Entity entity) -> bool override;
        auto Size() const noexcept -> size_t override { return m_storage.Size(); }
        auto StagedSize() const noexcept -> size_t override { return m_staging.size(); }
        auto TotalSize() const noexcept -> size_t override { return Size() + StagedSize(); }
        void Reserve(size_t capacity) override;
        auto GetEntityPool() const noexcept -> std::span<const Entity> override { return m_storage.GetEntities(); }
        auto GetComponentName() const noexcept -> std::string_view override { return m_handler.name; }
        auto HasFactory() const noexcept -> bool override { return m_handler.factory != nullptr; }
        auto HasUserData() const noexcept -> bool override { return m_handler.userData.has_value(); }
        auto HasSerialize() const noexcept -> bool override { return m_handler.serialize && m_handler.deserialize; }
        auto HasDrawUI() const noexcept -> bool override { return m_handler.drawUI != nullptr; }
        auto Id() const noexcept -> size_t override { return m_handler.id; };
        auto AddDefault(Entity entity) -> AnyComponent override;
        void Serialize(std::ostream& stream, Entity entity, const SerializationContext& ctx) override;
        void Deserialize(std::istream& stream, Entity entity, const DeserializationContext& ctx) override;
        void ClearNonPersistent() override;
        void Clear() override;
        void CommitStagedComponents(const std::vector<Entity>& deleted) override;
 
    private:
        ecs::detail::SparseSet<T> m_storage;
        std::vector<detail::StagedComponent<T>> m_staging;
        ComponentHandler<T> m_handler;
        Signal<T&> m_onAdd;
        Signal<T&> m_onCommit;
        Signal<Entity> m_onRemove;
};
 
template<PooledComponent T>
template<class... Args>
auto ComponentPool<T>::Emplace(Entity entity, Args&&... args) -> T&
{
    NC_ASSERT(entity.Index() < m_storage.MaxSize() && !Contains(entity), "Bad entity");
    auto& [_, component] = m_staging.emplace_back(
        entity,
        detail::Construct<T>(entity, std::forward<Args>(args)...)
    );
 
    if constexpr(StoragePolicy<T>::EnableOnAddCallbacks)
        m_onAdd.Emit(component);
 
    return component;
}
 
template<PooledComponent T>
auto ComponentPool<T>::Insert(Entity entity, T obj) -> T&
{
    NC_ASSERT(entity.Index() < m_storage.MaxSize() && !Contains(entity), "Bad entity");
    auto& [_, component] = m_staging.emplace_back(entity, std::move(obj));
 
    if constexpr(StoragePolicy<T>::EnableOnAddCallbacks)
        m_onAdd.Emit(component);
 
    return component;
}
 
template<PooledComponent T>
auto ComponentPool<T>::Remove(Entity entity) -> bool
{
    NC_ASSERT(entity.Valid(), "Bad entity");
    if (!m_storage.Remove(entity) && !detail::EraseUnstable(m_staging, entity))
        return false;
 
    if constexpr(StoragePolicy<T>::EnableOnRemoveCallbacks)
        m_onRemove.Emit(entity);
 
    return true;
}
 
template<PooledComponent T>
bool ComponentPool<T>::Contains(Entity entity) const
{
    return m_storage.Contains(entity)
        ? true
        : std::cend(m_staging) != std::ranges::find(m_staging, entity, &detail::StagedComponent<T>::entity);
}
 
template<PooledComponent T>
auto ComponentPool<T>::Get(Entity entity) -> T&
{
    NC_ASSERT(entity.Valid(), "Bad entity");
    if (m_storage.Contains(entity))
        return m_storage.Get(entity);
 
    auto pos = std::ranges::find(m_staging, entity, &detail::StagedComponent<T>::entity);
    NC_ASSERT(pos != std::cend(m_staging), "Component does not exist");
    return pos->component;
}
 
template<PooledComponent T>
auto ComponentPool<T>::Get(Entity entity) const -> const T&
{
    NC_ASSERT(entity.Valid(), "Bad entity");
    if (m_storage.Contains(entity))
        return m_storage.Get(entity);
 
    auto pos = std::ranges::find(m_staging, entity);
    NC_ASSERT(pos != std::cend(m_staging), "Component does not exist");
    return pos->component;
}
 
template<PooledComponent T>
auto ComponentPool<T>::GetAsAnyComponent(Entity entity) -> AnyComponent
{
    return Contains(entity) ? AnyComponent{&Get(entity), &m_handler} : AnyComponent{};
}
 
template<PooledComponent T>
auto ComponentPool<T>::GetParent(const T* component) const -> Entity
{
    if (auto parent = m_storage.GetParent(component); parent.Valid())
        return parent;
 
    const auto pos = std::ranges::find(m_staging, component, [](auto&& staged) { return &staged.component; });
    return pos != std::cend(m_staging) ? pos->entity : Entity::Null();
}
 
template<PooledComponent T>
template<std::predicate<const T&, const T&> Pred>
void ComponentPool<T>::Sort(Pred&& compare)
{
    m_storage.Sort(std::forward<Pred>(compare));
}
 
template<PooledComponent T>
void ComponentPool<T>::Reserve(size_t capacity)
{
    m_storage.Reserve(capacity);
    const auto existing = TotalSize();
    if (capacity > existing)
    {
        // We don't need to reserve the whole capacity for staging - we just
        // want to guarantee ptrs remain valid until we exceed capacity.
        m_staging.reserve(capacity - existing);
    }
}
 
template<PooledComponent T>
auto ComponentPool<T>::AddDefault(Entity entity) -> AnyComponent
{
    if (m_handler.factory)
    {
        auto& comp = Insert(entity, m_handler.factory(entity, m_handler.userData));
        return AnyComponent{&comp, &m_handler};
    }
 
    return AnyComponent{};
}
 
template<PooledComponent T>
void ComponentPool<T>::Serialize(std::ostream& stream, Entity entity, const SerializationContext& ctx)
{
    NC_ASSERT(HasSerialize() && Contains(entity), "Component does not exist or is not serializable");
    m_handler.serialize(stream, Get(entity), ctx, m_handler.userData);
}
 
template<PooledComponent T>
void ComponentPool<T>::Deserialize(std::istream& stream, Entity entity, const DeserializationContext& ctx)
{
    NC_ASSERT(HasSerialize(), "Component is not serializable");
    Insert(entity, m_handler.deserialize(stream, ctx, m_handler.userData));
}
 
template<PooledComponent T>
void ComponentPool<T>::CommitStagedComponents(const std::vector<Entity>& deleted)
{
    for(auto entity : deleted)
        Remove(entity);
 
    for(auto& [entity, component] : m_staging)
    {
        [[maybe_unused]] auto& committed = m_storage.Insert(entity, std::move(component));
        if constexpr (StoragePolicy<T>::EnableOnCommitCallbacks)
            m_onCommit(committed);
    }
 
    m_staging.clear();
}
 
template<PooledComponent T>
void ComponentPool<T>::ClearNonPersistent()
{
    m_staging.clear();
    m_staging.shrink_to_fit();
    m_storage.ClearNonPersistent();
}
 
template<PooledComponent T>
void ComponentPool<T>::Clear()
{
    m_staging.clear();
    m_staging.shrink_to_fit();
    m_storage.Clear();
}
} // namespace nc::ecs