TextFx——Ease Function(緩動(dòng)函數(shù))

By D.S.Qiu

尊重他人的勞動(dòng)，支持原創(chuàng)，轉(zhuǎn)載請(qǐng)注明出處：http://dsqiu.     

       之前有介紹過(guò)UITweener（點(diǎn)擊前往），NGUI用了一個(gè)目錄“收集”Tween腳本，集成的功能還是很豐富的，只提供了6種緩動(dòng)函數(shù)（Ease Fuction）：Linear,EaseIn,EaseOut,EaseInOut,BounceIn和BounceOut。當(dāng)時(shí)，對(duì)緩動(dòng)函數(shù)就只是一知半解。后面為了做文字特效，就發(fā)現(xiàn)了 TextFx 插件，這個(gè)插件太贊了，讓我有種感覺(jué)一切效果都可以用代碼模擬。TextFx提供了40種緩動(dòng)函數(shù)，表現(xiàn)效果豐富了很多，激動(dòng)之余，總是想著能不能把這些緩動(dòng)函數(shù)移植到UITweener里面去，所以才有了此文。

      下面就直接貼出Ease Function的實(shí)現(xiàn)，方便查看。

Method：

       擴(kuò)容之后的Method的樣式由6種變?yōu)?1種：

C#代碼  

1. public enum Method  
2. {  
3.     Linear,  
4.     EaseIn,EaseOut,EaseInOut,BounceIn,BounceOut,  
5.     QuadEaseOut, QuadEaseIn, QuadEaseInOut, QuadEaseOutIn,    //新增40種動(dòng)畫(huà)效果  
6.     ExpoEaseOut, ExpoEaseIn, ExpoEaseInOut, ExpoEaseOutIn,  
7.     CubicEaseOut, CubicEaseIn, CubicEaseInOut, CubicEaseOutIn,  
8.     QuartEaseOut, QuartEaseIn, QuartEaseInOut, QuartEaseOutIn,  
9.     QuintEaseOut, QuintEaseIn, QuintEaseInOut, QuintEaseOutIn,  
10.     CircEaseOut, CircEaseIn, CircEaseInOut, CircEaseOutIn,  
11.     SineEaseOut, SineEaseIn, SineEaseInOut, SineEaseOutIn,  
12.     ElasticEaseOut, ElasticEaseIn, ElasticEaseInOut, ElasticEaseOutIn,  
13.     BounceEaseOut, BounceEaseIn, BounceEaseInOut, BounceEaseOutIn,  
14.     BackEaseOut, BackEaseIn, BackEaseInOut, BackEaseOutIn  
15. }  

Sample：

C#代碼  

