Interpolator.h

#pragma once
 
#include "EasingFn.h"
#include "Interpolation.hpp"
 
#include "../Platform/Timer.h"
 
#include <glm/vec3.hpp>
#include <glm/ext/quaternion_float.hpp>
#include <glm/ext/quaternion_common.hpp>
#include <glm/gtx/norm.hpp>
 
namespace Cogs {
  template<typename T> inline bool tooCloseFn(const T& s, const T& d) {
    return glm::distance2(s, d) < 0.000001;
  }
 
  template<> inline bool tooCloseFn<glm::quat>(const glm::quat& s, const glm::quat& d) {
    return std::abs(glm::dot(s, d)) > 0.9999;
  }
 
  template<typename T> inline T interpolateFn(const T& s, const T& d, float t) {
    return Interpolation::linear(s, d, t);
  }
 
  template<> inline glm::quat interpolateFn<glm::quat>(const glm::quat& s, const glm::quat& d, float t) {
    return glm::slerp(s, d, t);
  }
 
  template<typename T> class Interpolator {
  public:
            Interpolator(T& destination) : mDestination(destination), mTarget(destination) {
            }
 
            Interpolator(T& destination, const T& target, EasingFn::Ptr fn, float duration) : Interpolator(destination) {
              setTarget(target, fn, duration);
            }
 
            void setTarget(const T& target, EasingFn::Ptr fn, float duration) {
              if (fn && (duration > 0.0f) && !tooCloseFn(mDestination, target)) {
                mStart = mDestination;
                mTarget = target;
                mTimer.start();
                mFunction = fn;
                mDuration = duration;
              }
              else {
                mDestination = target;
                mTarget = target;
                mFunction = nullptr;
              }
            }
 
            void snapToTarget() {
              if (mFunction) {
                mDestination = mTarget;
                mFunction = nullptr;
              }
            }
 
            bool process() {
              if (mFunction) {
                float t = static_cast<float>(mTimer.elapsedSeconds()) / mDuration;
 
                if (t < 1.0f) {
                  mDestination = interpolateFn(mStart, mTarget, mFunction(t));
                }
                else {
                  mDestination = mTarget;
                  mFunction = nullptr;
                }
                return true;
              }
              return false;
            }
 
            void          cancel()                { mFunction = nullptr; }
            bool          isProcessing() const    { return mFunction; }
 
            float         getTime()               { return isProcessing() ? static_cast<float>(mTimer.elapsedSeconds()) : 1.0f; }
            T             getTarget() const       { return mTarget; }
            T             getValue() const        { return mDestination; }
 
  private:
            T&            mDestination;
            T             mStart;
            T             mTarget;
            Timer         mTimer;
            EasingFn::Ptr mFunction = nullptr;
            float         mDuration = 0.0f;
  };
}