程序博客网 > js继承题目

TextFx-Ease Function(缓动函数)

来源：互联网 发布：js继承题目 编辑：程序博客网 时间：2024/06/09 17:10

尊重他人的劳动，支持原创，转载请注明出处：http://dsqiu.iteye.com    

       之前有介绍过UITweener（点击前往），NGUI用了一个目录“收集”Tween脚本，集成的功能还是很丰富的，只提供了6种缓动函数（Ease Fuction）：Linear,EaseIn,EaseOut,EaseInOut,BounceIn和BounceOut。当时，对缓动函数就只是一知半解。后面为了做文字特效，就发现了 TextFx 插件，这个插件太赞了，让我有种感觉一切效果都可以用代码模拟。TextFx提供了40种缓动函数，表现效果丰富了很多，激动之余，总是想着能不能把这些缓动函数移植到UITweener里面去，所以才有了此文。

      下面就直接贴出Ease Function的实现，方便查看。

Method：

       扩容之后的Method的样式由6种变为41种：

C#代码 复制代码 收藏代码
  1. public enum Method 
  2. { 
  3.     Linear, 
  4.     EaseIn,EaseOut,EaseInOut,BounceIn,BounceOut, 
  5.     QuadEaseOut, QuadEaseIn, QuadEaseInOut, QuadEaseOutIn,    //新增40种动画效果 
  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 staticfloat 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 */ 
  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 staticfloat Linear(float t,float b, float c,float d) 
  14. { 
  15.     return c * t / d + b; 
  16. } 
  18. #endregion 
  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 staticfloat 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 staticfloat 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 staticfloat 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 staticfloat 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. } 
  90. #endregion 
  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 staticfloat 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 staticfloat 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 staticfloat 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 staticfloat 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. } 
  156. #endregion 
  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 staticfloat 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 staticfloat 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 staticfloat 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 staticfloat 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. } 
  222. #endregion 
  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 staticfloat 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 staticfloat 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 staticfloat 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 staticfloat 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. } 
  288. #endregion 
  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 staticfloat 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 staticfloat 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 staticfloat 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 staticfloat 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. } 
  354. #endregion 
  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 staticfloat 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 staticfloat 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 staticfloat 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 staticfloat 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. } 
  420. #endregion 
  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 staticfloat 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 staticfloat 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 staticfloat 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 staticfloat 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. } 
  484. #endregion 
  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 staticfloat 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 staticfloat 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 staticfloat 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 staticfloat 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. } 
  566. #endregion 
  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 staticfloat 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 staticfloat 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 staticfloat 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 staticfloat 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. } 
  638. #endregion 
  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 staticfloat 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 staticfloat 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 staticfloat 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 staticfloat 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. } 
  703. #endregion 

小结：

       首先，非常感谢TextFx的作者，然后 TextFx 的插件真的很棒，实用又简单，而不会华而不实。在UITweener的文章中也对缓动函数有介绍，贴出其中30种的轨迹图，会更加直观。此文是为了大家能够检索到需要的内容。

『

       在UITweener的文末附上了30中缓动曲线的图形，感觉有点不够动态，参考①中给出的效果会更好些，更容易理解和体会。』

                                                                                                                                                                            增补于 2014,1,14  9:25

如果您对D.S.Qiu有任何建议或意见可以在文章后面评论，或者发邮件（gd.s.qiu@gmail.com)交流，您的鼓励和支持是我前进的动力，希望能有更多更好的分享。

        转载请在文首注明出处：http://dsqiu.iteye.com/blog/2001007

更多精彩请关注D.S.Qiu的博客和微博（ID：静水逐风）

参考：

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

0 0
js继承题目 js继承题目
原创粉丝点击
热门IT博客
杭州数据分析培训机构杭州数据分析培训机构
算法4 4kints.txt算法4 4kints.txt
淘宝手机助手登录失败
网络剧微电影审核通则
双11淘宝怎么抢购
佛经知乎
易语言吃鸡辅助源码
ubuntu 配置静态ip
经典的香水 知乎
工程清单计价软件
淘宝的摩托车可以买么
美迪软件
Linux怎么运行jar文件
ntfs for mac官网
第四方支付源码
文章得失寸心知
php exec 权限
微信公众源码
midi音源软件
网站开发php程序员
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 华盛顿旅游攻略 华盛顿杜勒斯机场 华盛顿大学研究生 华盛顿有哪些大学 华盛顿一日游攻略 华盛顿市 美国首都华盛顿 北京到华盛顿多少公里 华盛顿大学申请条件 华盛顿大学留学申请 史密斯先生到华盛顿 华肤天成一次性祛斑是真的吗 华硕k55vd zx50j华硕 华硕zx50v 华硕k012 华硕f454l 华硕y481l 华硕i3配置 华硕a42j 华硕u303l 华硕e402 华硕k43tk 华硕ux303 华硕n56v 华硕k45d 华硕k550 华硕a450j 华硕a450v 华硕k55d 华硕n56 华硕t100 华硕k43sd 华硕f554 华硕k401 华硕k43sj 华硕g751 华硕k53s 华硕n55 华硕k45v 华硕k55dr

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里