KeyframeAnimation.hpp

#pragma once
#ifndef KJY_ANIM_ENGINE_COMPONENTS_POSE_KEYFRAME_ANIMATION_HPP_
#define KJY_ANIM_ENGINE_COMPONENTS_POSE_KEYFRAME_ANIMATION_HPP_
#include <map>
#include <stdint.h>
#include <exception>
#include <util/common.h>
#include "Pose.hpp"
#include "AttachableComponent.hpp"
#include <util/UUID.hpp>
#include <vector>

/* Time as milliseconds from start of animation */
typedef size_t key_time_t;

key_time_t seconds_to_key_time(double seconds);
double key_time_to_seconds(key_time_t time);

/* Based on gltf 2.0 standard */
enum class InterpolationType{interp_step, interp_linear, interp_cubicspline}; 

template<typename T>
struct KeyframeTemplate{
    KeyframeTemplate<T>() {};
    KeyframeTemplate<T>(const T& t) : mKeyValue(t) {}
    KeyframeTemplate<T>(const T& t, const T& aInTangent, const T& aOutTangent) : mKeyValue(t), mInTangent(aInTangent), mOutTangent(aOutTangent) {}
    using property_t = T;

    T mKeyValue;
    T mInTangent, mOutTangent; // For cubic interpolation
    InterpolationType mInterpolationType = InterpolationType::interp_linear;

    virtual const T& getKeyValue() const {return(mKeyValue);}
    virtual void setKeyValue(const T& value){mKeyValue = value;}

    T interpolate_with_other(const KeyframeTemplate& other, double parameter) const = delete;
};

class ChannelNoKeyframeException : public std::exception{
 public:
    ChannelNoKeyframeException(const std::string& find_hint, size_t time_ms) : _whatstr("No keyframe exists to be returned when calling " + find_hint + "with timecode " + std::to_string(time_ms)){}
    const char* what() const noexcept {
        return(_whatstr.c_str());
    }
    
 private:
    const std::string _whatstr;
};

template<typename keyframe_t>
class KeyedPropertyChannelTemplate : public std::map<key_time_t, keyframe_t>
{
 public:
    using property_t = typename keyframe_t::property_t;

    inline const keyframe_t& at_index(size_t index) const {
        assert(this->size() > index);
        return(std::next(this->begin(), index)->second);
    }
    inline keyframe_t& at_index(size_t index) {
        assert(this->size() > index);
        return(std::next(this->begin(), index)->second);
    }

    inline key_time_t getLength() const {return(this->size() == 0 ? 0 : this->rbegin()->first);}
    std::pair<key_time_t, const keyframe_t&> getNearestKey(key_time_t time_ms) const;
    std::pair<key_time_t, const keyframe_t&> getNearestKeyBefore(key_time_t time_ms) const;
    std::pair<key_time_t, const keyframe_t&> getNearestKeyAfter(key_time_t time_ms) const;

    property_t sample(key_time_t time_ms) const;

 private:
    property_t _mFallbackValue;
};


struct Vec3Keyframe : public KeyframeTemplate<glm::vec3>{
    using keyframe_template = KeyframeTemplate<glm::vec3>;
    using keyframe_template::keyframe_template;
    using property_t = keyframe_template::property_t; // aka vec3

    property_t interpolate_with_other(const Vec3Keyframe& other, double parameter) const;
};

struct QuatKeyframe : public KeyframeTemplate<glm::quat>{
    using keyframe_template = KeyframeTemplate<glm::quat>;
    using keyframe_template::keyframe_template;
    using property_t = keyframe_template::property_t; // aka quat

    property_t interpolate_with_other(const QuatKeyframe& other, double parameter) const;
};

template<typename P>
struct PropertyAnimationSequence{
    using property_t = P;
    virtual key_time_t getLength() const = 0;
    virtual property_t sample(key_time_t time_ms) const = 0;
    virtual void sampleInPlace(key_time_t time, P& target_prop) const = 0;
};

template<typename P, typename K>
struct MultiPropertyAnimationSequence{
    using property_t = P;
    using key_t = K;
    virtual key_time_t getLength() const = 0;
    virtual property_t sample(K key, key_time_t time_ms) const = 0;
    virtual void sampleInPlace(K key, key_time_t time, P& target_prop) const = 0;
};

/* Defines a collection of Keyframe sequences. Each sequence in association with
 * a key of type K which should indicate something about the target of this
 * sequence of keyframes */
