Tanoda
EasingCore.cs
Go to the documentation of this file.
1/*
2 * EasingCore (https://github.com/setchi/EasingCore)
3 * Copyright (c) 2020 setchi
4 * Licensed under MIT (https://github.com/setchi/EasingCore/blob/master/LICENSE)
5 */
6
8{
9 public enum Ease
10 {
11 Linear,
12 InBack,
14 InCirc,
15 InCubic,
17 InExpo,
18 InQuad,
19 InQuart,
20 InQuint,
21 InSine,
22 OutBack,
24 OutCirc,
27 OutExpo,
28 OutQuad,
31 OutSine,
42 }
43
44 public delegate float EasingFunction(float t);
45
46 public static class Easing
47 {
53 public static EasingFunction Get(Ease type)
54 {
55 switch (type)
56 {
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;
89 }
90
91 float linear(float t) => t;
92
93 float inBack(float t) => t * t * t - t * Mathf.Sin(t * Mathf.PI);
94
95 float outBack(float t) => 1f - inBack(1f - t);
96
97 float inOutBack(float t) =>
98 t < 0.5f
99 ? 0.5f * inBack(2f * t)
100 : 0.5f * outBack(2f * t - 1f) + 0.5f;
101
102 float inBounce(float t) => 1f - outBounce(1f - t);
103
104 float outBounce(float t) =>
105 t < 4f / 11.0f ?
106 (121f * t * t) / 16.0f :
107 t < 8f / 11.0f ?
108 (363f / 40.0f * t * t) - (99f / 10.0f * t) + 17f / 5.0f :
109 t < 9f / 10.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;
112
113 float inOutBounce(float t) =>
114 t < 0.5f
115 ? 0.5f * inBounce(2f * t)
116 : 0.5f * outBounce(2f * t - 1f) + 0.5f;
117
118 float inCirc(float t) => 1f - Mathf.Sqrt(1f - (t * t));
119
120 float outCirc(float t) => Mathf.Sqrt((2f - t) * t);
121
122 float inOutCirc(float t) =>
123 t < 0.5f
124 ? 0.5f * (1 - Mathf.Sqrt(1f - 4f * (t * t)))
125 : 0.5f * (Mathf.Sqrt(-((2f * t) - 3f) * ((2f * t) - 1f)) + 1f);
126
127 float inCubic(float t) => t * t * t;
128
129 float outCubic(float t) => inCubic(t - 1f) + 1f;
130
131 float inOutCubic(float t) =>
132 t < 0.5f
133 ? 4f * t * t * t
134 : 0.5f * inCubic(2f * t - 2f) + 1f;
135
136 float inElastic(float t) => Mathf.Sin(13f * (Mathf.PI * 0.5f) * t) * Mathf.Pow(2f, 10f * (t - 1f));
137
138 float outElastic(float t) => Mathf.Sin(-13f * (Mathf.PI * 0.5f) * (t + 1)) * Mathf.Pow(2f, -10f * t) + 1f;
139
140 float inOutElastic(float t) =>
141 t < 0.5f
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);
144
145 float inExpo(float t) => Mathf.Approximately(0.0f, t) ? t : Mathf.Pow(2f, 10f * (t - 1f));
146
147 float outExpo(float t) => Mathf.Approximately(1.0f, t) ? t : 1f - Mathf.Pow(2f, -10f * t);
148
149 float inOutExpo(float v) =>
150 Mathf.Approximately(0.0f, v) || Mathf.Approximately(1.0f, v)
151 ? v
152 : v < 0.5f
153 ? 0.5f * Mathf.Pow(2f, (20f * v) - 10f)
154 : -0.5f * Mathf.Pow(2f, (-20f * v) + 10f) + 1f;
155
156 float inQuad(float t) => t * t;
157
158 float outQuad(float t) => -t * (t - 2f);
159
160 float inOutQuad(float t) =>
161 t < 0.5f
162 ? 2f * t * t
163 : -2f * t * t + 4f * t - 1f;
164
165 float inQuart(float t) => t * t * t * t;
166
167 float outQuart(float t)
168 {
169 var u = t - 1f;
170 return u * u * u * (1f - t) + 1f;
171 }
172
173 float inOutQuart(float t) =>
174 t < 0.5f
175 ? 8f * inQuart(t)
176 : -8f * inQuart(t - 1f) + 1f;
177
178 float inQuint(float t) => t * t * t * t * t;
179
180 float outQuint(float t) => inQuint(t - 1f) + 1f;
181
182 float inOutQuint(float t) =>
183 t < 0.5f
184 ? 16f * inQuint(t)
185 : 0.5f * inQuint(2f * t - 2f) + 1f;
186
187 float inSine(float t) => Mathf.Sin((t - 1f) * (Mathf.PI * 0.5f)) + 1f;
188
189 float outSine(float t) => Mathf.Sin(t * (Mathf.PI * 0.5f));
190
191 float inOutSine(float t) => 0.5f * (1f - Mathf.Cos(t * Mathf.PI));
192 }
193 }
194}
delegate float EasingFunction(float t)