smoothdamp.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include <mathutils.h>
 
// External Includes
#include <rtti/rtti.h>
 
namespace nap
{
    namespace math
    {
        class BaseSmoothOperator
        {
            RTTI_ENABLE()
        public:
 
            BaseSmoothOperator() = default;
 
            BaseSmoothOperator(float smoothTime) : mSmoothTime(smoothTime)  { }
 
            BaseSmoothOperator(float smoothTime, float maxSpeed) :
                mSmoothTime(smoothTime),
                mMaxSpeed(maxSpeed)                                         { }
 
            // Default destructor
            virtual ~BaseSmoothOperator() = default;
 
            float mSmoothTime = 1.0f;                       // approximately the time it will take to reach the target. A smaller value will reach the target faster.
            float mMaxSpeed = math::max<float>();           // allows you to clamp the maximum blend speed 
        };
 
 
        template<typename T>
        class SmoothOperator : public BaseSmoothOperator
        {
            RTTI_ENABLE(BaseSmoothOperator)
        public:
            SmoothOperator(const T& currentValue, float smoothTime);
 
            SmoothOperator(const T& currentValue, float smoothTime, float maxSpeed);
 
            T& update(const T& targetValue, float deltaTime);
 
            const T& getValue() const                               { return mValue; }
 
            T& getValue()                                           { return mValue; }
 
            const T& getTarget() const                              { return mTarget; }
 
            T& getTarget()                                          { return mTarget; }
 
            const T& getVelocity() const                            { return mVelocity; }
 
            T& getVelocity()                                        { return mVelocity; }
 
            void setValue(const T& value);
 
        protected:
            void init();
 
            T mValue;           // Current blend value
            T mTarget;          // Current blend target
            T mVelocity;        // Current velocity
        };
 
 
        // Template definitions
 
        template<typename T>
        T& SmoothOperator<T>::update(const T& targetValue, float deltaTime)
        {
            mTarget = targetValue;
            smooth<T>(mValue, targetValue, mVelocity, deltaTime, mSmoothTime, mMaxSpeed);
            return mValue;
        }
 
        template<typename T>
        SmoothOperator<T>::SmoothOperator(const T& currentValue, float smoothTime, float maxSpeed) : BaseSmoothOperator(smoothTime, maxSpeed),
            mValue(currentValue)
        {
            init();
        }
 
        template<typename T>
        SmoothOperator<T>::SmoothOperator(const T& currentValue, float smoothTime) : BaseSmoothOperator(smoothTime), mValue(currentValue)
        {
            init();
        }
 
 
        // Type definitions for all supported smooth operators
 
        using FloatSmoothOperator  = SmoothOperator<float>;
        using DoubleSmoothOperator = SmoothOperator<double>;
        using Vec2SmoothOperator   = SmoothOperator<glm::vec2>;
        using Vec3SmoothOperator   = SmoothOperator<glm::vec3>;
        using Vec4SmoothOperator   = SmoothOperator<glm::vec4>;
 
 
        // Forward declarations
        template<>
        NAPAPI void SmoothOperator<float>::init();
 
        template<>
        NAPAPI void SmoothOperator<double>::init();
 
        template<>
        NAPAPI void SmoothOperator<glm::vec2>::init();
 
        template<>
        NAPAPI void SmoothOperator<glm::vec3>::init();
 
        template<>
        NAPAPI void SmoothOperator<glm::vec4>::init();
 
        template<>
        NAPAPI void SmoothOperator<float>::setValue(const float& value);
 
        template<>
        NAPAPI void SmoothOperator<double>::setValue(const double& value);
 
        template<>
        NAPAPI void SmoothOperator<glm::vec2>::setValue(const glm::vec2& value);
 
        template<>
        NAPAPI void SmoothOperator<glm::vec3>::setValue(const glm::vec3& value);
 
        template<>
        NAPAPI void SmoothOperator<glm::vec4>::setValue(const glm::vec4& value);
    }
}