Ecs.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncengine/ecs/AccessPolicy.h"
 
namespace nc::ecs
{
template<FilterBase Base, class... Includes>
class EcsInterface
{
    public:
        using PolicyType = AccessPolicy<Base, Includes...>;
        using FilterType = typename PolicyType::FilterType;
 
        explicit EcsInterface(AccessPolicy<Base, Includes...> policy) noexcept
            : m_policy{policy} {}
 
        template<FilterBase TargetBase, class... TargetIncludes>
            requires PolicyType::template ConvertibleTo<TargetBase, TargetIncludes...>
        operator EcsInterface<TargetBase, TargetIncludes...>() const noexcept
        {
            return EcsInterface<TargetBase, TargetIncludes...>(m_policy);
        }
 
        template<std::same_as<Entity> T>
            requires PolicyType::template HasAccess<Entity, Transform, Tag, Hierarchy>
        auto Emplace(EntityInfo info = {}) -> Entity
        {
            const auto handle = m_policy.template GetPool<Entity>().Add(info.layer, info.flags, info.userData);
            if (info.parent.Valid())
            {
                auto& parentTransform = Get<Transform>(info.parent);
                Emplace<Transform>(handle, info.position, info.rotation, info.scale, parentTransform.TransformationMatrix());
                Get<Hierarchy>(info.parent).children.push_back(handle);
            }
            else
            {
                Emplace<Transform>(handle, info.position, info.rotation, info.scale);
            }
 
            Emplace<Hierarchy>(handle, info.parent, std::vector<Entity>{});
            Emplace<Tag>(handle, std::move(info.tag));
            return handle;
        }
 
        template<Component T, class... Args>
            requires PolicyType::template HasAccess<T>
        auto Emplace(Entity entity, Args&&... args) -> T&
        {
            NC_ASSERT(Contains<Entity>(entity), "Bad entity");
            if constexpr (std::derived_from<T, FreeComponent>)
            {
                return m_policy.GetFreeComponentPool().template Emplace<T>(entity, std::forward<Args>(args)...);
            }
            else
            {
                return m_policy.template GetPool<T>().Emplace(entity, std::forward<Args>(args)...);
            }
        }
 
        template<std::same_as<Entity> T>
            requires PolicyType::template HasAccess<Entity, Transform>
        auto Remove(Entity entity) -> bool
        {
            return Contains<Entity>(entity) ? RemoveNode<true>(entity) : false;
        }
 
        template<Component T>
            requires PolicyType::template HasAccess<T>
        auto Remove(Entity entity) -> bool
        {
            if (!Contains<Entity>(entity))
                return false;
 
            if constexpr (std::derived_from<T, FreeComponent>)
            {
                return m_policy.GetFreeComponentPool().template Remove<T>(entity);
            }
            else
            {
                return m_policy.template GetPool<T>().Remove(entity);
            }
        }
 
        template<Component T>
            requires PolicyType::template HasAccess<T>
        auto Get(Entity entity) -> T&
        {
            if constexpr (std::derived_from<T, FreeComponent>)
            {
                return m_policy.GetFreeComponentPool().template Get<T>(entity);
            }
            else
            {
                return m_policy.template GetPool<T>().Get(entity);
            }
        }
 
        template<Component T>
            requires PolicyType::template HasAccess<T>
        auto Get(Entity entity) const -> const T&
        {
            if constexpr (std::derived_from<T, FreeComponent>)
            {
                return m_policy.GetFreeComponentPool().template Get<T>(entity);
            }
            else
            {
                return m_policy.template GetPool<T>().Get(entity);
            }
        }
 
        auto GetEntityByTag(std::string_view tagValue) -> Entity
            requires PolicyType::template HasAccess<Entity>
                  && PolicyType::template HasAccess<Tag>
        {
            const auto tags = GetAll<Tag>();
            const auto pos = std::ranges::find(tags, tagValue, [](const auto& tag) { return tag.value; });
            NC_ASSERT(pos != std::ranges::end(tags), fmt::format("No Entity found with Tag '{}'", tagValue));
            return m_policy.template GetPool<Tag>().GetParent(&(*pos));
        }
 
        template<class T>
            requires PolicyType::template HasAccess<T>
                 && (PooledComponent<T> || std::same_as<Entity, T>)
        auto GetAll() -> std::span<T>
        {
            return std::span<T>{GetPool<T>()};
        }
 
        template<class T>
            requires PolicyType::template HasAccess<T>
                 && (PooledComponent<T> || std::same_as<Entity, T>)
        auto GetAll() const -> std::span<const T>
        {
            return std::span<const T>{GetPool<T>()};
        }
 
        template<class T>
            requires PolicyType::template HasAccess<T>
                && (PooledComponent<T> || std::same_as<Entity, T>)
        auto GetPool() -> decltype(auto)
        {
            return m_policy.template GetPool<T>();
        }
 
        template<class T>
            requires PolicyType::template HasAccess<T>
                && (PooledComponent<T> || std::same_as<Entity, T>)
        auto GetPool() const -> decltype(auto)
        {
            return m_policy.template GetPool<T>();
        }
 
        auto GetComponentPools()
            requires PolicyType::template BaseContains<FilterBase::All>
        {
            return m_policy.GetComponentPools();
        }
 
        void SetParent(Entity entity, Entity parent)
            requires PolicyType::template HasAccess<Hierarchy>
        {
            auto& hierarchy = Get<Hierarchy>(entity);
            const auto oldParent = std::exchange(hierarchy.parent, parent);
            if (oldParent.Valid())
            {
                std::erase(Get<Hierarchy>(oldParent).children, entity);
            }
 
            if (parent.Valid())
            {
                Get<Hierarchy>(parent).children.push_back(entity);
            }
        }
 
        auto GetRoot(Entity entity) -> Entity
            requires PolicyType::template HasAccess<Hierarchy>
        {
            const auto& hierarchy = Get<Hierarchy>(entity);
            return !hierarchy.parent.Valid() ? entity : GetRoot(hierarchy.parent);
        }
 
        template<PooledComponent T>
            requires PolicyType::template HasAccess<T>
        auto GetParent(const T* component) const -> Entity
        {
            return m_policy.template GetPool<T>().GetParent(component);
        }
 
        template<RegistryType T>
            requires PolicyType::template HasAccess<T>
        auto Contains(Entity entity) const -> bool
        {
            if constexpr (std::derived_from<T, FreeComponent>)
            {
                return m_policy.GetFreeComponentPool().template Contains<T>(entity);
            }
            else
            {
                return m_policy.template GetPool<T>().Contains(entity);
            }
        }
 
    private:
        PolicyType m_policy;
 
        template<bool IsRoot>
        auto RemoveNode(Entity entity) -> bool
        {
            auto& hierarchy = Get<Hierarchy>(entity);
            if constexpr(IsRoot)
            {
                if (hierarchy.parent.Valid())
                {
                    std::erase(Get<Hierarchy>(hierarchy.parent).children, entity);
                }
            }
 
            for (auto child : hierarchy.children)
                RemoveNode<false>(child);
 
            m_policy.template GetPool<Entity>().Remove(entity);
            return true;
        }
};
 
using Ecs = EcsInterface<FilterBase::All>;
 
template<class... Includes>
using BasicEcs = EcsInterface<FilterBase::Basic, Includes...>;
 
template<class... Includes>
using ExplicitEcs = EcsInterface<FilterBase::None, Includes...>;
} // namespace nc::ecs