[ts] Fixed first frame setup pose reset in all timeline implementations

spine-c/include/spine/AnimationState.h

@@ -76,24 +76,30 @@ struct spTrackEntry {
 #endif
 };
 
+typedef struct spEventQueue spEventQueue;
+
 struct spAnimationState {
 	spAnimationStateData* const data;
-	float timeScale;
-	spAnimationStateListener listener;
 
 	int tracksCount;
 	spTrackEntry** tracks;
 
-	void* rendererObject;
+	spAnimationStateListener listener;
+
+	float timeScale;
 
 #ifdef __cplusplus
 	spAnimationState() :
 		data(0),
-		timeScale(0),
-		listener(0),
-		tracksCount(0),
 		tracks(0),
-		rendererObject(0) {
+		tracksCount(0),
+		events(0),
+		eventsCount(0),
+		listener(0),
+		queue(0),
+		propertyIDs(0),
+		animationsChanged(0),
+		timeScale(0) {
 	}
 #endif
 };
@@ -119,14 +125,21 @@ spTrackEntry* spAnimationState_addAnimationByName (spAnimationState* self, int t
 		int/*bool*/loop, float delay);
 spTrackEntry* spAnimationState_addAnimation (spAnimationState* self, int trackIndex, spAnimation* animation, int/*bool*/loop,
 		float delay);
+spTrackEntry* spAnimationState_setEmptyAnimation(spAnimationState* self, int trackIndex, float mixDuration);
+spTrackEntry* spAnimationState_addEmptyAnimation(spAnimationState* self, int trackIndex, float mixDuration, float delay);
+spTrackEntry* spAnimationState_setEmptyAnimations(spAnimationState* self, float mixDuration);
 
 spTrackEntry* spAnimationState_getCurrent (spAnimationState* self, int trackIndex);
 
+spTrackEntry* spAnimationState_clearListenerNotifications(spAnimationState* self);
+
 #ifdef SPINE_SHORT_NAMES
 typedef spEventType EventType;
 #define ANIMATION_START SP_ANIMATION_START
+#define ANIMATION_INTERRUPT SP_ANIMATION_INTERRUPT
 #define ANIMATION_END SP_ANIMATION_END
 #define ANIMATION_COMPLETE SP_ANIMATION_COMPLETE
+#define ANIMATION_DISPOSE SP_ANIMATION_DISPOSE
 #define ANIMATION_EVENT SP_ANIMATION_EVENT
 typedef spAnimationStateListener AnimationStateListener;
 typedef spTrackEntry TrackEntry;
@@ -141,7 +154,11 @@ typedef spAnimationState AnimationState;
 #define AnimationState_setAnimation(...) spAnimationState_setAnimation(__VA_ARGS__)
 #define AnimationState_addAnimationByName(...) spAnimationState_addAnimationByName(__VA_ARGS__)
 #define AnimationState_addAnimation(...) spAnimationState_addAnimation(__VA_ARGS__)
+#define AnimationState_setEmptyAnimation(...) spAnimatinState_setEmptyAnimation(__VA_ARGS__)
+#define AnimationState_addEmptyAnimation(...) spAnimatinState_addEmptyAnimation(__VA_ARGS__)
+#define AnimationState_setEmptyAnimations(...) spAnimatinState_setEmptyAnimations(__VA_ARGS__)
 #define AnimationState_getCurrent(...) spAnimationState_getCurrent(__VA_ARGS__)
+#define AnimationState_clearListenerNotifications(...) spAnimatinState_clearListenerNotifications(__VA_ARGS__)
 #endif
 
 #ifdef __cplusplus

spine-c/include/spine/extension.h

@@ -173,15 +173,27 @@ char* _readFile (const char* path, int* length);
 
 typedef struct _spAnimationState {
 	spAnimationState super;
+
+	int eventsCount;
 	spEvent** events;
 
+	spEventQueue* queue;
+
+	void* propertyIDs;
+
+	int /*boolean*/ animationsChanged;
+
 	spTrackEntry* (*createTrackEntry) (spAnimationState* self);
 	void (*disposeTrackEntry) (spTrackEntry* entry);
 
 #ifdef __cplusplus
 	_spAnimationState() :
 		super(),
+		eventsCount(0),
 		events(0),
+		queue(0),
+		propertyIDs(0),
+		animationsChanged(0),
 		createTrackEntry(0),
 		disposeTrackEntry(0) {
 	}

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

@@ -196,6 +196,16 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, attachmentName: string): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
+	class DeformTimeline extends CurveTimeline {
+		slotIndex: number;
+		attachment: VertexAttachment;
+		frames: ArrayLike<number>;
+		frameVertices: Array<ArrayLike<number>>;
+		constructor(frameCount: number);
+		getPropertyId(): number;
+		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
+		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
+	}
 	class EventTimeline implements Timeline {
 		frames: ArrayLike<number>;
 		events: Array<Event>;
@@ -214,16 +224,6 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
-	class DeformTimeline extends CurveTimeline {
-		slotIndex: number;
-		attachment: VertexAttachment;
-		frames: ArrayLike<number>;
-		frameVertices: Array<ArrayLike<number>>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
-	}
 	class IkConstraintTimeline extends CurveTimeline {
 		static ENTRIES: number;
 		static PREV_TIME: number;

spine-ts/build/spine-all.js

@@ -515,9 +515,12 @@ var spine;
 		};
 		RotateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					bone.rotation = bone.data.rotation;
+				return;
+			}
 			if (time >= frames[frames.length - RotateTimeline.ENTRIES]) {
 				if (setupPose)
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
@@ -569,9 +572,14 @@ var spine;
 		};
 		TranslateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.x = bone.data.x;
+					bone.y = bone.data.y;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - TranslateTimeline.ENTRIES]) {
 				x = frames[frames.length + TranslateTimeline.PREV_X];
@@ -614,9 +622,14 @@ var spine;
 		};
 		ScaleTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.scaleX = bone.data.scaleX;
+					bone.scaleY = bone.data.scaleY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ScaleTimeline.ENTRIES]) {
 				x = frames[frames.length + ScaleTimeline.PREV_X] * bone.data.scaleX;
@@ -670,9 +683,14 @@ var spine;
 		};
 		ShearTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.shearX = bone.data.shearX;
+					bone.shearY = bone.data.shearY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ShearTimeline.ENTRIES]) {
 				x = frames[frames.length + ShearTimeline.PREV_X];
@@ -717,9 +735,13 @@ var spine;
 			this.frames[frameIndex + ColorTimeline.A] = a;
 		};
 		ColorTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose)
+					slot.color.setFromColor(slot.data.color);
 				return;
+			}
 			var r = 0, g = 0, b = 0, a = 0;
 			if (time >= frames[frames.length - ColorTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -741,7 +763,6 @@ var spine;
 				b += (frames[frame + ColorTimeline.B] - b) * percent;
 				a += (frames[frame + ColorTimeline.A] - a) * percent;
 			}
-			var slot = skeleton.slots[this.slotIndex];
 			if (alpha == 1)
 				slot.color.set(r, g, b, a);
 			else {
@@ -780,15 +801,20 @@ var spine;
 			this.attachmentNames[frameIndex] = attachmentName;
 		};
 		AttachmentTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			if (mixingOut && setupPose) {
-				var slot = skeleton.slots[this.slotIndex];
 				var attachmentName_1 = slot.data.attachmentName;
 				slot.setAttachment(attachmentName_1 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_1));
 				return;
 			}
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose) {
+					var attachmentName_2 = slot.data.attachmentName;
+					slot.setAttachment(attachmentName_2 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_2));
+				}
 				return;
+			}
 			var frameIndex = 0;
 			if (time >= frames[frames.length - 1])
 				frameIndex = frames.length - 1;
@@ -801,93 +827,6 @@ var spine;
 		return AttachmentTimeline;
 	}());
 	spine.AttachmentTimeline = AttachmentTimeline;
-	var EventTimeline = (function () {
-		function EventTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.events = new Array(frameCount);
-		}
-		EventTimeline.prototype.getPropertyId = function () {
-			return TimelineType.event << 24;
-		};
-		EventTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		EventTimeline.prototype.setFrame = function (frameIndex, event) {
-			this.frames[frameIndex] = event.time;
-			this.events[frameIndex] = event;
-		};
-		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (firedEvents == null)
-				return;
-			var frames = this.frames;
-			var frameCount = this.frames.length;
-			if (lastTime > time) {
-				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
-				lastTime = -1;
-			}
-			else if (lastTime >= frames[frameCount - 1])
-				return;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (lastTime < frames[0])
-				frame = 0;
-			else {
-				frame = Animation.binarySearch(frames, lastTime);
-				var frameTime = frames[frame];
-				while (frame > 0) {
-					if (frames[frame - 1] != frameTime)
-						break;
-					frame--;
-				}
-			}
-			for (; frame < frameCount && time >= frames[frame]; frame++)
-				firedEvents.push(this.events[frame]);
-		};
-		return EventTimeline;
-	}());
-	spine.EventTimeline = EventTimeline;
-	var DrawOrderTimeline = (function () {
-		function DrawOrderTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.drawOrders = new Array(frameCount);
-		}
-		DrawOrderTimeline.prototype.getPropertyId = function () {
-			return TimelineType.drawOrder << 24;
-		};
-		DrawOrderTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
-			this.frames[frameIndex] = time;
-			this.drawOrders[frameIndex] = drawOrder;
-		};
-		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (mixingOut && setupPose) {
-				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
-				return;
-			}
-			var frames = this.frames;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (time >= frames[frames.length - 1])
-				frame = frames.length - 1;
-			else
-				frame = Animation.binarySearch(frames, time) - 1;
-			var drawOrder = skeleton.drawOrder;
-			var slots = skeleton.slots;
-			var drawOrderToSetupIndex = this.drawOrders[frame];
-			if (drawOrderToSetupIndex == null)
-				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
-			else {
-				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
-					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
-			}
-		};
-		return DrawOrderTimeline;
-	}());
-	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var DeformTimeline = (function (_super) {
 		__extends(DeformTimeline, _super);
 		function DeformTimeline(frameCount) {
@@ -908,11 +847,14 @@ var spine;
 			if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
 				return;
 			var frames = this.frames;
-			if (time < frames[0])
+			var verticesArray = slot.attachmentVertices;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.setArraySize(verticesArray, 0);
 				return;
+			}
 			var frameVertices = this.frameVertices;
 			var vertexCount = frameVertices[0].length;
-			var verticesArray = slot.attachmentVertices;
 			if (verticesArray.length != vertexCount)
 				alpha = 1;
 			var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
@@ -978,6 +920,96 @@ var spine;
 		return DeformTimeline;
 	}(CurveTimeline));
 	spine.DeformTimeline = DeformTimeline;
