mirror of
https://github.com/pcottle/learnGitBranching.git
synced 2025-06-28 08:50:06 +02:00
530 lines
8.8 KiB
JavaScript
530 lines
8.8 KiB
JavaScript
/**
|
|
* @author sole / http://soledadpenades.com
|
|
* @author mr.doob / http://mrdoob.com
|
|
* @author Robert Eisele / http://www.xarg.org
|
|
* @author Philippe / http://philippe.elsass.me
|
|
* @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html
|
|
* @author Paul Lewis / http://www.aerotwist.com/
|
|
* @author lechecacharro
|
|
* @author Josh Faul / http://jocafa.com/
|
|
*/
|
|
|
|
var TWEEN = TWEEN || ( function () {
|
|
|
|
var i, tl, interval, time, fps = 60, autostart = false, tweens = [];
|
|
|
|
return {
|
|
|
|
setFPS: function ( f ) {
|
|
|
|
fps = f || 60;
|
|
|
|
},
|
|
|
|
start: function ( f ) {
|
|
|
|
if( arguments.length != 0 ) {
|
|
this.setFPS( f );
|
|
}
|
|
|
|
interval = setInterval( this.update, 1000 / fps );
|
|
|
|
},
|
|
|
|
stop: function () {
|
|
|
|
clearInterval( interval );
|
|
|
|
},
|
|
|
|
setAutostart: function ( value ) {
|
|
|
|
autostart = value;
|
|
|
|
if(autostart && !interval) {
|
|
this.start();
|
|
}
|
|
|
|
},
|
|
|
|
add: function ( tween ) {
|
|
|
|
tweens.push( tween );
|
|
|
|
if (autostart && !interval) {
|
|
|
|
this.start();
|
|
|
|
}
|
|
|
|
},
|
|
|
|
getAll: function() {
|
|
|
|
return tweens;
|
|
|
|
},
|
|
|
|
removeAll: function() {
|
|
|
|
tweens = [];
|
|
|
|
},
|
|
|
|
remove: function ( tween ) {
|
|
|
|
i = tweens.indexOf( tween );
|
|
|
|
if ( i !== -1 ) {
|
|
|
|
tweens.splice( i, 1 );
|
|
|
|
}
|
|
|
|
},
|
|
|
|
update: function (_time) {
|
|
|
|
i = 0; num_tweens = tweens.length;
|
|
var time = _time || Date.now();
|
|
|
|
while ( i < num_tweens ) {
|
|
|
|
if ( tweens[ i ].update( time ) ) {
|
|
|
|
i++;
|
|
|
|
} else {
|
|
|
|
tweens.splice( i, 1 );
|
|
num_tweens--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (num_tweens == 0 && autostart == true) {
|
|
|
|
this.stop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} )();
|
|
|
|
TWEEN.Tween = function ( object ) {
|
|
|
|
var _object = object,
|
|
_valuesStart = {},
|
|
_valuesDelta = {},
|
|
_valuesEnd = {},
|
|
_duration = 1000,
|
|
_delayTime = 0,
|
|
_startTime = null,
|
|
_easingFunction = TWEEN.Easing.Linear.EaseNone,
|
|
_chainedTween = null,
|
|
_onUpdateCallback = null,
|
|
_onCompleteCallback = null;
|
|
|
|
this.to = function ( properties, duration ) {
|
|
|
|
if( duration !== null ) {
|
|
|
|
_duration = duration;
|
|
|
|
}
|
|
|
|
for ( var property in properties ) {
|
|
|
|
// This prevents the engine from interpolating null values
|
|
if ( _object[ property ] === null ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// The current values are read when the tween starts;
|
|
// here we only store the final desired values
|
|
_valuesEnd[ property ] = properties[ property ];
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
};
|
|
|
|
this.start = function (_time) {
|
|
|
|
TWEEN.add( this );
|
|
|
|
_startTime = _time ? _time + _delayTime : Date.now() + _delayTime;
|
|
|
|
for ( var property in _valuesEnd ) {
|
|
|
|
// Again, prevent dealing with null values
|
|
if ( _object[ property ] === null ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
_valuesStart[ property ] = _object[ property ];
|
|
_valuesDelta[ property ] = _valuesEnd[ property ] - _object[ property ];
|
|
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
this.stop = function () {
|
|
|
|
TWEEN.remove( this );
|
|
return this;
|
|
|
|
};
|
|
|
|
this.delay = function ( amount ) {
|
|
|
|
_delayTime = amount;
|
|
return this;
|
|
|
|
};
|
|
|
|
this.easing = function ( easing ) {
|
|
|
|
_easingFunction = easing;
|
|
return this;
|
|
|
|
};
|
|
|
|
this.chain = function ( chainedTween ) {
|
|
|
|
_chainedTween = chainedTween;
|
|
|
|
};
|
|
|
|
this.onUpdate = function ( onUpdateCallback ) {
|
|
|
|
_onUpdateCallback = onUpdateCallback;
|
|
return this;
|
|
|
|
};
|
|
|
|
this.onComplete = function ( onCompleteCallback ) {
|
|
|
|
_onCompleteCallback = onCompleteCallback;
|
|
return this;
|
|
|
|
};
|
|
|
|
this.update = function ( time ) {
|
|
|
|
var property, elapsed, value;
|
|
|
|
if ( time < _startTime ) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
elapsed = ( time - _startTime ) / _duration;
|
|
elapsed = elapsed > 1 ? 1 : elapsed;
|
|
|
|
value = _easingFunction( elapsed );
|
|
|
|
for ( property in _valuesDelta ) {
|
|
|
|
_object[ property ] = _valuesStart[ property ] + _valuesDelta[ property ] * value;
|
|
|
|
}
|
|
|
|
if ( _onUpdateCallback !== null ) {
|
|
|
|
_onUpdateCallback.call( _object, value );
|
|
|
|
}
|
|
|
|
if ( elapsed == 1 ) {
|
|
|
|
if ( _onCompleteCallback !== null ) {
|
|
|
|
_onCompleteCallback.call( _object );
|
|
|
|
}
|
|
|
|
if ( _chainedTween !== null ) {
|
|
|
|
_chainedTween.start();
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
/*
|
|
this.destroy = function () {
|
|
|
|
TWEEN.remove( this );
|
|
|
|
};
|
|
*/
|
|
}
|
|
|
|
TWEEN.Easing = { Linear: {}, Quadratic: {}, Cubic: {}, Quartic: {}, Quintic: {}, Sinusoidal: {}, Exponential: {}, Circular: {}, Elastic: {}, Back: {}, Bounce: {} };
|
|
|
|
|
|
TWEEN.Easing.Linear.EaseNone = function ( k ) {
|
|
|
|
return k;
|
|
|
|
};
|
|
|
|
//
|
|
|
|
TWEEN.Easing.Quadratic.EaseIn = function ( k ) {
|
|
|
|
return k * k;
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Quadratic.EaseOut = function ( k ) {
|
|
|
|
return - k * ( k - 2 );
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Quadratic.EaseInOut = function ( k ) {
|
|
|
|
if ( ( k *= 2 ) < 1 ) return 0.5 * k * k;
|
|
return - 0.5 * ( --k * ( k - 2 ) - 1 );
|
|
|
|
};
|
|
|
|
//
|
|
|
|
TWEEN.Easing.Cubic.EaseIn = function ( k ) {
|
|
|
|
return k * k * k;
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Cubic.EaseOut = function ( k ) {
|
|
|
|
return --k * k * k + 1;
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Cubic.EaseInOut = function ( k ) {
|
|
|
|
if ( ( k *= 2 ) < 1 ) return 0.5 * k * k * k;
|
|
return 0.5 * ( ( k -= 2 ) * k * k + 2 );
|
|
|
|
};
|
|
|
|
//
|
|
|
|
TWEEN.Easing.Quartic.EaseIn = function ( k ) {
|
|
|
|
return k * k * k * k;
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Quartic.EaseOut = function ( k ) {
|
|
|
|
return - ( --k * k * k * k - 1 );
|
|
|
|
}
|
|
|
|
TWEEN.Easing.Quartic.EaseInOut = function ( k ) {
|
|
|
|
if ( ( k *= 2 ) < 1) return 0.5 * k * k * k * k;
|
|
return - 0.5 * ( ( k -= 2 ) * k * k * k - 2 );
|
|
|
|
};
|
|
|
|
//
|
|
|
|
TWEEN.Easing.Quintic.EaseIn = function ( k ) {
|
|
|
|
return k * k * k * k * k;
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Quintic.EaseOut = function ( k ) {
|
|
|
|
return ( k = k - 1 ) * k * k * k * k + 1;
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Quintic.EaseInOut = function ( k ) {
|
|
|
|
if ( ( k *= 2 ) < 1 ) return 0.5 * k * k * k * k * k;
|
|
return 0.5 * ( ( k -= 2 ) * k * k * k * k + 2 );
|
|
|
|
};
|
|
|
|
//
|
|
|
|
TWEEN.Easing.Sinusoidal.EaseIn = function ( k ) {
|
|
|
|
return - Math.cos( k * Math.PI / 2 ) + 1;
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Sinusoidal.EaseOut = function ( k ) {
|
|
|
|
return Math.sin( k * Math.PI / 2 );
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Sinusoidal.EaseInOut = function ( k ) {
|
|
|
|
return - 0.5 * ( Math.cos( Math.PI * k ) - 1 );
|
|
|
|
};
|
|
|
|
//
|
|
|
|
TWEEN.Easing.Exponential.EaseIn = function ( k ) {
|
|
|
|
return k == 0 ? 0 : Math.pow( 2, 10 * ( k - 1 ) );
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Exponential.EaseOut = function ( k ) {
|
|
|
|
return k == 1 ? 1 : - Math.pow( 2, - 10 * k ) + 1;
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Exponential.EaseInOut = function ( k ) {
|
|
|
|
if ( k == 0 ) return 0;
|
|
if ( k == 1 ) return 1;
|
|
if ( ( k *= 2 ) < 1 ) return 0.5 * Math.pow( 2, 10 * ( k - 1 ) );
|
|
return 0.5 * ( - Math.pow( 2, - 10 * ( k - 1 ) ) + 2 );
|
|
|
|
};
|
|
|
|
//
|
|
|
|
TWEEN.Easing.Circular.EaseIn = function ( k ) {
|
|
|
|
return - ( Math.sqrt( 1 - k * k ) - 1);
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Circular.EaseOut = function ( k ) {
|
|
|
|
return Math.sqrt( 1 - --k * k );
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Circular.EaseInOut = function ( k ) {
|
|
|
|
if ( ( k /= 0.5 ) < 1) return - 0.5 * ( Math.sqrt( 1 - k * k) - 1);
|
|
return 0.5 * ( Math.sqrt( 1 - ( k -= 2) * k) + 1);
|
|
|
|
};
|
|
|
|
//
|
|
|
|
TWEEN.Easing.Elastic.EaseIn = function( k ) {
|
|
|
|
var s, a = 0.1, p = 0.4;
|
|
if ( k == 0 ) return 0; if ( k == 1 ) return 1; if ( !p ) p = 0.3;
|
|
if ( !a || a < 1 ) { a = 1; s = p / 4; }
|
|
else s = p / ( 2 * Math.PI ) * Math.asin( 1 / a );
|
|
return - ( a * Math.pow( 2, 10 * ( k -= 1 ) ) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) );
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Elastic.EaseOut = function( k ) {
|
|
|
|
var s, a = 0.1, p = 0.4;
|
|
if ( k == 0 ) return 0; if ( k == 1 ) return 1; if ( !p ) p = 0.3;
|
|
if ( !a || a < 1 ) { a = 1; s = p / 4; }
|
|
else s = p / ( 2 * Math.PI ) * Math.asin( 1 / a );
|
|
return ( a * Math.pow( 2, - 10 * k) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) + 1 );
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Elastic.EaseInOut = function( k ) {
|
|
|
|
var s, a = 0.1, p = 0.4;
|
|
if ( k == 0 ) return 0; if ( k == 1 ) return 1; if ( !p ) p = 0.3;
|
|
if ( !a || a < 1 ) { a = 1; s = p / 4; }
|
|
else s = p / ( 2 * Math.PI ) * Math.asin( 1 / a );
|
|
if ( ( k *= 2 ) < 1 ) return - 0.5 * ( a * Math.pow( 2, 10 * ( k -= 1 ) ) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) );
|
|
return a * Math.pow( 2, -10 * ( k -= 1 ) ) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) * 0.5 + 1;
|
|
|
|
};
|
|
|
|
//
|
|
|
|
TWEEN.Easing.Back.EaseIn = function( k ) {
|
|
|
|
var s = 1.70158;
|
|
return k * k * ( ( s + 1 ) * k - s );
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Back.EaseOut = function( k ) {
|
|
|
|
var s = 1.70158;
|
|
return ( k = k - 1 ) * k * ( ( s + 1 ) * k + s ) + 1;
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Back.EaseInOut = function( k ) {
|
|
|
|
var s = 1.70158 * 1.525;
|
|
if ( ( k *= 2 ) < 1 ) return 0.5 * ( k * k * ( ( s + 1 ) * k - s ) );
|
|
return 0.5 * ( ( k -= 2 ) * k * ( ( s + 1 ) * k + s ) + 2 );
|
|
|
|
};
|
|
|
|
//
|
|
|
|
TWEEN.Easing.Bounce.EaseIn = function( k ) {
|
|
|
|
return 1 - TWEEN.Easing.Bounce.EaseOut( 1 - k );
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Bounce.EaseOut = function( k ) {
|
|
|
|
if ( ( k /= 1 ) < ( 1 / 2.75 ) ) {
|
|
|
|
return 7.5625 * k * k;
|
|
|
|
} else if ( k < ( 2 / 2.75 ) ) {
|
|
|
|
return 7.5625 * ( k -= ( 1.5 / 2.75 ) ) * k + 0.75;
|
|
|
|
} else if ( k < ( 2.5 / 2.75 ) ) {
|
|
|
|
return 7.5625 * ( k -= ( 2.25 / 2.75 ) ) * k + 0.9375;
|
|
|
|
} else {
|
|
|
|
return 7.5625 * ( k -= ( 2.625 / 2.75 ) ) * k + 0.984375;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
TWEEN.Easing.Bounce.EaseInOut = function( k ) {
|
|
|
|
if ( k < 0.5 ) return TWEEN.Easing.Bounce.EaseIn( k * 2 ) * 0.5;
|
|
return TWEEN.Easing.Bounce.EaseOut( k * 2 - 1 ) * 0.5 + 0.5;
|
|
|
|
};
|