1.       public static float GetEaseProgress(Method ease_type, float linear_progress)  
2.   
3. switch (ease_type)  
4. {  
5. case Method.Linear:  
6.     return linear_progress;  
7. case Method.BackEaseIn:  
8.     return BackEaseIn(linear_progress, 0, 1, 1);  
9.       
10. case Method.BackEaseInOut:  
11.     return BackEaseInOut(linear_progress, 0, 1, 1);  
12. case Method.BackEaseOut:  
13.     return BackEaseOut(linear_progress, 0, 1, 1);  
14. case Method.BackEaseOutIn:  
15.     return BackEaseOutIn(linear_progress, 0, 1, 1);  
16. case Method.BounceEaseIn:  
17.     return BounceEaseIn(linear_progress, 0, 1, 1);  
18. case Method.BounceEaseInOut:  
19.     return BounceEaseInOut(linear_progress, 0, 1, 1);  
20. case Method.BounceEaseOut:  
21.     return BounceEaseOut(linear_progress, 0, 1, 1);  
22. case Method.BounceEaseOutIn:  
23.     return BounceEaseOutIn(linear_progress, 0, 1, 1);  
24. case Method.CircEaseIn:  
25.     return CircEaseIn(linear_progress, 0, 1, 1);  
26. case Method.CircEaseInOut:  
27.     return CircEaseInOut(linear_progress, 0, 1, 1);  
28. case Method.CircEaseOut:  
29.     return CircEaseOut(linear_progress, 0, 1, 1);  
30. case Method.CircEaseOutIn:  
31.     return CircEaseOutIn(linear_progress, 0, 1, 1);  
32. case Method.CubicEaseIn:  
33.     return CubicEaseIn(linear_progress, 0, 1, 1);  
34. case Method.CubicEaseInOut:  
35.     return CubicEaseInOut(linear_progress, 0, 1, 1);  
36. case Method.CubicEaseOut:  
37.     return CubicEaseOut(linear_progress, 0, 1, 1);  
38. case Method.CubicEaseOutIn:  
39.     return CubicEaseOutIn(linear_progress, 0, 1, 1);  
40. case Method.ElasticEaseIn:  
41.     return ElasticEaseIn(linear_progress, 0, 1, 1);  
42.       
43. case Method.ElasticEaseInOut:  
44.     return ElasticEaseInOut(linear_progress, 0, 1, 1);  
45. case Method.ElasticEaseOut:  
46.     return ElasticEaseOut(linear_progress, 0, 1, 1);  
47. case Method.ElasticEaseOutIn:  
48.     return ElasticEaseOutIn(linear_progress, 0, 1, 1);  
49. case Method.ExpoEaseIn:  
50.     return ExpoEaseIn(linear_progress, 0, 1, 1);  
51. case Method.ExpoEaseInOut:  
52.     return ExpoEaseInOut(linear_progress, 0, 1, 1);  
53. case Method.ExpoEaseOut:  
54.     return ExpoEaseOut(linear_progress, 0, 1, 1);  
55. case Method.ExpoEaseOutIn:  
56.     return ExpoEaseOutIn(linear_progress, 0, 1, 1);  
57. case Method.QuadEaseIn:  
58.     return QuadEaseIn(linear_progress, 0, 1, 1);  
59. case Method.QuadEaseInOut:  
60.     return QuadEaseInOut(linear_progress, 0, 1, 1);  
61. case Method.QuadEaseOut:  
62.     return QuadEaseOut(linear_progress, 0, 1, 1);  
63. case Method.QuadEaseOutIn:  
64.     return QuadEaseOutIn(linear_progress, 0, 1, 1);  
65. case Method.QuartEaseIn:  
66.     return QuartEaseIn(linear_progress, 0, 1, 1);  
67. case Method.QuartEaseInOut:  
68.     return QuartEaseInOut(linear_progress, 0, 1, 1);  
69. case Method.QuartEaseOut:  
70.     return QuartEaseOut(linear_progress, 0, 1, 1);  
71. case Method.QuartEaseOutIn:  
72.     return QuartEaseOutIn(linear_progress, 0, 1, 1);  
73. case Method.QuintEaseIn:  
74.     return QuintEaseIn(linear_progress, 0, 1, 1);  
75. case Method.QuintEaseInOut:  
76.     return QuintEaseInOut(linear_progress, 0, 1, 1);  
77. case Method.QuintEaseOut:  
78.     return QuintEaseOut(linear_progress, 0, 1, 1);  
79. case Method.QuintEaseOutIn:  
80.     return QuintEaseOutIn(linear_progress, 0, 1, 1);  
81.       
82. case Method.SineEaseIn:  
83.     return SineEaseIn(linear_progress, 0, 1, 1);  
84. case Method.SineEaseInOut:  
85.     return SineEaseInOut(linear_progress, 0, 1, 1);  
86. case Method.SineEaseOut:  
87.     return SineEaseOut(linear_progress, 0, 1, 1);  
88. case Method.SineEaseOutIn:  
89.     return SineEaseOutIn(linear_progress, 0, 1, 1);  
90.       
91. default:  
92.     return linear_progress;  
93. }  

 Ease Function：

C#代碼  