+	var EventTimeline = (function () {
+		function EventTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.events = new Array(frameCount);
+		}
+		EventTimeline.prototype.getPropertyId = function () {
+			return TimelineType.event << 24;
+		};
+		EventTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		EventTimeline.prototype.setFrame = function (frameIndex, event) {
+			this.frames[frameIndex] = event.time;
+			this.events[frameIndex] = event;
+		};
+		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			if (firedEvents == null)
+				return;
+			var frames = this.frames;
+			var frameCount = this.frames.length;
+			if (lastTime > time) {
+				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
+				lastTime = -1;
+			}
+			else if (lastTime >= frames[frameCount - 1])
+				return;
+			if (time < frames[0])
+				return;
+			var frame = 0;
+			if (lastTime < frames[0])
+				frame = 0;
+			else {
+				frame = Animation.binarySearch(frames, lastTime);
+				var frameTime = frames[frame];
+				while (frame > 0) {
+					if (frames[frame - 1] != frameTime)
+						break;
+					frame--;
+				}
+			}
+			for (; frame < frameCount && time >= frames[frame]; frame++)
+				firedEvents.push(this.events[frame]);
+		};
+		return EventTimeline;
+	}());
+	spine.EventTimeline = EventTimeline;
+	var DrawOrderTimeline = (function () {
+		function DrawOrderTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.drawOrders = new Array(frameCount);
+		}
+		DrawOrderTimeline.prototype.getPropertyId = function () {
+			return TimelineType.drawOrder << 24;
+		};
+		DrawOrderTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
+			this.frames[frameIndex] = time;
+			this.drawOrders[frameIndex] = drawOrder;
+		};
+		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			var drawOrder = skeleton.drawOrder;
+			var slots = skeleton.slots;
+			if (mixingOut && setupPose) {
+				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frames = this.frames;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frame = 0;
+			if (time >= frames[frames.length - 1])
+				frame = frames.length - 1;
+			else
+				frame = Animation.binarySearch(frames, time) - 1;
+			var drawOrderToSetupIndex = this.drawOrders[frame];
+			if (drawOrderToSetupIndex == null)
+				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
+			else {
+				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
+					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
+			}
+		};
+		return DrawOrderTimeline;
+	}());
+	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var IkConstraintTimeline = (function (_super) {
 		__extends(IkConstraintTimeline, _super);
 		function IkConstraintTimeline(frameCount) {
@@ -995,9 +1027,14 @@ var spine;
 		};
 		IkConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.ikConstraints[this.ikConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.mix = constraint.data.mix;
+					constraint.bendDirection = constraint.data.bendDirection;
+				}
+				return;
+			}
 			if (time >= frames[frames.length - IkConstraintTimeline.ENTRIES]) {
 				if (setupPose) {
 					constraint.mix = constraint.data.mix + (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.data.mix) * alpha;
@@ -1053,9 +1090,17 @@ var spine;
 		};
 		TransformConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.transformConstraints[this.transformConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					var data = constraint.data;
+					constraint.rotateMix = data.rotateMix;
+					constraint.translateMix = data.rotateMix;
+					constraint.scaleMix = data.scaleMix;
+					constraint.shearMix = data.shearMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0, scale = 0, shear = 0;
 			if (time >= frames[frames.length - TransformConstraintTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -1120,9 +1165,12 @@ var spine;
 		};
 		PathConstraintPositionTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.position = constraint.data.position;
+				return;
+			}
 			var position = 0;
 			if (time >= frames[frames.length - PathConstraintPositionTimeline.ENTRIES])
 				position = frames[frames.length + PathConstraintPositionTimeline.PREV_VALUE];
@@ -1155,9 +1203,12 @@ var spine;
 		};
 		PathConstraintSpacingTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.spacing = constraint.data.spacing;
+				return;
+			}
 			var spacing = 0;
 			if (time >= frames[frames.length - PathConstraintSpacingTimeline.ENTRIES])
 				spacing = frames[frames.length + PathConstraintSpacingTimeline.PREV_VALUE];
@@ -1193,9 +1244,14 @@ var spine;
 		};
 		PathConstraintMixTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.rotateMix = constraint.data.rotateMix;
+					constraint.translateMix = constraint.data.translateMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0;
 			if (time >= frames[frames.length - PathConstraintMixTimeline.ENTRIES]) {
 				rotate = frames[frames.length + PathConstraintMixTimeline.PREV_ROTATE];

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

@@ -196,6 +196,16 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, attachmentName: string): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
+	class DeformTimeline extends CurveTimeline {
+		slotIndex: number;
+		attachment: VertexAttachment;
+		frames: ArrayLike<number>;
+		frameVertices: Array<ArrayLike<number>>;
+		constructor(frameCount: number);
+		getPropertyId(): number;
+		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
+		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
+	}
 	class EventTimeline implements Timeline {
 		frames: ArrayLike<number>;
 		events: Array<Event>;
@@ -214,16 +224,6 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
-	class DeformTimeline extends CurveTimeline {
-		slotIndex: number;
-		attachment: VertexAttachment;
-		frames: ArrayLike<number>;
-		frameVertices: Array<ArrayLike<number>>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
-	}
 	class IkConstraintTimeline extends CurveTimeline {
 		static ENTRIES: number;
 		static PREV_TIME: number;

spine-ts/build/spine-canvas.js

@@ -515,9 +515,12 @@ var spine;
 		};
 		RotateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					bone.rotation = bone.data.rotation;
+				return;
+			}
 			if (time >= frames[frames.length - RotateTimeline.ENTRIES]) {
 				if (setupPose)
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
@@ -569,9 +572,14 @@ var spine;
 		};
 		TranslateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.x = bone.data.x;
+					bone.y = bone.data.y;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - TranslateTimeline.ENTRIES]) {
 				x = frames[frames.length + TranslateTimeline.PREV_X];
@@ -614,9 +622,14 @@ var spine;
 		};
 		ScaleTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.scaleX = bone.data.scaleX;
+					bone.scaleY = bone.data.scaleY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ScaleTimeline.ENTRIES]) {
 				x = frames[frames.length + ScaleTimeline.PREV_X] * bone.data.scaleX;
@@ -670,9 +683,14 @@ var spine;
 		};
 		ShearTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.shearX = bone.data.shearX;
+					bone.shearY = bone.data.shearY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ShearTimeline.ENTRIES]) {
 				x = frames[frames.length + ShearTimeline.PREV_X];
@@ -717,9 +735,13 @@ var spine;
 			this.frames[frameIndex + ColorTimeline.A] = a;
 		};
 		ColorTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose)
+					slot.color.setFromColor(slot.data.color);
 				return;
+			}
 			var r = 0, g = 0, b = 0, a = 0;
 			if (time >= frames[frames.length - ColorTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -741,7 +763,6 @@ var spine;
 				b += (frames[frame + ColorTimeline.B] - b) * percent;
 				a += (frames[frame + ColorTimeline.A] - a) * percent;
 			}
-			var slot = skeleton.slots[this.slotIndex];
 			if (alpha == 1)
 				slot.color.set(r, g, b, a);
 			else {
@@ -780,15 +801,20 @@ var spine;
 			this.attachmentNames[frameIndex] = attachmentName;
 		};
 		AttachmentTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			if (mixingOut && setupPose) {
-				var slot = skeleton.slots[this.slotIndex];
 				var attachmentName_1 = slot.data.attachmentName;
 				slot.setAttachment(attachmentName_1 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_1));
 				return;
 			}
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose) {
+					var attachmentName_2 = slot.data.attachmentName;
+					slot.setAttachment(attachmentName_2 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_2));
+				}
 				return;
+			}
 			var frameIndex = 0;
 			if (time >= frames[frames.length - 1])
 				frameIndex = frames.length - 1;
@@ -801,93 +827,6 @@ var spine;
 		return AttachmentTimeline;
 	}());
 	spine.AttachmentTimeline = AttachmentTimeline;
-	var EventTimeline = (function () {
-		function EventTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.events = new Array(frameCount);
-		}
-		EventTimeline.prototype.getPropertyId = function () {
-			return TimelineType.event << 24;
-		};
-		EventTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		EventTimeline.prototype.setFrame = function (frameIndex, event) {
-			this.frames[frameIndex] = event.time;
-			this.events[frameIndex] = event;
-		};
-		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (firedEvents == null)
-				return;
-			var frames = this.frames;
-			var frameCount = this.frames.length;
-			if (lastTime > time) {
-				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
-				lastTime = -1;
-			}
-			else if (lastTime >= frames[frameCount - 1])
-				return;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (lastTime < frames[0])
-				frame = 0;
-			else {
-				frame = Animation.binarySearch(frames, lastTime);
-				var frameTime = frames[frame];
-				while (frame > 0) {
-					if (frames[frame - 1] != frameTime)
-						break;
-					frame--;
-				}
-			}
-			for (; frame < frameCount && time >= frames[frame]; frame++)
-				firedEvents.push(this.events[frame]);
-		};
-		return EventTimeline;
-	}());
-	spine.EventTimeline = EventTimeline;
-	var DrawOrderTimeline = (function () {
-		function DrawOrderTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.drawOrders = new Array(frameCount);
-		}
-		DrawOrderTimeline.prototype.getPropertyId = function () {
-			return TimelineType.drawOrder << 24;
-		};
-		DrawOrderTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
-			this.frames[frameIndex] = time;
-			this.drawOrders[frameIndex] = drawOrder;
-		};
-		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (mixingOut && setupPose) {
-				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
-				return;
-			}
-			var frames = this.frames;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (time >= frames[frames.length - 1])
-				frame = frames.length - 1;
-			else
-				frame = Animation.binarySearch(frames, time) - 1;
-			var drawOrder = skeleton.drawOrder;
-			var slots = skeleton.slots;
-			var drawOrderToSetupIndex = this.drawOrders[frame];
-			if (drawOrderToSetupIndex == null)
-				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
-			else {
-				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
-					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
-			}
-		};
-		return DrawOrderTimeline;
-	}());
-	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var DeformTimeline = (function (_super) {
 		__extends(DeformTimeline, _super);
 		function DeformTimeline(frameCount) {
@@ -908,11 +847,14 @@ var spine;
 			if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
 				return;
 			var frames = this.frames;
-			if (time < frames[0])
+			var verticesArray = slot.attachmentVertices;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.setArraySize(verticesArray, 0);
 				return;
+			}
 			var frameVertices = this.frameVertices;
 			var vertexCount = frameVertices[0].length;
-			var verticesArray = slot.attachmentVertices;
 			if (verticesArray.length != vertexCount)
 				alpha = 1;
 			var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
@@ -978,6 +920,96 @@ var spine;
 		return DeformTimeline;
 	}(CurveTimeline));
 	spine.DeformTimeline = DeformTimeline;
