Minor optimizations, clean up.

spine-as3/spine-as3/src/spine/Bone.as

@@ -83,7 +83,7 @@ public class Bone {
 			_worldScaleY = scaleY;
 			_worldRotation = rotation;
 		}
-		var radians:Number = _worldRotation * Math.PI / 180;
+		var radians:Number = _worldRotation * (Math.PI / 180);
 		var cos:Number = Math.cos(radians);
 		var sin:Number = Math.sin(radians);
 		_m00 = cos * _worldScaleX;

spine-as3/spine-as3/src/spine/Skeleton.as

@@ -58,7 +58,7 @@ public class Skeleton {
 		_bones = new Vector.<Bone>();
 		for each (var boneData:BoneData in data.bones) {
 			var parent:Bone = boneData.parent == null ? null : _bones[data.bones.indexOf(boneData.parent)];
-			_bones.push(new Bone(boneData, parent));
+			_bones[_bones.length] = new Bone(boneData, parent);
 		}
 
 		_slots = new Vector.<Slot>();
@@ -66,8 +66,8 @@ public class Skeleton {
 		for each (var slotData:SlotData in data.slots) {
 			var bone:Bone  = _bones[data.bones.indexOf(slotData.boneData)];
 			var slot:Slot  = new Slot(slotData, this, bone);
-			_slots.push(slot);
-			_drawOrder.push(slot);
+			_slots[_slots.length] = slot;
+			_drawOrder[_drawOrder.length] = slot;
 		}
 	}
 

spine-as3/spine-as3/src/spine/SkeletonBounds.as

@@ -49,14 +49,14 @@ public class SkeletonBounds {
 		
 		boundingBoxes.length = 0;
 		for each (var polygon:Polygon in polygons)
-			polygonPool.push(polygon);
+			polygonPool[polygonPool.length] = polygon;
 		polygons.length = 0;
 
 		for (var i:int = 0; i < slotCount; i++) {
 			var slot:Slot = slots[i];
 			var boundingBox:BoundingBoxAttachment = slot.attachment as BoundingBoxAttachment;
 			if (boundingBox == null) continue;
-			boundingBoxes.push(boundingBox);
+			boundingBoxes[boundingBoxes.length] = boundingBox;
 
 			var poolCount:int = polygonPool.length;
 			if (poolCount > 0) {
@@ -64,7 +64,7 @@ public class SkeletonBounds {
 				polygonPool.splice(poolCount - 1, 1);
 			} else
 				polygon = new Polygon();
-			polygons.push(polygon);
+			polygons[polygons.length] = polygon;
 
 			polygon.vertices.length = boundingBox.vertices.length;
 			boundingBox.computeWorldVertices(x, y, slot.bone, polygon.vertices);

spine-as3/spine-as3/src/spine/SkeletonData.as

@@ -48,7 +48,7 @@ public class SkeletonData {
 	public function addBone (bone:BoneData) : void {
 		if (bone == null)
 			throw new ArgumentError("bone cannot be null.");
-		bones.push(bone);
+		bones[bones.length] = bone;
 	}
 
 	/** @return May be null. */
@@ -78,7 +78,7 @@ public class SkeletonData {
 	public function addSlot (slot:SlotData) : void {
 		if (slot == null)
 			throw new ArgumentError("slot cannot be null.");
-		slots.push(slot);
+		slots[slots.length] = slot;
 	}
 
 	/** @return May be null. */
@@ -108,7 +108,7 @@ public class SkeletonData {
 	public function addSkin (skin:Skin) : void {
 		if (skin == null)
 			throw new ArgumentError("skin cannot be null.");
-		skins.push(skin);
+		skins[skins.length] = skin;
 	}
 
 	/** @return May be null. */
@@ -126,7 +126,7 @@ public class SkeletonData {
 	public function addEvent (eventData:EventData) : void {
 		if (eventData == null)
 			throw new ArgumentError("eventData cannot be null.");
-		events.push(eventData);
+		events[events.length] = eventData;
 	}
 	
 	/** @return May be null. */
@@ -146,7 +146,7 @@ public class SkeletonData {
 	public function addAnimation (animation:Animation) : void {
 		if (animation == null)
 			throw new ArgumentError("animation cannot be null.");
-		animations.push(animation);
+		animations[animations.length] = animation;
 	}
 	
 	/** @return May be null. */

spine-as3/spine-as3/src/spine/SkeletonJson.as

@@ -184,8 +184,9 @@ public class SkeletonJson {
 			regionAttachment.updateOffset();
 		} else if (attachment is BoundingBoxAttachment) {
 			var box:BoundingBoxAttachment = attachment as BoundingBoxAttachment;
+			var vertices:Vector.<Number> = box.vertices;
 			for each (var point:Number in map["vertices"])
-				box.vertices.push(point * scale);
+				vertices[vertices.length] = point * scale;
 		}
 
 		return attachment;
@@ -214,7 +215,7 @@ public class SkeletonJson {
 						readCurve(timeline, frameIndex, valueMap);
 						frameIndex++;
 					}
-					timelines.push(timeline);
+					timelines[timelines.length] = timeline;
 					duration = Math.max(duration, timeline.frames[timeline.frameCount * 2 - 2]);
 
 				} else if (timelineName == TIMELINE_TRANSLATE || timelineName == TIMELINE_SCALE) {
@@ -236,7 +237,7 @@ public class SkeletonJson {
 						readCurve(timeline1, frameIndex1, valueMap1);
 						frameIndex1++;
 					}
-					timelines.push(timeline1);
+					timelines[timelines.length] = timeline1;
 					duration = Math.max(duration, timeline1.frames[timeline1.frameCount * 3 - 3]);
 
 				} else
@@ -266,7 +267,7 @@ public class SkeletonJson {
 						readCurve(timeline2, frameIndex2, valueMap2);
 						frameIndex2++;
 					}
-					timelines.push(timeline2);
+					timelines[timelines.length] = timeline2;
 					duration = Math.max(duration, timeline2.frames[timeline2.frameCount * 5 - 5]);
 
 				} else if (timelineName2 == TIMELINE_ATTACHMENT) {
@@ -277,7 +278,7 @@ public class SkeletonJson {
 					for each (var valueMap3:Object in values2) {
 						timeline3.setFrame(frameIndex3++, valueMap3["time"], valueMap3["name"]);
 					}
-					timelines.push(timeline3);
+					timelines[timelines.length] = timeline3;
 					duration = Math.max(duration, timeline3.frames[timeline3.frameCount - 1]);
 
 				} else
@@ -298,7 +299,7 @@ public class SkeletonJson {
 				event.stringValue = eventMap.hasOwnProperty("string") ? eventMap["string"] : eventData.stringValue;
 				timeline4.setFrame(frameIndex4++, eventMap["time"], event);
 			}
-			timelines.push(timeline4);
+			timelines[timelines.length] = timeline4;
 			duration = Math.max(duration, timeline4.frames[timeline4.frameCount - 1]);
 		}
 
@@ -334,7 +335,7 @@ public class SkeletonJson {
 				}
 				timeline5.setFrame(frameIndex5++, drawOrderMap["time"], drawOrder);
 			}
-			timelines.push(timeline5);
+			timelines[timelines.length] = timeline5;
 			duration = Math.max(duration, timeline5.frames[timeline5.frameCount - 1]);
 		}
 

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

@@ -99,7 +99,7 @@ public class Animation {
 			return step;
 		var current:int = high >>> 1;
 		while (true) {
-			if (values[(current + 1) * step] <= target)
+			if (values[int((current + 1) * step)] <= target)
 				low = current + 1;
 			else
 				high = current;

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

@@ -139,7 +139,7 @@ public class AnimationState {
 	private function expandToIndex (index:int) : TrackEntry {
 		if (index < _tracks.length) return _tracks[index];
 		while (index >= _tracks.length)
-			_tracks.push(null);
+			_tracks[_tracks.length] = null;
 		return null;
 	}
 	

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

@@ -60,7 +60,7 @@ public class AttachmentTimeline implements Timeline {
 			return; // Time is before first frame.
 
 		var frameIndex:int;
-		if (time >= frames[frames.length - 1]) // Time is after last frame.
+		if (time >= frames[int(frames.length - 1)]) // Time is after last frame.
 			frameIndex = frames.length - 1;
 		else
 			frameIndex = Animation.binarySearch(frames, time, 1) - 1;

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

@@ -37,7 +37,7 @@ import spine.Skeleton;
 import spine.Slot;
 
 public class ColorTimeline extends CurveTimeline {
-	static private const LAST_FRAME_TIME:int = -5;
+	static private const PREV_FRAME_TIME:int = -5;
 	static private const FRAME_R:int = 1;
 	static private const FRAME_G:int = 2;
 	static private const FRAME_B:int = 3;
@@ -55,10 +55,10 @@ public class ColorTimeline extends CurveTimeline {
 	public function setFrame (frameIndex:int, time:Number, r:Number, g:Number, b:Number, a:Number) : void {
 		frameIndex *= 5;
 		frames[frameIndex] = time;
-		frames[frameIndex + 1] = r;
-		frames[frameIndex + 2] = g;
-		frames[frameIndex + 3] = b;
-		frames[frameIndex + 4] = a;
+		frames[int(frameIndex + 1)] = r;
+		frames[int(frameIndex + 2)] = g;
+		frames[int(frameIndex + 3)] = b;
+		frames[int(frameIndex + 4)] = a;
 	}
 
 	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number) : void {
@@ -67,29 +67,29 @@ public class ColorTimeline extends CurveTimeline {
 
 		var slot:Slot = skeleton.slots[slotIndex];
 
-		if (time >= frames[frames.length - 5]) { // Time is after last frame.
+		if (time >= frames[int(frames.length - 5)]) { // Time is after last frame.
 			var i:int = frames.length - 1;
-			slot.r = frames[i - 3];
-			slot.g = frames[i - 2];
-			slot.b = frames[i - 1];
+			slot.r = frames[int(i - 3)];
+			slot.g = frames[int(i - 2)];
+			slot.b = frames[int(i - 1)];
 			slot.a = frames[i];
 			return;
 		}
 
-		// Interpolate between the last frame and the current frame.
+		// Interpolate between the previous frame and the current frame.
 		var frameIndex:int = Animation.binarySearch(frames, time, 5);
-		var lastFrameR:Number = frames[frameIndex - 4];
-		var lastFrameG:Number = frames[frameIndex - 3];
-		var lastFrameB:Number = frames[frameIndex - 2];
-		var lastFrameA:Number = frames[frameIndex - 1];
+		var prevFrameR:Number = frames[int(frameIndex - 4)];
+		var prevFrameG:Number = frames[int(frameIndex - 3)];
+		var prevFrameB:Number = frames[int(frameIndex - 2)];
+		var prevFrameA:Number = frames[int(frameIndex - 1)];
 		var frameTime:Number = frames[frameIndex];
-		var percent:Number = 1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime);
+		var percent:Number = 1 - (time - frameTime) / (frames[int(frameIndex + PREV_FRAME_TIME)] - frameTime);
 		percent = getCurvePercent(frameIndex / 5 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
 
-		var r:Number = lastFrameR + (frames[frameIndex + FRAME_R] - lastFrameR) * percent;
-		var g:Number = lastFrameG + (frames[frameIndex + FRAME_G] - lastFrameG) * percent;
-		var b:Number = lastFrameB + (frames[frameIndex + FRAME_B] - lastFrameB) * percent;
-		var a:Number = lastFrameA + (frames[frameIndex + FRAME_A] - lastFrameA) * percent;
+		var r:Number = prevFrameR + (frames[int(frameIndex + FRAME_R)] - prevFrameR) * percent;
+		var g:Number = prevFrameG + (frames[int(frameIndex + FRAME_G)] - prevFrameG) * percent;
+		var b:Number = prevFrameB + (frames[int(frameIndex + FRAME_B)] - prevFrameB) * percent;
+		var a:Number = prevFrameA + (frames[int(frameIndex + FRAME_A)] - prevFrameA) * percent;
 		if (alpha < 1) {
 			slot.r += (r - slot.r) * alpha;
 			slot.g += (g - slot.g) * alpha;

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

@@ -55,11 +55,11 @@ public class CurveTimeline implements Timeline {
 	}
 
 	public function setLinear (frameIndex:int) : void {
-		curves[frameIndex * 6] = LINEAR;
+		curves[int(frameIndex * 6)] = LINEAR;
 	}
 
 	public function setStepped (frameIndex:int) : void {
-		curves[frameIndex * 6] = STEPPED;
+		curves[int(frameIndex * 6)] = STEPPED;
 	}
 
 	/** Sets the control handle positions for an interpolation bezier curve used to transition from this keyframe to the next.
@@ -79,11 +79,11 @@ public class CurveTimeline implements Timeline {
 		var tmp2y:Number = (cy1 - cy2) * 3 + 1;
 		var i:int = frameIndex * 6;
 		curves[i] = cx1 * pre1 + tmp1x * pre2 + tmp2x * subdiv_step3;
-		curves[i + 1] = cy1 * pre1 + tmp1y * pre2 + tmp2y * subdiv_step3;
-		curves[i + 2] = tmp1x * pre4 + tmp2x * pre5;
-		curves[i + 3] = tmp1y * pre4 + tmp2y * pre5;
-		curves[i + 4] = tmp2x * pre5;
-		curves[i + 5] = tmp2y * pre5;
+		curves[int(i + 1)] = cy1 * pre1 + tmp1y * pre2 + tmp2y * subdiv_step3;
+		curves[int(i + 2)] = tmp1x * pre4 + tmp2x * pre5;
+		curves[int(i + 3)] = tmp1y * pre4 + tmp2y * pre5;
+		curves[int(i + 4)] = tmp2x * pre5;
+		curves[int(i + 5)] = tmp2y * pre5;
 	}
 
 	public function getCurvePercent (frameIndex:int, percent:Number) : Number {
@@ -93,19 +93,19 @@ public class CurveTimeline implements Timeline {
 			return percent;
 		if (dfx == STEPPED)
 			return 0;
-		var dfy:Number = curves[curveIndex + 1];
-		var ddfx:Number = curves[curveIndex + 2];
-		var ddfy:Number = curves[curveIndex + 3];
-		var dddfx:Number = curves[curveIndex + 4];
-		var dddfy:Number = curves[curveIndex + 5];
+		var dfy:Number = curves[int(curveIndex + 1)];
+		var ddfx:Number = curves[int(curveIndex + 2)];
+		var ddfy:Number = curves[int(curveIndex + 3)];
+		var dddfx:Number = curves[int(curveIndex + 4)];
+		var dddfy:Number = curves[int(curveIndex + 5)];
 		var x:Number = dfx;
 		var y:Number = dfy;
 		var i:int = BEZIER_SEGMENTS - 2;
 		while (true) {
 			if (x >= percent) {
-				var lastX:Number = x - dfx;
-				var lastY:Number = y - dfy;
-				return lastY + (y - lastY) * (percent - lastX) / (x - lastX);
+				var prevX:Number = x - dfx;
+				var prevY:Number = y - dfy;
+				return prevY + (y - prevY) * (percent - prevX) / (x - prevX);
 			}
 			if (i == 0)
 				break;

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

@@ -60,7 +60,7 @@ public class DrawOrderTimeline implements Timeline {
 			return; // Time is before first frame.
 
 		var frameIndex:int;
-		if (time >= frames[frames.length - 1]) // Time is after last frame.
+		if (time >= frames[int(frames.length - 1)]) // Time is after last frame.
 			frameIndex = frames.length - 1;
 		else
 			frameIndex = Animation.binarySearch(frames, time, 1) - 1;

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

@@ -62,7 +62,7 @@ public class EventTimeline implements Timeline {
 		if (lastTime > time) { // Fire events after last time for looped animations.
 			apply(skeleton, lastTime, int.MAX_VALUE, firedEvents, alpha);
 			lastTime = -1;
-		} else if (lastTime >= frames[frameCount - 1]) // Last time is after last frame.
+		} else if (lastTime >= frames[int(frameCount - 1)]) // Last time is after last frame.
 			return;
 		if (time < frames[0]) return; // Time is before first frame.
 		
@@ -73,12 +73,12 @@ public class EventTimeline implements Timeline {
 			frameIndex = Animation.binarySearch(frames, lastTime, 1);
 			var frame:Number = frames[frameIndex];
 			while (frameIndex > 0) { // Fire multiple events with the same frame.
-				if (frames[frameIndex - 1] != frame) break;
+				if (frames[int(frameIndex - 1)] != frame) break;
 				frameIndex--;
 			}
 		}
 		for (; frameIndex < frameCount && time >= frames[frameIndex]; frameIndex++)
-			firedEvents.push(events[frameIndex]);
+			firedEvents[firedEvents.length] = events[frameIndex];
 	}
 }
 

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

@@ -42,7 +42,7 @@ package spine.animation {
 		public function add (listener:Function) : void {
 			if (listener == null)
 				throw new ArgumentError("listener cannot be null.");
-			_listeners.push(listener);
+			_listeners[_listeners.length] = listener;
 		}
 
 		public function remove (listener:Function) : void {

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

@@ -37,7 +37,7 @@ import spine.Event;
 import spine.Skeleton;
 
 public class RotateTimeline extends CurveTimeline {
-	static private const LAST_FRAME_TIME:int = -2;
+	static private const PREV_FRAME_TIME:int = -2;
 	static private const FRAME_VALUE:int = 1;
 
 	public var boneIndex:int;
@@ -52,7 +52,7 @@ public class RotateTimeline extends CurveTimeline {
 	public function setFrame (frameIndex:int, time:Number, angle:Number) : void {
 		frameIndex *= 2;
 		frames[frameIndex] = time;
-		frames[frameIndex + 1] = angle;
+		frames[int(frameIndex + 1)] = angle;
 	}
 
 	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number) : void {
@@ -62,8 +62,8 @@ public class RotateTimeline extends CurveTimeline {
 		var bone:Bone = skeleton.bones[boneIndex];
 
 		var amount:Number;
-		if (time >= frames[frames.length - 2]) { // Time is after last frame.
-			amount = bone.data.rotation + frames[frames.length - 1] - bone.rotation;
+		if (time >= frames[int(frames.length - 2)]) { // Time is after last frame.
+			amount = bone.data.rotation + frames[int(frames.length - 1)] - bone.rotation;
 			while (amount > 180)
 				amount -= 360;
 			while (amount < -180)
@@ -72,19 +72,19 @@ public class RotateTimeline extends CurveTimeline {
 			return;
 		}
 
-		// Interpolate between the last frame and the current frame.
+		// Interpolate between the previous frame and the current frame.
 		var frameIndex:int = Animation.binarySearch(frames, time, 2);
-		var lastFrameValue:Number = frames[frameIndex - 1];
+		var prevFrameValue:Number = frames[int(frameIndex - 1)];
 		var frameTime:Number = frames[frameIndex];
-		var percent:Number = 1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime);
+		var percent:Number = 1 - (time - frameTime) / (frames[int(frameIndex + PREV_FRAME_TIME)] - frameTime);
 		percent = getCurvePercent(frameIndex / 2 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
 
-		amount = frames[frameIndex + FRAME_VALUE] - lastFrameValue;
+		amount = frames[int(frameIndex + FRAME_VALUE)] - prevFrameValue;
 		while (amount > 180)
 			amount -= 360;
 		while (amount < -180)
 			amount += 360;
-		amount = bone.data.rotation + (lastFrameValue + amount * percent) - bone.rotation;
+		amount = bone.data.rotation + (prevFrameValue + amount * percent) - bone.rotation;
 		while (amount > 180)
 			amount -= 360;
 		while (amount < -180)

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

@@ -46,22 +46,22 @@ public class ScaleTimeline extends TranslateTimeline {
 			return; // Time is before first frame.
 
 		var bone:Bone = skeleton.bones[boneIndex];
-		if (time >= frames[frames.length - 3]) { // Time is after last frame.
-			bone.scaleX += (bone.data.scaleX - 1 + frames[frames.length - 2] - bone.scaleX) * alpha;
-			bone.scaleY += (bone.data.scaleY - 1 + frames[frames.length - 1] - bone.scaleY) * alpha;
+		if (time >= frames[int(frames.length - 3)]) { // Time is after last frame.
+			bone.scaleX += (bone.data.scaleX - 1 + frames[int(frames.length - 2)] - bone.scaleX) * alpha;
+			bone.scaleY += (bone.data.scaleY - 1 + frames[int(frames.length - 1)] - bone.scaleY) * alpha;
 			return;
 		}
 
-		// Interpolate between the last frame and the current frame.
+		// Interpolate between the previous frame and the current frame.
 		var frameIndex:int = Animation.binarySearch(frames, time, 3);
-		var lastFrameX:Number = frames[frameIndex - 2];
-		var lastFrameY:Number = frames[frameIndex - 1];
+		var prevFrameX:Number = frames[int(frameIndex - 2)];
+		var prevFrameY:Number = frames[int(frameIndex - 1)];
 		var frameTime:Number = frames[frameIndex];
-		var percent:Number = 1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime);
+		var percent:Number = 1 - (time - frameTime) / (frames[int(frameIndex + PREV_FRAME_TIME)] - frameTime);
 		percent = getCurvePercent(frameIndex / 3 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
 
-		bone.scaleX += (bone.data.scaleX - 1 + lastFrameX + (frames[frameIndex + FRAME_X] - lastFrameX) * percent - bone.scaleX) * alpha;
-		bone.scaleY += (bone.data.scaleY - 1 + lastFrameY + (frames[frameIndex + FRAME_Y] - lastFrameY) * percent - bone.scaleY) * alpha;
+		bone.scaleX += (bone.data.scaleX - 1 + prevFrameX + (frames[int(frameIndex + FRAME_X)] - prevFrameX) * percent - bone.scaleX) * alpha;
+		bone.scaleY += (bone.data.scaleY - 1 + prevFrameY + (frames[int(frameIndex + FRAME_Y)] - prevFrameY) * percent - bone.scaleY) * alpha;
 	}
 }
 

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

@@ -37,7 +37,7 @@ import spine.Event;
 import spine.Skeleton;
 
 public class TranslateTimeline extends CurveTimeline {
-	static internal const LAST_FRAME_TIME:int = -3;
+	static internal const PREV_FRAME_TIME:int = -3;
 	static internal const FRAME_X:int = 1;
 	static internal const FRAME_Y:int = 2;
 
@@ -53,8 +53,8 @@ public class TranslateTimeline extends CurveTimeline {
 	public function setFrame (frameIndex:int, time:Number, x:Number, y:Number) : void {
 		frameIndex *= 3;
 		frames[frameIndex] = time;
-		frames[frameIndex + 1] = x;
-		frames[frameIndex + 2] = y;
+		frames[int(frameIndex + 1)] = x;
+		frames[int(frameIndex + 2)] = y;
 	}
 
 	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number) : void {
@@ -63,22 +63,22 @@ public class TranslateTimeline extends CurveTimeline {
 
 		var bone:Bone = skeleton.bones[boneIndex];
 
-		if (time >= frames[frames.length - 3]) { // Time is after last frame.
-			bone.x += (bone.data.x + frames[frames.length - 2] - bone.x) * alpha;
-			bone.y += (bone.data.y + frames[frames.length - 1] - bone.y) * alpha;
+		if (time >= frames[int(frames.length - 3)]) { // Time is after last frame.
+			bone.x += (bone.data.x + frames[int(frames.length - 2)] - bone.x) * alpha;
+			bone.y += (bone.data.y + frames[int(frames.length - 1)] - bone.y) * alpha;
 			return;
 		}
 
-		// Interpolate between the last frame and the current frame.
+		// Interpolate between the previous frame and the current frame.
 		var frameIndex:int = Animation.binarySearch(frames, time, 3);
-		var lastFrameX:Number = frames[frameIndex - 2];
-		var lastFrameY:Number = frames[frameIndex - 1];
+		var prevFrameX:Number = frames[int(frameIndex - 2)];
+		var prevFrameY:Number = frames[int(frameIndex - 1)];
 		var frameTime:Number = frames[frameIndex];
-		var percent:Number = 1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime);
+		var percent:Number = 1 - (time - frameTime) / (frames[int(frameIndex + PREV_FRAME_TIME)] - frameTime);
 		percent = getCurvePercent(frameIndex / 3 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
 
-		bone.x += (bone.data.x + lastFrameX + (frames[frameIndex + FRAME_X] - lastFrameX) * percent - bone.x) * alpha;
-		bone.y += (bone.data.y + lastFrameY + (frames[frameIndex + FRAME_Y] - lastFrameY) * percent - bone.y) * alpha;
+		bone.x += (bone.data.x + prevFrameX + (frames[int(frameIndex + FRAME_X)] - prevFrameX) * percent - bone.x) * alpha;
+		bone.y += (bone.data.y + prevFrameY + (frames[int(frameIndex + FRAME_Y)] - prevFrameY) * percent - bone.y) * alpha;
 	}
 }
 

spine-as3/spine-as3/src/spine/atlas/Atlas.as

@@ -89,7 +89,7 @@ public class Atlas {
 
 				textureLoader.loadPage(page, line);
 
-				pages.push(page);
+				pages[pages.length] = page;
 
 			} else {
 				var region:AtlasRegion = new AtlasRegion();
@@ -140,7 +140,7 @@ public class Atlas {
 				region.index = parseInt(reader.readValue());
 
 				textureLoader.loadRegion(region);
-				regions.push(region);
+				regions[regions.length] = region;
 			}
 		}
 	}

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

@@ -50,10 +50,11 @@ public dynamic class BoundingBoxAttachment extends Attachment {
 		var m11:Number = bone.m11;
 		var vertices:Vector.<Number> = this.vertices;
 		for (var i:int = 0, n:int = vertices.length; i < n; i += 2) {
+			var ii:int = i + 1;
 			var px:Number = vertices[i];
-			var py:Number = vertices[i + 1];
+			var py:Number = vertices[ii];
 			worldVertices[i] = px * m00 + py * m01 + x;
-			worldVertices[i + 1] = px * m10 + py * m11 + y;
+			worldVertices[ii] = px * m10 + py * m11 + y;
 		}
 	}
 }

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

@@ -126,14 +126,22 @@ public dynamic class RegionAttachment extends Attachment {
 		var m01:Number = bone.m01;
 		var m10:Number = bone.m10;
 		var m11:Number = bone.m11;
-		vertices[X1] = offset[X1] * m00 + offset[Y1] * m01 + x;
-		vertices[Y1] = offset[X1] * m10 + offset[Y1] * m11 + y;
-		vertices[X2] = offset[X2] * m00 + offset[Y2] * m01 + x;
-		vertices[Y2] = offset[X2] * m10 + offset[Y2] * m11 + y;
-		vertices[X3] = offset[X3] * m00 + offset[Y3] * m01 + x;
-		vertices[Y3] = offset[X3] * m10 + offset[Y3] * m11 + y;
-		vertices[X4] = offset[X4] * m00 + offset[Y4] * m01 + x;
-		vertices[Y4] = offset[X4] * m10 + offset[Y4] * m11 + y;
+		var x1:Number = offset[X1];
+		var y1:Number = offset[Y1];
+		var x2:Number = offset[X2];
+		var y2:Number = offset[Y2];
+		var x3:Number = offset[X3];
+		var y3:Number = offset[Y3];
+		var x4:Number = offset[X4];
+		var y4:Number = offset[Y4];
+		vertices[X1] = x1 * m00 + y1 * m01 + x;
+		vertices[Y1] = x1 * m10 + y1 * m11 + y;
+		vertices[X2] = x2 * m00 + y2 * m01 + x;
+		vertices[Y2] = x2 * m10 + y2 * m11 + y;
+		vertices[X3] = x3 * m00 + y3 * m01 + x;
+		vertices[Y3] = x3 * m10 + y3 * m11 + y;
+		vertices[X4] = x4 * m00 + y4 * m01 + x;
+		vertices[Y4] = x4 * m10 + y4 * m11 + y;
 	}
 }
 

spine-starling/spine-starling/src/spine/starling/SkeletonSprite.as

@@ -91,7 +91,10 @@ public class SkeletonSprite extends DisplayObject implements IAnimatable {
 
 				var image:SkeletonImage;
 				image = regionAttachment.rendererObject as SkeletonImage;
-				if (image == null) image = SkeletonImage(AtlasRegion(regionAttachment.rendererObject).rendererObject);
+				if (image == null) {
+					image = SkeletonImage(AtlasRegion(regionAttachment.rendererObject).rendererObject);
+					regionAttachment.rendererObject = image;
+				}
 
 				var vertexData:VertexData = image.vertexData;