scene.h

#pragma once
 
#include <cstdint>
#include <memory>
#include <tuple>
#include <utility>
#include <vector>
 
#include "l_assert.h"
 
#include "ecs/component/core/hierarchy.h"
#include "core/memory/type_registry.h"
#include "ecs/environment.h"
#include "ecs/physics_settings.h"
#include "ecs/entity.h"
#include "ecs/scene_observer.h"
#include "core/memory/slot_allocator.h"
#include "core/memory/sparse_set.h"
#include "core/memory/types.h"
 
namespace Vkm::Engine {

class Scene {
    public:
        Scene() = default;
        ~Scene() = default;
 
        Scene(const Scene& other) = delete;
        Scene& operator=(const Scene& other) = delete;
 
        Scene(Scene && other) = delete;
        Scene& operator=(Scene && other) = delete;
 
    public:
        EntityId createEntity() {
            bool recycled = false;
            const EntityId id{m_entityAllocator.allocate(&recycled)};
            if (recycled) {
                m_components.forEach([&](ISparseSet& set) { set.removeIfPresent(id.slot()); });
            }
            return id;
        }

        EntityId createEntityAt(uint32_t index) {
            const EntityId id{m_entityAllocator.allocateAt(index)};
            if (id) {
                m_components.forEach([&](ISparseSet& set) { set.removeIfPresent(id.slot()); });
            }
            return id;
        }

        void destroyEntity(EntityId id) {
            VKM_ASSERT(isAlive(id), "Scene::destroyEntity called with dead/stale entity");
            if (!isAlive(id)) return;
 
            // Before tear-down, while the entity and its components are still intact.
            for (ISceneObserver* observer : m_observers) {
                observer->onEntityDestroyed(id);
            }
            detachFromHierarchy(*this, id);
 
            m_components.forEach([&](ISparseSet& set) { set.removeIfPresent(id.slot()); });
            m_entityAllocator.free(id.key);
        }
 
        bool isAlive(EntityId id)           const { return m_entityAllocator.has(id.key); }
        bool isAliveAtIndex(uint32_t index) const { return m_entityAllocator.isAliveAtIndex(index); }
        size_t entityCount()                const { return m_entityAllocator.size(); }

        EntityId entityAt(uint32_t index) const {
            return EntityId{m_entityAllocator.handleAt(index)};
        }
 
    public:
        template<typename T>
        auto& add(EntityId entity, T && component) {
            VKM_ASSERT(isAlive(entity), "Scene::add called with dead/stale entity");
            using U = std::remove_cv_t<std::remove_reference_t<T>>;
            VKM_ASSERT(!has<U>(entity), "Scene::add: entity already carries this component type");
            return getStorage<U>().add(entity.slot(), std::forward<T>(component));
        }

        template<typename T>
        void remove(EntityId entity) {
            VKM_ASSERT(isAlive(entity), "Scene::remove called with dead/stale entity");
            if (!isAlive(entity)) return;
            auto* store = findStorage<T>();
            if (store && store->contains(entity.slot())) {
                store->remove(entity.slot());
            }
        }

        template<typename T>
        bool has(EntityId entity) const {
            if (!isAlive(entity)) return false;
            auto* store = findStorage<T>();
            return store && store->contains(entity.slot());
        }

        template<typename T>
        T& get(EntityId entity) {
            VKM_ASSERT(isAlive(entity), "Scene::get called with dead/stale entity");
            auto* store = findStorage<T>();
            VKM_ASSERT(store, "Scene::get called for unregistered component type");
            return store->get(entity.slot());
        }

        template<typename T>
        const T& get(EntityId entity) const {
            VKM_ASSERT(isAlive(entity), "Scene::get called with dead/stale entity");
            auto* store = findStorage<T>();
            VKM_ASSERT(store, "Scene::get called for unregistered component type");
            return store->get(entity.slot());
        }

        template<typename T>
        T* tryGet(EntityId entity) {
            if (!isAlive(entity)) return nullptr;
            auto* store = findStorage<T>();
            if (!store || !store->contains(entity.slot())) return nullptr;
            return &store->get(entity.slot());
        }

        template<typename T>
        const T* tryGet(EntityId entity) const {
            if (!isAlive(entity)) return nullptr;
            const auto* store = findStorage<T>();
            if (!store || !store->contains(entity.slot())) return nullptr;
            return &store->get(entity.slot());
        }

        template<typename T>
        size_t count() const {
            auto* store = findStorage<T>();
            return store ? store->size() : 0;
        }
 
