AnimationAsset.hpp

#pragma once
#include "Ref.hpp"
#include "Map.hpp"
#include "SpinLock.hpp"
#include <ozz/base/containers/vector.h>
#include <ozz/animation/runtime/sampling_job.h>
#include <ozz/base/memory/unique_ptr.h>
#include "Function.hpp"
#include "mathtypes.hpp"
 
namespace ozz::animation {
    struct Skeleton;
    struct Animation;
}
 
namespace ozz::math {
    struct SoaTransform;
}
 
namespace RavEngine{
 
    class SkeletonAsset;
 
struct IAnimGraphable{
    virtual bool Sample(float t, float start,
                        float speed,
                        bool looping,
                        ozz::vector<ozz::math::SoaTransform>& output,
                        ozz::animation::SamplingJob::Context& cache,
                        const ozz::animation::Skeleton* skeleton) const = 0;
    
    
    void SampleDirect(float t, const ozz::animation::Animation* anim, ozz::animation::SamplingJob::Context& cache, ozz::vector<ozz::math::SoaTransform>& locals) const;
};
 
class AnimationAsset : public IAnimGraphable{
    //duration
    //clip data
    ozz::unique_ptr<ozz::animation::Animation> anim;
public:
    AnimationAsset(const std::string& name);
    
    bool Sample(float t, float start, float speed, bool looping, ozz::vector<ozz::math::SoaTransform>&, ozz::animation::SamplingJob::Context& cache, const ozz::animation::Skeleton* skeleton) const override;
    
    constexpr inline const decltype(anim)& GetAnim() const{
        return anim;
    }
    
    float duration_seconds;
    float tps;
};
 
class BoneTransforms{
    ozz::span<ozz::math::SoaTransform> transforms;
public:
    BoneTransforms(decltype(transforms) t) : transforms(t){}
    
    
    struct SingleTransform{
        quaternion rotation;
        vector3 translation, scale;
    };
    
    SingleTransform GetBone(uint32_t index) const;
    void SetBone(uint32_t index, const SingleTransform&);
};
 
class CustomSkeletonAnimation : public IAnimGraphable {
    Function<bool(BoneTransforms, const ozz::animation::Skeleton*, float, float, float, bool)> mutateBonesHook;
    bool Sample(float t, float start, float speed, bool looping, ozz::vector<ozz::math::SoaTransform>&, ozz::animation::SamplingJob::Context& cache, const ozz::animation::Skeleton* skeleton) const override;
public:
    CustomSkeletonAnimation(const decltype(mutateBonesHook)& hook) : mutateBonesHook(hook) {}
};
 
struct CustomSkeletonAnimationFunction {
 
    virtual bool operator()(BoneTransforms transforms, const ozz::animation::Skeleton* skeleton, float t, float start, float end, bool loop) = 0;
};
 
class AnimationAssetSegment : public IAnimGraphable{
public:
    float start_ticks, end_ticks;
    Ref<AnimationAsset> anim_asset;
    
    AnimationAssetSegment(decltype(anim_asset) asset, float start, float end = 0) : anim_asset(asset), start_ticks(start), end_ticks(end){}
    
    bool Sample(float global_time, float last_globalplaytime, float speed, bool looping, ozz::vector<ozz::math::SoaTransform>&, ozz::animation::SamplingJob::Context& cache, const ozz::animation::Skeleton* skeleton) const override;
};
 
class AnimationClip : public IAnimGraphable{
    struct Sampler{
        float influence;
        ozz::vector<ozz::math::SoaTransform> locals;
    };
    locked_hashmap<Ref<IAnimGraphable>,Sampler, SpinLock> influence;
public:
    inline void SetAnimationInfluence(Ref<IAnimGraphable> asset, float inf = 1){
        influence[asset].influence = inf;
    }
    
    inline void RemoveAnimation(Ref<IAnimGraphable> asset){
        influence.erase(asset);
    }
    
    inline void Clear(){
        influence.clear();
    }
    
    inline bool IsEmpty() const{
        return influence.empty();
    }
    
    bool Sample(float t, float start, float speed, bool looping, ozz::vector<ozz::math::SoaTransform>&, ozz::animation::SamplingJob::Context& cache, const ozz::animation::Skeleton* skeleton) const override;
    
};
}