ComponentStorage.hpp

#pragma once
 
#include "PixelBullet/Math/SparseSet.hpp"
#include "PixelBullet/Serialization/Node.hpp"
 
#include <cstdint>
#include <string>
#include <typeinfo>
 
namespace PixelBullet
{
    struct ComponentStorageBase
    {
        virtual ~ComponentStorageBase() = default;
        virtual void Serialize(Node& node) const = 0;
        virtual void Deserialize(const Node& node) = 0;
        virtual void RemoveComponent(uint32_t entity) = 0;
        virtual std::string GetTypeName() const = 0;
    };
 
    template <typename T>
    struct ComponentStorage : public ComponentStorageBase
    {
        SparseSet<T> Set;
 
        void Serialize(Node& node) const override
        {
            node.SetType(NodeType::Array);
            for (const auto& entry : Set)
            {
                Node entryNode;
                entryNode["entity"] << entry.id;
                Node compNode;
                compNode << entry.data;
                entryNode["component"] = compNode;
                node.GetProperties().push_back({ "", entryNode });
            }
        }
 
        void Deserialize(const Node& node) override
        {
            for (const auto& [key, entryNode] : node.GetProperties())
            {
                uint32_t entity = 0;
                entryNode["entity"] >> entity;
                T component{};
                entryNode["component"] >> component;
                Set.Insert(entity, component);
            }
        }
 
        void RemoveComponent(uint32_t entity) override
        {
            Set.Erase(entity);
        }
 
        [[nodiscard]] std::string GetTypeName() const override
        {
            return typeid(T).name();
        }
    };
} // namespace PixelBullet