887 lines
18 KiB
C#
887 lines
18 KiB
C#
using MoonWorks.Math.Fixed;
|
|
using System.Collections.Generic;
|
|
|
|
namespace MoonWorks.Math
|
|
{
|
|
public static class Easing
|
|
{
|
|
private const float C1 = 1.70158f;
|
|
private const float C2 = C1 * 1.525f;
|
|
private const float C3 = C1 + 1;
|
|
private const float C4 = (2 * System.MathF.PI) / 3;
|
|
private const float C5 = (2 * System.MathF.PI) / 4.5f;
|
|
|
|
private static readonly Fix64 HALF = Fix64.FromFraction(1, 2);
|
|
private static readonly Fix64 FIXED_C1 = Fix64.FromFraction(170158, 100000);
|
|
private static readonly Fix64 FIXED_C2 = FIXED_C1 * Fix64.FromFraction(61, 40);
|
|
private static readonly Fix64 FIXED_C3 = FIXED_C1 + Fix64.One;
|
|
private static readonly Fix64 FIXED_C4 = Fix64.PiTimes2 / new Fix64(3);
|
|
private static readonly Fix64 FIXED_C5 = Fix64.PiTimes2 / Fix64.FromFraction(9, 2);
|
|
|
|
private static readonly Fix64 FIXED_N1 = Fix64.FromFraction(121, 16);
|
|
private static readonly Fix64 FIXED_D1 = Fix64.FromFraction(11, 4);
|
|
|
|
private static float OutIn(
|
|
System.Func<float, float> outFunc,
|
|
System.Func<float, float> inFunc,
|
|
float t
|
|
) {
|
|
if (t < 0.5f)
|
|
{
|
|
return outFunc(t);
|
|
}
|
|
else
|
|
{
|
|
return inFunc(t);
|
|
}
|
|
}
|
|
|
|
private static Fix64 OutIn(
|
|
System.Func<Fix64, Fix64> outFunc,
|
|
System.Func<Fix64, Fix64> inFunc,
|
|
Fix64 t
|
|
) {
|
|
if (t < HALF)
|
|
{
|
|
return outFunc(t);
|
|
}
|
|
else
|
|
{
|
|
return inFunc(t);
|
|
}
|
|
}
|
|
|
|
/* GENERAL-USE FUNCTIONS */
|
|
|
|
public static float AttackHoldRelease(
|
|
float start,
|
|
float hold,
|
|
float end,
|
|
float time,
|
|
float attackDuration,
|
|
Function.Float attackEasingFunction,
|
|
float holdDuration,
|
|
float releaseDuration,
|
|
Function.Float releaseEasingFunction
|
|
) {
|
|
if (time < attackDuration)
|
|
{
|
|
return Interp(start, hold, time, attackDuration, Function.Get(attackEasingFunction));
|
|
}
|
|
else if (time >= attackDuration && time < attackDuration + holdDuration)
|
|
{
|
|
return hold;
|
|
}
|
|
else // time >= attackDuration + holdDuration
|
|
{
|
|
return Interp(hold, end, time - holdDuration - attackDuration, releaseDuration, Function.Get(releaseEasingFunction));
|
|
}
|
|
}
|
|
|
|
public static Fix64 AttackHoldRelease(
|
|
Fix64 start,
|
|
Fix64 hold,
|
|
Fix64 end,
|
|
Fix64 time,
|
|
Fix64 attackDuration,
|
|
Function.Fixed attackEasingFunction,
|
|
Fix64 holdDuration,
|
|
Fix64 releaseDuration,
|
|
Function.Fixed releaseEasingFunction
|
|
) {
|
|
if (time < attackDuration)
|
|
{
|
|
return Interp(start, hold, time, attackDuration, Function.Get(attackEasingFunction));
|
|
}
|
|
else if (time >= attackDuration && time < attackDuration + holdDuration)
|
|
{
|
|
return hold;
|
|
}
|
|
else // time >= attackDuration + holdDuration
|
|
{
|
|
return Interp(hold, end, time - holdDuration - attackDuration, releaseDuration, Function.Get(releaseEasingFunction));
|
|
}
|
|
}
|
|
|
|
public static float Lerp(float start, float end, float time)
|
|
{
|
|
return (start + (end - start) * time);
|
|
}
|
|
|
|
public static float Interp(float start, float end, float time, float duration, System.Func<float, float> easingFunc)
|
|
{
|
|
return Lerp(start, end, easingFunc(time / duration));
|
|
}
|
|
|
|
public static float Interp(float start, float end, float time, float duration, MoonWorks.Math.Easing.Function.Float easingFunc)
|
|
{
|
|
return Interp(start, end, time, duration, Function.Get(easingFunc));
|
|
}
|
|
|
|
public static Fix64 Lerp(Fix64 start, Fix64 end, Fix64 time)
|
|
{
|
|
return (start + (end - start) * time);
|
|
}
|
|
|
|
public static Fix64 Interp(Fix64 start, Fix64 end, Fix64 time, Fix64 duration, System.Func<Fix64, Fix64> easingFunc)
|
|
{
|
|
return Lerp(start, end, easingFunc(time / duration));
|
|
}
|
|
|
|
public static Fix64 Interp(Fix64 start, Fix64 end, Fix64 time, Fix64 duration, MoonWorks.Math.Easing.Function.Fixed easingFunc)
|
|
{
|
|
return Interp(start, end, time, duration, Function.Get(easingFunc));
|
|
}
|
|
|
|
/* FLOAT EASING FUNCTIONS */
|
|
|
|
// LINEAR
|
|
|
|
public static float Linear(float t)
|
|
{
|
|
return t;
|
|
}
|
|
|
|
// QUADRATIC
|
|
|
|
public static float InQuad(float t)
|
|
{
|
|
return t * t;
|
|
}
|
|
|
|
public static float OutQuad(float t)
|
|
{
|
|
return 1 - (1 - t) * (1 - t);
|
|
}
|
|
|
|
public static float InOutQuad(float t)
|
|
{
|
|
if (t < 0.5f)
|
|
{
|
|
return 2 * t * t;
|
|
}
|
|
else
|
|
{
|
|
var x = (-2 * t + 2);
|
|
return 1 - ((x * x) / 2);
|
|
}
|
|
}
|
|
|
|
public static float OutInQuad(float t) => OutIn(OutQuad, InQuad, t);
|
|
|
|
// CUBIC
|
|
|
|
public static float InCubic(float t)
|
|
{
|
|
return t * t * t;
|
|
}
|
|
|
|
public static float OutCubic(float t)
|
|
{
|
|
var x = 1 - t;
|
|
return 1 - (x * x * x);
|
|
}
|
|
|
|
public static float InOutCubic(float t)
|
|
{
|
|
if (t < 0.5f)
|
|
{
|
|
return 4 * t * t * t;
|
|
}
|
|
else
|
|
{
|
|
var x = -2 * t + 2;
|
|
return 1 - ((x * x * x) / 2);
|
|
}
|
|
}
|
|
|
|
public static float OutInCubic(float t) => OutIn(OutCubic, InCubic, t);
|
|
|
|
// QUARTIC
|
|
|
|
public static float InQuart(float t)
|
|
{
|
|
return t * t * t * t;
|
|
}
|
|
|
|
public static float OutQuart(float t)
|
|
{
|
|
var x = 1 - t;
|
|
return 1 - (x * x * x * x);
|
|
}
|
|
|
|
public static float InOutQuart(float t)
|
|
{
|
|
if (t < 0.5f)
|
|
{
|
|
return 8 * t * t * t * t;
|
|
}
|
|
else
|
|
{
|
|
var x = -2 * t + 2;
|
|
return 1 - ((x * x * x * x) / 2);
|
|
}
|
|
}
|
|
|
|
public static float OutInQuart(float t) => OutIn(OutQuart, InQuart, t);
|
|
|
|
// QUINTIC
|
|
|
|
public static float InQuint(float t)
|
|
{
|
|
return t * t * t * t * t;
|
|
}
|
|
|
|
public static float OutQuint(float t)
|
|
{
|
|
var x = 1 - t;
|
|
return 1 - (x * x * x * x * x);
|
|
}
|
|
|
|
public static float InOutQuint(float t)
|
|
{
|
|
if (t < 0.5f)
|
|
{
|
|
return 16 * t * t * t * t * t;
|
|
}
|
|
else
|
|
{
|
|
var x = -2 * t + 2;
|
|
return 1 - ((x * x * x * x * x) / 2);
|
|
}
|
|
}
|
|
|
|
public static float OutInQuint(float t) => OutIn(OutQuint, InQuint, t);
|
|
|
|
// SINE
|
|
|
|
public static float InSine(float t)
|
|
{
|
|
return 1 - System.MathF.Cos((t * System.MathF.PI) / 2);
|
|
}
|
|
|
|
public static float OutSine(float t)
|
|
{
|
|
return System.MathF.Sin((t * System.MathF.PI) / 2);
|
|
}
|
|
|
|
public static float InOutSine(float t)
|
|
{
|
|
return -(System.MathF.Cos(System.MathF.PI * t) - 1) / 2;
|
|
}
|
|
|
|
public static float OutInSine(float t) => OutIn(OutSine, InSine, t);
|
|
|
|
// EXPONENTIAL
|
|
|
|
public static float InExpo(float t)
|
|
{
|
|
if (t == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return System.MathF.Pow(2, 10 * t - 10);
|
|
}
|
|
}
|
|
|
|
public static float OutExpo(float t)
|
|
{
|
|
if (t == 1)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 1 - System.MathF.Pow(2, -10 * t);
|
|
}
|
|
}
|
|
|
|
public static float InOutExpo(float t)
|
|
{
|
|
if (t == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
else if (t == 1)
|
|
{
|
|
return 1;
|
|
}
|
|
else if (t < 0.5f)
|
|
{
|
|
return System.MathF.Pow(2, 20 * t - 10) / 2;
|
|
}
|
|
else
|
|
{
|
|
return (2 - System.MathF.Pow(2, -20 * t + 10)) / 2;
|
|
}
|
|
}
|
|
|
|
public static float OutInExpo(float t) => OutIn(OutExpo, InExpo, t);
|
|
|
|
// CIRCULAR
|
|
|
|
public static float InCirc(float t)
|
|
{
|
|
return 1 - System.MathF.Sqrt(1 - (t * t));
|
|
}
|
|
|
|
public static float OutCirc(float t)
|
|
{
|
|
return System.MathF.Sqrt(1 - ((t - 1) * (t - 1)));
|
|
}
|
|
|
|
public static float InOutCirc(float t)
|
|
{
|
|
if (t < 0.5f)
|
|
{
|
|
return (1 - System.MathF.Sqrt(1 - ((2 * t) * (2 * t)))) / 2;
|
|
}
|
|
else
|
|
{
|
|
var x = -2 * t + 2;
|
|
return (System.MathF.Sqrt(1 - (x * x)) + 1) / 2;
|
|
}
|
|
}
|
|
|
|
public static float OutInCirc(float t) => OutIn(OutCirc, InCirc, t);
|
|
|
|
// BACK
|
|
|
|
public static float InBack(float t)
|
|
{
|
|
return C3 * t * t * t - C1 * t * t;
|
|
}
|
|
|
|
public static float OutBack(float t)
|
|
{
|
|
return 1 + C3 * (t - 1) * (t - 1) * (t - 1) + C1 * (t - 1) * (t - 1);
|
|
}
|
|
|
|
public static float InOutBack(float t)
|
|
{
|
|
if (t < 0.5f)
|
|
{
|
|
return ((2 * t) * (2 * t) * ((C2 + 1) * 2 * t - C2)) / 2;
|
|
}
|
|
else
|
|
{
|
|
var x = 2 * t - 2;
|
|
return ((t * t) * ((C2 + 1) * (x) + C2) + 2) / 2;
|
|
}
|
|
}
|
|
|
|
public static float OutInBack(float t) => OutIn(OutBack, InBack, t);
|
|
|
|
// ELASTIC
|
|
|
|
public static float InElastic(float t)
|
|
{
|
|
if (t == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
else if (t == 1)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return -System.MathF.Pow(2, 10 * t - 10) * System.MathF.Sin((t * 10 - 10.75f) * C4);
|
|
}
|
|
}
|
|
|
|
public static float OutElastic(float t)
|
|
{
|
|
if (t == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
else if (t == 1)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return System.MathF.Pow(2, -10 * t) * System.MathF.Sin((t * 10 - 0.75f) * C4) + 1;
|
|
}
|
|
}
|
|
|
|
public static float InOutElastic(float t)
|
|
{
|
|
if (t == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
else if (t == 1)
|
|
{
|
|
return 1;
|
|
}
|
|
else if (t < 0.5f)
|
|
{
|
|
return -(System.MathF.Pow(2, 20 * t - 10) * System.MathF.Sin((20 * t - 11.125f) * C5)) / 2;
|
|
}
|
|
else
|
|
{
|
|
return (System.MathF.Pow(2, -20 * t + 10) * System.MathF.Sin((20 * t - 11.125f) * C5)) / 2 + 1;
|
|
}
|
|
}
|
|
|
|
public static float OutInElastic(float t) => OutIn(OutElastic, InElastic, t);
|
|
|
|
// BOUNCE
|
|
|
|
public static float InBounce(float t)
|
|
{
|
|
return 1 - OutBounce(1 - t);
|
|
}
|
|
|
|
public static float OutBounce(float t)
|
|
{
|
|
const float N1 = 7.5625f;
|
|
const float D1 = 2.75f;
|
|
|
|
if (t < 1 / D1)
|
|
{
|
|
return N1 * t * t;
|
|
}
|
|
else if (t < 2 / D1) {
|
|
return N1 * (t -= 1.5f / D1) * t + 0.75f;
|
|
}
|
|
else if (t < 2.5f / D1)
|
|
{
|
|
return N1 * (t -= 2.25f / D1) * t + 0.9375f;
|
|
}
|
|
else
|
|
{
|
|
return N1 * (t -= 2.625f / D1) * t + 0.984375f;
|
|
}
|
|
}
|
|
|
|
public static float InOutBounce(float t)
|
|
{
|
|
if (t < 0.5f)
|
|
{
|
|
return (1 - OutBounce(1 - 2 * t)) / 2;
|
|
}
|
|
else
|
|
{
|
|
return (1 + OutBounce(2 * t - 1)) / 2;
|
|
}
|
|
}
|
|
|
|
public static float OutInBounce(float t) => OutIn(OutBounce, InBounce, t);
|
|
|
|
/* FIXED EASING FUNCTIONS */
|
|
|
|
// LINEAR
|
|
|
|
public static Fix64 Linear(Fix64 t)
|
|
{
|
|
return t;
|
|
}
|
|
|
|
// QUADRATIC
|
|
|
|
public static Fix64 InQuad(Fix64 t)
|
|
{
|
|
return t * t;
|
|
}
|
|
|
|
public static Fix64 OutQuad(Fix64 t)
|
|
{
|
|
return 1 - (1 - t) * (1 - t);
|
|
}
|
|
|
|
public static Fix64 InOutQuad(Fix64 t)
|
|
{
|
|
if (t < HALF)
|
|
{
|
|
return 2 * t * t;
|
|
}
|
|
else
|
|
{
|
|
var x = (-2 * t + 2);
|
|
return 1 - ((x * x) / 2);
|
|
}
|
|
}
|
|
|
|
public static Fix64 OutInQuad(Fix64 t) => OutIn(OutQuad, InQuad, t);
|
|
|
|
// CUBIC
|
|
|
|
public static Fix64 InCubic(Fix64 t)
|
|
{
|
|
return t * t * t;
|
|
}
|
|
|
|
public static Fix64 OutCubic(Fix64 t)
|
|
{
|
|
var x = 1 - t;
|
|
return 1 - (x * x * x);
|
|
}
|
|
|
|
public static Fix64 InOutCubic(Fix64 t)
|
|
{
|
|
if (t < HALF)
|
|
{
|
|
return 4 * t * t * t;
|
|
}
|
|
else
|
|
{
|
|
var x = -2 * t + 2;
|
|
return 1 - ((x * x * x) / 2);
|
|
}
|
|
}
|
|
|
|
public static Fix64 OutInCubic(Fix64 t) => OutIn(OutCubic, InCubic, t);
|
|
|
|
// QUARTIC
|
|
|
|
public static Fix64 InQuart(Fix64 t)
|
|
{
|
|
return t * t * t * t;
|
|
}
|
|
|
|
public static Fix64 OutQuart(Fix64 t)
|
|
{
|
|
var x = 1 - t;
|
|
return 1 - (x * x * x * x);
|
|
}
|
|
|
|
public static Fix64 InOutQuart(Fix64 t)
|
|
{
|
|
if (t < HALF)
|
|
{
|
|
return 8 * t * t * t * t;
|
|
}
|
|
else
|
|
{
|
|
var x = -2 * t + 2;
|
|
return 1 - ((x * x * x * x) / 2);
|
|
}
|
|
}
|
|
|
|
public static Fix64 OutInQuart(Fix64 t) => OutIn(OutQuart, InQuart, t);
|
|
|
|
// QUINTIC
|
|
|
|
public static Fix64 InQuint(Fix64 t)
|
|
{
|
|
return t * t * t * t * t;
|
|
}
|
|
|
|
public static Fix64 OutQuint(Fix64 t)
|
|
{
|
|
var x = 1 - t;
|
|
return 1 - (x * x * x * x * x);
|
|
}
|
|
|
|
public static Fix64 InOutQuint(Fix64 t)
|
|
{
|
|
if (t < HALF)
|
|
{
|
|
return 16 * t * t * t * t * t;
|
|
}
|
|
else
|
|
{
|
|
var x = -2 * t + 2;
|
|
return 1 - ((x * x * x * x * x) / 2);
|
|
}
|
|
}
|
|
|
|
public static Fix64 OutInQuint(Fix64 t) => OutIn(OutQuint, InQuint, t);
|
|
|
|
// SINE
|
|
|
|
public static Fix64 InSine(Fix64 t)
|
|
{
|
|
return 1 - Fix64.Cos((t * Fix64.Pi) / 2);
|
|
}
|
|
|
|
public static Fix64 OutSine(Fix64 t)
|
|
{
|
|
return Fix64.Sin((t * Fix64.Pi) / 2);
|
|
}
|
|
|
|
public static Fix64 InOutSine(Fix64 t)
|
|
{
|
|
return -(Fix64.Cos(Fix64.Pi * t) - 1) / 2;
|
|
}
|
|
|
|
public static Fix64 OutInSine(Fix64 t) => OutIn(OutSine, InSine, t);
|
|
|
|
// CIRCULAR
|
|
|
|
public static Fix64 InCirc(Fix64 t)
|
|
{
|
|
return 1 - Fix64.Sqrt(1 - (t * t));
|
|
}
|
|
|
|
public static Fix64 OutCirc(Fix64 t)
|
|
{
|
|
return Fix64.Sqrt(1 - ((t - 1) * (t - 1)));
|
|
}
|
|
|
|
public static Fix64 InOutCirc(Fix64 t)
|
|
{
|
|
if (t < HALF)
|
|
{
|
|
return (1 - Fix64.Sqrt(1 - ((2 * t) * (2 * t)))) / 2;
|
|
}
|
|
else
|
|
{
|
|
var x = -2 * t + 2;
|
|
return (Fix64.Sqrt(1 - (x * x)) + 1) / 2;
|
|
}
|
|
}
|
|
|
|
public static Fix64 OutInCirc(Fix64 t) => OutIn(OutCirc, InCirc, t);
|
|
|
|
// BACK
|
|
|
|
public static Fix64 InBack(Fix64 t)
|
|
{
|
|
return FIXED_C3 * t * t * t - FIXED_C1 * t * t;
|
|
}
|
|
|
|
public static Fix64 OutBack(Fix64 t)
|
|
{
|
|
return 1 + FIXED_C3 * (t - 1) * (t - 1) * (t - 1) + FIXED_C1 * (t - 1) * (t - 1);
|
|
}
|
|
|
|
public static Fix64 InOutBack(Fix64 t)
|
|
{
|
|
if (t < HALF)
|
|
{
|
|
return ((2 * t) * (2 * t) * ((FIXED_C2 + 1) * 2 * t - FIXED_C2)) / 2;
|
|
}
|
|
else
|
|
{
|
|
var x = 2 * t - 2;
|
|
return ((t * t) * ((FIXED_C2 + 1) * (x) + FIXED_C2) + 2) / 2;
|
|
}
|
|
}
|
|
|
|
public static Fix64 OutInBack(Fix64 t) => OutIn(OutBack, InBack, t);
|
|
|
|
// BOUNCE
|
|
|
|
public static Fix64 InBounce(Fix64 t)
|
|
{
|
|
return 1 - OutBounce(1 - t);
|
|
}
|
|
|
|
public static Fix64 OutBounce(Fix64 t)
|
|
{
|
|
if (t < 1 / FIXED_D1)
|
|
{
|
|
return FIXED_N1 * t * t;
|
|
}
|
|
else if (t < 2 / FIXED_D1) {
|
|
return FIXED_N1 * (t -= Fix64.FromFraction(3, 2) / FIXED_D1) * t + Fix64.FromFraction(3, 4);
|
|
}
|
|
else if (t < Fix64.FromFraction(5, 2) / FIXED_D1)
|
|
{
|
|
return FIXED_N1 * (t -= Fix64.FromFraction(9, 4) / FIXED_D1) * t + Fix64.FromFraction(15, 16);
|
|
}
|
|
else
|
|
{
|
|
return FIXED_N1 * (t -= Fix64.FromFraction(181, 80) / FIXED_D1) * t + Fix64.FromFraction(63, 64);
|
|
}
|
|
}
|
|
|
|
public static Fix64 InOutBounce(Fix64 t)
|
|
{
|
|
if (t < HALF)
|
|
{
|
|
return (1 - OutBounce(1 - 2 * t)) / 2;
|
|
}
|
|
else
|
|
{
|
|
return (1 + OutBounce(2 * t - 1)) / 2;
|
|
}
|
|
}
|
|
|
|
public static Fix64 OutInBounce(Fix64 t) => OutIn(OutBounce, InBounce, t);
|
|
|
|
public static class Function
|
|
{
|
|
public enum Float
|
|
{
|
|
Linear,
|
|
InQuad,
|
|
OutQuad,
|
|
InOutQuad,
|
|
OutInQuad,
|
|
InCubic,
|
|
OutCubic,
|
|
InOutCubic,
|
|
OutInCubic,
|
|
InQuart,
|
|
OutQuart,
|
|
InOutQuart,
|
|
OutInQuart,
|
|
InQuint,
|
|
OutQuint,
|
|
InOutQuint,
|
|
OutInQuint,
|
|
InSine,
|
|
OutSine,
|
|
InOutSine,
|
|
OutInSine,
|
|
InExpo,
|
|
OutExpo,
|
|
InOutExpo,
|
|
OutInExpo,
|
|
InCirc,
|
|
OutCirc,
|
|
InOutCirc,
|
|
OutInCirc,
|
|
InElastic,
|
|
OutElastic,
|
|
InOutElastic,
|
|
OutInElastic,
|
|
InBack,
|
|
OutBack,
|
|
InOutBack,
|
|
OutInBack,
|
|
InBounce,
|
|
OutBounce,
|
|
InOutBounce,
|
|
OutInBounce
|
|
}
|
|
|
|
public enum Fixed
|
|
{
|
|
Linear,
|
|
InQuad,
|
|
OutQuad,
|
|
InOutQuad,
|
|
OutInQuad,
|
|
InCubic,
|
|
OutCubic,
|
|
InOutCubic,
|
|
OutInCubic,
|
|
InQuart,
|
|
OutQuart,
|
|
InOutQuart,
|
|
OutInQuart,
|
|
InQuint,
|
|
OutQuint,
|
|
InOutQuint,
|
|
OutInQuint,
|
|
InSine,
|
|
OutSine,
|
|
InOutSine,
|
|
OutInSine,
|
|
InCirc,
|
|
OutCirc,
|
|
InOutCirc,
|
|
OutInCirc,
|
|
InBack,
|
|
OutBack,
|
|
InOutBack,
|
|
OutInBack,
|
|
InBounce,
|
|
OutBounce,
|
|
InOutBounce,
|
|
OutInBounce
|
|
}
|
|
|
|
private static Dictionary<Float, System.Func<float, float>> FloatLookup = new Dictionary<Float, System.Func<float, float>>
|
|
{
|
|
{ Float.Linear, Linear },
|
|
{ Float.InQuad, InQuad },
|
|
{ Float.OutQuad, OutQuad },
|
|
{ Float.InOutQuad, InOutQuad },
|
|
{ Float.OutInQuad, OutInQuad },
|
|
{ Float.InCubic, InCubic },
|
|
{ Float.OutCubic, OutCubic },
|
|
{ Float.InOutCubic, InOutCubic },
|
|
{ Float.OutInCubic, OutInCubic },
|
|
{ Float.InQuart, InQuart },
|
|
{ Float.OutQuart, OutQuart },
|
|
{ Float.InOutQuart, InOutQuart },
|
|
{ Float.OutInQuart, OutInQuart },
|
|
{ Float.InQuint, InQuint },
|
|
{ Float.OutQuint, OutQuint },
|
|
{ Float.InOutQuint, InOutQuint },
|
|
{ Float.OutInQuint, OutInQuint },
|
|
{ Float.InSine, InSine },
|
|
{ Float.OutSine, OutSine },
|
|
{ Float.InOutSine, InOutSine },
|
|
{ Float.OutInSine, OutInSine },
|
|
{ Float.InExpo, InExpo },
|
|
{ Float.OutExpo, OutExpo },
|
|
{ Float.InOutExpo, InOutExpo },
|
|
{ Float.OutInExpo, OutInExpo },
|
|
{ Float.InCirc, InCirc },
|
|
{ Float.OutCirc, OutCirc },
|
|
{ Float.InOutCirc, InOutCirc },
|
|
{ Float.OutInCirc, OutInCirc },
|
|
{ Float.InElastic, InElastic },
|
|
{ Float.OutElastic, OutElastic },
|
|
{ Float.InOutElastic, InOutElastic },
|
|
{ Float.OutInElastic, OutInElastic },
|
|
{ Float.InBack, InBack },
|
|
{ Float.OutBack, OutBack },
|
|
{ Float.InOutBack, InOutBack },
|
|
{ Float.OutInBack, OutInBack },
|
|
{ Float.InBounce, InBounce },
|
|
{ Float.OutBounce, OutBounce },
|
|
{ Float.InOutBounce, InOutBounce },
|
|
{ Float.OutInBounce, OutInBounce }
|
|
};
|
|
|
|
private static Dictionary<Fixed, System.Func<Fix64, Fix64>> FixedLookup = new Dictionary<Fixed, System.Func<Fix64, Fix64>>
|
|
{
|
|
{ Fixed.Linear, Linear },
|
|
{ Fixed.InQuad, InQuad },
|
|
{ Fixed.OutQuad, OutQuad },
|
|
{ Fixed.InOutQuad, InOutQuad },
|
|
{ Fixed.OutInQuad, OutInQuad },
|
|
{ Fixed.InCubic, InCubic },
|
|
{ Fixed.OutCubic, OutCubic },
|
|
{ Fixed.InOutCubic, InOutCubic },
|
|
{ Fixed.OutInCubic, OutInCubic },
|
|
{ Fixed.InQuart, InQuart },
|
|
{ Fixed.OutQuart, OutQuart },
|
|
{ Fixed.InOutQuart, InOutQuart },
|
|
{ Fixed.OutInQuart, OutInQuart },
|
|
{ Fixed.InQuint, InQuint },
|
|
{ Fixed.OutQuint, OutQuint },
|
|
{ Fixed.InOutQuint, InOutQuint },
|
|
{ Fixed.OutInQuint, OutInQuint },
|
|
{ Fixed.InSine, InSine },
|
|
{ Fixed.OutSine, OutSine },
|
|
{ Fixed.InOutSine, InOutSine },
|
|
{ Fixed.OutInSine, OutInSine },
|
|
{ Fixed.InCirc, InCirc },
|
|
{ Fixed.OutCirc, OutCirc },
|
|
{ Fixed.InOutCirc, InOutCirc },
|
|
{ Fixed.OutInCirc, OutInCirc },
|
|
{ Fixed.InBack, InBack },
|
|
{ Fixed.OutBack, OutBack },
|
|
{ Fixed.InOutBack, InOutBack },
|
|
{ Fixed.OutInBack, OutInBack },
|
|
{ Fixed.InBounce, InBounce },
|
|
{ Fixed.OutBounce, OutBounce },
|
|
{ Fixed.InOutBounce, InOutBounce },
|
|
{ Fixed.OutInBounce, OutInBounce }
|
|
};
|
|
|
|
public static System.Func<float, float> Get(Float functionEnum)
|
|
{
|
|
return FloatLookup[functionEnum];
|
|
}
|
|
|
|
public static System.Func<Fix64, Fix64> Get(Fixed functionEnum)
|
|
{
|
|
return FixedLookup[functionEnum];
|
|
}
|
|
}
|
|
}
|
|
}
|