interpolation.h

#pragma once
 
#include <cstdint>
#include <unordered_map>
#include <vector>
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
 
#include "ecs/entity.h"
#include "net/prediction/sample_track.h"
 
namespace Vkm::Engine {
 
class Scene;

class NetInterpolation {
    public:
        static constexpr float SNAPSHOTS_BEHIND = 2.0f;

        static constexpr size_t HISTORY = 8;

        static constexpr float MAX_SNAPSHOTS_BEHIND = static_cast<float>(HISTORY) / 2.0f;
 
        static_assert(
            SNAPSHOTS_BEHIND <= MAX_SNAPSHOTS_BEHIND,
            "the least delay has to fit the samples kept"
        );
 
    public:
        NetInterpolation() = default;
        ~NetInterpolation() = default;
 
        NetInterpolation(const NetInterpolation& other) = delete;
        NetInterpolation& operator=(const NetInterpolation& other) = delete;
 
        NetInterpolation(NetInterpolation && other) = delete;
        NetInterpolation& operator=(NetInterpolation && other) = delete;
 
    public:
        void record(EntityId entity, uint32_t tick, const glm::vec3& position, const glm::quat& rotation);

        void heard(uint32_t tick, float tickRate);

        float delayTicks(float tickRate, float snapshotRate) const;

        void restoreConfirmed(Scene& scene);

        void apply(Scene& scene, float deltaTime, float tickRate, float snapshotRate);

        void hold(EntityId entity, bool held);

        void forget(EntityId entity);
 
        void clear();
 
        size_t tracked() const { return m_tracks.size(); }

        double renderTick() const { return m_renderTick; }

        float behindTicks() const {
            return m_started ? static_cast<float>(static_cast<double>(m_newestTick) - m_renderTick) : 0.0f;
        }
 
    private:
        struct Track {
            EntityId             entity;  
            SampleTrack<HISTORY> history;
            bool                 held = false;
        };

        bool isPosed(uint32_t slot) const { return slot < m_posed.size() && m_posed[slot]; }
 
    private:
        std::unordered_map<uint32_t, Track> m_tracks;

        std::vector<bool> m_posed;
 
        double   m_renderTick = 0.0;
        uint32_t m_newestTick = 0;
        bool     m_started    = false;
 
        double   m_seconds    = 0.0;    
        double   m_heardAt    = 0.0;    
        uint32_t m_heardTick  = 0;      
        float    m_jitter     = 0.0f;   
        bool     m_heardAny   = false;
};
 
} // namespace Vkm::Engine