schema.h

#pragma once
 
#include <cstdint>
#include <string>
#include <string_view>
#include <vector>
 
#include "ecs/scene.h"
#include "net/wire/bit_stream.h"
 
namespace Vkm::Engine {

struct NetType {
    std::string name;  

    bool (*has)(const Scene&, EntityId) = nullptr;

    void (*encode)(const Scene&, EntityId, BitWriter&) = nullptr;

    bool (*decode)(Scene&, EntityId, BitReader&) = nullptr;
};

class NetSchema {
    public:
        static constexpr size_t MAX_TYPES = 32;
 
    public:
        NetSchema() = default;
        ~NetSchema() = default;
 
        NetSchema(const NetSchema& other) = delete;
        NetSchema& operator=(const NetSchema& other) = delete;
 
        NetSchema(NetSchema && other) = delete;
        NetSchema& operator=(NetSchema && other) = delete;
 
    public:
        static NetSchema& get();
 
    public:
        template <typename T>
        void replicate(std::string name);

        const std::vector<NetType>& types() const { return m_types; }
 
        size_t size() const { return m_types.size(); }

        int indexOf(std::string_view name) const;

        uint32_t fingerprint() const;

        std::string describe() const;

        void clear() { m_types.clear(); }
 
    private:
        void add(NetType type);
 
    private:
        std::vector<NetType> m_types;
};
 
template <typename T>
void NetSchema::replicate(std::string name) {
    NetType type;
    type.name = std::move(name);
 
    // Stateless thunks: plain function pointers, nothing owned.
    type.has = [](const Scene& scene, EntityId entity) { return scene.has<T>(entity); };
    type.encode = [](const Scene& scene, EntityId entity, BitWriter& writer) {
        netEncode(scene.get<T>(entity), writer);
    };
    type.decode = [](Scene& scene, EntityId entity, BitReader& reader) {
        // Added, not required: a client learns of a component by being sent one.
        T* held = scene.tryGet<T>(entity);
        if (!held) held = &scene.add<T>(entity, T{});
        netDecode(*held, reader);
        return !reader.failed();
    };
 
    add(std::move(type));
}
 
} // namespace Vkm::Engine