672 lines
32 KiB
JavaScript
672 lines
32 KiB
JavaScript
/*!
|
|
* VERSION: 2.1.0
|
|
* DATE: 2019-02-15
|
|
* UPDATES AND DOCS AT: http://greensock.com
|
|
*
|
|
* @license Copyright (c) 2008-2019, GreenSock. All rights reserved.
|
|
* This work is subject to the terms at http://greensock.com/standard-license or for
|
|
* Club GreenSock members, the software agreement that was issued with your membership.
|
|
*
|
|
* @author: Jack Doyle, jack@greensock.com
|
|
**/
|
|
/* eslint-disable */
|
|
|
|
import TweenLite, { _gsScope, globals, Animation, SimpleTimeline, Ease, Power0, Power1, Power2, Power3, Power4, Linear } from "./TweenLite.js";
|
|
|
|
|
|
_gsScope._gsDefine("TweenMax", ["core.Animation","core.SimpleTimeline","TweenLite"], function() {
|
|
|
|
var _slice = function(a) { //don't use [].slice because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll()
|
|
var b = [],
|
|
l = a.length,
|
|
i;
|
|
for (i = 0; i !== l; b.push(a[i++]));
|
|
return b;
|
|
},
|
|
_applyCycle = function(vars, targets, i) {
|
|
var alt = vars.cycle,
|
|
p, val;
|
|
for (p in alt) {
|
|
val = alt[p];
|
|
vars[p] = (typeof(val) === "function") ? val(i, targets[i], targets) : val[i % val.length];
|
|
}
|
|
delete vars.cycle;
|
|
},
|
|
//for distributing values across an array. Can accept a number, a function or (most commonly) a function which can contain the following properties: {base, amount, from, ease, grid, axis, length}. Returns a function that expects the following parameters: index, target, array. Recognizes the following
|
|
_distribute = function(v) {
|
|
if (typeof(v) === "function") {
|
|
return v;
|
|
}
|
|
var vars = isNaN(v) ? v : {n:1, from:(v < 0) ? ((v = -v) && "end") : 0}, //n:1 is just to indicate v was a number; we leverage that later to set v according to the length we get. If a number is passed in, we treat it like the old stagger value where 0.1, for example, would mean that things would be distributed with 0.1 between each element in the array rather than a total "amount" that's chunked out among them all.
|
|
ease = vars.ease,
|
|
from = vars.from || 0,
|
|
base = vars.base || 0,
|
|
cache = {},
|
|
isFromKeyword = isNaN(from),
|
|
axis = vars.axis,
|
|
ratio = {center:0.5, end:1}[from] || 0;
|
|
return function(i, target, a) {
|
|
var l = (a || vars).length,
|
|
distances = cache[l],
|
|
originX, originY, x, y, d, j, max, min, wrap;
|
|
if (!distances) {
|
|
wrap = (vars.grid === "auto") ? 0 : (vars.grid || [Infinity])[0];
|
|
if (!wrap) {
|
|
max = -Infinity;
|
|
while (max < (max = a[wrap++].getBoundingClientRect().left) && wrap < l) { }
|
|
wrap--;
|
|
}
|
|
distances = cache[l] = [];
|
|
originX = isFromKeyword ? (Math.min(wrap, l) * ratio) - 0.5 : from % wrap;
|
|
originY = isFromKeyword ? l * ratio / wrap - 0.5 : (from / wrap) | 0;
|
|
max = 0;
|
|
min = Infinity;
|
|
for (j = 0; j < l; j++) {
|
|
x = (j % wrap) - originX;
|
|
y = originY - ((j / wrap) | 0);
|
|
distances[j] = d = !axis ? Math.sqrt(x * x + y * y) : Math.abs((axis === "y") ? y : x);
|
|
if (d > max) {
|
|
max = d;
|
|
}
|
|
if (d < min) {
|
|
min = d;
|
|
}
|
|
}
|
|
distances.max = max - min;
|
|
distances.min = min;
|
|
distances.v = vars.n ? l * (v || 0) : vars.amount;
|
|
}
|
|
l = (distances[i] - distances.min) / distances.max;
|
|
return base + (ease ? ease.getRatio(l) : l) * distances.v;
|
|
};
|
|
},
|
|
TweenMax = function(target, duration, vars) {
|
|
TweenLite.call(this, target, duration, vars);
|
|
this._cycle = 0;
|
|
this._yoyo = (this.vars.yoyo === true || !!this.vars.yoyoEase);
|
|
this._repeat = this.vars.repeat || 0;
|
|
this._repeatDelay = this.vars.repeatDelay || 0;
|
|
if (this._repeat) {
|
|
this._uncache(true); //ensures that if there is any repeat, the totalDuration will get recalculated to accurately report it.
|
|
}
|
|
this.render = TweenMax.prototype.render; //speed optimization (avoid prototype lookup on this "hot" method)
|
|
},
|
|
_tinyNum = 0.00000001,
|
|
TweenLiteInternals = TweenLite._internals,
|
|
_isSelector = TweenLiteInternals.isSelector,
|
|
_isArray = TweenLiteInternals.isArray,
|
|
p = TweenMax.prototype = TweenLite.to({}, 0.1, {}),
|
|
_blankArray = [];
|
|
|
|
TweenMax.version = "2.1.0";
|
|
p.constructor = TweenMax;
|
|
p.kill()._gc = false;
|
|
TweenMax.killTweensOf = TweenMax.killDelayedCallsTo = TweenLite.killTweensOf;
|
|
TweenMax.getTweensOf = TweenLite.getTweensOf;
|
|
TweenMax.lagSmoothing = TweenLite.lagSmoothing;
|
|
TweenMax.ticker = TweenLite.ticker;
|
|
TweenMax.render = TweenLite.render;
|
|
TweenMax.distribute = _distribute;
|
|
|
|
p.invalidate = function() {
|
|
this._yoyo = (this.vars.yoyo === true || !!this.vars.yoyoEase);
|
|
this._repeat = this.vars.repeat || 0;
|
|
this._repeatDelay = this.vars.repeatDelay || 0;
|
|
this._yoyoEase = null;
|
|
this._uncache(true);
|
|
return TweenLite.prototype.invalidate.call(this);
|
|
};
|
|
|
|
p.updateTo = function(vars, resetDuration) {
|
|
var self = this,
|
|
curRatio = self.ratio,
|
|
immediate = self.vars.immediateRender || vars.immediateRender,
|
|
p;
|
|
if (resetDuration && self._startTime < self._timeline._time) {
|
|
self._startTime = self._timeline._time;
|
|
self._uncache(false);
|
|
if (self._gc) {
|
|
self._enabled(true, false);
|
|
} else {
|
|
self._timeline.insert(self, self._startTime - self._delay); //ensures that any necessary re-sequencing of Animations in the timeline occurs to make sure the rendering order is correct.
|
|
}
|
|
}
|
|
for (p in vars) {
|
|
self.vars[p] = vars[p];
|
|
}
|
|
if (self._initted || immediate) {
|
|
if (resetDuration) {
|
|
self._initted = false;
|
|
if (immediate) {
|
|
self.render(0, true, true);
|
|
}
|
|
} else {
|
|
if (self._gc) {
|
|
self._enabled(true, false);
|
|
}
|
|
if (self._notifyPluginsOfEnabled && self._firstPT) {
|
|
TweenLite._onPluginEvent("_onDisable", self); //in case a plugin like MotionBlur must perform some cleanup tasks
|
|
}
|
|
if (self._time / self._duration > 0.998) { //if the tween has finished (or come extremely close to finishing), we just need to rewind it to 0 and then render it again at the end which forces it to re-initialize (parsing the new vars). We allow tweens that are close to finishing (but haven't quite finished) to work this way too because otherwise, the values are so small when determining where to project the starting values that binary math issues creep in and can make the tween appear to render incorrectly when run backwards.
|
|
var prevTime = self._totalTime;
|
|
self.render(0, true, false);
|
|
self._initted = false;
|
|
self.render(prevTime, true, false);
|
|
} else {
|
|
self._initted = false;
|
|
self._init();
|
|
if (self._time > 0 || immediate) {
|
|
var inv = 1 / (1 - curRatio),
|
|
pt = self._firstPT, endValue;
|
|
while (pt) {
|
|
endValue = pt.s + pt.c;
|
|
pt.c *= inv;
|
|
pt.s = endValue - pt.c;
|
|
pt = pt._next;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return self;
|
|
};
|
|
|
|
p.render = function(time, suppressEvents, force) {
|
|
if (!this._initted) if (this._duration === 0 && this.vars.repeat) { //zero duration tweens that render immediately have render() called from TweenLite's constructor, before TweenMax's constructor has finished setting _repeat, _repeatDelay, and _yoyo which are critical in determining totalDuration() so we need to call invalidate() which is a low-kb way to get those set properly.
|
|
this.invalidate();
|
|
}
|
|
var self = this,
|
|
totalDur = (!self._dirty) ? self._totalDuration : self.totalDuration(),
|
|
prevTime = self._time,
|
|
prevTotalTime = self._totalTime,
|
|
prevCycle = self._cycle,
|
|
duration = self._duration,
|
|
prevRawPrevTime = self._rawPrevTime,
|
|
isComplete, callback, pt, cycleDuration, r, type, pow, rawPrevTime, yoyoEase;
|
|
if (time >= totalDur - _tinyNum && time >= 0) { //to work around occasional floating point math artifacts.
|
|
self._totalTime = totalDur;
|
|
self._cycle = self._repeat;
|
|
if (self._yoyo && (self._cycle & 1) !== 0) {
|
|
self._time = 0;
|
|
self.ratio = self._ease._calcEnd ? self._ease.getRatio(0) : 0;
|
|
} else {
|
|
self._time = duration;
|
|
self.ratio = self._ease._calcEnd ? self._ease.getRatio(1) : 1;
|
|
}
|
|
if (!self._reversed) {
|
|
isComplete = true;
|
|
callback = "onComplete";
|
|
force = (force || self._timeline.autoRemoveChildren); //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline.
|
|
}
|
|
if (duration === 0) if (self._initted || !self.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered.
|
|
if (self._startTime === self._timeline._duration) { //if a zero-duration tween is at the VERY end of a timeline and that timeline renders at its end, it will typically add a tiny bit of cushion to the render time to prevent rounding errors from getting in the way of tweens rendering their VERY end. If we then reverse() that timeline, the zero-duration tween will trigger its onReverseComplete even though technically the playhead didn't pass over it again. It's a very specific edge case we must accommodate.
|
|
time = 0;
|
|
}
|
|
if (prevRawPrevTime < 0 || (time <= 0 && time >= -_tinyNum) || (prevRawPrevTime === _tinyNum && self.data !== "isPause")) if (prevRawPrevTime !== time) { //note: when this.data is "isPause", it's a callback added by addPause() on a timeline that we should not be triggered when LEAVING its exact start time. In other words, tl.addPause(1).play(1) shouldn't pause.
|
|
force = true;
|
|
if (prevRawPrevTime > _tinyNum) {
|
|
callback = "onReverseComplete";
|
|
}
|
|
}
|
|
self._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient.
|
|
}
|
|
|
|
} else if (time < _tinyNum) { //to work around occasional floating point math artifacts, round super small values to 0.
|
|
self._totalTime = self._time = self._cycle = 0;
|
|
self.ratio = self._ease._calcEnd ? self._ease.getRatio(0) : 0;
|
|
if (prevTotalTime !== 0 || (duration === 0 && prevRawPrevTime > 0)) {
|
|
callback = "onReverseComplete";
|
|
isComplete = self._reversed;
|
|
}
|
|
if (time > -_tinyNum) {
|
|
time = 0;
|
|
} else if (time < 0) {
|
|
self._active = false;
|
|
if (duration === 0) if (self._initted || !self.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered.
|
|
if (prevRawPrevTime >= 0) {
|
|
force = true;
|
|
}
|
|
self._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient.
|
|
}
|
|
}
|
|
if (!self._initted) { //if we render the very beginning (time == 0) of a fromTo(), we must force the render (normal tweens wouldn't need to render at a time of 0 when the prevTime was also 0). This is also mandatory to make sure overwriting kicks in immediately.
|
|
force = true;
|
|
}
|
|
} else {
|
|
self._totalTime = self._time = time;
|
|
if (self._repeat !== 0) {
|
|
cycleDuration = duration + self._repeatDelay;
|
|
self._cycle = (self._totalTime / cycleDuration) >> 0; //originally _totalTime % cycleDuration but floating point errors caused problems, so I normalized it. (4 % 0.8 should be 0 but some browsers report it as 0.79999999!)
|
|
if (self._cycle !== 0) if (self._cycle === self._totalTime / cycleDuration && prevTotalTime <= time) {
|
|
self._cycle--; //otherwise when rendered exactly at the end time, it will act as though it is repeating (at the beginning)
|
|
}
|
|
self._time = self._totalTime - (self._cycle * cycleDuration);
|
|
if (self._yoyo) if ((self._cycle & 1) !== 0) {
|
|
self._time = duration - self._time;
|
|
yoyoEase = self._yoyoEase || self.vars.yoyoEase; //note: we don't set this._yoyoEase in _init() like we do other properties because it's TweenMax-specific and doing it here allows us to optimize performance (most tweens don't have a yoyoEase). Note that we also must skip the this.ratio calculation further down right after we _init() in this function, because we're doing it here.
|
|
if (yoyoEase) {
|
|
if (!self._yoyoEase) {
|
|
if (yoyoEase === true && !self._initted) { //if it's not initted and yoyoEase is true, this._ease won't have been populated yet so we must discern it here.
|
|
yoyoEase = self.vars.ease;
|
|
self._yoyoEase = yoyoEase = !yoyoEase ? TweenLite.defaultEase : (yoyoEase instanceof Ease) ? yoyoEase : (typeof(yoyoEase) === "function") ? new Ease(yoyoEase, self.vars.easeParams) : Ease.map[yoyoEase] || TweenLite.defaultEase;
|
|
} else {
|
|
self._yoyoEase = yoyoEase = (yoyoEase === true) ? self._ease : (yoyoEase instanceof Ease) ? yoyoEase : Ease.map[yoyoEase];
|
|
}
|
|
}
|
|
self.ratio = yoyoEase ? 1 - yoyoEase.getRatio((duration - self._time) / duration) : 0;
|
|
}
|
|
}
|
|
if (self._time > duration) {
|
|
self._time = duration;
|
|
} else if (self._time < 0) {
|
|
self._time = 0;
|
|
}
|
|
}
|
|
if (self._easeType && !yoyoEase) {
|
|
r = self._time / duration;
|
|
type = self._easeType;
|
|
pow = self._easePower;
|
|
if (type === 1 || (type === 3 && r >= 0.5)) {
|
|
r = 1 - r;
|
|
}
|
|
if (type === 3) {
|
|
r *= 2;
|
|
}
|
|
if (pow === 1) {
|
|
r *= r;
|
|
} else if (pow === 2) {
|
|
r *= r * r;
|
|
} else if (pow === 3) {
|
|
r *= r * r * r;
|
|
} else if (pow === 4) {
|
|
r *= r * r * r * r;
|
|
}
|
|
self.ratio = (type === 1) ? 1 - r : (type === 2) ? r : (self._time / duration < 0.5) ? r / 2 : 1 - (r / 2);
|
|
|
|
} else if (!yoyoEase) {
|
|
self.ratio = self._ease.getRatio(self._time / duration);
|
|
}
|
|
|
|
}
|
|
|
|
if (prevTime === self._time && !force && prevCycle === self._cycle) {
|
|
if (prevTotalTime !== self._totalTime) if (self._onUpdate) if (!suppressEvents) { //so that onUpdate fires even during the repeatDelay - as long as the totalTime changed, we should trigger onUpdate.
|
|
self._callback("onUpdate");
|
|
}
|
|
return;
|
|
} else if (!self._initted) {
|
|
self._init();
|
|
if (!self._initted || self._gc) { //immediateRender tweens typically won't initialize until the playhead advances (_time is greater than 0) in order to ensure that overwriting occurs properly. Also, if all of the tweening properties have been overwritten (which would cause _gc to be true, as set in _init()), we shouldn't continue otherwise an onStart callback could be called for example.
|
|
return;
|
|
} else if (!force && self._firstPT && ((self.vars.lazy !== false && self._duration) || (self.vars.lazy && !self._duration))) { //we stick it in the queue for rendering at the very end of the tick - this is a performance optimization because browsers invalidate styles and force a recalculation if you read, write, and then read style data (so it's better to read/read/read/write/write/write than read/write/read/write/read/write). The down side, of course, is that usually you WANT things to render immediately because you may have code running right after that which depends on the change. Like imagine running TweenLite.set(...) and then immediately after that, creating a nother tween that animates the same property to another value; the starting values of that 2nd tween wouldn't be accurate if lazy is true.
|
|
self._time = prevTime;
|
|
self._totalTime = prevTotalTime;
|
|
self._rawPrevTime = prevRawPrevTime;
|
|
self._cycle = prevCycle;
|
|
TweenLiteInternals.lazyTweens.push(self);
|
|
self._lazy = [time, suppressEvents];
|
|
return;
|
|
}
|
|
//_ease is initially set to defaultEase, so now that init() has run, _ease is set properly and we need to recalculate the ratio. Overall this is faster than using conditional logic earlier in the method to avoid having to set ratio twice because we only init() once but renderTime() gets called VERY frequently.
|
|
if (self._time && !isComplete && !yoyoEase) {
|
|
self.ratio = self._ease.getRatio(self._time / duration);
|
|
} else if (isComplete && this._ease._calcEnd && !yoyoEase) {
|
|
self.ratio = self._ease.getRatio((self._time === 0) ? 0 : 1);
|
|
}
|
|
}
|
|
if (self._lazy !== false) {
|
|
self._lazy = false;
|
|
}
|
|
|
|
if (!self._active) if (!self._paused && self._time !== prevTime && time >= 0) {
|
|
self._active = true; //so that if the user renders a tween (as opposed to the timeline rendering it), the timeline is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the tween already finished but the user manually re-renders it as halfway done.
|
|
}
|
|
if (prevTotalTime === 0) {
|
|
if (self._initted === 2 && time > 0) {
|
|
self._init(); //will just apply overwriting since _initted of (2) means it was a from() tween that had immediateRender:true
|
|
}
|
|
if (self._startAt) {
|
|
if (time >= 0) {
|
|
self._startAt.render(time, true, force);
|
|
} else if (!callback) {
|
|
callback = "_dummyGS"; //if no callback is defined, use a dummy value just so that the condition at the end evaluates as true because _startAt should render AFTER the normal render loop when the time is negative. We could handle this in a more intuitive way, of course, but the render loop is the MOST important thing to optimize, so this technique allows us to avoid adding extra conditional logic in a high-frequency area.
|
|
}
|
|
}
|
|
if (self.vars.onStart) if (self._totalTime !== 0 || duration === 0) if (!suppressEvents) {
|
|
self._callback("onStart");
|
|
}
|
|
}
|
|
|
|
pt = self._firstPT;
|
|
while (pt) {
|
|
if (pt.f) {
|
|
pt.t[pt.p](pt.c * self.ratio + pt.s);
|
|
} else {
|
|
pt.t[pt.p] = pt.c * self.ratio + pt.s;
|
|
}
|
|
pt = pt._next;
|
|
}
|
|
|
|
if (self._onUpdate) {
|
|
if (time < 0) if (self._startAt && self._startTime) { //if the tween is positioned at the VERY beginning (_startTime 0) of its parent timeline, it's illegal for the playhead to go back further, so we should not render the recorded startAt values.
|
|
self._startAt.render(time, true, force); //note: for performance reasons, we tuck this conditional logic inside less traveled areas (most tweens don't have an onUpdate). We'd just have it at the end before the onComplete, but the values should be updated before any onUpdate is called, so we ALSO put it here and then if it's not called, we do so later near the onComplete.
|
|
}
|
|
if (!suppressEvents) if (self._totalTime !== prevTotalTime || callback) {
|
|
self._callback("onUpdate");
|
|
}
|
|
}
|
|
if (self._cycle !== prevCycle) if (!suppressEvents) if (!self._gc) if (self.vars.onRepeat) {
|
|
self._callback("onRepeat");
|
|
}
|
|
if (callback) if (!self._gc || force) { //check gc because there's a chance that kill() could be called in an onUpdate
|
|
if (time < 0 && self._startAt && !self._onUpdate && self._startTime) { //if the tween is positioned at the VERY beginning (_startTime 0) of its parent timeline, it's illegal for the playhead to go back further, so we should not render the recorded startAt values.
|
|
self._startAt.render(time, true, force);
|
|
}
|
|
if (isComplete) {
|
|
if (self._timeline.autoRemoveChildren) {
|
|
self._enabled(false, false);
|
|
}
|
|
self._active = false;
|
|
}
|
|
if (!suppressEvents && self.vars[callback]) {
|
|
self._callback(callback);
|
|
}
|
|
if (duration === 0 && self._rawPrevTime === _tinyNum && rawPrevTime !== _tinyNum) { //the onComplete or onReverseComplete could trigger movement of the playhead and for zero-duration tweens (which must discern direction) that land directly back on their start time, we don't want to fire again on the next render. Think of several addPause()'s in a timeline that forces the playhead to a certain spot, but what if it's already paused and another tween is tweening the "time" of the timeline? Each time it moves [forward] past that spot, it would move back, and since suppressEvents is true, it'd reset _rawPrevTime to _tinyNum so that when it begins again, the callback would fire (so ultimately it could bounce back and forth during that tween). Again, this is a very uncommon scenario, but possible nonetheless.
|
|
self._rawPrevTime = 0;
|
|
}
|
|
}
|
|
};
|
|
|
|
//---- STATIC FUNCTIONS -----------------------------------------------------------------------------------------------------------
|
|
|
|
TweenMax.to = function(target, duration, vars) {
|
|
return new TweenMax(target, duration, vars);
|
|
};
|
|
|
|
TweenMax.from = function(target, duration, vars) {
|
|
vars.runBackwards = true;
|
|
vars.immediateRender = (vars.immediateRender != false);
|
|
return new TweenMax(target, duration, vars);
|
|
};
|
|
|
|
TweenMax.fromTo = function(target, duration, fromVars, toVars) {
|
|
toVars.startAt = fromVars;
|
|
toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false);
|
|
return new TweenMax(target, duration, toVars);
|
|
};
|
|
|
|
TweenMax.staggerTo = TweenMax.allTo = function(targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) {
|
|
var a = [],
|
|
staggerFunc = _distribute(vars.stagger || stagger),
|
|
cycle = vars.cycle,
|
|
fromCycle = (vars.startAt || _blankArray).cycle,
|
|
l, copy, i, p;
|
|
if (!_isArray(targets)) {
|
|
if (typeof(targets) === "string") {
|
|
targets = TweenLite.selector(targets) || targets;
|
|
}
|
|
if (_isSelector(targets)) {
|
|
targets = _slice(targets);
|
|
}
|
|
}
|
|
targets = targets || [];
|
|
l = targets.length - 1;
|
|
for (i = 0; i <= l; i++) {
|
|
copy = {};
|
|
for (p in vars) {
|
|
copy[p] = vars[p];
|
|
}
|
|
if (cycle) {
|
|
_applyCycle(copy, targets, i);
|
|
if (copy.duration != null) {
|
|
duration = copy.duration;
|
|
delete copy.duration;
|
|
}
|
|
}
|
|
if (fromCycle) {
|
|
fromCycle = copy.startAt = {};
|
|
for (p in vars.startAt) {
|
|
fromCycle[p] = vars.startAt[p];
|
|
}
|
|
_applyCycle(copy.startAt, targets, i);
|
|
}
|
|
copy.delay = staggerFunc(i, targets[i], targets) + (copy.delay || 0);
|
|
if (i === l && onCompleteAll) {
|
|
copy.onComplete = function() {
|
|
if (vars.onComplete) {
|
|
vars.onComplete.apply(vars.onCompleteScope || this, arguments);
|
|
}
|
|
onCompleteAll.apply(onCompleteAllScope || vars.callbackScope || this, onCompleteAllParams || _blankArray);
|
|
};
|
|
}
|
|
a[i] = new TweenMax(targets[i], duration, copy);
|
|
}
|
|
return a;
|
|
};
|
|
|
|
TweenMax.staggerFrom = TweenMax.allFrom = function(targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) {
|
|
vars.runBackwards = true;
|
|
vars.immediateRender = (vars.immediateRender != false);
|
|
return TweenMax.staggerTo(targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope);
|
|
};
|
|
|
|
TweenMax.staggerFromTo = TweenMax.allFromTo = function(targets, duration, fromVars, toVars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) {
|
|
toVars.startAt = fromVars;
|
|
toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false);
|
|
return TweenMax.staggerTo(targets, duration, toVars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope);
|
|
};
|
|
|
|
TweenMax.delayedCall = function(delay, callback, params, scope, useFrames) {
|
|
return new TweenMax(callback, 0, {delay:delay, onComplete:callback, onCompleteParams:params, callbackScope:scope, onReverseComplete:callback, onReverseCompleteParams:params, immediateRender:false, useFrames:useFrames, overwrite:0});
|
|
};
|
|
|
|
TweenMax.set = function(target, vars) {
|
|
return new TweenMax(target, 0, vars);
|
|
};
|
|
|
|
TweenMax.isTweening = function(target) {
|
|
return (TweenLite.getTweensOf(target, true).length > 0);
|
|
};
|
|
|
|
var _getChildrenOf = function(timeline, includeTimelines) {
|
|
var a = [],
|
|
cnt = 0,
|
|
tween = timeline._first;
|
|
while (tween) {
|
|
if (tween instanceof TweenLite) {
|
|
a[cnt++] = tween;
|
|
} else {
|
|
if (includeTimelines) {
|
|
a[cnt++] = tween;
|
|
}
|
|
a = a.concat(_getChildrenOf(tween, includeTimelines));
|
|
cnt = a.length;
|
|
}
|
|
tween = tween._next;
|
|
}
|
|
return a;
|
|
},
|
|
getAllTweens = TweenMax.getAllTweens = function(includeTimelines) {
|
|
return _getChildrenOf(Animation._rootTimeline, includeTimelines).concat( _getChildrenOf(Animation._rootFramesTimeline, includeTimelines) );
|
|
};
|
|
|
|
TweenMax.killAll = function(complete, tweens, delayedCalls, timelines) {
|
|
if (tweens == null) {
|
|
tweens = true;
|
|
}
|
|
if (delayedCalls == null) {
|
|
delayedCalls = true;
|
|
}
|
|
var a = getAllTweens((timelines != false)),
|
|
l = a.length,
|
|
allTrue = (tweens && delayedCalls && timelines),
|
|
isDC, tween, i;
|
|
for (i = 0; i < l; i++) {
|
|
tween = a[i];
|
|
if (allTrue || (tween instanceof SimpleTimeline) || ((isDC = (tween.target === tween.vars.onComplete)) && delayedCalls) || (tweens && !isDC)) {
|
|
if (complete) {
|
|
tween.totalTime(tween._reversed ? 0 : tween.totalDuration());
|
|
} else {
|
|
tween._enabled(false, false);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
TweenMax.killChildTweensOf = function(parent, complete) {
|
|
if (parent == null) {
|
|
return;
|
|
}
|
|
var tl = TweenLiteInternals.tweenLookup,
|
|
a, curParent, p, i, l;
|
|
if (typeof(parent) === "string") {
|
|
parent = TweenLite.selector(parent) || parent;
|
|
}
|
|
if (_isSelector(parent)) {
|
|
parent = _slice(parent);
|
|
}
|
|
if (_isArray(parent)) {
|
|
i = parent.length;
|
|
while (--i > -1) {
|
|
TweenMax.killChildTweensOf(parent[i], complete);
|
|
}
|
|
return;
|
|
}
|
|
a = [];
|
|
for (p in tl) {
|
|
curParent = tl[p].target.parentNode;
|
|
while (curParent) {
|
|
if (curParent === parent) {
|
|
a = a.concat(tl[p].tweens);
|
|
}
|
|
curParent = curParent.parentNode;
|
|
}
|
|
}
|
|
l = a.length;
|
|
for (i = 0; i < l; i++) {
|
|
if (complete) {
|
|
a[i].totalTime(a[i].totalDuration());
|
|
}
|
|
a[i]._enabled(false, false);
|
|
}
|
|
};
|
|
|
|
var _changePause = function(pause, tweens, delayedCalls, timelines) {
|
|
tweens = (tweens !== false);
|
|
delayedCalls = (delayedCalls !== false);
|
|
timelines = (timelines !== false);
|
|
var a = getAllTweens(timelines),
|
|
allTrue = (tweens && delayedCalls && timelines),
|
|
i = a.length,
|
|
isDC, tween;
|
|
while (--i > -1) {
|
|
tween = a[i];
|
|
if (allTrue || (tween instanceof SimpleTimeline) || ((isDC = (tween.target === tween.vars.onComplete)) && delayedCalls) || (tweens && !isDC)) {
|
|
tween.paused(pause);
|
|
}
|
|
}
|
|
};
|
|
|
|
TweenMax.pauseAll = function(tweens, delayedCalls, timelines) {
|
|
_changePause(true, tweens, delayedCalls, timelines);
|
|
};
|
|
|
|
TweenMax.resumeAll = function(tweens, delayedCalls, timelines) {
|
|
_changePause(false, tweens, delayedCalls, timelines);
|
|
};
|
|
|
|
TweenMax.globalTimeScale = function(value) {
|
|
var tl = Animation._rootTimeline,
|
|
t = TweenLite.ticker.time;
|
|
if (!arguments.length) {
|
|
return tl._timeScale;
|
|
}
|
|
value = value || _tinyNum; //can't allow zero because it'll throw the math off
|
|
tl._startTime = t - ((t - tl._startTime) * tl._timeScale / value);
|
|
tl = Animation._rootFramesTimeline;
|
|
t = TweenLite.ticker.frame;
|
|
tl._startTime = t - ((t - tl._startTime) * tl._timeScale / value);
|
|
tl._timeScale = Animation._rootTimeline._timeScale = value;
|
|
return value;
|
|
};
|
|
|
|
|
|
//---- GETTERS / SETTERS ----------------------------------------------------------------------------------------------------------
|
|
|
|
p.progress = function(value, suppressEvents) {
|
|
return (!arguments.length) ? this._time / this.duration() : this.totalTime( this.duration() * ((this._yoyo && (this._cycle & 1) !== 0) ? 1 - value : value) + (this._cycle * (this._duration + this._repeatDelay)), suppressEvents);
|
|
};
|
|
|
|
p.totalProgress = function(value, suppressEvents) {
|
|
return (!arguments.length) ? this._totalTime / this.totalDuration() : this.totalTime( this.totalDuration() * value, suppressEvents);
|
|
};
|
|
|
|
p.time = function(value, suppressEvents) {
|
|
if (!arguments.length) {
|
|
return this._time;
|
|
}
|
|
if (this._dirty) {
|
|
this.totalDuration();
|
|
}
|
|
var duration = this._duration,
|
|
cycle = this._cycle,
|
|
cycleDur = cycle * (duration * this._repeatDelay);
|
|
if (value > duration) {
|
|
value = duration;
|
|
}
|
|
return this.totalTime((this._yoyo && (cycle & 1)) ? duration - value + cycleDur : this._repeat ? value + cycleDur : value, suppressEvents);
|
|
};
|
|
|
|
p.duration = function(value) {
|
|
if (!arguments.length) {
|
|
return this._duration; //don't set _dirty = false because there could be repeats that haven't been factored into the _totalDuration yet. Otherwise, if you create a repeated TweenMax and then immediately check its duration(), it would cache the value and the totalDuration would not be correct, thus repeats wouldn't take effect.
|
|
}
|
|
return Animation.prototype.duration.call(this, value);
|
|
};
|
|
|
|
p.totalDuration = function(value) {
|
|
if (!arguments.length) {
|
|
if (this._dirty) {
|
|
//instead of Infinity, we use 999999999999 so that we can accommodate reverses
|
|
this._totalDuration = (this._repeat === -1) ? 999999999999 : this._duration * (this._repeat + 1) + (this._repeatDelay * this._repeat);
|
|
this._dirty = false;
|
|
}
|
|
return this._totalDuration;
|
|
}
|
|
return (this._repeat === -1) ? this : this.duration( (value - (this._repeat * this._repeatDelay)) / (this._repeat + 1) );
|
|
};
|
|
|
|
p.repeat = function(value) {
|
|
if (!arguments.length) {
|
|
return this._repeat;
|
|
}
|
|
this._repeat = value;
|
|
return this._uncache(true);
|
|
};
|
|
|
|
p.repeatDelay = function(value) {
|
|
if (!arguments.length) {
|
|
return this._repeatDelay;
|
|
}
|
|
this._repeatDelay = value;
|
|
return this._uncache(true);
|
|
};
|
|
|
|
p.yoyo = function(value) {
|
|
if (!arguments.length) {
|
|
return this._yoyo;
|
|
}
|
|
this._yoyo = value;
|
|
return this;
|
|
};
|
|
|
|
|
|
return TweenMax;
|
|
|
|
}, true);
|
|
|
|
export var TweenMax = globals.TweenMax;
|
|
export var TweenMaxBase = TweenMax;
|
|
export { TweenMax as default };
|
|
export { TweenLite, Ease, Power0, Power1, Power2, Power3, Power4, Linear };
|