381 lines
11 KiB
JavaScript
Executable File
381 lines
11 KiB
JavaScript
Executable File
/*!
|
|
* VERSION: 1.16.0
|
|
* DATE: 2018-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 */
|
|
var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node
|
|
(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() {
|
|
|
|
"use strict";
|
|
|
|
_gsScope._gsDefine("easing.Back", ["easing.Ease"], function(Ease) {
|
|
|
|
var w = (_gsScope.GreenSockGlobals || _gsScope),
|
|
gs = w.com.greensock,
|
|
_2PI = Math.PI * 2,
|
|
_HALF_PI = Math.PI / 2,
|
|
_class = gs._class,
|
|
_create = function(n, f) {
|
|
var C = _class("easing." + n, function(){}, true),
|
|
p = C.prototype = new Ease();
|
|
p.constructor = C;
|
|
p.getRatio = f;
|
|
return C;
|
|
},
|
|
_easeReg = Ease.register || function(){}, //put an empty function in place just as a safety measure in case someone loads an OLD version of TweenLite.js where Ease.register doesn't exist.
|
|
_wrap = function(name, EaseOut, EaseIn, EaseInOut, aliases) {
|
|
var C = _class("easing."+name, {
|
|
easeOut:new EaseOut(),
|
|
easeIn:new EaseIn(),
|
|
easeInOut:new EaseInOut()
|
|
}, true);
|
|
_easeReg(C, name);
|
|
return C;
|
|
},
|
|
EasePoint = function(time, value, next) {
|
|
this.t = time;
|
|
this.v = value;
|
|
if (next) {
|
|
this.next = next;
|
|
next.prev = this;
|
|
this.c = next.v - value;
|
|
this.gap = next.t - time;
|
|
}
|
|
},
|
|
|
|
//Back
|
|
_createBack = function(n, f) {
|
|
var C = _class("easing." + n, function(overshoot) {
|
|
this._p1 = (overshoot || overshoot === 0) ? overshoot : 1.70158;
|
|
this._p2 = this._p1 * 1.525;
|
|
}, true),
|
|
p = C.prototype = new Ease();
|
|
p.constructor = C;
|
|
p.getRatio = f;
|
|
p.config = function(overshoot) {
|
|
return new C(overshoot);
|
|
};
|
|
return C;
|
|
},
|
|
|
|
Back = _wrap("Back",
|
|
_createBack("BackOut", function(p) {
|
|
return ((p = p - 1) * p * ((this._p1 + 1) * p + this._p1) + 1);
|
|
}),
|
|
_createBack("BackIn", function(p) {
|
|
return p * p * ((this._p1 + 1) * p - this._p1);
|
|
}),
|
|
_createBack("BackInOut", function(p) {
|
|
return ((p *= 2) < 1) ? 0.5 * p * p * ((this._p2 + 1) * p - this._p2) : 0.5 * ((p -= 2) * p * ((this._p2 + 1) * p + this._p2) + 2);
|
|
})
|
|
),
|
|
|
|
|
|
//SlowMo
|
|
SlowMo = _class("easing.SlowMo", function(linearRatio, power, yoyoMode) {
|
|
power = (power || power === 0) ? power : 0.7;
|
|
if (linearRatio == null) {
|
|
linearRatio = 0.7;
|
|
} else if (linearRatio > 1) {
|
|
linearRatio = 1;
|
|
}
|
|
this._p = (linearRatio !== 1) ? power : 0;
|
|
this._p1 = (1 - linearRatio) / 2;
|
|
this._p2 = linearRatio;
|
|
this._p3 = this._p1 + this._p2;
|
|
this._calcEnd = (yoyoMode === true);
|
|
}, true),
|
|
p = SlowMo.prototype = new Ease(),
|
|
SteppedEase, ExpoScaleEase, RoughEase, _createElastic;
|
|
|
|
p.constructor = SlowMo;
|
|
p.getRatio = function(p) {
|
|
var r = p + (0.5 - p) * this._p;
|
|
if (p < this._p1) {
|
|
return this._calcEnd ? 1 - ((p = 1 - (p / this._p1)) * p) : r - ((p = 1 - (p / this._p1)) * p * p * p * r);
|
|
} else if (p > this._p3) {
|
|
return this._calcEnd ? (p === 1 ? 0 : 1 - (p = (p - this._p3) / this._p1) * p) : r + ((p - r) * (p = (p - this._p3) / this._p1) * p * p * p); //added p === 1 ? 0 to avoid floating point rounding errors from affecting the final value, like 1 - 0.7 = 0.30000000000000004 instead of 0.3
|
|
}
|
|
return this._calcEnd ? 1 : r;
|
|
};
|
|
SlowMo.ease = new SlowMo(0.7, 0.7);
|
|
|
|
p.config = SlowMo.config = function(linearRatio, power, yoyoMode) {
|
|
return new SlowMo(linearRatio, power, yoyoMode);
|
|
};
|
|
|
|
|
|
//SteppedEase
|
|
SteppedEase = _class("easing.SteppedEase", function(steps, immediateStart) {
|
|
steps = steps || 1;
|
|
this._p1 = 1 / steps;
|
|
this._p2 = steps + (immediateStart ? 0 : 1);
|
|
this._p3 = immediateStart ? 1 : 0;
|
|
}, true);
|
|
p = SteppedEase.prototype = new Ease();
|
|
p.constructor = SteppedEase;
|
|
p.getRatio = function(p) {
|
|
if (p < 0) {
|
|
p = 0;
|
|
} else if (p >= 1) {
|
|
p = 0.999999999;
|
|
}
|
|
return (((this._p2 * p) | 0) + this._p3) * this._p1;
|
|
};
|
|
p.config = SteppedEase.config = function(steps, immediateStart) {
|
|
return new SteppedEase(steps, immediateStart);
|
|
};
|
|
|
|
|
|
//ExpoScaleEase
|
|
ExpoScaleEase = _class("easing.ExpoScaleEase", function(start, end, ease) {
|
|
this._p1 = Math.log(end / start);
|
|
this._p2 = end - start;
|
|
this._p3 = start;
|
|
this._ease = ease;
|
|
}, true);
|
|
p = ExpoScaleEase.prototype = new Ease();
|
|
p.constructor = ExpoScaleEase;
|
|
p.getRatio = function(p) {
|
|
if (this._ease) {
|
|
p = this._ease.getRatio(p);
|
|
}
|
|
return (this._p3 * Math.exp(this._p1 * p) - this._p3) / this._p2;
|
|
};
|
|
p.config = ExpoScaleEase.config = function(start, end, ease) {
|
|
return new ExpoScaleEase(start, end, ease);
|
|
};
|
|
|
|
|
|
//RoughEase
|
|
RoughEase = _class("easing.RoughEase", function(vars) {
|
|
vars = vars || {};
|
|
var taper = vars.taper || "none",
|
|
a = [],
|
|
cnt = 0,
|
|
points = (vars.points || 20) | 0,
|
|
i = points,
|
|
randomize = (vars.randomize !== false),
|
|
clamp = (vars.clamp === true),
|
|
template = (vars.template instanceof Ease) ? vars.template : null,
|
|
strength = (typeof(vars.strength) === "number") ? vars.strength * 0.4 : 0.4,
|
|
x, y, bump, invX, obj, pnt;
|
|
while (--i > -1) {
|
|
x = randomize ? Math.random() : (1 / points) * i;
|
|
y = template ? template.getRatio(x) : x;
|
|
if (taper === "none") {
|
|
bump = strength;
|
|
} else if (taper === "out") {
|
|
invX = 1 - x;
|
|
bump = invX * invX * strength;
|
|
} else if (taper === "in") {
|
|
bump = x * x * strength;
|
|
} else if (x < 0.5) { //"both" (start)
|
|
invX = x * 2;
|
|
bump = invX * invX * 0.5 * strength;
|
|
} else { //"both" (end)
|
|
invX = (1 - x) * 2;
|
|
bump = invX * invX * 0.5 * strength;
|
|
}
|
|
if (randomize) {
|
|
y += (Math.random() * bump) - (bump * 0.5);
|
|
} else if (i % 2) {
|
|
y += bump * 0.5;
|
|
} else {
|
|
y -= bump * 0.5;
|
|
}
|
|
if (clamp) {
|
|
if (y > 1) {
|
|
y = 1;
|
|
} else if (y < 0) {
|
|
y = 0;
|
|
}
|
|
}
|
|
a[cnt++] = {x:x, y:y};
|
|
}
|
|
a.sort(function(a, b) {
|
|
return a.x - b.x;
|
|
});
|
|
|
|
pnt = new EasePoint(1, 1, null);
|
|
i = points;
|
|
while (--i > -1) {
|
|
obj = a[i];
|
|
pnt = new EasePoint(obj.x, obj.y, pnt);
|
|
}
|
|
|
|
this._prev = new EasePoint(0, 0, (pnt.t !== 0) ? pnt : pnt.next);
|
|
}, true);
|
|
p = RoughEase.prototype = new Ease();
|
|
p.constructor = RoughEase;
|
|
p.getRatio = function(p) {
|
|
var pnt = this._prev;
|
|
if (p > pnt.t) {
|
|
while (pnt.next && p >= pnt.t) {
|
|
pnt = pnt.next;
|
|
}
|
|
pnt = pnt.prev;
|
|
} else {
|
|
while (pnt.prev && p <= pnt.t) {
|
|
pnt = pnt.prev;
|
|
}
|
|
}
|
|
this._prev = pnt;
|
|
return (pnt.v + ((p - pnt.t) / pnt.gap) * pnt.c);
|
|
};
|
|
p.config = function(vars) {
|
|
return new RoughEase(vars);
|
|
};
|
|
RoughEase.ease = new RoughEase();
|
|
|
|
|
|
//Bounce
|
|
_wrap("Bounce",
|
|
_create("BounceOut", function(p) {
|
|
if (p < 1 / 2.75) {
|
|
return 7.5625 * p * p;
|
|
} else if (p < 2 / 2.75) {
|
|
return 7.5625 * (p -= 1.5 / 2.75) * p + 0.75;
|
|
} else if (p < 2.5 / 2.75) {
|
|
return 7.5625 * (p -= 2.25 / 2.75) * p + 0.9375;
|
|
}
|
|
return 7.5625 * (p -= 2.625 / 2.75) * p + 0.984375;
|
|
}),
|
|
_create("BounceIn", function(p) {
|
|
if ((p = 1 - p) < 1 / 2.75) {
|
|
return 1 - (7.5625 * p * p);
|
|
} else if (p < 2 / 2.75) {
|
|
return 1 - (7.5625 * (p -= 1.5 / 2.75) * p + 0.75);
|
|
} else if (p < 2.5 / 2.75) {
|
|
return 1 - (7.5625 * (p -= 2.25 / 2.75) * p + 0.9375);
|
|
}
|
|
return 1 - (7.5625 * (p -= 2.625 / 2.75) * p + 0.984375);
|
|
}),
|
|
_create("BounceInOut", function(p) {
|
|
var invert = (p < 0.5);
|
|
if (invert) {
|
|
p = 1 - (p * 2);
|
|
} else {
|
|
p = (p * 2) - 1;
|
|
}
|
|
if (p < 1 / 2.75) {
|
|
p = 7.5625 * p * p;
|
|
} else if (p < 2 / 2.75) {
|
|
p = 7.5625 * (p -= 1.5 / 2.75) * p + 0.75;
|
|
} else if (p < 2.5 / 2.75) {
|
|
p = 7.5625 * (p -= 2.25 / 2.75) * p + 0.9375;
|
|
} else {
|
|
p = 7.5625 * (p -= 2.625 / 2.75) * p + 0.984375;
|
|
}
|
|
return invert ? (1 - p) * 0.5 : p * 0.5 + 0.5;
|
|
})
|
|
);
|
|
|
|
|
|
//CIRC
|
|
_wrap("Circ",
|
|
_create("CircOut", function(p) {
|
|
return Math.sqrt(1 - (p = p - 1) * p);
|
|
}),
|
|
_create("CircIn", function(p) {
|
|
return -(Math.sqrt(1 - (p * p)) - 1);
|
|
}),
|
|
_create("CircInOut", function(p) {
|
|
return ((p*=2) < 1) ? -0.5 * (Math.sqrt(1 - p * p) - 1) : 0.5 * (Math.sqrt(1 - (p -= 2) * p) + 1);
|
|
})
|
|
);
|
|
|
|
|
|
//Elastic
|
|
_createElastic = function(n, f, def) {
|
|
var C = _class("easing." + n, function(amplitude, period) {
|
|
this._p1 = (amplitude >= 1) ? amplitude : 1; //note: if amplitude is < 1, we simply adjust the period for a more natural feel. Otherwise the math doesn't work right and the curve starts at 1.
|
|
this._p2 = (period || def) / (amplitude < 1 ? amplitude : 1);
|
|
this._p3 = this._p2 / _2PI * (Math.asin(1 / this._p1) || 0);
|
|
this._p2 = _2PI / this._p2; //precalculate to optimize
|
|
}, true),
|
|
p = C.prototype = new Ease();
|
|
p.constructor = C;
|
|
p.getRatio = f;
|
|
p.config = function(amplitude, period) {
|
|
return new C(amplitude, period);
|
|
};
|
|
return C;
|
|
};
|
|
_wrap("Elastic",
|
|
_createElastic("ElasticOut", function(p) {
|
|
return this._p1 * Math.pow(2, -10 * p) * Math.sin( (p - this._p3) * this._p2 ) + 1;
|
|
}, 0.3),
|
|
_createElastic("ElasticIn", function(p) {
|
|
return -(this._p1 * Math.pow(2, 10 * (p -= 1)) * Math.sin( (p - this._p3) * this._p2 ));
|
|
}, 0.3),
|
|
_createElastic("ElasticInOut", function(p) {
|
|
return ((p *= 2) < 1) ? -0.5 * (this._p1 * Math.pow(2, 10 * (p -= 1)) * Math.sin( (p - this._p3) * this._p2)) : this._p1 * Math.pow(2, -10 *(p -= 1)) * Math.sin( (p - this._p3) * this._p2 ) * 0.5 + 1;
|
|
}, 0.45)
|
|
);
|
|
|
|
|
|
//Expo
|
|
_wrap("Expo",
|
|
_create("ExpoOut", function(p) {
|
|
return 1 - Math.pow(2, -10 * p);
|
|
}),
|
|
_create("ExpoIn", function(p) {
|
|
return Math.pow(2, 10 * (p - 1)) - 0.001;
|
|
}),
|
|
_create("ExpoInOut", function(p) {
|
|
return ((p *= 2) < 1) ? 0.5 * Math.pow(2, 10 * (p - 1)) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));
|
|
})
|
|
);
|
|
|
|
|
|
//Sine
|
|
_wrap("Sine",
|
|
_create("SineOut", function(p) {
|
|
return Math.sin(p * _HALF_PI);
|
|
}),
|
|
_create("SineIn", function(p) {
|
|
return -Math.cos(p * _HALF_PI) + 1;
|
|
}),
|
|
_create("SineInOut", function(p) {
|
|
return -0.5 * (Math.cos(Math.PI * p) - 1);
|
|
})
|
|
);
|
|
|
|
_class("easing.EaseLookup", {
|
|
find:function(s) {
|
|
return Ease.map[s];
|
|
}
|
|
}, true);
|
|
|
|
//register the non-standard eases
|
|
_easeReg(w.SlowMo, "SlowMo", "ease,");
|
|
_easeReg(RoughEase, "RoughEase", "ease,");
|
|
_easeReg(SteppedEase, "SteppedEase", "ease,");
|
|
|
|
return Back;
|
|
|
|
}, true);
|
|
|
|
}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); }
|
|
|
|
//export to AMD/RequireJS and CommonJS/Node (precursor to full modular build system coming at a later date)
|
|
(function() {
|
|
"use strict";
|
|
var getGlobal = function() {
|
|
return (_gsScope.GreenSockGlobals || _gsScope);
|
|
};
|
|
if (typeof(module) !== "undefined" && module.exports) { //node
|
|
require("../TweenLite.js");
|
|
module.exports = getGlobal();
|
|
} else if (typeof(define) === "function" && define.amd) { //AMD
|
|
define(["TweenLite"], getGlobal);
|
|
}
|
|
}()); |