Registry.hpp

Go to the documentation of this file.

#pragma once
 
#include "Assert.hpp"
#include "entt/entt.hpp"
#include <Types.hpp>
#include <functional>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#include <utility>
 
using Entity = entt::entity;
 
constexpr Entity NULL_ENTITY = static_cast<Entity>(0);


class Registry
{
public:

    Entity CreateEntity();

    void DestroyEntity(const Entity entity);

    bool EntityValid(const Entity entity);

    template <typename Component, typename... Args>
    const Component* Emplace(const Entity entity, Args&&... args)
    {
        Assert(EntityValid(entity));
        if (HasAny<Component>(entity))
        {
            return nullptr;
        }
 
        return &m_registry.emplace<Component>(entity, std::forward<Args>(args)...);
    }

    template <typename Component, typename... Args>
    const Component& EmplaceOrReplace(const Entity entity, Args&&... args)
    {
        Assert(EntityValid(entity));
        return m_registry.emplace_or_replace<Component>(entity, std::forward<Args>(args)...);
    }

    template <typename Component>
    bool Patch(const Entity entity, const std::function<void(Component&)>& func)
    {
        Assert(EntityValid(entity));
        if (!m_registry.any_of<Component>(entity))
        {
            return false;
        }
 
        m_registry.patch<Component>(entity, func);
 
        return true;
    }

    template <typename Component>
    const Component* Get(const Entity entity)
    {
        Assert(EntityValid(entity));
        Component* ptr = m_registry.try_get<Component>(entity);
        if (!ptr)
        {
            return nullptr;
        }
 
        return ptr;
    }

    template <typename... Components>
    bool HasAny(const Entity entity)
    {
        Assert(EntityValid(entity));
        return m_registry.any_of<Components...>(entity);
    }

    template <typename... Components>
    bool HasAll(const Entity entity)
    {
        Assert(EntityValid(entity));
        return m_registry.all_of<Components...>(entity);
    }

    template <typename Component, typename... Args>
    const Component* Replace(const Entity entity, Args&&... args)
    {
        Assert(EntityValid(entity));
        if (!HasAny<Component>(entity))
        {
            return nullptr;
        }
 
        return &m_registry.replace<Component>(entity, std::forward<Args>(args)...);
    }

    template <typename Component>
    void Remove(const Entity entity)
    {
        Assert(EntityValid(entity));
        m_registry.remove<Component>(entity);
    }

    template <typename Component>
    void ClearComponents()
    {
        m_registry.clear<Component>();
    }

    template <typename... Components>
    auto GetView()
    {
        return m_registry.view<const Components...>();
    }

    template <typename... Owned, typename... Get, typename... Exclude>
    auto GetGroup([[maybe_unused]] entt::get_t<Get...> get = entt::get_t{},
    [[maybe_unused]] entt::exclude_t<Exclude...> exclude = entt::exclude_t{})
    {
        return m_registry.group<const Owned...>(entt::get_t<const Get...>{}, entt::exclude_t<Exclude...>{});
    }

    template <typename Component>
    void Sort(const std::function<bool(const Component& a, const Component& b)>& comparitor)
    {
        m_registry.sort<Component>(comparitor);
    }

    template <typename... Owned, typename... Get, typename... Exclude>
    void SortGroup(const std::function<bool(const Entity& a, const Entity& b)>& comparitor,
    entt::get_t<Get...> get = entt::get_t{}, entt::exclude_t<Exclude...> exclude = entt::exclude_t{})
    {
        auto group = m_registry.group<Owned...>(get, exclude);
        group.sort(comparitor);
    }

    template <typename Component>
    u32 OnConstruct(const std::function<void(Component& component, const Entity entity)>& callback)
    {
        m_callbackId++;
 
        auto& callbacks = m_constructCallbacks[typeid(Component)];
        callbacks[m_callbackId] = [callback](void* comp, const Entity entity)
        {
            callback(*static_cast<Component*>(comp), entity);
        };
 
        if (!m_constructConnected.contains(typeid(Component)))
        {
            m_registry.on_construct<Component>().template connect<&Registry::HandleConstruct<Component>>(this);
            m_constructConnected.insert(typeid(Component));
        }
 
        return m_callbackId;
    };

