example: add easing_ball_anim

examples/shapes/reasings.zig

@@ -0,0 +1,192 @@
+const math = @import("std").math;
+
+// Linear Easing functions
+pub fn linearNone(t: f32, b: f32, c: f32, d: f32) f32 {
+    return (c * t / d + b);
+}
+pub fn linearIn(t: f32, b: f32, c: f32, d: f32) f32 {
+    return (c * t / d + b);
+}
+pub fn linearOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    return (c * t / d + b);
+}
+pub fn linearInOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    return (c * t / d + b);
+}
+
+pub fn sineIn(t: f32, b: f32, c: f32, d: f32) f32 {
+    return (-c * math.cos(t / d * (math.pi / 2.0)) + c + b);
+}
+pub fn sineOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    return (c * math.sin(t / d * (math.pi / 2.0)) + b);
+}
+pub fn sineInOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    return (-c / 2.0 * (math.cos(math.pi * t / d) - 1.0) + b);
+}
+
+// Circular Easing functions
+pub fn circIn(t: f32, b: f32, c: f32, d: f32) f32 {
+    const postFix = t / d;
+    return (-c * (math.sqrt(1.0 - postFix * postFix) - 1.0) + b);
+}
+pub fn circOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    const postFix = t / d - 1.0;
+    return (c * math.sqrt(1.0 - postFix * postFix) + b);
+}
+pub fn circInOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    var postFix = t / d;
+    if ((postFix / 2.0) < 1.0) return (-c / 2.0 * (math.sqrt(1.0 - postFix * postFix) - 1.0) + b);
+    postFix -= 2.0;
+    return (c / 2.0 * (math.sqrt(1.0 - postFix * postFix) + 1.0) + b);
+}
+
+// Cubic Easing functions
+pub fn cubicIn(t: f32, b: f32, c: f32, d: f32) f32 {
+    const postFix = t / d;
+    return (c * postFix * postFix * postFix + b);
+}
+pub fn cubicOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    const postFix = t / d - 1.0;
+    return (c * (postFix * postFix * postFix + 1.0) + b);
+}
+pub fn cubicInOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    const postFix = t / d;
+    if (postFix / 2.0 < 1.0) return (c / 2.0 * postFix * postFix * postFix + b);
+    postFix -= 2.0;
+    return (c / 2.0 * (t * t * t + 2.0) + b);
+}
+
+// Quadratic Easing functions
+pub fn quadIn(t: f32, b: f32, c: f32, d: f32) f32 {
+    const postfix = t / d;
+    return (c * postfix * postfix + b);
+}
+pub fn quadOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    const postFix = t / d;
+    return (-c * postFix * (postFix - 2.0) + b);
+}
+pub fn quadInOut(t: f32, b: f32, c: f32, d: f32) f32 // Ease: Quadratic In Out
+{
+    const postFix = t / d;
+    return if (postFix / 2 < 1)
+        (((c / 2) * (postFix * postFix)) + b)
+    else
+        (-c / 2.0 * (((postFix - 1.0) * (postFix - 3.0)) - 1.0) + b);
+}
+
+// Exponential Easing functions
+pub fn expoIn(t: f32, b: f32, c: f32, d: f32) f32 {
+    return if (t == 0.0) b else (c * math.pow(f32, 2.0, 10.0 * (t / d - 1.0)) + b);
+}
+pub fn expoOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    return if (t == d) (b + c) else (c * (-math.pow(f32, 2.0, -10.0 * t / d) + 1.0) + b);
+}
+pub fn expoInOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    if (t == 0.0) return b;
+    if (t == d) return (b + c);
+    const postFix = t / d;
+    if ((postFix / 2.0) < 1.0) return (c / 2.0 * math.pow(f32, 2.0, 10.0 * (postFix - 1.0)) + b);
+
+    return (c / 2.0 * (-math.pow(f32, 2.0, -10.0 * (postFix - 1.0)) + 2.0) + b);
+}
+
+// Back Easing functions
+pub fn backIn(t: f32, b: f32, c: f32, d: f32) f32 {
+    const s = 1.70158;
+    const postFix = t / d;
+    return (c * (postFix) * postFix * ((s + 1.0) * postFix - s) + b);
+}
+
+pub fn backOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    const s = 1.70158;
+    const postFix = t / d - 1.0;
+    return (c * (postFix * postFix * ((s + 1.0) * postFix + s) + 1.0) + b);
+}
+
+pub fn backInOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    const s = 1.70158;
+    t /= d;
+    if (t / 2.0 < 1.0) {
+        s *= 1.525;
+        return (c / 2.0 * (t * t * ((s + 1.0) * t - s)) + b);
+    }
+    t -= 2;
+    const postFix = t;
+    s *= 1.525;
+    return (c / 2.0 * ((postFix) * t * ((s + 1.0) * t + s) + 2.0) + b);
+}
+
+// Bounce Easing functions
+
+pub fn bounceOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    var tDivD = t / d;
+    if (tDivD < (1.0 / 2.75)) {
+        return (c * (7.5625 * tDivD * tDivD) + b);
+    } else if (tDivD < (2.0 / 2.75)) {
+        tDivD -= (1.5 / 2.75);
+        return (c * (7.5625 * tDivD * tDivD + 0.75) + b);
+    } else if (tDivD < (2.5 / 2.75)) {
+        tDivD -= (2.25 / 2.75);
+        return (c * (7.5625 * tDivD * tDivD + 0.9375) + b);
+    } else {
+        tDivD -= (2.625 / 2.75);
+        return (c * (7.5625 * tDivD * tDivD + 0.984375) + b);
+    }
+}
+
+pub fn bounceIn(t: f32, b: f32, c: f32, d: f32) f32 {
+    return (c - bounceOut(d - t, 0.0, c, d) + b);
+}
+
+pub fn bounceInOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    if (t < d / 2.0) return (bounceIn(t * 2.0, 0.0, c, d) * 0.5 + b);
+    return (bounceOut(t * 2.0 - d, 0.0, c, d) * 0.5 + c * 0.5 + b);
+}
+
+// Elastic Easing functions
+pub fn elasticIn(t: f32, b: f32, c: f32, d: f32) f32 {
+    if (t == 0.0) return b;
+    var tDivD = t / d;
+    if (tDivD == 1.0) return (b + c);
+
+    const p = d * 0.3;
+    const a = c;
+    const s = p / 4.0;
+    tDivD -= 1;
+    const postFix = a * math.pow(f32, 2.0, 10.0 * tDivD);
+
+    return (-(postFix * math.sin((tDivD * d - s) * (2.0 * math.pi) / p)) + b);
+}
+
+pub fn elasticOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    if (t == 0.0) return b;
+    const tDivD = t / d;
+    if (tDivD == 1.0) return (b + c);
+
+    const p = d * 0.3;
+    const a = c;
+    const s = p / 4.0;
+
+    return (a * math.pow(f32, 2.0, -10.0 * tDivD) * math.sin((tDivD * d - s) * (2.0 * math.pi) / p) + c + b);
+}
+
+pub fn elasticInOut(t: f32, b: f32, c: f32, d: f32) f32 {
+    if (t == 0.0) return b;
+    const tDivD = t / d;
+    if (tDivD / 2.0 == 2.0) return (b + c);
+
+    const p = d * (0.3 * 1.5);
+    const a = c;
+    const s = p / 4.0;
+
+    if (tDivD < 1.0) {
+        tDivD -= 1;
+        const postFix = a * math.pow(f32, 2.0, 10.0 * tDivD);
+        return -0.5 * (postFix * math.sin((tDivD * d - s) * (2.0 * math.pi) / p)) + b;
+    }
+
+    tDivD -= 1;
+    const postFix = a * math.pow(f32, 2.0, -10.0 * (tDivD));
+
+    return (postFix * math.sin((tDivD * d - s) * (2.0 * math.pi) / p) * 0.5 + c + b);
+}