1.        /* EASING FUNCTIONS */  
2.  
3. #region Linear  
4.   
5. /// <summary>  
6. /// Easing equation function for a simple linear tweening, with no easing.  
7. /// </summary>  
8. /// <param name="t">Current time in seconds.</param>  
9. /// <param name="b">Starting value.</param>  
10. /// <param name="c">Final value.</param>  
11. /// <param name="d">Duration of animation.</param>  
12. /// <returns>The correct value.</returns>  
13. public static float Linear(float t, float b, float c, float d)  
14. {  
15.     return c * t / d + b;  
16. }  
17.  
18. #endregion  
19.  
20. #region Expo  
21.   
22. /// <summary>  
23. /// Easing equation function for an exponential (2^t) easing out:   
24. /// decelerating from zero velocity.  
25. /// </summary>  
26. /// <param name="t">Current time in seconds.</param>  
27. /// <param name="b">Starting value.</param>  
28. /// <param name="c">Final value.</param>  
29. /// <param name="d">Duration of animation.</param>  
30. /// <returns>The correct value.</returns>  
31. public static float ExpoEaseOut(float t, float b, float c, float d)  
32. {  
33.     return (t == d) ? b + c : c * (-Mathf.Pow(2, -10 * t / d) + 1) + b;  
34. }  
35.   
36. /// <summary>  
37. /// Easing equation function for an exponential (2^t) easing in:   
38. /// accelerating from zero velocity.  
39. /// </summary>  
40. /// <param name="t">Current time in seconds.</param>  
41. /// <param name="b">Starting value.</param>  
42. /// <param name="c">Final value.</param>  
43. /// <param name="d">Duration of animation.</param>  
44. /// <returns>The correct value.</returns>  
45. public static float ExpoEaseIn(float t, float b, float c, float d)  
46. {  
47.     return (t == 0) ? b : c * Mathf.Pow(2, 10 * (t / d - 1)) + b;  
48. }  
49.   
50. /// <summary>  
51. /// Easing equation function for an exponential (2^t) easing in/out:   
52. /// acceleration until halfway, then deceleration.  
53. /// </summary>  
54. /// <param name="t">Current time in seconds.</param>  
55. /// <param name="b">Starting value.</param>  
56. /// <param name="c">Final value.</param>  
57. /// <param name="d">Duration of animation.</param>  
58. /// <returns>The correct value.</returns>  
59. public static float ExpoEaseInOut(float t, float b, float c, float d)  
60. {  
61.     if (t == 0)  
62.         return b;  
63.       
64.     if (t == d)  
65.         return b + c;  
66.       
67.     if ((t /= d / 2) < 1)  
68.         return c / 2 * Mathf.Pow(2, 10 * (t - 1)) + b;  
69.       
70.     return c / 2 * (-Mathf.Pow(2, -10 * --t) + 2) + b;  
71. }  
72.   
73. /// <summary>  
74. /// Easing equation function for an exponential (2^t) easing out/in:   
75. /// deceleration until halfway, then acceleration.  
76. /// </summary>  
77. /// <param name="t">Current time in seconds.</param>  
78. /// <param name="b">Starting value.</param>  
79. /// <param name="c">Final value.</param>  
80. /// <param name="d">Duration of animation.</param>  
81. /// <returns>The correct value.</returns>  
82. public static float ExpoEaseOutIn(float t, float b, float c, float d)  
83. {  
84.     if (t < d / 2)  
85.         return ExpoEaseOut(t * 2, b, c / 2, d);  
86.       
87.     return ExpoEaseIn((t * 2) - d, b + c / 2, c / 2, d);  
88. }  
89.  
90. #endregion  
91.  
92. #region Circular  
93.   
94. /// <summary>  
95. /// Easing equation function for a circular (sqrt(1-t^2)) easing out:   
96. /// decelerating from zero velocity.  
97. /// </summary>  
98. /// <param name="t">Current time in seconds.</param>  
99. /// <param name="b">Starting value.</param>  
100. /// <param name="c">Final value.</param>  
101. /// <param name="d">Duration of animation.</param>  
102. /// <returns>The correct value.</returns>  
103. public static float CircEaseOut(float t, float b, float c, float d)  
104. {  
105.     return c * Mathf.Sqrt(1 - (t = t / d - 1) * t) + b;  
106. }  
107.   
108. /// <summary>  
109. /// Easing equation function for a circular (sqrt(1-t^2)) easing in:   
110. /// accelerating from zero velocity.  
111. /// </summary>  
112. /// <param name="t">Current time in seconds.</param>  
113. /// <param name="b">Starting value.</param>  
114. /// <param name="c">Final value.</param>  
115. /// <param name="d">Duration of animation.</param>  
116. /// <returns>The correct value.</returns>  
117. public static float CircEaseIn(float t, float b, float c, float d)  
118. {  
119.     return -c * (Mathf.Sqrt(1 - (t /= d) * t) - 1) + b;  
120. }  
121.   
122. /// <summary>  
123. /// Easing equation function for a circular (sqrt(1-t^2)) easing in/out:   
124. /// acceleration until halfway, then deceleration.  
125. /// </summary>  
126. /// <param name="t">Current time in seconds.</param>  
127. /// <param name="b">Starting value.</param>  
128. /// <param name="c">Final value.</param>  
129. /// <param name="d">Duration of animation.</param>  
130. /// <returns>The correct value.</returns>  
131. public static float CircEaseInOut(float t, float b, float c, float d)  
132. {  
133.     if ((t /= d / 2) < 1)  
134.         return -c / 2 * (Mathf.Sqrt(1 - t * t) - 1) + b;  
135.       
136.     return c / 2 * (Mathf.Sqrt(1 - (t -= 2) * t) + 1) + b;  
137. }  
138.   
139. /// <summary>  
140. /// Easing equation function for a circular (sqrt(1-t^2)) easing in/out:   
141. /// acceleration until halfway, then deceleration.  
142. /// </summary>  
143. /// <param name="t">Current time in seconds.</param>  
144. /// <param name="b">Starting value.</param>  
145. /// <param name="c">Final value.</param>  
146. /// <param name="d">Duration of animation.</param>  
147. /// <returns>The correct value.</returns>  
148. public static float CircEaseOutIn(float t, float b, float c, float d)  
149. {  
150.     if (t < d / 2)  
151.         return CircEaseOut(t * 2, b, c / 2, d);  
152.       
153.     return CircEaseIn((t * 2) - d, b + c / 2, c / 2, d);  
154. }  
155.  
156. #endregion  
157.  
158. #region Quad  
159.   
160. /// <summary>  
161. /// Easing equation function for a quadratic (t^2) easing out:   
162. /// decelerating from zero velocity.  
163. /// </summary>  
164. /// <param name="t">Current time in seconds.</param>  
165. /// <param name="b">Starting value.</param>  
166. /// <param name="c">Final value.</param>  
167. /// <param name="d">Duration of animation.</param>  
168. /// <returns>The correct value.</returns>  
169. public static float QuadEaseOut(float t, float b, float c, float d)  
170. {  
171.     return -c * (t /= d) * (t - 2) + b;  
172. }  
173.   
174. /// <summary>  
175. /// Easing equation function for a quadratic (t^2) easing in:   
176. /// accelerating from zero velocity.  
177. /// </summary>  
178. /// <param name="t">Current time in seconds.</param>  
179. /// <param name="b">Starting value.</param>  
180. /// <param name="c">Final value.</param>  
181. /// <param name="d">Duration of animation.</param>  
182. /// <returns>The correct value.</returns>  
183. public static float QuadEaseIn(float t, float b, float c, float d)  
184. {  
185.     return c * (t /= d) * t + b;  
186. }  
187.   
188. /// <summary>  
189. /// Easing equation function for a quadratic (t^2) easing in/out:   
190. /// acceleration until halfway, then deceleration.  
191. /// </summary>  
192. /// <param name="t">Current time in seconds.</param>  
193. /// <param name="b">Starting value.</param>  
194. /// <param name="c">Final value.</param>  
195. /// <param name="d">Duration of animation.</param>  
196. /// <returns>The correct value.</returns>  
197. public static float QuadEaseInOut(float t, float b, float c, float d)  
198. {  
199.     if ((t /= d / 2) < 1)  
200.         return c / 2 * t * t + b;  
201.       
202.     return -c / 2 * ((--t) * (t - 2) - 1) + b;  
203. }  
204.   
205. /// <summary>  
206. /// Easing equation function for a quadratic (t^2) easing out/in:   
207. /// deceleration until halfway, then acceleration.  
208. /// </summary>  
209. /// <param name="t">Current time in seconds.</param>  
210. /// <param name="b">Starting value.</param>  
211. /// <param name="c">Final value.</param>  
212. /// <param name="d">Duration of animation.</param>  
213. /// <returns>The correct value.</returns>  
214. public static float QuadEaseOutIn(float t, float b, float c, float d)  
215. {  
216.     if (t < d / 2)  
217.         return QuadEaseOut(t * 2, b, c / 2, d);  
218.       
219.     return QuadEaseIn((t * 2) - d, b + c / 2, c / 2, d);  
220. }  
221.  
222. #endregion  
223.  
224. #region Sine  
225.   
226. /// <summary>  
227. /// Easing equation function for a sinusoidal (sin(t)) easing out:   
228. /// decelerating from zero velocity.  
229. /// </summary>  
230. /// <param name="t">Current time in seconds.</param>  
231. /// <param name="b">Starting value.</param>  
232. /// <param name="c">Final value.</param>  
233. /// <param name="d">Duration of animation.</param>  
234. /// <returns>The correct value.</returns>  
235. public static float SineEaseOut(float t, float b, float c, float d)  
236. {  
237.     return c * Mathf.Sin(t / d * (Mathf.PI / 2)) + b;  
238. }  
239.   
240. /// <summary>  
241. /// Easing equation function for a sinusoidal (sin(t)) easing in:   
242. /// accelerating from zero velocity.  
243. /// </summary>  
244. /// <param name="t">Current time in seconds.</param>  
245. /// <param name="b">Starting value.</param>  
246. /// <param name="c">Final value.</param>  
247. /// <param name="d">Duration of animation.</param>  
248. /// <returns>The correct value.</returns>  
249. public static float SineEaseIn(float t, float b, float c, float d)  
250. {  
251.     return -c * Mathf.Cos(t / d * (Mathf.PI / 2)) + c + b;  
252. }  
253.   
254. /// <summary>  
255. /// Easing equation function for a sinusoidal (sin(t)) easing in/out:   
256. /// acceleration until halfway, then deceleration.  
257. /// </summary>  
258. /// <param name="t">Current time in seconds.</param>  
259. /// <param name="b">Starting value.</param>  
260. /// <param name="c">Final value.</param>  
261. /// <param name="d">Duration of animation.</param>  
262. /// <returns>The correct value.</returns>  
263. public static float SineEaseInOut(float t, float b, float c, float d)  
264. {  
265.     if ((t /= d / 2) < 1)  
266.         return c / 2 * (Mathf.Sin(Mathf.PI * t / 2)) + b;  
267.       
268.     return -c / 2 * (Mathf.Cos(Mathf.PI * --t / 2) - 2) + b;  
269. }  
270.   
271. /// <summary>  
272. /// Easing equation function for a sinusoidal (sin(t)) easing in/out:   
273. /// deceleration until halfway, then acceleration.  
274. /// </summary>  
275. /// <param name="t">Current time in seconds.</param>  
276. /// <param name="b">Starting value.</param>  
277. /// <param name="c">Final value.</param>  
278. /// <param name="d">Duration of animation.</param>  
279. /// <returns>The correct value.</returns>  
280. public static float SineEaseOutIn(float t, float b, float c, float d)  
281. {  
282.     if (t < d / 2)  
283.         return SineEaseOut(t * 2, b, c / 2, d);  
284.       
285.     return SineEaseIn((t * 2) - d, b + c / 2, c / 2, d);  
286. }  
287.  
288. #endregion  
289.  
290. #region Cubic  
291.   
292. /// <summary>  
293. /// Easing equation function for a cubic (t^3) easing out:   
294. /// decelerating from zero velocity.  
295. /// </summary>  
296. /// <param name="t">Current time in seconds.</param>  
297. /// <param name="b">Starting value.</param>  
298. /// <param name="c">Final value.</param>  
299. /// <param name="d">Duration of animation.</param>  
300. /// <returns>The correct value.</returns>  
301. public static float CubicEaseOut(float t, float b, float c, float d)  
302. {  
303.     return c * ((t = t / d - 1) * t * t + 1) + b;  
304. }  
305.   
306. /// <summary>  
307. /// Easing equation function for a cubic (t^3) easing in:   
308. /// accelerating from zero velocity.  
309. /// </summary>  
310. /// <param name="t">Current time in seconds.</param>  
311. /// <param name="b">Starting value.</param>  
312. /// <param name="c">Final value.</param>  
313. /// <param name="d">Duration of animation.</param>  
314. /// <returns>The correct value.</returns>  
315. public static float CubicEaseIn(float t, float b, float c, float d)  
316. {  
317.     return c * (t /= d) * t * t + b;  
318. }  
319.   
320. /// <summary>  
321. /// Easing equation function for a cubic (t^3) easing in/out:   
322. /// acceleration until halfway, then deceleration.  
323. /// </summary>  
324. /// <param name="t">Current time in seconds.</param>  
325. /// <param name="b">Starting value.</param>  
326. /// <param name="c">Final value.</param>  
327. /// <param name="d">Duration of animation.</param>  
328. /// <returns>The correct value.</returns>  
329. public static float CubicEaseInOut(float t, float b, float c, float d)  
330. {  
331.     if ((t /= d / 2) < 1)  
332.         return c / 2 * t * t * t + b;  
333.       
334.     return c / 2 * ((t -= 2) * t * t + 2) + b;  
335. }  
336.   
337. /// <summary>  
338. /// Easing equation function for a cubic (t^3) easing out/in:   
339. /// deceleration until halfway, then acceleration.  
340. /// </summary>  
341. /// <param name="t">Current time in seconds.</param>  
342. /// <param name="b">Starting value.</param>  
343. /// <param name="c">Final value.</param>  
344. /// <param name="d">Duration of animation.</param>  
345. /// <returns>The correct value.</returns>  
346. public static float CubicEaseOutIn(float t, float b, float c, float d)  
347. {  
348.     if (t < d / 2)  
349.         return CubicEaseOut(t * 2, b, c / 2, d);  
350.       
351.     return CubicEaseIn((t * 2) - d, b + c / 2, c / 2, d);  
352. }  
353.  
354. #endregion  
355.  
356. #region Quartic  
357.   
358. /// <summary>  
359. /// Easing equation function for a quartic (t^4) easing out:   
360. /// decelerating from zero velocity.  
361. /// </summary>  
362. /// <param name="t">Current time in seconds.</param>  
363. /// <param name="b">Starting value.</param>  
364. /// <param name="c">Final value.</param>  
365. /// <param name="d">Duration of animation.</param>  
366. /// <returns>The correct value.</returns>  
367. public static float QuartEaseOut(float t, float b, float c, float d)  
368. {  
369.     return -c * ((t = t / d - 1) * t * t * t - 1) + b;  
370. }  
371.   
372. /// <summary>  
373. /// Easing equation function for a quartic (t^4) easing in:   
374. /// accelerating from zero velocity.  
375. /// </summary>  
376. /// <param name="t">Current time in seconds.</param>  
377. /// <param name="b">Starting value.</param>  
378. /// <param name="c">Final value.</param>  
379. /// <param name="d">Duration of animation.</param>  
380. /// <returns>The correct value.</returns>  
381. public static float QuartEaseIn(float t, float b, float c, float d)  
382. {  
383.     return c * (t /= d) * t * t * t + b;  
384. }  
385.   
386. /// <summary>  
387. /// Easing equation function for a quartic (t^4) easing in/out:   
388. /// acceleration until halfway, then deceleration.  
389. /// </summary>  
390. /// <param name="t">Current time in seconds.</param>  
391. /// <param name="b">Starting value.</param>  
392. /// <param name="c">Final value.</param>  
393. /// <param name="d">Duration of animation.</param>  
394. /// <returns>The correct value.</returns>  
395. public static float QuartEaseInOut(float t, float b, float c, float d)  
396. {  
397.     if ((t /= d / 2) < 1)  
398.         return c / 2 * t * t * t * t + b;  
399.       
400.     return -c / 2 * ((t -= 2) * t * t * t - 2) + b;  
401. }  
402.   
403. /// <summary>  
404. /// Easing equation function for a quartic (t^4) easing out/in:   
405. /// deceleration until halfway, then acceleration.  
406. /// </summary>  
407. /// <param name="t">Current time in seconds.</param>  
408. /// <param name="b">Starting value.</param>  
409. /// <param name="c">Final value.</param>  
410. /// <param name="d">Duration of animation.</param>  
411. /// <returns>The correct value.</returns>  
412. public static float QuartEaseOutIn(float t, float b, float c, float d)  
413. {  
414.     if (t < d / 2)  
415.         return QuartEaseOut(t * 2, b, c / 2, d);  
416.       
417.     return QuartEaseIn((t * 2) - d, b + c / 2, c / 2, d);  
418. }  
419.  
420. #endregion  
421.  
422. #region Quintic  
423.   
424. /// <summary>  
425. /// Easing equation function for a quintic (t^5) easing out:   
426. /// decelerating from zero velocity.  
427. /// </summary>  
428. /// <param name="t">Current time in seconds.</param>  
429. /// <param name="b">Starting value.</param>  
430. /// <param name="c">Final value.</param>  
431. /// <param name="d">Duration of animation.</param>  
432. /// <returns>The correct value.</returns>  
433. public static float QuintEaseOut(float t, float b, float c, float d)  
434. {  
435.     return c * ((t = t / d - 1) * t * t * t * t + 1) + b;  
436. }  
437.   
438. /// <summary>  
439. /// Easing equation function for a quintic (t^5) easing in:   
440. /// accelerating from zero velocity.  
441. /// </summary>  
442. /// <param name="t">Current time in seconds.</param>  
443. /// <param name="b">Starting value.</param>  
444. /// <param name="c">Final value.</param>  
445. /// <param name="d">Duration of animation.</param>  
446. /// <returns>The correct value.</returns>  
447. public static float QuintEaseIn(float t, float b, float c, float d)  
448. {  
449.     return c * (t /= d) * t * t * t * t + b;  
450. }  
451.   
452. /// <summary>  
453. /// Easing equation function for a quintic (t^5) easing in/out:   
454. /// acceleration until halfway, then deceleration.  
455. /// </summary>  
456. /// <param name="t">Current time in seconds.</param>  
457. /// <param name="b">Starting value.</param>  
458. /// <param name="c">Final value.</param>  
459. /// <param name="d">Duration of animation.</param>  
460. /// <returns>The correct value.</returns>  
461. public static float QuintEaseInOut(float t, float b, float c, float d)  
462. {  
463.     if ((t /= d / 2) < 1)  
464.         return c / 2 * t * t * t * t * t + b;  
465.     return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;  
466. }  
467.   
468. /// <summary>  
469. /// Easing equation function for a quintic (t^5) easing in/out:   
470. /// acceleration until halfway, then deceleration.  
471. /// </summary>  
472. /// <param name="t">Current time in seconds.</param>  
473. /// <param name="b">Starting value.</param>  
474. /// <param name="c">Final value.</param>  
475. /// <param name="d">Duration of animation.</param>  
476. /// <returns>The correct value.</returns>  
477. public static float QuintEaseOutIn(float t, float b, float c, float d)  
478. {  
479.     if (t < d / 2)  
480.         return QuintEaseOut(t * 2, b, c / 2, d);  
481.     return QuintEaseIn((t * 2) - d, b + c / 2, c / 2, d);  
482. }  
483.  
484. #endregion  
485.  
486. #region Elastic  
487.   
488. /// <summary>  
489. /// Easing equation function for an elastic (exponentially decaying sine wave) easing out:   
490. /// decelerating from zero velocity.  
491. /// </summary>  
492. /// <param name="t">Current time in seconds.</param>  
493. /// <param name="b">Starting value.</param>  
494. /// <param name="c">Final value.</param>  
495. /// <param name="d">Duration of animation.</param>  
496. /// <returns>The correct value.</returns>  
497. public static float ElasticEaseOut(float t, float b, float c, float d)  
498. {  
499.     if ((t /= d) == 1)  
500.         return b + c;  
501.       
502.     float p = d * 0.3f;  
503.     float s = p / 4;  
504.       
505.     return (c * Mathf.Pow(2, -10 * t) * Mathf.Sin((t * d - s) * (2 * Mathf.PI) / p) + c + b);  
506. }  
507.   
508. /// <summary>  
509. /// Easing equation function for an elastic (exponentially decaying sine wave) easing in:   
510. /// accelerating from zero velocity.  
511. /// </summary>  
512. /// <param name="t">Current time in seconds.</param>  
513. /// <param name="b">Starting value.</param>  
514. /// <param name="c">Final value.</param>  
515. /// <param name="d">Duration of animation.</param>  
516. /// <returns>The correct value.</returns>  
517. public static float ElasticEaseIn(float t, float b, float c, float d)  
518. {  
519.     if ((t /= d) == 1)  
520.         return b + c;  
521.       
522.     float p = d * 0.3f;  
523.     float s = p / 4;  
524.       
525.     return -(c * Mathf.Pow(2, 10 * (t -= 1)) * Mathf.Sin((t * d - s) * (2 * Mathf.PI) / p)) + b;  
526. }  
527.   
528. /// <summary>  
529. /// Easing equation function for an elastic (exponentially decaying sine wave) easing in/out:   
530. /// acceleration until halfway, then deceleration.  
531. /// </summary>  
532. /// <param name="t">Current time in seconds.</param>  
533. /// <param name="b">Starting value.</param>  
534. /// <param name="c">Final value.</param>  
535. /// <param name="d">Duration of animation.</param>  
536. /// <returns>The correct value.</returns>  
537. public static float ElasticEaseInOut(float t, float b, float c, float d)  
538. {  
539.     if ((t /= d / 2f) == 2)  
540.         return b + c;  
541.       
542.     float p = d * (0.3f * 1.5f);  
543.     float s = p / 4;  
544.       
545.     if (t < 1)  
546.         return -0.5f * (c * Mathf.Pow(2, 10 * (t -= 1)) * Mathf.Sin((t * d - s) * (2 * Mathf.PI) / p)) + b;  
547.     return c * Mathf.Pow(2, -10 * (t -= 1)) * Mathf.Sin((t * d - s) * (2 * Mathf.PI) / p) * 0.5f + c + b;  
548. }  
549.   
550. /// <summary>  
551. /// Easing equation function for an elastic (exponentially decaying sine wave) easing out/in:   
552. /// deceleration until halfway, then acceleration.  
553. /// </summary>  
554. /// <param name="t">Current time in seconds.</param>  
555. /// <param name="b">Starting value.</param>  
556. /// <param name="c">Final value.</param>  
557. /// <param name="d">Duration of animation.</param>  
558. /// <returns>The correct value.</returns>  
559. public static float ElasticEaseOutIn(float t, float b, float c, float d)  
560. {  
561.     if (t < d / 2)  
562.         return ElasticEaseOut(t * 2, b, c / 2, d);  
563.     return ElasticEaseIn((t * 2) - d, b + c / 2, c / 2, d);  
564. }  
565.  
566. #endregion  
567.  
568. #region Bounce  
569.   
570. /// <summary>  
571. /// Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out:   
572. /// decelerating from zero velocity.  
573. /// </summary>  
574. /// <param name="t">Current time in seconds.</param>  
575. /// <param name="b">Starting value.</param>  
576. /// <param name="c">Final value.</param>  
577. /// <param name="d">Duration of animation.</param>  
578. /// <returns>The correct value.</returns>  
579. public static float BounceEaseOut(float t, float b, float c, float d)  
580. {  
581.     if ((t /= d) < (1 / 2.75f))  
582.         return c * (7.5625f * t * t) + b;  
583.     else if (t < (2 / 2.75f))  
584.         return c * (7.5625f * (t -= (1.5f / 2.75f)) * t + 0.75f) + b;  
585.     else if (t < (2.5f / 2.75f))  
586.         return c * (7.5625f * (t -= (2.25f / 2.75f)) * t + 0.9375f) + b;  
587.     else  
588.         return c * (7.5625f * (t -= (2.625f / 2.75f)) * t + .984375f) + b;  
589. }  
590.   
591. /// <summary>  
592. /// Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in:   
593. /// accelerating from zero velocity.  
594. /// </summary>  
595. /// <param name="t">Current time in seconds.</param>  
596. /// <param name="b">Starting value.</param>  
597. /// <param name="c">Final value.</param>  
598. /// <param name="d">Duration of animation.</param>  
599. /// <returns>The correct value.</returns>  
600. public static float BounceEaseIn(float t, float b, float c, float d)  
601. {  
602.     return c - BounceEaseOut(d - t, 0, c, d) + b;  
603. }  
604.   
605. /// <summary>  
606. /// Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in/out:   
607. /// acceleration until halfway, then deceleration.  
608. /// </summary>  
609. /// <param name="t">Current time in seconds.</param>  
610. /// <param name="b">Starting value.</param>  
611. /// <param name="c">Final value.</param>  
612. /// <param name="d">Duration of animation.</param>  
613. /// <returns>The correct value.</returns>  
614. public static float BounceEaseInOut(float t, float b, float c, float d)  
615. {  
616.     if (t < d / 2)  
617.         return BounceEaseIn(t * 2, 0, c, d) * 0.5f + b;  
618.     else  
619.         return BounceEaseOut(t * 2 - d, 0, c, d) * 0.5f + c * 0.5f + b;  
620. }  
621.   
622. /// <summary>  
623. /// Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out/in:   
624. /// deceleration until halfway, then acceleration.  
625. /// </summary>  
626. /// <param name="t">Current time in seconds.</param>  
627. /// <param name="b">Starting value.</param>  
628. /// <param name="c">Final value.</param>  
629. /// <param name="d">Duration of animation.</param>  
630. /// <returns>The correct value.</returns>  
631. public static float BounceEaseOutIn(float t, float b, float c, float d)  
632. {  
633.     if (t < d / 2)  
634.         return BounceEaseOut(t * 2, b, c / 2, d);  
635.     return BounceEaseIn((t * 2) - d, b + c / 2, c / 2, d);  
636. }  
637.  
638. #endregion  
639.  
640. #region Back  
641.   
642. /// <summary>  
643. /// Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out:   
644. /// decelerating from zero velocity.  
645. /// </summary>  
646. /// <param name="t">Current time in seconds.</param>  
647. /// <param name="b">Starting value.</param>  
648. /// <param name="c">Final value.</param>  
649. /// <param name="d">Duration of animation.</param>  
650. /// <returns>The correct value.</returns>  
651. public static float BackEaseOut(float t, float b, float c, float d)  
652. {  
653.     return c * ((t = t / d - 1) * t * ((1.70158f + 1) * t + 1.70158f) + 1) + b;  
654. }  
655.   
656. /// <summary>  
657. /// Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in:   
658. /// accelerating from zero velocity.  
659. /// </summary>  
660. /// <param name="t">Current time in seconds.</param>  
661. /// <param name="b">Starting value.</param>  
662. /// <param name="c">Final value.</param>  
663. /// <param name="d">Duration of animation.</param>  
664. /// <returns>The correct value.</returns>  
665. public static float BackEaseIn(float t, float b, float c, float d)  
666. {  
667.     return c * (t /= d) * t * ((1.70158f + 1) * t - 1.70158f) + b;  
668. }  
669.   
670. /// <summary>  
671. /// Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in/out:   
672. /// acceleration until halfway, then deceleration.  
673. /// </summary>  
674. /// <param name="t">Current time in seconds.</param>  
675. /// <param name="b">Starting value.</param>  
676. /// <param name="c">Final value.</param>  
677. /// <param name="d">Duration of animation.</param>  
678. /// <returns>The correct value.</returns>  
679. public static float BackEaseInOut(float t, float b, float c, float d)  
680. {  
681.     float s = 1.70158f;  
682.     if ((t /= d / 2) < 1)  
683.         return c / 2 * (t * t * (((s *= (1.525f)) + 1) * t - s)) + b;  
684.     return c / 2 * ((t -= 2) * t * (((s *= (1.525f)) + 1) * t + s) + 2) + b;  
685. }  
686.   
687. /// <summary>  
688. /// Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out/in:   
689. /// deceleration until halfway, then acceleration.  
690. /// </summary>  
691. /// <param name="t">Current time in seconds.</param>  
692. /// <param name="b">Starting value.</param>  
693. /// <param name="c">Final value.</param>  
694. /// <param name="d">Duration of animation.</param>  
695. /// <returns>The correct value.</returns>  
696. public static float BackEaseOutIn(float t, float b, float c, float d)  
697. {  
698.     if (t < d / 2)  
699.         return BackEaseOut(t * 2, b, c / 2, d);  
700.     return BackEaseIn((t * 2) - d, b + c / 2, c / 2, d);  
701. }  
702.  
703. #endregion  

