A class that brings Robert Penner's easing functions into Processing
/* | |
* 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); | |
} |
This comment has been minimized.
This comment has been minimized.
@ErrorBot1122 Do you mean |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
This comment has been minimized.
can you do another for p5?