AnimatorComponent.hpp

#pragma once
#include <ozz/animation/runtime/animation.h>
#include <ozz/base/maths/soa_transform.h>
#include "AnimationAsset.hpp"
#include "DataStructures.hpp"
#include "Ref.hpp"
#include <algorithm>
#include "Tween.hpp"
#include "App.hpp"
#include "Function.hpp"
#include "Queryable.hpp"
 
namespace RavEngine{
 
struct Transform;
class SkeletonAsset;
struct SkeletonMask;
 
using anim_id_t = uint16_t;
 
class clamped_vec2{
    float x = 0, y = 0;
public:
    clamped_vec2(float ix, float iy) : x(std::clamp(ix,-1.0f,1.0f)), y(std::clamp(iy,-1.0f,1.0f)){}
    clamped_vec2(){}
    
    constexpr inline decltype(x) get_x() const{
        return x;
    }
    constexpr inline decltype(y) get_y() const{
        return y;
    }
};
 
struct AnimBlendTree : public IAnimGraphable{
    struct Node : public IAnimGraphable{
 
        Ref<IAnimGraphable> state;
        clamped_vec2 graph_pos;
        float max_influence = 1;
        
        Node(){}
                
        template<typename T>
        Node(Ref<T> s, const clamped_vec2& pos, float i = 1) : state(std::static_pointer_cast<IAnimGraphable>(s)), graph_pos(pos), max_influence(i){}
        
        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;
    };
 
    static constexpr uint16_t kmax_nodes = 64;
    
    inline void InsertNode(anim_id_t id, const Node& node){
        states[id].node = node;
    }
    
    inline void DeleteNode(anim_id_t id){
        states.erase(id);
    }
    
    Node& GetNode(const anim_id_t id){
        return states.at(id).node;
    }
    
    inline bool IsEmpty() const{
        return states.empty();
    }
    
