animation_track.h

#pragma once
 
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <vector>
 
#include <glm/gtc/quaternion.hpp>
 
#include "core/math/easing.h"
 
namespace Vkm::Engine {

template<typename T>
class AnimationTrack {
    public:
        static constexpr float SAME_INSTANT_SECONDS = 1e-4f;
 
    public:
        AnimationTrack() = default;

        explicit AnimationTrack(Easing easing) : m_easing(easing) {}
 
        ~AnimationTrack() = default;
 
        AnimationTrack(const AnimationTrack& other) = default;
        AnimationTrack& operator=(const AnimationTrack& other) = default;
 
        AnimationTrack(AnimationTrack && other) noexcept = default;
        AnimationTrack& operator=(AnimationTrack && other) noexcept = default;
 
    public:
        size_t addKeyframe(float time, const T& value) {
            auto it = std::upper_bound(m_times.begin(), m_times.end(), time);
            auto index = static_cast<size_t>(it - m_times.begin());
            m_times.insert(it, time);
            m_values.insert(m_values.begin() + index, value);
            return index;
        }

        void setKeyframe(float time, const T& value) {
            for (size_t i = 0; i < m_times.size(); ++i) {
                if (std::fabs(m_times[i] - time) < SAME_INSTANT_SECONDS) {
                    m_values[i] = value;
                    return;
                }
            }
            addKeyframe(time, value);
        }

        void removeKeyframe(size_t index) {
            if (index >= m_times.size()) return;
            m_times.erase(m_times.begin() + static_cast<std::ptrdiff_t>(index));
            m_values.erase(m_values.begin() + static_cast<std::ptrdiff_t>(index));
        }

        void setKeyframeValue(size_t index, const T& value) {
            if (index >= m_values.size()) return;
            m_values[index] = value;
        }

        size_t setKeyframeTime(size_t index, float time) {
            if (index >= m_times.size()) return index;
            T value = m_values[index];
            removeKeyframe(index);
            return addKeyframe(time, value);
        }
 
        void clear() {
            m_times.clear();
            m_values.clear();
        }

        void setEasing(Easing easing) {
            m_easing = easing;
        }

        T getValue(float time) const {
            if (m_times.empty()) {
                return T{};
            }
 
            if (m_times.size() == 1) {
                return m_values[0];
            }
 
            // Otherwise a first key past 0 reaches upper_bound == begin() and underflows prevIndex.
            if (time <= m_times.front()) {
                return m_values.front();
            }
 
            if (time >= m_times.back()) {
                return m_values.back();
            }
 
            // time < m_times.back() here, so upper_bound never returns end().
            auto it = std::upper_bound(m_times.begin(), m_times.end(), time);
 
            const size_t nextIndex = static_cast<size_t>(it - m_times.begin());
            const size_t prevIndex = nextIndex - 1;
 
            float segmentDuration = m_times[nextIndex] - m_times[prevIndex];
            if (segmentDuration <= 0.0f) {
                return m_values[prevIndex];
            }
 
            float t = (time - m_times[prevIndex]) / segmentDuration;
 
            const float eased = easingFunction(m_easing)(t);
 
            return interpolate(m_values[prevIndex], m_values[nextIndex], eased);
        }

        float getDuration() const {
            if (m_times.empty()) {
                return 0.0f;
            }
            return m_times.back();
        }
 
        bool isEmpty() const {
            return m_times.empty();
        }
 
        size_t keyframeCount() const {
            return m_times.size();
        }

        Easing getEasing() const {
            return m_easing;
        }

        const std::vector<float>& getTimes() const { return m_times; }

        const std::vector<T>& getValues() const { return m_values; }
 
    private:
        template<typename U = T>
        static U interpolate(const U& a, const U& b, float t) {
            if constexpr (std::is_same_v<U, glm::quat>) {
                return glm::slerp(a, b, t);
            } else {
                return glm::mix(a, b, t);
            }
        }
 
    private:
        std::vector<float> m_times;   
        std::vector<T>     m_values;  
        Easing             m_easing = Easing::Linear;
};
 
} // namespace Vkm::Engine