scene.h

#pragma once
 
#include "pixelbullet/core/assert.h"
#include "pixelbullet/scene/component_storage.h"
#include "pixelbullet/scene/entity_id.h"
#include "pixelbullet/scene/scene_environment_settings.h"
#include "pixelbullet/serialization/node_reader.h"
 
#include <cstdint>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <vector>
 
namespace pixelbullet
{
class SceneSerializer;
 
enum class SceneComponentDefaults
{
    None,
    Engine,
};
 
class Scene
{
public:
    explicit Scene(SceneComponentDefaults defaults = SceneComponentDefaults::Engine);
 
    EntityId CreateEntity();
    void DestroyEntity(EntityId entity_id);
 
    [[nodiscard]] bool IsAlive(EntityId entity_id) const
    {
        return entity_id.Index() < entities_.size() && entities_[entity_id.Index()] == entity_id;
    }
 
    [[nodiscard]] std::vector<EntityId> GetEntities() const
    {
        std::vector<EntityId> entities;
        entities.reserve(entities_.size());
        for (const EntityId entity : entities_)
        {
            if (entity)
            {
                entities.push_back(entity);
            }
        }
        return entities;
    }
 
    template <typename T, typename... Args>
    T& AddComponent(EntityId entity_id, Args&&... args)
    {
        ASSERT(IsAlive(entity_id), "Cannot add component to stale or invalid entity");
        auto storage = GetOrCreateComponentStorage<T>();
        T& component = storage->components.emplace(entity_id.Index(), std::forward<Args>(args)...);
        ++mutation_generation_;
        return component;
    }
 
    template <typename T>
    void RemoveComponent(EntityId entity_id)
    {
        ASSERT(IsAlive(entity_id), "Cannot remove component from stale or invalid entity");
        auto* storage = TryGetComponentStorage<T>();
        if (storage && storage->components.erase(entity_id.Index()))
        {
            ++mutation_generation_;
        }
    }
 
    template <typename T>
    bool HasComponent(EntityId entity_id) const
    {
        if (!IsAlive(entity_id))
        {
            return false;
        }
 
        const auto type_id = std::type_index(typeid(T));
        auto it = component_storage_.find(type_id);
        if (it != component_storage_.end())
        {
            const auto* storage = static_cast<const ComponentStorage<T>*>(it->second.get());
            return storage->components.contains(entity_id.Index());
        }
        return false;
    }
 
    template <typename T>
    void RegisterComponent(std::string_view serialization_name)
    {
        auto safe_deserialize = [](T& component, const Node& node, const std::string_view diagnostic_path) -> SerializationResult
        {
            if constexpr (serialization::NodeReadable<T>)
            {
                serialization::NodeReader reader{ std::string(diagnostic_path) };
                if (!TryReadNode(node, component, reader))
                {
                    return reader.ToResult();
                }
                return SerializationResult{ true, {} };
            }
            else
            {
                (void)component;
                (void)node;
                return SerializationResult{
                    false,
                    "Component type '" + std::string(typeid(T).name()) + "' does not support safe deserialization.",
                    { SerializationDiagnostic{ .path = std::string(diagnostic_path),
                                               .message = "Component type does not support safe deserialization." } },
                };
            }
        };
        RegisterComponentType(std::type_index(typeid(T)), std::string(serialization_name),
                              [safe_deserialize]() { return std::make_unique<ComponentStorage<T>>(safe_deserialize); });
    }
 
    void RegisterComponentTypesFrom(const Scene& source);
    [[nodiscard]] std::vector<std::string> GetRegisteredComponentNames() const;
 
    template <typename T>
    T& GetComponent(EntityId entity_id)
    {
        T* component = TryGetComponent<T>(entity_id);
        ASSERT(component, "Component not found");
        return *component;
    }
 
    template <typename T>
    const T& GetComponent(EntityId entity_id) const
    {
        const T* component = TryGetComponent<T>(entity_id);
        ASSERT(component, "Component not found");
        return *component;
    }
 
    template <typename T>
    T* TryGetComponent(EntityId entity_id)
    {
        if (!IsAlive(entity_id))
        {
            return nullptr;
        }
 
        auto* storage = TryGetComponentStorage<T>();
        if (!storage || !storage->components.contains(entity_id.Index()))
        {
            return nullptr;
        }
 
        return &storage->components.at(entity_id.Index());
    }
 
    template <typename T>
    const T* TryGetComponent(EntityId entity_id) const
    {
        if (!IsAlive(entity_id))
        {
            return nullptr;
        }
 
        const auto* storage = TryGetComponentStorage<T>();
        if (!storage || !storage->components.contains(entity_id.Index()))
        {
            return nullptr;
        }
 
        return &storage->components.at(entity_id.Index());
    }
 
    template <typename T>
    const SparseSet<T>& GetComponentSet() const
    {
        const auto type_id = std::type_index(typeid(T));
        auto it = component_storage_.find(type_id);
        if (it != component_storage_.end())
        {
            const auto* storage = static_cast<const ComponentStorage<T>*>(it->second.get());
            return storage->components;
        }
        throw std::runtime_error("Component not found");
    }
 
    template <typename T, typename Func>
    void Each(Func&& func)
    {
        auto* storage = TryGetComponentStorage<T>();
        if (!storage)
        {
            return;
        }
 
        for (const auto& entry : storage->components)
        {
            if (entry.id >= entities_.size())
            {
                continue;
            }
 
            const EntityId entity = entities_[entry.id];
            if (!entity)
            {
                continue;
            }
 
            func(entity, storage->components.at(entry.id));
        }
    }
 