小結(jié)：

       首先，非常感謝TextFx的作者，然后 TextFx 的插件真的很棒，實(shí)用又簡(jiǎn)單，而不會(huì)華而不實(shí)。在UITweener的文章中也對(duì)緩動(dòng)函數(shù)有介紹，貼出其中30種的軌跡圖，會(huì)更加直觀。此文是為了大家能夠檢索到需要的內(nèi)容。

『

       在UITweener的文末附上了30中緩動(dòng)曲線的圖形，感覺(jué)有點(diǎn)不夠動(dòng)態(tài)，參考①中給出的效果會(huì)更好些，更容易理解和體會(huì)?！?/p>

                                                                                                                                                                            增補(bǔ)于 2014,1,14  9:25

如果您對(duì)D.S.Qiu有任何建議或意見(jiàn)可以在文章后面評(píng)論，或者發(fā)郵件（gd.s.qiu@gmail.com)交流，您的鼓勵(lì)和支持是我前進(jìn)的動(dòng)力，希望能有更多更好的分享。

        轉(zhuǎn)載請(qǐng)?jiān)谖氖鬃⒚鞒鎏帲?a style="color: white; line-height: 1.5em; font-size: 1.2em; text-decoration: underline; background-color: rgb(16, 138, 198);" href="http://dsqiu./blog/2001007">http://dsqiu./blog/2001007

更多精彩請(qǐng)關(guān)注D.S.Qiu的博客和微博（ID：靜水逐風(fēng)）

 參考：

①: http://www./easing/easing_demo.html