Easing.cpp

#include "Easing.h"
#include <deki/Math.h>
#include <cmath>

namespace DekiTween
{
namespace Ease
{

// Easing math runs in plain float. Angles are in radians, as everywhere in the
// engine, so the trig calls take Penner's arguments as they are ("t * pi" is
// "t * Deki::Math::kPi", "t * pi/2" is "t * kHalfPi").

float Linear(float t)
{
    return t;
}

// Sine
float SineIn(float t)
{
    // 1 - cos((pi/2) * t)
    return 1.0f - std::cos(t * Deki::Math::kHalfPi);
}

float SineOut(float t)
{
    return std::sin(t * Deki::Math::kHalfPi);
}

float SineInOut(float t)
{
    // (1 - cos(pi*t)) / 2
    return (1.0f - std::cos(t * Deki::Math::kPi)) * 0.5f;
}

// Quad
float QuadIn(float t)
{
    return t * t;
}

float QuadOut(float t)
{
    float inv = 1.0f - t;
    return 1.0f - inv * inv;
}

float QuadInOut(float t)
{
    if (t < 0.5f)
    {
        return 2.0f * t * t;
    }
    float base = 2.0f - 2.0f * t;
    return 1.0f - (base * base) * 0.5f;
}

// Cubic
float CubicIn(float t)
{
    return t * t * t;
}

float CubicOut(float t)
{
    float inv = 1.0f - t;
    return 1.0f - inv * inv * inv;
}

float CubicInOut(float t)
{
    if (t < 0.5f)
    {
        return 4.0f * t * t * t;
    }
    float base = 2.0f - 2.0f * t;
    return 1.0f - (base * base * base) * 0.5f;
}

// Quart
float QuartIn(float t)
{
    float t2 = t * t;
    return t2 * t2;
}

float QuartOut(float t)
{
    float inv = 1.0f - t;
    float inv2 = inv * inv;
    return 1.0f - inv2 * inv2;
}

float QuartInOut(float t)
{
    if (t < 0.5f)
    {
        float t2 = t * t;
        return 8.0f * t2 * t2;
    }
    float base = 2.0f - 2.0f * t;
    float base2 = base * base;
    return 1.0f - (base2 * base2) * 0.5f;
}

// Quint
float QuintIn(float t)
{
    float t2 = t * t;
    return t2 * t2 * t;
}

float QuintOut(float t)
{
    float inv = 1.0f - t;
    float inv2 = inv * inv;
    return 1.0f - inv2 * inv2 * inv;
}

float QuintInOut(float t)
{
    if (t < 0.5f)
    {
        float t2 = t * t;
        return 16.0f * t2 * t2 * t;
    }
    float base = 2.0f - 2.0f * t;
    float base2 = base * base;
    return 1.0f - (base2 * base2 * base) * 0.5f;
}

// Expo
float ExpoIn(float t)
{
    if (t == 0.0f)
    {
        return 0.0f;
    }
    return std::pow(2.0f, 10.0f * t - 10.0f);
}

float ExpoOut(float t)
{
    if (t == 1.0f)
    {
        return 1.0f;
    }
    return 1.0f - std::pow(2.0f, -10.0f * t);
}

float ExpoInOut(float t)
{
    if (t == 0.0f)
    {
        return 0.0f;
    }
    if (t == 1.0f)
    {
        return 1.0f;
    }
    if (t < 0.5f)
    {
        return std::pow(2.0f, 20.0f * t - 10.0f) * 0.5f;
    }
    return (2.0f - std::pow(2.0f, 10.0f - 20.0f * t)) * 0.5f;
}

// Circ
float CircIn(float t)
{
    return 1.0f - std::sqrt(1.0f - t * t);
}

float CircOut(float t)
{
    float tm1 = t - 1.0f;
    return std::sqrt(1.0f - tm1 * tm1);
}

float CircInOut(float t)
{
    if (t < 0.5f)
    {
        float twoT = 2.0f * t;
        return (1.0f - std::sqrt(1.0f - twoT * twoT)) * 0.5f;
    }
    float base = 2.0f - 2.0f * t;
    return (std::sqrt(1.0f - base * base) + 1.0f) * 0.5f;
}

// Back constants (Penner: c1 = 1.70158, c2 = c1 * 1.525, c3 = c1 + 1).
static constexpr float kBackC1 = 1.70158f;
static constexpr float kBackC2 = 1.70158f * 1.525f;
static constexpr float kBackC3 = 1.70158f + 1.0f;

float BackIn(float t)
{
    // c3*t^3 - c1*t^2
    float t2 = t * t;
    return kBackC3 * t2 * t - kBackC1 * t2;
}

float BackOut(float t)
{
    // 1 + c3*(t-1)^3 + c1*(t-1)^2
    float tm1 = t - 1.0f;
    float tm12 = tm1 * tm1;
    return 1.0f + kBackC3 * tm12 * tm1 + kBackC1 * tm12;
}

float BackInOut(float t)
{
    if (t < 0.5f)
    {
        float twoT = 2.0f * t;
        return (twoT * twoT * ((kBackC2 + 1.0f) * twoT - kBackC2)) * 0.5f;
    }
    float base = 2.0f * t - 2.0f;
    return (base * base * ((kBackC2 + 1.0f) * (t * 2.0f - 2.0f) + kBackC2) + 2.0f) * 0.5f;
}

// Elastic. Penner uses sin arguments in radians: (2pi)/3 and (2pi)/4.5.
static constexpr float kElasticC4Rad = 2.0f * Deki::Math::kPi / 3.0f;
static constexpr float kElasticC5Rad = 2.0f * Deki::Math::kPi / 4.5f;

float ElasticIn(float t)
{
    if (t == 0.0f)
    {
        return 0.0f;
    }
    if (t == 1.0f)
    {
        return 1.0f;
    }
    float amp = std::pow(2.0f, 10.0f * t - 10.0f);
    float phaseRad = (t * 10.0f - 10.75f) * kElasticC4Rad;
    return -amp * std::sin(phaseRad);
}

float ElasticOut(float t)
{
    if (t == 0.0f)
    {
        return 0.0f;
    }
    if (t == 1.0f)
    {
        return 1.0f;
    }
    float amp = std::pow(2.0f, -10.0f * t);
    float phaseRad = (t * 10.0f - 0.75f) * kElasticC4Rad;
    return amp * std::sin(phaseRad) + 1.0f;
}

float ElasticInOut(float t)
{
    if (t == 0.0f)
    {
        return 0.0f;
    }
    if (t == 1.0f)
    {
        return 1.0f;
    }
    float phaseRad = (20.0f * t - 11.125f) * kElasticC5Rad;
    float s = std::sin(phaseRad);
    if (t < 0.5f)
    {
        float amp = std::pow(2.0f, 20.0f * t - 10.0f);
        return -(amp * s) * 0.5f;
    }
    float amp = std::pow(2.0f, 10.0f - 20.0f * t);
    return (amp * s) * 0.5f + 1.0f;
}

// Bounce. n1 = 7.5625, d1 = 2.75. Splits 0..1 into four bounces.
static constexpr float kBounceN1 = 7.5625f;
static constexpr float kBounceT1 = 1.0f / 2.75f;
static constexpr float kBounceT2 = 2.0f / 2.75f;
static constexpr float kBounceT3 = 2.5f / 2.75f;
static constexpr float kBounceO1 = 1.5f / 2.75f;
static constexpr float kBounceO2 = 2.25f / 2.75f;
static constexpr float kBounceO3 = 2.625f / 2.75f;
static constexpr float kBounceB2 = 0.75f;
static constexpr float kBounceB3 = 0.9375f;
static constexpr float kBounceB4 = 0.984375f;

static float BounceOutImpl(float t)
{
    if (t < kBounceT1)
    {
        return kBounceN1 * t * t;
    }
    else if (t < kBounceT2)
    {
        float tt = t - kBounceO1;
        return kBounceN1 * tt * tt + kBounceB2;
    }
    else if (t < kBounceT3)
    {
        float tt = t - kBounceO2;
        return kBounceN1 * tt * tt + kBounceB3;
    }
    else
    {
        float tt = t - kBounceO3;
        return kBounceN1 * tt * tt + kBounceB4;
    }
}

float BounceIn(float t)
{
    return 1.0f - BounceOutImpl(1.0f - t);
}

float BounceOut(float t)
{
    return BounceOutImpl(t);
}

float BounceInOut(float t)
{
    if (t < 0.5f)
    {
        return (1.0f - BounceOutImpl(1.0f - 2.0f * t)) * 0.5f;
    }
    return (1.0f + BounceOutImpl(2.0f * t - 1.0f)) * 0.5f;
}

EasingFunc GetFunction(EaseType type)
{
    switch (type)
    {
        case EaseType::Linear: return Linear;
        case EaseType::SineIn: return SineIn;
        case EaseType::SineOut: return SineOut;
        case EaseType::SineInOut: return SineInOut;
        case EaseType::QuadIn: return QuadIn;
        case EaseType::QuadOut: return QuadOut;
        case EaseType::QuadInOut: return QuadInOut;
        case EaseType::CubicIn: return CubicIn;
        case EaseType::CubicOut: return CubicOut;
        case EaseType::CubicInOut: return CubicInOut;
        case EaseType::QuartIn: return QuartIn;
        case EaseType::QuartOut: return QuartOut;
        case EaseType::QuartInOut: return QuartInOut;
        case EaseType::QuintIn: return QuintIn;
        case EaseType::QuintOut: return QuintOut;
        case EaseType::QuintInOut: return QuintInOut;
        case EaseType::ExpoIn: return ExpoIn;
        case EaseType::ExpoOut: return ExpoOut;
        case EaseType::ExpoInOut: return ExpoInOut;
        case EaseType::CircIn: return CircIn;
        case EaseType::CircOut: return CircOut;
        case EaseType::CircInOut: return CircInOut;
        case EaseType::BackIn: return BackIn;
        case EaseType::BackOut: return BackOut;
        case EaseType::BackInOut: return BackInOut;
        case EaseType::ElasticIn: return ElasticIn;
        case EaseType::ElasticOut: return ElasticOut;
        case EaseType::ElasticInOut: return ElasticInOut;
        case EaseType::BounceIn: return BounceIn;
        case EaseType::BounceOut: return BounceOut;
        case EaseType::BounceInOut: return BounceInOut;
        default: return Linear;
    }
}

}  // namespace Ease
}  // namespace DekiTween