Merge remote-tracking branch 'origin/dev' into dev

spine-ts/build/spine-all.d.ts

@@ -310,10 +310,10 @@ declare module spine {
 		clearTracks(): void;
 		clearTrack(trackIndex: number): void;
 		setCurrent(index: number, current: TrackEntry): void;
-		setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
-		setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
-		addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
-		addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
+		setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
+		setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
+		addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
+		addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
 		setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
 		addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
 		setEmptyAnimations(mixDuration: number): void;

spine-ts/build/spine-all.js

@@ -523,7 +523,7 @@ var spine;
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
 				else {
 					var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
-					r_1 -= (16384 - Math.floor(16384.499999999996 - r_1 / 360)) * 360;
+					r_1 -= (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360;
 					bone.rotation += r_1 * alpha;
 				}
 				return;
@@ -533,15 +533,15 @@ var spine;
 			var frameTime = frames[frame];
 			var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
 			var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
-			r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+			r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 			r = prevRotation + r * percent;
 			if (setupPose) {
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation = bone.data.rotation + r * alpha;
 			}
 			else {
 				r = bone.data.rotation + r - bone.rotation;
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation += r * alpha;
 			}
 		};
@@ -1415,9 +1415,9 @@ var spine;
 				var frameTime = frames[frame];
 				var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
 				r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 				r2 = prevRotation + r2 * percent + bone.data.rotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 			}
 			var r1 = setupPose ? bone.data.rotation : bone.rotation;
 			var total = 0, diff = r2 - r1;
@@ -1430,7 +1430,7 @@ var spine;
 					total = timelinesRotation[i];
 			}
 			else {
-				diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
+				diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
 				var lastTotal = 0, lastDiff = 0;
 				if (firstFrame) {
 					lastTotal = 0;
@@ -1453,7 +1453,7 @@ var spine;
 			}
 			timelinesRotation[i + 1] = diff;
 			r1 += total * alpha;
-			bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360;
+			bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
 		};
 		AnimationState.prototype.queueEvents = function (entry, animationTime) {
 			var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@@ -1522,13 +1522,13 @@ var spine;
 			}
 			this.queue.start(current);
 		};
-		AnimationState.prototype.setAnimationByName = function (trackIndex, animationName, loop) {
+		AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.setAnimation(trackIndex, animation, loop);
+			return this.setAnimationWith(trackIndex, animation, loop);
 		};
-		AnimationState.prototype.setAnimation = function (trackIndex, animation, loop) {
+		AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var current = this.expandToIndex(trackIndex);
@@ -1548,13 +1548,13 @@ var spine;
 			this.queue.drain();
 			return entry;
 		};
-		AnimationState.prototype.addAnimationByName = function (trackIndex, animationName, loop, delay) {
+		AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.addAnimation(trackIndex, animation, loop, delay);
+			return this.addAnimationWith(trackIndex, animation, loop, delay);
 		};
-		AnimationState.prototype.addAnimation = function (trackIndex, animation, loop, delay) {
+		AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var last = this.expandToIndex(trackIndex);
@@ -1572,7 +1572,7 @@ var spine;
 				if (delay <= 0) {
 					var duration = last.animationEnd - last.animationStart;
 					if (duration != 0)
-						delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation);
+						delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
 					else
 						delay = 0;
 				}
@@ -1581,7 +1581,7 @@ var spine;
 			return entry;
 		};
 		AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
-			var entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false);
+			var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1589,7 +1589,7 @@ var spine;
 		AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
 			if (delay <= 0)
 				delay -= mixDuration;
-			var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
+			var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1607,7 +1607,7 @@ var spine;
 		AnimationState.prototype.expandToIndex = function (index) {
 			if (index < this.tracks.length)
 				return this.tracks[index];
-			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1);
+			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
 			this.tracks.length = index + 1;
 			return null;
 		};
@@ -1790,41 +1790,47 @@ var spine;
 				var entry = objects[i + 1];
 				switch (type) {
 					case EventType.start:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].start(entry);
+							if (listeners[ii].start)
+								listeners[ii].start(entry);
 						break;
 					case EventType.interrupt:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].interrupt(entry);
+							if (listeners[ii].interrupt)
+								listeners[ii].interrupt(entry);
 						break;
 					case EventType.end:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].end(entry);
+							if (listeners[ii].end)
+								listeners[ii].end(entry);
 					case EventType.dispose:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].dispose(entry);
+							if (listeners[ii].dispose)
+								listeners[ii].dispose(entry);
 						this.animState.trackEntryPool.free(entry);
 						break;
 					case EventType.complete:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.complete)
 							entry.listener.complete(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].complete(entry);
+							if (listeners[ii].complete)
+								listeners[ii].complete(entry);
 						break;
 					case EventType.event:
 						var event_3 = objects[i++ + 2];
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.event)
 							entry.listener.event(entry, event_3);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].event(entry, event_3);
+							if (listeners[ii].event)
+								listeners[ii].event(entry, event_3);
 						break;
 				}
 			}
@@ -7887,7 +7893,7 @@ var spine;
 					skeleton.y = config.y;
 				}
 				var animationState = this.state = new spine.AnimationState(new spine.AnimationStateData(skeleton.data));
-				animationState.setAnimationByName(0, config.animation, true);
+				animationState.setAnimation(0, config.animation, true);
 				if (config.success)
 					config.success(this);
 				this.loaded = true;
@@ -7982,7 +7988,7 @@ var spine;
 			if (!this.loaded)
 				throw new Error("Widget isn't loaded yet");
 			this.skeleton.setToSetupPose();
-			this.state.setAnimationByName(0, animationName, this.config.loop);
+			this.state.setAnimation(0, animationName, this.config.loop);
 		};
 		SpineWidget.loadWidgets = function () {
 			var widgets = document.getElementsByClassName("spine-widget");

spine-ts/build/spine-canvas.d.ts

@@ -310,10 +310,10 @@ declare module spine {
 		clearTracks(): void;
 		clearTrack(trackIndex: number): void;
 		setCurrent(index: number, current: TrackEntry): void;
-		setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
-		setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
-		addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
-		addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
+		setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
+		setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
+		addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
+		addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
 		setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
 		addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
 		setEmptyAnimations(mixDuration: number): void;

spine-ts/build/spine-canvas.js

@@ -523,7 +523,7 @@ var spine;
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
 				else {
 					var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
-					r_1 -= (16384 - Math.floor(16384.499999999996 - r_1 / 360)) * 360;
+					r_1 -= (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360;
 					bone.rotation += r_1 * alpha;
 				}
 				return;
@@ -533,15 +533,15 @@ var spine;
 			var frameTime = frames[frame];
 			var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
 			var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
-			r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+			r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 			r = prevRotation + r * percent;
 			if (setupPose) {
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation = bone.data.rotation + r * alpha;
 			}
 			else {
 				r = bone.data.rotation + r - bone.rotation;
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation += r * alpha;
 			}
 		};
@@ -1415,9 +1415,9 @@ var spine;
 				var frameTime = frames[frame];
 				var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
 				r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 				r2 = prevRotation + r2 * percent + bone.data.rotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 			}
 			var r1 = setupPose ? bone.data.rotation : bone.rotation;
 			var total = 0, diff = r2 - r1;
@@ -1430,7 +1430,7 @@ var spine;
 					total = timelinesRotation[i];
 			}
 			else {
-				diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
+				diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
 				var lastTotal = 0, lastDiff = 0;
 				if (firstFrame) {
 					lastTotal = 0;
@@ -1453,7 +1453,7 @@ var spine;
 			}
 			timelinesRotation[i + 1] = diff;
 			r1 += total * alpha;
-			bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360;
+			bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
 		};
 		AnimationState.prototype.queueEvents = function (entry, animationTime) {
 			var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@@ -1522,13 +1522,13 @@ var spine;
 			}
 			this.queue.start(current);
 		};
