tb_interpolation.h

#ifndef _TurtleBrains_Interpolation_h_
#define _TurtleBrains_Interpolation_h_

namespace TurtleBrains
{
    namespace Math
    {
        namespace Interpolation
        {

            inline float Linear(float percentage)
            {
                return percentage;
            }

            template <typename T> T Linear(float percentage, const T& start, const T& final)
            {
                //return (p * a) + (b * (1 - p));
                return start + ((final - start) * percentage);
            }

            inline float SmoothStep(float percentage)
            {
                return (percentage * percentage * (3.0f - 2.0f * percentage));
            }

            template <typename T> T SmoothStep(float percentage, const T& start, const T& end)
            {
                const float smoothPercentage = SmoothStep(percentage);
                return (start * smoothPercentage) + (end * (1.0f - smoothPercentage));
            }

            inline float Squared(float percentage)
            {
                return percentage * percentage;
            }

            template <typename T> T Squared(float percentage, const T& start, const T& end)
            {
                const float squaredPercentage = Squared(percentage);
                return (squaredPercentage * start) + (end * (1.0f - squaredPercentage));
            }

            inline float InverseSquared(float percentage)
            {
                return 1.0f - ((1.0f - percentage) * (1.0f - percentage));
            }

            template <typename T> T InverseSquared(float percentage, const T& start, const T& end)
            {
                const float inverseSquared = InverseSquared(percentage);
                return (inverseSquared * start) + (end * (1.0f - inverseSquared));
            }

            template <typename T> T CubicBezier(float percentage, const T& a, const T& b, const T& c, const T& d)
            {
                const T tempA = Linear(percentage, a, c);
                const T tempB = Linear(percentage, c, d);
                const T tempC = Linear(percentage, d, b);

                const T tempAA = Linear(percentage, tempA, tempB);
                const T tempBB = Linear(percentage, tempB, tempC);

                return Linear(percentage, tempAA, tempBB);
            }

            template <typename T> T CubicBezierTangent(float percentage, const T& a, const T& b, const T& c, const T& d)
            {   //Source: http://stackoverflow.com/questions/4089443/find-the-tangent-of-a-point-on-a-cubic-bezier-curve-on-an-iphone

                const T c1(d - (3.0f * c) + (3.0f * b) - a);
                const T c2((3.0f * c) - (6.0f * b) + (3.0f * a));
                const T c3((3.0f * b) - (3.0f * a));
                //const float c4(a);

                return ((c1 * (3.0f * percentage * percentage)) + (c2 * (2.0f * percentage)) + c3);
            }

        }; /* namespace Interpolation */
    }; /* namespace Math */
}; /* namespace TurtleBrains */

namespace tbMath = TurtleBrains::Math;

#endif /* _TurtleBrains_Interpolation_h_ */