+	var EventTimeline = (function () {
+		function EventTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.events = new Array(frameCount);
+		}
+		EventTimeline.prototype.getPropertyId = function () {
+			return TimelineType.event << 24;
+		};
+		EventTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		EventTimeline.prototype.setFrame = function (frameIndex, event) {
+			this.frames[frameIndex] = event.time;
+			this.events[frameIndex] = event;
+		};
+		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			if (firedEvents == null)
+				return;
+			var frames = this.frames;
+			var frameCount = this.frames.length;
+			if (lastTime > time) {
+				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
+				lastTime = -1;
+			}
+			else if (lastTime >= frames[frameCount - 1])
+				return;
+			if (time < frames[0])
+				return;
+			var frame = 0;
+			if (lastTime < frames[0])
+				frame = 0;
+			else {
+				frame = Animation.binarySearch(frames, lastTime);
+				var frameTime = frames[frame];
+				while (frame > 0) {
+					if (frames[frame - 1] != frameTime)
+						break;
+					frame--;
+				}
+			}
+			for (; frame < frameCount && time >= frames[frame]; frame++)
+				firedEvents.push(this.events[frame]);
+		};
+		return EventTimeline;
+	}());
+	spine.EventTimeline = EventTimeline;
+	var DrawOrderTimeline = (function () {
+		function DrawOrderTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.drawOrders = new Array(frameCount);
+		}
+		DrawOrderTimeline.prototype.getPropertyId = function () {
+			return TimelineType.drawOrder << 24;
+		};
+		DrawOrderTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
+			this.frames[frameIndex] = time;
+			this.drawOrders[frameIndex] = drawOrder;
+		};
+		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			var drawOrder = skeleton.drawOrder;
+			var slots = skeleton.slots;
+			if (mixingOut && setupPose) {
+				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frames = this.frames;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frame = 0;
+			if (time >= frames[frames.length - 1])
+				frame = frames.length - 1;
+			else
+				frame = Animation.binarySearch(frames, time) - 1;
+			var drawOrderToSetupIndex = this.drawOrders[frame];
+			if (drawOrderToSetupIndex == null)
+				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
+			else {
+				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
+					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
+			}
+		};
+		return DrawOrderTimeline;
+	}());
+	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var IkConstraintTimeline = (function (_super) {
 		__extends(IkConstraintTimeline, _super);
 		function IkConstraintTimeline(frameCount) {
@@ -995,9 +1027,14 @@ var spine;
 		};
 		IkConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.ikConstraints[this.ikConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.mix = constraint.data.mix;
+					constraint.bendDirection = constraint.data.bendDirection;
+				}
+				return;
+			}
 			if (time >= frames[frames.length - IkConstraintTimeline.ENTRIES]) {
 				if (setupPose) {
 					constraint.mix = constraint.data.mix + (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.data.mix) * alpha;
@@ -1053,9 +1090,17 @@ var spine;
 		};
 		TransformConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.transformConstraints[this.transformConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					var data = constraint.data;
+					constraint.rotateMix = data.rotateMix;
+					constraint.translateMix = data.rotateMix;
+					constraint.scaleMix = data.scaleMix;
+					constraint.shearMix = data.shearMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0, scale = 0, shear = 0;
 			if (time >= frames[frames.length - TransformConstraintTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -1120,9 +1165,12 @@ var spine;
 		};
 		PathConstraintPositionTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.position = constraint.data.position;
+				return;
+			}
 			var position = 0;
 			if (time >= frames[frames.length - PathConstraintPositionTimeline.ENTRIES])
 				position = frames[frames.length + PathConstraintPositionTimeline.PREV_VALUE];
@@ -1155,9 +1203,12 @@ var spine;
 		};
 		PathConstraintSpacingTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.spacing = constraint.data.spacing;
+				return;
+			}
 			var spacing = 0;
 			if (time >= frames[frames.length - PathConstraintSpacingTimeline.ENTRIES])
 				spacing = frames[frames.length + PathConstraintSpacingTimeline.PREV_VALUE];
@@ -1193,9 +1244,14 @@ var spine;
 		};
 		PathConstraintMixTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.rotateMix = constraint.data.rotateMix;
+					constraint.translateMix = constraint.data.translateMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0;
 			if (time >= frames[frames.length - PathConstraintMixTimeline.ENTRIES]) {
 				rotate = frames[frames.length + PathConstraintMixTimeline.PREV_ROTATE];

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

@@ -108,6 +108,16 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, attachmentName: string): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
+	class DeformTimeline extends CurveTimeline {
+		slotIndex: number;
+		attachment: VertexAttachment;
+		frames: ArrayLike<number>;
+		frameVertices: Array<ArrayLike<number>>;
+		constructor(frameCount: number);
+		getPropertyId(): number;
+		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
+		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
+	}
 	class EventTimeline implements Timeline {
 		frames: ArrayLike<number>;
 		events: Array<Event>;
@@ -126,16 +136,6 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
-	class DeformTimeline extends CurveTimeline {
-		slotIndex: number;
-		attachment: VertexAttachment;
-		frames: ArrayLike<number>;
-		frameVertices: Array<ArrayLike<number>>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
-	}
 	class IkConstraintTimeline extends CurveTimeline {
 		static ENTRIES: number;
 		static PREV_TIME: number;

spine-ts/build/spine-core.js

@@ -168,9 +168,12 @@ var spine;
 		};
 		RotateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					bone.rotation = bone.data.rotation;
+				return;
+			}
 			if (time >= frames[frames.length - RotateTimeline.ENTRIES]) {
 				if (setupPose)
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
@@ -222,9 +225,14 @@ var spine;
 		};
 		TranslateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.x = bone.data.x;
+					bone.y = bone.data.y;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - TranslateTimeline.ENTRIES]) {
 				x = frames[frames.length + TranslateTimeline.PREV_X];
@@ -267,9 +275,14 @@ var spine;
 		};
 		ScaleTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.scaleX = bone.data.scaleX;
+					bone.scaleY = bone.data.scaleY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ScaleTimeline.ENTRIES]) {
 				x = frames[frames.length + ScaleTimeline.PREV_X] * bone.data.scaleX;
@@ -323,9 +336,14 @@ var spine;
 		};
 		ShearTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.shearX = bone.data.shearX;
+					bone.shearY = bone.data.shearY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ShearTimeline.ENTRIES]) {
 				x = frames[frames.length + ShearTimeline.PREV_X];
@@ -370,9 +388,13 @@ var spine;
 			this.frames[frameIndex + ColorTimeline.A] = a;
 		};
 		ColorTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose)
+					slot.color.setFromColor(slot.data.color);
 				return;
+			}
 			var r = 0, g = 0, b = 0, a = 0;
 			if (time >= frames[frames.length - ColorTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -394,7 +416,6 @@ var spine;
 				b += (frames[frame + ColorTimeline.B] - b) * percent;
 				a += (frames[frame + ColorTimeline.A] - a) * percent;
 			}
-			var slot = skeleton.slots[this.slotIndex];
 			if (alpha == 1)
 				slot.color.set(r, g, b, a);
 			else {
@@ -433,15 +454,20 @@ var spine;
 			this.attachmentNames[frameIndex] = attachmentName;
 		};
 		AttachmentTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			if (mixingOut && setupPose) {
-				var slot = skeleton.slots[this.slotIndex];
 				var attachmentName_1 = slot.data.attachmentName;
 				slot.setAttachment(attachmentName_1 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_1));
 				return;
 			}
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose) {
+					var attachmentName_2 = slot.data.attachmentName;
+					slot.setAttachment(attachmentName_2 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_2));
+				}
 				return;
+			}
 			var frameIndex = 0;
 			if (time >= frames[frames.length - 1])
 				frameIndex = frames.length - 1;
@@ -454,93 +480,6 @@ var spine;
 		return AttachmentTimeline;
 	}());
 	spine.AttachmentTimeline = AttachmentTimeline;
-	var EventTimeline = (function () {
-		function EventTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.events = new Array(frameCount);
-		}
-		EventTimeline.prototype.getPropertyId = function () {
-			return TimelineType.event << 24;
-		};
-		EventTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		EventTimeline.prototype.setFrame = function (frameIndex, event) {
-			this.frames[frameIndex] = event.time;
-			this.events[frameIndex] = event;
-		};
-		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (firedEvents == null)
-				return;
-			var frames = this.frames;
-			var frameCount = this.frames.length;
-			if (lastTime > time) {
-				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
-				lastTime = -1;
-			}
-			else if (lastTime >= frames[frameCount - 1])
-				return;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (lastTime < frames[0])
-				frame = 0;
-			else {
-				frame = Animation.binarySearch(frames, lastTime);
-				var frameTime = frames[frame];
-				while (frame > 0) {
-					if (frames[frame - 1] != frameTime)
-						break;
-					frame--;
-				}
-			}
-			for (; frame < frameCount && time >= frames[frame]; frame++)
-				firedEvents.push(this.events[frame]);
-		};
-		return EventTimeline;
-	}());
-	spine.EventTimeline = EventTimeline;
-	var DrawOrderTimeline = (function () {
-		function DrawOrderTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.drawOrders = new Array(frameCount);
-		}
-		DrawOrderTimeline.prototype.getPropertyId = function () {
-			return TimelineType.drawOrder << 24;
-		};
-		DrawOrderTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
-			this.frames[frameIndex] = time;
-			this.drawOrders[frameIndex] = drawOrder;
-		};
-		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (mixingOut && setupPose) {
-				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
-				return;
-			}
-			var frames = this.frames;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (time >= frames[frames.length - 1])
-				frame = frames.length - 1;
-			else
-				frame = Animation.binarySearch(frames, time) - 1;
-			var drawOrder = skeleton.drawOrder;
-			var slots = skeleton.slots;
-			var drawOrderToSetupIndex = this.drawOrders[frame];
-			if (drawOrderToSetupIndex == null)
-				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
-			else {
-				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
-					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
-			}
-		};
-		return DrawOrderTimeline;
-	}());
-	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var DeformTimeline = (function (_super) {
 		__extends(DeformTimeline, _super);
 		function DeformTimeline(frameCount) {
@@ -561,11 +500,14 @@ var spine;
 			if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
 				return;
 			var frames = this.frames;
-			if (time < frames[0])
+			var verticesArray = slot.attachmentVertices;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.setArraySize(verticesArray, 0);
 				return;
+			}
 			var frameVertices = this.frameVertices;
 			var vertexCount = frameVertices[0].length;
-			var verticesArray = slot.attachmentVertices;
 			if (verticesArray.length != vertexCount)
 				alpha = 1;
 			var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
@@ -631,6 +573,96 @@ var spine;
 		return DeformTimeline;
 	}(CurveTimeline));
 	spine.DeformTimeline = DeformTimeline;