    inline void Clear(){
        states.clear();
    }
    
    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 void SetBlendPos(const clamped_vec2& newPos){
        blend_pos = newPos;
    }
    
private:
    struct Sampler{
        ozz::vector<ozz::math::SoaTransform> locals;
        Node node;
    };
    locked_node_hashmap<anim_id_t,Sampler,SpinLock> states;
    clamped_vec2 blend_pos;
};
 
#if !RVE_SERVER
class AnimatorComponent : public IDebugRenderable, public Queryable<AnimatorComponent,IDebugRenderable>
#else
class AnimatorComponent : public AutoCTTI, public Queryable<AnimatorComponent>
#endif
{
    Ref<SkeletonAsset> skeleton;
public:
    
    MOVE_NO_COPY(AnimatorComponent);
    static constexpr uint16_t kmax_layers = 32;
 
    //a node in the state machine
    struct State{
        friend class AnimatorComponent;
        anim_id_t ID = 0;
        Ref<IAnimGraphable> clip;
        bool isLooping = true;
        float speed = 1;
        
        double lastPlayTime = 0;
 
        struct Transition{
            enum class TimeMode{
                Blended = 0,    //the time from this state carries over to the target state
                BeginNew = 1    //the target state's time is set to 0 when the transition begins
            } type = TimeMode::Blended;
            tweeny::tween<float> transition;
        };
        
        //transitions out of this state, keyed by ID
        UnorderedMap<decltype(ID),Transition> exitTransitions;
        
        template<typename T, typename decimal>
        constexpr inline State& SetTransition(decltype(ID) id, T interpolation, decimal duration, Transition::TimeMode mode = Transition::TimeMode::Blended){
            auto tween = tweeny::from(0.0f).to(1.0f).during(static_cast<float>(duration * GetApp()->evalNormal)).via(interpolation);
            exitTransitions[id].transition = tween;
            exitTransitions[id].type = mode;
            return *this;
        }
 
        State(decltype(ID) ID, decltype(clip) clip, decltype(isLooping) il = true, decltype(speed) speed = 1) : ID(ID), clip(clip), isLooping(il), speed(speed) {}
 
    private:
        bool hasAutoTransition = false;
        decltype(ID) autoTransitionID = 0;
        Function<void(decltype(State::ID))> beginCallback, endCallback;
 
        inline void DoBegin(decltype(ID) prevState) {
            if (beginCallback) {
                beginCallback(prevState);
            }
        }
 
        inline void DoEnd(decltype(ID) nextState) {
            if (endCallback) {
                endCallback(nextState);
            }
        }
    public:
 
        constexpr inline void SetAutoTransition(decltype(ID) id) {
            hasAutoTransition = true;
            autoTransitionID = id;
        }
 
        constexpr inline void ClearAutoTransition() {
            hasAutoTransition = false;
        }
 
        inline void SetBeginCallback(const decltype(beginCallback)& bc) {
            beginCallback = bc;
        }
 
        inline void SetEndCallback(const decltype(endCallback)& ec) {
            endCallback = ec;
        }
 
        constexpr inline bool HasAutoTransition() const{
            return hasAutoTransition;
        }
 
        constexpr inline decltype(autoTransitionID) GetAutoTransitionID() const {
            return autoTransitionID;
        }
    };
        
    AnimatorComponent(Ref<SkeletonAsset> sk);
        
    struct Layer{
        friend class AnimatorComponent;
        
        Layer(const Layer&) = delete; // no copy
        Layer(Layer&&) = default;   // movable
        Layer(){}
        Layer(const Ref<SkeletonMask>& mask) : skeletonMask(mask){}
        void Goto(anim_id_t newState, bool skipTransition = false);
        
        inline void InsertState(const State& state){
            states.insert(std::make_pair(state.ID,state));
        }
        
        void Play(float resetPlayhead = false);
        
        void Pause();
        
        void UpdateBuffers(const Ref<SkeletonAsset>& skeleton);
        
        auto GetCurrentState() const{
            return currentState;
        }
        
        void SetSkeletonMask(Ref<SkeletonMask> mask) {
            skeletonMask = mask;
        }
        
        auto& GetSkeletonMask() const{
            return skeletonMask;
        }
        
        void SetWeight(float w){
            weight = w;
        }
        float GetWeight() const{
            return weight;
        }
        
        bool SetAdditive(bool additive){
            isAdditive = additive;
        }
        
    private:
        std::optional<Ref<SkeletonMask>> skeletonMask;
        double lastPlayTime = 0;
        float weight = 1;
        bool isAdditive = false;
        State& GetStateForID(anim_id_t id);
        locked_node_hashmap<anim_id_t,State,SpinLock> states;
        
        struct StateBlend{
            anim_id_t from = 0, to = 0;
            decltype(State::Transition::transition) currentTween;
        } stateBlend;
            
        anim_id_t currentState = 0;
        
        bool isPlaying = false;
        bool isBlending = false;
        float currentBlendingValue = 0;
        
        inline void EndState(State& state, decltype(State::ID) nextState) {
            state.DoEnd(nextState);
            if (state.HasAutoTransition()) {
                Goto(state.GetAutoTransitionID());
            }
        }
        
        void Tick(const Ref<SkeletonAsset>& skeleton);
        
        ozz::vector<ozz::math::SoaTransform> transforms, transformsSecondaryBlending;
        std::shared_ptr<ozz::animation::SamplingJob::Context> cache = std::make_shared<ozz::animation::SamplingJob::Context>();
    };
    
 
    void Tick(const Transform& t);
    
    inline decltype(skeleton) GetSkeleton() const{
        return skeleton;
    }
#if !RVE_SERVER
 
    virtual void DebugDraw(RavEngine::DebugDrawer& dbg, const Transform&) const override;
#endif
    
    void UpdateSocket(const std::string&, Transform&) const;
 
protected:
    
    
    mutable ozz::vector<matrix4> glm_pose;
    ozz::vector<matrix4> local_pose;
    ozz::vector<matrix4> skinningmats;
    ozz::vector<ozz::math::Float4x4> models;
    ozz::vector<ozz::math::SoaTransform> all_transforms;
 
    Vector<std::unique_ptr<Layer>> layers;
 
    
    void UpdateSkeletonData(Ref<SkeletonAsset> sk);
 
public:
    
    Layer* AddLayer();
    
    Layer* GetLayerAtIndex(uint16_t index){
        return layers.at(index).get();
    };
    
    const decltype(glm_pose)& GetPose(const Transform& t) const;
    
    const decltype(local_pose)& GetLocalPose();
    
    inline const decltype(skinningmats)& GetSkinningMats(){
        return skinningmats;
    }
    
};
 
}