Easing.pde

/*
 * Easing.pde - brings Robert Penner's easing functions into Processing
 * (c) 2015 cocopon.
 *
 * See the following to learn more about these famous functions:
 * http://www.robertpenner.com/easing/
 *
 * License:
 * http://www.robertpenner.com/easing_terms_of_use.html
 */

/*
 * Usage:
 *
 * 1. Put this file in the same folder as your sketch.
 *   + your_sketch/
 *   |-- your_sketch.pde
 *   |-- Easing.pde
 *   |-- ...
 *
 * 2. Enjoy!
 *   // Easier way to use an easing function
 *   // (t: 0.0 ~ 1.0)
 *   float value = easeOutBack(t);
 *   ...
 *
 *   // You can also instanciate an easing function
 *   Easing easing = new EasingOutBack();
 *   float value = easing.get(t);
 *   ...
 *
 *   // Or using an anonymous class to instanciate a custom easing function
 *   Easing easing = new Easing() {
 *     public float get(float t) {
 *       return sqrt(t);
 *     }
 *   };
 *   float value = easing.get(t);
 *   ...
 */

public interface Easing {
    public float get(float t);
}

public class EasingLinear implements Easing {
    public float get(float t) {
        return t;
    }
}

public class EasingInBack implements Easing {
    public float get(float t, float s) {
        return t * t * ((s + 1) * t - s);
    }

    public float get(float t) {
        return get(t, 1.70158);
    }
}

public class EasingInBounce implements Easing {
    public float get(float t) {
        t = 1.0 - t;

        if (t < 1 / 2.75) {
            return 1.0 - (7.5625 * t * t);
        }
        if (t < 2 / 2.75) {
            t -= 1.5 / 2.75;
            return 1.0 - (7.5625 * t * t + 0.75);
        }
        if (t < 2.5 / 2.75) {
            t -= 2.25 / 2.75;
            return 1.0 - (7.5625 * t * t + 0.9375);
        }

        t -= 2.625 / 2.75;
        return 1.0 - (7.5625 * t * t + 0.984375);
    }
}

public class EasingInCirc implements Easing {
    public float get(float t) {
        return -(sqrt(1 - t * t) - 1);
    }
}

public class EasingInCubic implements Easing {
    public float get(float t) {
        return t * t * t;
    }
}

public class EasingInElastic implements Easing {
    public float get(float t, float s) {
        float p = 0.3;
        float a = 1.0;

        if (t == 0) {
            return 0;
        }
        if (t == 1.0) {
            return 1.0;
        }

        if (a < 1.0) {
            a = 1.0;
            s = p / 4;
        }
        else {
            s = p / (2 * 3.1419) * asin(1.0 / a);
        }

        --t;
        return -(a * pow(2, 10 * t) * sin((t - s) * (2 * 3.1419) / p));
    }

    public float get(float t) {
        return get(t, 1.70158);
    }
}

public class EasingInExpo implements Easing {
    public float get(float t) {
        return (t == 0)
                ? 0
                : pow(2, 10 * (t - 1));
    }
}

public class EasingInQuad implements Easing {
    public float get(float t) {
        return t * t;
    }
}

public class EasingInQuart implements Easing {
    public float get(float t) {
        return t * t * t * t;
    }
}

public class EasingInQuint implements Easing {
    public float get(float t) {
        return t * t * t * t * t;
    }
}

public class EasingInSine implements Easing {
    public float get(float t) {
        return -cos(t * (PI / 2)) + 1.0;
    }
}

public class EasingOutBack implements Easing {
    public float get(float t, float s) {
        --t;
        return t * t * ((s + 1.0) * t + s) + 1.0;
    }

    public float get(float t) {
        return get(t, 1.70158);
    }
}

public class EasingOutBounce implements Easing {
    public float get(float t) {
        if (t < 1 / 2.75) {
            return 7.5625 * t * t;
        }
        if (t < 2 / 2.75) {
            t -= 1.5 / 2.75;
            return 7.5625 * t * t + 0.75;
        }
        if (t < 2.5 / 2.75) {
            t -= 2.25 / 2.75;
            return 7.5625 * t * t + 0.9375;
        }

        t -= 2.625 / 2.75;
        return 7.5625 * t * t + 0.984375;
    }
}

public class EasingOutCirc implements Easing {
    public float get(float t) {
        --t;
        return sqrt(1 - t * t);
    }
}

public class EasingOutCubic implements Easing {
    public float get(float t) {
        --t;
        return t * t * t + 1;
    }
}

