skeletal_animation_system.h

#pragma once
 
#include <cstdint>
#include <vector>
 
#include "core/system.h"
#include "debug/fault_latch.h"
#include "ecs/component/animation/animator.h"
#include "ecs/entity.h"
#include "system/animation/pose_buffer.h"
#include "system/animation/ragdoll_pose.h"
#include "system/animation/pose_evaluator.h"
 
namespace Vkm::Engine {
 
struct Ragdoll;
 
class ResourceManager;
class Scene;
struct AnimationClipAsset;
struct SkeletonAsset;

class SkeletalAnimationSystem : public System {
    public:
        SkeletalAnimationSystem() = default;
        ~SkeletalAnimationSystem() override = default;
 
        SkeletalAnimationSystem(const SkeletalAnimationSystem& other) = delete;
        SkeletalAnimationSystem& operator=(const SkeletalAnimationSystem& other) = delete;
 
        SkeletalAnimationSystem(SkeletalAnimationSystem && other) = delete;
        SkeletalAnimationSystem& operator=(SkeletalAnimationSystem && other) = delete;
 
    public:
        void update(FrameContext& ctx) override;
        void fixedUpdate(FrameContext& ctx) override;
 
    private:
        struct RigWork {
            uint32_t animatorIndex = 0;  
            uint32_t entityIndex   = 0;  
            uint32_t slice         = 0;  
 
            const SkeletonAsset* skeleton = nullptr;

            const Ragdoll* ragdoll   = nullptr;
            uint32_t       firstBody = 0;                
            glm::mat4      rigWorld  = glm::mat4(1.0f);  
 
            const AnimationClipAsset* clip     = nullptr;  
            const AnimationClipAsset* fadeClip = nullptr;  

            PlaybackStep step;
        };

        void run(FrameContext& ctx, float step, bool announceMarkers);

        void poseRigs(FrameContext& ctx, float step);

        bool isPoseable(const SkeletonAsset& skeleton);

        const AnimationClipAsset* resolveClip(
            const ResourceManager& resources,
            const AnimationClipHandle& handle,
            const SkeletonAsset& skeleton
        );

        void stampDescendants(
            Scene& scene,
            const ResourceManager& resources,
            EntityId entity,
            const RigWork& work,
            uint32_t depth
        );

        void publishMarkers(FrameContext& ctx);

        void checkSkinnedMesh(
            const Scene& scene,
            const ResourceManager& resources,
            EntityId entity,
            const SkeletonAsset& skeleton,
            bool onRig
        );
 
    private:
        PoseBuffer m_poses;
        std::vector<RigWork> m_work;  

        std::vector<RagdollBodyPose> m_ragdollBodies;
 
        uint64_t m_epoch = 0;  
 
        FaultLatch m_badSkeleton;   
        FaultLatch m_badClip;       
        FaultLatch m_clipMismatch;  
        FaultLatch m_rigMismatch;   
        FaultLatch m_meshOffset;    
};
 
} // namespace Vkm::Engine