tb_interpolation.hpp

 
#ifndef TurtleBrains_Interpolation_hpp
#define TurtleBrains_Interpolation_hpp
 
#include <turtle_brains/math/tb_math.hpp>
#include <turtle_brains/math/tb_constants.hpp>
 
namespace TurtleBrains
{
    namespace Math
    {
        namespace Interpolation // Tweening / Easing
        {
 
            enum class InterpolationMode
            {
                Linear,
                InSquared, 
                OutSquared,
                InOutSquared,
 
                InCubic,
                OutCubic,
                InOutCubic,
 
                InQuartic,
                OutQuartic,
                InOutQuartic,
 
                InQuintic,
                OutQuintic,
                InOutQuintic,
 
                InExponential,
                OutExponential,
                InOutExponential,
 
                InSine,
                OutSine,
                InOutSine,
 
                //Circular,
                //Back,
                InElastic, 
                OutElastic, 
                InOutElastic, 
 
                InBounce,
                OutBounce,
                InOutBounce,
            };
 
            template<typename ScalarType> inline constexpr ScalarType Linear(const ScalarType percentage)
            {
                return percentage;
            }
 
            template<typename Type, typename ScalarType> constexpr Type Linear(const ScalarType percentage, const Type& start, const Type& end)
            {
                return ((end - start) * percentage) + start;
            }
 
 
            template<typename ScalarType> constexpr ScalarType Squared(const ScalarType percentage)
            {
                return percentage * percentage;
            }
 
            template<typename Type, typename ScalarType> Type Squared(const ScalarType percentage, const Type& start, const Type& end)
            {
                return ((end - start) * Squared(percentage)) + start;
            }
 
            template<typename ScalarType> constexpr ScalarType Cubic(const ScalarType percentage)
            {
                return percentage * percentage * percentage;
            }
 
            template<typename Type, typename ScalarType> Type Cubic(const ScalarType percentage, const Type& start, const Type& end)
            {
                return ((end - start) * Cubic(percentage)) + start;
            }
 
            template<typename ScalarType> constexpr ScalarType Quartic(const ScalarType percentage)
            {
                return percentage * percentage * percentage * percentage;
            }
 
            template<typename Type, typename ScalarType> Type Quartic(const ScalarType percentage, const Type& start, const Type& end)
            {
                return ((end - start) * Quartic(percentage)) + start;
            }
 
            template<typename ScalarType> constexpr ScalarType Quintic(const ScalarType percentage)
            {
                return percentage * percentage * percentage * percentage * percentage;
            }
 
            template<typename Type, typename ScalarType> Type Quintic(const ScalarType percentage, const Type& start, const Type& end)
            {
                return ((end - start) * Quintic(percentage)) + start;
            }
 
            template<typename ScalarType> ScalarType Exponential(const ScalarType percentage)
            {
                return std::pow(ScalarType(2.0), ScalarType(10.0) * (percentage - ScalarType(1.0)));
            }
 
            template<typename Type, typename ScalarType> Type Exponential(const ScalarType percentage, const Type& start, const Type& end)
            {
                return ((end - start) * Exponential(percentage)) + start;
            }
 
            template<typename ScalarType> ScalarType Sine(const ScalarType percentage)
            {   //Sin in from http://gizma.com/easing/#sin1 where t/d = percentage, c = 1, b = 0 (time, begin, change, distance)
                return ScalarType(1.0) - cos(percentage * tbMath::Pi<ScalarType>() / ScalarType(2.0));
            }
 
            template<typename Type, typename ScalarType> Type Sine(const ScalarType percentage, const Type& start, const Type& end)
            {
                return ((end - start) * Sine(percentage)) + start;
            }
 
            template<typename ScalarType> ScalarType Elastic(const ScalarType percentage)
            {   //https://github.com/vrld/hump/blob/master/timer.lua#L128L131
                const ScalarType amplitude = ScalarType(1.0);
                const ScalarType period = ScalarType(0.3);
                return (-amplitude * std::sin(tbMath::kTwoPi / period * (percentage - ScalarType(1.0)) -
                    std::asin(ScalarType(1.0) / amplitude))) * std::pow(ScalarType(2.0), (ScalarType(10.0) * (percentage - ScalarType(1.0))));
            }
 
