skeleton.h

// © Joseph Cameron - MIT License
 
#ifndef GDK_GRAPHICS_EXT_ANIMATION_SKELETON_H
#define GDK_GRAPHICS_EXT_ANIMATION_SKELETON_H
 
#include <gdk/graphics/ext/animation/animation_types.h>
 
#include <cstddef>
#include <string>
#include <string_view>
#include <vector>
#include <span>
 
namespace gdk::graphics::animation {
    struct skeleton final {
        struct bone final {
            int parent = -1;
            vector3_type local_position;
            quaternion_type local_rotation;
            std::string name;
        };
 
        std::vector<bone> bones;
        std::vector<matrix4x4_type> supplied_inverse_binds;

        [[nodiscard]] std::vector<matrix4x4_type> bind_world_transforms() const;

        [[nodiscard]] skeleton with_oriented_bone_frames() const;

        [[nodiscard]] std::vector<matrix4x4_type> inverse_bind_transforms() const;
    };

    struct vertical_extent final {
        float lowest = 0;
        float highest = 0;
 
        [[nodiscard]] float height() const { return highest - lowest; }
    };
 
    [[nodiscard]] vertical_extent bind_vertical_extent(const skeleton &aSkeleton);

    [[nodiscard]] float limb_half_width(const skeleton &aSkeleton);

    [[nodiscard]] int find_bone(const skeleton &aSkeleton, std::string_view aName);

    [[nodiscard]] std::vector<std::string> duplicate_bone_names(const skeleton &aSkeleton);

    struct pose final {
        std::vector<quaternion_type> local_rotations;
 
        [[nodiscard]] static pose rest(const skeleton &aSkeleton);
    };

    [[nodiscard]] pose blend(const pose &aFrom, const pose &aTo, const float aT);

    using bone_mask = std::vector<float>;

    [[nodiscard]] bone_mask mask_for_subtree(const skeleton &aSkeleton, const std::size_t aRoot,
        const float aWeight = 1.0f);

    [[nodiscard]] pose blend(const pose &aFrom, const pose &aTo, const bone_mask &aMask);

    [[nodiscard]] pose difference(const pose &aBase, const pose &aTarget);

    [[nodiscard]] pose add(const pose &aBase, const pose &aDelta, const bone_mask &aMask);

    [[nodiscard]] pose add(const pose &aBase, const pose &aDelta, const float aWeight);

    struct clip final {
        struct key final {
            float time = 0;
            pose p;
            vector3_type root_position;
        };
 
        std::vector<key> keys;
        float duration = 1.0f;
        vector3_type root_motion_per_cycle;
        bool loops = true;
    };

    [[nodiscard]] pose sample(const clip &aClip, const float aTime);

    [[nodiscard]] vector3_type sample_root_position(const clip &aClip, const float aTime);

    [[nodiscard]] vector3_type root_delta(const clip &aClip, const float aFrom, const float aTo);

    [[nodiscard]] std::vector<matrix4x4_type> pose_world_transforms(
        const skeleton &aSkeleton, const pose &aPose);

    struct socket final {
        std::size_t bone = 0;
        matrix4x4_type offset;
    };

    [[nodiscard]] matrix4x4_type socket_transform(std::span<const matrix4x4_type> aWorld,
        const socket &aSocket);

    [[nodiscard]] quaternion_type bone_world_rotation(const skeleton &aSkeleton, const pose &aPose,
        const std::size_t aBone);

    [[nodiscard]] std::vector<matrix4x4_type> skinning_palette(
        const skeleton &aSkeleton, const pose &aPose,
        std::span<const matrix4x4_type> aInverseBind
    );
}
 
#endif