-		AnimationState.prototype.setAnimationByName = function (trackIndex, animationName, loop) {
+		AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.setAnimation(trackIndex, animation, loop);
+			return this.setAnimationWith(trackIndex, animation, loop);
 		};
-		AnimationState.prototype.setAnimation = function (trackIndex, animation, loop) {
+		AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var current = this.expandToIndex(trackIndex);
@@ -1548,13 +1548,13 @@ var spine;
 			this.queue.drain();
 			return entry;
 		};
-		AnimationState.prototype.addAnimationByName = function (trackIndex, animationName, loop, delay) {
+		AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.addAnimation(trackIndex, animation, loop, delay);
+			return this.addAnimationWith(trackIndex, animation, loop, delay);
 		};
-		AnimationState.prototype.addAnimation = function (trackIndex, animation, loop, delay) {
+		AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var last = this.expandToIndex(trackIndex);
@@ -1572,7 +1572,7 @@ var spine;
 				if (delay <= 0) {
 					var duration = last.animationEnd - last.animationStart;
 					if (duration != 0)
-						delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation);
+						delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
 					else
 						delay = 0;
 				}
@@ -1581,7 +1581,7 @@ var spine;
 			return entry;
 		};
 		AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
-			var entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false);
+			var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1589,7 +1589,7 @@ var spine;
 		AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
 			if (delay <= 0)
 				delay -= mixDuration;
-			var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
+			var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1607,7 +1607,7 @@ var spine;
 		AnimationState.prototype.expandToIndex = function (index) {
 			if (index < this.tracks.length)
 				return this.tracks[index];
-			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1);
+			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
 			this.tracks.length = index + 1;
 			return null;
 		};
@@ -1790,41 +1790,47 @@ var spine;
 				var entry = objects[i + 1];
 				switch (type) {
 					case EventType.start:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].start(entry);
+							if (listeners[ii].start)
+								listeners[ii].start(entry);
 						break;
 					case EventType.interrupt:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].interrupt(entry);
+							if (listeners[ii].interrupt)
+								listeners[ii].interrupt(entry);
 						break;
 					case EventType.end:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].end(entry);
+							if (listeners[ii].end)
+								listeners[ii].end(entry);
 					case EventType.dispose:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].dispose(entry);
+							if (listeners[ii].dispose)
+								listeners[ii].dispose(entry);
 						this.animState.trackEntryPool.free(entry);
 						break;
 					case EventType.complete:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.complete)
 							entry.listener.complete(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].complete(entry);
+							if (listeners[ii].complete)
+								listeners[ii].complete(entry);
 						break;
 					case EventType.event:
 						var event_3 = objects[i++ + 2];
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.event)
 							entry.listener.event(entry, event_3);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].event(entry, event_3);
+							if (listeners[ii].event)
+								listeners[ii].event(entry, event_3);
 						break;
 				}
 			}

spine-ts/build/spine-core.d.ts

@@ -222,10 +222,10 @@ declare module spine {
 		clearTracks(): void;
 		clearTrack(trackIndex: number): void;
 		setCurrent(index: number, current: TrackEntry): void;
-		setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
-		setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
-		addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
-		addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
+		setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
+		setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
+		addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
+		addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
 		setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
 		addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
 		setEmptyAnimations(mixDuration: number): void;

spine-ts/build/spine-core.js

@@ -176,7 +176,7 @@ var spine;
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
 				else {
 					var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
-					r_1 -= (16384 - Math.floor(16384.499999999996 - r_1 / 360)) * 360;
+					r_1 -= (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360;
 					bone.rotation += r_1 * alpha;
 				}
 				return;
@@ -186,15 +186,15 @@ var spine;
 			var frameTime = frames[frame];
 			var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
 			var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
-			r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+			r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 			r = prevRotation + r * percent;
 			if (setupPose) {
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation = bone.data.rotation + r * alpha;
 			}
 			else {
 				r = bone.data.rotation + r - bone.rotation;
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation += r * alpha;
 			}
 		};
@@ -1068,9 +1068,9 @@ var spine;
 				var frameTime = frames[frame];
 				var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
 				r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 				r2 = prevRotation + r2 * percent + bone.data.rotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 			}
 			var r1 = setupPose ? bone.data.rotation : bone.rotation;
 			var total = 0, diff = r2 - r1;
@@ -1083,7 +1083,7 @@ var spine;
 					total = timelinesRotation[i];
 			}
 			else {
-				diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
+				diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
 				var lastTotal = 0, lastDiff = 0;
 				if (firstFrame) {
 					lastTotal = 0;
@@ -1106,7 +1106,7 @@ var spine;
 			}
 			timelinesRotation[i + 1] = diff;
 			r1 += total * alpha;
-			bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360;
+			bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
 		};
 		AnimationState.prototype.queueEvents = function (entry, animationTime) {
 			var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@@ -1175,13 +1175,13 @@ var spine;
 			}
 			this.queue.start(current);
 		};
-		AnimationState.prototype.setAnimationByName = function (trackIndex, animationName, loop) {
+		AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.setAnimation(trackIndex, animation, loop);
+			return this.setAnimationWith(trackIndex, animation, loop);
 		};
-		AnimationState.prototype.setAnimation = function (trackIndex, animation, loop) {
+		AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var current = this.expandToIndex(trackIndex);
@@ -1201,13 +1201,13 @@ var spine;
 			this.queue.drain();
 			return entry;
 		};
-		AnimationState.prototype.addAnimationByName = function (trackIndex, animationName, loop, delay) {
+		AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.addAnimation(trackIndex, animation, loop, delay);
+			return this.addAnimationWith(trackIndex, animation, loop, delay);
 		};
-		AnimationState.prototype.addAnimation = function (trackIndex, animation, loop, delay) {
+		AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var last = this.expandToIndex(trackIndex);
@@ -1225,7 +1225,7 @@ var spine;
 				if (delay <= 0) {
 					var duration = last.animationEnd - last.animationStart;
 					if (duration != 0)
-						delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation);
+						delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
 					else
 						delay = 0;
 				}
@@ -1234,7 +1234,7 @@ var spine;
 			return entry;
 		};
 		AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
-			var entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false);
+			var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1242,7 +1242,7 @@ var spine;
 		AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
 			if (delay <= 0)
 				delay -= mixDuration;
-			var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
+			var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1260,7 +1260,7 @@ var spine;
 		AnimationState.prototype.expandToIndex = function (index) {
 			if (index < this.tracks.length)
 				return this.tracks[index];
-			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1);
+			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
 			this.tracks.length = index + 1;
 			return null;
 		};
@@ -1443,41 +1443,47 @@ var spine;
 				var entry = objects[i + 1];
 				switch (type) {
 					case EventType.start:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].start(entry);
+							if (listeners[ii].start)
+								listeners[ii].start(entry);
 						break;
 					case EventType.interrupt:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].interrupt(entry);
