sample_track.h

#pragma once
 
#include <algorithm>
#include <cstdint>
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
 
namespace Vkm::Engine {

template <size_t N>
struct SampleTrack {
    struct Sample {
        uint32_t  tick = 0;
        glm::vec3 position{0.0f};
        glm::quat rotation{1.0f, 0.0f, 0.0f, 0.0f};
    };
 
    Sample samples[N];  
    size_t count = 0;   

    void record(uint32_t tick, const glm::vec3& position, const glm::quat& rotation) {
        if (count > 0 && tick <= samples[count - 1].tick) return;
 
        if (count == N) {
            std::move(samples + 1, samples + N, samples);
            --count;
        }
        samples[count++] = {tick, position, rotation};
    }

    bool poseAt(double tick, glm::vec3& position, glm::quat& rotation) const {
        if (count == 0) return false;
 
        if (tick <= static_cast<double>(samples[0].tick)) {
            position = samples[0].position;
            rotation = samples[0].rotation;
            return true;
        }
        const Sample& newest = samples[count - 1];
        if (tick >= static_cast<double>(newest.tick)) {
            position = newest.position;
            rotation = newest.rotation;
            return true;
        }
 
        for (size_t i = 0; i + 1 < count; ++i) {
            const Sample& from = samples[i];
            const Sample& to   = samples[i + 1];
            if (tick < static_cast<double>(from.tick) || tick > static_cast<double>(to.tick)) continue;
 
            const double span = static_cast<double>(to.tick - from.tick);
            const float  at   = span > 0.0
                ? static_cast<float>((tick - static_cast<double>(from.tick)) / span)
                : 1.0f;
            position = glm::mix(from.position, to.position, at);
            // slerp: a linear blend speeds up through the middle of a turn.
            rotation = glm::slerp(from.rotation, to.rotation, at);
            return true;
        }
        return false;
    }

    uint32_t newest() const { return count > 0 ? samples[count - 1].tick : 0u; }
};
 
} // namespace Vkm::Engine