EntityFactory.hpp

Go to the documentation of this file.

 
 
#ifndef GALAXY_META_ENTITYFACTORY_HPP_
#define GALAXY_META_ENTITYFACTORY_HPP_
 
#include <ankerl/unordered_dense.h>
#include <entt/entt.hpp>
#include <nlohmann/json.hpp>
 
#include "galaxy/fs/Serializable.hpp"
#include "galaxy/logging/Log.hpp"
#include "galaxy/meta/Concepts.hpp"
 
namespace galaxy
{
    namespace meta
    {
        class EntityFactory final
        {
            struct SerializationData final
            {
                std::string name;
 
                nlohmann::json json;
            };
 
            using Validations          = ankerl::unordered_dense::map<entt::id_type, std::move_only_function<bool(const entt::entity, entt::registry&)>>;
            using ComponentJSONFactory = ankerl::unordered_dense::map<std::string, std::move_only_function<void(const entt::entity, entt::registry&, const nlohmann::json&)>>;
            using AnyJSONFactory       = ankerl::unordered_dense::map<std::string, std::move_only_function<entt::any(const nlohmann::json&)>>;
            using SerializeFactory     = ankerl::unordered_dense::map<std::string, std::move_only_function<EntityFactory::SerializationData(void*)>>;
 
        public:
            template<valid_component ToValidate, valid_component... Dependencies>
            void register_dependencies();
 
            template<valid_component Component>
            void register_component(const std::string& name);
 
            void json_factory(const std::string& type, const entt::entity entity, entt::registry& registry, const nlohmann::json& json);
 
            [[nodiscard]]
            entt::any any_from_json(const std::string& type, const nlohmann::json& json);
 
            [[nodiscard]]
            nlohmann::json serialize_entity(const entt::entity entity, entt::registry& registry);
 
            [[maybe_unused]]
            entt::entity deserialize_entity(const nlohmann::json& json, entt::registry& registry);
 
            [[nodiscard]]
            const std::string& get_type(const entt::id_type id);
 
            [[nodiscard]]
            entt::id_type get_typeid(const std::string& name);
 
            [[nodiscard]]
            Validations& get_validations();
 
            [[nodiscard]]
            const std::vector<entt::id_type>& get_validation_list() const;
 
        private:
            ankerl::unordered_dense::map<entt::id_type, std::string> m_id_to_name;
 
            ankerl::unordered_dense::map<std::string, entt::id_type> m_name_to_id;
 
            ComponentJSONFactory m_json_factory;
 
            AnyJSONFactory m_json_any_factory;
 
            SerializeFactory m_serialize_factory;
 
            Validations m_validations;
 
            std::vector<entt::id_type> m_validations_to_run;
        };
 
        template<valid_component ToValidate, valid_component... Dependencies>
        inline void EntityFactory::register_dependencies()
        {
            const auto hash = entt::type_id<ToValidate>().hash();
            if (!m_validations.contains(hash))
            {
                m_validations[hash] = [this](const entt::entity entity, entt::registry& registry) -> bool {
                    const auto* component = registry.try_get<ToValidate>(entity);
                    if (component)
                    {
                        return registry.all_of<Dependencies...>(entity);
                    }
                    else
                    {
                        // If we dont have component needing to be validated, then entity is valid.
                        return true;
                    }
                };
 
                m_validations_to_run.push_back(hash);
            }
            else
            {
                GALAXY_LOG(GALAXY_WARNING, "Attempted to register duplicate validation of a component dependency.");
            }
        }
 
        template<valid_component Component>
        inline void EntityFactory::register_component(const std::string& name)
        {
            if (!m_json_factory.contains(name))
            {
                const auto hash = entt::type_id<Component>().hash();
                m_id_to_name.emplace(hash, name);
                m_name_to_id.emplace(name, hash);
 
                if constexpr (std::constructible_from<Component, const nlohmann::json&>)
                {
                    m_json_factory.emplace(name, [](const entt::entity entity, entt::registry& registry, const nlohmann::json& json) {
                        registry.emplace<Component>(entity, json);
                    });
 
                    m_json_any_factory.emplace(name, [](const nlohmann::json& json) -> entt::any {
                        return entt::make_any<Component>(json);
                    });
                }
 
                if constexpr (std::derived_from<Component, fs::Serializable>)
                {
                    m_serialize_factory.emplace(name, [name](void* component) -> SerializationData {
                        return SerializationData {.name = name, .json = static_cast<Component*>(component)->serialize()};
                    });
                }
            }
            else
            {
                GALAXY_LOG(GALAXY_WARNING, "Attempted to register duplicate component of type '{0}'.", name);
            }
        }
    } // namespace meta
} // namespace galaxy
 
#endif