+							if (listeners[ii].interrupt)
+								listeners[ii].interrupt(entry);
 						break;
 					case EventType.end:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].end(entry);
+							if (listeners[ii].end)
+								listeners[ii].end(entry);
 					case EventType.dispose:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].dispose(entry);
+							if (listeners[ii].dispose)
+								listeners[ii].dispose(entry);
 						this.animState.trackEntryPool.free(entry);
 						break;
 					case EventType.complete:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.complete)
 							entry.listener.complete(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].complete(entry);
+							if (listeners[ii].complete)
+								listeners[ii].complete(entry);
 						break;
 					case EventType.event:
 						var event_3 = objects[i++ + 2];
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.event)
 							entry.listener.event(entry, event_3);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].event(entry, event_3);
+							if (listeners[ii].event)
+								listeners[ii].event(entry, event_3);
 						break;
 				}
 			}

spine-ts/build/spine-threejs.d.ts

@@ -222,10 +222,10 @@ declare module spine {
 		clearTracks(): void;
 		clearTrack(trackIndex: number): void;
 		setCurrent(index: number, current: TrackEntry): void;
-		setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
-		setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
-		addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
-		addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
+		setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
+		setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
+		addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
+		addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
 		setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
 		addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
 		setEmptyAnimations(mixDuration: number): void;

spine-ts/build/spine-threejs.js

@@ -176,7 +176,7 @@ var spine;
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
 				else {
 					var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
-					r_1 -= (16384 - Math.floor(16384.499999999996 - r_1 / 360)) * 360;
+					r_1 -= (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360;
 					bone.rotation += r_1 * alpha;
 				}
 				return;
@@ -186,15 +186,15 @@ var spine;
 			var frameTime = frames[frame];
 			var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
 			var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
-			r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+			r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 			r = prevRotation + r * percent;
 			if (setupPose) {
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation = bone.data.rotation + r * alpha;
 			}
 			else {
 				r = bone.data.rotation + r - bone.rotation;
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation += r * alpha;
 			}
 		};
@@ -1068,9 +1068,9 @@ var spine;
 				var frameTime = frames[frame];
 				var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
 				r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 				r2 = prevRotation + r2 * percent + bone.data.rotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 			}
 			var r1 = setupPose ? bone.data.rotation : bone.rotation;
 			var total = 0, diff = r2 - r1;
@@ -1083,7 +1083,7 @@ var spine;
 					total = timelinesRotation[i];
 			}
 			else {
-				diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
+				diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
 				var lastTotal = 0, lastDiff = 0;
 				if (firstFrame) {
 					lastTotal = 0;
@@ -1106,7 +1106,7 @@ var spine;
 			}
 			timelinesRotation[i + 1] = diff;
 			r1 += total * alpha;
-			bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360;
+			bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
 		};
 		AnimationState.prototype.queueEvents = function (entry, animationTime) {
 			var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@@ -1175,13 +1175,13 @@ var spine;
 			}
 			this.queue.start(current);
 		};
-		AnimationState.prototype.setAnimationByName = function (trackIndex, animationName, loop) {
+		AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.setAnimation(trackIndex, animation, loop);
+			return this.setAnimationWith(trackIndex, animation, loop);
 		};
-		AnimationState.prototype.setAnimation = function (trackIndex, animation, loop) {
+		AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var current = this.expandToIndex(trackIndex);
@@ -1201,13 +1201,13 @@ var spine;
 			this.queue.drain();
 			return entry;
 		};
-		AnimationState.prototype.addAnimationByName = function (trackIndex, animationName, loop, delay) {
+		AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.addAnimation(trackIndex, animation, loop, delay);
+			return this.addAnimationWith(trackIndex, animation, loop, delay);
 		};
-		AnimationState.prototype.addAnimation = function (trackIndex, animation, loop, delay) {
+		AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var last = this.expandToIndex(trackIndex);
@@ -1225,7 +1225,7 @@ var spine;
 				if (delay <= 0) {
 					var duration = last.animationEnd - last.animationStart;
 					if (duration != 0)
-						delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation);
+						delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
 					else
 						delay = 0;
 				}
@@ -1234,7 +1234,7 @@ var spine;
 			return entry;
 		};
 		AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
-			var entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false);
+			var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1242,7 +1242,7 @@ var spine;
 		AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
 			if (delay <= 0)
 				delay -= mixDuration;
-			var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
+			var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1260,7 +1260,7 @@ var spine;
 		AnimationState.prototype.expandToIndex = function (index) {
 			if (index < this.tracks.length)
 				return this.tracks[index];
-			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1);
+			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
 			this.tracks.length = index + 1;
 			return null;
 		};
@@ -1443,41 +1443,47 @@ var spine;
 				var entry = objects[i + 1];
 				switch (type) {
 					case EventType.start:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].start(entry);
+							if (listeners[ii].start)
+								listeners[ii].start(entry);
 						break;
 					case EventType.interrupt:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].interrupt(entry);
+							if (listeners[ii].interrupt)
+								listeners[ii].interrupt(entry);
 						break;
 					case EventType.end:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].end(entry);
+							if (listeners[ii].end)
+								listeners[ii].end(entry);
 					case EventType.dispose:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].dispose(entry);
+							if (listeners[ii].dispose)
+								listeners[ii].dispose(entry);
 						this.animState.trackEntryPool.free(entry);
 						break;
 					case EventType.complete:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.complete)
 							entry.listener.complete(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].complete(entry);
+							if (listeners[ii].complete)
+								listeners[ii].complete(entry);
 						break;
 					case EventType.event:
 						var event_3 = objects[i++ + 2];
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.event)
 							entry.listener.event(entry, event_3);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].event(entry, event_3);
+							if (listeners[ii].event)
+								listeners[ii].event(entry, event_3);
 						break;
 				}
 			}

spine-ts/build/spine-webgl.d.ts

@@ -222,10 +222,10 @@ declare module spine {
 		clearTracks(): void;
 		clearTrack(trackIndex: number): void;
 		setCurrent(index: number, current: TrackEntry): void;
-		setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
-		setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
-		addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
-		addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
+		setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
+		setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
+		addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
+		addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
 		setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
 		addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
 		setEmptyAnimations(mixDuration: number): void;

spine-ts/build/spine-webgl.js

@@ -176,7 +176,7 @@ var spine;
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
 				else {
 					var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
-					r_1 -= (16384 - Math.floor(16384.499999999996 - r_1 / 360)) * 360;
+					r_1 -= (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360;
 					bone.rotation += r_1 * alpha;
 				}
 				return;
@@ -186,15 +186,15 @@ var spine;
 			var frameTime = frames[frame];
 			var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
 			var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
-			r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+			r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 			r = prevRotation + r * percent;
 			if (setupPose) {
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation = bone.data.rotation + r * alpha;
 			}
 			else {
 				r = bone.data.rotation + r - bone.rotation;
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation += r * alpha;
 			}
 		};
@@ -1068,9 +1068,9 @@ var spine;
 				var frameTime = frames[frame];
 				var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
 				r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 				r2 = prevRotation + r2 * percent + bone.data.rotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 			}
 			var r1 = setupPose ? bone.data.rotation : bone.rotation;
 			var total = 0, diff = r2 - r1;
