KeyFramedValue.hpp

#pragma once
 
#include <map>
#include <set>
 
#include <Core/Containers/AlignedAllocator.hpp>
#include <Core/Math/Math.hpp>
#include <Core/Types.hpp>
 
namespace Ra {
namespace Core {
namespace Animation {
 
class RA_CORE_API KeyFramedValueBase
{
  public:
    KeyFramedValueBase() {}
 
    virtual ~KeyFramedValueBase() {}
 
    virtual inline size_t size() const = 0;
 
    virtual inline bool removeKeyFrame( size_t i ) = 0;
 
    virtual inline void moveKeyFrame( size_t i, const Scalar& t ) = 0;
 
    virtual inline std::vector<Scalar> getTimes() const = 0;
};
 
template <typename VALUE_TYPE>
class KeyFramedValue : public KeyFramedValueBase
{
  public:
    using KeyFrame = std::pair<Scalar, VALUE_TYPE>;
 
    using KeyFrames = std::vector<KeyFrame>;
 
    using Interpolator = std::function<VALUE_TYPE( const KeyFramedValue<VALUE_TYPE>&, Scalar )>;
 
    KeyFramedValue( Scalar t, VALUE_TYPE frame ) { insertKeyFrame( t, frame ); }
 
    KeyFramedValue( const KeyFramedValue& keyframe ) = default;
 
    inline KeyFramedValue& operator=( const KeyFramedValue& keyframe ) = default;
 
    inline std::vector<Scalar> getTimes() const override {
        std::vector<Scalar> times( m_keyframes.size() );
#pragma omp parallel for
        for ( int i = 0; i < int( m_keyframes.size() ); ++i ) {
            times[i] = m_keyframes[i].first;
        }
        return times;
    }
 
 
    inline size_t size() const override { return m_keyframes.size(); }
 
    const KeyFrames& getKeyFrames() const { return m_keyframes; }
 
    inline const KeyFrame& operator[]( size_t i ) const { return m_keyframes[i]; }
 
    inline void insertKeyFrame( const Scalar& t, const VALUE_TYPE& frame ) {
        KeyFrame kf( t, frame );
        auto upper = std::upper_bound(
            m_keyframes.begin(), m_keyframes.end(), kf, []( const auto& a, const auto& b ) {
                return a.first < b.first;
            } );
        if ( upper == m_keyframes.begin() ) { m_keyframes.insert( upper, kf ); }
        else {
            auto lower = upper - 1;
            if ( Math::areApproxEqual( lower->first, t ) ) { lower->second = frame; }
            else { m_keyframes.insert( upper, kf ); }
        }
    }
 
    inline void insertInterpolatedKeyFrame( const Scalar& t, const Interpolator& interpolator ) {
        insertKeyFrame( t, at( t, interpolator ) );
    }
 
    inline bool removeKeyFrame( size_t i ) override {
        if ( size() == 1 ) return false;
        m_keyframes.erase( m_keyframes.begin() + i );
        return true;
    }
 
    inline void moveKeyFrame( size_t i, const Scalar& t ) override {
        KeyFrame kf = m_keyframes[i];
        if ( !Ra::Core::Math::areApproxEqual( kf.first, t ) ) {
            removeKeyFrame( i );
            insertKeyFrame( t, kf.second );
        }
    }
 
    inline VALUE_TYPE at( const Scalar& t, const Interpolator& interpolator ) const {
        return interpolator( *this, t );
    }
 
    std::tuple<size_t, size_t, Scalar> findRange( Scalar t ) const {
        // before first
        if ( t < m_keyframes.begin()->first ) { return { 0, 0, 0_ra }; }
        // after last
        if ( t > m_keyframes.rbegin()->first ) {
            const size_t i = m_keyframes.size() - 1;
            return { i, i, 0_ra };
        }
        // look for exact match
        auto kf0   = m_keyframes[0];
        kf0.first  = t;
        auto upper = std::upper_bound(
            m_keyframes.begin(), m_keyframes.end(), kf0, []( const auto& a, const auto& b ) {
                return a.first < b.first;
            } );
 
        // here upper > begin() since before first case is already taken into account.
        auto lower = upper;
        --lower;
        if ( Math::areApproxEqual( lower->first, t ) ) {
            const size_t i = std::distance( m_keyframes.begin(), lower );
            return { i, i, 0_ra };
        }
        // in-between
        const size_t i  = std::distance( m_keyframes.begin(), lower );
        const Scalar t0 = lower->first;
        const Scalar t1 = upper->first;
        return { i, i + 1, ( t - t0 ) / ( t1 - t0 ) };
    }
 
 
    inline bool operator==( const KeyFramedValue& keyframe ) const {
        return ( m_keyframes == keyframe.m_keyframes );
    }
 
    inline bool operator!=( const KeyFramedValue& keyframe ) const {
        return !( *this == keyframe );
    }
 
  protected:
    KeyFrames m_keyframes;
};
 
} // namespace Animation
} // namespace Core
} // namespace Ra