Animation.hpp

Go to the documentation of this file.

#pragma once
#include <Core/Container.hpp>
#include <Math/Math.hpp>
#include "Mesh.hpp"
 
using namespace Foundation;
using namespace Core;
using namespace Math;
 
struct FJoint
{
    int32_t parent{-1};                 // parent joint index (< this joint's index), or -1 for a root
    float3 restTranslation{0, 0, 0};    // rest-pose local TRS (used when a channel is absent)
    quat restRotation{0, 0, 0, 1};
    float3 restScale{1, 1, 1};
    mat4 inverseBind{1.0f};             // bind space -> joint space; identity for pure articulation
};
 
struct FSkeleton
{
    Vector<FJoint> joints;
    explicit FSkeleton(Allocator* alloc = GLOBAL_ALLOC) : joints(alloc) {}
    [[nodiscard]] uint32_t Count() const { return static_cast<uint32_t>(joints.size()); }
};
 
enum class FAnimPath : uint8_t
{
    Translation,
    Rotation,
    Scale,
};
 
enum class FAnimInterp : uint8_t
{
    Step,
    Linear,
    CubicSpline,
};
 
struct FAnimChannel
{
    uint32_t joint{0};
    FAnimPath path{FAnimPath::Translation};
    FAnimInterp interp{FAnimInterp::Linear};
    Vector<float> times;
    Vector<float> values;
    explicit FAnimChannel(Allocator* alloc = GLOBAL_ALLOC) : times(alloc), values(alloc) {}
};
 
struct FAnimationClip
{
    Vector<FAnimChannel> channels;
    float duration{0.0f};
    int32_t skeleton{-1};
    explicit FAnimationClip(Allocator* alloc = GLOBAL_ALLOC) : channels(alloc) {}
};
 
struct FPose
{
    Vector<float3> translations;
    Vector<quat> rotations;
    Vector<float3> scales;
    Vector<mat4> globals;
    explicit FPose(Allocator* alloc = GLOBAL_ALLOC)
        : translations(alloc), rotations(alloc), scales(alloc), globals(alloc)
    {
    }
    void Resize(uint32_t jointCount);
};
 
[[nodiscard]] mat4 JointLocalMatrix(float3 const& t, quat const& r, float3 const& s);
 
void ResetToRest(FSkeleton const& skel, FPose& pose);
 
void SampleClip(FAnimationClip const& clip, float t, FPose& pose);
 
void ComputeGlobals(FSkeleton const& skel, FPose& pose);
 
void SampleTrack(Span<const float> times, Span<const float> values, uint32_t comps, FAnimInterp interp, float t,
                 Span<float> out);
 
void ComputeSkinningMatrices(FSkeleton const& skel, FPose const& pose, Span<mat4> outPalette);
 
void SkinVertices(Span<const FVertex> bind, Span<const FSkinBinding> binding, Span<const mat4> palette,
                  Span<FQVertex> out);
 
void RecomputeNormals(Span<FVertex> verts, Span<const uint32_t> indices);