var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
/**
* @module annie
*/
var annie;
(function (annie) {
/**
* TweenObj，具体的tween对象类
* @class annie.TweenObj
* @public
* @since 1.0.0
*/
var TweenObj = (function (_super) {
__extends(TweenObj, _super);
function TweenObj() {
_super.call(this);
/**
* 是否暂停，默认false
* @property pause
* @type {boolean}
*/
this.pause = false;
/**
* 当前帧
* @property currentFrame
* @type {number}
*/
this.currentFrame = 0;
/**
* 总帧数
* @property totalFrames
* @type {number}
*/
this.totalFrames = 0;
this._isLoop = 0;
this._delay = 0;
this._isFront = true;
this._cParams = null;
this._loop = false;
}
/**
* 初始化数据
* @method init
* @param target
* @param times
* @param data
* @param isTo
* @param isPlay
* @public
* @since 1.0.0
*/
TweenObj.prototype.init = function (target, times, data, isTo, isPlay) {
if (isTo === void 0) { isTo = true; }
if (isPlay === void 0) { isPlay = true; }
if (times <= 0 || typeof (times) != "number") {
throw new Error("annie.Tween.to()或者annie.Tween.from()方法的第二个参数一定要是大于0的数字");
}
var s = this;
s.currentFrame = 1;
var tTime = times * annie.Stage._FPS >> 0;
s.totalFrames = tTime > 0 ? tTime : 1;
s.target = target;
s._isTo = isTo;
s._isLoop = 0;
s._startData = {};
s._disData = {};
s._delay = 0;
s._isFront = true;
s._ease = null;
s._update = null;
s._cParams = null;
s._loop = false;
s._completeFun = null;
for (var item in data) {
switch (item) {
case "useFrame":
if (data[item] == true) {
s.totalFrames = times;
}
break;
case "yoyo":
if (typeof (data[item]) == "number") {
s._isLoop = data[item];
}
else {
if (data[item] == false) {
s._isLoop = 0;
}
else if (data[item] == true) {
s._isLoop = Number.MAX_VALUE;
}
}
break;
case "delay":
if (data.useFrame) {
s._delay = data[item];
}
else {
s._delay = data[item] * annie.Stage._FPS >> 0;
}
break;
case "ease":
s._ease = data[item];
break;
case "onUpdate":
s._update = data[item];
break;
case "onComplete":
s._completeFun = data[item];
break;
case "completeParams":
s._cParams = data[item];
break;
case "loop":
s._loop = data[item];
break;
default:
if (typeof (data[item]) == "number") {
if (isTo) {
s._startData[item] = target[item];
s._disData[item] = data[item] - target[item];
}
else {
s._startData[item] = data[item];
s._disData[item] = target[item] - data[item];
target[item] = data[item];
}
}
}
}
};
/**
* 更新数据
* @method update
* @since 1.0.0
* @public
*/
TweenObj.prototype.update = function () {
var s = this;
if (s.pause)
return;
if (s._isFront && s._delay > 0) {
s._delay--;
return;
}
//更新数据
var per = s.currentFrame / s.totalFrames;
if (per < 0 || per > 1)
return;
if (s._ease) {
per = s._ease(per);
}
var isHave = false;
for (var item in s._disData) {
isHave = true;
s.target[item] = s._startData[item] + s._disData[item] * per;
}
if (!isHave) {
//如果发现tween被全新的tween全部给替换了，那就直接回收这个
Tween.kill(s.instanceId);
return;
}
if (s._update) {
s._update(per);
}
var cf = s._completeFun;
var pm = s._cParams;
if (s._isFront) {
s.currentFrame++;
if (s.currentFrame > s.totalFrames) {
if (s._loop) {
s.currentFrame = 1;
}
else {
if (cf) {
cf(pm, s._isLoop == 0);
}
if (s._isLoop > 0) {
s._isFront = false;
s.currentFrame = s.totalFrames;
s._isLoop--;
}
else {
Tween.kill(s.instanceId);
}
}
}
}
else {
s.currentFrame--;
if (s.currentFrame < 0) {
if (cf) {
cf(pm, s._isLoop == 0);
}
if (s._isLoop > 0) {
s._isFront = true;
s.currentFrame = 1;
}
else {
Tween.kill(s.instanceId);
}
}
}
};
TweenObj.prototype.destroy = function () {
var s = this;
s._update = null;
s._completeFun = null;
s._ease = null;
};
return TweenObj;
}(annie.AObject));
annie.TweenObj = TweenObj;
/**
* 全局静态单列类,不要实例化此类
* @class annie.Tween
* @public
* @since 1.0.0
*/
var Tween = (function () {
function Tween() {
}
/**
* 将target对象从data中指定的属性数值渐变到target属性当前的数值
* @method to
* @static
* @param {Object} target
* @param {number} totalFrame 总时间长度 如果data.useFrame为true 这里就是帧数，如果data.useFrame为false则这里就是时间
* @param {Object} data 包含target对象的各种数字类型属性及其他一些方法属性
* @param {number:boolean} data.yoyo 是否像摆钟一样来回循环,默认为false.设置为true则会无限循环,或想只运行指定的摆动次数,将此参数设置为数字就行了。
* @param {number:boolean} data.loop 是否循环播放。
* @param {Function} data.onComplete 完成结束函数. 默认为null. 两个参数，第一个是data.completeParams的值,第二个是true或者false，表示是否真的结束了,或者是一次yoyo,一次loop的结束
* @param {Array} data.completeParams 完成函数参数. 默认为null，可以给完成函数里传参数
* @param {Function} data.onUpdate 进入每帧后执行函数,回传参数是当前的Tween时间比.默认为null
* @param {Function} data.ease 缓动类型方法
* @param {boolean} data.useFrame 为false用时间秒值;为true则是以帧为单位
* @param {number} data.delay 延时，useFrame为true以帧为单位 useFrame为false以秒为单位
* @public
* @since 1.0.0
*/
Tween.to = function (target, totalFrame, data) {
return Tween.createTween(target, totalFrame, data, true);
};
/**
* 将target对象从data中指定的属性数值渐变到target属性当前的数值
* @method from
* @static
* @param {Object} target
* @param {number} totalFrame 总时间长度 如果data.useFrame为true 这里就是帧数，如果data.useFrame为false则这里就是时间
* @param {Object} data 包含target对象的各种数字类型属性及其他一些方法属性
* @param {number:boolean} data.yoyo 是否像摆钟一样来回循环,默认为false.设置为true则会无限循环,或想只运行指定的摆动次数,将此参数设置为数字就行了。
* @param {number:boolean} data.loop 是否循环播放。
* @param {Function} data.onComplete 完成结束函数. 默认为null. 两个参数，第一个是data.completeParams的值,第二个是true或者false，表示是否真的结束了,或者是一次yoyo,一次loop的结束
* @param {Array} data.completeParams 完成函数参数. 默认为null，可以给完成函数里传参数
* @param {Function} data.onUpdate 进入每帧后执行函数,回传参数是当前的Tween时间比.默认为null
* @param {Function} data.ease 缓动类型方法
* @param {boolean} data.useFrame 为false用时间秒值;为true则是以帧为单位
* @param {number} data.delay 延时，useFrame为true以帧为单位 useFrame为false以秒为单位
* @public
* @since 1.0.0
*/
Tween.from = function (target, totalFrame, data) {
return Tween.createTween(target, totalFrame, data, false);
};
Tween.createTween = function (target, totalFrame, data, isTo, isPlay) {
if (isPlay === void 0) { isPlay = true; }
var tweenObj;
var len = Tween._tweenList.length;
for (var i = 0; i < len; i++) {
tweenObj = Tween._tweenList[i];
if (target == tweenObj.target) {
for (var item in tweenObj._startData) {
if (data[item] != undefined) {
delete tweenObj._startData[item];
delete tweenObj._disData[item];
}
}
}
}
len = Tween._tweenPool.length;
if (len > 0) {
tweenObj = Tween._tweenPool.shift();
//考虑到对象池回收后需要变更id
tweenObj._instanceId = annie.AObject["_object_id"]++;
}
else {
tweenObj = new TweenObj();
}
Tween._tweenList.push(tweenObj);
tweenObj.init(target, totalFrame, data, isTo, isPlay);
return tweenObj.instanceId;
};
/**
* 销毁所有正在运行的Tween对象
* @method killAll
* @static
* @public
* @since 1.0.0
*/
Tween.killAll = function () {
var len = Tween._tweenList.length;
var tweenObj;
for (var i = 0; i < len; i++) {
tweenObj = Tween._tweenList[i];
tweenObj.target = null;
tweenObj._completeFun = null;
tweenObj._cParams = null;
tweenObj._update = null;
tweenObj._ease = null;
tweenObj._loop = false;
Tween._tweenPool.push(tweenObj);
}
Tween._tweenList.length = 0;
};
/**
* @通过创建Tween对象返回时的唯一id来销毁对应的Tween对象
* @method kill
* @static
* @public
* @param {annie.Tween} tween
* @since 1.0.0
*/
Tween.kill = function (tweenId) {
var len = Tween._tweenList.length;
var tweenObj;
for (var i = 0; i < len; i++) {
tweenObj = Tween._tweenList[i];
if (tweenObj.instanceId == tweenId) {
tweenObj.target = null;
tweenObj._completeFun = null;
tweenObj._cParams = null;
tweenObj._update = null;
tweenObj._ease = null;
tweenObj._loop = null;
Tween._tweenPool.push(tweenObj);
Tween._tweenList.splice(i, 1);
break;
}
}
};
/**
* quadraticIn缓动类型
* @method quadraticIn
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.quadraticIn = function (k) {
return k * k;
};
/**
* quadraticOut 缓动类型
* @method quadraticOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.quadraticOut = function (k) {
return k * (2 - k);
};
/**
* quadraticInOut 缓动类型
* @method quadraticInOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.quadraticInOut = function (k) {
if ((k *= 2) < 1) {
return 0.5 * k * k;
}
return -0.5 * (--k * (k - 2) - 1);
};
/**
* cubicIn 缓动类型
* @method cubicIn
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.cubicIn = function (k) {
return k * k * k;
};
/**
* cubicOut 缓动类型
* @method cubicOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.cubicOut = function (k) {
return --k * k * k + 1;
};
/**
* cubicInOut 缓动类型
* @method cubicInOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.cubicInOut = function (k) {
if ((k *= 2) < 1) {
return 0.5 * k * k * k;
}
return 0.5 * ((k -= 2) * k * k + 2);
};
/**
* quarticIn 缓动类型
* @method quarticIn
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.quarticIn = function (k) {
return k * k * k * k;
};
/**
* quarticOut 缓动类型
* @method quarticOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.quarticOut = function (k) {
return 1 - (--k * k * k * k);
};
/**
* quarticInOut 缓动类型
* @method quarticInOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.quarticInOut = function (k) {
if ((k *= 2) < 1) {
return 0.5 * k * k * k * k;
}
return -0.5 * ((k -= 2) * k * k * k - 2);
};
/**
* quinticIn 缓动类型
* @method quinticIn
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.quinticIn = function (k) {
return k * k * k * k * k;
};
/**
* quinticOut 缓动类型
* @method quinticOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.quinticOut = function (k) {
return --k * k * k * k * k + 1;
};
/**
* quinticInOut 缓动类型
* @method quinticInOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.quinticInOut = function (k) {
if ((k *= 2) < 1) {
return 0.5 * k * k * k * k * k;
}
return 0.5 * ((k -= 2) * k * k * k * k + 2);
};
/**
* sinusoidalIn 缓动类型
* @method sinusoidalIn
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.sinusoidalIn = function (k) {
return 1 - Math.cos(k * Math.PI / 2);
};
/**
* sinusoidalOut 缓动类型
* @method sinusoidalOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.sinusoidalOut = function (k) {
return Math.sin(k * Math.PI / 2);
};
/**
* sinusoidalInOut 缓动类型
* @method sinusoidalInOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.sinusoidalInOut = function (k) {
return 0.5 * (1 - Math.cos(Math.PI * k));
};
/**
* exponentialIn 缓动类型
* @method exponentialIn
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.exponentialIn = function (k) {
return k == 0 ? 0 : Math.pow(1024, k - 1);
};
/**
* exponentialOut 缓动类型
* @method exponentialOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.exponentialOut = function (k) {
return k == 1 ? 1 : 1 - Math.pow(2, -10 * k);
};
/**
* exponentialInOut 缓动类型
* @method exponentialInOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.exponentialInOut = function (k) {
if (k == 0) {
return 0;
}
if (k == 1) {
return 1;
}
if ((k *= 2) < 1) {
return 0.5 * Math.pow(1024, k - 1);
}
return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);
};
/**
* circularIn 缓动类型
* @method circularIn
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.circularIn = function (k) {
return 1 - Math.sqrt(1 - k * k);
};
/**
* circularOut 缓动类型
* @method circularOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.circularOut = function (k) {
return Math.sqrt(1 - (--k * k));
};
/**
* circularInOut 缓动类型
* @method circularInOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.circularInOut = function (k) {
if ((k *= 2) < 1) {
return -0.5 * (Math.sqrt(1 - k * k) - 1);
}
return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);
};
/**
* elasticIn 缓动类型
* @method elasticIn
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.elasticIn = function (k) {
if (k == 0) {
return 0;
}
if (k == 1) {
return 1;
}
return -Math.pow(2, 10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI);
};
/**
* elasticOut 缓动类型
* @method elasticOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.elasticOut = function (k) {
if (k == 0) {
return 0;
}
if (k == 1) {
return 1;
}
return Math.pow(2, -10 * k) * Math.sin((k - 0.1) * 5 * Math.PI) + 1;
};
/**
* elasticInOut 缓动类型
* @method elasticInOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.elasticInOut = function (k) {
if (k == 0) {
return 0;
}
if (k == 1) {
return 1;
}
k *= 2;
if (k < 1) {
return -0.5 * Math.pow(2, 10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI);
}
return 0.5 * Math.pow(2, -10 * (k - 1)) * Math.sin((k - 1.1) * 5 * Math.PI) + 1;
};
/**
* backIn 缓动类型
* @method backIn
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.backIn = function (k) {
var s = 1.70158;
return k * k * ((s + 1) * k - s);
};
/**
* backOut 缓动类型
* @method backOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.backOut = function (k) {
var s = 1.70158;
return --k * k * ((s + 1) * k + s) + 1;
};
/**
* backInOut 缓动类型
* @method backInOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.backInOut = 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);
};
/**
* bounceIn 缓动类型
* @method bounceIn
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.bounceIn = function (k) {
return 1 - Tween.bounceOut(1 - k);
};
/**
* bounceOut 缓动类型
* @method bounceOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.bounceOut = function (k) {
if (k < (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;
}
};
/**
* bounceInOut 缓动类型
* @method bounceInOut
* @static
* @public
* @since 1.0.0
* @param {number}k
* @return {number}
*/
Tween.bounceInOut = function (k) {
if (k < 0.5) {
return Tween.bounceIn(k * 2) * 0.5;
}
return Tween.bounceOut(k * 2 - 1) * 0.5 + 0.5;
};
//这里之所有要独立运行,是因为可能存在多个stage，不能把这个跟其中任何一个stage放在一起update
Tween.flush = function () {
var len = Tween._tweenList.length;
for (var i = len - 1; i >= 0; i--) {
if (Tween._tweenList[i]) {
Tween._tweenList[i].update();
}
else {
Tween._tweenList.splice(i, 1);
}
}
};
Tween._tweenPool = [];
Tween._tweenList = [];
return Tween;
}());
annie.Tween = Tween;
})(annie || (annie = {}));