Registry.hpp

#pragma once
#include <vector>
#include <memory>
#include <functional>
#include "Types.hpp"
#include "ComponentStorage.hpp"
#include "VEX/VEX_export.h"
 
namespace vex {

class VEX_EXPORT ComponentType {
public:
    static uint32_t get_id_by_name(const char* name);
 
    template <typename T>
    static uint32_t get_id() {
        static const uint32_t id = get_id_by_name(typeid(T).name());
        return id;
    }
};

class Registry {
private:
    std::vector<Entity> m_availableEntities;
    Entity m_nextEntity = 0;
    std::vector<std::unique_ptr<IComponentStorage>> m_componentStorages;

    template <typename T>
    ComponentStorage<T>* get_storage() {
        uint32_t typeId = ComponentType::get_id<T>();
        if (typeId >= m_componentStorages.size()) {
            m_componentStorages.resize(typeId + 1);
        }
        if (!m_componentStorages[typeId]) {
            m_componentStorages[typeId] = std::make_unique<ComponentStorage<T>>();
        }
        return static_cast<ComponentStorage<T>*>(m_componentStorages[typeId].get());
    }
 
public:
    template <typename T>
    ComponentStorage<T>* try_get_storage_internal() {
        uint32_t typeId = ComponentType::get_id<T>();
        if (typeId >= m_componentStorages.size() || !m_componentStorages[typeId]) {
            return nullptr;
        }
        return static_cast<ComponentStorage<T>*>(m_componentStorages[typeId].get());
    }

    Entity create() {
        if (!m_availableEntities.empty()) {
            Entity e = m_availableEntities.back();
            m_availableEntities.pop_back();
            return e;
        }
        return m_nextEntity++;
    }

    void destroy(Entity entity) {
        for (auto& Storage : m_componentStorages) {
            if (Storage) Storage->entity_destroyed(entity);
        }
        m_availableEntities.push_back(entity);
    }

    template<typename T, typename... Args>
    T& add_or_replace(Entity entity, Args&&... args) {
        return get_storage<T>()->add_or_replace(entity, std::forward<Args>(args)...);
    }

    template<typename T>
    void remove(Entity entity) {
        get_storage<T>()->remove(entity);
    }

    template<typename T>
    T& get(Entity entity) {
        return get_storage<T>()->get(entity);
    }

    template<typename T>
    T* try_get(Entity entity) {
        auto* arr = try_get_storage_internal<T>();
        return (arr && arr->has(entity)) ? &arr->get(entity) : nullptr;
    }

    template<typename T>
    bool has(Entity entity) {
        auto* arr = try_get_storage_internal<T>();
        return arr != nullptr && arr->has(entity);
    }

    template<typename T>
    void on_create(std::function<void(Entity, T&)> cb) { get_storage<T>()->on_create(cb); }

    template<typename T>
    void on_destroy(std::function<void(Entity, T&)> cb) { get_storage<T>()->on_destroy(cb); }
};
 
}