AnimSnapshot.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>

struct AnimSlot
{
    std::uint8_t clipIdRaw = 0xFFu;

    float timeRatio = 0.0f;

    float weight = 0.0f;
};

struct AnimSnapshot
{
    static constexpr std::size_t k_numSlots = 5;
    std::array<AnimSlot, k_numSlots> slots{};
};
 
namespace anim_snapshot
{

[[nodiscard]] inline float delta(const AnimSnapshot& a, const AnimSnapshot& b)
{
    float d = 0.0f;
    for (std::size_t i = 0; i < AnimSnapshot::k_numSlots; ++i) {
        const auto& sa = a.slots[i];
        const auto& sb = b.slots[i];
        const bool aActive = sa.weight > 0.0f;
        const bool bActive = sb.weight > 0.0f;
        if (aActive != bActive) {
            // Active/inactive mismatch — typical near a transition edge.
            // Soft penalty so a half-transitioned blend doesn't reject
            // the whole shot.
            d += 0.5f;
            continue;
        }
        if (!aActive)
            continue; // both inactive: nothing to compare.
        if (sa.clipIdRaw != sb.clipIdRaw) {
            // Different clip in the same slot — state-machine
            // disagreement, can't be reconciled by timeRatio fuzziness.
            d += 1.0f;
            continue;
        }
        const float maxW = std::max(sa.weight, sb.weight);
        d += std::abs(sa.timeRatio - sb.timeRatio) * maxW;
        d += std::abs(sa.weight - sb.weight) * 0.5f;
    }
    return d;
}

inline void pack(const AnimSlot& s, std::uint8_t out[4])
{
    out[0] = s.clipIdRaw;
    const float tClamped = std::max(0.0f, std::min(1.0f, s.timeRatio));
    const float wClamped = std::max(0.0f, std::min(1.0f, s.weight));
    const auto tq = static_cast<std::uint16_t>(std::lround(tClamped * 65535.0f));
    const auto wq = static_cast<std::uint8_t>(std::lround(wClamped * 255.0f));
    out[1] = static_cast<std::uint8_t>(tq & 0xFFu);
    out[2] = static_cast<std::uint8_t>((tq >> 8) & 0xFFu);
    out[3] = wq;
}
 
inline AnimSlot unpack(const std::uint8_t in[4])
{
    AnimSlot s;
    s.clipIdRaw = in[0];
    const std::uint16_t tq =
        static_cast<std::uint16_t>(static_cast<std::uint16_t>(in[1]) | static_cast<std::uint16_t>(in[2] << 8));
    s.timeRatio = static_cast<float>(tq) / 65535.0f;
    s.weight = static_cast<float>(in[3]) / 255.0f;
    return s;
}

inline constexpr std::size_t k_wireSize = AnimSnapshot::k_numSlots * 4;
 
inline void packSnapshot(const AnimSnapshot& snap, std::uint8_t out[k_wireSize])
{
    for (std::size_t i = 0; i < AnimSnapshot::k_numSlots; ++i)
        pack(snap.slots[i], &out[i * 4]);
}
 
inline AnimSnapshot unpackSnapshot(const std::uint8_t in[k_wireSize])
{
    AnimSnapshot s;
    for (std::size_t i = 0; i < AnimSnapshot::k_numSlots; ++i)
        s.slots[i] = unpack(&in[i * 4]);
    return s;
}
 
} // namespace anim_snapshot

struct PendingShotIntent
{
    bool received = false;
    std::uint16_t targetClientId = 0xFFFFu;
    AnimSnapshot targetAnim{};
};