46 public static class Easing
57 case Ease.Linear:
return linear;
58 case Ease.InBack:
return inBack;
59 case Ease.InBounce:
return inBounce;
60 case Ease.InCirc:
return inCirc;
61 case Ease.InCubic:
return inCubic;
62 case Ease.InElastic:
return inElastic;
63 case Ease.InExpo:
return inExpo;
64 case Ease.InQuad:
return inQuad;
65 case Ease.InQuart:
return inQuart;
66 case Ease.InQuint:
return inQuint;
67 case Ease.InSine:
return inSine;
68 case Ease.OutBack:
return outBack;
69 case Ease.OutBounce:
return outBounce;
70 case Ease.OutCirc:
return outCirc;
71 case Ease.OutCubic:
return outCubic;
72 case Ease.OutElastic:
return outElastic;
73 case Ease.OutExpo:
return outExpo;
74 case Ease.OutQuad:
return outQuad;
75 case Ease.OutQuart:
return outQuart;
76 case Ease.OutQuint:
return outQuint;
77 case Ease.OutSine:
return outSine;
78 case Ease.InOutBack:
return inOutBack;
79 case Ease.InOutBounce:
return inOutBounce;
80 case Ease.InOutCirc:
return inOutCirc;
81 case Ease.InOutCubic:
return inOutCubic;
82 case Ease.InOutElastic:
return inOutElastic;
83 case Ease.InOutExpo:
return inOutExpo;
84 case Ease.InOutQuad:
return inOutQuad;
85 case Ease.InOutQuart:
return inOutQuart;
86 case Ease.InOutQuint:
return inOutQuint;
87 case Ease.InOutSine:
return inOutSine;
88 default:
return linear;
91 float linear(
float t) => t;
93 float inBack(
float t) => t * t * t - t * Mathf.Sin(t * Mathf.PI);
95 float outBack(
float t) => 1f - inBack(1f - t);
97 float inOutBack(
float t) =>
99 ? 0.5f * inBack(2f * t)
100 : 0.5f * outBack(2f * t - 1f) + 0.5f;
102 float inBounce(
float t) => 1f - outBounce(1f - t);
104 float outBounce(
float t) =>
106 (121f * t * t) / 16.0f :
108 (363f / 40.0f * t * t) - (99f / 10.0f * t) + 17f / 5.0f :
110 (4356f / 361.0f * t * t) - (35442f / 1805.0f * t) + 16061f / 1805.0f :
111 (54f / 5.0f * t * t) - (513f / 25.0f * t) + 268f / 25.0f;
113 float inOutBounce(
float t) =>
115 ? 0.5f * inBounce(2f * t)
116 : 0.5f * outBounce(2f * t - 1f) + 0.5f;
118 float inCirc(
float t) => 1f - Mathf.Sqrt(1f - (t * t));
120 float outCirc(
float t) => Mathf.Sqrt((2f - t) * t);
122 float inOutCirc(
float t) =>
124 ? 0.5f * (1 - Mathf.Sqrt(1f - 4f * (t * t)))
125 : 0.5f * (Mathf.Sqrt(-((2f * t) - 3f) * ((2f * t) - 1f)) + 1f);
127 float inCubic(
float t) => t * t * t;
129 float outCubic(
float t) => inCubic(t - 1f) + 1f;
131 float inOutCubic(
float t) =>
134 : 0.5f * inCubic(2f * t - 2f) + 1f;
136 float inElastic(
float t) => Mathf.Sin(13f * (Mathf.PI * 0.5f) * t) * Mathf.Pow(2f, 10f * (t - 1f));
138 float outElastic(
float t) => Mathf.Sin(-13f * (Mathf.PI * 0.5f) * (t + 1)) * Mathf.Pow(2f, -10f * t) + 1f;
140 float inOutElastic(
float t) =>
142 ? 0.5f * Mathf.Sin(13f * (Mathf.PI * 0.5f) * (2f * t)) * Mathf.Pow(2f, 10f * ((2f * t) - 1f))
143 : 0.5f * (Mathf.Sin(-13f * (Mathf.PI * 0.5f) * ((2f * t - 1f) + 1f)) * Mathf.Pow(2f, -10f * (2f * t - 1f)) + 2f);
145 float inExpo(
float t) => Mathf.Approximately(0.0f, t) ? t : Mathf.Pow(2f, 10f * (t - 1f));
147 float outExpo(
float t) => Mathf.Approximately(1.0f, t) ? t : 1f - Mathf.Pow(2f, -10f * t);
149 float inOutExpo(
float v) =>
150 Mathf.Approximately(0.0f, v) || Mathf.Approximately(1.0f, v)
153 ? 0.5f * Mathf.Pow(2f, (20f * v) - 10f)
154 : -0.5f * Mathf.Pow(2f, (-20f * v) + 10f) + 1f;
156 float inQuad(
float t) => t * t;
158 float outQuad(
float t) => -t * (t - 2f);
160 float inOutQuad(
float t) =>
163 : -2f * t * t + 4f * t - 1f;
165 float inQuart(
float t) => t * t * t * t;
167 float outQuart(
float t)
170 return u * u * u * (1f - t) + 1f;
173 float inOutQuart(
float t) =>
176 : -8f * inQuart(t - 1f) + 1f;
178 float inQuint(
float t) => t * t * t * t * t;
180 float outQuint(
float t) => inQuint(t - 1f) + 1f;
182 float inOutQuint(
float t) =>
185 : 0.5f * inQuint(2f * t - 2f) + 1f;
187 float inSine(
float t) => Mathf.Sin((t - 1f) * (Mathf.PI * 0.5f)) + 1f;
189 float outSine(
float t) => Mathf.Sin(t * (Mathf.PI * 0.5f));
191 float inOutSine(
float t) => 0.5f * (1f - Mathf.Cos(t * Mathf.PI));
delegate float EasingFunction(float t)