            template<typename ScalarType> ScalarType Elastic(const ScalarType percentage, const ScalarType amplitude, const ScalarType period)
            {   //https://github.com/vrld/hump/blob/master/timer.lua#L128L131
                return (-amplitude * std::sin(tbMath::kTwoPi / period * (percentage - ScalarType(1.0)) -
                    std::asin(ScalarType(1.0) / amplitude))) * std::pow(ScalarType(2.0), (ScalarType(10.0) * (percentage - ScalarType(1.0))));
            }
 
            template<typename Type, typename ScalarType> Type Elastic(const ScalarType percentage, const Type& start, const Type& end)
            {
                return ((end - start) * Elastic(percentage)) + start;
            }
 
            template<typename ScalarType> ScalarType Bounce(const ScalarType percentage)
            {   //https://github.com/vrld/hump/blob/master/timer.lua#L123-L126
                const ScalarType a = ScalarType(7.5625);
                const ScalarType b = ScalarType(1.0f / 2.75);
 
                return tbMath::Minimum(a * percentage * percentage,
                    tbMath::Minimum(a * (percentage - ScalarType(1.5) * b) * (percentage - ScalarType(1.5) * b) + ScalarType(0.75),
                    tbMath::Minimum(a * (percentage - ScalarType(2.25) * b) * (percentage - ScalarType(2.25) * b) + ScalarType(0.9375),
                    a * (percentage - ScalarType(2.625) * b) * (percentage - ScalarType(2.625) * b) + ScalarType(0.984375))));
            }
 
            template<typename Type, typename ScalarType> Type Bounce(const ScalarType percentage, const Type& start, const Type& end)
            {
                return ((end - start) * Bounce(percentage)) + start;
            }
 
 
            //typedef float(*InterpolationFunction)(float);
            template<typename ScalarType> using InterpolationFunction = ScalarType(*)(ScalarType);
 
            template<typename ScalarType> ScalarType Out(const ScalarType percentage, InterpolationFunction<ScalarType> interpolation)
            {
                return ScalarType(1.0) - interpolation(ScalarType(1.0) - percentage);
            }
 
            template<typename Type, typename ScalarType> Type Out(const ScalarType percentage, const Type& start,
                const Type& end, InterpolationFunction<ScalarType> interpolation)
            {
                return ((end - start) * Out(percentage, interpolation)) + start;
            }
 
            template<typename ScalarType> ScalarType InOut(const ScalarType percentage, InterpolationFunction<ScalarType> interpolation)
            {
                return ScalarType(0.5) * ((percentage < ScalarType(0.5)) ? interpolation(ScalarType(2.0) * percentage) :
                    ScalarType(1.0) + Out(ScalarType(2.0) * percentage - ScalarType(1.0), interpolation));
            }
 
            template<typename Type, typename ScalarType> Type InOut(const ScalarType percentage, const Type& start,
                const Type& end, InterpolationFunction<ScalarType> interpolation)
            {
                return ((end - start) * InOut(percentage, interpolation)) + start;
            }
 