+	var EventTimeline = (function () {
+		function EventTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.events = new Array(frameCount);
+		}
+		EventTimeline.prototype.getPropertyId = function () {
+			return TimelineType.event << 24;
+		};
+		EventTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		EventTimeline.prototype.setFrame = function (frameIndex, event) {
+			this.frames[frameIndex] = event.time;
+			this.events[frameIndex] = event;
+		};
+		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			if (firedEvents == null)
+				return;
+			var frames = this.frames;
+			var frameCount = this.frames.length;
+			if (lastTime > time) {
+				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
+				lastTime = -1;
+			}
+			else if (lastTime >= frames[frameCount - 1])
+				return;
+			if (time < frames[0])
+				return;
+			var frame = 0;
+			if (lastTime < frames[0])
+				frame = 0;
+			else {
+				frame = Animation.binarySearch(frames, lastTime);
+				var frameTime = frames[frame];
+				while (frame > 0) {
+					if (frames[frame - 1] != frameTime)
+						break;
+					frame--;
+				}
+			}
+			for (; frame < frameCount && time >= frames[frame]; frame++)
+				firedEvents.push(this.events[frame]);
+		};
+		return EventTimeline;
+	}());
+	spine.EventTimeline = EventTimeline;
+	var DrawOrderTimeline = (function () {
+		function DrawOrderTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.drawOrders = new Array(frameCount);
+		}
+		DrawOrderTimeline.prototype.getPropertyId = function () {
+			return TimelineType.drawOrder << 24;
+		};
+		DrawOrderTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
+			this.frames[frameIndex] = time;
+			this.drawOrders[frameIndex] = drawOrder;
+		};
+		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			var drawOrder = skeleton.drawOrder;
+			var slots = skeleton.slots;
+			if (mixingOut && setupPose) {
+				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frames = this.frames;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frame = 0;
+			if (time >= frames[frames.length - 1])
+				frame = frames.length - 1;
+			else
+				frame = Animation.binarySearch(frames, time) - 1;
+			var drawOrderToSetupIndex = this.drawOrders[frame];
+			if (drawOrderToSetupIndex == null)
+				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
+			else {
+				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
+					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
+			}
+		};
+		return DrawOrderTimeline;
+	}());
+	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var IkConstraintTimeline = (function (_super) {
 		__extends(IkConstraintTimeline, _super);
 		function IkConstraintTimeline(frameCount) {
@@ -648,9 +680,14 @@ var spine;
 		};
 		IkConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.ikConstraints[this.ikConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.mix = constraint.data.mix;
+					constraint.bendDirection = constraint.data.bendDirection;
+				}
+				return;
+			}
 			if (time >= frames[frames.length - IkConstraintTimeline.ENTRIES]) {
 				if (setupPose) {
 					constraint.mix = constraint.data.mix + (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.data.mix) * alpha;
@@ -706,9 +743,17 @@ var spine;
 		};
 		TransformConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.transformConstraints[this.transformConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					var data = constraint.data;
+					constraint.rotateMix = data.rotateMix;
+					constraint.translateMix = data.rotateMix;
+					constraint.scaleMix = data.scaleMix;
+					constraint.shearMix = data.shearMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0, scale = 0, shear = 0;
 			if (time >= frames[frames.length - TransformConstraintTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -773,9 +818,12 @@ var spine;
 		};
 		PathConstraintPositionTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.position = constraint.data.position;
+				return;
+			}
 			var position = 0;
 			if (time >= frames[frames.length - PathConstraintPositionTimeline.ENTRIES])
 				position = frames[frames.length + PathConstraintPositionTimeline.PREV_VALUE];
@@ -808,9 +856,12 @@ var spine;
 		};
 		PathConstraintSpacingTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.spacing = constraint.data.spacing;
+				return;
+			}
 			var spacing = 0;
 			if (time >= frames[frames.length - PathConstraintSpacingTimeline.ENTRIES])
 				spacing = frames[frames.length + PathConstraintSpacingTimeline.PREV_VALUE];
@@ -846,9 +897,14 @@ var spine;
 		};
 		PathConstraintMixTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.rotateMix = constraint.data.rotateMix;
+					constraint.translateMix = constraint.data.translateMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0;
 			if (time >= frames[frames.length - PathConstraintMixTimeline.ENTRIES]) {
 				rotate = frames[frames.length + PathConstraintMixTimeline.PREV_ROTATE];

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

@@ -108,6 +108,16 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, attachmentName: string): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
+	class DeformTimeline extends CurveTimeline {
+		slotIndex: number;
+		attachment: VertexAttachment;
+		frames: ArrayLike<number>;
+		frameVertices: Array<ArrayLike<number>>;
+		constructor(frameCount: number);
+		getPropertyId(): number;
+		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
+		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
+	}
 	class EventTimeline implements Timeline {
 		frames: ArrayLike<number>;
 		events: Array<Event>;
@@ -126,16 +136,6 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
-	class DeformTimeline extends CurveTimeline {
-		slotIndex: number;
-		attachment: VertexAttachment;
-		frames: ArrayLike<number>;
-		frameVertices: Array<ArrayLike<number>>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
-	}
 	class IkConstraintTimeline extends CurveTimeline {
 		static ENTRIES: number;
 		static PREV_TIME: number;

spine-ts/build/spine-threejs.js

@@ -168,9 +168,12 @@ var spine;
 		};
 		RotateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					bone.rotation = bone.data.rotation;
+				return;
+			}
 			if (time >= frames[frames.length - RotateTimeline.ENTRIES]) {
 				if (setupPose)
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
@@ -222,9 +225,14 @@ var spine;
 		};
 		TranslateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.x = bone.data.x;
+					bone.y = bone.data.y;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - TranslateTimeline.ENTRIES]) {
 				x = frames[frames.length + TranslateTimeline.PREV_X];
@@ -267,9 +275,14 @@ var spine;
 		};
 		ScaleTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.scaleX = bone.data.scaleX;
+					bone.scaleY = bone.data.scaleY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ScaleTimeline.ENTRIES]) {
 				x = frames[frames.length + ScaleTimeline.PREV_X] * bone.data.scaleX;
@@ -323,9 +336,14 @@ var spine;
 		};
 		ShearTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.shearX = bone.data.shearX;
+					bone.shearY = bone.data.shearY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ShearTimeline.ENTRIES]) {
 				x = frames[frames.length + ShearTimeline.PREV_X];
@@ -370,9 +388,13 @@ var spine;
 			this.frames[frameIndex + ColorTimeline.A] = a;
 		};
 		ColorTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose)
+					slot.color.setFromColor(slot.data.color);
 				return;
+			}
 			var r = 0, g = 0, b = 0, a = 0;
 			if (time >= frames[frames.length - ColorTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -394,7 +416,6 @@ var spine;
 				b += (frames[frame + ColorTimeline.B] - b) * percent;
 				a += (frames[frame + ColorTimeline.A] - a) * percent;
 			}
-			var slot = skeleton.slots[this.slotIndex];
 			if (alpha == 1)
 				slot.color.set(r, g, b, a);
 			else {
@@ -433,15 +454,20 @@ var spine;
 			this.attachmentNames[frameIndex] = attachmentName;
 		};
 		AttachmentTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			if (mixingOut && setupPose) {
-				var slot = skeleton.slots[this.slotIndex];
 				var attachmentName_1 = slot.data.attachmentName;
 				slot.setAttachment(attachmentName_1 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_1));
 				return;
 			}
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose) {
+					var attachmentName_2 = slot.data.attachmentName;
+					slot.setAttachment(attachmentName_2 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_2));
+				}
 				return;
+			}
 			var frameIndex = 0;
 			if (time >= frames[frames.length - 1])
 				frameIndex = frames.length - 1;
@@ -454,93 +480,6 @@ var spine;
 		return AttachmentTimeline;
 	}());
 	spine.AttachmentTimeline = AttachmentTimeline;
-	var EventTimeline = (function () {
-		function EventTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.events = new Array(frameCount);
-		}
-		EventTimeline.prototype.getPropertyId = function () {
-			return TimelineType.event << 24;
-		};
-		EventTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		EventTimeline.prototype.setFrame = function (frameIndex, event) {
-			this.frames[frameIndex] = event.time;
-			this.events[frameIndex] = event;
-		};
-		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (firedEvents == null)
-				return;
-			var frames = this.frames;
-			var frameCount = this.frames.length;
-			if (lastTime > time) {
-				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
-				lastTime = -1;
-			}
-			else if (lastTime >= frames[frameCount - 1])
-				return;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (lastTime < frames[0])
-				frame = 0;
-			else {
-				frame = Animation.binarySearch(frames, lastTime);
-				var frameTime = frames[frame];
-				while (frame > 0) {
-					if (frames[frame - 1] != frameTime)
-						break;
-					frame--;
-				}
-			}
-			for (; frame < frameCount && time >= frames[frame]; frame++)
-				firedEvents.push(this.events[frame]);
-		};
-		return EventTimeline;
-	}());
-	spine.EventTimeline = EventTimeline;
-	var DrawOrderTimeline = (function () {
-		function DrawOrderTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.drawOrders = new Array(frameCount);
-		}
-		DrawOrderTimeline.prototype.getPropertyId = function () {
-			return TimelineType.drawOrder << 24;
-		};
-		DrawOrderTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
-			this.frames[frameIndex] = time;
-			this.drawOrders[frameIndex] = drawOrder;
-		};
-		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (mixingOut && setupPose) {
-				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
-				return;
-			}
-			var frames = this.frames;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (time >= frames[frames.length - 1])
-				frame = frames.length - 1;
-			else
-				frame = Animation.binarySearch(frames, time) - 1;
-			var drawOrder = skeleton.drawOrder;
-			var slots = skeleton.slots;
-			var drawOrderToSetupIndex = this.drawOrders[frame];
-			if (drawOrderToSetupIndex == null)
-				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
-			else {
-				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
-					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
-			}
-		};
-		return DrawOrderTimeline;
-	}());
-	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var DeformTimeline = (function (_super) {
 		__extends(DeformTimeline, _super);
 		function DeformTimeline(frameCount) {
@@ -561,11 +500,14 @@ var spine;
 			if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
 				return;
 			var frames = this.frames;
-			if (time < frames[0])
+			var verticesArray = slot.attachmentVertices;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.setArraySize(verticesArray, 0);
 				return;
+			}
 			var frameVertices = this.frameVertices;
 			var vertexCount = frameVertices[0].length;
-			var verticesArray = slot.attachmentVertices;
 			if (verticesArray.length != vertexCount)
 				alpha = 1;
 			var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
@@ -631,6 +573,96 @@ var spine;
 		return DeformTimeline;
 	}(CurveTimeline));
 	spine.DeformTimeline = DeformTimeline;
