Easing extension for VisualElements experimental animations

EasingExtensions.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UIElements;
using UnityEngine.UIElements.Experimental;


public static class EasingExtensions
{
    private static Dictionary<EasingMode, Func<float, float>> _funcs = new ();

    static EasingExtensions()
    {
        _funcs.Add(EasingMode.Ease, Linear);
        _funcs.Add(EasingMode.EaseIn, InQuad);
        _funcs.Add(EasingMode.EaseOut, OutQuad);
        _funcs.Add(EasingMode.EaseInOut, InOutQuad);
        _funcs.Add(EasingMode.Linear, InCubic);
        _funcs.Add(EasingMode.EaseInSine, OutCubic);
        _funcs.Add(EasingMode.EaseOutSine, InOutCubic);
        _funcs.Add(EasingMode.EaseInOutSine, InQuart);
        _funcs.Add(EasingMode.EaseInCubic, OutQuart);
        _funcs.Add(EasingMode.EaseOutCubic, InOutQuart);
        _funcs.Add(EasingMode.EaseInOutCubic, InQuint);
        _funcs.Add(EasingMode.EaseInCirc, OutQuint);
        _funcs.Add(EasingMode.EaseOutCirc, InOutQuint);
        _funcs.Add(EasingMode.EaseInOutCirc, InSine);
        _funcs.Add(EasingMode.EaseInElastic, OutSine);
        _funcs.Add(EasingMode.EaseOutElastic, InOutSine);
        _funcs.Add(EasingMode.EaseInOutElastic, InExpo);
        _funcs.Add(EasingMode.EaseInBack, OutExpo);
        _funcs.Add(EasingMode.EaseOutBack, InOutExpo);
        _funcs.Add(EasingMode.EaseInOutBack, InCirc);
        _funcs.Add(EasingMode.EaseInBounce, OutCirc);
        _funcs.Add(EasingMode.EaseOutBounce, InOutCirc);
        _funcs.Add(EasingMode.EaseInOutBounce, InElastic);
    }

    public static Func<float,float> GetEasingFunction(this EasingMode mode)
    {
        return _funcs[mode];
    }

    public static ValueAnimation<float> SetEaseFunction(this ValueAnimation<float> animation, EasingMode mode)
    {
        animation.easingCurve = mode.GetEasingFunction();
        return animation;
    }

    private static float Linear(float arg)
    {
        return arg;
    }

    private static float InQuad(float arg)
    {
        return arg * arg;
    }

    private static float OutQuad(float arg)
    {
        return arg * (2 - arg);
    }

    private static float InOutQuad(float arg)
    {
        return arg < 0.5f ? 2 * arg * arg : -1 + (4 - 2 * arg) * arg;
    }

    private static float InCubic(float arg)
    {
        return arg * arg * arg;
    }

    private static float OutCubic(float arg)
    {
        return (--arg) * arg * arg + 1;
    }

    private static float InOutCubic(float arg)
    {
        return arg < 0.5f ? 4 * arg * arg * arg : (arg - 1) * (2 * arg - 2) * (2 * arg - 2) + 1;
    }

    private static float InQuart(float arg)
    {
        return arg * arg * arg * arg;
    }

    private static float OutQuart(float arg)
    {
        return 1 - (--arg) * arg * arg * arg;
    }

    private static float InOutQuart(float arg)
    {
        return arg < 0.5f ? 8 * arg * arg * arg * arg : 1 - 8 * (--arg) * arg * arg * arg;
    }

    private static float InQuint(float arg)
    {
        return arg * arg * arg * arg * arg;
    }

    private static float OutQuint(float arg)
    {
        return 1 + (--arg) * arg * arg * arg * arg;
    }

    private static float InOutQuint(float arg)
    {
        return arg < 0.5f ? 16 * arg * arg * arg * arg * arg : 1 + 16 * (--arg) * arg * arg * arg * arg;
    }

    private static float InSine(float arg)
    {
        return 1 - Mathf.Cos(arg * Mathf.PI / 2);
    }

    private static float OutSine(float arg)
    {
        return Mathf.Sin(arg * Mathf.PI / 2);
    }

    private static float InOutSine(float arg)
    {
        return 0.5f * (1 - Mathf.Cos(Mathf.PI * arg));
    }

    private static float InExpo(float arg)
    {
        return arg == 0 ? 0 : Mathf.Pow(1024, arg - 1);
    }

    private static float OutExpo(float arg)
    {
        return arg == 1 ? 1 : 1 - Mathf.Pow(2, -10 * arg);
    }

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

    private static float InCirc(float arg)
    {
        return 1 - Mathf.Sqrt(1 - arg * arg);
    }

    private static float OutCirc(float arg)
    {
        return Mathf.Sqrt(1 - (--arg) * arg);
    }

    private static float InOutCirc(float arg)
    {
        if ((arg *= 2) < 1) return -0.5f * (Mathf.Sqrt(1 - arg * arg) - 1);
        return 0.5f * (Mathf.Sqrt(1 - (arg -= 2) * arg) + 1);
    }

    private static float InElastic(float arg)
    {
        if (arg == 0) return 0;
        if (arg == 1) return 1;
        return -Mathf.Pow(2, 10 * (arg -= 1)) * Mathf.Sin((arg - 0.1f) * (2 * Mathf.PI) / 0.4f);
    }

}