template<typename Sequence, typename K>
class AnimationSequenceCollection : public std::map<K, Sequence>{
 public:
    using inherited_map = std::map<K, Sequence>;
    using inherited_map::inherited_map;
    using sequence_selection = typename inherited_map::iterator;
    using const_sequence_selection = typename inherited_map::const_iterator;
    key_time_t getLength() const{
        key_time_t max = 0;
        for(auto pair_iter = this->begin(); pair_iter != this->end(); pair_iter++){
            key_time_t seq_len = pair_iter->second.getLength();
            max = max < seq_len ? seq_len : max;
        }
        return(max);
    }
};

class Animator : virtual public AttachableComponent{
 public:
    virtual key_time_t getCurrentTime() const = 0;
    virtual void setCurrentTime(key_time_t time) = 0;
    virtual std::string getAnimatorName() const = 0;
    virtual void setAnimatorName(const std::string& name) = 0;
    virtual bool isEnabled() const = 0;
    virtual void enable() = 0;
    virtual void disable() = 0;
    virtual bool willLoop() const = 0;
    virtual void enableLoop() = 0;
    virtual void disableLoop() = 0;
    /* Override the time index at which the animation loops. */
    virtual void overrideLoopTime(key_time_t time) = 0;
    /* Reset loop time to the default (The length of the animation) */
    virtual void resetLoopTime() = 0;

    /* Return the length in ms of the animator's animation (or the active animation if multiple are managed) */
    virtual key_time_t getLength() const = 0;
};

typedef std::vector<Animator*> AnimatorCollection;

class PoseKeyframeSequence : public PropertyAnimationSequence<Pose>{
 protected:
    struct PoseKeyframeChannels{
        KeyedPropertyChannelTemplate<Vec3Keyframe> translation;
        KeyedPropertyChannelTemplate<Vec3Keyframe> scale;
        KeyedPropertyChannelTemplate<QuatKeyframe> orientation;

        /* Insert keyframe for all pose properties at `time` */
        void keyPose(key_time_t time, const Pose& pose);

        inline key_time_t getLength() const {return(MAX(translation.getLength(), MAX(scale.getLength(), orientation.getLength())));}
    };

 public:
    PoseKeyframeSequence(){}
    PoseKeyframeSequence(const Pose& initial_pose) : _underlying_pose_(initial_pose) {}


    std::string name;
    PoseKeyframeChannels keyframes;

    inline key_time_t getLength() const {return(keyframes.getLength());}
    inline void setUnderlyingPose(const Pose& pose) {_underlying_pose_ = pose;}
    Pose sample(key_time_t time_ms) const;
    void sampleInPlace(key_time_t time_ms, Pose& target) const;
    Pose sample(key_time_t time_ms, const Pose& initial_state) const;

 private:
   Pose _underlying_pose_;
};

class PoseKeyframeAnimator : public Animator{
 public:
    /* Collection of pose keyframe sequences' that map to a specific entity UUID */
    using SequenceCollection = AnimationSequenceCollection<PoseKeyframeSequence, uuid_t>;
    SequenceCollection animations;

    PoseKeyframeAnimator(){}
    PoseKeyframeAnimator(const Pose& fallback) : _fallback_pose_(fallback){}

    virtual key_time_t getCurrentTime() const override;
    virtual void setCurrentTime(key_time_t time) override;
    virtual std::string getAnimatorName() const override;
    virtual void setAnimatorName(const std::string& name) override;
    virtual void setFallbackPose(const Pose& fallback) {_fallback_pose_ = fallback;}
    virtual key_time_t getLength() const override ;

    virtual bool isEnabled() const override {return(_enabled);}
    virtual void enable() override {_enabled = true;}
    virtual void disable() override {_enabled = false;}

    virtual bool willLoop() const override {return(_loops);}
    virtual void enableLoop() override {_loops = true;};
    virtual void disableLoop() override {_loops = false;}
    /* Override the time index at which the animation loops. A time value of 0 resets to the default */
    virtual void overrideLoopTime(key_time_t time) override {_loop_time = time;}
    /* Reset loop time to the default (The length of the animation) */
    virtual void resetLoopTime() override {_loop_time = 0;}

 protected:
    std::string _animation_name;
    key_time_t _current_time;

    bool _enabled = true;
    bool _loops = true;
    key_time_t _loop_time = 0;


 private:
    Pose _fallback_pose_;
};


#endif