public class EasingOutElastic implements Easing {
    public float get(float t, float s) {
        float p = 0.3;
        float a = 1.0;

        if (t == 0) {
            return 0;
        }
        if (t == 1.0) {
            return 1.0;
        }

        if (a < 1.0) {
            a = 1.0;
            s = p / 4;
        }
        else {
            s = p / (2 * 3.1419) * asin(1.0 / a);
        }
        return a * pow(2, -10 * t) * sin((t - s) * (2 * 3.1419) / p) + 1.0;
    }

    public float get(float t) {
        return get(t, 1.70158);
    }
}

public class EasingOutExpo implements Easing {
    public float get(float t) {
        return (t == 1.0)
                ? 1.0
                : (-pow(2, -10 * t) + 1);
    }
}

public class EasingOutQuad implements Easing {
    public float get(float t) {
        return -t * (t - 2);
    }
}

public class EasingOutQuart implements Easing {
    public float get(float t) {
        --t;
        return 1.0 - t * t * t * t;
    }
}

public class EasingOutQuint implements Easing {
    public float get(float t) {
        --t;
        return t * t * t * t * t + 1;
    }
}

public class EasingOutSine implements Easing {
    public float get(float t) {
        return sin(t * (PI / 2));
    }
}

public class EasingInOutBack implements Easing {
    public float get(float t, float s) {
        float k = 1.525;

        t *= 2;
        s *= k;

        if (t < 1) {
            return 0.5 * (t * t * ((s + 1) * t - s));
        }
        t -= 2;
        return 0.5 * (t * t * ((s + 1) * t + s) + 2);
    }

    public float get(float t) {
        return get(t, 1.70158);
    }
}

public class EasingInOutBounce implements Easing {
    Easing inBounce_ = new EasingInBounce();
    Easing outBounce_ = new EasingOutBounce();

    public float get(float t) {
        return (t < 0.5)
                ? (inBounce_.get(t * 2) * 0.5)
                : (outBounce_.get(t * 2 - 1.0) * 0.5 + 0.5);
    }
}

public class EasingInOutCirc implements Easing {
    public float get(float t) {
        t *= 2;

        if (t < 1) {
            return -0.5 * (sqrt(1 - t * t) - 1);
        }

        t -= 2;
        return 0.5 * (sqrt(1 - t * t) + 1);
    }
}

public class EasingInOutCubic implements Easing {
    public float get(float t) {
        t *= 2;

        if (t < 1) {
            return 0.5 * t * t * t;
        }

        t -= 2;
        return 0.5 * (t * t * t + 2);
    }
}

public class EasingInOutElastic implements Easing {
    public float get(float t, float s) {
        float p =  0.3 * 1.5;
        float a = 1.0;

        if (t == 0) {
            return 0;
        }
        if (t == 1.0) {
            return 1.0;
        }

        if (a < 1.0) {
            a = 1.0;
            s = p / 4;
        }
        else {
            s = p / (2 * 3.1419) * asin(1.0 / a);
        }

        if (t < 1) {
            --t;
            return -0.5 * (a * pow(2, 10 * t) * sin((t - s) * (2 * 3.1419) / p));
        }
        --t;
        return a * pow(2, -10 * t) * sin((t - s) * (2 * 3.1419) / p) * 0.5 + 1.0;
    }

    public float get(float t) {
        return get(t, 1.70158);
    }
}

public class EasingInOutExpo implements Easing {
    public float get(float t) {
        if (t == 0) {
            return 0;
        }
        if (t == 1.0) {
            return 1.0;
        }

        t *= 2;
        if (t < 1) {
            return 0.5 * pow(2, 10 * (t - 1));
        }

        --t;
        return 0.5 * (-pow(2, -10 * t) + 2);
    }
}

public class EasingInOutQuad implements Easing {
    public float get(float t) {
        t *= 2;

        if (t < 1) {
            return 0.5 * t * t;
        }

        --t;
        return -0.5 * (t * (t - 2) - 1);
    }
}

public class EasingInOutQuart implements Easing {
    public float get(float t) {
        t *= 2;

        if (t < 1) {
            return 0.5 * t * t * t * t;
        }

        t -= 2;
        return -0.5 * (t * t * t * t - 2);
    }
}

public class EasingInOutQuint implements Easing {
    public float get(float t) {
        t *= 2;

        if (t < 1) {
            return 0.5 * t * t * t * t * t;
        }

        t -= 2;
        return 0.5 * (t * t * t * t * t + 2);
    }
}

public class EasingInOutSine implements Easing {
    public float get(float t) {
        return -0.5 * (cos(PI * t) - 1);
    }
}