@@ -1083,7 +1083,7 @@ var spine;
 					total = timelinesRotation[i];
 			}
 			else {
-				diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
+				diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
 				var lastTotal = 0, lastDiff = 0;
 				if (firstFrame) {
 					lastTotal = 0;
@@ -1106,7 +1106,7 @@ var spine;
 			}
 			timelinesRotation[i + 1] = diff;
 			r1 += total * alpha;
-			bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360;
+			bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
 		};
 		AnimationState.prototype.queueEvents = function (entry, animationTime) {
 			var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@@ -1175,13 +1175,13 @@ var spine;
 			}
 			this.queue.start(current);
 		};
-		AnimationState.prototype.setAnimationByName = function (trackIndex, animationName, loop) {
+		AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.setAnimation(trackIndex, animation, loop);
+			return this.setAnimationWith(trackIndex, animation, loop);
 		};
-		AnimationState.prototype.setAnimation = function (trackIndex, animation, loop) {
+		AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var current = this.expandToIndex(trackIndex);
@@ -1201,13 +1201,13 @@ var spine;
 			this.queue.drain();
 			return entry;
 		};
-		AnimationState.prototype.addAnimationByName = function (trackIndex, animationName, loop, delay) {
+		AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.addAnimation(trackIndex, animation, loop, delay);
+			return this.addAnimationWith(trackIndex, animation, loop, delay);
 		};
-		AnimationState.prototype.addAnimation = function (trackIndex, animation, loop, delay) {
+		AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var last = this.expandToIndex(trackIndex);
@@ -1225,7 +1225,7 @@ var spine;
 				if (delay <= 0) {
 					var duration = last.animationEnd - last.animationStart;
 					if (duration != 0)
-						delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation);
+						delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
 					else
 						delay = 0;
 				}
@@ -1234,7 +1234,7 @@ var spine;
 			return entry;
 		};
 		AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
-			var entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false);
+			var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1242,7 +1242,7 @@ var spine;
 		AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
 			if (delay <= 0)
 				delay -= mixDuration;
-			var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
+			var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1260,7 +1260,7 @@ var spine;
 		AnimationState.prototype.expandToIndex = function (index) {
 			if (index < this.tracks.length)
 				return this.tracks[index];
-			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1);
+			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
 			this.tracks.length = index + 1;
 			return null;
 		};
@@ -1443,41 +1443,47 @@ var spine;
 				var entry = objects[i + 1];
 				switch (type) {
 					case EventType.start:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].start(entry);
+							if (listeners[ii].start)
+								listeners[ii].start(entry);
 						break;
 					case EventType.interrupt:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].interrupt(entry);
+							if (listeners[ii].interrupt)
+								listeners[ii].interrupt(entry);
 						break;
 					case EventType.end:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].end(entry);
+							if (listeners[ii].end)
+								listeners[ii].end(entry);
 					case EventType.dispose:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].dispose(entry);
+							if (listeners[ii].dispose)
+								listeners[ii].dispose(entry);
 						this.animState.trackEntryPool.free(entry);
 						break;
 					case EventType.complete:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.complete)
 							entry.listener.complete(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].complete(entry);
+							if (listeners[ii].complete)
+								listeners[ii].complete(entry);
 						break;
 					case EventType.event:
 						var event_3 = objects[i++ + 2];
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.event)
 							entry.listener.event(entry, event_3);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].event(entry, event_3);
+							if (listeners[ii].event)
+								listeners[ii].event(entry, event_3);
 						break;
 				}
 			}

spine-ts/build/spine-widget.d.ts

@@ -222,10 +222,10 @@ declare module spine {
 		clearTracks(): void;
 		clearTrack(trackIndex: number): void;
 		setCurrent(index: number, current: TrackEntry): void;
-		setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
-		setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
-		addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
-		addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
+		setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
+		setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
+		addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
+		addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
 		setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
 		addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
 		setEmptyAnimations(mixDuration: number): void;

spine-ts/build/spine-widget.js

@@ -176,7 +176,7 @@ var spine;
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
 				else {
 					var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
-					r_1 -= (16384 - Math.floor(16384.499999999996 - r_1 / 360)) * 360;
+					r_1 -= (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360;
 					bone.rotation += r_1 * alpha;
 				}
 				return;
@@ -186,15 +186,15 @@ var spine;
 			var frameTime = frames[frame];
 			var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
 			var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
-			r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+			r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 			r = prevRotation + r * percent;
 			if (setupPose) {
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation = bone.data.rotation + r * alpha;
 			}
 			else {
 				r = bone.data.rotation + r - bone.rotation;
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation += r * alpha;
 			}
 		};
@@ -1068,9 +1068,9 @@ var spine;
 				var frameTime = frames[frame];
 				var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
 				r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 				r2 = prevRotation + r2 * percent + bone.data.rotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 			}
 			var r1 = setupPose ? bone.data.rotation : bone.rotation;
 			var total = 0, diff = r2 - r1;
@@ -1083,7 +1083,7 @@ var spine;
 					total = timelinesRotation[i];
 			}
 			else {
-				diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
+				diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
 				var lastTotal = 0, lastDiff = 0;
 				if (firstFrame) {
 					lastTotal = 0;
@@ -1106,7 +1106,7 @@ var spine;
 			}
 			timelinesRotation[i + 1] = diff;
 			r1 += total * alpha;
-			bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360;
+			bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
 		};
 		AnimationState.prototype.queueEvents = function (entry, animationTime) {
 			var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@@ -1175,13 +1175,13 @@ var spine;
 			}
 			this.queue.start(current);
 		};
-		AnimationState.prototype.setAnimationByName = function (trackIndex, animationName, loop) {
+		AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.setAnimation(trackIndex, animation, loop);
+			return this.setAnimationWith(trackIndex, animation, loop);
 		};
-		AnimationState.prototype.setAnimation = function (trackIndex, animation, loop) {
+		AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var current = this.expandToIndex(trackIndex);
@@ -1201,13 +1201,13 @@ var spine;
 			this.queue.drain();
 			return entry;
 		};
-		AnimationState.prototype.addAnimationByName = function (trackIndex, animationName, loop, delay) {
+		AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
 			var animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null)
 				throw new Error("Animation not found: " + animationName);
-			return this.addAnimation(trackIndex, animation, loop, delay);
+			return this.addAnimationWith(trackIndex, animation, loop, delay);
 		};
-		AnimationState.prototype.addAnimation = function (trackIndex, animation, loop, delay) {
+		AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
 			if (animation == null)
 				throw new Error("animation cannot be null.");
 			var last = this.expandToIndex(trackIndex);
@@ -1225,7 +1225,7 @@ var spine;
 				if (delay <= 0) {
 					var duration = last.animationEnd - last.animationStart;
 					if (duration != 0)
-						delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation);
+						delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
 					else
 						delay = 0;
 				}
@@ -1234,7 +1234,7 @@ var spine;
 			return entry;
 		};
 		AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
-			var entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false);
+			var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1242,7 +1242,7 @@ var spine;
 		AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
 			if (delay <= 0)
 				delay -= mixDuration;
-			var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
+			var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -1260,7 +1260,7 @@ var spine;
 		AnimationState.prototype.expandToIndex = function (index) {
 			if (index < this.tracks.length)
 				return this.tracks[index];
-			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1);
+			spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
 			this.tracks.length = index + 1;
 			return null;
 		};
@@ -1443,41 +1443,47 @@ var spine;
 				var entry = objects[i + 1];
 				switch (type) {
 					case EventType.start:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].start(entry);
+							if (listeners[ii].start)
+								listeners[ii].start(entry);
 						break;
 					case EventType.interrupt:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].interrupt(entry);
