web-ui-fw/0.0.2/0.0.2_Common/original/css/car/components/tween/tween.js

   1 /**
   2  * @author sole / http://soledadpenades.com
   3  * @author mrdoob / http://mrdoob.com
   4  * @author Robert Eisele / http://www.xarg.org
   5  * @author Philippe / http://philippe.elsass.me
   6  * @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html
   7  * @author Paul Lewis / http://www.aerotwist.com/
   8  * @author lechecacharro
   9  * @author Josh Faul / http://jocafa.com/
  10  * @author egraether / http://egraether.com/
  11  * @author endel / http://endel.me
  12  * @author Ben Delarre / http://delarre.net
  13  */
  14
  15 // Date.now shim for (ahem) Internet Explo(d|r)er
  16 if ( Date.now === undefined ) {
  17
  18         Date.now = function () {
  19
  20                 return new Date().valueOf();
  21
  22         };
  23
  24 }
  25
  26 var TWEEN = TWEEN || ( function () {
  27
  28         var _tweens = [];
  29
  30         return {
  31
  32                 REVISION: '12',
  33
  34                 getAll: function () {
  35
  36                         return _tweens;
  37
  38                 },
  39
  40                 removeAll: function () {
  41
  42                         _tweens = [];
  43
  44                 },
  45
  46                 add: function ( tween ) {
  47
  48                         _tweens.push( tween );
  49
  50                 },
  51
  52                 remove: function ( tween ) {
  53
  54                         var i = _tweens.indexOf( tween );
  55
  56                         if ( i !== -1 ) {
  57
  58                                 _tweens.splice( i, 1 );
  59
  60                         }
  61
  62                 },
  63
  64                 update: function ( time ) {
  65
  66                         if ( _tweens.length === 0 ) return false;
  67
  68                         var i = 0;
  69
  70                         time = time !== undefined ? time : ( typeof window !== 'undefined' && window.performance !== undefined && window.performance.now !== undefined ? window.performance.now() : Date.now() );
  71
  72                         while ( i < _tweens.length ) {
  73
  74                                 if ( _tweens[ i ].update( time ) ) {
  75
  76                                         i++;
  77
  78                                 } else {
  79
  80                                         _tweens.splice( i, 1 );
  81
  82                                 }
  83
  84                         }
  85
  86                         return true;
  87
  88                 }
  89         };
  90
  91 } )();
  92
  93 TWEEN.Tween = function ( object ) {
  94
  95         var _object = object;
  96         var _valuesStart = {};
  97         var _valuesEnd = {};
  98         var _valuesStartRepeat = {};
  99         var _duration = 1000;
 100         var _repeat = 0;
 101         var _yoyo = false;
 102         var _isPlaying = false;
 103         var _reversed = false;
 104         var _delayTime = 0;
 105         var _startTime = null;
 106         var _easingFunction = TWEEN.Easing.Linear.None;
 107         var _interpolationFunction = TWEEN.Interpolation.Linear;
 108         var _chainedTweens = [];
 109         var _onStartCallback = null;
 110         var _onStartCallbackFired = false;
 111         var _onUpdateCallback = null;
 112         var _onCompleteCallback = null;
 113
 114         // Set all starting values present on the target object
 115         for ( var field in object ) {
 116
 117                 _valuesStart[ field ] = parseFloat(object[field], 10);
 118
 119         }
 120
 121         this.to = function ( properties, duration ) {
 122
 123                 if ( duration !== undefined ) {
 124
 125                         _duration = duration;
 126
 127                 }
 128
 129                 _valuesEnd = properties;
 130
 131                 return this;
 132
 133         };
 134
 135         this.start = function ( time ) {
 136
 137                 TWEEN.add( this );
 138
 139                 _isPlaying = true;
 140
 141                 _onStartCallbackFired = false;
 142
 143                 _startTime = time !== undefined ? time : ( typeof window !== 'undefined' && window.performance !== undefined && window.performance.now !== undefined ? window.performance.now() : Date.now() );
 144                 _startTime += _delayTime;
 145
 146                 for ( var property in _valuesEnd ) {
 147
 148                         // check if an Array was provided as property value
 149                         if ( _valuesEnd[ property ] instanceof Array ) {
 150
 151                                 if ( _valuesEnd[ property ].length === 0 ) {
 152
 153                                         continue;
 154
 155                                 }
 156
 157                                 // create a local copy of the Array with the start value at the front
 158                                 _valuesEnd[ property ] = [ _object[ property ] ].concat( _valuesEnd[ property ] );
 159
 160                         }
 161
 162                         _valuesStart[ property ] = _object[ property ];
 163
 164                         if( ( _valuesStart[ property ] instanceof Array ) === false ) {
 165                                 _valuesStart[ property ] *= 1.0; // Ensures we're using numbers, not strings
 166                         }
 167
 168                         _valuesStartRepeat[ property ] = _valuesStart[ property ] || 0;
 169
 170                 }
 171
 172                 return this;
 173
 174         };
 175
 176         this.stop = function () {
 177
 178                 if ( !_isPlaying ) {
 179                         return this;
 180                 }
 181
 182                 TWEEN.remove( this );
 183                 _isPlaying = false;
 184                 this.stopChainedTweens();
 185                 return this;
 186
 187         };
 188
 189         this.stopChainedTweens = function () {
 190
 191                 for ( var i = 0, numChainedTweens = _chainedTweens.length; i < numChainedTweens; i++ ) {
 192
 193                         _chainedTweens[ i ].stop();
 194
 195                 }
 196
 197         };
 198
 199         this.delay = function ( amount ) {
 200
 201                 _delayTime = amount;
 202                 return this;
 203
 204         };
 205
 206         this.repeat = function ( times ) {
 207
 208                 _repeat = times;
 209                 return this;
 210
 211         };
 212
 213         this.yoyo = function( yoyo ) {
 214
 215                 _yoyo = yoyo;
 216                 return this;
 217
 218         };
 219
 220
 221         this.easing = function ( easing ) {
 222
 223                 _easingFunction = easing;
 224                 return this;
 225
 226         };
 227
 228         this.interpolation = function ( interpolation ) {
 229
 230                 _interpolationFunction = interpolation;
 231                 return this;
 232
 233         };
 234
 235         this.chain = function () {
 236
 237                 _chainedTweens = arguments;
 238                 return this;
 239
 240         };
 241
 242         this.onStart = function ( callback ) {
 243
 244                 _onStartCallback = callback;
 245                 return this;
 246
 247         };
 248
 249         this.onUpdate = function ( callback ) {
 250
 251                 _onUpdateCallback = callback;
 252                 return this;
 253
 254         };
 255
 256         this.onComplete = function ( callback ) {
 257
 258                 _onCompleteCallback = callback;
 259                 return this;
 260
 261         };
 262
 263         this.update = function ( time ) {
 264
 265                 var property;
 266
 267                 if ( time < _startTime ) {
 268
 269                         return true;
 270
 271                 }
 272
 273                 if ( _onStartCallbackFired === false ) {
 274
 275                         if ( _onStartCallback !== null ) {
 276
 277                                 _onStartCallback.call( _object );
 278
 279                         }
 280
 281                         _onStartCallbackFired = true;
 282
 283                 }
 284
 285                 var elapsed = ( time - _startTime ) / _duration;
 286                 elapsed = elapsed > 1 ? 1 : elapsed;
 287
 288                 var value = _easingFunction( elapsed );
 289
 290                 for ( property in _valuesEnd ) {
 291
 292                         var start = _valuesStart[ property ] || 0;
 293                         var end = _valuesEnd[ property ];
 294
 295                         if ( end instanceof Array ) {
 296
 297                                 _object[ property ] = _interpolationFunction( end, value );
 298
 299                         } else {
 300
 301                 // Parses relative end values with start as base (e.g.: +10, -3)
 302                                 if ( typeof(end) === "string" ) {
 303                                         end = start + parseFloat(end, 10);
 304                                 }
 305
 306                                 // protect against non numeric properties.
 307                 if ( typeof(end) === "number" ) {
 308                                         _object[ property ] = start + ( end - start ) * value;
 309                                 }
 310
 311                         }
 312
 313                 }
 314
 315                 if ( _onUpdateCallback !== null ) {
 316
 317                         _onUpdateCallback.call( _object, value );
 318
 319                 }
 320
 321                 if ( elapsed == 1 ) {
 322
 323                         if ( _repeat > 0 ) {
 324
 325                                 if( isFinite( _repeat ) ) {
 326                                         _repeat--;
 327                                 }
 328
 329                                 // reassign starting values, restart by making startTime = now
 330                                 for( property in _valuesStartRepeat ) {
 331
 332                                         if ( typeof( _valuesEnd[ property ] ) === "string" ) {
 333                                                 _valuesStartRepeat[ property ] = _valuesStartRepeat[ property ] + parseFloat(_valuesEnd[ property ], 10);
 334                                         }
 335
 336                                         if (_yoyo) {
 337                                                 var tmp = _valuesStartRepeat[ property ];
 338                                                 _valuesStartRepeat[ property ] = _valuesEnd[ property ];
 339                                                 _valuesEnd[ property ] = tmp;
 340                                                 _reversed = !_reversed;
 341                                         }
 342                                         _valuesStart[ property ] = _valuesStartRepeat[ property ];
 343
 344                                 }
 345
 346                                 _startTime = time + _delayTime;
 347
 348                                 return true;
 349
 350                         } else {
 351
 352                                 if ( _onCompleteCallback !== null ) {
 353
 354                                         _onCompleteCallback.call( _object );
 355
 356                                 }
 357
 358                                 for ( var i = 0, numChainedTweens = _chainedTweens.length; i < numChainedTweens; i++ ) {
 359
 360                                         _chainedTweens[ i ].start( time );
 361
 362                                 }
 363
 364                                 return false;
 365
 366                         }
 367
 368                 }
 369
 370                 return true;
 371
 372         };
 373
 374 };
 375
 376
 377 TWEEN.Easing = {
 378
 379         Linear: {
 380
 381                 None: function ( k ) {
 382
 383                         return k;
 384
 385                 }
 386
 387         },
 388
 389         Quadratic: {
 390
 391                 In: function ( k ) {
 392
 393                         return k * k;
 394
 395                 },
 396
 397                 Out: function ( k ) {
 398
 399                         return k * ( 2 - k );
 400
 401                 },
 402
 403                 InOut: function ( k ) {
 404
 405                         if ( ( k *= 2 ) < 1 ) return 0.5 * k * k;
 406                         return - 0.5 * ( --k * ( k - 2 ) - 1 );
 407
 408                 }
 409
 410         },
 411
 412         Cubic: {
 413
 414                 In: function ( k ) {
 415
 416                         return k * k * k;
 417
 418                 },
 419
 420                 Out: function ( k ) {
 421
 422                         return --k * k * k + 1;
 423
 424                 },
 425
 426                 InOut: function ( k ) {
 427
 428                         if ( ( k *= 2 ) < 1 ) return 0.5 * k * k * k;
 429                         return 0.5 * ( ( k -= 2 ) * k * k + 2 );
 430
 431                 }
 432
 433         },
 434
 435         Quartic: {
 436
 437                 In: function ( k ) {
 438
 439                         return k * k * k * k;
 440
 441                 },
 442
 443                 Out: function ( k ) {
 444
 445                         return 1 - ( --k * k * k * k );
 446
 447                 },
 448
 449                 InOut: function ( k ) {
 450
 451                         if ( ( k *= 2 ) < 1) return 0.5 * k * k * k * k;
 452                         return - 0.5 * ( ( k -= 2 ) * k * k * k - 2 );
 453
 454                 }
 455
 456         },
 457
 458         Quintic: {
 459
 460                 In: function ( k ) {
 461
 462                         return k * k * k * k * k;
 463
 464                 },
 465
 466                 Out: function ( k ) {
 467
 468                         return --k * k * k * k * k + 1;
 469
 470                 },
 471
 472                 InOut: function ( k ) {
 473
 474                         if ( ( k *= 2 ) < 1 ) return 0.5 * k * k * k * k * k;
 475                         return 0.5 * ( ( k -= 2 ) * k * k * k * k + 2 );
 476
 477                 }
 478
 479         },
 480
 481         Sinusoidal: {
 482
 483                 In: function ( k ) {
 484
 485                         return 1 - Math.cos( k * Math.PI / 2 );
 486
 487                 },
 488
 489                 Out: function ( k ) {
 490
 491                         return Math.sin( k * Math.PI / 2 );
 492
 493                 },
 494
 495                 InOut: function ( k ) {
 496
 497                         return 0.5 * ( 1 - Math.cos( Math.PI * k ) );
 498
 499                 }
 500
 501         },
 502
 503         Exponential: {
 504
 505                 In: function ( k ) {
 506
 507                         return k === 0 ? 0 : Math.pow( 1024, k - 1 );
 508
 509                 },
 510
 511                 Out: function ( k ) {
 512
 513                         return k === 1 ? 1 : 1 - Math.pow( 2, - 10 * k );
 514
 515                 },
 516
 517                 InOut: function ( k ) {
 518
 519                         if ( k === 0 ) return 0;
 520                         if ( k === 1 ) return 1;
 521                         if ( ( k *= 2 ) < 1 ) return 0.5 * Math.pow( 1024, k - 1 );
 522                         return 0.5 * ( - Math.pow( 2, - 10 * ( k - 1 ) ) + 2 );
 523
 524                 }
 525
 526         },
 527
 528         Circular: {
 529
 530                 In: function ( k ) {
 531
 532                         return 1 - Math.sqrt( 1 - k * k );
 533
 534                 },
 535
 536                 Out: function ( k ) {
 537
 538                         return Math.sqrt( 1 - ( --k * k ) );
 539
 540                 },
 541
 542                 InOut: function ( k ) {
 543
 544                         if ( ( k *= 2 ) < 1) return - 0.5 * ( Math.sqrt( 1 - k * k) - 1);
 545                         return 0.5 * ( Math.sqrt( 1 - ( k -= 2) * k) + 1);
 546
 547                 }
 548
 549         },
 550
 551         Elastic: {
 552
 553                 In: function ( k ) {
 554
 555                         var s, a = 0.1, p = 0.4;
 556                         if ( k === 0 ) return 0;
 557                         if ( k === 1 ) return 1;
 558                         if ( !a || a < 1 ) { a = 1; s = p / 4; }
 559                         else s = p * Math.asin( 1 / a ) / ( 2 * Math.PI );
 560                         return - ( a * Math.pow( 2, 10 * ( k -= 1 ) ) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) );
 561
 562                 },
 563
 564                 Out: function ( k ) {
 565
 566                         var s, a = 0.1, p = 0.4;
 567                         if ( k === 0 ) return 0;
 568                         if ( k === 1 ) return 1;
 569                         if ( !a || a < 1 ) { a = 1; s = p / 4; }
 570                         else s = p * Math.asin( 1 / a ) / ( 2 * Math.PI );
 571                         return ( a * Math.pow( 2, - 10 * k) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) + 1 );
 572
 573                 },
 574
 575                 InOut: function ( k ) {
 576
 577                         var s, a = 0.1, p = 0.4;
 578                         if ( k === 0 ) return 0;
 579                         if ( k === 1 ) return 1;
 580                         if ( !a || a < 1 ) { a = 1; s = p / 4; }
 581                         else s = p * Math.asin( 1 / a ) / ( 2 * Math.PI );
 582                         if ( ( k *= 2 ) < 1 ) return - 0.5 * ( a * Math.pow( 2, 10 * ( k -= 1 ) ) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) );
 583                         return a * Math.pow( 2, -10 * ( k -= 1 ) ) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) * 0.5 + 1;
 584
 585                 }
 586
 587         },
 588
 589         Back: {
 590
 591                 In: function ( k ) {
 592
 593                         var s = 1.70158;
 594                         return k * k * ( ( s + 1 ) * k - s );
 595
 596                 },
 597
 598                 Out: function ( k ) {
 599
 600                         var s = 1.70158;
 601                         return --k * k * ( ( s + 1 ) * k + s ) + 1;
 602
 603                 },
 604
 605                 InOut: function ( k ) {
 606
 607                         var s = 1.70158 * 1.525;
 608                         if ( ( k *= 2 ) < 1 ) return 0.5 * ( k * k * ( ( s + 1 ) * k - s ) );
 609                         return 0.5 * ( ( k -= 2 ) * k * ( ( s + 1 ) * k + s ) + 2 );
 610
 611                 }
 612
 613         },
 614
 615         Bounce: {
 616
 617                 In: function ( k ) {
 618
 619                         return 1 - TWEEN.Easing.Bounce.Out( 1 - k );
 620
 621                 },
 622
 623                 Out: function ( k ) {
 624
 625                         if ( k < ( 1 / 2.75 ) ) {
 626
 627                                 return 7.5625 * k * k;
 628
 629                         } else if ( k < ( 2 / 2.75 ) ) {
 630
 631                                 return 7.5625 * ( k -= ( 1.5 / 2.75 ) ) * k + 0.75;
 632
 633                         } else if ( k < ( 2.5 / 2.75 ) ) {
 634
 635                                 return 7.5625 * ( k -= ( 2.25 / 2.75 ) ) * k + 0.9375;
 636
 637                         } else {
 638
 639                                 return 7.5625 * ( k -= ( 2.625 / 2.75 ) ) * k + 0.984375;
 640
 641                         }
 642
 643                 },
 644
 645                 InOut: function ( k ) {
 646
 647                         if ( k < 0.5 ) return TWEEN.Easing.Bounce.In( k * 2 ) * 0.5;
 648                         return TWEEN.Easing.Bounce.Out( k * 2 - 1 ) * 0.5 + 0.5;
 649
 650                 }
 651
 652         }
 653
 654 };
 655
 656 TWEEN.Interpolation = {
 657
 658         Linear: function ( v, k ) {
 659
 660                 var m = v.length - 1, f = m * k, i = Math.floor( f ), fn = TWEEN.Interpolation.Utils.Linear;
 661
 662                 if ( k < 0 ) return fn( v[ 0 ], v[ 1 ], f );
 663                 if ( k > 1 ) return fn( v[ m ], v[ m - 1 ], m - f );
 664
 665                 return fn( v[ i ], v[ i + 1 > m ? m : i + 1 ], f - i );
 666
 667         },
 668
 669         Bezier: function ( v, k ) {
 670
 671                 var b = 0, n = v.length - 1, pw = Math.pow, bn = TWEEN.Interpolation.Utils.Bernstein, i;
 672
 673                 for ( i = 0; i <= n; i++ ) {
 674                         b += pw( 1 - k, n - i ) * pw( k, i ) * v[ i ] * bn( n, i );
 675                 }
 676
 677                 return b;
 678
 679         },
 680
 681         CatmullRom: function ( v, k ) {
 682
 683                 var m = v.length - 1, f = m * k, i = Math.floor( f ), fn = TWEEN.Interpolation.Utils.CatmullRom;
 684
 685                 if ( v[ 0 ] === v[ m ] ) {
 686
 687                         if ( k < 0 ) i = Math.floor( f = m * ( 1 + k ) );
 688
 689                         return fn( v[ ( i - 1 + m ) % m ], v[ i ], v[ ( i + 1 ) % m ], v[ ( i + 2 ) % m ], f - i );
 690
 691                 } else {
 692
 693                         if ( k < 0 ) return v[ 0 ] - ( fn( v[ 0 ], v[ 0 ], v[ 1 ], v[ 1 ], -f ) - v[ 0 ] );
 694                         if ( k > 1 ) return v[ m ] - ( fn( v[ m ], v[ m ], v[ m - 1 ], v[ m - 1 ], f - m ) - v[ m ] );
 695
 696                         return fn( v[ i ? i - 1 : 0 ], v[ i ], v[ m < i + 1 ? m : i + 1 ], v[ m < i + 2 ? m : i + 2 ], f - i );
 697
 698                 }
 699
 700         },
 701
 702         Utils: {
 703
 704                 Linear: function ( p0, p1, t ) {
 705
 706                         return ( p1 - p0 ) * t + p0;
 707
 708                 },
 709
 710                 Bernstein: function ( n , i ) {
 711
 712                         var fc = TWEEN.Interpolation.Utils.Factorial;
 713                         return fc( n ) / fc( i ) / fc( n - i );
 714
 715                 },
 716
 717                 Factorial: ( function () {
 718
 719                         var a = [ 1 ];
 720
 721                         return function ( n ) {
 722
 723                                 var s = 1, i;
 724                                 if ( a[ n ] ) return a[ n ];
 725                                 for ( i = n; i > 1; i-- ) s *= i;
 726                                 return a[ n ] = s;
 727
 728                         };
 729
 730                 } )(),
 731
 732                 CatmullRom: function ( p0, p1, p2, p3, t ) {
 733
 734                         var v0 = ( p2 - p0 ) * 0.5, v1 = ( p3 - p1 ) * 0.5, t2 = t * t, t3 = t * t2;
 735                         return ( 2 * p1 - 2 * p2 + v0 + v1 ) * t3 + ( - 3 * p1 + 3 * p2 - 2 * v0 - v1 ) * t2 + v0 * t + p1;
 736
 737                 }
 738
 739         }
 740
 741 };