Interpolators.h

#pragma once

#define MAX_ITERATIONS 8

template<class T>
T LinearInterpolation(const float t, const T& P0, const T& P1)
{
        return (T)(P0 + (P1 - P0) * t);

}

template<class T>
T CatmulRomInterpolation(const float t, const T& P0, const T& P1, const T& P2, const T& P3)
{
        static float t2; 
        static float t3; 
        t2 = t*t;
        t3 = t2*t;

        return (T) (0.5f * ( (2.0f * P1) + ( -1.0f * P0 + P2) * t + (2.0f * P0 - 5.0f * P1 + 4.0f * P2 - P3) * t2 + ( -1.0f * P0 + 3.0f * P1 - 3.0f * P2 + P3) * t3));
                        
}
template<class T>
T CatmulRomInterpolationFirstDerivation(const float t, const T& P0, const T& P1, const T& P2, const T& P3)
{
        return (T) 0.5f * ( 3.0f * t*t * (-P0 + 3.0f*P1 - 3.0f*P2 + P3) + 2.0f * t * (2.0f*P0 - 5.0f*P1 +4.0f*P2 - P3) - P0 + P2); 
}

/*
        Cubic Bezier
*/
#pragma region CUBIC_BEZIER
template<class T>
T Bezier3Interpolation(const float t, const T& P0, const T& C0, const T& C1, const T& P1)
{
        static float t2, t3, one_t, one_t2, one_t3;
        t2 = t*t;
        t3 = t2*t;
        one_t = 1 - t;
        one_t2 = one_t * one_t;
        one_t3 = one_t2 * one_t;

        return (T) one_t3*P0 + 3.0f*one_t2*t*C0 + 3.0f*one_t*t2*C1 + t3*P1;
}
template<class T>
T Bezier3InterpolationFirstDerivation(const float t, const T& P0, const T& C0, const T& C1, const T& P1)
{
        static float t2, one_t2;
        t2 = t*t;
        one_t2 = (1 - t) * (1 - t);
        
        return (T) -3.0f * (P0 * one_t2 + C0 * (-3.0f*t2 + 4.0f*t - 1.0f) + t * (3.0f*C1*t - 2.0f*C1 - P1 * t));
}

template<class T>
T Bezier3InterpolationSecondDerivation(const float t, const T& P0, const T& C0, const T& C1, const T& P1)
{
        static float t2, one_t2;
        t2 = t*t;
        one_t2 = (1 - t) * (1 - t);
        
        return (T) -6.0f * (P0 * (t - 1.0f) + C0 * (2.0f - 3.0f*t) + 3.0f*C1*t - C1 - P1 * t);
}

float Bezier3InterpolationInverse(const float value, const float t_guess, float epsilon, const float& P0, const float& C0, const float& C1, const float& P1);


#pragma endregion CUBIC_BEZIER



template<class T>
T Hermite3Interpolation(const float t, const T& P0, const T& C0, const T& C1, const T& P1)
{
        static float t2, t3;
        t2 = t*t;
        t3 = t2*t;
        

        return (T) (2.0*t3 - 3.0*t2 + 1.0)*P0 + (t3 - 2.0*t2 + t)*(C0 - P0) + (-2.0*t3 + 3.0*t2)*(P1) + (t3 - t2)*(C1 - P1);
}

/*
smoothstep performs smooth Hermite interpolation between 0 and 1 when edge0 < x < edge1. This is useful in cases where a threshold function with a smooth transition is desired. smoothstep is equivalent to: 

genType t; 
t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
return t * t * (3.0 - 2.0 * t);

Results are undefined if edge0 ≥ edge1.

clamp returns the value of x constrained to the range minVal to maxVal. The returned value is computed as min(max(x, minVal), maxVal).
*/