+							if (listeners[ii].interrupt)
+								listeners[ii].interrupt(entry);
 						break;
 					case EventType.end:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].end(entry);
+							if (listeners[ii].end)
+								listeners[ii].end(entry);
 					case EventType.dispose:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.end)
 							entry.listener.end(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].dispose(entry);
+							if (listeners[ii].dispose)
+								listeners[ii].dispose(entry);
 						this.animState.trackEntryPool.free(entry);
 						break;
 					case EventType.complete:
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.complete)
 							entry.listener.complete(entry);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].complete(entry);
+							if (listeners[ii].complete)
+								listeners[ii].complete(entry);
 						break;
 					case EventType.event:
 						var event_3 = objects[i++ + 2];
-						if (entry.listener != null)
+						if (entry.listener != null && entry.listener.event)
 							entry.listener.event(entry, event_3);
 						for (var ii = 0; ii < listeners.length; ii++)
-							listeners[ii].event(entry, event_3);
+							if (listeners[ii].event)
+								listeners[ii].event(entry, event_3);
 						break;
 				}
 			}
@@ -7466,7 +7472,7 @@ var spine;
 					skeleton.y = config.y;
 				}
 				var animationState = this.state = new spine.AnimationState(new spine.AnimationStateData(skeleton.data));
-				animationState.setAnimationByName(0, config.animation, true);
+				animationState.setAnimation(0, config.animation, true);
 				if (config.success)
 					config.success(this);
 				this.loaded = true;
@@ -7561,7 +7567,7 @@ var spine;
 			if (!this.loaded)
 				throw new Error("Widget isn't loaded yet");
 			this.skeleton.setToSetupPose();