    template <typename Component>
    u32 OnUpdate(const std::function<void(Component& component, const Entity entity)>& callback)
    {
        m_callbackId++;
 
        auto& callbacks = m_updateCallbacks[typeid(Component)];
        callbacks[m_callbackId] = [callback](void* comp, const Entity entity)
        {
            callback(*static_cast<Component*>(comp), entity);
        };
 
        if (!m_updateConnected.contains(typeid(Component)))
        {
            m_registry.on_update<Component>().template connect<&Registry::HandleUpdate<Component>>(this);
            m_updateConnected.insert(typeid(Component));
        }
 
        return m_callbackId;
    };

    template <typename Component>
    u32 OnDestroy(const std::function<void(Component& component, const Entity entity)>& callback)
    {
        m_callbackId++;
 
        auto& callbacks = m_destroyCallbacks[typeid(Component)];
        callbacks[m_callbackId] = [callback](void* comp, const Entity entity)
        {
            callback(*static_cast<Component*>(comp), entity);
        };
 
        if (!m_destroyConnected.contains(typeid(Component)))
        {
            m_registry.on_destroy<Component>().template connect<&Registry::HandleDestroy<Component>>(this);
            m_destroyConnected.insert(typeid(Component));
        }
 
        return m_callbackId;
    };

    template <typename Component>
    void RemoveConstructCallback(const u32 callbackId)
    {
        auto it = m_constructCallbacks.find(typeid(Component));
        if (it == m_constructCallbacks.end())
        {
            return;
        }
 
        auto& map = it->second;
        map.erase(callbackId);
 
        if (map.empty())
        {
            m_registry.on_construct<Component>().template disconnect<&Registry::HandleConstruct<Component>>(this);
            m_constructConnected.erase(typeid(Component));
        }
    }

    template <typename Component>
    void RemoveUpdateCallback(const u32 callbackId)
    {
        auto it = m_updateCallbacks.find(typeid(Component));
        if (it == m_updateCallbacks.end())
        {
            return;
        }
 
        auto& map = it->second;
        map.erase(callbackId);
 
        if (map.empty())
        {
            m_registry.on_update<Component>().template disconnect<&Registry::HandleUpdate<Component>>(this);
            m_updateConnected.erase(typeid(Component));
        }
    }

    template <typename Component>
    void RemoveDestroyCallback(const u32 callbackId)
    {
        auto it = m_destroyCallbacks.find(typeid(Component));
        if (it == m_destroyCallbacks.end())
        {
            return;
        }
 
        auto& map = it->second;
        map.erase(callbackId);
 
        if (map.empty())
        {
            m_registry.on_destroy<Component>().template disconnect<&Registry::HandleDestroy<Component>>(this);
            m_destroyConnected.erase(typeid(Component));
        }
    }

    entt::registry& GetRegistry();
 
private:
 
    template <typename Component>
    void HandleConstruct(entt::registry& registry, Entity entity)
    {
        auto it = m_constructCallbacks.find(typeid(Component));
        if (it == m_constructCallbacks.end())
        {
            return;
        }
 
        for (auto& pair : it->second)
        {
            pair.second(static_cast<void*>(&registry.get<Component>(entity)), entity);
        }
    }
 
    template <typename Component>
    void HandleUpdate(entt::registry& registry, Entity entity)
    {
        auto it = m_updateCallbacks.find(typeid(Component));
        if (it == m_updateCallbacks.end())
        {
            return;
        }
 
        for (auto& pair : it->second)
        {
            pair.second(static_cast<void*>(&registry.get<Component>(entity)), entity);
        }
    }
 
    template <typename Component>
    void HandleDestroy(entt::registry& registry, Entity entity)
    {
        auto it = m_destroyCallbacks.find(typeid(Component));
        if (it == m_destroyCallbacks.end())
        {
            return;
        }
 
        for (auto& pair : it->second)
        {
            pair.second(static_cast<void*>(&registry.get<Component>(entity)), entity);
        }
    }
 
    u32 m_callbackId = 0;
 
    std::unordered_map<std::type_index, std::unordered_map<u32, std::function<void(void*, const Entity entity)>>>
    m_constructCallbacks;
    std::unordered_map<std::type_index, std::unordered_map<u32, std::function<void(void*, const Entity entity)>>>
    m_updateCallbacks;
    std::unordered_map<std::type_index, std::unordered_map<u32, std::function<void(void*, const Entity entity)>>>
    m_destroyCallbacks;
 
    std::unordered_set<std::type_index> m_constructConnected;
    std::unordered_set<std::type_index> m_updateConnected;
    std::unordered_set<std::type_index> m_destroyConnected;
 
    entt::registry m_registry;
};