+	var EventTimeline = (function () {
+		function EventTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.events = new Array(frameCount);
+		}
+		EventTimeline.prototype.getPropertyId = function () {
+			return TimelineType.event << 24;
+		};
+		EventTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		EventTimeline.prototype.setFrame = function (frameIndex, event) {
+			this.frames[frameIndex] = event.time;
+			this.events[frameIndex] = event;
+		};
+		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			if (firedEvents == null)
+				return;
+			var frames = this.frames;
+			var frameCount = this.frames.length;
+			if (lastTime > time) {
+				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
+				lastTime = -1;
+			}
+			else if (lastTime >= frames[frameCount - 1])
+				return;
+			if (time < frames[0])
+				return;
+			var frame = 0;
+			if (lastTime < frames[0])
+				frame = 0;
+			else {
+				frame = Animation.binarySearch(frames, lastTime);
+				var frameTime = frames[frame];
+				while (frame > 0) {
+					if (frames[frame - 1] != frameTime)
+						break;
+					frame--;
+				}
+			}
+			for (; frame < frameCount && time >= frames[frame]; frame++)
+				firedEvents.push(this.events[frame]);
+		};
+		return EventTimeline;
+	}());
+	spine.EventTimeline = EventTimeline;
+	var DrawOrderTimeline = (function () {
+		function DrawOrderTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.drawOrders = new Array(frameCount);
+		}
+		DrawOrderTimeline.prototype.getPropertyId = function () {
+			return TimelineType.drawOrder << 24;
+		};
+		DrawOrderTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
+			this.frames[frameIndex] = time;
+			this.drawOrders[frameIndex] = drawOrder;
+		};
+		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			var drawOrder = skeleton.drawOrder;
+			var slots = skeleton.slots;
+			if (mixingOut && setupPose) {
+				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frames = this.frames;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frame = 0;
+			if (time >= frames[frames.length - 1])
+				frame = frames.length - 1;
+			else
+				frame = Animation.binarySearch(frames, time) - 1;
+			var drawOrderToSetupIndex = this.drawOrders[frame];
+			if (drawOrderToSetupIndex == null)
+				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
+			else {
+				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
+					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
+			}
+		};
+		return DrawOrderTimeline;
+	}());
+	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var IkConstraintTimeline = (function (_super) {
 		__extends(IkConstraintTimeline, _super);
 		function IkConstraintTimeline(frameCount) {
@@ -648,9 +680,14 @@ var spine;
 		};
 		IkConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.ikConstraints[this.ikConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.mix = constraint.data.mix;
+					constraint.bendDirection = constraint.data.bendDirection;
+				}
+				return;
+			}
 			if (time >= frames[frames.length - IkConstraintTimeline.ENTRIES]) {
 				if (setupPose) {
 					constraint.mix = constraint.data.mix + (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.data.mix) * alpha;
@@ -706,9 +743,17 @@ var spine;
 		};
 		TransformConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.transformConstraints[this.transformConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					var data = constraint.data;
+					constraint.rotateMix = data.rotateMix;
+					constraint.translateMix = data.rotateMix;
+					constraint.scaleMix = data.scaleMix;
+					constraint.shearMix = data.shearMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0, scale = 0, shear = 0;
 			if (time >= frames[frames.length - TransformConstraintTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -773,9 +818,12 @@ var spine;
 		};
 		PathConstraintPositionTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.position = constraint.data.position;
+				return;
+			}
 			var position = 0;
 			if (time >= frames[frames.length - PathConstraintPositionTimeline.ENTRIES])
 				position = frames[frames.length + PathConstraintPositionTimeline.PREV_VALUE];
@@ -808,9 +856,12 @@ var spine;
 		};
 		PathConstraintSpacingTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.spacing = constraint.data.spacing;
+				return;
+			}
 			var spacing = 0;
 			if (time >= frames[frames.length - PathConstraintSpacingTimeline.ENTRIES])
 				spacing = frames[frames.length + PathConstraintSpacingTimeline.PREV_VALUE];
@@ -846,9 +897,14 @@ var spine;
 		};
 		PathConstraintMixTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.rotateMix = constraint.data.rotateMix;
+					constraint.translateMix = constraint.data.translateMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0;
 			if (time >= frames[frames.length - PathConstraintMixTimeline.ENTRIES]) {
 				rotate = frames[frames.length + PathConstraintMixTimeline.PREV_ROTATE];

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

@@ -108,6 +108,16 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, attachmentName: string): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
+	class DeformTimeline extends CurveTimeline {
+		slotIndex: number;
+		attachment: VertexAttachment;
+		frames: ArrayLike<number>;
+		frameVertices: Array<ArrayLike<number>>;
+		constructor(frameCount: number);
+		getPropertyId(): number;
+		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
+		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
+	}
 	class EventTimeline implements Timeline {
 		frames: ArrayLike<number>;
 		events: Array<Event>;
@@ -126,16 +136,6 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
-	class DeformTimeline extends CurveTimeline {
-		slotIndex: number;
-		attachment: VertexAttachment;
-		frames: ArrayLike<number>;
-		frameVertices: Array<ArrayLike<number>>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
-	}
 	class IkConstraintTimeline extends CurveTimeline {
 		static ENTRIES: number;
 		static PREV_TIME: number;

spine-ts/build/spine-webgl.js

@@ -168,9 +168,12 @@ var spine;
 		};
 		RotateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					bone.rotation = bone.data.rotation;
+				return;
+			}
 			if (time >= frames[frames.length - RotateTimeline.ENTRIES]) {
 				if (setupPose)
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
@@ -222,9 +225,14 @@ var spine;
 		};
 		TranslateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.x = bone.data.x;
+					bone.y = bone.data.y;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - TranslateTimeline.ENTRIES]) {
 				x = frames[frames.length + TranslateTimeline.PREV_X];
@@ -267,9 +275,14 @@ var spine;
 		};
 		ScaleTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.scaleX = bone.data.scaleX;
+					bone.scaleY = bone.data.scaleY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ScaleTimeline.ENTRIES]) {
 				x = frames[frames.length + ScaleTimeline.PREV_X] * bone.data.scaleX;
@@ -323,9 +336,14 @@ var spine;
 		};
 		ShearTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.shearX = bone.data.shearX;
+					bone.shearY = bone.data.shearY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ShearTimeline.ENTRIES]) {
 				x = frames[frames.length + ShearTimeline.PREV_X];
@@ -370,9 +388,13 @@ var spine;
 			this.frames[frameIndex + ColorTimeline.A] = a;
 		};
 		ColorTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose)
+					slot.color.setFromColor(slot.data.color);
 				return;
+			}
 			var r = 0, g = 0, b = 0, a = 0;
 			if (time >= frames[frames.length - ColorTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -394,7 +416,6 @@ var spine;
 				b += (frames[frame + ColorTimeline.B] - b) * percent;
 				a += (frames[frame + ColorTimeline.A] - a) * percent;
 			}
-			var slot = skeleton.slots[this.slotIndex];
 			if (alpha == 1)
 				slot.color.set(r, g, b, a);
 			else {
@@ -433,15 +454,20 @@ var spine;
 			this.attachmentNames[frameIndex] = attachmentName;
 		};
 		AttachmentTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			if (mixingOut && setupPose) {
-				var slot = skeleton.slots[this.slotIndex];
 				var attachmentName_1 = slot.data.attachmentName;
 				slot.setAttachment(attachmentName_1 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_1));
 				return;
 			}
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose) {
+					var attachmentName_2 = slot.data.attachmentName;
+					slot.setAttachment(attachmentName_2 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_2));
+				}
 				return;
+			}
 			var frameIndex = 0;
 			if (time >= frames[frames.length - 1])
 				frameIndex = frames.length - 1;
@@ -454,93 +480,6 @@ var spine;
 		return AttachmentTimeline;
 	}());
 	spine.AttachmentTimeline = AttachmentTimeline;
-	var EventTimeline = (function () {
-		function EventTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.events = new Array(frameCount);
-		}
-		EventTimeline.prototype.getPropertyId = function () {
-			return TimelineType.event << 24;
-		};
-		EventTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		EventTimeline.prototype.setFrame = function (frameIndex, event) {
-			this.frames[frameIndex] = event.time;
-			this.events[frameIndex] = event;
-		};
-		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (firedEvents == null)
-				return;
-			var frames = this.frames;
-			var frameCount = this.frames.length;
-			if (lastTime > time) {
-				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
-				lastTime = -1;
-			}
-			else if (lastTime >= frames[frameCount - 1])
-				return;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (lastTime < frames[0])
-				frame = 0;
-			else {
-				frame = Animation.binarySearch(frames, lastTime);
-				var frameTime = frames[frame];
-				while (frame > 0) {
-					if (frames[frame - 1] != frameTime)
-						break;
-					frame--;
-				}
-			}
-			for (; frame < frameCount && time >= frames[frame]; frame++)
-				firedEvents.push(this.events[frame]);
-		};
-		return EventTimeline;
-	}());
-	spine.EventTimeline = EventTimeline;
-	var DrawOrderTimeline = (function () {
-		function DrawOrderTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.drawOrders = new Array(frameCount);
-		}
-		DrawOrderTimeline.prototype.getPropertyId = function () {
-			return TimelineType.drawOrder << 24;
-		};
-		DrawOrderTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
-			this.frames[frameIndex] = time;
-			this.drawOrders[frameIndex] = drawOrder;
-		};
-		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (mixingOut && setupPose) {
-				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
-				return;
-			}
-			var frames = this.frames;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (time >= frames[frames.length - 1])
-				frame = frames.length - 1;
-			else
-				frame = Animation.binarySearch(frames, time) - 1;
-			var drawOrder = skeleton.drawOrder;
-			var slots = skeleton.slots;
-			var drawOrderToSetupIndex = this.drawOrders[frame];
-			if (drawOrderToSetupIndex == null)
-				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
-			else {
-				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
-					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
-			}
-		};
-		return DrawOrderTimeline;
-	}());
-	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var DeformTimeline = (function (_super) {
 		__extends(DeformTimeline, _super);
 		function DeformTimeline(frameCount) {
@@ -561,11 +500,14 @@ var spine;
 			if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
 				return;
 			var frames = this.frames;
-			if (time < frames[0])
+			var verticesArray = slot.attachmentVertices;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.setArraySize(verticesArray, 0);
 				return;
+			}
 			var frameVertices = this.frameVertices;
 			var vertexCount = frameVertices[0].length;
-			var verticesArray = slot.attachmentVertices;
 			if (verticesArray.length != vertexCount)
 				alpha = 1;
 			var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
@@ -631,6 +573,96 @@ var spine;
 		return DeformTimeline;
 	}(CurveTimeline));
 	spine.DeformTimeline = DeformTimeline;