-			this.state.setAnimationByName(0, animationName, this.config.loop);
+			this.state.setAnimation(0, animationName, this.config.loop);
 		};
 		SpineWidget.loadWidgets = function () {
 			var widgets = document.getElementsByClassName("spine-widget");

spine-ts/core/src/Animation.ts

@@ -215,7 +215,7 @@ module spine {
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
 				else {
 					let r = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
-					r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; // Wrap within -180 and 180.
+					r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360; // Wrap within -180 and 180.
 					bone.rotation += r * alpha;
 				}
 				return;
@@ -229,14 +229,14 @@ module spine {
 				1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
 
 			let r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
-			r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+			r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 			r = prevRotation + r * percent;
 			if (setupPose) {
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
 				bone.rotation = bone.data.rotation + r * alpha;
 			} else {
 				r = bone.data.rotation + r - bone.rotation;
-				r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360;
+				r -= (16384 - ((16384.499999999996 - r / 360) |0)) * 360;
 				bone.rotation += r * alpha;
 			}
 		}

spine-ts/core/src/AnimationState.ts

@@ -238,9 +238,9 @@ module spine {
 					1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
 
 				r2 = frames[frame + RotateTimeline.ROTATION] - prevRotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 				r2 = prevRotation + r2 * percent + bone.data.rotation;
-				r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
+				r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
 			}
 
 			// Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.
@@ -253,7 +253,7 @@ module spine {
 				} else
 					total = timelinesRotation[i];
 			} else {
-				diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
+				diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
 				let lastTotal = 0, lastDiff = 0;
 				if (firstFrame) {
 					lastTotal = 0;
@@ -275,7 +275,7 @@ module spine {
 			}
 			timelinesRotation[i + 1] = diff;
 			r1 += total * alpha;
-			bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360;
+			bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
 		}
 
 		queueEvents (entry: TrackEntry, animationTime: number) {
@@ -358,13 +358,13 @@ module spine {
 			this.queue.start(current);
 		}
 
-		setAnimationByName (trackIndex: number, animationName: string, loop: boolean) {
+		setAnimation (trackIndex: number, animationName: string, loop: boolean) {
 			let animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null) throw new Error("Animation not found: " + animationName);
-			return this.setAnimation(trackIndex, animation, loop);
+			return this.setAnimationWith(trackIndex, animation, loop);
 		}
 
-		setAnimation (trackIndex: number, animation: Animation, loop: boolean) {
+		setAnimationWith (trackIndex: number, animation: Animation, loop: boolean) {
 			if (animation == null) throw new Error("animation cannot be null.");
 			let current = this.expandToIndex(trackIndex);
 			if (current != null) {
@@ -384,13 +384,13 @@ module spine {
 			return entry;
 		}
 
-		addAnimationByName (trackIndex: number, animationName: string, loop: boolean, delay: number) {
+		addAnimation (trackIndex: number, animationName: string, loop: boolean, delay: number) {
 			let animation = this.data.skeletonData.findAnimation(animationName);
 			if (animation == null) throw new Error("Animation not found: " + animationName);
-			return this.addAnimation(trackIndex, animation, loop, delay);
+			return this.addAnimationWith(trackIndex, animation, loop, delay);
 		}
 
-		addAnimation (trackIndex: number, animation: Animation, loop: boolean, delay: number) {
+		addAnimationWith (trackIndex: number, animation: Animation, loop: boolean, delay: number) {
 			if (animation == null) throw new Error("animation cannot be null.");
 
 			let last = this.expandToIndex(trackIndex);
@@ -409,7 +409,7 @@ module spine {
 				if (delay <= 0) {
 					let duration = last.animationEnd - last.animationStart;
 					if (duration != 0)
-						delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation);
+						delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
 					else
 						delay = 0;
 				}
@@ -420,7 +420,7 @@ module spine {
 		}
 
 		setEmptyAnimation (trackIndex: number, mixDuration: number) {
-			let entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false);
+			let entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -428,7 +428,7 @@ module spine {
 
 		addEmptyAnimation (trackIndex: number, mixDuration: number, delay: number) {
 			if (delay <= 0) delay -= mixDuration;
-			let entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
+			let entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
 			entry.mixDuration = mixDuration;
 			entry.trackEnd = mixDuration;
 			return entry;
@@ -446,7 +446,7 @@ module spine {
 
 		expandToIndex (index: number) {
 			if (index < this.tracks.length) return this.tracks[index];
-			Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1);
+			Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
 			this.tracks.length = index + 1;
 			return null;
 		}
@@ -659,36 +659,36 @@ module spine {
 				let entry = objects[i + 1] as TrackEntry;
 				switch (type) {
 				case EventType.start:
-					if (entry.listener != null) entry.listener.end(entry);
+					if (entry.listener != null && entry.listener.end) entry.listener.end(entry);
 					for (let ii = 0; ii < listeners.length; ii++)
-						listeners[ii].start(entry);
+						if (listeners[ii].start) listeners[ii].start(entry);
 					break;
 				case EventType.interrupt:
-					if (entry.listener != null) entry.listener.end(entry);
+					if (entry.listener != null && entry.listener.end) entry.listener.end(entry);
 					for (let ii = 0; ii < listeners.length; ii++)
-						listeners[ii].interrupt(entry);
+						if (listeners[ii].interrupt)listeners[ii].interrupt(entry);
 					break;
 				case EventType.end:
-					if (entry.listener != null) entry.listener.end(entry);
+					if (entry.listener != null && entry.listener.end) entry.listener.end(entry);
 					for (let ii = 0; ii < listeners.length; ii++)
-						listeners[ii].end(entry);
+						if (listeners[ii].end) listeners[ii].end(entry);
 					// Fall through.
 				case EventType.dispose:
-					if (entry.listener != null) entry.listener.end(entry);
+					if (entry.listener != null && entry.listener.end) entry.listener.end(entry);
 					for (let ii = 0; ii < listeners.length; ii++)
-						listeners[ii].dispose(entry);
+						if (listeners[ii].dispose) listeners[ii].dispose(entry);
 					this.animState.trackEntryPool.free(entry);
 					break;
 				case EventType.complete:
-					if (entry.listener != null) entry.listener.complete(entry);
+					if (entry.listener != null && entry.listener.complete) entry.listener.complete(entry);
 					for (let ii = 0; ii < listeners.length; ii++)
-						listeners[ii].complete(entry);
+						if (listeners[ii].complete) listeners[ii].complete(entry);
 					break;
 				case EventType.event:
 					let event = objects[i++ + 2] as Event;
-					if (entry.listener != null) entry.listener.event(entry, event);
+					if (entry.listener != null && entry.listener.event) entry.listener.event(entry, event);
 					for (let ii = 0; ii < listeners.length; ii++)
-						listeners[ii].event(entry, event);
+						if (listeners[ii].event) listeners[ii].event(entry, event);
 					break;
 				}
 			}

spine-ts/webgl/demos/hoverboard.js

@@ -5,31 +5,31 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
 	var COLOR_OUTER_SELECTED = new spine.Color(0.0, 0, 0.8, 0.8);
 
 	var canvas, gl, renderer, input, assetManager;
-	var skeleton, state, bounds;		
+	var skeleton, state, bounds;
 	var timeKeeper, loadingScreen;
-	var target = null;	
+	var target = null;
 	var hoverTargets = [];
 	var controlBones = ["hoverboard controller", "hip controller", "board target"];
-	var coords = new spine.webgl.Vector3(), temp = new spine.webgl.Vector3(), temp2 = new spine.Vector2(), temp3 = new spine.webgl.Vector3();	
+	var coords = new spine.webgl.Vector3(), temp = new spine.webgl.Vector3(), temp2 = new spine.Vector2(), temp3 = new spine.webgl.Vector3();
 	var isPlaying = true;
 
 	var DEMO_NAME = "HoverboardDemo";
 
-	if (!bgColor) bgColor = new spine.Color(235 / 255, 239 / 255, 244 / 255, 1);	
+	if (!bgColor) bgColor = new spine.Color(235 / 255, 239 / 255, 244 / 255, 1);
 
 	function init () {
 		canvas = document.getElementById("hoverboard-canvas");
 		canvas.width = canvas.clientWidth; canvas.height = canvas.clientHeight;
-		gl = canvas.getContext("webgl", { alpha: false }) || canvas.getContext("experimental-webgl", { alpha: false });	
+		gl = canvas.getContext("webgl", { alpha: false }) || canvas.getContext("experimental-webgl", { alpha: false });
 
 		renderer = new spine.webgl.SceneRenderer(canvas, gl);
 		assetManager = spineDemos.assetManager;
-		var textureLoader = function(img) { return new spine.webgl.GLTexture(gl, img); };				
+		var textureLoader = function(img) { return new spine.webgl.GLTexture(gl, img); };
 		assetManager.loadTexture(DEMO_NAME, textureLoader, "atlas1.png");
 		assetManager.loadText(DEMO_NAME, "atlas1.atlas");
-		assetManager.loadJson(DEMO_NAME, "demos.json");		
+		assetManager.loadJson(DEMO_NAME, "demos.json");
 		input = new spine.webgl.Input(canvas);
-		timeKeeper = new spine.TimeKeeper();		
+		timeKeeper = new spine.TimeKeeper();
 		loadingScreen = new spine.webgl.LoadingScreen(renderer);
 		requestAnimationFrame(load);
 	}
@@ -38,7 +38,7 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
 		timeKeeper.update();
 		if (assetManager.isLoadingComplete(DEMO_NAME)) {
 			var atlas = new spine.TextureAtlas(assetManager.get(DEMO_NAME, "atlas1.atlas"), function(path) {
-				return assetManager.get(DEMO_NAME, path);		
+				return assetManager.get(DEMO_NAME, path);
 			});
 			var atlasLoader = new spine.AtlasAttachmentLoader(atlas);
 			var skeletonJson = new spine.SkeletonJson(atlasLoader);
@@ -51,7 +51,7 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
 			var offset = new spine.Vector2();
 			bounds = new spine.Vector2();
 			skeleton.getBounds(offset, bounds);
-			for (var i = 0; i < controlBones.length; i++) hoverTargets.push(null);			
+			for (var i = 0; i < controlBones.length; i++) hoverTargets.push(null);
 
 			renderer.camera.position.x = offset.x + bounds.x / 2;
 			renderer.camera.position.y = offset.y + bounds.y / 2;
@@ -69,14 +69,14 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
 		}
 	}
 
-	function setupUI() {		
+	function setupUI() {
 		var checkbox = $("#hoverboard-drawbones");
 		renderer.skeletonDebugRenderer.drawRegionAttachments = false;
 		renderer.skeletonDebugRenderer.drawPaths = false;
 		renderer.skeletonDebugRenderer.drawBones = false;
 		checkbox.change(function() {
 			renderer.skeletonDebugRenderer.drawPaths = this.checked;
-			renderer.skeletonDebugRenderer.drawBones = this.checked;			
+			renderer.skeletonDebugRenderer.drawBones = this.checked;
 		});
 	}
 
@@ -84,12 +84,12 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
 		input.addListener({
 			down: function(x, y) {
 				isPlaying = false;
-				for (var i = 0; i < controlBones.length; i++) {	
-					var bone = skeleton.findBone(controlBones[i]);				
-					renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);				
-					if (temp.set(skeleton.x + bone.worldX, skeleton.y + bone.worldY, 0).distance(coords) < 30) {
+				for (var i = 0; i < controlBones.length; i++) {
+					var bone = skeleton.findBone(controlBones[i]);
+					renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
+					if (temp.set(bone.worldX, bone.worldY, 0).distance(coords) < 30) {
 						target = bone;
-					}				
+					}
 				}
 			},
 			up: function(x, y) {
@@ -99,35 +99,35 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
 				if (target != null) {
 					renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
 					if (target.parent !== null) {
-						target.parent.worldToLocal(temp2.set(coords.x - skeleton.x, coords.y - skeleton.y));
+						target.parent.worldToLocal(temp2.set(coords.x, coords.y));
 						target.x = temp2.x;
 						target.y = temp2.y;
 					} else {
-						target.x = coords.x - skeleton.x;
-						target.y = coords.y - skeleton.y;
+						target.x = coords.x;
+						target.y = coords.y;
 					}
 				}
 			},
-			moved: function (x, y) { 
-				for (var i = 0; i < controlBones.length; i++) {	
-					var bone = skeleton.findBone(controlBones[i]);				
-					renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);				
-					if (temp.set(skeleton.x + bone.worldX, skeleton.y + bone.worldY, 0).distance(coords) < 30) {
+			moved: function (x, y) {
+				for (var i = 0; i < controlBones.length; i++) {
+					var bone = skeleton.findBone(controlBones[i]);
+					renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
+					if (temp.set(bone.worldX, bone.worldY, 0).distance(coords) < 30) {
 						hoverTargets[i] = bone;
 					} else {
 						hoverTargets[i] = null;
 					}
-				}	
+				}
 			}
 		});
 	}
 
 	function render () {
 		timeKeeper.update();
-		var delta = timeKeeper.delta;	
-	
+		var delta = timeKeeper.delta;
+
 		state.update(delta);
-		state.apply(skeleton);					
+		state.apply(skeleton);
 		skeleton.updateWorldTransform();
 
 		renderer.camera.viewportWidth = bounds.x * 1.2;
@@ -135,18 +135,18 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
 		renderer.resize(spine.webgl.ResizeMode.Fit);
 
 		gl.clearColor(bgColor.r, bgColor.g, bgColor.b, bgColor.a);
-		gl.clear(gl.COLOR_BUFFER_BIT);			
+		gl.clear(gl.COLOR_BUFFER_BIT);
 
-		renderer.begin();				
+		renderer.begin();
 		renderer.drawSkeleton(skeleton, true);
 		renderer.drawSkeletonDebug(skeleton, false, ["root"]);
 		gl.lineWidth(2);
-		for (var i = 0; i < controlBones.length; i++) {		
+		for (var i = 0; i < controlBones.length; i++) {
 			var bone = skeleton.findBone(controlBones[i]);
 			var colorInner = hoverTargets[i] !== null ? spineDemos.HOVER_COLOR_INNER : spineDemos.NON_HOVER_COLOR_INNER;
 			var colorOuter = hoverTargets[i] !== null ? spineDemos.HOVER_COLOR_OUTER : spineDemos.NON_HOVER_COLOR_OUTER;
-			renderer.circle(true, skeleton.x + bone.worldX, skeleton.y + bone.worldY, 20, colorInner);			
-			renderer.circle(false, skeleton.x + bone.worldX, skeleton.y + bone.worldY, 20, colorOuter);			
+			renderer.circle(true, bone.worldX, bone.worldY, 20, colorInner);
+			renderer.circle(false, bone.worldX, bone.worldY, 20, colorOuter);
 		}
 		renderer.end();
 		gl.lineWidth(1);

spine-ts/webgl/demos/spritesheets.js

@@ -5,7 +5,7 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
 	var canvas, gl, renderer, input, assetManager;
 	var skeleton, animationState, offset, bounds;
 	var skeletonSeq, walkAnim, walkLastTime = 0, walkLastTimePrecise = 0;
-	var skeletonAtlas;	
+	var skeletonAtlas;
 	var viewportWidth, viewportHeight;
 	var frames = [], currFrame = 0, frameTime = 0, frameScale = 0, FPS = 30;
 	var timeKeeper, loadingScreen, input;
@@ -17,17 +17,17 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
 
 	function init () {
 		canvas = document.getElementById("spritesheets-canvas");
-		canvas.width = canvas.clientWidth; canvas.height = canvas.clientHeight;	
-		gl = canvas.getContext("webgl", { alpha: false }) || canvas.getContext("experimental-webgl", { alpha: false });	
+		canvas.width = canvas.clientWidth; canvas.height = canvas.clientHeight;
+		gl = canvas.getContext("webgl", { alpha: false }) || canvas.getContext("experimental-webgl", { alpha: false });
 
 		renderer = new spine.webgl.SceneRenderer(canvas, gl);
 		assetManager = spineDemos.assetManager;
-		var textureLoader = function(img) { return new spine.webgl.GLTexture(gl, img); };		
+		var textureLoader = function(img) { return new spine.webgl.GLTexture(gl, img); };
 		assetManager.loadTexture(DEMO_NAME, textureLoader, "atlas1.png");
 		assetManager.loadText(DEMO_NAME, "atlas1.atlas");
-		assetManager.loadJson(DEMO_NAME, "demos.json");	
+		assetManager.loadJson(DEMO_NAME, "demos.json");
 		timeKeeper = new spine.TimeKeeper();
-		input = new spine.webgl.Input(canvas);	
+		input = new spine.webgl.Input(canvas);
 		loadingScreen = new spine.webgl.LoadingScreen(renderer);
 		requestAnimationFrame(load);
 	}
@@ -36,8 +36,8 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
 		timeKeeper.update();
 		if (assetManager.isLoadingComplete(DEMO_NAME)) {
 			skeletonAtlas = new spine.TextureAtlas(assetManager.get(DEMO_NAME, "atlas1.atlas"), function(path) {
-				return assetManager.get(DEMO_NAME, path);		
-			});			
+				return assetManager.get(DEMO_NAME, path);
+			});
 			var atlasLoader = new spine.AtlasAttachmentLoader(skeletonAtlas);
 			var skeletonJson = new spine.SkeletonJson(atlasLoader);
 			var skeletonData = skeletonJson.readSkeletonData(assetManager.get(DEMO_NAME, "demos.json").raptor);
@@ -55,9 +55,9 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
 
 			skeletonSeq = new spine.Skeleton(skeletonData);
 			walkAnim = skeletonSeq.data.findAnimation("walk");
-			walkAnim.apply(skeletonSeq, 0, 0, true, null);
+			walkAnim.apply(skeletonSeq, 0, 0, true, null, 1, true, false);
 			skeletonSeq.x += bounds.x + 150;
-			
+
 			viewportWidth = ((700 + bounds.x) - offset.x);
 			viewportHeight = ((0 + bounds.y) - offset.y);
 			resize();
@@ -71,7 +71,7 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
 			loadingScreen.draw();
 			requestAnimationFrame(load);
 		}
-	}	
+	}
 
 	function setupUI () {
 		timeSlider = $("#spritesheets-timeslider").data("slider");
@@ -95,7 +95,7 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
 			setAnimation("jump");
 		});
 	}
-	
+
 	function setAnimation (name) {
 		animationState.setAnimation(0, name, false);
 		animationState.addAnimation(0, "walk", true, 0);
@@ -103,7 +103,7 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
 
 	function resize () {
 		renderer.camera.position.x = offset.x + viewportWidth / 2 - 25;
-		renderer.camera.position.y = offset.y + viewportHeight / 2  - 160;	
+		renderer.camera.position.y = offset.y + viewportHeight / 2  - 160;
 		renderer.camera.viewportWidth = viewportWidth * 1.2;
 		renderer.camera.viewportHeight = viewportHeight * 1.2;
 		renderer.resize(spine.webgl.ResizeMode.Fit);
@@ -120,21 +120,21 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
 			var oldValue = timeSliderLabel.textContent;
 			var newValue = Math.round(timeSlider.get() * 100) + "%";
 			if (oldValue !== newValue) timeSliderLabel.textContent = newValue;
-		} 	
+		}
 
 		var animationDuration = animationState.getCurrent(0).animation.duration;
-		playTime += delta;			
+		playTime += delta;
 		while (playTime >= animationDuration) {
 			playTime -= animationDuration;
 		}
 
-		walkLastTimePrecise += delta;				
+		walkLastTimePrecise += delta;
 		while (walkLastTimePrecise - walkLastTime > 1 / FPS) {
 			var newWalkTime = walkLastTime + 1 / FPS;
-			walkAnim.apply(skeletonSeq, walkLastTime, newWalkTime, true, null);
+			walkAnim.apply(skeletonSeq, walkLastTime, newWalkTime, true, null, 1, true, false);
 			walkLastTime = newWalkTime;
-		}								
-		skeletonSeq.updateWorldTransform();					
+		}
+		skeletonSeq.updateWorldTransform();
 
 		animationState.update(delta);
 		var current = animationState.getCurrent(0);
@@ -143,12 +143,12 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
 		skeleton.updateWorldTransform();
 
 		gl.clearColor(bgColor.r, bgColor.g, bgColor.b, bgColor.a);
-		gl.clear(gl.COLOR_BUFFER_BIT);	
+		gl.clear(gl.COLOR_BUFFER_BIT);
 
 		renderer.begin();
 		var frame = frames[currFrame];
 		renderer.drawSkeleton(skeleton, true);
-		renderer.drawSkeleton(skeletonSeq, true);		
+		renderer.drawSkeleton(skeletonSeq, true);
 		renderer.end();
 
 		loadingScreen.draw(true);

spine-ts/webgl/example/index.html

@@ -38,8 +38,8 @@ function init () {
 	canvas.width = window.innerWidth;
 	canvas.height = window.innerHeight;
 	var config = { alpha: false };
-	gl = canvas.getContext("webgl", config) || canvas.getContext("experimental-webgl", config);	
-	
+	gl = canvas.getContext("webgl", config) || canvas.getContext("experimental-webgl", config);
+
 	// Create a simple shader, mesh, model-view-projection matrix and SkeletonRenderer.
 	shader = spine.webgl.Shader.newColoredTextured(gl);
 	batcher = new spine.webgl.PolygonBatcher(gl);
@@ -71,7 +71,7 @@ function init () {
 	assetManager.loadTexture("assets/goblins.png");
 	assetManager.loadText("assets/vine.json");
 	assetManager.loadText("assets/vine.atlas");
-	assetManager.loadTexture("assets/vine.png");	
+	assetManager.loadTexture("assets/vine.png");
 	assetManager.loadText("assets/stretchyman.json");
 	assetManager.loadText("assets/stretchyman.atlas");
 	assetManager.loadTexture("assets/stretchyman.png");
@@ -82,11 +82,11 @@ function load () {
 	// Wait until the AssetManager has loaded all resources, then load the skeletons.
 	if (assetManager.isLoadingComplete()) {
 		skeletons["raptor"] = loadSkeleton("raptor", "walk", false);
-		skeletons["spineboy"] = loadSkeleton("spineboy", "run", false);		
+		skeletons["spineboy"] = loadSkeleton("spineboy", "run", false);
 		skeletons["tank"] = loadSkeleton("tank", "drive", false);
 		skeletons["goblins"] = loadSkeleton("goblins-mesh", "walk", false, "goblin");
 		skeletons["vine"] = loadSkeleton("vine", "animation", false);
-		skeletons["stretchyman"] = loadSkeleton("stretchyman", "sneak", false);				
+		skeletons["stretchyman"] = loadSkeleton("stretchyman", "sneak", false);
 		setupUI();
 		requestAnimationFrame(render);
 	} else {
@@ -100,7 +100,7 @@ function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
 	// Load the texture atlas using name.atlas and name.png from the AssetManager.
 	// The function passed to TextureAtlas is used to resolve relative paths.
 	atlas = new spine.TextureAtlas(assetManager.get("assets/" + name + ".atlas"), function(path) {
-		return assetManager.get("assets/" + path);		
+		return assetManager.get("assets/" + path);
 	});
 
 	// Create a AtlasAttachmentLoader that resolves region, mesh, boundingbox and path attachments
@@ -108,28 +108,34 @@ function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
 
 	// Create a SkeletonJson instance for parsing the .json file.
 	var skeletonJson = new spine.SkeletonJson(atlasLoader);
-	
-	// Set the scale to apply during parsing, parse the file, and create a new skeleton.	
+
+	// Set the scale to apply during parsing, parse the file, and create a new skeleton.
 	var skeletonData = skeletonJson.readSkeletonData(assetManager.get("assets/" + name + ".json"));
 	var skeleton = new spine.Skeleton(skeletonData);
 	skeleton.setSkinByName(skin);
-	var bounds = calculateBounds(skeleton);	
+	var bounds = calculateBounds(skeleton);
 
 	// Create an AnimationState, and set the initial animation in looping mode.
 	var animationState = new spine.AnimationState(new spine.AnimationStateData(skeleton.data));
 	animationState.setAnimation(0, initialAnimation, true);
 	animationState.addListener({
-		event: function(trackIndex, event) {
-			// console.log("Event on track " + trackIndex + ": " + JSON.stringify(event));
+		start: function(track) {
+			console.log("Animation on track " + track.trackIndex + " started");
+		},
+		interrupt: function(track) {
+			console.log("Animation on track " + track.trackIndex + " interrupted");
 		},
-		complete: function(trackIndex, loopCount) {
-			// console.log("Animation on track " + trackIndex + " completed, loop count: " + loopCount);
+		end: function(track) {
+			console.log("Animation on track " + track.trackIndex + " ended");
 		},
-		start: function(trackIndex) {
-			// console.log("Animation on track " + trackIndex + " started");
+		disposed: function(track) {
+			console.log("Animation on track " + track.trackIndex + " disposed");
 		},
-		end: function(trackIndex) {
-			// console.log("Animation on track " + trackIndex + " ended");
+		complete: function(track) {
+			console.log("Animation on track " + track.trackIndex + " completed");
+		},
+		event: function(track, event) {
+			console.log("Event on track " + track.trackIndex + ": " + JSON.stringify(event));
 		}
 	})
 
@@ -137,7 +143,7 @@ function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
 	return { skeleton: skeleton, state: animationState, bounds: bounds, premultipliedAlpha: premultipliedAlpha };
 }
 
-function calculateBounds(skeleton) {	
+function calculateBounds(skeleton) {
 	skeleton.setToSetupPose();
 	skeleton.updateWorldTransform();
 	var offset = new spine.Vector2();
@@ -173,7 +179,7 @@ function setupUI () {
 			var skeleton = skeletons[activeSkeleton].skeleton;
 			var animationName = $("#animationList option:selected").text();
 			skeleton.setToSetupPose();
-			state.setAnimation(0, animationName, true);			
+			state.setAnimation(0, animationName, true);
 		})
 	}
 
@@ -190,7 +196,7 @@ function setupUI () {
 			skinList.append(option);
 		}
 
-		skinList.change(function() {			
+		skinList.change(function() {
 			var skeleton = skeletons[activeSkeleton].skeleton;
 			var skinName = $("#skinList option:selected").text();
 			skeleton.setSkinByName(skinName);
@@ -236,7 +242,7 @@ function render () {
 	skeletonRenderer.premultipliedAlpha = premultipliedAlpha;
 	skeletonRenderer.draw(batcher, skeleton);
 	batcher.end();
-		
+
 	shader.unbind();
 
 	// draw debug information

spine-ts/widget/src/Widget.ts

@@ -143,7 +143,7 @@ module spine {
 				}
 
 				var animationState = this.state = new spine.AnimationState(new spine.AnimationStateData(skeleton.data));
-				animationState.setAnimationByName(0, config.animation, true);
+				animationState.setAnimation(0, config.animation, true);
 				if (config.success) config.success(this);
 				this.loaded = true;
 				requestAnimationFrame(() => { this.render(); });
@@ -246,7 +246,7 @@ module spine {
 		setAnimation (animationName: string) {
 			if (!this.loaded) throw new Error("Widget isn't loaded yet");
 			this.skeleton.setToSetupPose();
-			this.state.setAnimationByName(0, animationName, this.config.loop);
+			this.state.setAnimation(0, animationName, this.config.loop);
 		}