    template <typename T, typename Func>
    void Each(Func&& func) const
    {
        const auto* storage = TryGetComponentStorage<T>();
        if (!storage)
        {
            return;
        }
 
        for (const auto& entry : storage->components)
        {
            if (entry.id >= entities_.size())
            {
                continue;
            }
 
            const EntityId entity = entities_[entry.id];
            if (!entity)
            {
                continue;
            }
 
            func(entity, storage->components.at(entry.id));
        }
    }
 
    SceneEnvironmentSettings& GetEnvironmentSettings() noexcept
    {
        return environment_settings_;
    }
 
    const SceneEnvironmentSettings& GetEnvironmentSettings() const noexcept
    {
        return environment_settings_;
    }
 
    void SetEnvironmentSettings(SceneEnvironmentSettings settings) noexcept
    {
        environment_settings_ = std::move(settings);
        ++mutation_generation_;
    }
 
    [[nodiscard]] uint64_t GetMutationGeneration() const noexcept
    {
        return mutation_generation_;
    }
 
    template <typename T, typename U, typename Func>
    void Each(Func&& func)
    {
        auto* primary = TryGetComponentStorage<T>();
        auto* secondary = TryGetComponentStorage<U>();
        if (!primary || !secondary)
        {
            return;
        }
 
        if (secondary->components.size() < primary->components.size())
        {
            for (const auto& entry : secondary->components)
            {
                if (entry.id >= entities_.size())
                {
                    continue;
                }
 
                const EntityId entity = entities_[entry.id];
                if (!entity || !primary->components.contains(entry.id))
                {
                    continue;
                }
 
                func(entity, primary->components.at(entry.id), secondary->components.at(entry.id));
            }
            return;
        }
 
        for (const auto& entry : primary->components)
        {
            if (entry.id >= entities_.size())
            {
                continue;
            }
 
            const EntityId entity = entities_[entry.id];
            if (!entity || !secondary->components.contains(entry.id))
            {
                continue;
            }
 
            func(entity, primary->components.at(entry.id), secondary->components.at(entry.id));
        }
    }
 
    template <typename T, typename U, typename Func>
    void Each(Func&& func) const
    {
        const auto* primary = TryGetComponentStorage<T>();
        const auto* secondary = TryGetComponentStorage<U>();
        if (!primary || !secondary)
        {
            return;
        }
 
        if (secondary->components.size() < primary->components.size())
        {
            for (const auto& entry : secondary->components)
            {
                if (entry.id >= entities_.size())
                {
                    continue;
                }
 
                const EntityId entity = entities_[entry.id];
                if (!entity || !primary->components.contains(entry.id))
                {
                    continue;
                }
 
                func(entity, primary->components.at(entry.id), secondary->components.at(entry.id));
            }
            return;
        }
 
        for (const auto& entry : primary->components)
        {
            if (entry.id >= entities_.size())
            {
                continue;
            }
 
            const EntityId entity = entities_[entry.id];
            if (!entity || !secondary->components.contains(entry.id))
            {
                continue;
            }
 
            func(entity, primary->components.at(entry.id), secondary->components.at(entry.id));
        }
    }
 
    friend Node& operator<<(Node& node, const Scene& scene);
    friend const Node& operator>>(const Node& node, Scene& scene);
    friend class SceneSerializer;
 
private:
    using ComponentTypeId = std::type_index;
    using ComponentStorageFactory = std::function<std::unique_ptr<ComponentStorageBase>()>;
 
    struct ComponentRegistration
    {
        std::string name;
        ComponentStorageFactory factory;
    };
 
    void ClearSceneState();
    void RegisterComponentType(ComponentTypeId type_id, std::string serialization_name, ComponentStorageFactory factory);
    ComponentStorageBase* FindOrCreateStorage(ComponentTypeId type_id, std::string_view serialization_name);
    [[nodiscard]] const ComponentRegistration* FindComponentRegistration(ComponentTypeId type_id) const;
 
private:
    std::vector<EntityId> entities_;
    std::vector<uint32_t> entity_generations_;
    std::vector<uint32_t> free_entities_;
    std::unordered_map<ComponentTypeId, std::unique_ptr<ComponentStorageBase>> component_storage_;
    std::unordered_map<ComponentTypeId, ComponentRegistration> component_registrations_;
    std::unordered_map<std::string, ComponentTypeId> component_types_by_name_;
    std::unordered_map<std::string, ComponentStorageFactory> component_storage_factories_by_name_;
    SceneEnvironmentSettings environment_settings_;
    uint64_t mutation_generation_ = 1;
 
private:
    template <typename T>
    ComponentStorage<T>* GetOrCreateComponentStorage()
    {
        const auto type_id = std::type_index(typeid(T));
        auto it = component_storage_.find(type_id);
        if (it != component_storage_.end())
        {
            return static_cast<ComponentStorage<T>*>(it->second.get());
        }
        else
        {
            auto storage = std::make_unique<ComponentStorage<T>>();
            ComponentStorage<T>* ptr = storage.get();
            component_storage_[type_id] = std::move(storage);
            return ptr;
        }
    }
 
    template <typename T>
    ComponentStorage<T>* TryGetComponentStorage()
    {
        const auto type_id = std::type_index(typeid(T));
        auto it = component_storage_.find(type_id);
        if (it == component_storage_.end())
        {
            return nullptr;
        }
        return static_cast<ComponentStorage<T>*>(it->second.get());
    }
 
    template <typename T>
    const ComponentStorage<T>* TryGetComponentStorage() const
    {
        const auto type_id = std::type_index(typeid(T));
        auto it = component_storage_.find(type_id);
        if (it == component_storage_.end())
        {
            return nullptr;
        }
        return static_cast<const ComponentStorage<T>*>(it->second.get());
    }
};
 
void RegisterEngineSceneComponents(Scene& scene);
 
} // namespace pixelbullet