[Summary view] [Print] [Text view]

   1  /*
   2  YUI 3.17.2 (build 9c3c78e)
   3  Copyright 2014 Yahoo! Inc. All rights reserved.
   4  Licensed under the BSD License.
   5  http://yuilibrary.com/license/
   6  */
   7  
   8  YUI.add('anim-easing', function (Y, NAME) {
   9  
  10  /*
  11  TERMS OF USE - EASING EQUATIONS
  12  Open source under the BSD License.
  13  Copyright 2001 Robert Penner All rights reserved.
  14  
  15  Redistribution and use in source and binary forms, with or without modification,
  16  are permitted provided that the following conditions are met:
  17  
  18   * Redistributions of source code must retain the above copyright notice, this
  19      list of conditions and the following disclaimer.
  20   * Redistributions in binary form must reproduce the above copyright notice,
  21      this list of conditions and the following disclaimer in the documentation
  22      and/or other materials provided with the distribution.
  23   * Neither the name of the author nor the names of contributors may be used to
  24      endorse or promote products derived from this software without specific prior
  25      written permission.
  26  
  27  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  28  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  29  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  30  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  31  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  32  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  33  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  34  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  35  OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  36  OF THE POSSIBILITY OF SUCH DAMAGE.
  37  */
  38  
  39  /**
  40   * The easing module provides methods for customizing
  41   * how an animation behaves during each run.
  42   * @class Easing
  43   * @module anim
  44   * @submodule anim-easing
  45   */
  46  
  47  var Easing = {
  48  
  49      /**
  50       * Uniform speed between points.
  51       * @for Easing
  52       * @method easeNone
  53       * @param {Number} t Time value used to compute current value
  54       * @param {Number} b Starting value
  55       * @param {Number} c Delta between start and end values
  56       * @param {Number} d Total length of animation
  57       * @return {Number} The computed value for the current animation frame
  58       */
  59      easeNone: function (t, b, c, d) {
  60          return c*t/d + b;
  61      },
  62  
  63      /**
  64       * Begins slowly and accelerates towards end. (quadratic)
  65       * @method easeIn
  66       * @param {Number} t Time value used to compute current value
  67       * @param {Number} b Starting value
  68       * @param {Number} c Delta between start and end values
  69       * @param {Number} d Total length of animation
  70       * @return {Number} The computed value for the current animation frame
  71       */
  72      easeIn: function (t, b, c, d) {
  73          return c*(t/=d)*t + b;
  74      },
  75  
  76      /**
  77       * Begins quickly and decelerates towards end.  (quadratic)
  78       * @method easeOut
  79       * @param {Number} t Time value used to compute current value
  80       * @param {Number} b Starting value
  81       * @param {Number} c Delta between start and end values
  82       * @param {Number} d Total length of animation
  83       * @return {Number} The computed value for the current animation frame
  84       */
  85      easeOut: function (t, b, c, d) {
  86          return -c *(t/=d)*(t-2) + b;
  87      },
  88  
  89      /**
  90       * Begins slowly and decelerates towards end. (quadratic)
  91       * @method easeBoth
  92       * @param {Number} t Time value used to compute current value
  93       * @param {Number} b Starting value
  94       * @param {Number} c Delta between start and end values
  95       * @param {Number} d Total length of animation
  96       * @return {Number} The computed value for the current animation frame
  97       */
  98      easeBoth: function (t, b, c, d) {
  99          if ((t /= d/2) < 1) {
 100              return c/2*t*t + b;
 101          }
 102  
 103          return -c/2 * ((--t)*(t-2) - 1) + b;
 104      },
 105  
 106      /**
 107       * Begins slowly and accelerates towards end. (quartic)
 108       * @method easeInStrong
 109       * @param {Number} t Time value used to compute current value
 110       * @param {Number} b Starting value
 111       * @param {Number} c Delta between start and end values
 112       * @param {Number} d Total length of animation
 113       * @return {Number} The computed value for the current animation frame
 114       */
 115      easeInStrong: function (t, b, c, d) {
 116          return c*(t/=d)*t*t*t + b;
 117      },
 118  
 119      /**
 120       * Begins quickly and decelerates towards end.  (quartic)
 121       * @method easeOutStrong
 122       * @param {Number} t Time value used to compute current value
 123       * @param {Number} b Starting value
 124       * @param {Number} c Delta between start and end values
 125       * @param {Number} d Total length of animation
 126       * @return {Number} The computed value for the current animation frame
 127       */
 128      easeOutStrong: function (t, b, c, d) {
 129          return -c * ((t=t/d-1)*t*t*t - 1) + b;
 130      },
 131  
 132      /**
 133       * Begins slowly and decelerates towards end. (quartic)
 134       * @method easeBothStrong
 135       * @param {Number} t Time value used to compute current value
 136       * @param {Number} b Starting value
 137       * @param {Number} c Delta between start and end values
 138       * @param {Number} d Total length of animation
 139       * @return {Number} The computed value for the current animation frame
 140       */
 141      easeBothStrong: function (t, b, c, d) {
 142          if ((t /= d/2) < 1) {
 143              return c/2*t*t*t*t + b;
 144          }
 145  
 146          return -c/2 * ((t-=2)*t*t*t - 2) + b;
 147      },
 148  
 149      /**
 150       * Snap in elastic effect.
 151       * @method elasticIn
 152       * @param {Number} t Time value used to compute current value
 153       * @param {Number} b Starting value
 154       * @param {Number} c Delta between start and end values
 155       * @param {Number} d Total length of animation
 156       * @param {Number} a Amplitude (optional)
 157       * @param {Number} p Period (optional)
 158       * @return {Number} The computed value for the current animation frame
 159       */
 160  
 161      elasticIn: function (t, b, c, d, a, p) {
 162          var s;
 163          if (t === 0) {
 164              return b;
 165          }
 166          if ( (t /= d) === 1 ) {
 167              return b+c;
 168          }
 169          if (!p) {
 170              p = d* 0.3;
 171          }
 172  
 173          if (!a || a < Math.abs(c)) {
 174              a = c;
 175              s = p/4;
 176          }
 177          else {
 178              s = p/(2*Math.PI) * Math.asin (c/a);
 179          }
 180  
 181          return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
 182      },
 183  
 184      /**
 185       * Snap out elastic effect.
 186       * @method elasticOut
 187       * @param {Number} t Time value used to compute current value
 188       * @param {Number} b Starting value
 189       * @param {Number} c Delta between start and end values
 190       * @param {Number} d Total length of animation
 191       * @param {Number} a Amplitude (optional)
 192       * @param {Number} p Period (optional)
 193       * @return {Number} The computed value for the current animation frame
 194       */
 195      elasticOut: function (t, b, c, d, a, p) {
 196          var s;
 197          if (t === 0) {
 198              return b;
 199          }
 200          if ( (t /= d) === 1 ) {
 201              return b+c;
 202          }
 203          if (!p) {
 204              p=d * 0.3;
 205          }
 206  
 207          if (!a || a < Math.abs(c)) {
 208              a = c;
 209              s = p / 4;
 210          }
 211          else {
 212              s = p/(2*Math.PI) * Math.asin (c/a);
 213          }
 214  
 215          return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
 216      },
 217  
 218      /**
 219       * Snap both elastic effect.
 220       * @method elasticBoth
 221       * @param {Number} t Time value used to compute current value
 222       * @param {Number} b Starting value
 223       * @param {Number} c Delta between start and end values
 224       * @param {Number} d Total length of animation
 225       * @param {Number} a Amplitude (optional)
 226       * @param {Number} p Period (optional)
 227       * @return {Number} The computed value for the current animation frame
 228       */
 229      elasticBoth: function (t, b, c, d, a, p) {
 230          var s;
 231          if (t === 0) {
 232              return b;
 233          }
 234  
 235          if ( (t /= d/2) === 2 ) {
 236              return b+c;
 237          }
 238  
 239          if (!p) {
 240              p = d*(0.3*1.5);
 241          }
 242  
 243          if ( !a || a < Math.abs(c) ) {
 244              a = c;
 245              s = p/4;
 246          }
 247          else {
 248              s = p/(2*Math.PI) * Math.asin (c/a);
 249          }
 250  
 251          if (t < 1) {
 252              return -0.5*(a*Math.pow(2,10*(t-=1)) *
 253                      Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
 254          }
 255          return a*Math.pow(2,-10*(t-=1)) *
 256                  Math.sin( (t*d-s)*(2*Math.PI)/p )*0.5 + c + b;
 257      },
 258  
 259  
 260      /**
 261       * Backtracks slightly, then reverses direction and moves to end.
 262       * @method backIn
 263       * @param {Number} t Time value used to compute current value
 264       * @param {Number} b Starting value
 265       * @param {Number} c Delta between start and end values
 266       * @param {Number} d Total length of animation
 267       * @param {Number} s Overshoot (optional)
 268       * @return {Number} The computed value for the current animation frame
 269       */
 270      backIn: function (t, b, c, d, s) {
 271          if (s === undefined) {
 272              s = 1.70158;
 273          }
 274          if (t === d) {
 275              t -= 0.001;
 276          }
 277          return c*(t/=d)*t*((s+1)*t - s) + b;
 278      },
 279  
 280      /**
 281       * Overshoots end, then reverses and comes back to end.
 282       * @method backOut
 283       * @param {Number} t Time value used to compute current value
 284       * @param {Number} b Starting value
 285       * @param {Number} c Delta between start and end values
 286       * @param {Number} d Total length of animation
 287       * @param {Number} s Overshoot (optional)
 288       * @return {Number} The computed value for the current animation frame
 289       */
 290      backOut: function (t, b, c, d, s) {
 291          if (typeof s === 'undefined') {
 292              s = 1.70158;
 293          }
 294          return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
 295      },
 296  
 297      /**
 298       * Backtracks slightly, then reverses direction, overshoots end,
 299       * then reverses and comes back to end.
 300       * @method backBoth
 301       * @param {Number} t Time value used to compute current value
 302       * @param {Number} b Starting value
 303       * @param {Number} c Delta between start and end values
 304       * @param {Number} d Total length of animation
 305       * @param {Number} s Overshoot (optional)
 306       * @return {Number} The computed value for the current animation frame
 307       */
 308      backBoth: function (t, b, c, d, s) {
 309          if (typeof s === 'undefined') {
 310              s = 1.70158;
 311          }
 312  
 313          if ((t /= d/2 ) < 1) {
 314              return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
 315          }
 316          return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
 317      },
 318  
 319      /**
 320       * Bounce off of start.
 321       * @method bounceIn
 322       * @param {Number} t Time value used to compute current value
 323       * @param {Number} b Starting value
 324       * @param {Number} c Delta between start and end values
 325       * @param {Number} d Total length of animation
 326       * @return {Number} The computed value for the current animation frame
 327       */
 328      bounceIn: function (t, b, c, d) {
 329          return c - Y.Easing.bounceOut(d-t, 0, c, d) + b;
 330      },
 331  
 332      /**
 333       * Bounces off end.
 334       * @method bounceOut
 335       * @param {Number} t Time value used to compute current value
 336       * @param {Number} b Starting value
 337       * @param {Number} c Delta between start and end values
 338       * @param {Number} d Total length of animation
 339       * @return {Number} The computed value for the current animation frame
 340       */
 341      bounceOut: function (t, b, c, d) {
 342          if ((t/=d) < (1/2.75)) {
 343                  return c*(7.5625*t*t) + b;
 344          } else if (t < (2/2.75)) {
 345                  return c*(7.5625*(t-=(1.5/2.75))*t + 0.75) + b;
 346          } else if (t < (2.5/2.75)) {
 347                  return c*(7.5625*(t-=(2.25/2.75))*t + 0.9375) + b;
 348          }
 349          return c*(7.5625*(t-=(2.625/2.75))*t + 0.984375) + b;
 350      },
 351  
 352      /**
 353       * Bounces off start and end.
 354       * @method bounceBoth
 355       * @param {Number} t Time value used to compute current value
 356       * @param {Number} b Starting value
 357       * @param {Number} c Delta between start and end values
 358       * @param {Number} d Total length of animation
 359       * @return {Number} The computed value for the current animation frame
 360       */
 361      bounceBoth: function (t, b, c, d) {
 362          if (t < d/2) {
 363              return Y.Easing.bounceIn(t * 2, 0, c, d) * 0.5 + b;
 364          }
 365          return Y.Easing.bounceOut(t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b;
 366      }
 367  };
 368  
 369  Y.Easing = Easing;
 370  
 371  
 372  }, '3.17.2', {"requires": ["anim-base"]});