            template<typename ScalarType> ScalarType Interpolate(const ScalarType percentage, const InterpolationMode& mode)
            {
                switch (mode)
                {
                case InterpolationMode::Linear: return Linear(percentage);
                case InterpolationMode::InSquared: return Squared(percentage);
                case InterpolationMode::OutSquared: return Out(percentage, Squared);
                case InterpolationMode::InOutSquared: return InOut(percentage, &Squared);
 
                case InterpolationMode::InCubic: return Cubic(percentage);
                case InterpolationMode::OutCubic: return Out(percentage, Cubic);
                case InterpolationMode::InOutCubic: return InOut(percentage, &Cubic);
 
                case InterpolationMode::InQuartic: return Quartic(percentage);
                case InterpolationMode::OutQuartic: return Out(percentage, Quartic);
                case InterpolationMode::InOutQuartic: return InOut(percentage, &Quartic);
 
                case InterpolationMode::InQuintic: return Quintic(percentage);
                case InterpolationMode::OutQuintic: return Out(percentage, Quintic);
                case InterpolationMode::InOutQuintic: return InOut(percentage, &Quintic);
 
                case InterpolationMode::InExponential: return Exponential(percentage);
                case InterpolationMode::OutExponential: return Out(percentage, Exponential);
                case InterpolationMode::InOutExponential: return InOut(percentage, &Exponential);
 
                case InterpolationMode::InSine: return Sine(percentage);
                case InterpolationMode::OutSine: return Out(percentage, Sine);
                case InterpolationMode::InOutSine: return InOut(percentage, &Sine);
 
                case InterpolationMode::InElastic: return Elastic(percentage);
                case InterpolationMode::OutElastic: return Out(percentage, Elastic);
                case InterpolationMode::InOutElastic: return InOut(percentage, &Elastic);
 
                case InterpolationMode::InBounce: return Bounce(percentage);
                case InterpolationMode::OutBounce: return Out(percentage, Bounce);
                case InterpolationMode::InOutBounce: return InOut(percentage, &Bounce);
                }
 
                tb_error("tbInternalError: Unhandled case for InterpolationMode: %d\n", mode);
                return ScalarType(0.0);
            }
 
            template<typename Type, typename ScalarType> Type Interpolate(const ScalarType percentage,
                const Type& start, const Type& end, const InterpolationMode& mode)
            {
                return ((end - start) * Interpolate(percentage, mode)) + start;
            }
 
 
            template<typename ScalarType> ScalarType SmoothStep(const ScalarType percentage)
            {
                return (percentage * percentage * (ScalarType(3.0) - ScalarType(2.0) * percentage));
            }
 
            template<typename Type, typename ScalarType> Type SmoothStep(const ScalarType percentage, const Type& start, const Type& end)
            {
                const float smoothPercentage = SmoothStep(percentage);
                return (start * smoothPercentage) + (end * (ScalarType(1.0) - smoothPercentage));
            }
 
            template<typename Type, typename ScalarType> Type CubicBezier(const ScalarType percentage,
                const Type& a, const Type& b, const Type& c, const Type& d)
            {
                //In this version A is start, B is final, C and D are control points.
                //const Type tempA = Linear(percentage, a, c);
                //const Type tempB = Linear(percentage, c, d);
                //const Type tempC = Linear(percentage, d, b);
                //The following A is start, B and C are control points and D is final.
                const Type tempA = Linear(percentage, a, b);
                const Type tempB = Linear(percentage, b, c);
                const Type tempC = Linear(percentage, c, d);
 
                const Type tempAA = Linear(percentage, tempA, tempB);
                const Type tempBB = Linear(percentage, tempB, tempC);
 
                return Linear(percentage, tempAA, tempBB);
            }
 
            template<typename Type, typename ScalarType> Type CubicBezierTangent(const ScalarType percentage,
                const Type& a, const Type& b, const Type& c, const Type& d)
            {   //Source: http://stackoverflow.com/questions/4089443/find-the-tangent-of-a-point-on-a-cubic-bezier-curve-on-an-iphone
                const ScalarType kThree = ScalarType(3.0);
                const Type c1(d - (kThree * c) + (kThree * b) - a);
                const Type c2((kThree * c) - (ScalarType(6.0) * b) + (kThree * a));
                const Type c3((kThree * b) - (kThree * a));
                //const float c4(a);
 
                return ((c1 * (kThree * percentage * percentage)) + (c2 * (ScalarType(2.0) * percentage)) + c3);
            }
 
        }; /* namespace Interpolation */
    }; /* namespace Math */
}; /* namespace TurtleBrains */
 
namespace tbMath = TurtleBrains::Math;
 
#endif /* TurtleBrains_Interpolation_hpp */