+	var EventTimeline = (function () {
+		function EventTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.events = new Array(frameCount);
+		}
+		EventTimeline.prototype.getPropertyId = function () {
+			return TimelineType.event << 24;
+		};
+		EventTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		EventTimeline.prototype.setFrame = function (frameIndex, event) {
+			this.frames[frameIndex] = event.time;
+			this.events[frameIndex] = event;
+		};
+		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			if (firedEvents == null)
+				return;
+			var frames = this.frames;
+			var frameCount = this.frames.length;
+			if (lastTime > time) {
+				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
+				lastTime = -1;
+			}
+			else if (lastTime >= frames[frameCount - 1])
+				return;
+			if (time < frames[0])
+				return;
+			var frame = 0;
+			if (lastTime < frames[0])
+				frame = 0;
+			else {
+				frame = Animation.binarySearch(frames, lastTime);
+				var frameTime = frames[frame];
+				while (frame > 0) {
+					if (frames[frame - 1] != frameTime)
+						break;
+					frame--;
+				}
+			}
+			for (; frame < frameCount && time >= frames[frame]; frame++)
+				firedEvents.push(this.events[frame]);
+		};
+		return EventTimeline;
+	}());
+	spine.EventTimeline = EventTimeline;
+	var DrawOrderTimeline = (function () {
+		function DrawOrderTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.drawOrders = new Array(frameCount);
+		}
+		DrawOrderTimeline.prototype.getPropertyId = function () {
+			return TimelineType.drawOrder << 24;
+		};
+		DrawOrderTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
+			this.frames[frameIndex] = time;
+			this.drawOrders[frameIndex] = drawOrder;
+		};
+		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			var drawOrder = skeleton.drawOrder;
+			var slots = skeleton.slots;
+			if (mixingOut && setupPose) {
+				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frames = this.frames;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frame = 0;
+			if (time >= frames[frames.length - 1])
+				frame = frames.length - 1;
+			else
+				frame = Animation.binarySearch(frames, time) - 1;
+			var drawOrderToSetupIndex = this.drawOrders[frame];
+			if (drawOrderToSetupIndex == null)
+				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
+			else {
+				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
+					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
+			}
+		};
+		return DrawOrderTimeline;
+	}());
+	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var IkConstraintTimeline = (function (_super) {
 		__extends(IkConstraintTimeline, _super);
 		function IkConstraintTimeline(frameCount) {
@@ -648,9 +680,14 @@ var spine;
 		};
 		IkConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.ikConstraints[this.ikConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.mix = constraint.data.mix;
+					constraint.bendDirection = constraint.data.bendDirection;
+				}
+				return;
+			}
 			if (time >= frames[frames.length - IkConstraintTimeline.ENTRIES]) {
 				if (setupPose) {
 					constraint.mix = constraint.data.mix + (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.data.mix) * alpha;
@@ -706,9 +743,17 @@ var spine;
 		};
 		TransformConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.transformConstraints[this.transformConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					var data = constraint.data;
+					constraint.rotateMix = data.rotateMix;
+					constraint.translateMix = data.rotateMix;
+					constraint.scaleMix = data.scaleMix;
+					constraint.shearMix = data.shearMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0, scale = 0, shear = 0;
 			if (time >= frames[frames.length - TransformConstraintTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -773,9 +818,12 @@ var spine;
 		};
 		PathConstraintPositionTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.position = constraint.data.position;
+				return;
+			}
 			var position = 0;
 			if (time >= frames[frames.length - PathConstraintPositionTimeline.ENTRIES])
 				position = frames[frames.length + PathConstraintPositionTimeline.PREV_VALUE];
@@ -808,9 +856,12 @@ var spine;
 		};
 		PathConstraintSpacingTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.spacing = constraint.data.spacing;
+				return;
+			}
 			var spacing = 0;
 			if (time >= frames[frames.length - PathConstraintSpacingTimeline.ENTRIES])
 				spacing = frames[frames.length + PathConstraintSpacingTimeline.PREV_VALUE];
@@ -846,9 +897,14 @@ var spine;
 		};
 		PathConstraintMixTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.rotateMix = constraint.data.rotateMix;
+					constraint.translateMix = constraint.data.translateMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0;
 			if (time >= frames[frames.length - PathConstraintMixTimeline.ENTRIES]) {
 				rotate = frames[frames.length + PathConstraintMixTimeline.PREV_ROTATE];

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

@@ -108,6 +108,16 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, attachmentName: string): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
+	class DeformTimeline extends CurveTimeline {
+		slotIndex: number;
+		attachment: VertexAttachment;
+		frames: ArrayLike<number>;
+		frameVertices: Array<ArrayLike<number>>;
+		constructor(frameCount: number);
+		getPropertyId(): number;
+		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
+		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
+	}
 	class EventTimeline implements Timeline {
 		frames: ArrayLike<number>;
 		events: Array<Event>;
@@ -126,16 +136,6 @@ declare module spine {
 		setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
 		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
 	}
-	class DeformTimeline extends CurveTimeline {
-		slotIndex: number;
-		attachment: VertexAttachment;
-		frames: ArrayLike<number>;
-		frameVertices: Array<ArrayLike<number>>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean): void;
-	}
 	class IkConstraintTimeline extends CurveTimeline {
 		static ENTRIES: number;
 		static PREV_TIME: number;

spine-ts/build/spine-widget.js

@@ -168,9 +168,12 @@ var spine;
 		};
 		RotateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					bone.rotation = bone.data.rotation;
+				return;
+			}
 			if (time >= frames[frames.length - RotateTimeline.ENTRIES]) {
 				if (setupPose)
 					bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
@@ -222,9 +225,14 @@ var spine;
 		};
 		TranslateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.x = bone.data.x;
+					bone.y = bone.data.y;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - TranslateTimeline.ENTRIES]) {
 				x = frames[frames.length + TranslateTimeline.PREV_X];
@@ -267,9 +275,14 @@ var spine;
 		};
 		ScaleTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.scaleX = bone.data.scaleX;
+					bone.scaleY = bone.data.scaleY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ScaleTimeline.ENTRIES]) {
 				x = frames[frames.length + ScaleTimeline.PREV_X] * bone.data.scaleX;
@@ -323,9 +336,14 @@ var spine;
 		};
 		ShearTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.shearX = bone.data.shearX;
+					bone.shearY = bone.data.shearY;
+				}
+				return;
+			}
 			var x = 0, y = 0;
 			if (time >= frames[frames.length - ShearTimeline.ENTRIES]) {
 				x = frames[frames.length + ShearTimeline.PREV_X];
@@ -370,9 +388,13 @@ var spine;
 			this.frames[frameIndex + ColorTimeline.A] = a;
 		};
 		ColorTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose)
+					slot.color.setFromColor(slot.data.color);
 				return;
+			}
 			var r = 0, g = 0, b = 0, a = 0;
 			if (time >= frames[frames.length - ColorTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -394,7 +416,6 @@ var spine;
 				b += (frames[frame + ColorTimeline.B] - b) * percent;
 				a += (frames[frame + ColorTimeline.A] - a) * percent;
 			}
-			var slot = skeleton.slots[this.slotIndex];
 			if (alpha == 1)
 				slot.color.set(r, g, b, a);
 			else {
@@ -433,15 +454,20 @@ var spine;
 			this.attachmentNames[frameIndex] = attachmentName;
 		};
 		AttachmentTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, setupPose, mixingOut) {
+			var slot = skeleton.slots[this.slotIndex];
 			if (mixingOut && setupPose) {
-				var slot = skeleton.slots[this.slotIndex];
 				var attachmentName_1 = slot.data.attachmentName;
 				slot.setAttachment(attachmentName_1 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_1));
 				return;
 			}
 			var frames = this.frames;
-			if (time < frames[0])
+			if (time < frames[0]) {
+				if (setupPose) {
+					var attachmentName_2 = slot.data.attachmentName;
+					slot.setAttachment(attachmentName_2 == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName_2));
+				}
 				return;
+			}
 			var frameIndex = 0;
 			if (time >= frames[frames.length - 1])
 				frameIndex = frames.length - 1;
@@ -454,93 +480,6 @@ var spine;
 		return AttachmentTimeline;
 	}());
 	spine.AttachmentTimeline = AttachmentTimeline;
-	var EventTimeline = (function () {
-		function EventTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.events = new Array(frameCount);
-		}
-		EventTimeline.prototype.getPropertyId = function () {
-			return TimelineType.event << 24;
-		};
-		EventTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		EventTimeline.prototype.setFrame = function (frameIndex, event) {
-			this.frames[frameIndex] = event.time;
-			this.events[frameIndex] = event;
-		};
-		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (firedEvents == null)
-				return;
-			var frames = this.frames;
-			var frameCount = this.frames.length;
-			if (lastTime > time) {
-				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
-				lastTime = -1;
-			}
-			else if (lastTime >= frames[frameCount - 1])
-				return;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (lastTime < frames[0])
-				frame = 0;
-			else {
-				frame = Animation.binarySearch(frames, lastTime);
-				var frameTime = frames[frame];
-				while (frame > 0) {
-					if (frames[frame - 1] != frameTime)
-						break;
-					frame--;
-				}
-			}
-			for (; frame < frameCount && time >= frames[frame]; frame++)
-				firedEvents.push(this.events[frame]);
-		};
-		return EventTimeline;
-	}());
-	spine.EventTimeline = EventTimeline;
-	var DrawOrderTimeline = (function () {
-		function DrawOrderTimeline(frameCount) {
-			this.frames = spine.Utils.newFloatArray(frameCount);
-			this.drawOrders = new Array(frameCount);
-		}
-		DrawOrderTimeline.prototype.getPropertyId = function () {
-			return TimelineType.drawOrder << 24;
-		};
-		DrawOrderTimeline.prototype.getFrameCount = function () {
-			return this.frames.length;
-		};
-		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
-			this.frames[frameIndex] = time;
-			this.drawOrders[frameIndex] = drawOrder;
-		};
-		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
-			if (mixingOut && setupPose) {
-				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
-				return;
-			}
-			var frames = this.frames;
-			if (time < frames[0])
-				return;
-			var frame = 0;
-			if (time >= frames[frames.length - 1])
-				frame = frames.length - 1;
-			else
-				frame = Animation.binarySearch(frames, time) - 1;
-			var drawOrder = skeleton.drawOrder;
-			var slots = skeleton.slots;
-			var drawOrderToSetupIndex = this.drawOrders[frame];
-			if (drawOrderToSetupIndex == null)
-				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
-			else {
-				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
-					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
-			}
-		};
-		return DrawOrderTimeline;
-	}());
-	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var DeformTimeline = (function (_super) {
 		__extends(DeformTimeline, _super);
 		function DeformTimeline(frameCount) {
@@ -561,11 +500,14 @@ var spine;
 			if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
 				return;
 			var frames = this.frames;
-			if (time < frames[0])
+			var verticesArray = slot.attachmentVertices;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.setArraySize(verticesArray, 0);
 				return;
+			}
 			var frameVertices = this.frameVertices;
 			var vertexCount = frameVertices[0].length;
-			var verticesArray = slot.attachmentVertices;
 			if (verticesArray.length != vertexCount)
 				alpha = 1;
 			var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
@@ -631,6 +573,96 @@ var spine;
 		return DeformTimeline;
 	}(CurveTimeline));
 	spine.DeformTimeline = DeformTimeline;