    public:
        template<typename First, typename... Rest, typename Fn>
        void forEach(Fn&& fn) {
            // findStorage: creating the set here would flip a later storage<T>()
            // from null, which a caller may branch on.
            auto* firstStorage = findStorage<First>();
            if (!firstStorage) return;
 
            if constexpr (sizeof...(Rest) == 0) {
                firstStorage->forEach([&](uint32_t entityIdx, First& first) {
                    EntityId eid = entityAt(entityIdx);
                    fn(eid, first);
                });
            } else {
                auto restStorages = std::make_tuple(findStorage<Rest>()...);
                if (!(std::get<SparseSet<Rest>*>(restStorages) && ...)) return;
 
                firstStorage->forEach([&](uint32_t entityIdx, First& first) {
                    if (!(std::get<SparseSet<Rest>*>(restStorages)->contains(entityIdx) && ...)) return;
 
                    EntityId eid = entityAt(entityIdx);
                    fn(eid, first, std::get<SparseSet<Rest>*>(restStorages)->get(entityIdx)...);
                });
            }
        }
 
        template<typename First, typename... Rest, typename Fn>
        void forEach(Fn&& fn) const {
            auto* firstStorage = findStorage<First>();
            if (!firstStorage) return;
 
            if constexpr (sizeof...(Rest) == 0) {
                firstStorage->forEach([&](uint32_t entityIdx, const First& first) {
                    EntityId eid = entityAt(entityIdx);
                    fn(eid, first);
                });
            } else {
                auto restStorages = std::make_tuple(findStorage<Rest>()...);
                if (!(std::get<const SparseSet<Rest>*>(restStorages) && ...)) return;
 
                firstStorage->forEach([&](uint32_t entityIdx, const First& first) {
                    if (!(std::get<const SparseSet<Rest>*>(restStorages)->contains(entityIdx) && ...)) return;
 
                    EntityId eid = entityAt(entityIdx);
                    fn(eid, first, std::get<const SparseSet<Rest>*>(restStorages)->get(entityIdx)...);
                });
            }
        }

        template<typename Fn>
        void forEachEntity(Fn&& fn) const {
            m_entityAllocator.forEach([&](uint32_t idx) {
                fn(entityAt(idx));
            });
        }
 
    public:
        void clear() {
            // Every entity goes at once, so no detachFromHierarchy is needed.
            m_components.clear();
            m_entityAllocator.clear();
            m_environment = Environment{};
            m_physics     = PhysicsSettings{};
            ++m_epoch;
        }

        void compact() {
            m_components.forEach([](ISparseSet& set) { set.compact(); });
        }

        void swap(Scene& other) noexcept {
            using std::swap;
            m_entityAllocator.swap(other.m_entityAllocator);
            m_components.swap(other.m_components);
            swap(m_environment, other.m_environment);
            swap(m_physics, other.m_physics);
            ++m_epoch;
            ++other.m_epoch;
        }

        void addObserver(ISceneObserver* observer) {
            m_observers.push_back(observer);
        }

        void removeObserver(ISceneObserver* observer) {
            for (auto it = m_observers.begin(); it != m_observers.end(); ++it) {
                if (*it == observer) {
                    m_observers.erase(it);
                    return;
                }
            }
        }
 
    public:
        template<typename T>
        SparseSet<T>* storage() { return findStorage<T>(); }
 
        template<typename T>
        const SparseSet<T>* storage() const { return findStorage<T>(); }

        uint64_t epoch() const { return m_epoch; }

        Environment& environment() { return m_environment; }
        const Environment& environment() const { return m_environment; }

        PhysicsSettings& physics() { return m_physics; }
        const PhysicsSettings& physics() const { return m_physics; }
 
    private:
        template<typename T>
        SparseSet<T>& getStorage() {
            ISparseSet& base = m_components.ensure<T>([] { return std::make_unique<SparseSet<T>>(); });
            return static_cast<SparseSet<T>&>(base);
        }

        template<typename T>
        SparseSet<T>* findStorage() {
            return static_cast<SparseSet<T>*>(m_components.find<T>());
        }
 
        template<typename T>
        const SparseSet<T>* findStorage() const {
            return static_cast<const SparseSet<T>*>(m_components.find<T>());
        }
 
    private:
        Environment     m_environment;
        PhysicsSettings m_physics;
 
        uint64_t m_epoch = 0;
 
        SlotAllocator m_entityAllocator;
        TypeRegistry<ISparseSet> m_components;
        std::vector<ISceneObserver*> m_observers;  
};

template <typename First, typename... Rest, typename Pred>
EntityId findLowestSlot(const Scene& scene, Pred pred) {
    EntityId found{};
    scene.forEach<First, Rest...>([&](EntityId id, const First& first, const Rest&... rest) {
        if (!pred(first, rest...)) return;
        if (!found || id.slot() < found.slot()) found = id;
    });
    return found;
}
 
} // namespace Vkm::Engine