[as3] Ported latest AnimationState and Animation changes. See #1303.

spine-as3/spine-as3/src/spine/Slot.as

@@ -38,7 +38,7 @@ package spine {
 		public var darkColor : Color;
 		internal var _attachment : Attachment;
 		private var _attachmentTime : Number;
-		public var attachmentVertices : Vector.<Number> = new Vector.<Number>();
+		public var deform : Vector.<Number> = new Vector.<Number>();
 
 		public function Slot(data : SlotData, bone : Bone) {
 			if (data == null) throw new ArgumentError("data cannot be null.");
@@ -73,7 +73,7 @@ package spine {
 			if (_attachment == attachment) return;
 			_attachment = attachment;
 			_attachmentTime = _bone._skeleton.time;
-			attachmentVertices.length = 0;
+			deform.length = 0;
 		}
 
 		public function set attachmentTime(time : Number) : void {

spine-as3/spine-as3/src/spine/animation/AnimationState.as

@@ -40,6 +40,7 @@ package spine.animation {
 		public static var FIRST : int = 1;
 		public static var HOLD : int = 2;
 		public static var HOLD_MIX : int = 3;
+		public static var NOT_LAST : int = 4;
 		internal static var emptyAnimation : Animation = new Animation("<empty>", new Vector.<Timeline>(), 0);
 		public var data : AnimationStateData;
 		public var tracks : Vector.<TrackEntry> = new Vector.<TrackEntry>();
@@ -188,7 +189,7 @@ package spine.animation {
 					
 					for (ii = 0; ii < timelineCount; ii++) {
 						var timeline : Timeline = timelines[ii];
-						var timelineBlend : MixBlend = timelineMode[ii] == AnimationState.SUBSEQUENT ? blend : MixBlend.setup;
+						var timelineBlend : MixBlend = (timelineMode[ii] & (NOT_LAST - 1)) == SUBSEQUENT ? blend : MixBlend.setup;
 						if (timeline is RotateTimeline) {
 							applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);
 						} else
@@ -244,7 +245,7 @@ package spine.animation {
 					var direction : MixDirection = MixDirection.Out;
 					var timelineBlend: MixBlend;
 					var alpha : Number = 0;
-					switch (timelineMode[i]) {
+					switch (timelineMode[i] & (NOT_LAST - 1)) {
 					case SUBSEQUENT:
 						if (!attachments && timeline is AttachmentTimeline) continue;
 						if (!drawOrder && timeline is DrawOrderTimeline) continue;
@@ -271,7 +272,7 @@ package spine.animation {
 					else {	
 						if (timelineBlend == MixBlend.setup) {
 							if (timeline is AttachmentTimeline) {
-								if (attachments) direction = MixDirection.In;				
+								if (attachments || ((timelineMode[i] & NOT_LAST) == NOT_LAST)) direction = MixDirection.In;
 							} else if (timeline is DrawOrderTimeline) {
 								if (drawOrder) direction = MixDirection.In;
 							}
@@ -586,20 +587,51 @@ package spine.animation {
 			animationsChanged = false;
 
 			propertyIDs = new Dictionary();					
-				
-			for (var i : int = 0, n : int = tracks.length; i < n; i++) {
-				var entry : TrackEntry = tracks[i];
+			var i : int = 0;
+			var n: int = 0;
+			var entry : TrackEntry = null;
+			for (i = 0, n = tracks.length; i < n; i++) {
+				entry = tracks[i];
 				if (entry == null) continue;
 				while (entry.mixingFrom != null)
 					entry = entry.mixingFrom;
 				do {
-					if (entry.mixingTo == null || entry.mixBlend != MixBlend.add) setTimelineModes(entry);
+					if (entry.mixingTo == null || entry.mixBlend != MixBlend.add) computeHold(entry);
 					entry = entry.mixingTo;			
 				} while (entry != null);
 			}
+
+			propertyIDs = new Dictionary();
+			for (i = tracks.length - 1; i >= 0; i--) {
+				entry = tracks[i];
+				while (entry != null) {
+					computeNotLast(entry);
+					entry = entry.mixingFrom;
+				}
+			}
 		}
 		
-		private function setTimelineModes (entry: TrackEntry) {
+		private function computeNotLast (entry: TrackEntry) : void {
+			var timelines : Vector.<Timeline> = entry.animation.timelines;
+			var timelinesCount : int = entry.animation.timelines.length;
+			var timelineMode : Vector.<int> = entry.timelineMode;
+			var propertyIDs : Dictionary = this.propertyIDs;
+
+			for (var i : int = 0; i < timelinesCount; i++) {
+				if (timelines[i] is AttachmentTimeline) {
+					var timeline : AttachmentTimeline = AttachmentTimeline(timelines[i]);
+					var intId : int = timeline.slotIndex;
+					var id : String = intId.toString();
+					var contained : Object = propertyIDs[id];
+					propertyIDs[id] = true;
+					if (contained != null) {
+						timelineMode[i] |= NOT_LAST;
+					}
+				}
+			}
+		}
+
+		private function computeHold (entry: TrackEntry) : void {
 			var to: TrackEntry = entry.mixingTo;			
 			var timelines : Vector.<Timeline> = entry.animation.timelines;
 			var timelinesCount : int = entry.animation.timelines.length;
@@ -609,8 +641,9 @@ package spine.animation {
 			timelineHoldMix.length = 0;
 			var propertyIDs: Dictionary = this.propertyIDs;
 			
+			var i : int = 0;
 			if (to != null && to.holdPrevious) {
-				for (var i : int = 0; i < timelinesCount; i++) {										
+				for (i = 0; i < timelinesCount; i++) {
 					propertyIDs[timelines[i].getPropertyId().toString()] = true;			
 					timelineMode[i] = HOLD;
 				}
@@ -618,14 +651,16 @@ package spine.animation {
 			}
 
 			outer:
-			for (var i : int = 0; i < timelinesCount; i++) {
-				var intId : int = timelines[i].getPropertyId();
+			for (i = 0; i < timelinesCount; i++) {
+				var timeline : Timeline = Timeline(timelines[i]);
+				var intId : int = timeline.getPropertyId();
 				var id : String = intId.toString();			
 				var contained: Object = propertyIDs[id];
 				propertyIDs[id] = true;
 				if (contained != null) {
 					timelineMode[i] = AnimationState.SUBSEQUENT;
-				} else if (to == null || !hasTimeline(to, intId)) {				
+				} else if (to == null || timeline is AttachmentTimeline || timeline is DrawOrderTimeline
+					|| timeline is EventTimeline || !hasTimeline(to, intId)) {
 					timelineMode[i] = AnimationState.FIRST;
 				} else {					
 					for (var next : TrackEntry = to.mixingTo; next != null; next = next.mixingTo) {

spine-as3/spine-as3/src/spine/animation/DeformTimeline.as

@@ -64,12 +64,12 @@ package spine.animation {
 			var slotAttachment : Attachment = slot.attachment;
 			if (!(slotAttachment is VertexAttachment) || !(VertexAttachment(slotAttachment)).applyDeform(attachment)) return;
 			
-			var verticesArray : Vector.<Number> = slot.attachmentVertices;
-			if (verticesArray.length == 0) blend = MixBlend.setup;
+			var deformArray : Vector.<Number> = slot.deform;
+			if (deformArray.length == 0) blend = MixBlend.setup;
 			
 			var frameVertices : Vector.<Vector.<Number>> = this.frameVertices;
 			var vertexCount : int = frameVertices[0].length;
-			var vertices : Vector.<Number>;		
+			var deform : Vector.<Number>;
 
 			var frames : Vector.<Number> = this.frames;
 			var i : int;			
@@ -77,32 +77,32 @@ package spine.animation {
 				vertexAttachment = VertexAttachment(slotAttachment);
 				switch (blend) {
 				case MixBlend.setup:
-					verticesArray.length = 0;
+					deformArray.length = 0;
 					return;
 				case MixBlend.first:
 					if (alpha == 1) {
-						verticesArray.length = 0;
+						deformArray.length = 0;
 						return;
 					}
-					verticesArray.length = vertexCount;
-					vertices = verticesArray;
+					deformArray.length = vertexCount;
+					deform = deformArray;
 					if (vertexAttachment.bones == null) {
 						// Unweighted vertex positions.
 						setupVertices = vertexAttachment.vertices;
 						for (i = 0; i < vertexCount; i++)
-							vertices[i] += (setupVertices[i] - vertices[i]) * alpha;
+							deform[i] += (setupVertices[i] - deform[i]) * alpha;
 					} else {
 						// Weighted deform offsets.
 						alpha = 1 - alpha;
 						for (i = 0; i < vertexCount; i++)
-							vertices[i] *= alpha;
+							deform[i] *= alpha;
 					}
 				}
 				return;
 			}						
 
-			verticesArray.length = vertexCount;
-			vertices = verticesArray;
+			deformArray.length = vertexCount;
+			deform = deformArray;
 			var n : int;			
 			var setup : Number, prev : Number;
 			if (time >= frames[frames.length - 1]) { // Time is after last frame.
@@ -113,15 +113,15 @@ package spine.animation {
 						if (vertexAttachment.bones == null) {							
 							setupVertices = vertexAttachment.vertices;
 							for (i = 0; i < vertexCount; i++) {								
-								vertices[i] += lastVertices[i] - setupVertices[i];
+								deform[i] += lastVertices[i] - setupVertices[i];
 							}
 						} else {							
 							for (i = 0; i < vertexCount; i++)
-								vertices[i] += lastVertices[i];
+								deform[i] += lastVertices[i];
 						}
 					} else {						
 						for (i = 0, n = vertexCount; i < n; i++)
-							vertices[i] = lastVertices[i];
+							deform[i] = lastVertices[i];
 					}
 				} else {
 					switch (blend) {
@@ -132,28 +132,28 @@ package spine.animation {
 								setupVertices = vertexAttachment.vertices;
 								for (i = 0; i < vertexCount; i++) {
 									setup = setupVertices[i];
-									vertices[i] = setup + (lastVertices[i] - setup) * alpha;
+									deform[i] = setup + (lastVertices[i] - setup) * alpha;
 								}
 							} else {
 								// Weighted deform offsets, with alpha.
 								for (i = 0; i < vertexCount; i++)
-									vertices[i] = lastVertices[i] * alpha;
+									deform[i] = lastVertices[i] * alpha;
 							}
 							break;
 						case MixBlend.first:
 						case MixBlend.replace:
 							for (i = 0; i < vertexCount; i++)
-								vertices[i] += (lastVertices[i] - vertices[i]) * alpha;
+								deform[i] += (lastVertices[i] - deform[i]) * alpha;
 						case MixBlend.add:
 							vertexAttachment = VertexAttachment(slotAttachment);
 							if (vertexAttachment.bones == null) {								
 								setupVertices = vertexAttachment.vertices;
 								for (i = 0; i < vertexCount; i++) {									
-									vertices[i] += (lastVertices[i] - setupVertices[i]) * alpha;
+									deform[i] += (lastVertices[i] - setupVertices[i]) * alpha;
 								}
 							} else {
 								for (i = 0; i < vertexCount; i++)
-									vertices[i] += lastVertices[i] * alpha;
+									deform[i] += lastVertices[i] * alpha;
 							}							
 					}					
 				}
@@ -174,18 +174,18 @@ package spine.animation {
 						setupVertices = vertexAttachment.vertices;
 						for (i = 0; i < vertexCount; i++) {
 							prev = prevVertices[i];
-							vertices[i] += prev + (nextVertices[i] - prev) * percent - setupVertices[i];
+							deform[i] += prev + (nextVertices[i] - prev) * percent - setupVertices[i];
 						}
 					} else {						
 						for (i = 0; i < vertexCount; i++) {
 							prev = prevVertices[i];					
-							vertices[i] += prev + (nextVertices[i] - prev) * percent;
+							deform[i] += prev + (nextVertices[i] - prev) * percent;
 						}
 					}
 				} else {					
 					for (i = 0; i < vertexCount; i++) {						
 						prev = prevVertices[i];
-						vertices[i] = prev + (nextVertices[i] - prev) * percent;
+						deform[i] = prev + (nextVertices[i] - prev) * percent;
 					}
 				}
 			} else {
@@ -197,13 +197,13 @@ package spine.animation {
 							setupVertices = vertexAttachment.vertices;
 							for (i = 0; i < vertexCount; i++) {
 								prev = prevVertices[i], setup = setupVertices[i];
-								vertices[i] = setup + (prev + (nextVertices[i] - prev) * percent - setup) * alpha;
+								deform[i] = setup + (prev + (nextVertices[i] - prev) * percent - setup) * alpha;
 							}
 						} else {
 							// Weighted deform offsets, with alpha.
 							for (i = 0; i < vertexCount; i++) {
 								prev = prevVertices[i];
-								vertices[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;
+								deform[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;
 							}
 						}
 						break;
@@ -211,7 +211,7 @@ package spine.animation {
 					case MixBlend.replace:
 						for (i = 0; i < vertexCount; i++) {
 							prev = prevVertices[i];
-							vertices[i] += (prev + (nextVertices[i] - prev) * percent - vertices[i]) * alpha;
+							deform[i] += (prev + (nextVertices[i] - prev) * percent - deform[i]) * alpha;
 						}
 						break;
 					case MixBlend.add:
@@ -220,12 +220,12 @@ package spine.animation {
 							setupVertices = vertexAttachment.vertices;
 							for (i = 0; i < vertexCount; i++) {
 								prev = prevVertices[i], setup = setupVertices[i];
-								vertices[i] += (prev + (nextVertices[i] - prev) * percent - setupVertices[i]) * alpha;
+								deform[i] += (prev + (nextVertices[i] - prev) * percent - setupVertices[i]) * alpha;
 							}
 						} else {							
 							for (i = 0; i < vertexCount; i++) {
 								prev = prevVertices[i];
-								vertices[i] += (prev + (nextVertices[i] - prev) * percent) * alpha;
+								deform[i] += (prev + (nextVertices[i] - prev) * percent) * alpha;
 							}
 						}
 				}				

spine-as3/spine-as3/src/spine/attachments/VertexAttachment.as

@@ -53,7 +53,7 @@ package spine.attachments {
 		public function computeWorldVertices(slot : Slot, start : int, count : int, worldVertices : Vector.<Number>, offset : int, stride : int) : void {
 			count = offset + (count >> 1) * stride;
 			var skeleton : Skeleton = slot.skeleton;
-			var deformArray : Vector.<Number> = slot.attachmentVertices;
+			var deformArray : Vector.<Number> = slot.deform;
 			var vertices : Vector.<Number> = this.vertices;
 			var bones : Vector.<int> = this.bones;
 			var deform : Vector.<Number>;