+	var EventTimeline = (function () {
+		function EventTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.events = new Array(frameCount);
+		}
+		EventTimeline.prototype.getPropertyId = function () {
+			return TimelineType.event << 24;
+		};
+		EventTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		EventTimeline.prototype.setFrame = function (frameIndex, event) {
+			this.frames[frameIndex] = event.time;
+			this.events[frameIndex] = event;
+		};
+		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			if (firedEvents == null)
+				return;
+			var frames = this.frames;
+			var frameCount = this.frames.length;
+			if (lastTime > time) {
+				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
+				lastTime = -1;
+			}
+			else if (lastTime >= frames[frameCount - 1])
+				return;
+			if (time < frames[0])
+				return;
+			var frame = 0;
+			if (lastTime < frames[0])
+				frame = 0;
+			else {
+				frame = Animation.binarySearch(frames, lastTime);
+				var frameTime = frames[frame];
+				while (frame > 0) {
+					if (frames[frame - 1] != frameTime)
+						break;
+					frame--;
+				}
+			}
+			for (; frame < frameCount && time >= frames[frame]; frame++)
+				firedEvents.push(this.events[frame]);
+		};
+		return EventTimeline;
+	}());
+	spine.EventTimeline = EventTimeline;
+	var DrawOrderTimeline = (function () {
+		function DrawOrderTimeline(frameCount) {
+			this.frames = spine.Utils.newFloatArray(frameCount);
+			this.drawOrders = new Array(frameCount);
+		}
+		DrawOrderTimeline.prototype.getPropertyId = function () {
+			return TimelineType.drawOrder << 24;
+		};
+		DrawOrderTimeline.prototype.getFrameCount = function () {
+			return this.frames.length;
+		};
+		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
+			this.frames[frameIndex] = time;
+			this.drawOrders[frameIndex] = drawOrder;
+		};
+		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
+			var drawOrder = skeleton.drawOrder;
+			var slots = skeleton.slots;
+			if (mixingOut && setupPose) {
+				spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frames = this.frames;
+			if (time < frames[0]) {
+				if (setupPose)
+					spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
+			var frame = 0;
+			if (time >= frames[frames.length - 1])
+				frame = frames.length - 1;
+			else
+				frame = Animation.binarySearch(frames, time) - 1;
+			var drawOrderToSetupIndex = this.drawOrders[frame];
+			if (drawOrderToSetupIndex == null)
+				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
+			else {
+				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
+					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
+			}
+		};
+		return DrawOrderTimeline;
+	}());
+	spine.DrawOrderTimeline = DrawOrderTimeline;
 	var IkConstraintTimeline = (function (_super) {
 		__extends(IkConstraintTimeline, _super);
 		function IkConstraintTimeline(frameCount) {
@@ -648,9 +680,14 @@ var spine;
 		};
 		IkConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.ikConstraints[this.ikConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.mix = constraint.data.mix;
+					constraint.bendDirection = constraint.data.bendDirection;
+				}
+				return;
+			}
 			if (time >= frames[frames.length - IkConstraintTimeline.ENTRIES]) {
 				if (setupPose) {
 					constraint.mix = constraint.data.mix + (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.data.mix) * alpha;
@@ -706,9 +743,17 @@ var spine;
 		};
 		TransformConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.transformConstraints[this.transformConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					var data = constraint.data;
+					constraint.rotateMix = data.rotateMix;
+					constraint.translateMix = data.rotateMix;
+					constraint.scaleMix = data.scaleMix;
+					constraint.shearMix = data.shearMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0, scale = 0, shear = 0;
 			if (time >= frames[frames.length - TransformConstraintTimeline.ENTRIES]) {
 				var i = frames.length;
@@ -773,9 +818,12 @@ var spine;
 		};
 		PathConstraintPositionTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.position = constraint.data.position;
+				return;
+			}
 			var position = 0;
 			if (time >= frames[frames.length - PathConstraintPositionTimeline.ENTRIES])
 				position = frames[frames.length + PathConstraintPositionTimeline.PREV_VALUE];
@@ -808,9 +856,12 @@ var spine;
 		};
 		PathConstraintSpacingTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose)
+					constraint.spacing = constraint.data.spacing;
+				return;
+			}
 			var spacing = 0;
 			if (time >= frames[frames.length - PathConstraintSpacingTimeline.ENTRIES])
 				spacing = frames[frames.length + PathConstraintSpacingTimeline.PREV_VALUE];