Easing easeInBack__    = new EasingInBack();
Easing easeInBounce__  = new EasingInBounce();
Easing easeInCirc__    = new EasingInCirc();
Easing easeInCubic__   = new EasingInCubic();
Easing easeInElastic__ = new EasingInElastic();
Easing easeInExpo__    = new EasingInExpo();
Easing easeInQuad__    = new EasingInQuad();
Easing easeInQuart__   = new EasingInQuart();
Easing easeInQuint__   = new EasingInQuint();
Easing easeInSine__    = new EasingInSine();

Easing easeOutBack__    = new EasingOutBack();
Easing easeOutBounce__  = new EasingOutBounce();
Easing easeOutCirc__    = new EasingOutCirc();
Easing easeOutCubic__   = new EasingOutCubic();
Easing easeOutElastic__ = new EasingOutElastic();
Easing easeOutExpo__    = new EasingOutExpo();
Easing easeOutQuad__    = new EasingOutQuad();
Easing easeOutQuart__   = new EasingOutQuart();
Easing easeOutQuint__   = new EasingOutQuint();
Easing easeOutSine__    = new EasingOutSine();

Easing easeInOutBack__    = new EasingInOutBack();
Easing easeInOutBounce__  = new EasingInOutBounce();
Easing easeInOutCirc__    = new EasingInOutCirc();
Easing easeInOutCubic__   = new EasingInOutCubic();
Easing easeInOutElastic__ = new EasingInOutElastic();
Easing easeInOutExpo__    = new EasingInOutExpo();
Easing easeInOutQuad__    = new EasingInOutQuad();
Easing easeInOutQuart__   = new EasingInOutQuart();
Easing easeInOutQuint__   = new EasingInOutQuint();
Easing easeInOutSine__    = new EasingInOutSine();

float easeInBack(float t, float s) {
    return ((EasingInBack)easeInBack__).get(t, s);
}

float easeInBack(float t) {
    return easeInBack__.get(t);
}

float easeInBounce(float t) {
    return easeInBounce__.get(t);
}

float easeInCirc(float t) {
    return easeInCirc__.get(t);
}

float easeInCubic(float t) {
    return easeInCubic__.get(t);
}

float easeInElastic(float t, float s) {
    return ((EasingInElastic)easeInElastic__).get(t, s);
}

float easeInElastic(float t) {
    return easeInElastic__.get(t);
}

float easeInExpo(float t) {
    return easeInExpo__.get(t);
}

float easeInQuad(float t) {
    return easeInQuad__.get(t);
}

float easeInQuart(float t) {
    return easeInQuart__.get(t);
}

float easeInQuint(float t) {
    return easeInQuint__.get(t);
}

float easeInSine(float t) {
    return easeInSine__.get(t);
}

float easeOutBack(float t, float s) {
    return ((EasingOutBack)easeOutBack__).get(t, s);
}

float easeOutBack(float t) {
    return easeOutBack__.get(t);
}

float easeOutBounce(float t) {
    return easeOutBounce__.get(t);
}

float easeOutCirc(float t) {
    return easeOutCirc__.get(t);
}

float easeOutCubic(float t) {
    return easeOutCubic__.get(t);
}

float easeOutElastic(float t, float s) {
    return ((EasingOutElastic)easeOutElastic__).get(t, s);
}

float easeOutElastic(float t) {
    return easeOutElastic__.get(t);
}

float easeOutExpo(float t) {
    return easeOutExpo__.get(t);
}

float easeOutQuad(float t) {
    return easeOutQuad__.get(t);
}

float easeOutQuart(float t) {
    return easeOutQuart__.get(t);
}

float easeOutQuint(float t) {
    return easeOutQuint__.get(t);
}

float easeOutSine(float t) {
    return easeOutSine__.get(t);
}

float easeInOutBack(float t, float s) {
    return ((EasingInOutBack)easeInOutBack__).get(t, s);
}

float easeInOutBack(float t) {
    return easeInOutBack__.get(t);
}

float easeInOutBounce(float t) {
    return easeInOutBounce__.get(t);
}

float easeInOutCirc(float t) {
    return easeInOutCirc__.get(t);
}

float easeInOutCubic(float t) {
    return easeInOutCubic__.get(t);
}

float easeInOutElastic(float t, float s) {
    return ((EasingInOutElastic)easeInOutElastic__).get(t, s);
}

float easeInOutElastic(float t) {
    return easeInOutElastic__.get(t);
}

float easeInOutExpo(float t) {
    return easeInOutExpo__.get(t);
}

float easeInOutQuad(float t) {
    return easeInOutQuad__.get(t);
}

float easeInOutQuart(float t) {
    return easeInOutQuart__.get(t);
}

float easeInOutQuint(float t) {
    return easeInOutQuint__.get(t);
}

float easeInOutSine(float t) {
    return easeInOutSine__.get(t);
}