Skip to content

Instantly share code, notes, and snippets.

@brettmjohnson

brettmjohnson/Easing.cs

Forked from Fonserbc/Easing.cs
Last active May 6, 2019 16:39
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save brettmjohnson/9819b86af431fb3acd72fe18e4f1e15d to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save brettmjohnson/9819b86af431fb3acd72fe18e4f1e15d to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. brettmjohnson revised this gist May 6, 2019. 1 changed file with 136 additions and 26 deletions.
    162 changes: 136 additions & 26 deletions Easing.cs
    View file
    Original file line number Diff line number Diff line change
    @@ -1,17 +1,127 @@
    using UnityEngine;

    /*
    * Functions taken from Tween.js - Licensed under the MIT license
    * at https://github.com/sole/tween.js
    */
    public class Easing
    // Functions taken from Tween.js - Licensed under the MIT license at https://github.com/sole/tween.js
    public static class Easing
    {
    public enum EasingType
    {
    Linear,
    SineIn,
    SineOut,
    SineInOut,
    QuadIn,
    QuadOut,
    QuadInOut,
    CubicIn,
    CubicOut,
    CubicInOut,
    QuartIn,
    QuartOut,
    QuartInOut,
    QuintIn,
    QuintOut,
    QuintInOut,
    ExpoIn,
    ExpoOut,
    ExpoInOut,
    CircIn,
    CircOut,
    CircInOut,
    BackIn,
    BackOut,
    BackInOut,
    ElasticIn,
    ElasticOut,
    ElasticInOut,
    BounceIn,
    BounceOut,
    BounceInOut
    }

    public static float Ease(EasingType type, float k)
    {
    switch (type)
    {
    case EasingType.BackIn:
    return Back.In(k);
    case EasingType.BackOut:
    return Back.Out(k);
    case EasingType.BackInOut:
    return Back.InOut(k);

    case EasingType.BounceIn:
    return Bounce.In(k);
    case EasingType.BounceOut:
    return Bounce.Out(k);
    case EasingType.BounceInOut:
    return Bounce.InOut(k);

    case EasingType.CircIn:
    return Circular.In(k);
    case EasingType.CircOut:
    return Circular.Out(k);
    case EasingType.CircInOut:
    return Circular.InOut(k);

    case EasingType.CubicIn:
    return Cubic.In(k);
    case EasingType.CubicOut:
    return Cubic.Out(k);
    case EasingType.CubicInOut:
    return Cubic.InOut(k);

    case EasingType.ElasticIn:
    return Elastic.In(k);
    case EasingType.ElasticOut:
    return Elastic.Out(k);
    case EasingType.ElasticInOut:
    return Elastic.InOut(k);

    case EasingType.ExpoIn:
    return Exponential.In(k);
    case EasingType.ExpoOut:
    return Exponential.Out(k);
    case EasingType.ExpoInOut:
    return Exponential.InOut(k);

    case EasingType.QuadIn:
    return Quadratic.In(k);
    case EasingType.QuadOut:
    return Quadratic.Out(k);
    case EasingType.QuadInOut:
    return Quadratic.InOut(k);

    case EasingType.QuartIn:
    return Quartic.In(k);
    case EasingType.QuartOut:
    return Quartic.Out(k);
    case EasingType.QuartInOut:
    return Quartic.InOut(k);

    case EasingType.QuintIn:
    return Quintic.In(k);
    case EasingType.QuintOut:
    return Quintic.Out(k);
    case EasingType.QuintInOut:
    return Quintic.InOut(k);

    case EasingType.SineIn:
    return Sinusoidal.In(k);
    case EasingType.SineOut:
    return Sinusoidal.Out(k);
    case EasingType.SineInOut:
    return Sinusoidal.InOut(k);

    default:
    return Linear(k);
    }
    }

    public static float Linear (float k) {
    return k;
    }

    public class Quadratic
    public static class Quadratic
    {
    public static float In (float k) {
    return k*k;
    @@ -27,7 +137,7 @@ public static float InOut (float k) {
    }
    };

    public class Cubic
    public static class Cubic
    {
    public static float In (float k) {
    return k*k*k;
    @@ -43,7 +153,7 @@ public static float InOut (float k) {
    }
    };

    public class Quartic
    public static class Quartic
    {
    public static float In (float k) {
    return k*k*k*k;
    @@ -59,7 +169,7 @@ public static float InOut (float k) {
    }
    };

    public class Quintic
    public static class Quintic
    {
    public static float In (float k) {
    return k*k*k*k*k;
    @@ -75,7 +185,7 @@ public static float InOut (float k) {
    }
    };

    public class Sinusoidal
    public static class Sinusoidal
    {
    public static float In (float k) {
    return 1f - Mathf.Cos(k*Mathf.PI/2f);
    @@ -90,25 +200,25 @@ public static float InOut (float k) {
    }
    };

    public class Exponential
    public static class Exponential
    {
    public static float In (float k) {
    return k == 0f? 0f : Mathf.Pow(1024f, k - 1f);
    return Mathf.Approximately(k, 0f) ? 0f : Mathf.Pow(1024f, k - 1f);
    }

    public static float Out (float k) {
    return k == 1f? 1f : 1f - Mathf.Pow(2f, -10f*k);
    return Mathf.Approximately(k, 1f) ? 1f : 1f - Mathf.Pow(2f, -10f*k);
    }

    public static float InOut (float k) {
    if (k == 0f) return 0f;
    if (k == 1f) return 1f;
    if (Mathf.Approximately(k, 0f)) return 0f;
    if (Mathf.Approximately(k, 1f)) return 1f;
    if ((k *= 2f) < 1f) return 0.5f*Mathf.Pow(1024f, k - 1f);
    return 0.5f*(-Mathf.Pow(2f, -10f*(k - 1f)) + 2f);
    }
    };

    public class Circular
    public static class Circular
    {
    public static float In (float k) {
    return 1f - Mathf.Sqrt(1f - k*k);
    @@ -124,17 +234,17 @@ public static float InOut (float k) {
    }
    };

    public class Elastic
    public static class Elastic
    {
    public static float In (float k) {
    if (k == 0) return 0;
    if (k == 1) return 1;
    if (Mathf.Approximately(k, 0f)) return 0;
    if (Mathf.Approximately(k, 1f)) return 1;
    return -Mathf.Pow( 2f, 10f*(k -= 1f))*Mathf.Sin((k - 0.1f)*(2f*Mathf.PI)/0.4f);
    }

    public static float Out (float k) {
    if (k == 0) return 0;
    if (k == 1) return 1;
    if (Mathf.Approximately(k, 0f)) return 0;
    if (Mathf.Approximately(k, 1f)) return 1;
    return Mathf.Pow(2f, -10f*k)*Mathf.Sin((k - 0.1f)*(2f*Mathf.PI)/0.4f) + 1f;
    }

    @@ -144,10 +254,10 @@ public static float InOut (float k) {
    }
    };

    public class Back
    public static class Back
    {
    static float s = 1.70158f;
    static float s2 = 2.5949095f;
    const float s = 1.70158f;
    const float s2 = 2.5949095f;

    public static float In (float k) {
    return k*k*((s + 1f)*k - s);
    @@ -163,7 +273,7 @@ public static float InOut (float k) {
    }
    };

    public class Bounce
    public static class Bounce
    {
    public static float In (float k) {
    return 1f - Out(1f - k);
  2. @Fonserbc Fonserbc revised this gist Dec 26, 2014. 1 changed file with 4 additions and 0 deletions.
    4 changes: 4 additions & 0 deletions Easing.cs
    View file
    Original file line number Diff line number Diff line change
    @@ -1,5 +1,9 @@
    using UnityEngine;

    /*
    * Functions taken from Tween.js - Licensed under the MIT license
    * at https://github.com/sole/tween.js
    */
    public class Easing
    {

  3. @Fonserbc Fonserbc created this gist Dec 26, 2014.
    188 changes: 188 additions & 0 deletions Easing.cs
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,188 @@
    using UnityEngine;

    public class Easing
    {

    public static float Linear (float k) {
    return k;
    }

    public class Quadratic
    {
    public static float In (float k) {
    return k*k;
    }

    public static float Out (float k) {
    return k*(2f - k);
    }

    public static float InOut (float k) {
    if ((k *= 2f) < 1f) return 0.5f*k*k;
    return -0.5f*((k -= 1f)*(k - 2f) - 1f);
    }
    };

    public class Cubic
    {
    public static float In (float k) {
    return k*k*k;
    }

    public static float Out (float k) {
    return 1f + ((k -= 1f)*k*k);
    }

    public static float InOut (float k) {
    if ((k *= 2f) < 1f) return 0.5f*k*k*k;
    return 0.5f*((k -= 2f)*k*k + 2f);
    }
    };

    public class Quartic
    {
    public static float In (float k) {
    return k*k*k*k;
    }

    public static float Out (float k) {
    return 1f - ((k -= 1f)*k*k*k);
    }

    public static float InOut (float k) {
    if ((k *= 2f) < 1f) return 0.5f*k*k*k*k;
    return -0.5f*((k -= 2f)*k*k*k - 2f);
    }
    };

    public class Quintic
    {
    public static float In (float k) {
    return k*k*k*k*k;
    }

    public static float Out (float k) {
    return 1f + ((k -= 1f)*k*k*k*k);
    }

    public static float InOut (float k) {
    if ((k *= 2f) < 1f) return 0.5f*k*k*k*k*k;
    return 0.5f*((k -= 2f)*k*k*k*k + 2f);
    }
    };

    public class Sinusoidal
    {
    public static float In (float k) {
    return 1f - Mathf.Cos(k*Mathf.PI/2f);
    }

    public static float Out (float k) {
    return Mathf.Sin(k*Mathf.PI/2f);
    }

    public static float InOut (float k) {
    return 0.5f*(1f - Mathf.Cos(Mathf.PI*k));
    }
    };

    public class Exponential
    {
    public static float In (float k) {
    return k == 0f? 0f : Mathf.Pow(1024f, k - 1f);
    }

    public static float Out (float k) {
    return k == 1f? 1f : 1f - Mathf.Pow(2f, -10f*k);
    }

    public static float InOut (float k) {
    if (k == 0f) return 0f;
    if (k == 1f) return 1f;
    if ((k *= 2f) < 1f) return 0.5f*Mathf.Pow(1024f, k - 1f);
    return 0.5f*(-Mathf.Pow(2f, -10f*(k - 1f)) + 2f);
    }
    };

    public class Circular
    {
    public static float In (float k) {
    return 1f - Mathf.Sqrt(1f - k*k);
    }

    public static float Out (float k) {
    return Mathf.Sqrt(1f - ((k -= 1f)*k));
    }

    public static float InOut (float k) {
    if ((k *= 2f) < 1f) return -0.5f*(Mathf.Sqrt(1f - k*k) - 1);
    return 0.5f*(Mathf.Sqrt(1f - (k -= 2f)*k) + 1f);
    }
    };

    public class Elastic
    {
    public static float In (float k) {
    if (k == 0) return 0;
    if (k == 1) return 1;
    return -Mathf.Pow( 2f, 10f*(k -= 1f))*Mathf.Sin((k - 0.1f)*(2f*Mathf.PI)/0.4f);
    }

    public static float Out (float k) {
    if (k == 0) return 0;
    if (k == 1) return 1;
    return Mathf.Pow(2f, -10f*k)*Mathf.Sin((k - 0.1f)*(2f*Mathf.PI)/0.4f) + 1f;
    }

    public static float InOut (float k) {
    if ((k *= 2f) < 1f) return -0.5f*Mathf.Pow(2f, 10f*(k -= 1f))*Mathf.Sin((k - 0.1f)*(2f*Mathf.PI)/0.4f);
    return Mathf.Pow(2f, -10f*(k -= 1f))*Mathf.Sin((k - 0.1f)*(2f*Mathf.PI)/0.4f)*0.5f + 1f;
    }
    };

    public class Back
    {
    static float s = 1.70158f;
    static float s2 = 2.5949095f;

    public static float In (float k) {
    return k*k*((s + 1f)*k - s);
    }

    public static float Out (float k) {
    return (k -= 1f)*k*((s + 1f)*k + s) + 1f;
    }

    public static float InOut (float k) {
    if ((k *= 2f) < 1f) return 0.5f*(k*k*((s2 + 1f)*k - s2));
    return 0.5f*((k -= 2f)*k*((s2 + 1f)*k + s2) + 2f);
    }
    };

    public class Bounce
    {
    public static float In (float k) {
    return 1f - Out(1f - k);
    }

    public static float Out (float k) {
    if (k < (1f/2.75f)) {
    return 7.5625f*k*k;
    }
    else if (k < (2f/2.75f)) {
    return 7.5625f*(k -= (1.5f/2.75f))*k + 0.75f;
    }
    else if (k < (2.5f/2.75f)) {
    return 7.5625f *(k -= (2.25f/2.75f))*k + 0.9375f;
    }
    else {
    return 7.5625f*(k -= (2.625f/2.75f))*k + 0.984375f;
    }
    }

    public static float InOut (float k) {
    if (k < 0.5f) return In(k*2f)*0.5f;
    return Out(k*2f - 1f)*0.5f + 0.5f;
    }
    };
    }