@@ -846,9 +897,14 @@ var spine;
 		};
 		PathConstraintMixTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, setupPose, mixingOut) {
 			var frames = this.frames;
-			if (time < frames[0])
-				return;
 			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.rotateMix = constraint.data.rotateMix;
+					constraint.translateMix = constraint.data.translateMix;
+				}
+				return;
+			}
 			var rotate = 0, translate = 0;
 			if (time >= frames[frames.length - PathConstraintMixTimeline.ENTRIES]) {
 				rotate = frames[frames.length + PathConstraintMixTimeline.PREV_ROTATE];

spine-ts/core/src/Animation.ts

@@ -206,9 +206,12 @@ module spine {
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
 
 			let bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) bone.rotation = bone.data.rotation;
+				return;
+			}
 
 			if (time >= frames[frames.length - RotateTimeline.ENTRIES]) { // Time is after last frame.
 				if (setupPose)
@@ -269,9 +272,15 @@ module spine {
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
 
 			let bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.x = bone.data.x;
+					bone.y = bone.data.y;
+				}
+				return;
+			}
 
 			let x = 0, y = 0;
 			if (time >= frames[frames.length - TranslateTimeline.ENTRIES]) { // Time is after last frame.
@@ -310,9 +319,16 @@ module spine {
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
 
 			let bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.scaleX = bone.data.scaleX;
+					bone.scaleY = bone.data.scaleY;
+				}
+				return;
+			}
+
 			let x = 0, y = 0;
 			if (time >= frames[frames.length - ScaleTimeline.ENTRIES]) { // Time is after last frame.
 				x = frames[frames.length + ScaleTimeline.PREV_X] * bone.data.scaleX;
@@ -366,9 +382,15 @@ module spine {
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
 
 			let bone = skeleton.bones[this.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.shearX = bone.data.shearX;
+					bone.shearY = bone.data.shearY;
+				}
+				return;
+			}
 
 			let x = 0, y = 0;
 			if (time >= frames[frames.length - ShearTimeline.ENTRIES]) { // Time is after last frame.
@@ -424,8 +446,12 @@ module spine {
 		}
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
+			let slot = skeleton.slots[this.slotIndex];
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
+			if (time < frames[0]) {
+				if (setupPose) slot.color.setFromColor(slot.data.color);
+				return;
+			}
 
 			let r = 0, g = 0, b = 0, a = 0;
 			if (time >= frames[frames.length - ColorTimeline.ENTRIES]) { // Time is after last frame.
@@ -450,7 +476,6 @@ module spine {
 				b += (frames[frame + ColorTimeline.B] - b) * percent;
 				a += (frames[frame + ColorTimeline.A] - a) * percent;
 			}
-			let slot = skeleton.slots[this.slotIndex];
 			if (alpha == 1)
 				slot.color.set(r, g, b, a);
 			else {
@@ -486,15 +511,21 @@ module spine {
 		}
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
+			let slot = skeleton.slots[this.slotIndex];
 			if (mixingOut && setupPose) {
-				let slot = skeleton.slots[this.slotIndex];
 				let attachmentName = slot.data.attachmentName;
 				slot.setAttachment(attachmentName == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName));
 				return;
 			}
 
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
+			if (time < frames[0]) {
+				if (setupPose) {
+					let attachmentName = slot.data.attachmentName;
+					slot.setAttachment(attachmentName == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName));
+				}
+				return;
+			}
 
 			let frameIndex = 0;
 			if (time >= frames[frames.length - 1]) // Time is after last frame.
@@ -508,6 +539,109 @@ module spine {
 		}
 	}
 
+	export class DeformTimeline extends CurveTimeline {
+		slotIndex: number;
+		attachment: VertexAttachment;
+		frames: ArrayLike<number>; // time, ...
+		frameVertices: Array<ArrayLike<number>>;
+
+		constructor (frameCount: number) {
+			super(frameCount);
+			this.frames = Utils.newFloatArray(frameCount);
+			this.frameVertices = new Array<ArrayLike<number>>(frameCount);
+		}
+
+		getPropertyId () {
+			return (TimelineType.deform << 24) + this.slotIndex;
+		}
+
+		/** Sets the time of the specified keyframe. */
+		setFrame (frameIndex: number, time: number, vertices: ArrayLike<number>) {
+			this.frames[frameIndex] = time;
+			this.frameVertices[frameIndex] = vertices;
+		}
+
+		apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
+			let slot: Slot = skeleton.slots[this.slotIndex];
+			let slotAttachment: Attachment = slot.getAttachment();
+			if (!(slotAttachment instanceof VertexAttachment) || !(<VertexAttachment>slotAttachment).applyDeform(this.attachment)) return;
+
+			let frames = this.frames;
+			let verticesArray: Array<number> = slot.attachmentVertices;
+			if (time < frames[0]) {
+				if (setupPose) Utils.setArraySize(verticesArray, 0);
+				return;
+			}
+
+			let frameVertices = this.frameVertices;
+			let vertexCount = frameVertices[0].length;
+
+			if (verticesArray.length != vertexCount) alpha = 1; // Don't mix from uninitialized slot vertices.
+			let vertices: Array<number> = Utils.setArraySize(verticesArray, vertexCount);
+
+			if (time >= frames[frames.length - 1]) { // Time is after last frame.
+				let lastVertices = frameVertices[frames.length - 1];
+				if (alpha == 1) {
+					Utils.arrayCopy(lastVertices, 0, vertices, 0, vertexCount);
+				} else if (setupPose) {
+					let vertexAttachment = slotAttachment as VertexAttachment;
+					if (vertexAttachment.bones == null) {
+						// Unweighted vertex positions, with alpha.
+						let setupVertices = vertexAttachment.vertices;
+						for (let i = 0; i < vertexCount; i++) {
+							let setup = setupVertices[i];
+							vertices[i] = setup + (lastVertices[i] - setup) * alpha;
+						}
+					} else {
+						// Weighted deform offsets, with alpha.
+						for (let i = 0; i < vertexCount; i++)
+							vertices[i] = lastVertices[i] * alpha;
+					}
+				} else {
+					for (let i = 0; i < vertexCount; i++)
+						vertices[i] += (lastVertices[i] - vertices[i]) * alpha;
+				}
+				return;
+			}
+
+			// Interpolate between the previous frame and the current frame.
+			let frame = Animation.binarySearch(frames, time);
+			let prevVertices = frameVertices[frame - 1];
+			let nextVertices = frameVertices[frame];
+			let frameTime = frames[frame];
+			let percent = this.getCurvePercent(frame - 1, 1 - (time - frameTime) / (frames[frame - 1] - frameTime));
+
+			if (alpha == 1) {
+				for (let i = 0; i < vertexCount; i++) {
+					let prev = prevVertices[i];
+					vertices[i] = prev + (nextVertices[i] - prev) * percent;
+				}
+			} else if (setupPose) {
+				let vertexAttachment = slotAttachment as VertexAttachment;
+				if (vertexAttachment.bones == null) {
+					// Unweighted vertex positions, with alpha.
+					let setupVertices = vertexAttachment.vertices;
+					for (let i = 0; i < vertexCount; i++) {
+						let prev = prevVertices[i], setup = setupVertices[i];
+						vertices[i] = setup + (prev + (nextVertices[i] - prev) * percent - setup) * alpha;
+					}
+				} else {
+					// Weighted deform offsets, with alpha.
+					for (let i = 0; i < vertexCount; i++) {
+						let prev = prevVertices[i];
+						vertices[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;
+					}
+				}
+			} else {
+				// Vertex positions or deform offsets, with alpha.
+				for (let i = 0; i < vertexCount; i++) {
+					let prev = prevVertices[i];
+					vertices[i] += (prev + (nextVertices[i] - prev) * percent - vertices[i]) * alpha;
+				}
+			}
+		}
+	}
+
 	export class EventTimeline implements Timeline {
 		frames: ArrayLike<number>; // time, ...
 		events: Array<Event>;
@@ -585,13 +719,18 @@ module spine {
 		}
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
+			let drawOrder: Array<Slot> = skeleton.drawOrder;
+			let slots: Array<Slot> = skeleton.slots;
 			if (mixingOut && setupPose) {
 				Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
 				return;
 			}
 
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
+			if (time < frames[0]) {
+				if (setupPose) Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
+				return;
+			}
 
 			let frame = 0;
 			if (time >= frames[frames.length - 1]) // Time is after last frame.
@@ -599,8 +738,6 @@ module spine {
 			else
 				frame = Animation.binarySearch(frames, time) - 1;
 
-			let drawOrder: Array<Slot> = skeleton.drawOrder;
-			let slots: Array<Slot> = skeleton.slots;
 			let drawOrderToSetupIndex = this.drawOrders[frame];
 			if (drawOrderToSetupIndex == null)
 				Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
@@ -611,106 +748,6 @@ module spine {
 		}
 	}
 
-	export class DeformTimeline extends CurveTimeline {
-		slotIndex: number;
-		attachment: VertexAttachment;
-		frames: ArrayLike<number>; // time, ...
-		frameVertices: Array<ArrayLike<number>>;
-
-		constructor (frameCount: number) {
-			super(frameCount);
-			this.frames = Utils.newFloatArray(frameCount);
-			this.frameVertices = new Array<ArrayLike<number>>(frameCount);
-		}
-
-		getPropertyId () {
-			return (TimelineType.deform << 24) + this.slotIndex;
-		}
-
-		/** Sets the time of the specified keyframe. */
-		setFrame (frameIndex: number, time: number, vertices: ArrayLike<number>) {
-			this.frames[frameIndex] = time;
-			this.frameVertices[frameIndex] = vertices;
-		}
-
-		apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
-			let slot: Slot = skeleton.slots[this.slotIndex];
-			let slotAttachment: Attachment = slot.getAttachment();
-			if (!(slotAttachment instanceof VertexAttachment) || !(<VertexAttachment>slotAttachment).applyDeform(this.attachment)) return;
-
-			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
-
-			let frameVertices = this.frameVertices;
-			let vertexCount = frameVertices[0].length;
-
-			let verticesArray: Array<number> = slot.attachmentVertices;
-			if (verticesArray.length != vertexCount) alpha = 1; // Don't mix from uninitialized slot vertices.
-			let vertices: Array<number> = Utils.setArraySize(verticesArray, vertexCount);
-
-			if (time >= frames[frames.length - 1]) { // Time is after last frame.
-				let lastVertices = frameVertices[frames.length - 1];
-				if (alpha == 1) {
-					Utils.arrayCopy(lastVertices, 0, vertices, 0, vertexCount);
-				} else if (setupPose) {
-					let vertexAttachment = slotAttachment as VertexAttachment;
-					if (vertexAttachment.bones == null) {
-						// Unweighted vertex positions, with alpha.
-						let setupVertices = vertexAttachment.vertices;
-						for (let i = 0; i < vertexCount; i++) {
-							let setup = setupVertices[i];
-							vertices[i] = setup + (lastVertices[i] - setup) * alpha;
-						}
-					} else {
-						// Weighted deform offsets, with alpha.
-						for (let i = 0; i < vertexCount; i++)
-							vertices[i] = lastVertices[i] * alpha;
-					}
-				} else {
-					for (let i = 0; i < vertexCount; i++)
-						vertices[i] += (lastVertices[i] - vertices[i]) * alpha;
-				}
-				return;
-			}
-
-			// Interpolate between the previous frame and the current frame.
-			let frame = Animation.binarySearch(frames, time);
-			let prevVertices = frameVertices[frame - 1];
-			let nextVertices = frameVertices[frame];
-			let frameTime = frames[frame];
-			let percent = this.getCurvePercent(frame - 1, 1 - (time - frameTime) / (frames[frame - 1] - frameTime));
-
-			if (alpha == 1) {
-				for (let i = 0; i < vertexCount; i++) {
-					let prev = prevVertices[i];
-					vertices[i] = prev + (nextVertices[i] - prev) * percent;
-				}
-			} else if (setupPose) {
-				let vertexAttachment = slotAttachment as VertexAttachment;
-				if (vertexAttachment.bones == null) {
-					// Unweighted vertex positions, with alpha.
-					let setupVertices = vertexAttachment.vertices;
-					for (let i = 0; i < vertexCount; i++) {
-						let prev = prevVertices[i], setup = setupVertices[i];
-						vertices[i] = setup + (prev + (nextVertices[i] - prev) * percent - setup) * alpha;
-					}
-				} else {
-					// Weighted deform offsets, with alpha.
-					for (let i = 0; i < vertexCount; i++) {
-						let prev = prevVertices[i];
-						vertices[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;
-					}
-				}
-			} else {
-				// Vertex positions or deform offsets, with alpha.
-				for (let i = 0; i < vertexCount; i++) {
-					let prev = prevVertices[i];
-					vertices[i] += (prev + (nextVertices[i] - prev) * percent - vertices[i]) * alpha;
-				}
-			}
-		}
-	}
-
 	export class IkConstraintTimeline extends CurveTimeline {
 		static ENTRIES = 3;
 		static PREV_TIME = -3; static PREV_MIX = -2; static PREV_BEND_DIRECTION = -1;
@@ -738,9 +775,14 @@ module spine {
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
-
 			let constraint: IkConstraint = skeleton.ikConstraints[this.ikConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.mix = constraint.data.mix;
+					constraint.bendDirection = constraint.data.bendDirection;
+				}
+				return;
+			}
 
 			if (time >= frames[frames.length - IkConstraintTimeline.ENTRIES]) { // Time is after last frame.
 				if (setupPose) {
@@ -800,9 +842,18 @@ module spine {
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
 
 			let constraint: TransformConstraint = skeleton.transformConstraints[this.transformConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					let data = constraint.data;
+					constraint.rotateMix = data.rotateMix;
+					constraint.translateMix = data.rotateMix;
+					constraint.scaleMix = data.scaleMix;
+					constraint.shearMix = data.shearMix;
+				}
+				return;
+			}
 
 			let rotate = 0, translate = 0, scale = 0, shear = 0;
 			if (time >= frames[frames.length - TransformConstraintTimeline.ENTRIES]) { // Time is after last frame.
@@ -869,9 +920,11 @@ module spine {
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
-
 			let constraint: PathConstraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) constraint.position = constraint.data.position;
+				return;
+			}
 
 			let position = 0;
 			if (time >= frames[frames.length - PathConstraintPositionTimeline.ENTRIES]) // Time is after last frame.
@@ -904,9 +957,11 @@ module spine {
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
-
 			let constraint: PathConstraint = skeleton.pathConstraints[this.pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) constraint.spacing = constraint.data.spacing;
+				return;
+			}
 
 			let spacing = 0;
 			if (time >= frames[frames.length - PathConstraintSpacingTimeline.ENTRIES]) // Time is after last frame.
@@ -957,10 +1012,16 @@ module spine {
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, setupPose: boolean, mixingOut: boolean) {
 			let frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
-
 			let constraint: PathConstraint = skeleton.pathConstraints[this.pathConstraintIndex];
 
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.rotateMix = constraint.data.rotateMix;
+					constraint.translateMix = constraint.data.translateMix;
+				}
+				return;
+			}
+
 			let rotate = 0, translate = 0;
 			if (time >= frames[frames.length - PathConstraintMixTimeline.ENTRIES]) { // Time is after last frame.
 				rotate = frames[frames.length + PathConstraintMixTimeline.PREV_ROTATE];