RegistrySerialization.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ecs/components/InputSnapshot.hpp"
#include "entt/entity/fwd.hpp"
 
#include <entt/entt.hpp>
#include <optional>
#include <vector>

namespace registry_serialization
{

struct RemoteInputRecord
{
    entt::entity entity{entt::null};
    InputSnapshot input{};
};

std::vector<uint8_t> serialize(const entt::registry& registry);
 
// ── PR-10 (server-perf): snapshot delta encoding ────────────────────────
//
// Two helpers pair to give a simple bytewise diff against a prior
// snapshot.  Format:
//   [skip:u32] [copy:u32] [copy_bytes : u8 × copy] (repeated until output
//                                                   covers `current.size()`)
// The decoder walks the same triples, copying `skip` bytes from the
// baseline and `copy` bytes from the patch into the output buffer.
//
// Caller contract: only emit a delta when `baseline.size() ==
// current.size()`. Different sizes mean the entt entity-list section
// shifted; the sequential skip/copy form would mis-align. Server
// falls back to a full snapshot in that case.
//
// `encodeDelta` returns the patch bytes only — callers prepend the
// `[currentTick:u32] [fromTick:u32] [size:u32]` wire header outside.

std::vector<uint8_t> encodeDelta(const std::vector<uint8_t>& baseline, const std::vector<uint8_t>& current);

std::vector<uint8_t>
applyDelta(const std::vector<uint8_t>& baseline, const uint8_t* patch, std::size_t patchSize, std::size_t outputSize);

class Loader
{
public:
    explicit Loader(entt ::registry& registry) : registry(registry), loader(registry) {}

    void apply(const uint8_t* data,
               size_t size,
               std::optional<entt::entity> localPlayerServerEntity = std::nullopt,
               uint32_t* outServerAckedClientTick = nullptr);

    [[nodiscard]] entt::entity map(entt::entity e) const;
 
private:
    entt::registry& registry;
    entt::continuous_loader loader;
};
 
} // namespace registry_serialization