[as3][starling] Formatting.

spine-as3/spine-as3-example/src/spine/examples/Main.as

@@ -27,70 +27,65 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
-
 package spine.examples {
+	import flash.display.Sprite;
 
-import flash.display.Sprite;
+	import spine.*;
+	import spine.animation.AnimationStateData;
+	import spine.atlas.Atlas;
+	import spine.attachments.AtlasAttachmentLoader;
+	import spine.flash.FlashTextureLoader;
+	import spine.flash.SkeletonAnimation;
 
-import spine.*;
-import spine.animation.AnimationStateData;
-import spine.atlas.Atlas;
-import spine.attachments.AtlasAttachmentLoader;
-import spine.flash.FlashTextureLoader;
-import spine.flash.SkeletonAnimation;
+	[SWF(width = "800", height = "600", frameRate = "60", backgroundColor = "#dddddd")]
+	public class Main extends Sprite {
+		[Embed(source = "/spineboy.atlas", mimeType = "application/octet-stream")]
+		static public const SpineboyAtlas : Class;
 
-[SWF(width = "800", height = "600", frameRate = "60", backgroundColor = "#dddddd")]
-public class Main extends Sprite {
-	[Embed(source = "/spineboy.atlas", mimeType = "application/octet-stream")]
-	static public const SpineboyAtlas:Class;
+		[Embed(source = "/spineboy.png")]
+		static public const SpineboyAtlasTexture : Class;
 
-	[Embed(source = "/spineboy.png")]
-	static public const SpineboyAtlasTexture:Class;
+		[Embed(source = "/spineboy.json", mimeType = "application/octet-stream")]
+		static public const SpineboyJson : Class;
+		private var skeleton : SkeletonAnimation;
 
-	[Embed(source = "/spineboy.json", mimeType = "application/octet-stream")]
-	static public const SpineboyJson:Class;
+		public function Main() {
+			var atlas : Atlas = new Atlas(new SpineboyAtlas(), new FlashTextureLoader(new SpineboyAtlasTexture()));
+			var json : SkeletonJson = new SkeletonJson(new AtlasAttachmentLoader(atlas));
+			json.scale = 0.6;
+			var skeletonData : SkeletonData = json.readSkeletonData(new SpineboyJson());
 
-	private var skeleton:SkeletonAnimation;
+			var stateData : AnimationStateData = new AnimationStateData(skeletonData);
+			stateData.setMixByName("walk", "jump", 0.2);
+			stateData.setMixByName("jump", "run", 0.4);
+			stateData.setMixByName("jump", "jump", 0.2);
 
-	public function Main () {
-		var atlas:Atlas = new Atlas(new SpineboyAtlas(), new FlashTextureLoader(new SpineboyAtlasTexture()));
-		var json:SkeletonJson = new SkeletonJson(new AtlasAttachmentLoader(atlas));
-		json.scale = 0.6;
-		var skeletonData:SkeletonData = json.readSkeletonData(new SpineboyJson());
+			skeleton = new SkeletonAnimation(skeletonData, stateData);
+			skeleton.x = 400;
+			skeleton.y = 560;
 
-		var stateData:AnimationStateData = new AnimationStateData(skeletonData);
-		stateData.setMixByName("walk", "jump", 0.2);
-		stateData.setMixByName("jump", "run", 0.4);
-		stateData.setMixByName("jump", "jump", 0.2);
+			skeleton.state.onStart.add(function(trackIndex : int) : void {
+				trace(trackIndex + " fuu start: " + skeleton.state.getCurrent(trackIndex));
+			});
+			skeleton.state.onEnd.add(function(trackIndex : int) : void {
+				trace(trackIndex + " end: " + skeleton.state.getCurrent(trackIndex));
+			});
+			skeleton.state.onComplete.add(function(trackIndex : int, count : int) : void {
+				trace(trackIndex + " complete: " + skeleton.state.getCurrent(trackIndex) + ", " + count);
+			});
+			skeleton.state.onEvent.add(function(trackIndex : int, event : Event) : void {
+				trace(trackIndex + " event: " + skeleton.state.getCurrent(trackIndex) + ", " + event.data.name + ": " + event.intValue + ", " + event.floatValue + ", " + event.stringValue);
+			});
 
-		skeleton = new SkeletonAnimation(skeletonData, stateData);
-		skeleton.x = 400;
-		skeleton.y = 560;
-		
-		skeleton.state.onStart.add(function (trackIndex:int) : void {
-			trace(trackIndex + " fuu start: " + skeleton.state.getCurrent(trackIndex));
-		});
-		skeleton.state.onEnd.add(function (trackIndex:int) : void {
-			trace(trackIndex + " end: " + skeleton.state.getCurrent(trackIndex));
-		});
-		skeleton.state.onComplete.add(function (trackIndex:int, count:int) : void {
-			trace(trackIndex + " complete: " + skeleton.state.getCurrent(trackIndex) + ", " + count);
-		});
-		skeleton.state.onEvent.add(function (trackIndex:int, event:Event) : void {
-			trace(trackIndex + " event: " + skeleton.state.getCurrent(trackIndex) + ", "
-				+ event.data.name + ": " + event.intValue + ", " + event.floatValue + ", " + event.stringValue);
-		});
-		
-		if (false) {
-			skeleton.state.setAnimationByName(0, "test", true);
-		} else {
-			skeleton.state.setAnimationByName(0, "walk", true);
-			skeleton.state.addAnimationByName(0, "jump", false, 3);
-			skeleton.state.addAnimationByName(0, "run", true, 0);
-		}
+			if (false) {
+				skeleton.state.setAnimationByName(0, "test", true);
+			} else {
+				skeleton.state.setAnimationByName(0, "walk", true);
+				skeleton.state.addAnimationByName(0, "jump", false, 3);
+				skeleton.state.addAnimationByName(0, "run", true, 0);
+			}
 
-		addChild(skeleton);
+			addChild(skeleton);
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/BlendMode.as

@@ -29,18 +29,15 @@
  *****************************************************************************/
 
 package spine {
+	public class BlendMode {
+		public static const normal : BlendMode = new BlendMode(0);
+		public static const additive : BlendMode = new BlendMode(1);
+		public static const multiply : BlendMode = new BlendMode(2);
+		public static const screen : BlendMode = new BlendMode(3);
+		public var ordinal : int;
 
-public class BlendMode {
-	public static const normal:BlendMode = new BlendMode(0);
-	public static const additive:BlendMode = new BlendMode(1);
-	public static const multiply:BlendMode = new BlendMode(2);
-	public static const screen:BlendMode = new BlendMode(3);
-
-	public var ordinal:int;
-
-	public function BlendMode (ordinal:int) {
-		this.ordinal = ordinal;
+		public function BlendMode(ordinal : int) {
+			this.ordinal = ordinal;
+		}
 	}
-}
-
-}
+}

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

@@ -29,314 +29,310 @@
  *****************************************************************************/
 
 package spine {
+	public class Bone implements Updatable {
+		static public var yDown : Boolean;
+		internal var _data : BoneData;
+		internal var _skeleton : Skeleton;
+		internal var _parent : Bone;
+		internal var _children : Vector.<Bone> = new Vector.<Bone>();
+		public var x : Number;
+		public var y : Number;
+		public var rotation : Number;
+		public var scaleX : Number;
+		public var scaleY : Number;
+		public var shearX : Number;
+		public var shearY : Number;
+		public var ax : Number;
+		public var ay : Number;
+		public var arotation : Number;
+		public var ascaleX : Number;
+		public var ascaleY : Number;
+		public var ashearX : Number;
+		public var ashearY : Number;
+		public var appliedValid : Boolean;
+		public var a : Number;
+		public var b : Number;
+		public var c : Number;
+		public var d : Number;
+		public var worldX : Number;
+		public var worldY : Number;
+		internal var _sorted : Boolean;
 
-public class Bone implements Updatable {
-	static public var yDown:Boolean;
+		/** @param parent May be null. */
+		public function Bone(data : BoneData, skeleton : Skeleton, parent : Bone) {
+			if (data == null) throw new ArgumentError("data cannot be null.");
+			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
+			_data = data;
+			_skeleton = skeleton;
+			_parent = parent;
+			setToSetupPose();
+		}
 
-	internal var _data:BoneData;
-	internal var _skeleton:Skeleton;
-	internal var _parent:Bone;
-	internal var _children:Vector.<Bone> = new Vector.<Bone>();
-	public var x:Number;
-	public var y:Number;
-	public var rotation:Number;
-	public var scaleX:Number;
-	public var scaleY:Number;
-	public var shearX:Number;
-	public var shearY:Number;
-	public var ax:Number;
-	public var ay:Number;
-	public var arotation:Number;
-	public var ascaleX:Number;
-	public var ascaleY:Number;
-	public var ashearX:Number;
-	public var ashearY:Number;
-	public var appliedValid:Boolean;	
+		/** Same as updateWorldTransform(). This method exists for Bone to implement Updatable. */
+		public function update() : void {
+			updateWorldTransformWith(x, y, rotation, scaleX, scaleY, shearX, shearY);
+		}
 
-	public var a:Number;
-	public var b:Number;
-	public var c:Number;
-	public var d:Number;
-	public var worldX:Number;
-	public var worldY:Number;
-	
-	internal var _sorted:Boolean;
+		/** Computes the world SRT using the parent bone and this bone's local SRT. */
+		public function updateWorldTransform() : void {
+			updateWorldTransformWith(x, y, rotation, scaleX, scaleY, shearX, shearY);
+		}
 
-	/** @param parent May be null. */
-	public function Bone (data:BoneData, skeleton:Skeleton, parent:Bone) {
-		if (data == null) throw new ArgumentError("data cannot be null.");
-		if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
-		_data = data;
-		_skeleton = skeleton;
-		_parent = parent;
-		setToSetupPose();
-	}
-	
-	/** Same as updateWorldTransform(). This method exists for Bone to implement Updatable. */
-	public function update () : void {
-		updateWorldTransformWith(x, y, rotation, scaleX, scaleY, shearX, shearY);
-	}
+		/** Computes the world SRT using the parent bone and the specified local SRT. */
+		public function updateWorldTransformWith(x : Number, y : Number, rotation : Number, scaleX : Number, scaleY : Number, shearX : Number, shearY : Number) : void {
+			ax = x;
+			ay = y;
+			arotation = rotation;
+			ascaleX = scaleX;
+			ascaleY = scaleY;
+			ashearX = shearX;
+			ashearY = shearY;
+			appliedValid = true;
 
-	/** Computes the world SRT using the parent bone and this bone's local SRT. */
-	public function updateWorldTransform () : void {
-		updateWorldTransformWith(x, y, rotation, scaleX, scaleY, shearX, shearY);
-	}
+			var rotationY : Number = 0, la : Number = 0, lb : Number = 0, lc : Number = 0, ld : Number = 0;
+			var sin : Number = 0, cos : Number = 0;
+			var s : Number = 0;
 
-	/** Computes the world SRT using the parent bone and the specified local SRT. */
-	public function updateWorldTransformWith (x:Number, y:Number, rotation:Number, scaleX:Number, scaleY:Number, shearX:Number, shearY:Number) : void {
-		ax = x;
-		ay = y;
-		arotation = rotation;
-		ascaleX = scaleX;
-		ascaleY = scaleY;
-		ashearX = shearX;
-		ashearY = shearY;
-		appliedValid = true;
-		
-		var rotationY:Number = 0, la:Number = 0, lb:Number = 0, lc:Number = 0, ld:Number = 0;
-		var sin:Number = 0, cos:Number = 0;
-		var s:Number = 0;
-		
-		var parent:Bone = _parent;
-		if (!parent) { // Root bone.
-			rotationY = rotation + 90 + shearY;
-			la = MathUtils.cosDeg(rotation + shearX) * scaleX;
-			lb = MathUtils.cosDeg(rotationY) * scaleY;
-			lc = MathUtils.sinDeg(rotation + shearX) * scaleX;
-			ld = MathUtils.sinDeg(rotationY) * scaleY;
-			var skeleton:Skeleton = _skeleton;
-			if (skeleton.flipX) {
-				x = -x;
-				la = -la;
-				lb = -lb;
+			var parent : Bone = _parent;
+			if (!parent) { // Root bone.
+				rotationY = rotation + 90 + shearY;
+				la = MathUtils.cosDeg(rotation + shearX) * scaleX;
+				lb = MathUtils.cosDeg(rotationY) * scaleY;
+				lc = MathUtils.sinDeg(rotation + shearX) * scaleX;
+				ld = MathUtils.sinDeg(rotationY) * scaleY;
+				var skeleton : Skeleton = _skeleton;
+				if (skeleton.flipX) {
+					x = -x;
+					la = -la;
+					lb = -lb;
+				}
+				if (skeleton.flipY != yDown) {
+					y = -y;
+					lc = -lc;
+					ld = -ld;
+				}
+				this.a = la;
+				this.b = lb;
+				this.c = lc;
+				this.d = ld;
+				worldX = x + skeleton.x;
+				worldY = y + skeleton.y;
+				return;
 			}
-			if (skeleton.flipY != yDown) {
-				y = -y;
-				lc = -lc;
-				ld = -ld;
-			}
-			this.a = la;
-			this.b = lb;
-			this.c = lc;
-			this.d = ld;
-			worldX = x + skeleton.x;
-			worldY = y + skeleton.y;	
-			return;
-		}
 
-		var pa:Number = parent.a, pb:Number = parent.b, pc:Number = parent.c, pd:Number = parent.d;
-		worldX = pa * x + pb * y + parent.worldX;
-		worldY = pc * x + pd * y + parent.worldY;		
+			var pa : Number = parent.a, pb : Number = parent.b, pc : Number = parent.c, pd : Number = parent.d;
+			worldX = pa * x + pb * y + parent.worldX;
+			worldY = pc * x + pd * y + parent.worldY;
 
-		switch (this.data.transformMode) {
-		case TransformMode.normal: {
-			rotationY = rotation + 90 + shearY;
-			la = MathUtils.cosDeg(rotation + shearX) * scaleX;
-			lb = MathUtils.cosDeg(rotationY) * scaleY;
-			lc = MathUtils.sinDeg(rotation + shearX) * scaleX;
-			ld = MathUtils.sinDeg(rotationY) * scaleY;
-			this.a = pa * la + pb * lc;
-			this.b = pa * lb + pb * ld;
-			this.c = pc * la + pd * lc;
-			this.d = pc * lb + pd * ld;
-			return;
-		}
-		case TransformMode.onlyTranslation: {
-			rotationY = rotation + 90 + shearY;
-			this.a = MathUtils.cosDeg(rotation + shearX) * scaleX;
-			this.b = MathUtils.cosDeg(rotationY) * scaleY;
-			this.c = MathUtils.sinDeg(rotation + shearX) * scaleX;
-			this.d = MathUtils.sinDeg(rotationY) * scaleY;
-			break;
-		}
-		case TransformMode.noRotationOrReflection: {
-			s = pa * pa + pc * pc;
-			var prx:Number = 0;
-			if (s > 0.0001) {
-				s = Math.abs(pa * pd - pb * pc) / s;
-				pb = pc * s;
-				pd = pa * s;
-				prx = Math.atan2(pc, pa) * MathUtils.radDeg;
-			} else {
-				pa = 0;
-				pc = 0;
-				prx = 90 - Math.atan2(pd, pb) * MathUtils.radDeg;
+			switch (this.data.transformMode) {
+				case TransformMode.normal: {
+					rotationY = rotation + 90 + shearY;
+					la = MathUtils.cosDeg(rotation + shearX) * scaleX;
+					lb = MathUtils.cosDeg(rotationY) * scaleY;
+					lc = MathUtils.sinDeg(rotation + shearX) * scaleX;
+					ld = MathUtils.sinDeg(rotationY) * scaleY;
+					this.a = pa * la + pb * lc;
+					this.b = pa * lb + pb * ld;
+					this.c = pc * la + pd * lc;
+					this.d = pc * lb + pd * ld;
+					return;
+				}
+				case TransformMode.onlyTranslation: {
+					rotationY = rotation + 90 + shearY;
+					this.a = MathUtils.cosDeg(rotation + shearX) * scaleX;
+					this.b = MathUtils.cosDeg(rotationY) * scaleY;
+					this.c = MathUtils.sinDeg(rotation + shearX) * scaleX;
+					this.d = MathUtils.sinDeg(rotationY) * scaleY;
+					break;
+				}
+				case TransformMode.noRotationOrReflection: {
+					s = pa * pa + pc * pc;
+					var prx : Number = 0;
+					if (s > 0.0001) {
+						s = Math.abs(pa * pd - pb * pc) / s;
+						pb = pc * s;
+						pd = pa * s;
+						prx = Math.atan2(pc, pa) * MathUtils.radDeg;
+					} else {
+						pa = 0;
+						pc = 0;
+						prx = 90 - Math.atan2(pd, pb) * MathUtils.radDeg;
+					}
+					var rx : Number = rotation + shearX - prx;
+					var ry : Number = rotation + shearY - prx + 90;
+					la = MathUtils.cosDeg(rx) * scaleX;
+					lb = MathUtils.cosDeg(ry) * scaleY;
+					lc = MathUtils.sinDeg(rx) * scaleX;
+					ld = MathUtils.sinDeg(ry) * scaleY;
+					this.a = pa * la - pb * lc;
+					this.b = pa * lb - pb * ld;
+					this.c = pc * la + pd * lc;
+					this.d = pc * lb + pd * ld;
+					break;
+				}
+				case TransformMode.noScale:
+				case TransformMode.noScaleOrReflection: {
+					cos = MathUtils.cosDeg(rotation);
+					sin = MathUtils.sinDeg(rotation);
+					var za : Number = pa * cos + pb * sin;
+					var zc : Number = pc * cos + pd * sin;
+					s = Math.sqrt(za * za + zc * zc);
+					if (s > 0.00001) s = 1 / s;
+					za *= s;
+					zc *= s;
+					s = Math.sqrt(za * za + zc * zc);
+					var r : Number = Math.PI / 2 + Math.atan2(zc, za);
+					var zb : Number = Math.cos(r) * s;
+					var zd : Number = Math.sin(r) * s;
+					la = MathUtils.cosDeg(shearX) * scaleX;
+					lb = MathUtils.cosDeg(90 + shearY) * scaleY;
+					lc = MathUtils.sinDeg(shearX) * scaleX;
+					ld = MathUtils.sinDeg(90 + shearY) * scaleY;
+					this.a = za * la + zb * lc;
+					this.b = za * lb + zb * ld;
+					this.c = zc * la + zd * lc;
+					this.d = zc * lb + zd * ld;
+					if (this.data.transformMode != TransformMode.noScaleOrReflection ? pa * pd - pb * pc < 0 : skeleton.flipX != skeleton.flipY) {
+						this.b = -this.b;
+						this.d = -this.d;
+					}
+					return;
+				}
 			}
-			var rx:Number = rotation + shearX - prx;
-			var ry:Number = rotation + shearY - prx + 90;
-			la = MathUtils.cosDeg(rx) * scaleX;
-			lb = MathUtils.cosDeg(ry) * scaleY;
-			lc = MathUtils.sinDeg(rx) * scaleX;
-			ld = MathUtils.sinDeg(ry) * scaleY;
-			this.a = pa * la - pb * lc;
-			this.b = pa * lb - pb * ld;
-			this.c = pc * la + pd * lc;
-			this.d = pc * lb + pd * ld;
-			break;
-		}
-		case TransformMode.noScale:
-		case TransformMode.noScaleOrReflection: {
-			cos = MathUtils.cosDeg(rotation);
-			sin = MathUtils.sinDeg(rotation);
-			var za:Number = pa * cos + pb * sin;
-			var zc:Number = pc * cos + pd * sin;
-			s = Math.sqrt(za * za + zc * zc);
-			if (s > 0.00001) s = 1 / s;
-			za *= s;
-			zc *= s;
-			s = Math.sqrt(za * za + zc * zc);
-			var r:Number = Math.PI / 2 + Math.atan2(zc, za);
-			var zb:Number = Math.cos(r) * s;
-			var zd:Number = Math.sin(r) * s;
-			la = MathUtils.cosDeg(shearX) * scaleX;
-			lb = MathUtils.cosDeg(90 + shearY) * scaleY;
-			lc = MathUtils.sinDeg(shearX) * scaleX;
-			ld = MathUtils.sinDeg(90 + shearY) * scaleY;
-			this.a = za * la + zb * lc;
-			this.b = za * lb + zb * ld;
-			this.c = zc * la + zd * lc;
-			this.d = zc * lb + zd * ld;
-			if (this.data.transformMode != TransformMode.noScaleOrReflection ? pa * pd - pb * pc < 0 : skeleton.flipX != skeleton.flipY) {
+			if (_skeleton.flipX) {
+				this.a = -this.a;
 				this.b = -this.b;
+			}
+			if (_skeleton.flipY != yDown) {
+				this.c = -this.c;
 				this.d = -this.d;
 			}
-			return;
 		}
+
+		public function setToSetupPose() : void {
+			x = this.data.x;
+			y = this.data.y;
+			rotation = this.data.rotation;
+			scaleX = this.data.scaleX;
+			scaleY = this.data.scaleY;
+			shearX = this.data.shearX;
+			shearY = this.data.shearY;
 		}
-		if (_skeleton.flipX) {
-			this.a = -this.a;
-			this.b = -this.b;
+
+		public function get data() : BoneData {
+			return _data;
 		}
-		if (_skeleton.flipY != yDown) {
-			this.c = -this.c;
-			this.d = -this.d;
+
+		public function get skeleton() : Skeleton {
+			return _skeleton;
 		}
-	}
 
-	public function setToSetupPose () : void {
-		x = this.data.x;
-		y = this.data.y;
-		rotation = this.data.rotation;
-		scaleX = this.data.scaleX;
-		scaleY = this.data.scaleY;
-		shearX = this.data.shearX;
-		shearY = this.data.shearY;
-	}
+		public function get parent() : Bone {
+			return _parent;
+		}
 
-	public function get data () : BoneData {
-		return _data;
-	}
-	
-	public function get skeleton () : Skeleton {
-		return _skeleton;
-	}
-	
-	public function get parent () : Bone {
-		return _parent;
-	}
-	
-	public function get children () : Vector.<Bone> {;
-		return _children;
-	}	
+		public function get children() : Vector.<Bone> {
+			;
+			return _children;
+		}
 
-	public function get worldRotationX () : Number {
-		return Math.atan2(this.c, this.a) * MathUtils.radDeg;
-	}
+		public function get worldRotationX() : Number {
+			return Math.atan2(this.c, this.a) * MathUtils.radDeg;
+		}
 
-	public function get worldRotationY () : Number {
-		return Math.atan2(this.d, this.b) * MathUtils.radDeg;
-	}
+		public function get worldRotationY() : Number {
+			return Math.atan2(this.d, this.b) * MathUtils.radDeg;
+		}
 
-	public function get worldScaleX () : Number {
-		return Math.sqrt(this.a * this.a + this.c * this.c);
-	}
+		public function get worldScaleX() : Number {
+			return Math.sqrt(this.a * this.a + this.c * this.c);
+		}
 
-	public function get worldScaleY () : Number {
-		return Math.sqrt(this.b * this.b + this.d * this.d);
-	}
+		public function get worldScaleY() : Number {
+			return Math.sqrt(this.b * this.b + this.d * this.d);
+		}
 
-	/** Computes the individual applied transform values from the world transform. This can be useful to perform processing using
-	 * the applied transform after the world transform has been modified directly (eg, by a constraint).
-	 * <p>
-	 * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. */
-	internal function updateAppliedTransform () : void {
-		appliedValid = true;
-		var parent:Bone = this.parent;
-		if (parent == null) {
-			ax = worldX;
-			ay = worldY;
-			arotation = Math.atan2(c, a) * MathUtils.radDeg;
-			ascaleX = Math.sqrt(a * a + c * c);
-			ascaleY = Math.sqrt(b * b + d * d);			
+		/** Computes the individual applied transform values from the world transform. This can be useful to perform processing using
+		 * the applied transform after the world transform has been modified directly (eg, by a constraint).
+		 * <p>
+		 * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. */
+		internal function updateAppliedTransform() : void {
+			appliedValid = true;
+			var parent : Bone = this.parent;
+			if (parent == null) {
+				ax = worldX;
+				ay = worldY;
+				arotation = Math.atan2(c, a) * MathUtils.radDeg;
+				ascaleX = Math.sqrt(a * a + c * c);
+				ascaleY = Math.sqrt(b * b + d * d);
+				ashearX = 0;
+				ashearY = Math.atan2(a * b + c * d, a * d - b * c) * MathUtils.radDeg;
+				return;
+			}
+			var pa : Number = parent.a, pb : Number = parent.b, pc : Number = parent.c, pd : Number = parent.d;
+			var pid : Number = 1 / (pa * pd - pb * pc);
+			var dx : Number = worldX - parent.worldX, dy : Number = worldY - parent.worldY;
+			ax = (dx * pd * pid - dy * pb * pid);
+			ay = (dy * pa * pid - dx * pc * pid);
+			var ia : Number = pid * pd;
+			var id : Number = pid * pa;
+			var ib : Number = pid * pb;
+			var ic : Number = pid * pc;
+			var ra : Number = ia * a - ib * c;
+			var rb : Number = ia * b - ib * d;
+			var rc : Number = id * c - ic * a;
+			var rd : Number = id * d - ic * b;
 			ashearX = 0;
-			ashearY = Math.atan2(a * b + c * d, a * d - b * c) * MathUtils.radDeg;
-			return;
+			ascaleX = Math.sqrt(ra * ra + rc * rc);
+			if (scaleX > 0.0001) {
+				var det : Number = ra * rd - rb * rc;
+				ascaleY = det / ascaleX;
+				ashearY = Math.atan2(ra * rb + rc * rd, det) * MathUtils.radDeg;
+				arotation = Math.atan2(rc, ra) * MathUtils.radDeg;
+			} else {
+				ascaleX = 0;
+				ascaleY = Math.sqrt(rb * rb + rd * rd);
+				ashearY = 0;
+				arotation = 90 - Math.atan2(rd, rb) * MathUtils.radDeg;
+			}
 		}
-		var pa:Number = parent.a, pb:Number = parent.b, pc:Number = parent.c, pd:Number = parent.d;
-		var pid:Number = 1 / (pa * pd - pb * pc);
-		var dx:Number = worldX - parent.worldX, dy:Number = worldY - parent.worldY;
-		ax = (dx * pd * pid - dy * pb * pid);
-		ay = (dy * pa * pid - dx * pc * pid);
-		var ia:Number = pid * pd;
-		var id:Number = pid * pa;
-		var ib:Number = pid * pb;
-		var ic:Number = pid * pc;
-		var ra:Number = ia * a - ib * c;
-		var rb:Number = ia * b - ib * d;
-		var rc:Number = id * c - ic * a;
-		var rd:Number = id * d - ic * b;
-		ashearX = 0;
-		ascaleX = Math.sqrt(ra * ra + rc * rc);
-		if (scaleX > 0.0001) {
-			var det:Number = ra * rd - rb * rc;
-			ascaleY = det /ascaleX;
-			ashearY = Math.atan2(ra * rb + rc * rd, det) * MathUtils.radDeg;
-			arotation = Math.atan2(rc, ra) * MathUtils.radDeg;
-		} else {
-			ascaleX = 0;
-			ascaleY = Math.sqrt(rb * rb + rd * rd);
-			ashearY = 0;
-			arotation = 90 - Math.atan2(rd, rb) * MathUtils.radDeg;
-		}		
-	}
 
-	public function worldToLocal (world:Vector.<Number>) : void {
-		var a:Number = this.a, b:Number = this.b, c:Number = this.c, d:Number = this.d;
-		var invDet:Number = 1 / (a * d - b * c);
-		var x:Number = world[0] - this.worldX, y:Number = world[1] - this.worldY;
-		world[0] = (x * d * invDet - y * b * invDet);
-		world[1] = (y * a * invDet - x * c * invDet);
-	}
+		public function worldToLocal(world : Vector.<Number>) : void {
+			var a : Number = this.a, b : Number = this.b, c : Number = this.c, d : Number = this.d;
+			var invDet : Number = 1 / (a * d - b * c);
+			var x : Number = world[0] - this.worldX, y : Number = world[1] - this.worldY;
+			world[0] = (x * d * invDet - y * b * invDet);
+			world[1] = (y * a * invDet - x * c * invDet);
+		}
 
-	public function localToWorld (local:Vector.<Number>) : void {
-		var localX:Number = local[0], localY:Number = local[1];
-		local[0] = localX * this.a + localY * this.b + this.worldX;
-		local[1] = localX * this.c + localY * this.d + this.worldY;
-	}
-	
-	public function worldToLocalRotation (worldRotation:Number) : Number {
-		var sin:Number = MathUtils.sinDeg(worldRotation), cos:Number = MathUtils.cosDeg(worldRotation);
-		return Math.atan2(this.a * sin - this.c * cos, this.d * cos - this.b * sin) * MathUtils.radDeg;
-	}
+		public function localToWorld(local : Vector.<Number>) : void {
+			var localX : Number = local[0], localY : Number = local[1];
+			local[0] = localX * this.a + localY * this.b + this.worldX;
+			local[1] = localX * this.c + localY * this.d + this.worldY;
+		}
 
-	public function localToWorldRotation (localRotation:Number) : Number {
-		var sin:Number = MathUtils.sinDeg(localRotation), cos:Number = MathUtils.cosDeg(localRotation);
-		return Math.atan2(cos * this.c + sin * this.d, cos * this.a + sin * this.b) * MathUtils.radDeg;
-	}
+		public function worldToLocalRotation(worldRotation : Number) : Number {
+			var sin : Number = MathUtils.sinDeg(worldRotation), cos : Number = MathUtils.cosDeg(worldRotation);
+			return Math.atan2(this.a * sin - this.c * cos, this.d * cos - this.b * sin) * MathUtils.radDeg;
+		}
 
-	public function rotateWorld (degrees:Number) : void {
-		var a:Number = this.a, b:Number = this.b, c:Number = this.c, d:Number = this.d;
-		var cos:Number = MathUtils.cosDeg(degrees), sin:Number = MathUtils.sinDeg(degrees);
-		this.a = cos * a - sin * c;
-		this.b = cos * b - sin * d;
-		this.c = sin * a + cos * c;
-		this.d = sin * b + cos * d;
-		this.appliedValid = false;
-	}
+		public function localToWorldRotation(localRotation : Number) : Number {
+			var sin : Number = MathUtils.sinDeg(localRotation), cos : Number = MathUtils.cosDeg(localRotation);
+			return Math.atan2(cos * this.c + sin * this.d, cos * this.a + sin * this.b) * MathUtils.radDeg;
+		}
 
-	public function toString () : String {
-		return this.data._name;
-	}
-}
+		public function rotateWorld(degrees : Number) : void {
+			var a : Number = this.a, b : Number = this.b, c : Number = this.c, d : Number = this.d;
+			var cos : Number = MathUtils.cosDeg(degrees), sin : Number = MathUtils.sinDeg(degrees);
+			this.a = cos * a - sin * c;
+			this.b = cos * b - sin * d;
+			this.c = sin * a + cos * c;
+			this.d = sin * b + cos * d;
+			this.appliedValid = false;
+		}
 
-}
+		public function toString() : String {
+			return this.data._name;
+		}
+	}
+}

spine-as3/spine-as3/src/spine/BoneData.as

@@ -29,46 +29,44 @@
  *****************************************************************************/
 
 package spine {
+	public class BoneData {
+		internal var _index : int;
+		internal var _name : String;
+		internal var _parent : BoneData;
+		public var length : Number;
+		public var x : Number;
+		public var y : Number;
+		public var rotation : Number;
+		public var scaleX : Number = 1;
+		public var scaleY : Number = 1;
+		public var shearX : Number;
+		public var shearY : Number;
+		public var transformMode : TransformMode = TransformMode.normal;
 
-public class BoneData {
-	internal var _index:int;
-	internal var _name:String;
-	internal var _parent:BoneData;
-	public var length:Number;
-	public var x:Number;
-	public var y:Number;
-	public var rotation:Number;
-	public var scaleX:Number = 1;
-	public var scaleY:Number = 1;
-	public var shearX:Number;
-	public var shearY:Number;	
-	public var transformMode:TransformMode = TransformMode.normal;
+		/** @param parent May be null. */
+		public function BoneData(index : int, name : String, parent : BoneData) {
+			if (index < 0) throw new ArgumentError("index must be >= 0");
+			if (name == null) throw new ArgumentError("name cannot be null.");
+			_index = index;
+			_name = name;
+			_parent = parent;
+		}
 
-	/** @param parent May be null. */
-	public function BoneData (index:int, name:String, parent:BoneData) {
-		if (index < 0) throw new ArgumentError("index must be >= 0");
-		if (name == null) throw new ArgumentError("name cannot be null.");
-		_index = index;
-		_name = name;
-		_parent = parent;
-	}
-	
-	public function get index () : int {
-		return _index;
-	}
+		public function get index() : int {
+			return _index;
+		}
 
-	public function get name () : String {
-		return _name;
-	}
+		public function get name() : String {
+			return _name;
+		}
 
-	/** @return May be null. */
-	public function get parent () : BoneData {
-		return _parent;
-	}
+		/** @return May be null. */
+		public function get parent() : BoneData {
+			return _parent;
+		}
 
-	public function toString () : String {
-		return _name;
+		public function toString() : String {
+			return _name;
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/Color.as

@@ -30,25 +30,24 @@
 
 package spine {
 	public class Color {
-		public static var WHITE:Color = new Color(1, 1, 1, 1);
-		public static var RED:Color = new Color(1, 0, 0, 1);
-		public static var GREEN:Color = new Color(0, 1, 0, 1);
-		public static var BLUE:Color = new Color(0, 0, 1, 1);
-		public static var MAGENTA:Color = new Color(1, 0, 1, 1);
+		public static var WHITE : Color = new Color(1, 1, 1, 1);
+		public static var RED : Color = new Color(1, 0, 0, 1);
+		public static var GREEN : Color = new Color(0, 1, 0, 1);
+		public static var BLUE : Color = new Color(0, 0, 1, 1);
+		public static var MAGENTA : Color = new Color(1, 0, 1, 1);
+		public var r : Number = 0;
+		public var g : Number = 0;
+		public var b : Number = 0;
+		public var a : Number = 0;
 
-		public var r:Number = 0;
-		public var g:Number = 0;
-		public var b:Number = 0;
-		public var a:Number = 0;
-
-		public function Color (r:Number, g:Number, b:Number, a:Number = 0) {
+		public function Color(r : Number, g : Number, b : Number, a : Number = 0) {
 			this.r = r;
 			this.g = g;
 			this.b = b;
 			this.a = a;
 		}
 
-		public function setFrom (r:Number, g:Number, b:Number, a:Number): Color {
+		public function setFrom(r : Number, g : Number, b : Number, a : Number) : Color {
 			this.r = r;
 			this.g = g;
 			this.b = b;
@@ -57,7 +56,7 @@ package spine {
 			return this;
 		}
 
-		public function setFromColor (c:Color): Color{
+		public function setFromColor(c : Color) : Color {
 			this.r = c.r;
 			this.g = c.g;
 			this.b = c.b;
@@ -65,7 +64,7 @@ package spine {
 			return this;
 		}
 
-		public function setFromString (hex:String): Color {
+		public function setFromString(hex : String) : Color {
 			hex = hex.charAt(0) == '#' ? hex.substr(1) : hex;
 			this.r = parseInt(hex.substr(0, 2), 16) / 255.0;
 			this.g = parseInt(hex.substr(2, 2), 16) / 255.0;
@@ -74,7 +73,7 @@ package spine {
 			return this;
 		}
 
-		public function add (r:Number, g:Number, b:Number, a:Number): Color {
+		public function add(r : Number, g : Number, b : Number, a : Number) : Color {
 			this.r += r;
 			this.g += g;
 			this.b += b;
@@ -83,7 +82,7 @@ package spine {
 			return this;
 		}
 
-		public function clamp (): Color {
+		public function clamp() : Color {
 			if (this.r < 0) this.r = 0;
 			else if (this.r > 1) this.r = 1;
 

spine-as3/spine-as3/src/spine/Constraint.as

@@ -29,9 +29,7 @@
  *****************************************************************************/
 
 package spine {
-
-public interface Constraint extends Updatable {
-	function getOrder () : Number;
-}
-
-}
+	public interface Constraint extends Updatable {
+		function getOrder() : Number;
+	}
+}

spine-as3/spine-as3/src/spine/Event.as

@@ -29,27 +29,25 @@
  *****************************************************************************/
 
 package spine {
+	public class Event {
+		internal var _data : EventData;
+		public var time : Number;
+		public var intValue : int;
+		public var floatValue : Number;
+		public var stringValue : String;
 
-public class Event {
-	internal var _data:EventData;
-	public var time:Number;
-	public var intValue:int;
-	public var floatValue:Number;
-	public var stringValue:String;
+		public function Event(time : Number, data : EventData) {
+			if (data == null) throw new ArgumentError("data cannot be null.");
+			this.time = time;
+			_data = data;
+		}
 
-	public function Event (time:Number, data:EventData) {
-		if (data == null) throw new ArgumentError("data cannot be null.");
-		this.time = time;
-		_data = data;
-	}
-
-	public function get data () : EventData {
-		return _data;
-	}
+		public function get data() : EventData {
+			return _data;
+		}
 
-	public function toString () : String {
-		return _data._name;
+		public function toString() : String {
+			return _data._name;
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/EventData.as

@@ -29,25 +29,24 @@
  *****************************************************************************/
 
 package spine {
+	public class EventData {
+		internal var _name : String;
+		public var intValue : int;
+		;
+		public var floatValue : Number;
+		public var stringValue : String;
 
-public class EventData {
-	internal var _name:String;
-	public var intValue:int;;
-	public var floatValue:Number;
-	public var stringValue:String;
-	
-	public function EventData (name:String) {
-		if (name == null) throw new ArgumentError("name cannot be null.");
-		_name = name;
-	}
+		public function EventData(name : String) {
+			if (name == null) throw new ArgumentError("name cannot be null.");
+			_name = name;
+		}
 
-	public function get name () : String {
-		return _name;
-	}
+		public function get name() : String {
+			return _name;
+		}
 
-	public function toString () : String {
-		return _name;
+		public function toString() : String {
+			return _name;
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/IkConstraint.as

@@ -29,207 +29,204 @@
  *****************************************************************************/
 
 package spine {
+	public class IkConstraint implements Constraint {
+		internal var _data : IkConstraintData;
+		public var bones : Vector.<Bone>;
+		public var target : Bone;
+		public var mix : Number;
+		public var bendDirection : int;
 
-public class IkConstraint implements Constraint {
-	internal var _data:IkConstraintData;
-	public var bones:Vector.<Bone>;
-	public var target:Bone;
-	public var mix:Number;
-	public var bendDirection:int;
+		public function IkConstraint(data : IkConstraintData, skeleton : Skeleton) {
+			if (data == null) throw new ArgumentError("data cannot be null.");
+			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
+			_data = data;
+			mix = data.mix;
+			bendDirection = data.bendDirection;
 
-	public function IkConstraint (data:IkConstraintData, skeleton:Skeleton) {
-		if (data == null) throw new ArgumentError("data cannot be null.");
-		if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
-		_data = data;
-		mix = data.mix;
-		bendDirection = data.bendDirection;
-
-		bones = new Vector.<Bone>();
-		for each (var boneData:BoneData in data.bones)
-			bones[bones.length] = skeleton.findBone(boneData.name);
-		target = skeleton.findBone(data.target._name);
-	}
-
-	public function apply () : void {
-		update();
-	}
-
-	public function update () : void {
-		switch (bones.length) {
-		case 1:
-			apply1(bones[0], target.worldX, target.worldY, mix);
-			break;
-		case 2:
-			apply2(bones[0], bones[1], target.worldX, target.worldY, bendDirection, mix);
-			break;
+			bones = new Vector.<Bone>();
+			for each (var boneData : BoneData in data.bones)
+				bones[bones.length] = skeleton.findBone(boneData.name);
+			target = skeleton.findBone(data.target._name);
 		}
-	}
-	
-	public function getOrder() : Number {
-		return _data.order;
-	}
 
-	public function get data () : IkConstraintData {
-		return _data;
-	}
+		public function apply() : void {
+			update();
+		}
 
-	public function toString () : String {
-		return _data._name;
-	}
-	
-	/** Adjusts the bone rotation so the tip is as close to the target position as possible. The target is specified in the world
-	 * coordinate system. */
-	static public function apply1 (bone:Bone, targetX:Number, targetY:Number, alpha:Number) : void {
-		if (!bone.appliedValid) bone.updateAppliedTransform();
-		var p:Bone = bone.parent;
-		var id:Number = 1 / (p.a * p.d - p.b * p.c);
-		var x:Number = targetX - p.worldX, y:Number = targetY - p.worldY;
-		var tx:Number = (x * p.d - y * p.b) * id - bone.ax, ty:Number = (y * p.a - x * p.c) * id - bone.ay;
-		var rotationIK:Number = Math.atan2(ty, tx) * MathUtils.radDeg - bone.ashearX - bone.arotation;
-		if (bone.ascaleX < 0) rotationIK += 180;
-		if (rotationIK > 180)
-			rotationIK -= 360;
-		else if (rotationIK < -180) rotationIK += 360;
-		bone.updateWorldTransformWith(bone.ax, bone.ay, bone.arotation + rotationIK * alpha, bone.ascaleX, bone.ascaleY, bone.ashearX,
-			bone.ashearY);
-	}
+		public function update() : void {
+			switch (bones.length) {
+				case 1:
+					apply1(bones[0], target.worldX, target.worldY, mix);
+					break;
+				case 2:
+					apply2(bones[0], bones[1], target.worldX, target.worldY, bendDirection, mix);
+					break;
+			}
+		}
 
-	/** Adjusts the parent and child bone rotations so the tip of the child is as close to the target position as possible. The
-	 * target is specified in the world coordinate system.
-	 * @param child Any descendant bone of the parent. */
-	static public function apply2 (parent:Bone, child:Bone, targetX:Number, targetY:Number, bendDir:int, alpha:Number) : void {
-		if (alpha == 0) {
-			child.updateWorldTransform();
-			return;
+		public function getOrder() : Number {
+			return _data.order;
 		}
-		if (!parent.appliedValid) parent.updateAppliedTransform();
-		if (!child.appliedValid) child.updateAppliedTransform();
-		var px:Number = parent.ax, py:Number = parent.ay, psx:Number = parent.ascaleX, psy:Number = parent.ascaleY, csx:Number = child.ascaleX;
-		var os1:int, os2:int, s2:int;
-		if (psx < 0) {
-			psx = -psx;
-			os1 = 180;
-			s2 = -1;
-		} else {
-			os1 = 0;
-			s2 = 1;
+
+		public function get data() : IkConstraintData {
+			return _data;
 		}
-		if (psy < 0) {
-			psy = -psy;
-			s2 = -s2;
+
+		public function toString() : String {
+			return _data._name;
 		}
-		if (csx < 0) {
-			csx = -csx;
-			os2 = 180;
-		} else
-			os2 = 0;
-		var cx:Number = child.ax, cy:Number, cwx:Number, cwy:Number, a:Number = parent.a, b:Number = parent.b, c:Number = parent.c, d:Number = parent.d;
-		var u:Boolean = Math.abs(psx - psy) <= 0.0001;
-		if (!u) {
-			cy = 0;
-			cwx = a * cx + parent.worldX;
-			cwy = c * cx + parent.worldY;
-		} else {
-			cy = child.ay;
-			cwx = a * cx + b * cy + parent.worldX;
-			cwy = c * cx + d * cy + parent.worldY;
+
+		/** Adjusts the bone rotation so the tip is as close to the target position as possible. The target is specified in the world
+		 * coordinate system. */
+		static public function apply1(bone : Bone, targetX : Number, targetY : Number, alpha : Number) : void {
+			if (!bone.appliedValid) bone.updateAppliedTransform();
+			var p : Bone = bone.parent;
+			var id : Number = 1 / (p.a * p.d - p.b * p.c);
+			var x : Number = targetX - p.worldX, y : Number = targetY - p.worldY;
+			var tx : Number = (x * p.d - y * p.b) * id - bone.ax, ty : Number = (y * p.a - x * p.c) * id - bone.ay;
+			var rotationIK : Number = Math.atan2(ty, tx) * MathUtils.radDeg - bone.ashearX - bone.arotation;
+			if (bone.ascaleX < 0) rotationIK += 180;
+			if (rotationIK > 180)
+				rotationIK -= 360;
+			else if (rotationIK < -180) rotationIK += 360;
+			bone.updateWorldTransformWith(bone.ax, bone.ay, bone.arotation + rotationIK * alpha, bone.ascaleX, bone.ascaleY, bone.ashearX, bone.ashearY);
 		}
-		var pp:Bone = parent.parent;
-		a = pp.a;
-		b = pp.b;
-		c = pp.c;
-		d = pp.d;
-		var id:Number = 1 / (a * d - b * c), x:Number = targetX - pp.worldX, y:Number = targetY - pp.worldY;
-		var tx:Number = (x * d - y * b) * id - px, ty:Number = (y * a - x * c) * id - py;
-		x = cwx - pp.worldX;
-		y = cwy - pp.worldY;
-		var dx:Number = (x * d - y * b) * id - px, dy:Number = (y * a - x * c) * id - py;
-		var l1:Number = Math.sqrt(dx * dx + dy * dy), l2:Number = child.data.length * csx, a1:Number, a2:Number;
-		outer:
-		if (u) {
-			l2 *= psx;
-			var cos:Number = (tx * tx + ty * ty - l1 * l1 - l2 * l2) / (2 * l1 * l2);
-			if (cos < -1)
-				cos = -1;
-			else if (cos > 1) cos = 1;
-			a2 = Math.acos(cos) * bendDir;
-			a = l1 + l2 * cos;
-			b = l2 * Math.sin(a2);
-			a1 = Math.atan2(ty * a - tx * b, tx * a + ty * b);
-		} else {
-			a = psx * l2;
-			b = psy * l2;
-			var aa:Number = a * a, bb:Number = b * b, dd:Number = tx * tx + ty * ty, ta:Number = Math.atan2(ty, tx);
-			c = bb * l1 * l1 + aa * dd - aa * bb;
-			var c1:Number = -2 * bb * l1, c2:Number = bb - aa;
-			d = c1 * c1 - 4 * c2 * c;
-			if (d >= 0) {
-				var q:Number = Math.sqrt(d);
-				if (c1 < 0) q = -q;
-				q = -(c1 + q) / 2;
-				var r0:Number = q / c2, r1:Number = c / q;
-				var r:Number = Math.abs(r0) < Math.abs(r1) ? r0 : r1;
-				if (r * r <= dd) {
-					y = Math.sqrt(dd - r * r) * bendDir;
-					a1 = ta - Math.atan2(y, r);
-					a2 = Math.atan2(y / psy, (r - l1) / psx);
-					break outer;
-				}
-			}
-			var minAngle:Number = 0, minDist:Number = Number.MAX_VALUE, minX:Number = 0, minY:Number = 0;
-			var maxAngle:Number = 0, maxDist:Number = 0, maxX:Number = 0, maxY:Number = 0;
-			x = l1 + a;
-			d = x * x;
-			if (d > maxDist) {
-				maxAngle = 0;
-				maxDist = d;
-				maxX = x;
+
+		/** Adjusts the parent and child bone rotations so the tip of the child is as close to the target position as possible. The
+		 * target is specified in the world coordinate system.
+		 * @param child Any descendant bone of the parent. */
+		static public function apply2(parent : Bone, child : Bone, targetX : Number, targetY : Number, bendDir : int, alpha : Number) : void {
+			if (alpha == 0) {
+				child.updateWorldTransform();
+				return;
 			}
-			x = l1 - a;
-			d = x * x;
-			if (d < minDist) {
-				minAngle = Math.PI;
-				minDist = d;
-				minX = x;
+			if (!parent.appliedValid) parent.updateAppliedTransform();
+			if (!child.appliedValid) child.updateAppliedTransform();
+			var px : Number = parent.ax, py : Number = parent.ay, psx : Number = parent.ascaleX, psy : Number = parent.ascaleY, csx : Number = child.ascaleX;
+			var os1 : int, os2 : int, s2 : int;
+			if (psx < 0) {
+				psx = -psx;
+				os1 = 180;
+				s2 = -1;
+			} else {
+				os1 = 0;
+				s2 = 1;
 			}
-			var angle:Number = Math.acos(-a * l1 / (aa - bb));
-			x = a * Math.cos(angle) + l1;
-			y = b * Math.sin(angle);
-			d = x * x + y * y;
-			if (d < minDist) {
-				minAngle = angle;
-				minDist = d;
-				minX = x;
-				minY = y;
+			if (psy < 0) {
+				psy = -psy;
+				s2 = -s2;
 			}
-			if (d > maxDist) {
-				maxAngle = angle;
-				maxDist = d;
-				maxX = x;
-				maxY = y;
+			if (csx < 0) {
+				csx = -csx;
+				os2 = 180;
+			} else
+				os2 = 0;
+			var cx : Number = child.ax, cy : Number, cwx : Number, cwy : Number, a : Number = parent.a, b : Number = parent.b, c : Number = parent.c, d : Number = parent.d;
+			var u : Boolean = Math.abs(psx - psy) <= 0.0001;
+			if (!u) {
+				cy = 0;
+				cwx = a * cx + parent.worldX;
+				cwy = c * cx + parent.worldY;
+			} else {
+				cy = child.ay;
+				cwx = a * cx + b * cy + parent.worldX;
+				cwy = c * cx + d * cy + parent.worldY;
 			}
-			if (dd <= (minDist + maxDist) / 2) {
-				a1 = ta - Math.atan2(minY * bendDir, minX);
-				a2 = minAngle * bendDir;
+			var pp : Bone = parent.parent;
+			a = pp.a;
+			b = pp.b;
+			c = pp.c;
+			d = pp.d;
+			var id : Number = 1 / (a * d - b * c), x : Number = targetX - pp.worldX, y : Number = targetY - pp.worldY;
+			var tx : Number = (x * d - y * b) * id - px, ty : Number = (y * a - x * c) * id - py;
+			x = cwx - pp.worldX;
+			y = cwy - pp.worldY;
+			var dx : Number = (x * d - y * b) * id - px, dy : Number = (y * a - x * c) * id - py;
+			var l1 : Number = Math.sqrt(dx * dx + dy * dy), l2 : Number = child.data.length * csx, a1 : Number, a2 : Number;
+			outer:
+			if (u) {
+				l2 *= psx;
+				var cos : Number = (tx * tx + ty * ty - l1 * l1 - l2 * l2) / (2 * l1 * l2);
+				if (cos < -1)
+					cos = -1;
+				else if (cos > 1) cos = 1;
+				a2 = Math.acos(cos) * bendDir;
+				a = l1 + l2 * cos;
+				b = l2 * Math.sin(a2);
+				a1 = Math.atan2(ty * a - tx * b, tx * a + ty * b);
 			} else {
-				a1 = ta - Math.atan2(maxY * bendDir, maxX);
-				a2 = maxAngle * bendDir;
+				a = psx * l2;
+				b = psy * l2;
+				var aa : Number = a * a, bb : Number = b * b, dd : Number = tx * tx + ty * ty, ta : Number = Math.atan2(ty, tx);
+				c = bb * l1 * l1 + aa * dd - aa * bb;
+				var c1 : Number = -2 * bb * l1, c2 : Number = bb - aa;
+				d = c1 * c1 - 4 * c2 * c;
+				if (d >= 0) {
+					var q : Number = Math.sqrt(d);
+					if (c1 < 0) q = -q;
+					q = -(c1 + q) / 2;
+					var r0 : Number = q / c2, r1 : Number = c / q;
+					var r : Number = Math.abs(r0) < Math.abs(r1) ? r0 : r1;
+					if (r * r <= dd) {
+						y = Math.sqrt(dd - r * r) * bendDir;
+						a1 = ta - Math.atan2(y, r);
+						a2 = Math.atan2(y / psy, (r - l1) / psx);
+						break outer;
+					}
+				}
+				var minAngle : Number = 0, minDist : Number = Number.MAX_VALUE, minX : Number = 0, minY : Number = 0;
+				var maxAngle : Number = 0, maxDist : Number = 0, maxX : Number = 0, maxY : Number = 0;
+				x = l1 + a;
+				d = x * x;
+				if (d > maxDist) {
+					maxAngle = 0;
+					maxDist = d;
+					maxX = x;
+				}
+				x = l1 - a;
+				d = x * x;
+				if (d < minDist) {
+					minAngle = Math.PI;
+					minDist = d;
+					minX = x;
+				}
+				var angle : Number = Math.acos(-a * l1 / (aa - bb));
+				x = a * Math.cos(angle) + l1;
+				y = b * Math.sin(angle);
+				d = x * x + y * y;
+				if (d < minDist) {
+					minAngle = angle;
+					minDist = d;
+					minX = x;
+					minY = y;
+				}
+				if (d > maxDist) {
+					maxAngle = angle;
+					maxDist = d;
+					maxX = x;
+					maxY = y;
+				}
+				if (dd <= (minDist + maxDist) / 2) {
+					a1 = ta - Math.atan2(minY * bendDir, minX);
+					a2 = minAngle * bendDir;
+				} else {
+					a1 = ta - Math.atan2(maxY * bendDir, maxX);
+					a2 = maxAngle * bendDir;
+				}
 			}
+			var os : Number = Math.atan2(cy, cx) * s2;
+			var rotation : Number = parent.arotation;
+			a1 = (a1 - os) * MathUtils.radDeg + os1 - rotation;
+			if (a1 > 180)
+				a1 -= 360;
+			else if (a1 < -180) a1 += 360;
+			parent.updateWorldTransformWith(px, py, rotation + a1 * alpha, parent.ascaleX, parent.ascaleY, 0, 0);
+			rotation = child.arotation;
+			a2 = ((a2 + os) * MathUtils.radDeg - child.ashearX) * s2 + os2 - rotation;
+			if (a2 > 180)
+				a2 -= 360;
+			else if (a2 < -180) a2 += 360;
+			child.updateWorldTransformWith(cx, cy, rotation + a2 * alpha, child.ascaleX, child.ascaleY, child.ashearX, child.ashearY);
 		}
-		var os:Number = Math.atan2(cy, cx) * s2;
-		var rotation:Number = parent.arotation;
-		a1 = (a1 - os) * MathUtils.radDeg + os1 - rotation;
-		if (a1 > 180)
-			a1 -= 360;
-		else if (a1 < -180) a1 += 360;
-		parent.updateWorldTransformWith(px, py, rotation + a1 * alpha, parent.ascaleX, parent.ascaleY, 0, 0);
-		rotation = child.arotation;
-		a2 = ((a2 + os) * MathUtils.radDeg - child.ashearX) * s2 + os2 - rotation;
-		if (a2 > 180)
-			a2 -= 360;
-		else if (a2 < -180) a2 += 360;
-		child.updateWorldTransformWith(cx, cy, rotation + a2 * alpha, child.ascaleX, child.ascaleY, child.ashearX, child.ashearY);
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/IkConstraintData.as

@@ -29,27 +29,25 @@
  *****************************************************************************/
 
 package spine {
+	public class IkConstraintData {
+		internal var _name : String;
+		public var order : Number;
+		public var bones : Vector.<BoneData> = new Vector.<BoneData>();
+		public var target : BoneData;
+		public var bendDirection : int = 1;
+		public var mix : Number = 1;
 
-public class IkConstraintData {
-	internal var _name:String;
-	public var order:Number;
-	public var bones:Vector.<BoneData> = new Vector.<BoneData>();
-	public var target:BoneData;
-	public var bendDirection:int = 1;
-	public var mix:Number = 1;
+		public function IkConstraintData(name : String) {
+			if (name == null) throw new ArgumentError("name cannot be null.");
+			_name = name;
+		}
 
-	public function IkConstraintData (name:String) {
-		if (name == null) throw new ArgumentError("name cannot be null.");
-		_name = name;
-	}
-
-	public function get name () : String {
-		return _name;
-	}
+		public function get name() : String {
+			return _name;
+		}
 
-	public function toString () : String {
-		return _name;
+		public function toString() : String {
+			return _name;
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/MathUtils.as

@@ -29,30 +29,28 @@
  *****************************************************************************/
 
 package spine {
+	public class MathUtils {
+		static public var PI : Number = Math.PI;
+		static public var PI2 : Number = Math.PI * 2;
+		static public var radDeg : Number = 180 / Math.PI;
+		static public var degRad : Number = Math.PI / 180;
 
-public class MathUtils {
-	static public var PI:Number = Math.PI;
-	static public var PI2:Number = Math.PI * 2;
-	static public var radDeg:Number = 180 / Math.PI;
-	static public var degRad:Number = Math.PI / 180;
-	
-	static public function cosDeg(degrees:Number): Number {
-		return Math.cos(degrees * degRad);
-	}
-	
-	static public function sinDeg(degrees:Number): Number {
-		return Math.sin(degrees * degRad);
-	}
-	
-	static public function clamp (value:Number, min:Number, max:Number) : Number {
-		if (value < min) return min;
-		if (value > max) return max;
-		return value;
-	}
-	
-	static public function signum (value: Number):Number {
-		return value > 0 ? 1 : value < 0 ? -1 : 0;
-	}
-}
+		static public function cosDeg(degrees : Number) : Number {
+			return Math.cos(degrees * degRad);
+		}
 
-}
+		static public function sinDeg(degrees : Number) : Number {
+			return Math.sin(degrees * degRad);
+		}
+
+		static public function clamp(value : Number, min : Number, max : Number) : Number {
+			if (value < min) return min;
+			if (value > max) return max;
+			return value;
+		}
+
+		static public function signum(value : Number) : Number {
+			return value > 0 ? 1 : value < 0 ? -1 : 0;
+		}
+	}
+}

spine-as3/spine-as3/src/spine/PathConstraint.as

@@ -29,403 +29,398 @@
  *****************************************************************************/
 
 package spine {
-import spine.attachments.PathAttachment;
+	import spine.attachments.PathAttachment;
 
-public class PathConstraint implements Constraint {
-	private static const NONE:int = -1, BEFORE:int = -2, AFTER:int = -3;
+	public class PathConstraint implements Constraint {
+		private static const NONE : int = -1, BEFORE : int = -2, AFTER : int = -3;
+		internal var _data : PathConstraintData;
+		internal var _bones : Vector.<Bone>;
+		public var target : Slot;
+		public var position : Number, spacing : Number, rotateMix : Number, translateMix : Number;
+		internal const _spaces : Vector.<Number> = new Vector.<Number>();
+		internal const _positions : Vector.<Number> = new Vector.<Number>();
+		internal const _world : Vector.<Number> = new Vector.<Number>();
+		internal const _curves : Vector.<Number> = new Vector.<Number>();
+		internal const _lengths : Vector.<Number> = new Vector.<Number>();
+		internal const _segments : Vector.<Number> = new Vector.<Number>(10);
 
-	internal var _data:PathConstraintData;
-	internal var _bones:Vector.<Bone>;
-	public var target:Slot;
-	public var position:Number, spacing:Number, rotateMix:Number, translateMix:Number;
-
-	internal const _spaces:Vector.<Number> = new Vector.<Number>();
-	internal const _positions:Vector.<Number> = new Vector.<Number>();
-	internal const _world:Vector.<Number> = new Vector.<Number>();
-	internal const _curves:Vector.<Number> = new Vector.<Number>();
-	internal const _lengths:Vector.<Number> = new Vector.<Number>();
-	internal const _segments:Vector.<Number> = new Vector.<Number>(10);	
+		public function PathConstraint(data : PathConstraintData, skeleton : Skeleton) {
+			if (data == null) throw new ArgumentError("data cannot be null.");
+			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
+			_data = data;
+			_bones = new Vector.<Bone>();
+			for each (var boneData : BoneData in data.bones)
+				_bones.push(skeleton.findBone(boneData.name));
+			target = skeleton.findSlot(data.target.name);
+			position = data.position;
+			spacing = data.spacing;
+			rotateMix = data.rotateMix;
+			translateMix = data.translateMix;
+		}
 
-	public function PathConstraint (data:PathConstraintData, skeleton:Skeleton) {
-		if (data == null) throw new ArgumentError("data cannot be null.");
-		if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
-		_data = data;
-		_bones = new Vector.<Bone>();		
-		for each (var boneData:BoneData in data.bones)
-			_bones.push(skeleton.findBone(boneData.name));
-		target = skeleton.findSlot(data.target.name);
-		position = data.position;
-		spacing = data.spacing;
-		rotateMix = data.rotateMix;
-		translateMix = data.translateMix;
-	}
+		public function apply() : void {
+			update();
+		}
 
-	public function apply () : void {
-		update();
-	}
-	
-	public function update () : void {
-		var attachment:PathAttachment = target.attachment as PathAttachment;
-		if (attachment == null) return;		
+		public function update() : void {
+			var attachment : PathAttachment = target.attachment as PathAttachment;
+			if (attachment == null) return;
 
-		var rotateMix:Number = this.rotateMix, translateMix:Number = this.translateMix;
-		var translate:Boolean = translateMix > 0, rotate:Boolean = rotateMix > 0;
-		if (!translate && !rotate) return;
+			var rotateMix : Number = this.rotateMix, translateMix : Number = this.translateMix;
+			var translate : Boolean = translateMix > 0, rotate : Boolean = rotateMix > 0;
+			if (!translate && !rotate) return;
 
-		var data:PathConstraintData = this._data;
-		var spacingMode:SpacingMode = data.spacingMode;
-		var lengthSpacing:Boolean = spacingMode == SpacingMode.length;
-		var rotateMode:RotateMode = data.rotateMode;
-		var tangents:Boolean = rotateMode == RotateMode.tangent, scale:Boolean = rotateMode == RotateMode.chainScale;
-		var boneCount:int = this._bones.length, spacesCount:int = tangents ? boneCount : boneCount + 1;
-		var bones:Vector.<Bone> = this._bones;
-		this._spaces.length = spacesCount;
-		var spaces:Vector.<Number> = this._spaces, lengths:Vector.<Number> = null;
-		var spacing:Number = this.spacing;
-		if (scale || lengthSpacing) {
-			if (scale) {
-				this._lengths.length = boneCount;
-				lengths = this._lengths;
-			}
-			for (var i:int = 0, n:int = spacesCount - 1; i < n;) {
-				var bone:Bone = bones[i];
-				var setupLength:Number = bone.data.length, x:Number = setupLength * bone.a, y:Number = setupLength * bone.c;
-				var length:Number = Math.sqrt(x * x + y * y);
-				if (scale) lengths[i] = length;
-				spaces[++i] = (lengthSpacing ? setupLength + spacing : spacing) * length / setupLength;
+			var data : PathConstraintData = this._data;
+			var spacingMode : SpacingMode = data.spacingMode;
+			var lengthSpacing : Boolean = spacingMode == SpacingMode.length;
+			var rotateMode : RotateMode = data.rotateMode;
+			var tangents : Boolean = rotateMode == RotateMode.tangent, scale : Boolean = rotateMode == RotateMode.chainScale;
+			var boneCount : int = this._bones.length, spacesCount : int = tangents ? boneCount : boneCount + 1;
+			var bones : Vector.<Bone> = this._bones;
+			this._spaces.length = spacesCount;
+			var spaces : Vector.<Number> = this._spaces, lengths : Vector.<Number> = null;
+			var spacing : Number = this.spacing;
+			if (scale || lengthSpacing) {
+				if (scale) {
+					this._lengths.length = boneCount;
+					lengths = this._lengths;
+				}
+				for (var i : int = 0, n : int = spacesCount - 1; i < n;) {
+					var bone : Bone = bones[i];
+					var setupLength : Number = bone.data.length, x : Number = setupLength * bone.a, y : Number = setupLength * bone.c;
+					var length : Number = Math.sqrt(x * x + y * y);
+					if (scale) lengths[i] = length;
+					spaces[++i] = (lengthSpacing ? setupLength + spacing : spacing) * length / setupLength;
+				}
+			} else {
+				for (i = 1; i < spacesCount; i++)
+					spaces[i] = spacing;
 			}
-		} else {
-			for (i = 1; i < spacesCount; i++)
-				spaces[i] = spacing;
-		}
 
-		var positions:Vector.<Number> = computeWorldPositions(attachment, spacesCount, tangents,
-			data.positionMode == PositionMode.percent, spacingMode == SpacingMode.percent);		
-		var boneX:Number = positions[0], boneY:Number = positions[1], offsetRotation:Number = data.offsetRotation;
-		var tip:Boolean = false;
-		if (offsetRotation == 0)
-			tip = rotateMode == RotateMode.chain;
-		else {
-			tip = false;
-			var pa:Bone = target.bone;
-			offsetRotation *= pa.a * pa.d - pa.b * pa.c > 0 ? MathUtils.degRad : -MathUtils.degRad;
-		}
-		var p:Number;
-		for (i = 0, p = 3; i < boneCount; i++, p += 3) {
-			bone = bones[i];
-			bone.worldX += (boneX - bone.worldX) * translateMix;
-			bone.worldY += (boneY - bone.worldY) * translateMix;
-			x = positions[p]; y = positions[p + 1]; var dx:Number = x - boneX, dy:Number = y - boneY;
-			if (scale) {
-				length = lengths[i];
-				if (length != 0) {
-					var s:Number = (Math.sqrt(dx * dx + dy * dy) / length - 1) * rotateMix + 1;
-					bone.a *= s;
-					bone.c *= s;
-				}
+			var positions : Vector.<Number> = computeWorldPositions(attachment, spacesCount, tangents, data.positionMode == PositionMode.percent, spacingMode == SpacingMode.percent);
+			var boneX : Number = positions[0], boneY : Number = positions[1], offsetRotation : Number = data.offsetRotation;
+			var tip : Boolean = false;
+			if (offsetRotation == 0)
+				tip = rotateMode == RotateMode.chain;
+			else {
+				tip = false;
+				var pa : Bone = target.bone;
+				offsetRotation *= pa.a * pa.d - pa.b * pa.c > 0 ? MathUtils.degRad : -MathUtils.degRad;
 			}
-			boneX = x;
-			boneY = y;
-			if (rotate) {
-				var a:Number = bone.a, b:Number = bone.b, c:Number = bone.c, d:Number = bone.d, r:Number, cos:Number, sin:Number;
-				if (tangents)
-					r = positions[p - 1];
-				else if (spaces[i + 1] == 0)
-					r = positions[p + 2];
-				else
-					r = Math.atan2(dy, dx);
-				r -= Math.atan2(c, a);	
-				if (tip) {
+			var p : Number;
+			for (i = 0, p = 3; i < boneCount; i++, p += 3) {
+				bone = bones[i];
+				bone.worldX += (boneX - bone.worldX) * translateMix;
+				bone.worldY += (boneY - bone.worldY) * translateMix;
+				x = positions[p];
+				y = positions[p + 1];
+				var dx : Number = x - boneX, dy : Number = y - boneY;
+				if (scale) {
+					length = lengths[i];
+					if (length != 0) {
+						var s : Number = (Math.sqrt(dx * dx + dy * dy) / length - 1) * rotateMix + 1;
+						bone.a *= s;
+						bone.c *= s;
+					}
+				}
+				boneX = x;
+				boneY = y;
+				if (rotate) {
+					var a : Number = bone.a, b : Number = bone.b, c : Number = bone.c, d : Number = bone.d, r : Number, cos : Number, sin : Number;
+					if (tangents)
+						r = positions[p - 1];
+					else if (spaces[i + 1] == 0)
+						r = positions[p + 2];
+					else
+						r = Math.atan2(dy, dx);
+					r -= Math.atan2(c, a);
+					if (tip) {
+						cos = Math.cos(r);
+						sin = Math.sin(r);
+						length = bone.data.length;
+						boneX += (length * (cos * a - sin * c) - dx) * rotateMix;
+						boneY += (length * (sin * a + cos * c) - dy) * rotateMix;
+					} else {
+						r += offsetRotation;
+					}
+					if (r > Math.PI)
+						r -= (Math.PI * 2);
+					else if (r < -Math.PI) //
+						r += (Math.PI * 2);
+					r *= rotateMix;
 					cos = Math.cos(r);
 					sin = Math.sin(r);
-					length = bone.data.length;
-					boneX += (length * (cos * a - sin * c) - dx) * rotateMix;
-					boneY += (length * (sin * a + cos * c) - dy) * rotateMix;
-				} else {
-					r += offsetRotation;
+					bone.a = cos * a - sin * c;
+					bone.b = cos * b - sin * d;
+					bone.c = sin * a + cos * c;
+					bone.d = sin * b + cos * d;
 				}
-				if (r > Math.PI)
-					r -= (Math.PI * 2);
-				else if (r < -Math.PI) //
-					r += (Math.PI * 2);
-				r *= rotateMix;
-				cos = Math.cos(r);
-				sin = Math.sin(r);
-				bone.a = cos * a - sin * c;
-				bone.b = cos * b - sin * d;
-				bone.c = sin * a + cos * c;
-				bone.d = sin * b + cos * d;
+				bone.appliedValid = false;
 			}
-			bone.appliedValid = false;
 		}
-	}
 
-	protected function computeWorldPositions (path:PathAttachment, spacesCount:int, tangents:Boolean, percentPosition:Boolean,
-		percentSpacing:Boolean) : Vector.<Number> {
-		var target:Slot = this.target;
-		var position:Number = this.position;
-		var spaces:Vector.<Number> = this._spaces;
-		this._positions.length = spacesCount * 3 + 2;
-		var out:Vector.<Number> = this._positions, world:Vector.<Number>;
-		var closed:Boolean = path.closed;
-		var verticesLength:int = path.worldVerticesLength, curveCount:int = verticesLength / 6, prevCurve:int = NONE;
+		protected function computeWorldPositions(path : PathAttachment, spacesCount : int, tangents : Boolean, percentPosition : Boolean, percentSpacing : Boolean) : Vector.<Number> {
+			var target : Slot = this.target;
+			var position : Number = this.position;
+			var spaces : Vector.<Number> = this._spaces;
+			this._positions.length = spacesCount * 3 + 2;
+			var out : Vector.<Number> = this._positions, world : Vector.<Number>;
+			var closed : Boolean = path.closed;
+			var verticesLength : int = path.worldVerticesLength, curveCount : int = verticesLength / 6, prevCurve : int = NONE;
+
+			if (!path.constantSpeed) {
+				var lengths : Vector.<Number> = path.lengths;
+				curveCount -= closed ? 1 : 2;
+				var pathLength : Number = lengths[curveCount];
+				if (percentPosition) position *= pathLength;
+				if (percentSpacing) {
+					for (var i : int = 0; i < spacesCount; i++)
+						spaces[i] *= pathLength;
+				}
+				this._world.length = 8;
+				world = this._world;
+				var o : int, curve : int;
+				for (i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) {
+					var space : Number = spaces[i];
+					position += space;
+					var p : Number = position;
+
+					if (closed) {
+						p %= pathLength;
+						if (p < 0) p += pathLength;
+						curve = 0;
+					} else if (p < 0) {
+						if (prevCurve != BEFORE) {
+							prevCurve = BEFORE;
+							path.computeWorldVertices(target, 2, 4, world, 0, 2);
+						}
+						addBeforePosition(p, world, 0, out, o);
+						continue;
+					} else if (p > pathLength) {
+						if (prevCurve != AFTER) {
+							prevCurve = AFTER;
+							path.computeWorldVertices(target, verticesLength - 6, 4, world, 0, 2);
+						}
+						addAfterPosition(p - pathLength, world, 0, out, o);
+						continue;
+					}
+
+					// Determine curve containing position.
+					for (;; curve++) {
+						var length : Number = lengths[curve];
+						if (p > length) continue;
+						if (curve == 0)
+							p /= length;
+						else {
+							var prev : Number = lengths[curve - 1];
+							p = (p - prev) / (length - prev);
+						}
+						break;
+					}
+					if (curve != prevCurve) {
+						prevCurve = curve;
+						if (closed && curve == curveCount) {
+							path.computeWorldVertices(target, verticesLength - 4, 4, world, 0, 2);
+							path.computeWorldVertices(target, 0, 4, world, 4, 2);
+						} else
+							path.computeWorldVertices(target, curve * 6 + 2, 8, world, 0, 2);
+					}
+					addCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], out, o, tangents || (i > 0 && space == 0));
+				}
+				return out;
+			}
+
+			// World vertices.
+			if (closed) {
+				verticesLength += 2;
+				this._world.length = verticesLength;
+				world = this._world;
+				path.computeWorldVertices(target, 2, verticesLength - 4, world, 0, 2);
+				path.computeWorldVertices(target, 0, 2, world, verticesLength - 4, 2);
+				world[verticesLength - 2] = world[0];
+				world[verticesLength - 1] = world[1];
+			} else {
+				curveCount--;
+				verticesLength -= 4;
+				this._world.length = verticesLength;
+				world = this._world;
+				path.computeWorldVertices(target, 2, verticesLength, world, 0, 2);
+			}
 
-		if (!path.constantSpeed) {
-			var lengths:Vector.<Number> = path.lengths;
-			curveCount -= closed ? 1 : 2;
-			var pathLength:Number = lengths[curveCount];
+			// Curve lengths.
+			this._curves.length = curveCount;
+			var curves : Vector.<Number> = this._curves;
+			pathLength = 0;
+			var x1 : Number = world[0], y1 : Number = world[1], cx1 : Number = 0, cy1 : Number = 0, cx2 : Number = 0, cy2 : Number = 0, x2 : Number = 0, y2 : Number = 0;
+			var tmpx : Number, tmpy : Number, dddfx : Number, dddfy : Number, ddfx : Number, ddfy : Number, dfx : Number, dfy : Number;
+			var w : int;
+			for (i = 0, w = 2; i < curveCount; i++, w += 6) {
+				cx1 = world[w];
+				cy1 = world[w + 1];
+				cx2 = world[w + 2];
+				cy2 = world[w + 3];
+				x2 = world[w + 4];
+				y2 = world[w + 5];
+				tmpx = (x1 - cx1 * 2 + cx2) * 0.1875;
+				tmpy = (y1 - cy1 * 2 + cy2) * 0.1875;
+				dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
+				dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
+				ddfx = tmpx * 2 + dddfx;
+				ddfy = tmpy * 2 + dddfy;
+				dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667;
+				dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667;
+				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+				dfx += ddfx;
+				dfy += ddfy;
+				ddfx += dddfx;
+				ddfy += dddfy;
+				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+				dfx += ddfx;
+				dfy += ddfy;
+				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+				dfx += ddfx + dddfx;
+				dfy += ddfy + dddfy;
+				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+				curves[i] = pathLength;
+				x1 = x2;
+				y1 = y2;
+			}
 			if (percentPosition) position *= pathLength;
 			if (percentSpacing) {
-				for (var i:int = 0; i < spacesCount; i++)
+				for (i = 0; i < spacesCount; i++)
 					spaces[i] *= pathLength;
 			}
-			this._world.length = 8;
-			world = this._world;
-			var o:int, curve:int;
-			for (i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) {
-				var space:Number = spaces[i];
+
+			var segments : Vector.<Number> = this._segments;
+			var curveLength : Number = 0;
+			var segment : int;
+			for (i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) {
+				space = spaces[i];
 				position += space;
-				var p:Number = position;
+				p = position;
 
 				if (closed) {
 					p %= pathLength;
 					if (p < 0) p += pathLength;
 					curve = 0;
 				} else if (p < 0) {
-					if (prevCurve != BEFORE) {
-						prevCurve = BEFORE;
-						path.computeWorldVertices(target, 2, 4, world, 0, 2);
-					}
 					addBeforePosition(p, world, 0, out, o);
 					continue;
 				} else if (p > pathLength) {
-					if (prevCurve != AFTER) {
-						prevCurve = AFTER;
-						path.computeWorldVertices(target, verticesLength - 6, 4, world, 0, 2);
-					}
-					addAfterPosition(p - pathLength, world, 0, out, o);
+					addAfterPosition(p - pathLength, world, verticesLength - 4, out, o);
 					continue;
 				}
 
 				// Determine curve containing position.
 				for (;; curve++) {
-					var length:Number = lengths[curve];
+					length = curves[curve];
 					if (p > length) continue;
 					if (curve == 0)
 						p /= length;
 					else {
-						var prev:Number = lengths[curve - 1];
+						prev = curves[curve - 1];
 						p = (p - prev) / (length - prev);
 					}
 					break;
 				}
+
+				// Curve segment lengths.
 				if (curve != prevCurve) {
 					prevCurve = curve;
-					if (closed && curve == curveCount) {
-						path.computeWorldVertices(target, verticesLength - 4, 4, world, 0, 2);
-						path.computeWorldVertices(target, 0, 4, world, 4, 2);
-					} else
-						path.computeWorldVertices(target, curve * 6 + 2, 8, world, 0, 2);
+					var ii : int = curve * 6;
+					x1 = world[ii];
+					y1 = world[ii + 1];
+					cx1 = world[ii + 2];
+					cy1 = world[ii + 3];
+					cx2 = world[ii + 4];
+					cy2 = world[ii + 5];
+					x2 = world[ii + 6];
+					y2 = world[ii + 7];
+					tmpx = (x1 - cx1 * 2 + cx2) * 0.03;
+					tmpy = (y1 - cy1 * 2 + cy2) * 0.03;
+					dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006;
+					dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006;
+					ddfx = tmpx * 2 + dddfx;
+					ddfy = tmpy * 2 + dddfy;
+					dfx = (cx1 - x1) * 0.3 + tmpx + dddfx * 0.16666667;
+					dfy = (cy1 - y1) * 0.3 + tmpy + dddfy * 0.16666667;
+					curveLength = Math.sqrt(dfx * dfx + dfy * dfy);
+					segments[0] = curveLength;
+					for (ii = 1; ii < 8; ii++) {
+						dfx += ddfx;
+						dfy += ddfy;
+						ddfx += dddfx;
+						ddfy += dddfy;
+						curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
+						segments[ii] = curveLength;
+					}
+					dfx += ddfx;
+					dfy += ddfy;
+					curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
+					segments[8] = curveLength;
+					dfx += ddfx + dddfx;
+					dfy += ddfy + dddfy;
+					curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
+					segments[9] = curveLength;
+					segment = 0;
 				}
-				addCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], out, o,
-					tangents || (i > 0 && space == 0));
+
+				// Weight by segment length.
+				p *= curveLength;
+				for (;; segment++) {
+					length = segments[segment];
+					if (p > length) continue;
+					if (segment == 0)
+						p /= length;
+					else {
+						prev = segments[segment - 1];
+						p = segment + (p - prev) / (length - prev);
+					}
+					break;
+				}
+				addCurvePosition(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents || (i > 0 && space == 0));
 			}
 			return out;
 		}
 
-		// World vertices.
-		if (closed) {
-			verticesLength += 2;
-			this._world.length = verticesLength;
-			world = this._world;
-			path.computeWorldVertices(target, 2, verticesLength - 4, world, 0, 2);
-			path.computeWorldVertices(target, 0, 2, world, verticesLength - 4, 2);
-			world[verticesLength - 2] = world[0];
-			world[verticesLength - 1] = world[1];
-		} else {
-			curveCount--;
-			verticesLength -= 4;
-			this._world.length = verticesLength;
-			world = this._world;
-			path.computeWorldVertices(target, 2, verticesLength, world, 0, 2);
+		private function addBeforePosition(p : Number, temp : Vector.<Number>, i : int, out : Vector.<Number>, o : int) : void {
+			var x1 : Number = temp[i], y1 : Number = temp[i + 1], dx : Number = temp[i + 2] - x1, dy : Number = temp[i + 3] - y1, r : Number = Math.atan2(dy, dx);
+			out[o] = x1 + p * Math.cos(r);
+			out[o + 1] = y1 + p * Math.sin(r);
+			out[o + 2] = r;
 		}
 
-		// Curve lengths.
-		this._curves.length = curveCount;
-		var curves:Vector.<Number> = this._curves;
-		pathLength = 0;
-		var x1:Number = world[0], y1:Number = world[1], cx1:Number = 0, cy1:Number = 0, cx2:Number = 0, cy2:Number = 0, x2:Number = 0, y2:Number = 0;
-		var tmpx:Number, tmpy:Number, dddfx:Number, dddfy:Number, ddfx:Number, ddfy:Number, dfx:Number, dfy:Number;
-		var w:int;
-		for (i = 0, w = 2; i < curveCount; i++, w += 6) {
-			cx1 = world[w];
-			cy1 = world[w + 1];
-			cx2 = world[w + 2];
-			cy2 = world[w + 3];
-			x2 = world[w + 4];
-			y2 = world[w + 5];
-			tmpx = (x1 - cx1 * 2 + cx2) * 0.1875;
-			tmpy = (y1 - cy1 * 2 + cy2) * 0.1875;
-			dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
-			dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
-			ddfx = tmpx * 2 + dddfx;
-			ddfy = tmpy * 2 + dddfy;
-			dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667;
-			dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667;
-			pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-			dfx += ddfx;
-			dfy += ddfy;
-			ddfx += dddfx;
-			ddfy += dddfy;
-			pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-			dfx += ddfx;
-			dfy += ddfy;
-			pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-			dfx += ddfx + dddfx;
-			dfy += ddfy + dddfy;
-			pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-			curves[i] = pathLength;
-			x1 = x2;
-			y1 = y2;
-		}
-		if (percentPosition) position *= pathLength;
-		if (percentSpacing) {
-			for (i = 0; i < spacesCount; i++)
-				spaces[i] *= pathLength;
+		private function addAfterPosition(p : Number, temp : Vector.<Number>, i : int, out : Vector.<Number>, o : int) : void {
+			var x1 : Number = temp[i + 2], y1 : Number = temp[i + 3], dx : Number = x1 - temp[i], dy : Number = y1 - temp[i + 1], r : Number = Math.atan2(dy, dx);
+			out[o] = x1 + p * Math.cos(r);
+			out[o + 1] = y1 + p * Math.sin(r);
+			out[o + 2] = r;
 		}
 
-		var segments:Vector.<Number> = this._segments;
-		var curveLength:Number = 0;
-		var segment:int;
-		for (i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) {
-			space = spaces[i];
-			position += space;
-			p = position;
-
-			if (closed) {
-				p %= pathLength;
-				if (p < 0) p += pathLength;
-				curve = 0;
-			} else if (p < 0) {
-				addBeforePosition(p, world, 0, out, o);
-				continue;
-			} else if (p > pathLength) {
-				addAfterPosition(p - pathLength, world, verticesLength - 4, out, o);
-				continue;
-			}
-
-			// Determine curve containing position.
-			for (;; curve++) {
-				length = curves[curve];
-				if (p > length) continue;
-				if (curve == 0)
-					p /= length;
-				else {
-					prev = curves[curve - 1];
-					p = (p - prev) / (length - prev);
-				}
-				break;
-			}
-
-			// Curve segment lengths.
-			if (curve != prevCurve) {
-				prevCurve = curve;
-				var ii:int = curve * 6;
-				x1 = world[ii];
-				y1 = world[ii + 1];
-				cx1 = world[ii + 2];
-				cy1 = world[ii + 3];
-				cx2 = world[ii + 4];
-				cy2 = world[ii + 5];
-				x2 = world[ii + 6];
-				y2 = world[ii + 7];
-				tmpx = (x1 - cx1 * 2 + cx2) * 0.03;
-				tmpy = (y1 - cy1 * 2 + cy2) * 0.03;
-				dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006;
-				dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006;
-				ddfx = tmpx * 2 + dddfx;
-				ddfy = tmpy * 2 + dddfy;
-				dfx = (cx1 - x1) * 0.3 + tmpx + dddfx * 0.16666667;
-				dfy = (cy1 - y1) * 0.3 + tmpy + dddfy * 0.16666667;
-				curveLength = Math.sqrt(dfx * dfx + dfy * dfy);
-				segments[0] = curveLength;
-				for (ii = 1; ii < 8; ii++) {
-					dfx += ddfx;
-					dfy += ddfy;
-					ddfx += dddfx;
-					ddfy += dddfy;
-					curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
-					segments[ii] = curveLength;
-				}
-				dfx += ddfx;
-				dfy += ddfy;
-				curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
-				segments[8] = curveLength;
-				dfx += ddfx + dddfx;
-				dfy += ddfy + dddfy;
-				curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
-				segments[9] = curveLength;
-				segment = 0;
-			}
-
-			// Weight by segment length.
-			p *= curveLength;
-			for (;; segment++) {
-				length = segments[segment];
-				if (p > length) continue;
-				if (segment == 0)
-					p /= length;
-				else {
-					prev = segments[segment - 1];
-					p = segment + (p - prev) / (length - prev);
-				}
-				break;
-			}
-			addCurvePosition(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents || (i > 0 && space == 0));
+		private function addCurvePosition(p : Number, x1 : Number, y1 : Number, cx1 : Number, cy1 : Number, cx2 : Number, cy2 : Number, x2 : Number, y2 : Number, out : Vector.<Number>, o : int, tangents : Boolean) : void {
+			if (p == 0 || isNaN(p)) p = 0.0001;
+			var tt : Number = p * p, ttt : Number = tt * p, u : Number = 1 - p, uu : Number = u * u, uuu : Number = uu * u;
+			var ut : Number = u * p, ut3 : Number = ut * 3, uut3 : Number = u * ut3, utt3 : Number = ut3 * p;
+			var x : Number = x1 * uuu + cx1 * uut3 + cx2 * utt3 + x2 * ttt, y : Number = y1 * uuu + cy1 * uut3 + cy2 * utt3 + y2 * ttt;
+			out[o] = x;
+			out[o + 1] = y;
+			if (tangents) out[o + 2] = Math.atan2(y - (y1 * uu + cy1 * ut * 2 + cy2 * tt), x - (x1 * uu + cx1 * ut * 2 + cx2 * tt));
 		}
-		return out;
-	}
-
-	private function addBeforePosition (p:Number, temp:Vector.<Number>, i:int, out:Vector.<Number>, o:int) : void {
-		var x1:Number = temp[i], y1:Number = temp[i + 1], dx:Number = temp[i + 2] - x1, dy:Number = temp[i + 3] - y1, r:Number = Math.atan2(dy, dx);
-		out[o] = x1 + p * Math.cos(r);
-		out[o + 1] = y1 + p * Math.sin(r);
-		out[o + 2] = r;
-	}
 
-	private function addAfterPosition (p:Number, temp:Vector.<Number>, i:int, out:Vector.<Number>, o:int) : void {
-		var x1:Number = temp[i + 2], y1:Number = temp[i + 3], dx:Number = x1 - temp[i], dy:Number = y1 - temp[i + 1], r:Number = Math.atan2(dy, dx);
-		out[o] = x1 + p * Math.cos(r);
-		out[o + 1] = y1 + p * Math.sin(r);
-		out[o + 2] = r;
-	}
+		public function get bones() : Vector.<Bone> {
+			return _bones;
+		}
 
-	private function addCurvePosition (p:Number, x1:Number, y1:Number, cx1:Number, cy1:Number, cx2:Number, cy2:Number, x2:Number, y2:Number,
-		out:Vector.<Number>, o:int, tangents:Boolean) : void {
-		if (p == 0 || isNaN(p)) p = 0.0001;
-		var tt:Number = p * p, ttt:Number = tt * p, u:Number = 1 - p, uu:Number = u * u, uuu:Number = uu * u;
-		var ut:Number = u * p, ut3:Number = ut * 3, uut3:Number = u * ut3, utt3:Number = ut3 * p;
-		var x:Number = x1 * uuu + cx1 * uut3 + cx2 * utt3 + x2 * ttt, y:Number = y1 * uuu + cy1 * uut3 + cy2 * utt3 + y2 * ttt;
-		out[o] = x;
-		out[o + 1] = y;
-		if (tangents) out[o + 2] = Math.atan2(y - (y1 * uu + cy1 * ut * 2 + cy2 * tt), x - (x1 * uu + cx1 * ut * 2 + cx2 * tt));
-	}
+		public function get data() : PathConstraintData {
+			return _data;
+		}
 
-	public function get bones () : Vector.<Bone> {
-		return _bones;
-	}
-	
-	public function get data () : PathConstraintData {
-		return _data;
-	}
-	
-	public function getOrder () : Number {
-		return _data.order;
-	}
+		public function getOrder() : Number {
+			return _data.order;
+		}
 
-	public function toString () : String {
-		return _data.name;
+		public function toString() : String {
+			return _data.name;
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/PathConstraintData.as

@@ -29,34 +29,32 @@
  *****************************************************************************/
 
 package spine {
+	public dynamic class PathConstraintData {
+		internal var _name : String;
+		public var order : Number;
+		internal var _bones : Vector.<BoneData> = new Vector.<BoneData>();
+		public var target : SlotData;
+		public var positionMode : PositionMode;
+		public var spacingMode : SpacingMode;
+		public var rotateMode : RotateMode;
+		public var offsetRotation : Number;
+		public var position : Number, spacing : Number, rotateMix : Number, translateMix : Number;
 
-public dynamic class PathConstraintData {
-	internal var _name:String;
-	public var order:Number;
-	internal var _bones:Vector.<BoneData> = new Vector.<BoneData>();
-	public var target:SlotData;
-	public var positionMode:PositionMode;
-	public var spacingMode:SpacingMode;
-	public var rotateMode:RotateMode;
-	public var offsetRotation:Number;
-	public var position:Number, spacing:Number, rotateMix:Number, translateMix:Number;
+		public function PathConstraintData(name : String) {
+			if (name == null) throw new ArgumentError("name cannot be null.");
+			_name = name;
+		}
 
-	public function PathConstraintData (name:String) {
-		if (name == null) throw new ArgumentError("name cannot be null.");
-		_name = name;
-	}
+		public function get bones() : Vector.<BoneData> {
+			return _bones;
+		}
 
-	public function get bones () : Vector.<BoneData> {
-		return _bones;
-	}
-	
-	public function get name () : String {
-		return _name;
-	}
+		public function get name() : String {
+			return _name;
+		}
 
-	public function toString () : String {
-		return name;
+		public function toString() : String {
+			return name;
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/Polygon.as

@@ -29,54 +29,52 @@
  *****************************************************************************/
 
 package spine {
+	public class Polygon {
+		public var vertices : Vector.<Number> = new Vector.<Number>();
 
-public class Polygon {
-	public var vertices:Vector.<Number> = new Vector.<Number>();
-	
-	public function Polygon () {		
-	}
-	
-	/** Returns true if the polygon contains the point. */
-	public function containsPoint (x:Number, y:Number) : Boolean {
-		var nn:int = vertices.length;
-		
-		var prevIndex:int = nn - 2;
-		var inside:Boolean = false;
-		for (var ii:int = 0; ii < nn; ii += 2) {
-			var vertexY:Number = vertices[ii + 1];
-			var prevY:Number = vertices[prevIndex + 1];
-			if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
-				var vertexX:Number = vertices[ii];
-				if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside;
+		public function Polygon() {
+		}
+
+		/** Returns true if the polygon contains the point. */
+		public function containsPoint(x : Number, y : Number) : Boolean {
+			var nn : int = vertices.length;
+
+			var prevIndex : int = nn - 2;
+			var inside : Boolean = false;
+			for (var ii : int = 0; ii < nn; ii += 2) {
+				var vertexY : Number = vertices[ii + 1];
+				var prevY : Number = vertices[prevIndex + 1];
+				if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
+					var vertexX : Number = vertices[ii];
+					if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside;
+				}
+				prevIndex = ii;
 			}
-			prevIndex = ii;
+
+			return inside;
 		}
-		
-		return inside;
-	}
 
-	/** Returns true if the polygon contains the line segment. */
-	public function intersectsSegment (x1:Number, y1:Number, x2:Number, y2:Number) : Boolean {
-		var nn:int = vertices.length;
-		
-		var width12:Number = x1 - x2, height12:Number = y1 - y2;
-		var det1:Number = x1 * y2 - y1 * x2;
-		var x3:Number = vertices[nn - 2], y3:Number = vertices[nn - 1];
-		for (var ii:int = 0; ii < nn; ii += 2) {
-			var x4:Number = vertices[ii], y4:Number = vertices[ii + 1];
-			var det2:Number = x3 * y4 - y3 * x4;
-			var width34:Number = x3 - x4, height34:Number = y3 - y4;
-			var det3:Number = width12 * height34 - height12 * width34;
-			var x:Number = (det1 * width34 - width12 * det2) / det3;
-			if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
-				var y:Number = (det1 * height34 - height12 * det2) / det3;
-				if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))) return true;
+		/** Returns true if the polygon contains the line segment. */
+		public function intersectsSegment(x1 : Number, y1 : Number, x2 : Number, y2 : Number) : Boolean {
+			var nn : int = vertices.length;
+
+			var width12 : Number = x1 - x2, height12 : Number = y1 - y2;
+			var det1 : Number = x1 * y2 - y1 * x2;
+			var x3 : Number = vertices[nn - 2], y3 : Number = vertices[nn - 1];
+			for (var ii : int = 0; ii < nn; ii += 2) {
+				var x4 : Number = vertices[ii], y4 : Number = vertices[ii + 1];
+				var det2 : Number = x3 * y4 - y3 * x4;
+				var width34 : Number = x3 - x4, height34 : Number = y3 - y4;
+				var det3 : Number = width12 * height34 - height12 * width34;
+				var x : Number = (det1 * width34 - width12 * det2) / det3;
+				if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
+					var y : Number = (det1 * height34 - height12 * det2) / det3;
+					if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))) return true;
+				}
+				x3 = x4;
+				y3 = y4;
 			}
-			x3 = x4;
-			y3 = y4;
+			return false;
 		}
-		return false;
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/Pool.as

@@ -29,32 +29,31 @@
  *****************************************************************************/
 
 package spine {
-	
-public class Pool {
-	internal var items:Vector.<Object> = new Vector.<Object>();
-	internal var instantiator:Function;
-	
-	public function Pool(instantiator:Function) {
-		this.instantiator = instantiator;
-	}
-	
-	public function obtain (): Object {
-		return this.items.length > 0 ? this.items.pop() : this.instantiator();
-	}
-	
-	public function free (item:Object):void {
-		if (item is Poolable) Poolable(item).reset();
-		items.push(item);
-	}
-	
-	public function freeAll (items:Vector):void {
-		for (var i:int = 0; i < items.length; i++) {
-			free(items[i]);
+	public class Pool {
+		internal var items : Vector.<Object> = new Vector.<Object>();
+		internal var instantiator : Function;
+
+		public function Pool(instantiator : Function) {
+			this.instantiator = instantiator;
+		}
+
+		public function obtain() : Object {
+			return this.items.length > 0 ? this.items.pop() : this.instantiator();
+		}
+
+		public function free(item : Object) : void {
+			if (item is Poolable) Poolable(item).reset();
+			items.push(item);
+		}
+
+		public function freeAll(items : Vector) : void {
+			for (var i : int = 0; i < items.length; i++) {
+				free(items[i]);
+			}
+		}
+
+		public function clear() : void {
+			items.length = 0;
 		}
 	}
-	
-	public function clear ():void {
-		items.length = 0;
-	}
-}
 }

spine-as3/spine-as3/src/spine/Poolable.as

@@ -1,5 +1,35 @@
+/******************************************************************************
+ * Spine Runtimes Software License v2.5
+ *
+ * Copyright (c) 2013-2016, Esoteric Software
+ * All rights reserved.
+ *
+ * You are granted a perpetual, non-exclusive, non-sublicensable, and
+ * non-transferable license to use, install, execute, and perform the Spine
+ * Runtimes software and derivative works solely for personal or internal
+ * use. Without the written permission of Esoteric Software (see Section 2 of
+ * the Spine Software License Agreement), you may not (a) modify, translate,
+ * adapt, or develop new applications using the Spine Runtimes or otherwise
+ * create derivative works or improvements of the Spine Runtimes or (b) remove,
+ * delete, alter, or obscure any trademarks or any copyright, trademark, patent,
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "AS IS" AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS INTERRUPTION, OR LOSS OF
+ * USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+
 package spine {
-public interface Poolable {
-	function reset ():void;
-}
+	public interface Poolable {
+		function reset() : void;
+	}
 }

spine-as3/spine-as3/src/spine/PositionMode.as

@@ -29,10 +29,8 @@
  *****************************************************************************/
 
 package spine {
-	
-public class PositionMode {
-	public static const fixed:PositionMode = new PositionMode();
-	public static const percent:PositionMode = new PositionMode();
-}
-
-}
+	public class PositionMode {
+		public static const fixed : PositionMode = new PositionMode();
+		public static const percent : PositionMode = new PositionMode();
+	}
+}

spine-as3/spine-as3/src/spine/RotateMode.as

@@ -29,11 +29,9 @@
  *****************************************************************************/
 
 package spine {
-
-public class RotateMode {
-	public static const tangent:RotateMode = new RotateMode();
-	public static const chain:RotateMode = new RotateMode();
-	public static const chainScale:RotateMode = new RotateMode();
-}
-
-}
+	public class RotateMode {
+		public static const tangent : RotateMode = new RotateMode();
+		public static const chain : RotateMode = new RotateMode();
+		public static const chainScale : RotateMode = new RotateMode();
+	}
+}

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

@@ -29,477 +29,479 @@
  *****************************************************************************/
 
 package spine {
-import spine.attachments.MeshAttachment;
-import spine.attachments.RegionAttachment;
-import flash.utils.Dictionary;
-import spine.attachments.PathAttachment;
-import spine.attachments.Attachment;
-
-public class Skeleton {
-	internal var _data:SkeletonData;
-	public var bones:Vector.<Bone>;
-	public var slots:Vector.<Slot>;
-	public var drawOrder:Vector.<Slot>;
-	public var ikConstraints:Vector.<IkConstraint>;
-	public var transformConstraints:Vector.<TransformConstraint>;
-	public var pathConstraints:Vector.<PathConstraint>;
-	private var _updateCache:Vector.<Updatable> = new Vector.<Updatable>();
-	private var _updateCacheReset:Vector.<Bone> = new Vector.<Bone>();
-	private var _skin:Skin;
-	public var color:Color = new Color(1, 1, 1, 1);
-	public var time:Number = 0;
-	public var flipX:Boolean, flipY:Boolean;
-	public var x:Number = 0, y:Number = 0;
-
-	public function Skeleton (data:SkeletonData) {
-		if (data == null)
-			throw new ArgumentError("data cannot be null.");
-		_data = data;
-
-		bones = new Vector.<Bone>();
-		for each (var boneData:BoneData in data.bones) {
-			var bone:Bone;
-			if (boneData.parent == null)
-				bone = new Bone(boneData, this, null);
-			else {
-				var parent:Bone = bones[boneData.parent.index];
-				bone = new Bone(boneData, this, parent);
-				parent.children.push(bone);
+	import spine.attachments.MeshAttachment;
+	import spine.attachments.RegionAttachment;
+
+	import flash.utils.Dictionary;
+
+	import spine.attachments.PathAttachment;
+	import spine.attachments.Attachment;
+
+	public class Skeleton {
+		internal var _data : SkeletonData;
+		public var bones : Vector.<Bone>;
+		public var slots : Vector.<Slot>;
+		public var drawOrder : Vector.<Slot>;
+		public var ikConstraints : Vector.<IkConstraint>;
+		public var transformConstraints : Vector.<TransformConstraint>;
+		public var pathConstraints : Vector.<PathConstraint>;
+		private var _updateCache : Vector.<Updatable> = new Vector.<Updatable>();
+		private var _updateCacheReset : Vector.<Bone> = new Vector.<Bone>();
+		private var _skin : Skin;
+		public var color : Color = new Color(1, 1, 1, 1);
+		public var time : Number = 0;
+		public var flipX : Boolean, flipY : Boolean;
+		public var x : Number = 0, y : Number = 0;
+
+		public function Skeleton(data : SkeletonData) {
+			if (data == null)
+				throw new ArgumentError("data cannot be null.");
+			_data = data;
+
+			bones = new Vector.<Bone>();
+			for each (var boneData : BoneData in data.bones) {
+				var bone : Bone;
+				if (boneData.parent == null)
+					bone = new Bone(boneData, this, null);
+				else {
+					var parent : Bone = bones[boneData.parent.index];
+					bone = new Bone(boneData, this, parent);
+					parent.children.push(bone);
+				}
+				bones.push(bone);
 			}
-			bones.push(bone);
-		}
-
-		slots = new Vector.<Slot>();
-		drawOrder = new Vector.<Slot>();
-		for each (var slotData:SlotData in data.slots) {
-			bone = bones[slotData.boneData.index];
-			var slot:Slot = new Slot(slotData, bone);
-			slots.push(slot);
-			drawOrder[drawOrder.length] = slot;
-		}
-		
-		ikConstraints = new Vector.<IkConstraint>();		
-		for each (var ikConstraintData:IkConstraintData in data.ikConstraints)
-			ikConstraints.push(new IkConstraint(ikConstraintData, this));
-		
-		transformConstraints = new Vector.<TransformConstraint>();
-		for each (var transformConstraintData:TransformConstraintData in data.transformConstraints)
-			transformConstraints.push(new TransformConstraint(transformConstraintData, this));
-
-		pathConstraints = new Vector.<PathConstraint>();
-		for each (var pathConstraintData:PathConstraintData in data.pathConstraints)
-			pathConstraints.push(new PathConstraint(pathConstraintData, this));
-
-		updateCache();
-	}
 
-	/** Caches information about bones and constraints. Must be called if bones, constraints, or weighted path attachments are
-	 * added or removed. */
-	public function updateCache () : void {
-		var updateCache:Vector.<Updatable> = this._updateCache;
-		updateCache.length = 0;
-		this._updateCacheReset.length = 0;
-
-		var bones:Vector.<Bone> = this.bones;
-		var i:Number = 0;
-		var n:Number = 0;
-		for (i = 0, n = bones.length; i < n; i++)
-			bones[i]._sorted = false;
-
-		// IK first, lowest hierarchy depth first.
-		var ikConstraints:Vector.<IkConstraint> = this.ikConstraints;
-		var transformConstraints:Vector.<TransformConstraint> = this.transformConstraints;
-		var pathConstraints:Vector.<PathConstraint> = this.pathConstraints;
-		var ikCount:Number = ikConstraints.length, transformCount:Number = transformConstraints.length, pathCount:Number = pathConstraints.length;
-		var constraintCount:Number = ikCount + transformCount + pathCount;
-		
-		outer:			
-		for (i = 0; i < constraintCount; i++) {
-			var ii:Number = 0;
-			for (ii = 0; ii < ikCount; ii++) {
-				var ikConstraint:IkConstraint = ikConstraints[ii];
-				if (ikConstraint.data.order == i) {
-					sortIkConstraint(ikConstraint);
-					continue outer;
-				}
+			slots = new Vector.<Slot>();
+			drawOrder = new Vector.<Slot>();
+			for each (var slotData : SlotData in data.slots) {
+				bone = bones[slotData.boneData.index];
+				var slot : Slot = new Slot(slotData, bone);
+				slots.push(slot);
+				drawOrder[drawOrder.length] = slot;
 			}
-			for (ii = 0; ii < transformCount; ii++) {
-				var transformConstraint:TransformConstraint = transformConstraints[ii];
-				if (transformConstraint.data.order == i) {
-					sortTransformConstraint(transformConstraint);
-					continue outer;
+
+			ikConstraints = new Vector.<IkConstraint>();
+			for each (var ikConstraintData : IkConstraintData in data.ikConstraints)
+				ikConstraints.push(new IkConstraint(ikConstraintData, this));
+
+			transformConstraints = new Vector.<TransformConstraint>();
+			for each (var transformConstraintData : TransformConstraintData in data.transformConstraints)
+				transformConstraints.push(new TransformConstraint(transformConstraintData, this));
+
+			pathConstraints = new Vector.<PathConstraint>();
+			for each (var pathConstraintData : PathConstraintData in data.pathConstraints)
+				pathConstraints.push(new PathConstraint(pathConstraintData, this));
+
+			updateCache();
+		}
+
+		/** Caches information about bones and constraints. Must be called if bones, constraints, or weighted path attachments are
+		 * added or removed. */
+		public function updateCache() : void {
+			var updateCache : Vector.<Updatable> = this._updateCache;
+			updateCache.length = 0;
+			this._updateCacheReset.length = 0;
+
+			var bones : Vector.<Bone> = this.bones;
+			var i : Number = 0;
+			var n : Number = 0;
+			for (i = 0, n = bones.length; i < n; i++)
+				bones[i]._sorted = false;
+
+			// IK first, lowest hierarchy depth first.
+			var ikConstraints : Vector.<IkConstraint> = this.ikConstraints;
+			var transformConstraints : Vector.<TransformConstraint> = this.transformConstraints;
+			var pathConstraints : Vector.<PathConstraint> = this.pathConstraints;
+			var ikCount : Number = ikConstraints.length, transformCount : Number = transformConstraints.length, pathCount : Number = pathConstraints.length;
+			var constraintCount : Number = ikCount + transformCount + pathCount;
+
+			outer:
+			for (i = 0; i < constraintCount; i++) {
+				var ii : Number = 0;
+				for (ii = 0; ii < ikCount; ii++) {
+					var ikConstraint : IkConstraint = ikConstraints[ii];
+					if (ikConstraint.data.order == i) {
+						sortIkConstraint(ikConstraint);
+						continue outer;
+					}
 				}
-			}
-			for (ii = 0; ii < pathCount; ii++) {
-				var pathConstraint:PathConstraint = pathConstraints[ii];
-				if (pathConstraint.data.order == i) {
-					sortPathConstraint(pathConstraint);
-					continue outer;
+				for (ii = 0; ii < transformCount; ii++) {
+					var transformConstraint : TransformConstraint = transformConstraints[ii];
+					if (transformConstraint.data.order == i) {
+						sortTransformConstraint(transformConstraint);
+						continue outer;
+					}
+				}
+				for (ii = 0; ii < pathCount; ii++) {
+					var pathConstraint : PathConstraint = pathConstraints[ii];
+					if (pathConstraint.data.order == i) {
+						sortPathConstraint(pathConstraint);
+						continue outer;
+					}
 				}
 			}
+
+			for (i = 0, n = bones.length; i < n; i++)
+				sortBone(bones[i]);
 		}
-		
-		for (i = 0, n = bones.length; i < n; i++)
-			sortBone(bones[i]);
-	}
-	
-	private function sortIkConstraint (constraint:IkConstraint): void {
-		var target:Bone = constraint.target;
-		sortBone(target);
 
-		var constrained:Vector.<Bone> = constraint.bones;
-		var parent:Bone = constrained[0];
-		sortBone(parent);
+		private function sortIkConstraint(constraint : IkConstraint) : void {
+			var target : Bone = constraint.target;
+			sortBone(target);
 
-		if (constrained.length > 1) {
-			var child:Bone = constrained[constrained.length - 1];
-			if (!(_updateCache.indexOf(child) > -1)) _updateCacheReset.push(child);
-		}
+			var constrained : Vector.<Bone> = constraint.bones;
+			var parent : Bone = constrained[0];
+			sortBone(parent);
 
-		_updateCache.push(constraint);
+			if (constrained.length > 1) {
+				var child : Bone = constrained[constrained.length - 1];
+				if (!(_updateCache.indexOf(child) > -1)) _updateCacheReset.push(child);
+			}
 
-		sortReset(parent.children);
-		constrained[constrained.length - 1]._sorted = true;
-	}
+			_updateCache.push(constraint);
 
-	private function sortPathConstraint (constraint:PathConstraint): void {
-		var slot:Slot = constraint.target;
-		var slotIndex:Number = slot.data.index;
-		var slotBone:Bone = slot.bone;
-		if (skin != null) sortPathConstraintAttachment(skin, slotIndex, slotBone);
-		if (data.defaultSkin != null && data.defaultSkin != skin)
-			sortPathConstraintAttachment(data.defaultSkin, slotIndex, slotBone);
-		var i:Number = 0;
-		var n:Number = 0;		
-		for (i = 0, n = data.skins.length; i < n; i++)
-			sortPathConstraintAttachment(data.skins[i], slotIndex, slotBone);
-
-		var attachment:Attachment = slot.attachment;
-		if (attachment is PathAttachment) sortPathConstraintAttachment2(attachment, slotBone);
-
-		var constrained:Vector.<Bone> = constraint.bones;
-		var boneCount:Number = constrained.length;
-		for (i = 0; i < boneCount; i++)
-			sortBone(constrained[i]);
-
-		_updateCache.push(constraint);
-
-		for (i = 0; i < boneCount; i++)
-			sortReset(constrained[i].children);
-		for (i = 0; i < boneCount; i++)
-			constrained[i]._sorted = true;
-	}
+			sortReset(parent.children);
+			constrained[constrained.length - 1]._sorted = true;
+		}
 
-	private function sortTransformConstraint (constraint:TransformConstraint): void {
-		sortBone(constraint.target);
+		private function sortPathConstraint(constraint : PathConstraint) : void {
+			var slot : Slot = constraint.target;
+			var slotIndex : Number = slot.data.index;
+			var slotBone : Bone = slot.bone;
+			if (skin != null) sortPathConstraintAttachment(skin, slotIndex, slotBone);
+			if (data.defaultSkin != null && data.defaultSkin != skin)
+				sortPathConstraintAttachment(data.defaultSkin, slotIndex, slotBone);
+			var i : Number = 0;
+			var n : Number = 0;
+			for (i = 0, n = data.skins.length; i < n; i++)
+				sortPathConstraintAttachment(data.skins[i], slotIndex, slotBone);
+
+			var attachment : Attachment = slot.attachment;
+			if (attachment is PathAttachment) sortPathConstraintAttachment2(attachment, slotBone);
+
+			var constrained : Vector.<Bone> = constraint.bones;
+			var boneCount : Number = constrained.length;
+			for (i = 0; i < boneCount; i++)
+				sortBone(constrained[i]);
 
-		var constrained:Vector.<Bone> = constraint.bones;
-		var boneCount:Number = constrained.length;
-		var i:Number = 0;
-		if (constraint.data.local) {
-			for (i = 0; i < boneCount; i++) {
-				var child:Bone = constrained[i];
-				sortBone(child.parent);
-				if (!(_updateCache.indexOf(child) > -1)) _updateCacheReset.push(child);
+			_updateCache.push(constraint);
+
+			for (i = 0; i < boneCount; i++)
+				sortReset(constrained[i].children);
+			for (i = 0; i < boneCount; i++)
+				constrained[i]._sorted = true;
+		}
+
+		private function sortTransformConstraint(constraint : TransformConstraint) : void {
+			sortBone(constraint.target);
+
+			var constrained : Vector.<Bone> = constraint.bones;
+			var boneCount : Number = constrained.length;
+			var i : Number = 0;
+			if (constraint.data.local) {
+				for (i = 0; i < boneCount; i++) {
+					var child : Bone = constrained[i];
+					sortBone(child.parent);
+					if (!(_updateCache.indexOf(child) > -1)) _updateCacheReset.push(child);
+				}
+			} else {
+				for (i = 0; i < boneCount; i++)
+					sortBone(constrained[i]);
 			}
-		} else {
+
+			_updateCache.push(constraint);
+
 			for (i = 0; i < boneCount; i++)
-				sortBone(constrained[i]);
+				sortReset(constrained[i].children);
+			for (i = 0; i < boneCount; i++)
+				constrained[i]._sorted = true;
 		}
 
-		_updateCache.push(constraint);
+		private function sortPathConstraintAttachment(skin : Skin, slotIndex : int, slotBone : Bone) : void {
+			var dict : Dictionary = skin.attachments[slotIndex];
+			if (!dict) return;
 
-		for (i = 0; i < boneCount; i++)
-			sortReset(constrained[i].children);
-		for (i = 0; i < boneCount; i++)
-			constrained[i]._sorted = true;
-	}
-	
-	private function sortPathConstraintAttachment (skin:Skin, slotIndex:int, slotBone:Bone) : void {
-		var dict:Dictionary = skin.attachments[slotIndex];
-		if (!dict) return;
-		
-		for each (var value:Attachment in dict) {
-			sortPathConstraintAttachment2(value, slotBone);
+			for each (var value : Attachment in dict) {
+				sortPathConstraintAttachment2(value, slotBone);
+			}
 		}
-	}
 
-	private function sortPathConstraintAttachment2 (attachment:Attachment, slotBone:Bone) : void {
-		var pathAttachment:PathAttachment = attachment as PathAttachment;
-		if (!pathAttachment) return;
-		var pathBones:Vector.<int> = pathAttachment.bones;
-		if (pathBones == null)
-			sortBone(slotBone);
-		else {
-			var bones:Vector.<Bone> = this.bones;
-			var i:int = 0;
-			while (i < pathBones.length) {
-				var boneCount:int = pathBones[i++];
-				for (var n:int = i + boneCount; i < n; i++) {				
-					sortBone(bones[pathBones[i]]);
+		private function sortPathConstraintAttachment2(attachment : Attachment, slotBone : Bone) : void {
+			var pathAttachment : PathAttachment = attachment as PathAttachment;
+			if (!pathAttachment) return;
+			var pathBones : Vector.<int> = pathAttachment.bones;
+			if (pathBones == null)
+				sortBone(slotBone);
+			else {
+				var bones : Vector.<Bone> = this.bones;
+				var i : int = 0;
+				while (i < pathBones.length) {
+					var boneCount : int = pathBones[i++];
+					for (var n : int = i + boneCount; i < n; i++) {
+						sortBone(bones[pathBones[i]]);
+					}
 				}
 			}
 		}
-	}
 
-	private function sortBone (bone:Bone) : void {
-		if (bone._sorted) return;
-		var parent:Bone = bone.parent;
-		if (parent != null) sortBone(parent);
-		bone._sorted = true;
-		_updateCache.push(bone);
-	}
+		private function sortBone(bone : Bone) : void {
+			if (bone._sorted) return;
+			var parent : Bone = bone.parent;
+			if (parent != null) sortBone(parent);
+			bone._sorted = true;
+			_updateCache.push(bone);
+		}
 
-	private function sortReset (bones:Vector.<Bone>) : void {
-		for (var i:int = 0, n:int = bones.length; i < n; i++) {
-			var bone:Bone = bones[i];
-			if (bone._sorted) sortReset(bone.children);
-			bone._sorted = false;
+		private function sortReset(bones : Vector.<Bone>) : void {
+			for (var i : int = 0, n : int = bones.length; i < n; i++) {
+				var bone : Bone = bones[i];
+				if (bone._sorted) sortReset(bone.children);
+				bone._sorted = false;
+			}
 		}
-	}
 
-	/** Updates the world transform for each bone and applies constraints. */
-	public function updateWorldTransform () : void {
-		var updateCacheReset:Vector.<Bone> = this._updateCacheReset;
-		for each (var bone:Bone in updateCacheReset) {
-			bone.ax = bone.x;
-			bone.ay = bone.y;
-			bone.arotation = bone.rotation;
-			bone.ascaleX = bone.scaleX;
-			bone.ascaleY = bone.scaleY;
-			bone.ashearX = bone.shearX;
-			bone.ashearY = bone.shearY;
-			bone.appliedValid = true;
-		}
-		for each (var updatable:Updatable in _updateCache)
-			updatable.update();
-	}
+		/** Updates the world transform for each bone and applies constraints. */
+		public function updateWorldTransform() : void {
+			var updateCacheReset : Vector.<Bone> = this._updateCacheReset;
+			for each (var bone : Bone in updateCacheReset) {
+				bone.ax = bone.x;
+				bone.ay = bone.y;
+				bone.arotation = bone.rotation;
+				bone.ascaleX = bone.scaleX;
+				bone.ascaleY = bone.scaleY;
+				bone.ashearX = bone.shearX;
+				bone.ashearY = bone.shearY;
+				bone.appliedValid = true;
+			}
+			for each (var updatable : Updatable in _updateCache)
+				updatable.update();
+		}
 
-	/** Sets the bones, constraints, and slots to their setup pose values. */
-	public function setToSetupPose () : void {
-		setBonesToSetupPose();
-		setSlotsToSetupPose();
-	}
+		/** Sets the bones, constraints, and slots to their setup pose values. */
+		public function setToSetupPose() : void {
+			setBonesToSetupPose();
+			setSlotsToSetupPose();
+		}
 
-	/** Sets the bones and constraints to their setup pose values. */
-	public function setBonesToSetupPose () : void {
-		for each (var bone:Bone in bones)
-			bone.setToSetupPose();
+		/** Sets the bones and constraints to their setup pose values. */
+		public function setBonesToSetupPose() : void {
+			for each (var bone : Bone in bones)
+				bone.setToSetupPose();
 
-		for each (var ikConstraint:IkConstraint in ikConstraints) {
-			ikConstraint.bendDirection = ikConstraint._data.bendDirection;
-			ikConstraint.mix = ikConstraint._data.mix;
-		}
+			for each (var ikConstraint : IkConstraint in ikConstraints) {
+				ikConstraint.bendDirection = ikConstraint._data.bendDirection;
+				ikConstraint.mix = ikConstraint._data.mix;
+			}
+
+			for each (var transformConstraint : TransformConstraint in transformConstraints) {
+				transformConstraint.rotateMix = transformConstraint._data.rotateMix;
+				transformConstraint.translateMix = transformConstraint._data.translateMix;
+				transformConstraint.scaleMix = transformConstraint._data.scaleMix;
+				transformConstraint.shearMix = transformConstraint._data.shearMix;
+			}
 
-		for each (var transformConstraint:TransformConstraint in transformConstraints) {
-			transformConstraint.rotateMix = transformConstraint._data.rotateMix;
-			transformConstraint.translateMix = transformConstraint._data.translateMix;
-			transformConstraint.scaleMix = transformConstraint._data.scaleMix;
-			transformConstraint.shearMix = transformConstraint._data.shearMix;
+			for each (var pathConstraint : PathConstraint in pathConstraints) {
+				pathConstraint.position = pathConstraint._data.position;
+				pathConstraint.spacing = pathConstraint._data.spacing;
+				pathConstraint.rotateMix = pathConstraint._data.rotateMix;
+				pathConstraint.translateMix = pathConstraint._data.translateMix;
+			}
 		}
-		
-		for each (var pathConstraint:PathConstraint in pathConstraints) {
-			pathConstraint.position = pathConstraint._data.position;
-			pathConstraint.spacing = pathConstraint._data.spacing;
-			pathConstraint.rotateMix = pathConstraint._data.rotateMix;
-			pathConstraint.translateMix = pathConstraint._data.translateMix;
+
+		public function setSlotsToSetupPose() : void {
+			var i : int = 0;
+			for each (var slot : Slot in slots) {
+				drawOrder[i++] = slot;
+				slot.setToSetupPose();
+			}
 		}
-	}
 
-	public function setSlotsToSetupPose () : void {
-		var i:int = 0;
-		for each (var slot:Slot in slots) {
-			drawOrder[i++] = slot;
-			slot.setToSetupPose();
+		public function get data() : SkeletonData {
+			return _data;
 		}
-	}
 
-	public function get data () : SkeletonData {
-		return _data;
-	}
-	
-	public function get getUpdateCache () : Vector.<Updatable> {
-		return _updateCache;
-	}
+		public function get getUpdateCache() : Vector.<Updatable> {
+			return _updateCache;
+		}
 
-	public function get rootBone () : Bone {
-		if (bones.length == 0) return null;
-		return bones[0];
-	}
+		public function get rootBone() : Bone {
+			if (bones.length == 0) return null;
+			return bones[0];
+		}
 
-	/** @return May be null. */
-	public function findBone (boneName:String) : Bone {
-		if (boneName == null)
-			throw new ArgumentError("boneName cannot be null.");
-		for each (var bone:Bone in bones)
-			if (bone._data._name == boneName) return bone;
-		return null;
-	}
+		/** @return May be null. */
+		public function findBone(boneName : String) : Bone {
+			if (boneName == null)
+				throw new ArgumentError("boneName cannot be null.");
+			for each (var bone : Bone in bones)
+				if (bone._data._name == boneName) return bone;
+			return null;
+		}
 
-	/** @return -1 if the bone was not found. */
-	public function findBoneIndex (boneName:String) : int {
-		if (boneName == null)
-			throw new ArgumentError("boneName cannot be null.");
-		var i:int = 0;
-		for each (var bone:Bone in bones) {
-			if (bone._data._name == boneName) return i;
-			i++;
+		/** @return -1 if the bone was not found. */
+		public function findBoneIndex(boneName : String) : int {
+			if (boneName == null)
+				throw new ArgumentError("boneName cannot be null.");
+			var i : int = 0;
+			for each (var bone : Bone in bones) {
+				if (bone._data._name == boneName) return i;
+				i++;
+			}
+			return -1;
 		}
-		return -1;
-	}
 
-	/** @return May be null. */
-	public function findSlot (slotName:String) : Slot {
-		if (slotName == null)
-			throw new ArgumentError("slotName cannot be null.");
-		for each (var slot:Slot in slots)
-			if (slot._data._name == slotName) return slot;
-		return null;
-	}
+		/** @return May be null. */
+		public function findSlot(slotName : String) : Slot {
+			if (slotName == null)
+				throw new ArgumentError("slotName cannot be null.");
+			for each (var slot : Slot in slots)
+				if (slot._data._name == slotName) return slot;
+			return null;
+		}
 
-	/** @return -1 if the bone was not found. */
-	public function findSlotIndex (slotName:String) : int {
-		if (slotName == null)
-			throw new ArgumentError("slotName cannot be null.");
-		var i:int = 0;
-		for each (var slot:Slot in slots) {
-			if (slot._data._name == slotName) return i;
-			i++;
+		/** @return -1 if the bone was not found. */
+		public function findSlotIndex(slotName : String) : int {
+			if (slotName == null)
+				throw new ArgumentError("slotName cannot be null.");
+			var i : int = 0;
+			for each (var slot : Slot in slots) {
+				if (slot._data._name == slotName) return i;
+				i++;
+			}
+			return -1;
 		}
-		return -1;
-	}
 
-	public function get skin () : Skin {
-		return _skin;
-	}
+		public function get skin() : Skin {
+			return _skin;
+		}
 
-	public function set skinName (skinName:String) : void {
-		var skin:Skin = data.findSkin(skinName);
-		if (skin == null) throw new ArgumentError("Skin not found: " + skinName);
-		this.skin = skin;
-	}
+		public function set skinName(skinName : String) : void {
+			var skin : Skin = data.findSkin(skinName);
+			if (skin == null) throw new ArgumentError("Skin not found: " + skinName);
+			this.skin = skin;
+		}
 
-	/** @return May be null. */
-	public function get skinName () : String {
-		return _skin == null ? null : _skin._name;
-	}
+		/** @return May be null. */
+		public function get skinName() : String {
+			return _skin == null ? null : _skin._name;
+		}
 
-	/** Sets the skin used to look up attachments before looking in the {@link SkeletonData#getDefaultSkin() default skin}.
-	 * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was
-	 * no old skin, each slot's setup mode attachment is attached from the new skin.
-	 * @param newSkin May be null. */
-	public function set skin (newSkin:Skin) : void {
-		if (newSkin) {
-			if (skin)
-				newSkin.attachAll(this, skin);
-			else {
-				var i:int = 0;
-				for each (var slot:Slot in slots) {
-					var name:String = slot._data.attachmentName;
-					if (name) {
-						var attachment:Attachment = newSkin.getAttachment(i, name);
-						if (attachment) slot.attachment = attachment;
+		/** Sets the skin used to look up attachments before looking in the {@link SkeletonData#getDefaultSkin() default skin}.
+		 * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was
+		 * no old skin, each slot's setup mode attachment is attached from the new skin.
+		 * @param newSkin May be null. */
+		public function set skin(newSkin : Skin) : void {
+			if (newSkin) {
+				if (skin)
+					newSkin.attachAll(this, skin);
+				else {
+					var i : int = 0;
+					for each (var slot : Slot in slots) {
+						var name : String = slot._data.attachmentName;
+						if (name) {
+							var attachment : Attachment = newSkin.getAttachment(i, name);
+							if (attachment) slot.attachment = attachment;
+						}
+						i++;
 					}
-					i++;
 				}
 			}
+			_skin = newSkin;
 		}
-		_skin = newSkin;
-	}
 
-	/** @return May be null. */
-	public function getAttachmentForSlotName (slotName:String, attachmentName:String) : Attachment {
-		return getAttachmentForSlotIndex(data.findSlotIndex(slotName), attachmentName);
-	}
+		/** @return May be null. */
+		public function getAttachmentForSlotName(slotName : String, attachmentName : String) : Attachment {
+			return getAttachmentForSlotIndex(data.findSlotIndex(slotName), attachmentName);
+		}
 
-	/** @return May be null. */
-	public function getAttachmentForSlotIndex (slotIndex:int, attachmentName:String) : Attachment {
-		if (attachmentName == null) throw new ArgumentError("attachmentName cannot be null.");
-		if (skin != null) {
-			var attachment:Attachment = skin.getAttachment(slotIndex, attachmentName);
-			if (attachment != null) return attachment;
+		/** @return May be null. */
+		public function getAttachmentForSlotIndex(slotIndex : int, attachmentName : String) : Attachment {
+			if (attachmentName == null) throw new ArgumentError("attachmentName cannot be null.");
+			if (skin != null) {
+				var attachment : Attachment = skin.getAttachment(slotIndex, attachmentName);
+				if (attachment != null) return attachment;
+			}
+			if (data.defaultSkin != null) return data.defaultSkin.getAttachment(slotIndex, attachmentName);
+			return null;
 		}
-		if (data.defaultSkin != null) return data.defaultSkin.getAttachment(slotIndex, attachmentName);
-		return null;
-	}
 
-	/** @param attachmentName May be null. */
-	public function setAttachment (slotName:String, attachmentName:String) : void {
-		if (slotName == null) throw new ArgumentError("slotName cannot be null.");
-		var i:int = 0;
-		for each (var slot:Slot in slots) {
-			if (slot._data._name == slotName) {
-				var attachment:Attachment = null;
-				if (attachmentName != null) {
-					attachment = getAttachmentForSlotIndex(i, attachmentName);
-					if (attachment == null)
-						throw new ArgumentError("Attachment not found: " + attachmentName + ", for slot: " + slotName);
+		/** @param attachmentName May be null. */
+		public function setAttachment(slotName : String, attachmentName : String) : void {
+			if (slotName == null) throw new ArgumentError("slotName cannot be null.");
+			var i : int = 0;
+			for each (var slot : Slot in slots) {
+				if (slot._data._name == slotName) {
+					var attachment : Attachment = null;
+					if (attachmentName != null) {
+						attachment = getAttachmentForSlotIndex(i, attachmentName);
+						if (attachment == null)
+							throw new ArgumentError("Attachment not found: " + attachmentName + ", for slot: " + slotName);
+					}
+					slot.attachment = attachment;
+					return;
 				}
-				slot.attachment = attachment;
-				return;
+				i++;
 			}
-			i++;
+			throw new ArgumentError("Slot not found: " + slotName);
 		}
-		throw new ArgumentError("Slot not found: " + slotName);
-	}
 
-	/** @return May be null. */
-	public function findIkConstraint (constraintName:String) : IkConstraint {
-		if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-		for each (var ikConstraint:IkConstraint in ikConstraints)
-			if (ikConstraint._data._name == constraintName) return ikConstraint;
-		return null;
-	}
+		/** @return May be null. */
+		public function findIkConstraint(constraintName : String) : IkConstraint {
+			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
+			for each (var ikConstraint : IkConstraint in ikConstraints)
+				if (ikConstraint._data._name == constraintName) return ikConstraint;
+			return null;
+		}
 
-	/** @return May be null. */
-	public function findTransformConstraint (constraintName:String) : TransformConstraint {
-		if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-		for each (var transformConstraint:TransformConstraint in transformConstraints)
-			if (transformConstraint._data._name == constraintName) return transformConstraint;
-		return null;
-	}
-	
-	/** @return May be null. */
-	public function findPathConstraint (constraintName:String) : PathConstraint {
-		if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-		for each (var pathConstraint:PathConstraint in pathConstraints)
-			if (pathConstraint._data._name == constraintName) return pathConstraint;
-		return null;
-	}
+		/** @return May be null. */
+		public function findTransformConstraint(constraintName : String) : TransformConstraint {
+			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
+			for each (var transformConstraint : TransformConstraint in transformConstraints)
+				if (transformConstraint._data._name == constraintName) return transformConstraint;
+			return null;
+		}
 
-	public function update (delta:Number) : void {
-		time += delta;
-	}
+		/** @return May be null. */
+		public function findPathConstraint(constraintName : String) : PathConstraint {
+			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
+			for each (var pathConstraint : PathConstraint in pathConstraints)
+				if (pathConstraint._data._name == constraintName) return pathConstraint;
+			return null;
+		}
 
-	public function toString () : String {
-		return _data.name != null ? _data.name : super.toString();
-	}
-	
-	public function getBounds (offset: Vector.<Number>, size: Vector.<Number>, temp: Vector.<Number>) : void {
+		public function update(delta : Number) : void {
+			time += delta;
+		}
+
+		public function toString() : String {
+			return _data.name != null ? _data.name : super.toString();
+		}
+
+		public function getBounds(offset : Vector.<Number>, size : Vector.<Number>, temp : Vector.<Number>) : void {
 			if (offset == null) throw new ArgumentError("offset cannot be null.");
 			if (size == null) throw new ArgumentError("size cannot be null.");
-			var drawOrder:Vector.<Slot> = this.drawOrder;
-			var minX:Number = Number.POSITIVE_INFINITY, minY:Number = Number.POSITIVE_INFINITY, maxX:Number = Number.NEGATIVE_INFINITY, maxY:Number = Number.NEGATIVE_INFINITY;
-			for (var i:int = 0, n:int = drawOrder.length; i < n; i++) {
-				var slot:Slot = drawOrder[i];
-				var verticesLength:int = 0;
-				var vertices: Vector.<Number> = null;
-				var attachment:Attachment = slot.attachment;
+			var drawOrder : Vector.<Slot> = this.drawOrder;
+			var minX : Number = Number.POSITIVE_INFINITY, minY : Number = Number.POSITIVE_INFINITY, maxX : Number = Number.NEGATIVE_INFINITY, maxY : Number = Number.NEGATIVE_INFINITY;
+			for (var i : int = 0, n : int = drawOrder.length; i < n; i++) {
+				var slot : Slot = drawOrder[i];
+				var verticesLength : int = 0;
+				var vertices : Vector.<Number> = null;
+				var attachment : Attachment = slot.attachment;
 				if (attachment is RegionAttachment) {
 					verticesLength = 8;
 					temp.length = verticesLength;
 					vertices = temp;
 					(attachment as RegionAttachment).computeWorldVertices(slot.bone, vertices, 0, 2);
-				} else if (attachment is MeshAttachment) {
-					var mesh:MeshAttachment = attachment as MeshAttachment;
+				} else if (attachment is MeshAttachment) {
+					var mesh : MeshAttachment = attachment as MeshAttachment;
 					verticesLength = mesh.worldVerticesLength;
 					temp.length = verticesLength;
 					vertices = temp;
 					mesh.computeWorldVertices(slot, 0, verticesLength, vertices, 0, 2);
 				}
 				if (vertices != null) {
-					for (var ii:int = 0, nn:int = vertices.length; ii < nn; ii += 8) {
-						var x:Number = vertices[ii], y:Number = vertices[ii + 1];
+					for (var ii : int = 0, nn : int = vertices.length; ii < nn; ii += 8) {
+						var x : Number = vertices[ii], y : Number = vertices[ii + 1];
 						minX = Math.min(minX, x);
 						minY = Math.min(minY, y);
 						maxX = Math.max(maxX, x);
@@ -512,6 +514,5 @@ public class Skeleton {
 			size[0] = maxX - minX;
 			size[1] = maxY - minY;
 		}
-}
-
-}
+	}
+}

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

@@ -29,131 +29,128 @@
  *****************************************************************************/
 
 package spine {
-import spine.attachments.BoundingBoxAttachment;
+	import spine.attachments.BoundingBoxAttachment;
 
-public class SkeletonBounds {
-	private var polygonPool:Vector.<Polygon> = new Vector.<Polygon>();
+	public class SkeletonBounds {
+		private var polygonPool : Vector.<Polygon> = new Vector.<Polygon>();
+		public var boundingBoxes : Vector.<BoundingBoxAttachment> = new Vector.<BoundingBoxAttachment>();
+		public var polygons : Vector.<Polygon> = new Vector.<Polygon>();
+		public var minX : Number, minY : Number, maxX : Number, maxY : Number;
 
-	public var boundingBoxes:Vector.<BoundingBoxAttachment> = new Vector.<BoundingBoxAttachment>();
-	public var polygons:Vector.<Polygon> = new Vector.<Polygon>();
-	public var minX:Number, minY:Number, maxX:Number, maxY:Number;
-	
-	public function SkeletonBounds () {		
-	}
-
-	public function update (skeleton:Skeleton, updateAabb:Boolean) : void {
-		var slots:Vector.<Slot> = skeleton.slots;
-		var slotCount:int = slots.length;		
-
-		boundingBoxes.length = 0;
-		for each (var polygon:Polygon in polygons)
-			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[boundingBoxes.length] = boundingBox;
-
-			var poolCount:int = polygonPool.length;
-			if (poolCount > 0) {
-				polygon = polygonPool[poolCount - 1];
-				polygonPool.splice(poolCount - 1, 1);
-			} else
-				polygon = new Polygon();
-			polygons[polygons.length] = polygon;
-
-			polygon.vertices.length = boundingBox.worldVerticesLength;
-			boundingBox.computeWorldVertices(slot, 0, boundingBox.worldVerticesLength, polygon.vertices, 0, 2);
+		public function SkeletonBounds() {
 		}
 
-		if (updateAabb) 
-			aabbCompute();
-		else {
-			minX = Number.MIN_VALUE;
-			minY = Number.MIN_VALUE;
-			maxX = Number.MAX_VALUE;
-			maxY = Number.MAX_VALUE;
+		public function update(skeleton : Skeleton, updateAabb : Boolean) : void {
+			var slots : Vector.<Slot> = skeleton.slots;
+			var slotCount : int = slots.length;
+
+			boundingBoxes.length = 0;
+			for each (var polygon : Polygon in polygons)
+				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[boundingBoxes.length] = boundingBox;
+
+				var poolCount : int = polygonPool.length;
+				if (poolCount > 0) {
+					polygon = polygonPool[poolCount - 1];
+					polygonPool.splice(poolCount - 1, 1);
+				} else
+					polygon = new Polygon();
+				polygons[polygons.length] = polygon;
+
+				polygon.vertices.length = boundingBox.worldVerticesLength;
+				boundingBox.computeWorldVertices(slot, 0, boundingBox.worldVerticesLength, polygon.vertices, 0, 2);
+			}
+
+			if (updateAabb)
+				aabbCompute();
+			else {
+				minX = Number.MIN_VALUE;
+				minY = Number.MIN_VALUE;
+				maxX = Number.MAX_VALUE;
+				maxY = Number.MAX_VALUE;
+			}
 		}
-	}
 
-	private function aabbCompute () : void {
-		var minX:Number = Number.MAX_VALUE, minY:Number = Number.MAX_VALUE;
-		var maxX:Number = -Number.MAX_VALUE, maxY:Number = -Number.MAX_VALUE;
-		for (var i:int = 0, n:int = polygons.length; i < n; i++) {
-			var polygon:Polygon = polygons[i];
-			var vertices:Vector.<Number> = polygon.vertices;
-			for (var ii:int = 0, nn:int = vertices.length; ii < nn; ii += 2) {
-				var x:Number = vertices[ii];
-				var y:Number = vertices[ii + 1];
-				minX = Math.min(minX, x);
-				minY = Math.min(minY, y);
-				maxX = Math.max(maxX, x);
-				maxY = Math.max(maxY, y);
+		private function aabbCompute() : void {
+			var minX : Number = Number.MAX_VALUE, minY : Number = Number.MAX_VALUE;
+			var maxX : Number = -Number.MAX_VALUE, maxY : Number = -Number.MAX_VALUE;
+			for (var i : int = 0, n : int = polygons.length; i < n; i++) {
+				var polygon : Polygon = polygons[i];
+				var vertices : Vector.<Number> = polygon.vertices;
+				for (var ii : int = 0, nn : int = vertices.length; ii < nn; ii += 2) {
+					var x : Number = vertices[ii];
+					var y : Number = vertices[ii + 1];
+					minX = Math.min(minX, x);
+					minY = Math.min(minY, y);
+					maxX = Math.max(maxX, x);
+					maxY = Math.max(maxY, y);
+				}
 			}
+			this.minX = minX;
+			this.minY = minY;
+			this.maxX = maxX;
+			this.maxY = maxY;
 		}
-		this.minX = minX;
-		this.minY = minY;
-		this.maxX = maxX;
-		this.maxY = maxY;
-	}
-	
-	
-	/** Returns true if the axis aligned bounding box contains the point. */
-	public function aabbContainsPoint (x:Number, y:Number) : Boolean {
-		return x >= minX && x <= maxX && y >= minY && y <= maxY;
-	}
-	
-	/** Returns true if the axis aligned bounding box intersects the line segment. */
-	public function aabbIntersectsSegment (x1:Number, y1:Number, x2:Number, y2:Number) : Boolean {
-		if ((x1 <= minX && x2 <= minX) || (y1 <= minY && y2 <= minY) || (x1 >= maxX && x2 >= maxX) || (y1 >= maxY && y2 >= maxY))
+
+		/** Returns true if the axis aligned bounding box contains the point. */
+		public function aabbContainsPoint(x : Number, y : Number) : Boolean {
+			return x >= minX && x <= maxX && y >= minY && y <= maxY;
+		}
+
+		/** Returns true if the axis aligned bounding box intersects the line segment. */
+		public function aabbIntersectsSegment(x1 : Number, y1 : Number, x2 : Number, y2 : Number) : Boolean {
+			if ((x1 <= minX && x2 <= minX) || (y1 <= minY && y2 <= minY) || (x1 >= maxX && x2 >= maxX) || (y1 >= maxY && y2 >= maxY))
+				return false;
+			var m : Number = (y2 - y1) / (x2 - x1);
+			var y : Number = m * (minX - x1) + y1;
+			if (y > minY && y < maxY) return true;
+			y = m * (maxX - x1) + y1;
+			if (y > minY && y < maxY) return true;
+			var x : Number = (minY - y1) / m + x1;
+			if (x > minX && x < maxX) return true;
+			x = (maxY - y1) / m + x1;
+			if (x > minX && x < maxX) return true;
 			return false;
-		var m:Number = (y2 - y1) / (x2 - x1);
-		var y:Number = m * (minX - x1) + y1;
-		if (y > minY && y < maxY) return true;
-		y = m * (maxX - x1) + y1;
-		if (y > minY && y < maxY) return true;
-		var x:Number = (minY - y1) / m + x1;
-		if (x > minX && x < maxX) return true;
-		x = (maxY - y1) / m + x1;
-		if (x > minX && x < maxX) return true;
-		return false;
-	}
-	
-	/** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
-	public function aabbIntersectsSkeleton (bounds:SkeletonBounds) : Boolean {
-		return minX < bounds.maxX && maxX > bounds.minX && minY < bounds.maxY && maxY > bounds.minY;
-	}
-	
-	/** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
-	 * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
-	public function containsPoint (x:Number, y:Number) : BoundingBoxAttachment {
-		for (var i:int = 0, n:int = polygons.length; i < n; i++)
-			if (polygons[i].containsPoint(x, y)) return boundingBoxes[i];
-		return null;
-	}
-	
-	/** Returns the first bounding box attachment that contains the line segment, or null. When doing many checks, it is usually
-	 * more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} returns true. */
-	public function intersectsSegment (x1:Number, y1:Number, x2:Number, y2:Number) : BoundingBoxAttachment {
-		for (var i:int = 0, n:int = polygons.length; i < n; i++)
-			if (polygons[i].intersectsSegment(x1, y1, x2, y2)) return boundingBoxes[i];
-		return null;
-	}
+		}
 
-	public function getPolygon (attachment:BoundingBoxAttachment) : Polygon {
-		var index:int = boundingBoxes.indexOf(attachment);
-		return index == -1 ? null : polygons[index];
-	}
+		/** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
+		public function aabbIntersectsSkeleton(bounds : SkeletonBounds) : Boolean {
+			return minX < bounds.maxX && maxX > bounds.minX && minY < bounds.maxY && maxY > bounds.minY;
+		}
 
-	public function get width () : Number {
-		return maxX - minX;
-	}
-	
-	public function get height () : Number {
-		return maxY - minY;
-	}
-}
+		/** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
+		 * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
+		public function containsPoint(x : Number, y : Number) : BoundingBoxAttachment {
+			for (var i : int = 0, n : int = polygons.length; i < n; i++)
+				if (polygons[i].containsPoint(x, y)) return boundingBoxes[i];
+			return null;
+		}
 
-}
+		/** Returns the first bounding box attachment that contains the line segment, or null. When doing many checks, it is usually
+		 * more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} returns true. */
+		public function intersectsSegment(x1 : Number, y1 : Number, x2 : Number, y2 : Number) : BoundingBoxAttachment {
+			for (var i : int = 0, n : int = polygons.length; i < n; i++)
+				if (polygons[i].intersectsSegment(x1, y1, x2, y2)) return boundingBoxes[i];
+			return null;
+		}
+
+		public function getPolygon(attachment : BoundingBoxAttachment) : Polygon {
+			var index : int = boundingBoxes.indexOf(attachment);
+			return index == -1 ? null : polygons[index];
+		}
+
+		public function get width() : Number {
+			return maxX - minX;
+		}
+
+		public function get height() : Number {
+			return maxY - minY;
+		}
+	}
+}

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

@@ -29,155 +29,144 @@
  *****************************************************************************/
 
 package spine {
-import spine.animation.Animation;
-
-public class SkeletonData {
-	/** May be null. */
-	public var name:String;
-	public var bones:Vector.<BoneData> = new Vector.<BoneData>(); // Ordered parents first.
-	public var slots:Vector.<SlotData> = new Vector.<SlotData>(); // Setup pose draw order.
-	public var skins:Vector.<Skin> = new Vector.<Skin>();
-	public var defaultSkin:Skin;
-	public var events:Vector.<EventData> = new Vector.<EventData>();
-	public var animations:Vector.<Animation> = new Vector.<Animation>();
-	public var ikConstraints:Vector.<IkConstraintData> = new Vector.<IkConstraintData>();
-	public var transformConstraints:Vector.<TransformConstraintData> = new Vector.<TransformConstraintData>();
-	public var pathConstraints:Vector.<PathConstraintData> = new Vector.<PathConstraintData>();
-	public var width:Number, height:Number;
-	public var version:String, hash:String;
-	
-	public var fps:Number;
-	public var imagesPath:String;
-	
-	public function SkeletonData () {		
-	}
+	import spine.animation.Animation;
+
+	public class SkeletonData {
+		/** May be null. */
+		public var name : String;
+		public var bones : Vector.<BoneData> = new Vector.<BoneData>(); // Ordered parents first.
+		public var slots : Vector.<SlotData> = new Vector.<SlotData>(); // Setup pose draw order.
+		public var skins : Vector.<Skin> = new Vector.<Skin>();
+		public var defaultSkin : Skin;
+		public var events : Vector.<EventData> = new Vector.<EventData>();
+		public var animations : Vector.<Animation> = new Vector.<Animation>();
+		public var ikConstraints : Vector.<IkConstraintData> = new Vector.<IkConstraintData>();
+		public var transformConstraints : Vector.<TransformConstraintData> = new Vector.<TransformConstraintData>();
+		public var pathConstraints : Vector.<PathConstraintData> = new Vector.<PathConstraintData>();
+		public var width : Number, height : Number;
+		public var version : String, hash : String;
+		public var fps : Number;
+		public var imagesPath : String;
+
+		public function SkeletonData() {
+		}
 
-	// --- Bones.
+		// --- Bones.
+		/** @return May be null. */
+		public function findBone(boneName : String) : BoneData {
+			if (boneName == null) throw new ArgumentError("boneName cannot be null.");
+			for (var i : int = 0, n : int = bones.length; i < n; i++) {
+				var bone : BoneData = bones[i];
+				if (bone._name == boneName) return bone;
+			}
+			return null;
+		}
 
-	/** @return May be null. */
-	public function findBone (boneName:String) : BoneData {
-		if (boneName == null) throw new ArgumentError("boneName cannot be null.");
-		for (var i:int = 0, n:int = bones.length; i < n; i++) {
-			var bone:BoneData = bones[i];
-			if (bone._name == boneName) return bone;
+		/** @return -1 if the bone was not found. */
+		public function findBoneIndex(boneName : String) : int {
+			if (boneName == null) throw new ArgumentError("boneName cannot be null.");
+			for (var i : int = 0, n : int = bones.length; i < n; i++)
+				if (bones[i]._name == boneName) return i;
+			return -1;
 		}
-		return null;
-	}
 
-	/** @return -1 if the bone was not found. */
-	public function findBoneIndex (boneName:String) : int {
-		if (boneName == null) throw new ArgumentError("boneName cannot be null.");
-		for (var i:int = 0, n:int = bones.length; i < n; i++)
-			if (bones[i]._name == boneName) return i;
-		return -1;
-	}
+		// --- Slots.
+		/** @return May be null. */
+		public function findSlot(slotName : String) : SlotData {
+			if (slotName == null) throw new ArgumentError("slotName cannot be null.");
+			for (var i : int = 0, n : int = slots.length; i < n; i++) {
+				var slot : SlotData = slots[i];
+				if (slot._name == slotName) return slot;
+			}
+			return null;
+		}
 
-	// --- Slots.
+		/** @return -1 if the bone was not found. */
+		public function findSlotIndex(slotName : String) : int {
+			if (slotName == null) throw new ArgumentError("slotName cannot be null.");
+			for (var i : int = 0, n : int = slots.length; i < n; i++)
+				if (slots[i]._name == slotName) return i;
+			return -1;
+		}
 
-	/** @return May be null. */
-	public function findSlot (slotName:String) : SlotData {
-		if (slotName == null) throw new ArgumentError("slotName cannot be null.");
-		for (var i:int = 0, n:int = slots.length; i < n; i++) {
-			var slot:SlotData = slots[i];
-			if (slot._name == slotName) return slot;
+		// --- Skins.
+		/** @return May be null. */
+		public function findSkin(skinName : String) : Skin {
+			if (skinName == null) throw new ArgumentError("skinName cannot be null.");
+			for each (var skin : Skin in skins)
+				if (skin._name == skinName) return skin;
+			return null;
 		}
-		return null;
-	}
 
-	/** @return -1 if the bone was not found. */
-	public function findSlotIndex (slotName:String) : int {
-		if (slotName == null) throw new ArgumentError("slotName cannot be null.");
-		for (var i:int = 0, n:int = slots.length; i < n; i++)
-			if (slots[i]._name == slotName) return i;
-		return -1;
-	}
+		// --- Events.
+		/** @return May be null. */
+		public function findEvent(eventName : String) : EventData {
+			if (eventName == null) throw new ArgumentError("eventName cannot be null.");
+			for each (var eventData : EventData in events)
+				if (eventData._name == eventName) return eventData;
+			return null;
+		}
 
-	// --- Skins.
+		// --- Animations.
+		/** @return May be null. */
+		public function findAnimation(animationName : String) : Animation {
+			if (animationName == null) throw new ArgumentError("animationName cannot be null.");
+			for each (var animation : Animation in animations)
+				if (animation.name == animationName) return animation;
+			return null;
+		}
 
-	/** @return May be null. */
-	public function findSkin (skinName:String) : Skin {
-		if (skinName == null) throw new ArgumentError("skinName cannot be null.");
-		for each (var skin:Skin in skins)
-			if (skin._name == skinName) return skin;
-		return null;
-	}
-	
-	// --- Events.
-	
-	/** @return May be null. */
-	public function findEvent (eventName:String) : EventData {
-		if (eventName == null) throw new ArgumentError("eventName cannot be null.");
-		for each (var eventData:EventData in events)
-			if (eventData._name == eventName) return eventData;
-		return null;
-	}
-	
-	// --- Animations.
-	
-	/** @return May be null. */
-	public function findAnimation (animationName:String) : Animation {
-		if (animationName == null) throw new ArgumentError("animationName cannot be null.");
-		for each (var animation:Animation in animations)
-			if (animation.name == animationName) return animation;
-		return null;
-	}
-	
-	// --- IK constraints.
-
-	/** @return May be null. */
-	public function findIkConstraint (constraintName:String) : IkConstraintData {
-		if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-		for each (var ikConstraintData:IkConstraintData in ikConstraints)
-			if (ikConstraintData._name == constraintName) return ikConstraintData;
-		return null;
-	}
-	
-	// --- Transform constraints.
-
-	/** @return May be null. */
-	public function findTransformConstraint (constraintName:String) : TransformConstraintData {
-		if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-		for each (var transformConstraintData:TransformConstraintData in transformConstraints)
-			if (transformConstraintData._name == constraintName) return transformConstraintData;
-		return null;
-	}
-	
-	/** @return -1 if the transform constraint was not found. */
-	public function findTransformConstraintIndex (transformConstraintName:String) : int {
-		if (transformConstraintName == null) throw new ArgumentError("transformConstraintName cannot be null.");
-		var transformConstraints:Vector.<TransformConstraintData> = this.transformConstraints;
-		for (var i:int = 0, n:int = transformConstraints.length; i < n; i++)
-			if (transformConstraints[i].name == transformConstraintName) return i;
-		return -1;
-	}
-	
-	// --- Path constraints.
-	
+		// --- IK constraints.
 		/** @return May be null. */
-	public function findPathConstraint (constraintName:String) : PathConstraintData {
-		if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-		var pathConstraints:Vector.<PathConstraintData> = this.pathConstraints;
-		for (var i:int = 0, n:int = pathConstraints.length; i < n; i++) {
-			var constraint:PathConstraintData = pathConstraints[i];
-			if (constraint.name == constraintName) return constraint;
+		public function findIkConstraint(constraintName : String) : IkConstraintData {
+			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
+			for each (var ikConstraintData : IkConstraintData in ikConstraints)
+				if (ikConstraintData._name == constraintName) return ikConstraintData;
+			return null;
 		}
-		return null;
-	}
 
-	/** @return -1 if the path constraint was not found. */
-	public function findPathConstraintIndex (pathConstraintName:String) : int {
-		if (pathConstraintName == null) throw new ArgumentError("pathConstraintName cannot be null.");
-		var pathConstraints:Vector.<PathConstraintData> = this.pathConstraints;
-		for (var i:int = 0, n:int = pathConstraints.length; i < n; i++)
-			if (pathConstraints[i].name == pathConstraintName) return i;
-		return -1;
-	}
+		// --- Transform constraints.
+		/** @return May be null. */
+		public function findTransformConstraint(constraintName : String) : TransformConstraintData {
+			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
+			for each (var transformConstraintData : TransformConstraintData in transformConstraints)
+				if (transformConstraintData._name == constraintName) return transformConstraintData;
+			return null;
+		}
 
-	// ---
+		/** @return -1 if the transform constraint was not found. */
+		public function findTransformConstraintIndex(transformConstraintName : String) : int {
+			if (transformConstraintName == null) throw new ArgumentError("transformConstraintName cannot be null.");
+			var transformConstraints : Vector.<TransformConstraintData> = this.transformConstraints;
+			for (var i : int = 0, n : int = transformConstraints.length; i < n; i++)
+				if (transformConstraints[i].name == transformConstraintName) return i;
+			return -1;
+		}
 
-	public function toString () : String {
-		return name != null ? name : super.toString();
-	}
-}
+		// --- Path constraints.
+		/** @return May be null. */
+		public function findPathConstraint(constraintName : String) : PathConstraintData {
+			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
+			var pathConstraints : Vector.<PathConstraintData> = this.pathConstraints;
+			for (var i : int = 0, n : int = pathConstraints.length; i < n; i++) {
+				var constraint : PathConstraintData = pathConstraints[i];
+				if (constraint.name == constraintName) return constraint;
+			}
+			return null;
+		}
 
-}
+		/** @return -1 if the path constraint was not found. */
+		public function findPathConstraintIndex(pathConstraintName : String) : int {
+			if (pathConstraintName == null) throw new ArgumentError("pathConstraintName cannot be null.");
+			var pathConstraints : Vector.<PathConstraintData> = this.pathConstraints;
+			for (var i : int = 0, n : int = pathConstraints.length; i < n; i++)
+				if (pathConstraints[i].name == pathConstraintName) return i;
+			return -1;
+		}
+
+		// ---
+		public function toString() : String {
+			return name != null ? name : super.toString();
+		}
+	}
+}

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

@@ -31,742 +31,733 @@
 package spine {
 	import spine.animation.TwoColorTimeline;
 	import spine.attachments.PointAttachment;
-import spine.animation.PathConstraintMixTimeline;
-import spine.animation.PathConstraintSpacingTimeline;
-import spine.animation.PathConstraintPositionTimeline;
-import spine.animation.TransformConstraintTimeline;
-import spine.animation.ShearTimeline;
-import spine.attachments.PathAttachment;
-import spine.attachments.VertexAttachment;
-import flash.utils.ByteArray;
-
-import spine.animation.Animation;
-import spine.animation.AttachmentTimeline;
-import spine.animation.ColorTimeline;
-import spine.animation.CurveTimeline;
-import spine.animation.DrawOrderTimeline;
-import spine.animation.EventTimeline;
-import spine.animation.DeformTimeline;
-import spine.animation.IkConstraintTimeline;
-import spine.animation.RotateTimeline;
-import spine.animation.ScaleTimeline;
-import spine.animation.Timeline;
-import spine.animation.TranslateTimeline;
-import spine.attachments.Attachment;
-import spine.attachments.AttachmentLoader;
-import spine.attachments.AttachmentType;
-import spine.attachments.BoundingBoxAttachment;
-import spine.attachments.MeshAttachment;
-import spine.attachments.RegionAttachment;
-
-public class SkeletonJson {
-	public var attachmentLoader:AttachmentLoader;
-	public var scale:Number = 1;
-	private var linkedMeshes:Vector.<LinkedMesh> = new Vector.<LinkedMesh>();
-
-	public function SkeletonJson (attachmentLoader:AttachmentLoader = null) {
-		this.attachmentLoader = attachmentLoader;
-	}
-
-	/** @param object A String or ByteArray. */
-	public function readSkeletonData (object:*, name:String = null) : SkeletonData {
-		if (object == null) throw new ArgumentError("object cannot be null.");
-
-		var root:Object;
-		if (object is String)
-			root = JSON.parse(String(object));
-		else if (object is ByteArray)
-			root = JSON.parse(ByteArray(object).readUTFBytes(ByteArray(object).length));
-		else if (object is Object)
-			root = object;
-		else
-			throw new ArgumentError("object must be a String, ByteArray or Object.");
-
-		var skeletonData:SkeletonData = new SkeletonData();
-		skeletonData.name = name;
-
-		// Skeleton.
-		var skeletonMap:Object = root["skeleton"];
-		if (skeletonMap) {
-			skeletonData.hash = skeletonMap["hash"];
-			skeletonData.version = skeletonMap["spine"];
-			skeletonData.width = skeletonMap["width"] || 0;
-			skeletonData.height = skeletonMap["height"] || 0;
-			skeletonData.fps = skeletonMap["fps"] || 0;
-			skeletonData.imagesPath = skeletonMap["images"];		
-		}			
-
-		// Bones.
-		var boneData:BoneData;
-		for each (var boneMap:Object in root["bones"]) {
-			var parent:BoneData = null;
-			var parentName:String = boneMap["parent"];
-			if (parentName) {
-				parent = skeletonData.findBone(parentName);
-				if (!parent) throw new Error("Parent bone not found: " + parentName);
-			}
-			boneData = new BoneData(skeletonData.bones.length, boneMap["name"], parent);
-			boneData.length = Number(boneMap["length"] || 0) * scale;
-			boneData.x = Number(boneMap["x"] || 0) * scale;
-			boneData.y = Number(boneMap["y"] || 0) * scale;
-			boneData.rotation = (boneMap["rotation"] || 0);
-			boneData.scaleX = boneMap.hasOwnProperty("scaleX") ? boneMap["scaleX"] : 1;
-			boneData.scaleY = boneMap.hasOwnProperty("scaleY") ? boneMap["scaleY"] : 1;
-			boneData.shearX = Number(boneMap["shearX"] || 0);
-			boneData.shearY = Number(boneMap["shearY"] || 0);
-			boneData.transformMode = TransformMode[boneMap["transform"] || "normal"];			
-			skeletonData.bones.push(boneData);
+	import spine.animation.PathConstraintMixTimeline;
+	import spine.animation.PathConstraintSpacingTimeline;
+	import spine.animation.PathConstraintPositionTimeline;
+	import spine.animation.TransformConstraintTimeline;
+	import spine.animation.ShearTimeline;
+	import spine.attachments.PathAttachment;
+	import spine.attachments.VertexAttachment;
+
+	import flash.utils.ByteArray;
+
+	import spine.animation.Animation;
+	import spine.animation.AttachmentTimeline;
+	import spine.animation.ColorTimeline;
+	import spine.animation.CurveTimeline;
+	import spine.animation.DrawOrderTimeline;
+	import spine.animation.EventTimeline;
+	import spine.animation.DeformTimeline;
+	import spine.animation.IkConstraintTimeline;
+	import spine.animation.RotateTimeline;
+	import spine.animation.ScaleTimeline;
+	import spine.animation.Timeline;
+	import spine.animation.TranslateTimeline;
+	import spine.attachments.Attachment;
+	import spine.attachments.AttachmentLoader;
+	import spine.attachments.AttachmentType;
+	import spine.attachments.BoundingBoxAttachment;
+	import spine.attachments.MeshAttachment;
+	import spine.attachments.RegionAttachment;
+
+	public class SkeletonJson {
+		public var attachmentLoader : AttachmentLoader;
+		public var scale : Number = 1;
+		private var linkedMeshes : Vector.<LinkedMesh> = new Vector.<LinkedMesh>();
+
+		public function SkeletonJson(attachmentLoader : AttachmentLoader = null) {
+			this.attachmentLoader = attachmentLoader;
 		}
-		
-		// Slots.
-		for each (var slotMap:Object in root["slots"]) {
-			var slotName:String = slotMap["name"];
-			var boneName:String = slotMap["bone"];
-			boneData = skeletonData.findBone(boneName);
-			if (!boneData) throw new Error("Slot bone not found: " + boneName);
-			var slotData:SlotData = new SlotData(skeletonData.slots.length, slotName, boneData);
-
-			var color:String = slotMap["color"];
-			if (color) {
-				slotData.color.setFrom(toColor(color, 0), toColor(color, 1), toColor(color, 2), toColor(color, 3));
+
+		/** @param object A String or ByteArray. */
+		public function readSkeletonData(object : *, name : String = null) : SkeletonData {
+			if (object == null) throw new ArgumentError("object cannot be null.");
+
+			var root : Object;
+			if (object is String)
+				root = JSON.parse(String(object));
+			else if (object is ByteArray)
+				root = JSON.parse(ByteArray(object).readUTFBytes(ByteArray(object).length));
+			else if (object is Object)
+				root = object;
+			else
+				throw new ArgumentError("object must be a String, ByteArray or Object.");
+
+			var skeletonData : SkeletonData = new SkeletonData();
+			skeletonData.name = name;
+
+			// Skeleton.
+			var skeletonMap : Object = root["skeleton"];
+			if (skeletonMap) {
+				skeletonData.hash = skeletonMap["hash"];
+				skeletonData.version = skeletonMap["spine"];
+				skeletonData.width = skeletonMap["width"] || 0;
+				skeletonData.height = skeletonMap["height"] || 0;
+				skeletonData.fps = skeletonMap["fps"] || 0;
+				skeletonData.imagesPath = skeletonMap["images"];
 			}
-			
-			var dark:String = slotMap["dark"];
-			if (dark) {
-				slotData.darkColor.setFrom(toColor(dark, 0), toColor(dark, 1), toColor(dark, 2), toColor(dark, 3));
+
+			// Bones.
+			var boneData : BoneData;
+			for each (var boneMap : Object in root["bones"]) {
+				var parent : BoneData = null;
+				var parentName : String = boneMap["parent"];
+				if (parentName) {
+					parent = skeletonData.findBone(parentName);
+					if (!parent) throw new Error("Parent bone not found: " + parentName);
+				}
+				boneData = new BoneData(skeletonData.bones.length, boneMap["name"], parent);
+				boneData.length = Number(boneMap["length"] || 0) * scale;
+				boneData.x = Number(boneMap["x"] || 0) * scale;
+				boneData.y = Number(boneMap["y"] || 0) * scale;
+				boneData.rotation = (boneMap["rotation"] || 0);
+				boneData.scaleX = boneMap.hasOwnProperty("scaleX") ? boneMap["scaleX"] : 1;
+				boneData.scaleY = boneMap.hasOwnProperty("scaleY") ? boneMap["scaleY"] : 1;
+				boneData.shearX = Number(boneMap["shearX"] || 0);
+				boneData.shearY = Number(boneMap["shearY"] || 0);
+				boneData.transformMode = TransformMode[boneMap["transform"] || "normal"];
+				skeletonData.bones.push(boneData);
 			}
 
-			slotData.attachmentName = slotMap["attachment"];
-			slotData.blendMode = BlendMode[slotMap["blend"] || "normal"];
-			skeletonData.slots.push(slotData);
-		}
+			// Slots.
+			for each (var slotMap : Object in root["slots"]) {
+				var slotName : String = slotMap["name"];
+				var boneName : String = slotMap["bone"];
+				boneData = skeletonData.findBone(boneName);
+				if (!boneData) throw new Error("Slot bone not found: " + boneName);
+				var slotData : SlotData = new SlotData(skeletonData.slots.length, slotName, boneData);
 
-		// IK constraints.
-		for each (var constraintMap:Object in root["ik"]) {
-			var ikConstraintData:IkConstraintData = new IkConstraintData(constraintMap["name"]);
-			ikConstraintData.order = constraintMap["order"] || 0;
+				var color : String = slotMap["color"];
+				if (color) {
+					slotData.color.setFrom(toColor(color, 0), toColor(color, 1), toColor(color, 2), toColor(color, 3));
+				}
 
-			for each (boneName in constraintMap["bones"]) {
-				var bone:BoneData = skeletonData.findBone(boneName);
-				if (!bone) throw new Error("IK constraint bone not found: " + boneName);
-				ikConstraintData.bones.push(bone);
+				var dark : String = slotMap["dark"];
+				if (dark) {
+					slotData.darkColor.setFrom(toColor(dark, 0), toColor(dark, 1), toColor(dark, 2), toColor(dark, 3));
+				}
+
+				slotData.attachmentName = slotMap["attachment"];
+				slotData.blendMode = BlendMode[slotMap["blend"] || "normal"];
+				skeletonData.slots.push(slotData);
 			}
 
-			ikConstraintData.target = skeletonData.findBone(constraintMap["target"]);
-			if (!ikConstraintData.target) throw new Error("Target bone not found: " + constraintMap["target"]);
+			// IK constraints.
+			for each (var constraintMap : Object in root["ik"]) {
+				var ikConstraintData : IkConstraintData = new IkConstraintData(constraintMap["name"]);
+				ikConstraintData.order = constraintMap["order"] || 0;
 
-			ikConstraintData.bendDirection = (!constraintMap.hasOwnProperty("bendPositive") || constraintMap["bendPositive"]) ? 1 : -1;
-			ikConstraintData.mix = constraintMap.hasOwnProperty("mix") ? constraintMap["mix"] : 1;
+				for each (boneName in constraintMap["bones"]) {
+					var bone : BoneData = skeletonData.findBone(boneName);
+					if (!bone) throw new Error("IK constraint bone not found: " + boneName);
+					ikConstraintData.bones.push(bone);
+				}
 
-			skeletonData.ikConstraints.push(ikConstraintData);
-		}
+				ikConstraintData.target = skeletonData.findBone(constraintMap["target"]);
+				if (!ikConstraintData.target) throw new Error("Target bone not found: " + constraintMap["target"]);
 
-		// Transform constraints.
-		for each (constraintMap in root["transform"]) {
-			var transformConstraintData:TransformConstraintData = new TransformConstraintData(constraintMap["name"]);
-			transformConstraintData.order = constraintMap["order"] || 0;
+				ikConstraintData.bendDirection = (!constraintMap.hasOwnProperty("bendPositive") || constraintMap["bendPositive"]) ? 1 : -1;
+				ikConstraintData.mix = constraintMap.hasOwnProperty("mix") ? constraintMap["mix"] : 1;
 
-			for each (boneName in constraintMap["bones"]) {
-				bone = skeletonData.findBone(boneName);
-				if (!bone) throw new Error("Transform constraint bone not found: " + boneName);
-				transformConstraintData.bones.push(bone);
-			}
-		
-			transformConstraintData.target = skeletonData.findBone(constraintMap["target"]);
-			if (!transformConstraintData.target) throw new Error("Target bone not found: " + constraintMap["target"]);
-			
-			transformConstraintData.local = constraintMap.hasOwnProperty("local") ? Boolean(constraintMap["local"]) : false;
-			transformConstraintData.relative = constraintMap.hasOwnProperty("relative") ? Boolean(constraintMap["relative"]) : false;
-			
-			transformConstraintData.offsetRotation = Number(constraintMap["rotation"] || 0);
-			transformConstraintData.offsetX = Number(constraintMap["x"] || 0) * scale;
-			transformConstraintData.offsetY = Number(constraintMap["y"] || 0) * scale;
-			transformConstraintData.offsetScaleX = Number(constraintMap["scaleX"] || 0);
-			transformConstraintData.offsetScaleY = Number(constraintMap["scaleY"] || 0);
-			transformConstraintData.offsetShearY = Number(constraintMap["shearY"] || 0);
-			
-			transformConstraintData.rotateMix = constraintMap.hasOwnProperty("rotateMix") ? constraintMap["rotateMix"] : 1;
-			transformConstraintData.translateMix = constraintMap.hasOwnProperty("translateMix") ? constraintMap["translateMix"] : 1;
-			transformConstraintData.scaleMix = constraintMap.hasOwnProperty("scaleMix") ? constraintMap["scaleMix"] : 1;
-			transformConstraintData.shearMix = constraintMap.hasOwnProperty("shearMix") ? constraintMap["shearMix"] : 1;
-
-			skeletonData.transformConstraints.push(transformConstraintData);
-		}
-		
-		// Path constraints.
-		for each (constraintMap in root["path"]) {
-			var pathConstraintData:PathConstraintData = new PathConstraintData(constraintMap["name"]);
-			pathConstraintData.order = constraintMap["order"] || 0;
-
-			for each (boneName in constraintMap["bones"]) {
-				bone = skeletonData.findBone(boneName);
-				if (!bone) throw new Error("Path constraint bone not found: " + boneName);
-				pathConstraintData.bones.push(bone);
+				skeletonData.ikConstraints.push(ikConstraintData);
 			}
-		
-			pathConstraintData.target = skeletonData.findSlot(constraintMap["target"]);
-			if (!pathConstraintData.target) throw new Error("Path target slot not found: " + constraintMap["target"]);
-
-			pathConstraintData.positionMode = PositionMode[constraintMap["positionMode"] || "percent"];
-			pathConstraintData.spacingMode = SpacingMode[constraintMap["spacingMode"] || "length"];
-			pathConstraintData.rotateMode = RotateMode[constraintMap["rotateMode"] || "tangent"];
-			pathConstraintData.offsetRotation = Number(constraintMap["rotation"] || 0);
-			pathConstraintData.position = Number(constraintMap["position"] || 0);
-			if (pathConstraintData.positionMode == PositionMode.fixed) pathConstraintData.position *= scale;
-			pathConstraintData.spacing = Number(constraintMap["spacing"] || 0);
-			if (pathConstraintData.spacingMode == SpacingMode.length || pathConstraintData.spacingMode == SpacingMode.fixed) pathConstraintData.spacing *= scale;
-			pathConstraintData.rotateMix = constraintMap.hasOwnProperty("rotateMix") ? constraintMap["rotateMix"] : 1;
-			pathConstraintData.translateMix = constraintMap.hasOwnProperty("translateMix") ? constraintMap["translateMix"] : 1;
-
-			skeletonData.pathConstraints.push(pathConstraintData);
-		}
 
-		// Skins.
-		var skins:Object = root["skins"];
-		for (var skinName:String in skins) {
-			var skinMap:Object = skins[skinName];
-			var skin:Skin = new Skin(skinName);
-			for (slotName in skinMap) {
-				var slotIndex:int = skeletonData.findSlotIndex(slotName);
-				var slotEntry:Object = skinMap[slotName];
-				for (var attachmentName:String in slotEntry) {
-					var attachment:Attachment = readAttachment(slotEntry[attachmentName], skin, slotIndex, attachmentName);
-					if (attachment != null)
-						skin.addAttachment(slotIndex, attachmentName, attachment);
+			// Transform constraints.
+			for each (constraintMap in root["transform"]) {
+				var transformConstraintData : TransformConstraintData = new TransformConstraintData(constraintMap["name"]);
+				transformConstraintData.order = constraintMap["order"] || 0;
+
+				for each (boneName in constraintMap["bones"]) {
+					bone = skeletonData.findBone(boneName);
+					if (!bone) throw new Error("Transform constraint bone not found: " + boneName);
+					transformConstraintData.bones.push(bone);
 				}
-			}
-			skeletonData.skins[skeletonData.skins.length] = skin;
-			if (skin.name == "default")
-				skeletonData.defaultSkin = skin;
-		}
 
-		// Linked meshes.
-		var linkedMeshes:Vector.<LinkedMesh> = this.linkedMeshes;
-		for each (var linkedMesh:LinkedMesh in linkedMeshes) {
-			var parentSkin:Skin = !linkedMesh.skin ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin);
-			if (!parentSkin) throw new Error("Skin not found: " + linkedMesh.skin);
-			var parentMesh:Attachment = parentSkin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent);
-			if (!parentMesh) throw new Error("Parent mesh not found: " + linkedMesh.parent);
-			linkedMesh.mesh.parentMesh = MeshAttachment(parentMesh);
-			linkedMesh.mesh.updateUVs();
-		}
-		linkedMeshes.length = 0;
-
-		// Events.
-		var events:Object = root["events"];
-		if (events) {
-			for (var eventName:String in events) {
-				var eventMap:Object = events[eventName];
-				var eventData:EventData = new EventData(eventName);
-				eventData.intValue = eventMap["int"] || 0;
-				eventData.floatValue = eventMap["float"] || 0;
-				eventData.stringValue = eventMap["string"] || "";
-				skeletonData.events.push(eventData);
-			}
-		}
+				transformConstraintData.target = skeletonData.findBone(constraintMap["target"]);
+				if (!transformConstraintData.target) throw new Error("Target bone not found: " + constraintMap["target"]);
 
-		// Animations.
-		var animations:Object = root["animations"];
-		for (var animationName:String in animations)
-			readAnimation(animations[animationName], animationName, skeletonData);
+				transformConstraintData.local = constraintMap.hasOwnProperty("local") ? Boolean(constraintMap["local"]) : false;
+				transformConstraintData.relative = constraintMap.hasOwnProperty("relative") ? Boolean(constraintMap["relative"]) : false;
 
-		return skeletonData;
-	}
+				transformConstraintData.offsetRotation = Number(constraintMap["rotation"] || 0);
+				transformConstraintData.offsetX = Number(constraintMap["x"] || 0) * scale;
+				transformConstraintData.offsetY = Number(constraintMap["y"] || 0) * scale;
+				transformConstraintData.offsetScaleX = Number(constraintMap["scaleX"] || 0);
+				transformConstraintData.offsetScaleY = Number(constraintMap["scaleY"] || 0);
+				transformConstraintData.offsetShearY = Number(constraintMap["shearY"] || 0);
 
-	private function readAttachment (map:Object, skin:Skin, slotIndex:int, name:String) : Attachment {
-		name = map["name"] || name;
-
-		var typeName:String = map["type"] || "region";		
-		var type:AttachmentType = AttachmentType[typeName];		
-
-		var scale:Number = this.scale;
-		var color:String;
-		switch (type) {
-			case AttachmentType.region:
-				var region:RegionAttachment = attachmentLoader.newRegionAttachment(skin, name, map["path"] || name);
-				if (!region) return null;
-				region.path = map["path"] || name;
-				region.x = Number(map["x"] || 0) * scale;
-				region.y = Number(map["y"] || 0) * scale;
-				region.scaleX = map.hasOwnProperty("scaleX") ? map["scaleX"] : 1;
-				region.scaleY = map.hasOwnProperty("scaleY") ? map["scaleY"] : 1;
-				region.rotation = map["rotation"] || 0;
-				region.width = Number(map["width"] || 0) * scale;
-				region.height = Number(map["height"] || 0) * scale;
-				color = map["color"];
-				if (color) {
-					region.color.setFrom(toColor(color, 0), toColor(color, 1), toColor(color, 2), toColor(color, 3));					
-				}
-				region.updateOffset();
-				return region;
-			case AttachmentType.mesh:
-			case AttachmentType.linkedmesh:
-				var mesh:MeshAttachment = attachmentLoader.newMeshAttachment(skin, name, map["path"] || name);
-				if (!mesh) return null;
-				mesh.path = map["path"] || name;
-
-				color = map["color"];
-				if (color) {
-					mesh.color.setFrom(toColor(color, 0), toColor(color, 1), toColor(color, 2), toColor(color, 3));
-				}
+				transformConstraintData.rotateMix = constraintMap.hasOwnProperty("rotateMix") ? constraintMap["rotateMix"] : 1;
+				transformConstraintData.translateMix = constraintMap.hasOwnProperty("translateMix") ? constraintMap["translateMix"] : 1;
+				transformConstraintData.scaleMix = constraintMap.hasOwnProperty("scaleMix") ? constraintMap["scaleMix"] : 1;
+				transformConstraintData.shearMix = constraintMap.hasOwnProperty("shearMix") ? constraintMap["shearMix"] : 1;
 
-				mesh.width = Number(map["width"] || 0) * scale;
-				mesh.height = Number(map["height"] || 0) * scale;
+				skeletonData.transformConstraints.push(transformConstraintData);
+			}
 
-				if (map["parent"]) {
-					mesh.inheritDeform = map.hasOwnProperty("deform") ? Boolean(map["deform"]) : true;
-					linkedMeshes.push(new LinkedMesh(mesh, map["skin"], slotIndex, map["parent"]));
-					return mesh;
-				}
-				
-				var uvs:Vector.<Number> = getFloatArray(map, "uvs", 1);
-				readVertices(map, mesh, uvs.length);			
-				mesh.triangles = getUintArray(map, "triangles");	
-				mesh.regionUVs = uvs;									
-				mesh.updateUVs();
-
-				mesh.hullLength = int(map["hull"] || 0) * 2;
-				if (map["edges"]) mesh.edges = getIntArray(map, "edges");
-				return mesh;			
-			case AttachmentType.boundingbox:
-				var box:BoundingBoxAttachment = attachmentLoader.newBoundingBoxAttachment(skin, name);
-				if (!box) return null;
-				readVertices(map, box, int(map["vertexCount"]) << 1);								
-				return box;
-			case AttachmentType.path:
-				var path:PathAttachment = attachmentLoader.newPathAttachment(skin, name);
-				if (!path) return null;
-				path.closed = map.hasOwnProperty("closed") ? Boolean(map["closed"]) : false;
-				path.constantSpeed = map.hasOwnProperty("constantSpeed") ? Boolean(map["constantSpeed"]) : true;
-				
-				var vertexCount:int = int(map["vertexCount"]);
-				readVertices(map, path, vertexCount << 1);
-				
-				var lengths:Vector.<Number> = new Vector.<Number>();							
-				for each (var curves:Object in map["lengths"]) {
-					lengths.push(Number(curves) * scale);
-				}
-				path.lengths = lengths;				
-				return path;
-			case AttachmentType.point:
-				var point:PointAttachment = attachmentLoader.newPointAttachment(skin, name);
-				if (!point) return null;
-				point.x = map.hasOwnProperty("x") ? Number(map["x"]) * scale : 0;
-				point.y = map.hasOwnProperty("y") ? Number(map["y"]) * scale : 0;
-				point.rotation = map.hasOwnProperty("rotation") ? Number(map["rotation"]) : 0;
-				
-				color = map["color"];
-				if (color) {
-					point.color.setFrom(toColor(color, 0), toColor(color, 1), toColor(color, 2), toColor(color, 3)); 					
+			// Path constraints.
+			for each (constraintMap in root["path"]) {
+				var pathConstraintData : PathConstraintData = new PathConstraintData(constraintMap["name"]);
+				pathConstraintData.order = constraintMap["order"] || 0;
+
+				for each (boneName in constraintMap["bones"]) {
+					bone = skeletonData.findBone(boneName);
+					if (!bone) throw new Error("Path constraint bone not found: " + boneName);
+					pathConstraintData.bones.push(bone);
 				}
-				return point;
-		}
 
-		return null;
-	}
-	
-	private function readVertices(map:Object, attachment:VertexAttachment, verticesLength:int) : void {
-		attachment.worldVerticesLength = verticesLength;
-		var vertices:Vector.<Number> = getFloatArray(map, "vertices", 1);
-		if (verticesLength == vertices.length) {
-			if (scale != 1) {
-				for (var i:int = 0, n:int = vertices.length; i < n; i++) {
-					vertices[i] *= scale;
+				pathConstraintData.target = skeletonData.findSlot(constraintMap["target"]);
+				if (!pathConstraintData.target) throw new Error("Path target slot not found: " + constraintMap["target"]);
+
+				pathConstraintData.positionMode = PositionMode[constraintMap["positionMode"] || "percent"];
+				pathConstraintData.spacingMode = SpacingMode[constraintMap["spacingMode"] || "length"];
+				pathConstraintData.rotateMode = RotateMode[constraintMap["rotateMode"] || "tangent"];
+				pathConstraintData.offsetRotation = Number(constraintMap["rotation"] || 0);
+				pathConstraintData.position = Number(constraintMap["position"] || 0);
+				if (pathConstraintData.positionMode == PositionMode.fixed) pathConstraintData.position *= scale;
+				pathConstraintData.spacing = Number(constraintMap["spacing"] || 0);
+				if (pathConstraintData.spacingMode == SpacingMode.length || pathConstraintData.spacingMode == SpacingMode.fixed) pathConstraintData.spacing *= scale;
+				pathConstraintData.rotateMix = constraintMap.hasOwnProperty("rotateMix") ? constraintMap["rotateMix"] : 1;
+				pathConstraintData.translateMix = constraintMap.hasOwnProperty("translateMix") ? constraintMap["translateMix"] : 1;
+
+				skeletonData.pathConstraints.push(pathConstraintData);
+			}
+
+			// Skins.
+			var skins : Object = root["skins"];
+			for (var skinName : String in skins) {
+				var skinMap : Object = skins[skinName];
+				var skin : Skin = new Skin(skinName);
+				for (slotName in skinMap) {
+					var slotIndex : int = skeletonData.findSlotIndex(slotName);
+					var slotEntry : Object = skinMap[slotName];
+					for (var attachmentName : String in slotEntry) {
+						var attachment : Attachment = readAttachment(slotEntry[attachmentName], skin, slotIndex, attachmentName);
+						if (attachment != null)
+							skin.addAttachment(slotIndex, attachmentName, attachment);
+					}
 				}
+				skeletonData.skins[skeletonData.skins.length] = skin;
+				if (skin.name == "default")
+					skeletonData.defaultSkin = skin;
 			}
-			attachment.vertices = vertices;
-			return;
-		}
-		
-		var weights:Vector.<Number> = new Vector.<Number>(verticesLength * 3 * 3);
-		weights.length = 0;
-		var bones:Vector.<int> = new Vector.<int>(verticesLength * 3);
-		bones.length = 0;
-		for (i = 0, n = vertices.length; i < n;) {
-			var boneCount:int = int(vertices[i++]);
-			bones.push(boneCount);
-			for (var nn:int = i + boneCount * 4; i < nn; i+=4) {
-				bones.push(int(vertices[i]));
-				weights.push(vertices[i + 1] * scale);
-				weights.push(vertices[i + 2] * scale);
-				weights.push(vertices[i + 3]);
+
+			// Linked meshes.
+			var linkedMeshes : Vector.<LinkedMesh> = this.linkedMeshes;
+			for each (var linkedMesh : LinkedMesh in linkedMeshes) {
+				var parentSkin : Skin = !linkedMesh.skin ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin);
+				if (!parentSkin) throw new Error("Skin not found: " + linkedMesh.skin);
+				var parentMesh : Attachment = parentSkin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent);
+				if (!parentMesh) throw new Error("Parent mesh not found: " + linkedMesh.parent);
+				linkedMesh.mesh.parentMesh = MeshAttachment(parentMesh);
+				linkedMesh.mesh.updateUVs();
 			}
+			linkedMeshes.length = 0;
+
+			// Events.
+			var events : Object = root["events"];
+			if (events) {
+				for (var eventName : String in events) {
+					var eventMap : Object = events[eventName];
+					var eventData : EventData = new EventData(eventName);
+					eventData.intValue = eventMap["int"] || 0;
+					eventData.floatValue = eventMap["float"] || 0;
+					eventData.stringValue = eventMap["string"] || "";
+					skeletonData.events.push(eventData);
+				}
+			}
+
+			// Animations.
+			var animations : Object = root["animations"];
+			for (var animationName : String in animations)
+				readAnimation(animations[animationName], animationName, skeletonData);
+
+			return skeletonData;
 		}
-		attachment.bones = bones;
-		attachment.vertices = weights;
-	}
 
-	private function readAnimation (map:Object, name:String, skeletonData:SkeletonData) : void {
-		var scale:Number = this.scale;
-		var timelines:Vector.<Timeline> = new Vector.<Timeline>();
-		var duration:Number = 0;
-
-		var slotMap:Object, slotIndex:int, slotName:String;
-		var values:Array, valueMap:Object, frameIndex:int;
-		var i:int;
-		var timelineName:String;
-
-		var slots:Object = map["slots"];
-		for (slotName in slots) {
-			slotMap = slots[slotName];
-			slotIndex = skeletonData.findSlotIndex(slotName);
-
-			for (timelineName in slotMap) {
-				values = slotMap[timelineName];
-				if (timelineName == "attachment") {
-					var attachmentTimeline:AttachmentTimeline = new AttachmentTimeline(values.length);
-					attachmentTimeline.slotIndex = slotIndex;
-
-					frameIndex = 0;
-					for each (valueMap in values)
-						attachmentTimeline.setFrame(frameIndex++, valueMap["time"], valueMap["name"]);
-					timelines[timelines.length] = attachmentTimeline;
-					duration = Math.max(duration, attachmentTimeline.frames[attachmentTimeline.frameCount - 1]);
-				} else if (timelineName == "color") {
-					var colorTimeline:ColorTimeline = new ColorTimeline(values.length);
-					colorTimeline.slotIndex = slotIndex;
-
-					frameIndex = 0;
-					for each (valueMap in values) {
-						var color:String = valueMap["color"];
-						var r:Number = toColor(color, 0);
-						var g:Number = toColor(color, 1);
-						var b:Number = toColor(color, 2);
-						var a:Number = toColor(color, 3);
-						colorTimeline.setFrame(frameIndex, valueMap["time"], r, g, b, a);
-						readCurve(valueMap, colorTimeline, frameIndex);
-						frameIndex++;
+		private function readAttachment(map : Object, skin : Skin, slotIndex : int, name : String) : Attachment {
+			name = map["name"] || name;
+
+			var typeName : String = map["type"] || "region";
+			var type : AttachmentType = AttachmentType[typeName];
+
+			var scale : Number = this.scale;
+			var color : String;
+			switch (type) {
+				case AttachmentType.region:
+					var region : RegionAttachment = attachmentLoader.newRegionAttachment(skin, name, map["path"] || name);
+					if (!region) return null;
+					region.path = map["path"] || name;
+					region.x = Number(map["x"] || 0) * scale;
+					region.y = Number(map["y"] || 0) * scale;
+					region.scaleX = map.hasOwnProperty("scaleX") ? map["scaleX"] : 1;
+					region.scaleY = map.hasOwnProperty("scaleY") ? map["scaleY"] : 1;
+					region.rotation = map["rotation"] || 0;
+					region.width = Number(map["width"] || 0) * scale;
+					region.height = Number(map["height"] || 0) * scale;
+					color = map["color"];
+					if (color) {
+						region.color.setFrom(toColor(color, 0), toColor(color, 1), toColor(color, 2), toColor(color, 3));
 					}
-					timelines[timelines.length] = colorTimeline;
-					duration = Math.max(duration, colorTimeline.frames[(colorTimeline.frameCount - 1) * ColorTimeline.ENTRIES]);
-				} else if (timelineName == "twoColor") {
-					var twoColorTimeline:TwoColorTimeline = new TwoColorTimeline(values.length);
-					twoColorTimeline.slotIndex = slotIndex;
-
-					frameIndex = 0;
-					for each (valueMap in values) {
-						color = valueMap["color"];
-						var darkColor:String = valueMap["dark"];
-						var light:Color = new Color(0, 0, 0, 0);
-						var dark:Color = new Color(0, 0, 0, 0);						
-						light.setFrom(toColor(color, 0), toColor(color, 1), toColor(color, 2), toColor(color, 3));
-						dark.setFrom(toColor(darkColor, 0), toColor(darkColor, 1), toColor(darkColor, 2), toColor(darkColor, 3));						
-						twoColorTimeline.setFrame(frameIndex, valueMap["time"], light.r, light.g, light.b, light.a, dark.r, dark.g, dark.b);
-						readCurve(valueMap, twoColorTimeline, frameIndex);
-						frameIndex++;
+					region.updateOffset();
+					return region;
+				case AttachmentType.mesh:
+				case AttachmentType.linkedmesh:
+					var mesh : MeshAttachment = attachmentLoader.newMeshAttachment(skin, name, map["path"] || name);
+					if (!mesh) return null;
+					mesh.path = map["path"] || name;
+					color = map["color"];
+					if (color) {
+						mesh.color.setFrom(toColor(color, 0), toColor(color, 1), toColor(color, 2), toColor(color, 3));
 					}
-					timelines[timelines.length] = twoColorTimeline;
-					duration = Math.max(duration, twoColorTimeline.frames[(twoColorTimeline.frameCount - 1) * TwoColorTimeline.ENTRIES]);
-				} else
-					throw new Error("Invalid timeline type for a slot: " + timelineName + " (" + slotName + ")");
-			}
-		}
-
-		var bones:Object = map["bones"];
-		for (var boneName:String in bones) {
-			var boneIndex:int = skeletonData.findBoneIndex(boneName);
-			if (boneIndex == -1) throw new Error("Bone not found: " + boneName);
-			var boneMap:Object = bones[boneName];
-
-			for (timelineName in boneMap) {
-				values = boneMap[timelineName];
-				if (timelineName == "rotate") {
-					var rotateTimeline:RotateTimeline = new RotateTimeline(values.length);
-					rotateTimeline.boneIndex = boneIndex;
-
-					frameIndex = 0;
-					for each (valueMap in values) {
-						rotateTimeline.setFrame(frameIndex, valueMap["time"], valueMap["angle"]);
-						readCurve(valueMap, rotateTimeline, frameIndex);
-						frameIndex++;
+					mesh.width = Number(map["width"] || 0) * scale;
+					mesh.height = Number(map["height"] || 0) * scale;
+					if (map["parent"]) {
+						mesh.inheritDeform = map.hasOwnProperty("deform") ? Boolean(map["deform"]) : true;
+						linkedMeshes.push(new LinkedMesh(mesh, map["skin"], slotIndex, map["parent"]));
+						return mesh;
 					}
-					timelines[timelines.length] = rotateTimeline;
-					duration = Math.max(duration, rotateTimeline.frames[(rotateTimeline.frameCount - 1) * RotateTimeline.ENTRIES]);
-				} else if (timelineName == "translate" || timelineName == "scale" || timelineName == "shear") {
-					var translateTimeline:TranslateTimeline;
-					var timelineScale:Number = 1;
-					if (timelineName == "scale")
-						translateTimeline = new ScaleTimeline(values.length);
-					else if (timelineName == "shear")
-						translateTimeline = new ShearTimeline(values.length);
-					else {
-						translateTimeline = new TranslateTimeline(values.length);
-						timelineScale = scale;
+					var uvs : Vector.<Number> = getFloatArray(map, "uvs", 1);
+					readVertices(map, mesh, uvs.length);
+					mesh.triangles = getUintArray(map, "triangles");
+					mesh.regionUVs = uvs;
+					mesh.updateUVs();
+					mesh.hullLength = int(map["hull"] || 0) * 2;
+					if (map["edges"]) mesh.edges = getIntArray(map, "edges");
+					return mesh;
+				case AttachmentType.boundingbox:
+					var box : BoundingBoxAttachment = attachmentLoader.newBoundingBoxAttachment(skin, name);
+					if (!box) return null;
+					readVertices(map, box, int(map["vertexCount"]) << 1);
+					return box;
+				case AttachmentType.path:
+					var path : PathAttachment = attachmentLoader.newPathAttachment(skin, name);
+					if (!path) return null;
+					path.closed = map.hasOwnProperty("closed") ? Boolean(map["closed"]) : false;
+					path.constantSpeed = map.hasOwnProperty("constantSpeed") ? Boolean(map["constantSpeed"]) : true;
+					var vertexCount : int = int(map["vertexCount"]);
+					readVertices(map, path, vertexCount << 1);
+					var lengths : Vector.<Number> = new Vector.<Number>();
+					for each (var curves : Object in map["lengths"]) {
+						lengths.push(Number(curves) * scale);
 					}
-					translateTimeline.boneIndex = boneIndex;
-
-					frameIndex = 0;
-					for each (valueMap in values) {
-						var x:Number = Number(valueMap["x"] || 0) * timelineScale;
-						var y:Number = Number(valueMap["y"] || 0) * timelineScale;
-						translateTimeline.setFrame(frameIndex, valueMap["time"], x, y);
-						readCurve(valueMap, translateTimeline, frameIndex);
-						frameIndex++;
+					path.lengths = lengths;
+					return path;
+				case AttachmentType.point:
+					var point : PointAttachment = attachmentLoader.newPointAttachment(skin, name);
+					if (!point) return null;
+					point.x = map.hasOwnProperty("x") ? Number(map["x"]) * scale : 0;
+					point.y = map.hasOwnProperty("y") ? Number(map["y"]) * scale : 0;
+					point.rotation = map.hasOwnProperty("rotation") ? Number(map["rotation"]) : 0;
+					color = map["color"];
+					if (color) {
+						point.color.setFrom(toColor(color, 0), toColor(color, 1), toColor(color, 2), toColor(color, 3));
 					}
-					timelines[timelines.length] = translateTimeline;
-					duration = Math.max(duration, translateTimeline.frames[(translateTimeline.frameCount - 1) * TranslateTimeline.ENTRIES]);
-				} else
-					throw new Error("Invalid timeline type for a bone: " + timelineName + " (" + boneName + ")");
+					return point;
 			}
-		}
 
-		var ikMap:Object = map["ik"];
-		for (var ikConstraintName:String in ikMap) {
-			var ikConstraint:IkConstraintData = skeletonData.findIkConstraint(ikConstraintName);
-			values = ikMap[ikConstraintName];
-			var ikTimeline:IkConstraintTimeline = new IkConstraintTimeline(values.length);
-			ikTimeline.ikConstraintIndex = skeletonData.ikConstraints.indexOf(ikConstraint);
-			frameIndex = 0;
-			for each (valueMap in values) {
-				var mix:Number = valueMap.hasOwnProperty("mix") ? valueMap["mix"] : 1;
-				var bendDirection:int = (!valueMap.hasOwnProperty("bendPositive") || valueMap["bendPositive"]) ? 1 : -1;
-				ikTimeline.setFrame(frameIndex, valueMap["time"], mix, bendDirection);
-				readCurve(valueMap, ikTimeline, frameIndex);
-				frameIndex++;
-			}
-			timelines[timelines.length] = ikTimeline;
-			duration = Math.max(duration, ikTimeline.frames[(ikTimeline.frameCount - 1) * IkConstraintTimeline.ENTRIES]);
+			return null;
 		}
-		
-		var transformMap:Object = map["transform"];
-		for (var transformName:String in transformMap) {
-			var transformConstraint:TransformConstraintData = skeletonData.findTransformConstraint(transformName);
-			values = transformMap[transformName];
-			var transformTimeline:TransformConstraintTimeline = new TransformConstraintTimeline(values.length);
-			transformTimeline.transformConstraintIndex = skeletonData.transformConstraints.indexOf(transformConstraint);
-			frameIndex = 0;
-			for each (valueMap in values) {
-				var rotateMix:Number = valueMap.hasOwnProperty("rotateMix") ? valueMap["rotateMix"] : 1;
-				var translateMix:Number = valueMap.hasOwnProperty("translateMix") ? valueMap["translateMix"] : 1;
-				var scaleMix:Number = valueMap.hasOwnProperty("scaleMix") ? valueMap["scaleMix"] : 1;
-				var shearMix:Number = valueMap.hasOwnProperty("shearMix") ? valueMap["shearMix"] : 1;
-				transformTimeline.setFrame(frameIndex, valueMap["time"], rotateMix, translateMix, scaleMix, shearMix);
-				readCurve(valueMap, transformTimeline, frameIndex);
-				frameIndex++;
-			}
-			timelines.push(transformTimeline);
-			duration = Math.max(duration, transformTimeline.frames[(transformTimeline.frameCount - 1) * TransformConstraintTimeline.ENTRIES]);
-		}
-				
-		// Path constraint timelines.
-		var paths:Object = map["paths"];
-		for (var pathName:String in paths) {
-			var index:int = skeletonData.findPathConstraintIndex(pathName);
-			if (index == -1) throw new Error("Path constraint not found: " + pathName);
-			var data:PathConstraintData = skeletonData.pathConstraints[index];
-			
-			var pathMap:Object = paths[pathName];
-			for (timelineName in pathMap) {
-				values = pathMap[timelineName];
-				
-				if (timelineName == "position" || timelineName == "spacing") {
-					var pathTimeline:PathConstraintPositionTimeline;
-					timelineScale = 1;
-					if (timelineName == "spacing") {
-						pathTimeline = new PathConstraintSpacingTimeline(values.length);
-						if (data.spacingMode == SpacingMode.length || data.spacingMode == SpacingMode.fixed) timelineScale = scale;
-					} else {
-						pathTimeline = new PathConstraintPositionTimeline(values.length);
-						if (data.positionMode == PositionMode.fixed) timelineScale = scale;
-					}
-					pathTimeline.pathConstraintIndex = index;
-					frameIndex = 0;
-					for each (valueMap in values) {
-						var value:Number = valueMap[timelineName] || 0;
-						pathTimeline.setFrame(frameIndex, valueMap["time"], value * timelineScale);
-						readCurve(valueMap, pathTimeline, frameIndex);
-						frameIndex++;
-					}
-					timelines.push(pathTimeline);
-					duration = Math.max(duration,
-						pathTimeline.frames[(pathTimeline.frameCount - 1) * PathConstraintPositionTimeline.ENTRIES]);
-				} else if (timelineName == "mix") {
-					var pathMixTimeline:PathConstraintMixTimeline = new PathConstraintMixTimeline(values.length);
-					pathMixTimeline.pathConstraintIndex = index;
-					frameIndex = 0;
-					for each (valueMap in values) {
-						rotateMix = valueMap.hasOwnProperty("rotateMix") ? valueMap["rotateMix"] : 1;
-						translateMix = valueMap.hasOwnProperty("translateMix") ? valueMap["translateMix"] : 1;
-						pathMixTimeline.setFrame(frameIndex, valueMap["time"], rotateMix, translateMix);
-						readCurve(valueMap, pathMixTimeline, frameIndex);
-						frameIndex++;
+
+		private function readVertices(map : Object, attachment : VertexAttachment, verticesLength : int) : void {
+			attachment.worldVerticesLength = verticesLength;
+			var vertices : Vector.<Number> = getFloatArray(map, "vertices", 1);
+			if (verticesLength == vertices.length) {
+				if (scale != 1) {
+					for (var i : int = 0, n : int = vertices.length; i < n; i++) {
+						vertices[i] *= scale;
 					}
-					timelines.push(pathMixTimeline);
-					duration = Math.max(duration,
-						pathMixTimeline.frames[(pathMixTimeline.frameCount - 1) * PathConstraintMixTimeline.ENTRIES]);
 				}
+				attachment.vertices = vertices;
+				return;
 			}
+
+			var weights : Vector.<Number> = new Vector.<Number>(verticesLength * 3 * 3);
+			weights.length = 0;
+			var bones : Vector.<int> = new Vector.<int>(verticesLength * 3);
+			bones.length = 0;
+			for (i = 0, n = vertices.length; i < n;) {
+				var boneCount : int = int(vertices[i++]);
+				bones.push(boneCount);
+				for (var nn : int = i + boneCount * 4; i < nn; i += 4) {
+					bones.push(int(vertices[i]));
+					weights.push(vertices[i + 1] * scale);
+					weights.push(vertices[i + 2] * scale);
+					weights.push(vertices[i + 3]);
+				}
+			}
+			attachment.bones = bones;
+			attachment.vertices = weights;
 		}
-		
-		var deformMap:Object = map["deform"];
-		for (var skinName:String in deformMap) {
-			var skin:Skin = skeletonData.findSkin(skinName);
-			slotMap = deformMap[skinName];
-			for (slotName in slotMap) {
+
+		private function readAnimation(map : Object, name : String, skeletonData : SkeletonData) : void {
+			var scale : Number = this.scale;
+			var timelines : Vector.<Timeline> = new Vector.<Timeline>();
+			var duration : Number = 0;
+
+			var slotMap : Object, slotIndex : int, slotName : String;
+			var values : Array, valueMap : Object, frameIndex : int;
+			var i : int;
+			var timelineName : String;
+
+			var slots : Object = map["slots"];
+			for (slotName in slots) {
+				slotMap = slots[slotName];
 				slotIndex = skeletonData.findSlotIndex(slotName);
-				var timelineMap:Object = slotMap[slotName];
-				for (timelineName in timelineMap) {
-					values = timelineMap[timelineName];
-
-					var attachment:VertexAttachment = skin.getAttachment(slotIndex, timelineName) as VertexAttachment;
-					if (attachment == null) throw new Error("Deform attachment not found: " + timelineName);
-					var weighted:Boolean = attachment.bones != null;
-					var vertices:Vector.<Number> = attachment.vertices;
-					var deformLength:int = weighted ? vertices.length / 3 * 2 : vertices.length;
-
-					var deformTimeline:DeformTimeline = new DeformTimeline(values.length);
-					deformTimeline.slotIndex = slotIndex;
-					deformTimeline.attachment = attachment;
-
-					frameIndex = 0;
-					for each (valueMap in values) {
-						var deform:Vector.<Number>;
-						var verticesValue:Object = valueMap["vertices"];
-						if (verticesValue == null)
-							deform = weighted ? new Vector.<Number>(deformLength, true) : vertices;
+
+				for (timelineName in slotMap) {
+					values = slotMap[timelineName];
+					if (timelineName == "attachment") {
+						var attachmentTimeline : AttachmentTimeline = new AttachmentTimeline(values.length);
+						attachmentTimeline.slotIndex = slotIndex;
+
+						frameIndex = 0;
+						for each (valueMap in values)
+							attachmentTimeline.setFrame(frameIndex++, valueMap["time"], valueMap["name"]);
+						timelines[timelines.length] = attachmentTimeline;
+						duration = Math.max(duration, attachmentTimeline.frames[attachmentTimeline.frameCount - 1]);
+					} else if (timelineName == "color") {
+						var colorTimeline : ColorTimeline = new ColorTimeline(values.length);
+						colorTimeline.slotIndex = slotIndex;
+
+						frameIndex = 0;
+						for each (valueMap in values) {
+							var color : String = valueMap["color"];
+							var r : Number = toColor(color, 0);
+							var g : Number = toColor(color, 1);
+							var b : Number = toColor(color, 2);
+							var a : Number = toColor(color, 3);
+							colorTimeline.setFrame(frameIndex, valueMap["time"], r, g, b, a);
+							readCurve(valueMap, colorTimeline, frameIndex);
+							frameIndex++;
+						}
+						timelines[timelines.length] = colorTimeline;
+						duration = Math.max(duration, colorTimeline.frames[(colorTimeline.frameCount - 1) * ColorTimeline.ENTRIES]);
+					} else if (timelineName == "twoColor") {
+						var twoColorTimeline : TwoColorTimeline = new TwoColorTimeline(values.length);
+						twoColorTimeline.slotIndex = slotIndex;
+
+						frameIndex = 0;
+						for each (valueMap in values) {
+							color = valueMap["color"];
+							var darkColor : String = valueMap["dark"];
+							var light : Color = new Color(0, 0, 0, 0);
+							var dark : Color = new Color(0, 0, 0, 0);
+							light.setFrom(toColor(color, 0), toColor(color, 1), toColor(color, 2), toColor(color, 3));
+							dark.setFrom(toColor(darkColor, 0), toColor(darkColor, 1), toColor(darkColor, 2), toColor(darkColor, 3));
+							twoColorTimeline.setFrame(frameIndex, valueMap["time"], light.r, light.g, light.b, light.a, dark.r, dark.g, dark.b);
+							readCurve(valueMap, twoColorTimeline, frameIndex);
+							frameIndex++;
+						}
+						timelines[timelines.length] = twoColorTimeline;
+						duration = Math.max(duration, twoColorTimeline.frames[(twoColorTimeline.frameCount - 1) * TwoColorTimeline.ENTRIES]);
+					} else
+						throw new Error("Invalid timeline type for a slot: " + timelineName + " (" + slotName + ")");
+				}
+			}
+
+			var bones : Object = map["bones"];
+			for (var boneName : String in bones) {
+				var boneIndex : int = skeletonData.findBoneIndex(boneName);
+				if (boneIndex == -1) throw new Error("Bone not found: " + boneName);
+				var boneMap : Object = bones[boneName];
+
+				for (timelineName in boneMap) {
+					values = boneMap[timelineName];
+					if (timelineName == "rotate") {
+						var rotateTimeline : RotateTimeline = new RotateTimeline(values.length);
+						rotateTimeline.boneIndex = boneIndex;
+
+						frameIndex = 0;
+						for each (valueMap in values) {
+							rotateTimeline.setFrame(frameIndex, valueMap["time"], valueMap["angle"]);
+							readCurve(valueMap, rotateTimeline, frameIndex);
+							frameIndex++;
+						}
+						timelines[timelines.length] = rotateTimeline;
+						duration = Math.max(duration, rotateTimeline.frames[(rotateTimeline.frameCount - 1) * RotateTimeline.ENTRIES]);
+					} else if (timelineName == "translate" || timelineName == "scale" || timelineName == "shear") {
+						var translateTimeline : TranslateTimeline;
+						var timelineScale : Number = 1;
+						if (timelineName == "scale")
+							translateTimeline = new ScaleTimeline(values.length);
+						else if (timelineName == "shear")
+							translateTimeline = new ShearTimeline(values.length);
 						else {
-							deform = new Vector.<Number>(deformLength, true);
-							var start:int = Number(valueMap["offset"] || 0);
-							var temp:Vector.<Number> = getFloatArray(valueMap, "vertices", 1);
-							for (i = 0; i < temp.length; i++) {
-								deform[start + i] = temp[i];
-							}							
-							if (scale != 1) {
-								var n:int;
-								for (i = start, n = i + temp.length; i < n; i++)
-									deform[i] *= scale;
-							}
-							if (!weighted) {
-								for (i = 0; i < deformLength; i++)
-									deform[i] += vertices[i];
-							}
+							translateTimeline = new TranslateTimeline(values.length);
+							timelineScale = scale;
+						}
+						translateTimeline.boneIndex = boneIndex;
+
+						frameIndex = 0;
+						for each (valueMap in values) {
+							var x : Number = Number(valueMap["x"] || 0) * timelineScale;
+							var y : Number = Number(valueMap["y"] || 0) * timelineScale;
+							translateTimeline.setFrame(frameIndex, valueMap["time"], x, y);
+							readCurve(valueMap, translateTimeline, frameIndex);
+							frameIndex++;
+						}
+						timelines[timelines.length] = translateTimeline;
+						duration = Math.max(duration, translateTimeline.frames[(translateTimeline.frameCount - 1) * TranslateTimeline.ENTRIES]);
+					} else
+						throw new Error("Invalid timeline type for a bone: " + timelineName + " (" + boneName + ")");
+				}
+			}
+
+			var ikMap : Object = map["ik"];
+			for (var ikConstraintName : String in ikMap) {
+				var ikConstraint : IkConstraintData = skeletonData.findIkConstraint(ikConstraintName);
+				values = ikMap[ikConstraintName];
+				var ikTimeline : IkConstraintTimeline = new IkConstraintTimeline(values.length);
+				ikTimeline.ikConstraintIndex = skeletonData.ikConstraints.indexOf(ikConstraint);
+				frameIndex = 0;
+				for each (valueMap in values) {
+					var mix : Number = valueMap.hasOwnProperty("mix") ? valueMap["mix"] : 1;
+					var bendDirection : int = (!valueMap.hasOwnProperty("bendPositive") || valueMap["bendPositive"]) ? 1 : -1;
+					ikTimeline.setFrame(frameIndex, valueMap["time"], mix, bendDirection);
+					readCurve(valueMap, ikTimeline, frameIndex);
+					frameIndex++;
+				}
+				timelines[timelines.length] = ikTimeline;
+				duration = Math.max(duration, ikTimeline.frames[(ikTimeline.frameCount - 1) * IkConstraintTimeline.ENTRIES]);
+			}
+
+			var transformMap : Object = map["transform"];
+			for (var transformName : String in transformMap) {
+				var transformConstraint : TransformConstraintData = skeletonData.findTransformConstraint(transformName);
+				values = transformMap[transformName];
+				var transformTimeline : TransformConstraintTimeline = new TransformConstraintTimeline(values.length);
+				transformTimeline.transformConstraintIndex = skeletonData.transformConstraints.indexOf(transformConstraint);
+				frameIndex = 0;
+				for each (valueMap in values) {
+					var rotateMix : Number = valueMap.hasOwnProperty("rotateMix") ? valueMap["rotateMix"] : 1;
+					var translateMix : Number = valueMap.hasOwnProperty("translateMix") ? valueMap["translateMix"] : 1;
+					var scaleMix : Number = valueMap.hasOwnProperty("scaleMix") ? valueMap["scaleMix"] : 1;
+					var shearMix : Number = valueMap.hasOwnProperty("shearMix") ? valueMap["shearMix"] : 1;
+					transformTimeline.setFrame(frameIndex, valueMap["time"], rotateMix, translateMix, scaleMix, shearMix);
+					readCurve(valueMap, transformTimeline, frameIndex);
+					frameIndex++;
+				}
+				timelines.push(transformTimeline);
+				duration = Math.max(duration, transformTimeline.frames[(transformTimeline.frameCount - 1) * TransformConstraintTimeline.ENTRIES]);
+			}
+
+			// Path constraint timelines.
+			var paths : Object = map["paths"];
+			for (var pathName : String in paths) {
+				var index : int = skeletonData.findPathConstraintIndex(pathName);
+				if (index == -1) throw new Error("Path constraint not found: " + pathName);
+				var data : PathConstraintData = skeletonData.pathConstraints[index];
+
+				var pathMap : Object = paths[pathName];
+				for (timelineName in pathMap) {
+					values = pathMap[timelineName];
+
+					if (timelineName == "position" || timelineName == "spacing") {
+						var pathTimeline : PathConstraintPositionTimeline;
+						timelineScale = 1;
+						if (timelineName == "spacing") {
+							pathTimeline = new PathConstraintSpacingTimeline(values.length);
+							if (data.spacingMode == SpacingMode.length || data.spacingMode == SpacingMode.fixed) timelineScale = scale;
+						} else {
+							pathTimeline = new PathConstraintPositionTimeline(values.length);
+							if (data.positionMode == PositionMode.fixed) timelineScale = scale;
 						}
+						pathTimeline.pathConstraintIndex = index;
+						frameIndex = 0;
+						for each (valueMap in values) {
+							var value : Number = valueMap[timelineName] || 0;
+							pathTimeline.setFrame(frameIndex, valueMap["time"], value * timelineScale);
+							readCurve(valueMap, pathTimeline, frameIndex);
+							frameIndex++;
+						}
+						timelines.push(pathTimeline);
+						duration = Math.max(duration, pathTimeline.frames[(pathTimeline.frameCount - 1) * PathConstraintPositionTimeline.ENTRIES]);
+					} else if (timelineName == "mix") {
+						var pathMixTimeline : PathConstraintMixTimeline = new PathConstraintMixTimeline(values.length);
+						pathMixTimeline.pathConstraintIndex = index;
+						frameIndex = 0;
+						for each (valueMap in values) {
+							rotateMix = valueMap.hasOwnProperty("rotateMix") ? valueMap["rotateMix"] : 1;
+							translateMix = valueMap.hasOwnProperty("translateMix") ? valueMap["translateMix"] : 1;
+							pathMixTimeline.setFrame(frameIndex, valueMap["time"], rotateMix, translateMix);
+							readCurve(valueMap, pathMixTimeline, frameIndex);
+							frameIndex++;
+						}
+						timelines.push(pathMixTimeline);
+						duration = Math.max(duration, pathMixTimeline.frames[(pathMixTimeline.frameCount - 1) * PathConstraintMixTimeline.ENTRIES]);
+					}
+				}
+			}
+
+			var deformMap : Object = map["deform"];
+			for (var skinName : String in deformMap) {
+				var skin : Skin = skeletonData.findSkin(skinName);
+				slotMap = deformMap[skinName];
+				for (slotName in slotMap) {
+					slotIndex = skeletonData.findSlotIndex(slotName);
+					var timelineMap : Object = slotMap[slotName];
+					for (timelineName in timelineMap) {
+						values = timelineMap[timelineName];
+
+						var attachment : VertexAttachment = skin.getAttachment(slotIndex, timelineName) as VertexAttachment;
+						if (attachment == null) throw new Error("Deform attachment not found: " + timelineName);
+						var weighted : Boolean = attachment.bones != null;
+						var vertices : Vector.<Number> = attachment.vertices;
+						var deformLength : int = weighted ? vertices.length / 3 * 2 : vertices.length;
+
+						var deformTimeline : DeformTimeline = new DeformTimeline(values.length);
+						deformTimeline.slotIndex = slotIndex;
+						deformTimeline.attachment = attachment;
+
+						frameIndex = 0;
+						for each (valueMap in values) {
+							var deform : Vector.<Number>;
+							var verticesValue : Object = valueMap["vertices"];
+							if (verticesValue == null)
+								deform = weighted ? new Vector.<Number>(deformLength, true) : vertices;
+							else {
+								deform = new Vector.<Number>(deformLength, true);
+								var start : int = Number(valueMap["offset"] || 0);
+								var temp : Vector.<Number> = getFloatArray(valueMap, "vertices", 1);
+								for (i = 0; i < temp.length; i++) {
+									deform[start + i] = temp[i];
+								}
+								if (scale != 1) {
+									var n : int;
+									for (i = start, n = i + temp.length; i < n; i++)
+										deform[i] *= scale;
+								}
+								if (!weighted) {
+									for (i = 0; i < deformLength; i++)
+										deform[i] += vertices[i];
+								}
+							}
 
-						deformTimeline.setFrame(frameIndex, valueMap["time"], deform);
-						readCurve(valueMap, deformTimeline, frameIndex);
-						frameIndex++;
+							deformTimeline.setFrame(frameIndex, valueMap["time"], deform);
+							readCurve(valueMap, deformTimeline, frameIndex);
+							frameIndex++;
+						}
+						timelines[timelines.length] = deformTimeline;
+						duration = Math.max(duration, deformTimeline.frames[deformTimeline.frameCount - 1]);
 					}
-					timelines[timelines.length] = deformTimeline;
-					duration = Math.max(duration, deformTimeline.frames[deformTimeline.frameCount - 1]);
 				}
 			}
-		}
 
-		var drawOrderValues:Array = map["drawOrder"];
-		if (!drawOrderValues) drawOrderValues = map["draworder"];
-		if (drawOrderValues) {
-			var drawOrderTimeline:DrawOrderTimeline = new DrawOrderTimeline(drawOrderValues.length);
-			var slotCount:int = skeletonData.slots.length;
-			frameIndex = 0;
-			for each (var drawOrderMap:Object in drawOrderValues) {
-				var drawOrder:Vector.<int> = null;
-				if (drawOrderMap["offsets"]) {
-					drawOrder = new Vector.<int>(slotCount);
-					for (i = slotCount - 1; i >= 0; i--)
-						drawOrder[i] = -1;
-					var offsets:Array = drawOrderMap["offsets"];
-					var unchanged:Vector.<int> = new Vector.<int>(slotCount - offsets.length);
-					var originalIndex:int = 0, unchangedIndex:int = 0;
-					for each (var offsetMap:Object in offsets) {
-						slotIndex = skeletonData.findSlotIndex(offsetMap["slot"]);
-						if (slotIndex == -1) throw new Error("Slot not found: " + offsetMap["slot"]);
-						// Collect unchanged items.
-						while (originalIndex != slotIndex)
+			var drawOrderValues : Array = map["drawOrder"];
+			if (!drawOrderValues) drawOrderValues = map["draworder"];
+			if (drawOrderValues) {
+				var drawOrderTimeline : DrawOrderTimeline = new DrawOrderTimeline(drawOrderValues.length);
+				var slotCount : int = skeletonData.slots.length;
+				frameIndex = 0;
+				for each (var drawOrderMap : Object in drawOrderValues) {
+					var drawOrder : Vector.<int> = null;
+					if (drawOrderMap["offsets"]) {
+						drawOrder = new Vector.<int>(slotCount);
+						for (i = slotCount - 1; i >= 0; i--)
+							drawOrder[i] = -1;
+						var offsets : Array = drawOrderMap["offsets"];
+						var unchanged : Vector.<int> = new Vector.<int>(slotCount - offsets.length);
+						var originalIndex : int = 0, unchangedIndex : int = 0;
+						for each (var offsetMap : Object in offsets) {
+							slotIndex = skeletonData.findSlotIndex(offsetMap["slot"]);
+							if (slotIndex == -1) throw new Error("Slot not found: " + offsetMap["slot"]);
+							// Collect unchanged items.
+							while (originalIndex != slotIndex)
+								unchanged[unchangedIndex++] = originalIndex++;
+							// Set changed items.
+							drawOrder[originalIndex + offsetMap["offset"]] = originalIndex++;
+						}
+						// Collect remaining unchanged items.
+						while (originalIndex < slotCount)
 							unchanged[unchangedIndex++] = originalIndex++;
-						// Set changed items.
-						drawOrder[originalIndex + offsetMap["offset"]] = originalIndex++;
+						// Fill in unchanged items.
+						for (i = slotCount - 1; i >= 0; i--)
+							if (drawOrder[i] == -1) drawOrder[i] = unchanged[--unchangedIndex];
 					}
-					// Collect remaining unchanged items.
-					while (originalIndex < slotCount)
-						unchanged[unchangedIndex++] = originalIndex++;
-					// Fill in unchanged items.
-					for (i = slotCount - 1; i >= 0; i--)
-						if (drawOrder[i] == -1) drawOrder[i] = unchanged[--unchangedIndex];
+					drawOrderTimeline.setFrame(frameIndex++, drawOrderMap["time"], drawOrder);
 				}
-				drawOrderTimeline.setFrame(frameIndex++, drawOrderMap["time"], drawOrder);
+				timelines[timelines.length] = drawOrderTimeline;
+				duration = Math.max(duration, drawOrderTimeline.frames[drawOrderTimeline.frameCount - 1]);
 			}
-			timelines[timelines.length] = drawOrderTimeline;
-			duration = Math.max(duration, drawOrderTimeline.frames[drawOrderTimeline.frameCount - 1]);
-		}
 
-		var eventsMap:Array = map["events"];
-		if (eventsMap) {
-			var eventTimeline:EventTimeline = new EventTimeline(eventsMap.length);
-			frameIndex = 0;
-			for each (var eventMap:Object in eventsMap) {
-				var eventData:EventData = skeletonData.findEvent(eventMap["name"]);
-				if (!eventData) throw new Error("Event not found: " + eventMap["name"]);
-				var event:Event = new Event(eventMap["time"], eventData);
-				event.intValue = eventMap.hasOwnProperty("int") ? eventMap["int"] : eventData.intValue;
-				event.floatValue = eventMap.hasOwnProperty("float") ? eventMap["float"] : eventData.floatValue;
-				event.stringValue = eventMap.hasOwnProperty("string") ? eventMap["string"] : eventData.stringValue;
-				eventTimeline.setFrame(frameIndex++, event);
+			var eventsMap : Array = map["events"];
+			if (eventsMap) {
+				var eventTimeline : EventTimeline = new EventTimeline(eventsMap.length);
+				frameIndex = 0;
+				for each (var eventMap : Object in eventsMap) {
+					var eventData : EventData = skeletonData.findEvent(eventMap["name"]);
+					if (!eventData) throw new Error("Event not found: " + eventMap["name"]);
+					var event : Event = new Event(eventMap["time"], eventData);
+					event.intValue = eventMap.hasOwnProperty("int") ? eventMap["int"] : eventData.intValue;
+					event.floatValue = eventMap.hasOwnProperty("float") ? eventMap["float"] : eventData.floatValue;
+					event.stringValue = eventMap.hasOwnProperty("string") ? eventMap["string"] : eventData.stringValue;
+					eventTimeline.setFrame(frameIndex++, event);
+				}
+				timelines[timelines.length] = eventTimeline;
+				duration = Math.max(duration, eventTimeline.frames[eventTimeline.frameCount - 1]);
 			}
-			timelines[timelines.length] = eventTimeline;
-			duration = Math.max(duration, eventTimeline.frames[eventTimeline.frameCount - 1]);
-		}
 
-		skeletonData.animations[skeletonData.animations.length] = new Animation(name, timelines, duration);
-	}
+			skeletonData.animations[skeletonData.animations.length] = new Animation(name, timelines, duration);
+		}
 
-	static private function readCurve (map:Object, timeline:CurveTimeline, frameIndex:int) : void {
-		var curve:Object = map["curve"];
-		if (!curve) return;
-		if (curve == "stepped")
-			timeline.setStepped(frameIndex);
-		else if (curve is Array)
-			timeline.setCurve(frameIndex, curve[0], curve[1], curve[2], curve[3]);
-	}
+		static private function readCurve(map : Object, timeline : CurveTimeline, frameIndex : int) : void {
+			var curve : Object = map["curve"];
+			if (!curve) return;
+			if (curve == "stepped")
+				timeline.setStepped(frameIndex);
+			else if (curve is Array)
+				timeline.setCurve(frameIndex, curve[0], curve[1], curve[2], curve[3]);
+		}
 
-	static private function toColor (hexString:String, colorIndex:int) : Number {
-		if (hexString.length != 8) throw new ArgumentError("Color hexidecimal length must be 8, received: " + hexString);
-		return parseInt(hexString.substring(colorIndex * 2, colorIndex * 2 + 2), 16) / 255;
-	}
+		static private function toColor(hexString : String, colorIndex : int) : Number {
+			if (hexString.length != 8) throw new ArgumentError("Color hexidecimal length must be 8, received: " + hexString);
+			return parseInt(hexString.substring(colorIndex * 2, colorIndex * 2 + 2), 16) / 255;
+		}
 
-	static private function getFloatArray (map:Object, name:String, scale:Number) : Vector.<Number> {
-		var list:Array = map[name];
-		var values:Vector.<Number> = new Vector.<Number>(list.length, true);
-		var i:int = 0, n:int = list.length;
-		if (scale == 1) {
-			for (; i < n; i++)
-				values[i] = list[i];
-		} else {
-			for (; i < n; i++)
-				values[i] = list[i] * scale;
+		static private function getFloatArray(map : Object, name : String, scale : Number) : Vector.<Number> {
+			var list : Array = map[name];
+			var values : Vector.<Number> = new Vector.<Number>(list.length, true);
+			var i : int = 0, n : int = list.length;
+			if (scale == 1) {
+				for (; i < n; i++)
+					values[i] = list[i];
+			} else {
+				for (; i < n; i++)
+					values[i] = list[i] * scale;
+			}
+			return values;
 		}
-		return values;
-	}
 
-	static private function getIntArray (map:Object, name:String) : Vector.<int> {
-		var list:Array = map[name];
-		var values:Vector.<int> = new Vector.<int>(list.length, true);
-		for (var i:int = 0, n:int = list.length; i < n; i++)
-			values[i] = int(list[i]);
-		return values;
-	}
+		static private function getIntArray(map : Object, name : String) : Vector.<int> {
+			var list : Array = map[name];
+			var values : Vector.<int> = new Vector.<int>(list.length, true);
+			for (var i : int = 0, n : int = list.length; i < n; i++)
+				values[i] = int(list[i]);
+			return values;
+		}
 
-	static private function getUintArray (map:Object, name:String) : Vector.<uint> {
-		var list:Array = map[name];
-		var values:Vector.<uint> = new Vector.<uint>(list.length, true);
-		for (var i:int = 0, n:int = list.length; i < n; i++)
-			values[i] = int(list[i]);
-		return values;
+		static private function getUintArray(map : Object, name : String) : Vector.<uint> {
+			var list : Array = map[name];
+			var values : Vector.<uint> = new Vector.<uint>(list.length, true);
+			for (var i : int = 0, n : int = list.length; i < n; i++)
+				values[i] = int(list[i]);
+			return values;
+		}
 	}
 }
 
-}
-
 import spine.attachments.MeshAttachment;
 
+
 class LinkedMesh {
-	internal var parent:String, skin:String;
-	internal var slotIndex:int;
-	internal var mesh:MeshAttachment;
+	internal var parent : String, skin : String;
+	internal var slotIndex : int;
+	internal var mesh : MeshAttachment;
 
-	public function LinkedMesh (mesh:MeshAttachment, skin:String, slotIndex:int, parent:String) {
+	public function LinkedMesh(mesh : MeshAttachment, skin : String, slotIndex : int, parent : String) {
 		this.mesh = mesh;
 		this.skin = skin;
 		this.slotIndex = slotIndex;
 		this.parent = parent;
 	}
-}
+}

spine-as3/spine-as3/src/spine/Skin.as

@@ -29,65 +29,64 @@
  *****************************************************************************/
 
 package spine {
-import flash.utils.Dictionary;
+	import flash.utils.Dictionary;
 
-import spine.attachments.Attachment;
+	import spine.attachments.Attachment;
 
-/** Stores attachments by slot index and attachment name. */
-public class Skin {
-	internal var _name:String;
-	private var _attachments:Vector.<Dictionary> = new Vector.<Dictionary>();
+	/** Stores attachments by slot index and attachment name. */
+	public class Skin {
+		internal var _name : String;
+		private var _attachments : Vector.<Dictionary> = new Vector.<Dictionary>();
 
-	public function Skin (name:String) {
-		if (name == null) throw new ArgumentError("name cannot be null.");
-		_name = name;
-	}
+		public function Skin(name : String) {
+			if (name == null) throw new ArgumentError("name cannot be null.");
+			_name = name;
+		}
 
-	public function addAttachment (slotIndex:int, name:String, attachment:Attachment) : void {
-		if (attachment == null) throw new ArgumentError("attachment cannot be null.");
-		if (slotIndex >= attachments.length) attachments.length = slotIndex + 1;
-		if (!attachments[slotIndex]) attachments[slotIndex] = new Dictionary();
-		attachments[slotIndex][name] = attachment;
-	}
+		public function addAttachment(slotIndex : int, name : String, attachment : Attachment) : void {
+			if (attachment == null) throw new ArgumentError("attachment cannot be null.");
+			if (slotIndex >= attachments.length) attachments.length = slotIndex + 1;
+			if (!attachments[slotIndex]) attachments[slotIndex] = new Dictionary();
+			attachments[slotIndex][name] = attachment;
+		}
 
-	/** @return May be null. */
-	public function getAttachment (slotIndex:int, name:String) : Attachment {
-		if (slotIndex >= attachments.length) return null;
-		var dictionary:Dictionary = attachments[slotIndex];
-		return dictionary ? dictionary[name] : null;
-	}
+		/** @return May be null. */
+		public function getAttachment(slotIndex : int, name : String) : Attachment {
+			if (slotIndex >= attachments.length) return null;
+			var dictionary : Dictionary = attachments[slotIndex];
+			return dictionary ? dictionary[name] : null;
+		}
 
-	public function get attachments () : Vector.<Dictionary> {
-		return _attachments;
-	}
+		public function get attachments() : Vector.<Dictionary> {
+			return _attachments;
+		}
 
-	public function get name () : String {
-		return _name;
-	}
+		public function get name() : String {
+			return _name;
+		}
 
-	public function toString () : String {
-		return _name;
-	}
+		public function toString() : String {
+			return _name;
+		}
 
-	/** Attach each attachment in this skin if the corresponding attachment in the old skin is currently attached. */
-	public function attachAll (skeleton:Skeleton, oldSkin:Skin) : void {
-		var slotIndex:int = 0;
-		for each (var slot:Slot in skeleton.slots) {
-			var slotAttachment:Attachment = slot.attachment;
-			if (slotAttachment && slotIndex < oldSkin.attachments.length) {
-				var dictionary:Dictionary = oldSkin.attachments[slotIndex];
-				for (var name:String in dictionary) {
-					var skinAttachment:Attachment = dictionary[name];
-					if (slotAttachment == skinAttachment) {
-						var attachment:Attachment = getAttachment(slotIndex, name);
-						if (attachment != null) slot.attachment = attachment;
-						break;
+		/** Attach each attachment in this skin if the corresponding attachment in the old skin is currently attached. */
+		public function attachAll(skeleton : Skeleton, oldSkin : Skin) : void {
+			var slotIndex : int = 0;
+			for each (var slot : Slot in skeleton.slots) {
+				var slotAttachment : Attachment = slot.attachment;
+				if (slotAttachment && slotIndex < oldSkin.attachments.length) {
+					var dictionary : Dictionary = oldSkin.attachments[slotIndex];
+					for (var name : String in dictionary) {
+						var skinAttachment : Attachment = dictionary[name];
+						if (slotAttachment == skinAttachment) {
+							var attachment : Attachment = getAttachment(slotIndex, name);
+							if (attachment != null) slot.attachment = attachment;
+							break;
+						}
 					}
 				}
+				slotIndex++;
 			}
-			slotIndex++;
 		}
 	}
-}
-
-}
+}

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

@@ -29,76 +29,75 @@
  *****************************************************************************/
 
 package spine {
-import spine.attachments.Attachment;
+	import spine.attachments.Attachment;
 
-public class Slot {
-	internal var _data:SlotData;
-	internal var _bone:Bone;
-	public var color:Color;
-	public var darkColor:Color;
-	internal var _attachment:Attachment;
-	private var _attachmentTime:Number;
-	public var attachmentVertices:Vector.<Number> = new Vector.<Number>();
+	public class Slot {
+		internal var _data : SlotData;
+		internal var _bone : Bone;
+		public var color : Color;
+		public var darkColor : Color;
+		internal var _attachment : Attachment;
+		private var _attachmentTime : Number;
+		public var attachmentVertices : Vector.<Number> = new Vector.<Number>();
 
-	public function Slot (data:SlotData, bone:Bone) {
-		if (data == null) throw new ArgumentError("data cannot be null.");
-		if (bone == null) throw new ArgumentError("bone cannot be null.");
-		_data = data;
-		_bone = bone;
-		this.color = new Color(1, 1, 1, 1);
-		this.darkColor = data.darkColor == null ? null : new Color(1, 1, 1, 1);
-		setToSetupPose();
-	}
+		public function Slot(data : SlotData, bone : Bone) {
+			if (data == null) throw new ArgumentError("data cannot be null.");
+			if (bone == null) throw new ArgumentError("bone cannot be null.");
+			_data = data;
+			_bone = bone;
+			this.color = new Color(1, 1, 1, 1);
+			this.darkColor = data.darkColor == null ? null : new Color(1, 1, 1, 1);
+			setToSetupPose();
+		}
 
-	public function get data () : SlotData {
-		return _data;
-	}
-	
-	public function get bone () : Bone {
-		return _bone;
-	}
-	
-	public function get skeleton () : Skeleton {
-		return _bone._skeleton;
-	}
+		public function get data() : SlotData {
+			return _data;
+		}
 
-	/** @return May be null. */
-	public function get attachment () : Attachment {
-		return _attachment;
-	}
+		public function get bone() : Bone {
+			return _bone;
+		}
 
-	/** Sets the attachment and resets {@link #getAttachmentTime()}.
-	 * @param attachment May be null. */
-	public function set attachment (attachment:Attachment) : void {
-		if (_attachment == attachment) return;
-		_attachment = attachment;
-		_attachmentTime = _bone._skeleton.time;
-		attachmentVertices.length = 0;
-	}
+		public function get skeleton() : Skeleton {
+			return _bone._skeleton;
+		}
 
-	public function set attachmentTime (time:Number) : void {
-		_attachmentTime = _bone._skeleton.time - time;
-	}
+		/** @return May be null. */
+		public function get attachment() : Attachment {
+			return _attachment;
+		}
 
-	/** Returns the time since the attachment was set. */
-	public function get attachmentTime () : Number {
-		return _bone._skeleton.time - _attachmentTime;
-	}
+		/** Sets the attachment and resets {@link #getAttachmentTime()}.
+		 * @param attachment May be null. */
+		public function set attachment(attachment : Attachment) : void {
+			if (_attachment == attachment) return;
+			_attachment = attachment;
+			_attachmentTime = _bone._skeleton.time;
+			attachmentVertices.length = 0;
+		}
 
-	public function setToSetupPose () : void {		
-		color.setFromColor(data.color);
-		if (darkColor != null) darkColor.setFromColor(this.data.darkColor);
-		if (_data.attachmentName == null)
-			attachment = null;
-		else {
-			_attachment = null;
-			attachment = _bone._skeleton.getAttachmentForSlotIndex(data.index, data.attachmentName);
+		public function set attachmentTime(time : Number) : void {
+			_attachmentTime = _bone._skeleton.time - time;
 		}
-	}
 
-	public function toString () : String {
-		return _data.name;
-	}
-}
+		/** Returns the time since the attachment was set. */
+		public function get attachmentTime() : Number {
+			return _bone._skeleton.time - _attachmentTime;
+		}
+
+		public function setToSetupPose() : void {
+			color.setFromColor(data.color);
+			if (darkColor != null) darkColor.setFromColor(this.data.darkColor);
+			if (_data.attachmentName == null)
+				attachment = null;
+			else {
+				_attachment = null;
+				attachment = _bone._skeleton.getAttachmentForSlotIndex(data.index, data.attachmentName);
+			}
+		}
 
-}
+		public function toString() : String {
+			return _data.name;
+		}
+	}
+}

spine-as3/spine-as3/src/spine/SlotData.as

@@ -29,40 +29,38 @@
  *****************************************************************************/
 
 package spine {
+	public class SlotData {
+		internal var _index : int;
+		internal var _name : String;
+		internal var _boneData : BoneData;
+		public var color : Color = new Color(1, 1, 1, 1);
+		public var darkColor : Color;
+		public var attachmentName : String;
+		public var blendMode : BlendMode;
 
-public class SlotData {
-	internal var _index:int;
-	internal var _name:String;
-	internal var _boneData:BoneData;
-	public var color: Color = new Color(1, 1, 1, 1);
-	public var darkColor: Color;	
-	public var attachmentName:String;
-	public var blendMode:BlendMode;
+		public function SlotData(index : int, name : String, boneData : BoneData) {
+			if (index < 0) throw new ArgumentError("index must be >= 0.");
+			if (name == null) throw new ArgumentError("name cannot be null.");
+			if (boneData == null) throw new ArgumentError("boneData cannot be null.");
+			_index = index;
+			_name = name;
+			_boneData = boneData;
+		}
 
-	public function SlotData (index:int, name:String, boneData:BoneData) {
-		if (index < 0) throw new ArgumentError("index must be >= 0.");
-		if (name == null) throw new ArgumentError("name cannot be null.");
-		if (boneData == null) throw new ArgumentError("boneData cannot be null.");
-		_index = index;
-		_name = name;
-		_boneData = boneData;
-	}
-	
-	public function get index () : int {
-		return _index;
-	}
+		public function get index() : int {
+			return _index;
+		}
 
-	public function get name () : String {
-		return _name;
-	}
+		public function get name() : String {
+			return _name;
+		}
 
-	public function get boneData () : BoneData {
-		return _boneData;
-	}
+		public function get boneData() : BoneData {
+			return _boneData;
+		}
 
-	public function toString () : String {
-		return _name;
+		public function toString() : String {
+			return _name;
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/SpacingMode.as

@@ -29,11 +29,9 @@
  *****************************************************************************/
 
 package spine {
-
-public class SpacingMode {
-	public static const length:SpacingMode = new SpacingMode();
-	public static const fixed:SpacingMode = new SpacingMode();
-	public static const percent:SpacingMode = new SpacingMode();
-}
-
-}
+	public class SpacingMode {
+		public static const length : SpacingMode = new SpacingMode();
+		public static const fixed : SpacingMode = new SpacingMode();
+		public static const percent : SpacingMode = new SpacingMode();
+	}
+}

spine-as3/spine-as3/src/spine/TransformConstraint.as

@@ -29,268 +29,266 @@
  *****************************************************************************/
 
 package spine {
+	public class TransformConstraint implements Constraint {
+		internal var _data : TransformConstraintData;
+		internal var _bones : Vector.<Bone>;
+		public var target : Bone;
+		public var rotateMix : Number;
+		public var translateMix : Number;
+		public var scaleMix : Number;
+		public var shearMix : Number;
+		internal var _temp : Vector.<Number> = new Vector.<Number>(2);
 
-public class TransformConstraint implements Constraint {
-	internal var _data:TransformConstraintData;
-	internal var _bones:Vector.<Bone>;
-	public var target:Bone;
-	public var rotateMix:Number;	
-	public var translateMix:Number;
-	public var scaleMix:Number;
-	public var shearMix:Number;
-	internal var _temp:Vector.<Number> = new Vector.<Number>(2);
-
-	public function TransformConstraint (data:TransformConstraintData, skeleton:Skeleton) {
-		if (data == null) throw new ArgumentError("data cannot be null.");
-		if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
-		_data = data;
-		rotateMix = data.rotateMix;
-		translateMix = data.translateMix;
-		scaleMix = data.scaleMix;
-		shearMix = data.shearMix;
-		_bones = new Vector.<Bone>();		
-		for each (var boneData:BoneData in data.bones)
-			_bones.push(skeleton.findBone(boneData.name));		
-		target = skeleton.findBone(data.target._name);
-	}		
-
-	public function apply () : void {
-		update();
-	}
-	
-	public function update () : void {
-		if (data.local) {
-			if (data.relative)
-				applyRelativeLocal();
-			else
-				applyAbsoluteLocal();
-
-		} else {
-			if (data.relative)
-				applyRelativeWorld();
-			else
-				applyAbsoluteWorld();
+		public function TransformConstraint(data : TransformConstraintData, skeleton : Skeleton) {
+			if (data == null) throw new ArgumentError("data cannot be null.");
+			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
+			_data = data;
+			rotateMix = data.rotateMix;
+			translateMix = data.translateMix;
+			scaleMix = data.scaleMix;
+			shearMix = data.shearMix;
+			_bones = new Vector.<Bone>();
+			for each (var boneData : BoneData in data.bones)
+				_bones.push(skeleton.findBone(boneData.name));
+			target = skeleton.findBone(data.target._name);
 		}
-	}
 
-	internal function applyAbsoluteWorld () : void {
-		var rotateMix:Number = this.rotateMix, translateMix:Number = this.translateMix, scaleMix:Number = this.scaleMix, shearMix:Number = this.shearMix;
-		var target:Bone = this.target;
-		var ta:Number = target.a, tb:Number = target.b, tc:Number = target.c, td:Number = target.d;
-		var degRadReflect:Number = ta * td - tb * tc > 0 ? MathUtils.degRad : -MathUtils.degRad;
-		var offsetRotation:Number = data.offsetRotation * degRadReflect;
-		var offsetShearY:Number = data.offsetShearY * degRadReflect;
-		var bones:Vector.<Bone> = this._bones;
-		for (var i:int = 0, n:int = bones.length; i < n; i++) {
-			var bone:Bone = bones[i];
-			var modified:Boolean = false;
-
-			if (rotateMix != 0) {
-				var a:Number = bone.a, b:Number = bone.b, c:Number = bone.c, d:Number = bone.d;
-				var r:Number = Math.atan2(tc, ta) - Math.atan2(c, a) + offsetRotation;
-				if (r > Math.PI)
-					r -= Math.PI * 2;
-				else if (r < -Math.PI) r += Math.PI * 2;
-				r *= rotateMix;
-				var cos:Number = Math.cos(r), sin:Number = Math.sin(r);
-				bone.a = cos * a - sin * c;
-				bone.b = cos * b - sin * d;
-				bone.c = sin * a + cos * c;
-				bone.d = sin * b + cos * d;
-				modified = true;
-			}
+		public function apply() : void {
+			update();
+		}
 
-			if (translateMix != 0) {
-				_temp[0] = data.offsetX;
-				_temp[1] = data.offsetY;
-				target.localToWorld(_temp);
-				bone.worldX += (_temp[0] - bone.worldX) * translateMix;
-				bone.worldY += (_temp[1] - bone.worldY) * translateMix;
-				modified = true;
+		public function update() : void {
+			if (data.local) {
+				if (data.relative)
+					applyRelativeLocal();
+				else
+					applyAbsoluteLocal();
+			} else {
+				if (data.relative)
+					applyRelativeWorld();
+				else
+					applyAbsoluteWorld();
 			}
+		}
 
-			if (scaleMix > 0) {
-				var s:Number = Math.sqrt(bone.a * bone.a + bone.c * bone.c);
-				var ts:Number = Math.sqrt(ta * ta + tc * tc);
-				if (s > 0.00001) s = (s + (ts - s + data.offsetScaleX) * scaleMix) / s;
-				bone.a *= s;
-				bone.c *= s;
-				s = Math.sqrt(bone.b * bone.b + bone.d * bone.d);
-				ts = Math.sqrt(tb * tb + td * td);
-				if (s > 0.00001) s = (s + (ts - s + data.offsetScaleY) * scaleMix) / s;
-				bone.b *= s;
-				bone.d *= s;
-				modified = true;
-			}
+		internal function applyAbsoluteWorld() : void {
+			var rotateMix : Number = this.rotateMix, translateMix : Number = this.translateMix, scaleMix : Number = this.scaleMix, shearMix : Number = this.shearMix;
+			var target : Bone = this.target;
+			var ta : Number = target.a, tb : Number = target.b, tc : Number = target.c, td : Number = target.d;
+			var degRadReflect : Number = ta * td - tb * tc > 0 ? MathUtils.degRad : -MathUtils.degRad;
+			var offsetRotation : Number = data.offsetRotation * degRadReflect;
+			var offsetShearY : Number = data.offsetShearY * degRadReflect;
+			var bones : Vector.<Bone> = this._bones;
+			for (var i : int = 0, n : int = bones.length; i < n; i++) {
+				var bone : Bone = bones[i];
+				var modified : Boolean = false;
+
+				if (rotateMix != 0) {
+					var a : Number = bone.a, b : Number = bone.b, c : Number = bone.c, d : Number = bone.d;
+					var r : Number = Math.atan2(tc, ta) - Math.atan2(c, a) + offsetRotation;
+					if (r > Math.PI)
+						r -= Math.PI * 2;
+					else if (r < -Math.PI) r += Math.PI * 2;
+					r *= rotateMix;
+					var cos : Number = Math.cos(r), sin : Number = Math.sin(r);
+					bone.a = cos * a - sin * c;
+					bone.b = cos * b - sin * d;
+					bone.c = sin * a + cos * c;
+					bone.d = sin * b + cos * d;
+					modified = true;
+				}
+
+				if (translateMix != 0) {
+					_temp[0] = data.offsetX;
+					_temp[1] = data.offsetY;
+					target.localToWorld(_temp);
+					bone.worldX += (_temp[0] - bone.worldX) * translateMix;
+					bone.worldY += (_temp[1] - bone.worldY) * translateMix;
+					modified = true;
+				}
+
+				if (scaleMix > 0) {
+					var s : Number = Math.sqrt(bone.a * bone.a + bone.c * bone.c);
+					var ts : Number = Math.sqrt(ta * ta + tc * tc);
+					if (s > 0.00001) s = (s + (ts - s + data.offsetScaleX) * scaleMix) / s;
+					bone.a *= s;
+					bone.c *= s;
+					s = Math.sqrt(bone.b * bone.b + bone.d * bone.d);
+					ts = Math.sqrt(tb * tb + td * td);
+					if (s > 0.00001) s = (s + (ts - s + data.offsetScaleY) * scaleMix) / s;
+					bone.b *= s;
+					bone.d *= s;
+					modified = true;
+				}
+
+				if (shearMix > 0) {
+					b = bone.b
+					,
+					d = bone.d;
+					var by : Number = Math.atan2(d, b);
+					r = Math.atan2(td, tb) - Math.atan2(tc, ta) - (by - Math.atan2(bone.c, bone.a));
+					if (r > Math.PI)
+						r -= Math.PI * 2;
+					else if (r < -Math.PI) r += Math.PI * 2;
+					r = by + (r + offsetShearY) * shearMix;
+					s = Math.sqrt(b * b + d * d);
+					bone.b = Math.cos(r) * s;
+					bone.d = Math.sin(r) * s;
+					modified = true;
+				}
 
-			if (shearMix > 0) {
-				b = bone.b, d = bone.d;
-				var by:Number = Math.atan2(d, b);
-				r = Math.atan2(td, tb) - Math.atan2(tc, ta) - (by - Math.atan2(bone.c, bone.a));
-				if (r > Math.PI)
-					r -= Math.PI * 2;
-				else if (r < -Math.PI) r += Math.PI * 2;
-				r = by + (r + offsetShearY) * shearMix;
-				s = Math.sqrt(b * b + d * d);
-				bone.b = Math.cos(r) * s;
-				bone.d = Math.sin(r) * s;
-				modified = true;
+				if (modified) bone.appliedValid = false;
 			}
-			
-			if (modified) bone.appliedValid = false;
 		}
-	}
-	
-	public function applyRelativeWorld () : void {
-		var rotateMix:Number = this.rotateMix, translateMix:Number = this.translateMix, scaleMix:Number = this.scaleMix, shearMix:Number = this.shearMix;
-		var target:Bone = this.target;
-		var ta:Number = target.a, tb:Number = target.b, tc:Number = target.c, td:Number = target.d;
-		var degRadReflect:Number = ta * td - tb * tc > 0 ? MathUtils.degRad : -MathUtils.degRad;
-		var offsetRotation:Number = this.data.offsetRotation * degRadReflect, offsetShearY:Number = this.data.offsetShearY * degRadReflect;
-		var bones:Vector.<Bone> = this.bones;
-		for (var i:int = 0, n:int = bones.length; i < n; i++) {
-			var bone:Bone = bones[i];
-			var modified:Boolean = false;
-
-			if (rotateMix != 0) {
-				var a:Number = bone.a, b:Number = bone.b, c:Number = bone.c, d:Number = bone.d;
-				var r:Number = Math.atan2(tc, ta) + offsetRotation;
-				if (r > MathUtils.PI)
-					r -= MathUtils.PI2;
-				else if (r < -MathUtils.PI) r += MathUtils.PI2;
-				r *= rotateMix;
-				var cos:Number = Math.cos(r), sin:Number = Math.sin(r);
-				bone.a = cos * a - sin * c;
-				bone.b = cos * b - sin * d;
-				bone.c = sin * a + cos * c;
-				bone.d = sin * b + cos * d;
-				modified = true;
-			}
 
-			if (translateMix != 0) {
-				var temp:Vector.<Number> = this._temp;
-				temp[0] = this._data.offsetX;
-				temp[1] = this._data.offsetY;
-				target.localToWorld(temp);
-				bone.worldX += temp[0] * translateMix;
-				bone.worldY += temp[1] * translateMix;
-				modified = true;
-			}
+		public function applyRelativeWorld() : void {
+			var rotateMix : Number = this.rotateMix, translateMix : Number = this.translateMix, scaleMix : Number = this.scaleMix, shearMix : Number = this.shearMix;
+			var target : Bone = this.target;
+			var ta : Number = target.a, tb : Number = target.b, tc : Number = target.c, td : Number = target.d;
+			var degRadReflect : Number = ta * td - tb * tc > 0 ? MathUtils.degRad : -MathUtils.degRad;
+			var offsetRotation : Number = this.data.offsetRotation * degRadReflect, offsetShearY : Number = this.data.offsetShearY * degRadReflect;
+			var bones : Vector.<Bone> = this.bones;
+			for (var i : int = 0, n : int = bones.length; i < n; i++) {
+				var bone : Bone = bones[i];
+				var modified : Boolean = false;
 
-			if (scaleMix > 0) {
-				var s:Number = (Math.sqrt(ta * ta + tc * tc) - 1 + this.data.offsetScaleX) * scaleMix + 1;
-				bone.a *= s;
-				bone.c *= s;
-				s = (Math.sqrt(tb * tb + td * td) - 1 + this.data.offsetScaleY) * scaleMix + 1;
-				bone.b *= s;
-				bone.d *= s;
-				modified = true;
-			}
+				if (rotateMix != 0) {
+					var a : Number = bone.a, b : Number = bone.b, c : Number = bone.c, d : Number = bone.d;
+					var r : Number = Math.atan2(tc, ta) + offsetRotation;
+					if (r > MathUtils.PI)
+						r -= MathUtils.PI2;
+					else if (r < -MathUtils.PI) r += MathUtils.PI2;
+					r *= rotateMix;
+					var cos : Number = Math.cos(r), sin : Number = Math.sin(r);
+					bone.a = cos * a - sin * c;
+					bone.b = cos * b - sin * d;
+					bone.c = sin * a + cos * c;
+					bone.d = sin * b + cos * d;
+					modified = true;
+				}
 
-			if (shearMix > 0) {
-				r = Math.atan2(td, tb) - Math.atan2(tc, ta);
-				if (r > MathUtils.PI)
-					r -= MathUtils.PI2;
-				else if (r < -MathUtils.PI) r += MathUtils.PI2;
-				b = bone.b; d = bone.d;
-				r = Math.atan2(d, b) + (r - MathUtils.PI / 2 + offsetShearY) * shearMix;
-				s = Math.sqrt(b * b + d * d);
-				bone.b = Math.cos(r) * s;
-				bone.d = Math.sin(r) * s;
-				modified = true;
-			}
+				if (translateMix != 0) {
+					var temp : Vector.<Number> = this._temp;
+					temp[0] = this._data.offsetX;
+					temp[1] = this._data.offsetY;
+					target.localToWorld(temp);
+					bone.worldX += temp[0] * translateMix;
+					bone.worldY += temp[1] * translateMix;
+					modified = true;
+				}
 
-			if (modified) bone.appliedValid = false;
-		}
-	}
+				if (scaleMix > 0) {
+					var s : Number = (Math.sqrt(ta * ta + tc * tc) - 1 + this.data.offsetScaleX) * scaleMix + 1;
+					bone.a *= s;
+					bone.c *= s;
+					s = (Math.sqrt(tb * tb + td * td) - 1 + this.data.offsetScaleY) * scaleMix + 1;
+					bone.b *= s;
+					bone.d *= s;
+					modified = true;
+				}
 
-	public function applyAbsoluteLocal () : void {
-		var rotateMix:Number = this.rotateMix, translateMix:Number = this.translateMix, scaleMix:Number = this.scaleMix, shearMix:Number = this.shearMix;
-		var target:Bone = this.target;
-		if (!target.appliedValid) target.updateAppliedTransform();
-		var bones:Vector.<Bone> = this.bones;
-		for (var i:int = 0, n:int = bones.length; i < n; i++) {
-			var bone:Bone = bones[i];
-			if (!bone.appliedValid) bone.updateAppliedTransform();
-
-			var rotation:Number = bone.arotation;
-			if (rotateMix != 0) {
-				var r:Number = target.arotation - rotation + this.data.offsetRotation;
-				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
-				rotation += r * rotateMix;
-			}
+				if (shearMix > 0) {
+					r = Math.atan2(td, tb) - Math.atan2(tc, ta);
+					if (r > MathUtils.PI)
+						r -= MathUtils.PI2;
+					else if (r < -MathUtils.PI) r += MathUtils.PI2;
+					b = bone.b;
+					d = bone.d;
+					r = Math.atan2(d, b) + (r - MathUtils.PI / 2 + offsetShearY) * shearMix;
+					s = Math.sqrt(b * b + d * d);
+					bone.b = Math.cos(r) * s;
+					bone.d = Math.sin(r) * s;
+					modified = true;
+				}
 
-			var x:Number = bone.ax, y:Number = bone.ay;
-			if (translateMix != 0) {
-				x += (target.ax - x + this.data.offsetX) * translateMix;
-				y += (target.ay - y + this.data.offsetY) * translateMix;
+				if (modified) bone.appliedValid = false;
 			}
+		}
 
-			var scaleX:Number = bone.ascaleX, scaleY:Number = bone.ascaleY;
-			if (scaleMix > 0) {
-				if (scaleX > 0.00001) scaleX = (scaleX + (target.ascaleX - scaleX + this.data.offsetScaleX) * scaleMix) / scaleX;
-				if (scaleY > 0.00001) scaleY = (scaleY + (target.ascaleY - scaleY + this.data.offsetScaleY) * scaleMix) / scaleY;
-			}
+		public function applyAbsoluteLocal() : void {
+			var rotateMix : Number = this.rotateMix, translateMix : Number = this.translateMix, scaleMix : Number = this.scaleMix, shearMix : Number = this.shearMix;
+			var target : Bone = this.target;
+			if (!target.appliedValid) target.updateAppliedTransform();
+			var bones : Vector.<Bone> = this.bones;
+			for (var i : int = 0, n : int = bones.length; i < n; i++) {
+				var bone : Bone = bones[i];
+				if (!bone.appliedValid) bone.updateAppliedTransform();
 
-			var shearY:Number = bone.ashearY;
-			if (shearMix > 0) {
-				r = target.ashearY - shearY + this.data.offsetShearY;
-				r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
-				bone.shearY += r * shearMix;
-			}
+				var rotation : Number = bone.arotation;
+				if (rotateMix != 0) {
+					var r : Number = target.arotation - rotation + this.data.offsetRotation;
+					r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
+					rotation += r * rotateMix;
+				}
 
-			bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
-		}
-	}
+				var x : Number = bone.ax, y : Number = bone.ay;
+				if (translateMix != 0) {
+					x += (target.ax - x + this.data.offsetX) * translateMix;
+					y += (target.ay - y + this.data.offsetY) * translateMix;
+				}
+
+				var scaleX : Number = bone.ascaleX, scaleY : Number = bone.ascaleY;
+				if (scaleMix > 0) {
+					if (scaleX > 0.00001) scaleX = (scaleX + (target.ascaleX - scaleX + this.data.offsetScaleX) * scaleMix) / scaleX;
+					if (scaleY > 0.00001) scaleY = (scaleY + (target.ascaleY - scaleY + this.data.offsetScaleY) * scaleMix) / scaleY;
+				}
+
+				var shearY : Number = bone.ashearY;
+				if (shearMix > 0) {
+					r = target.ashearY - shearY + this.data.offsetShearY;
+					r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
+					bone.shearY += r * shearMix;
+				}
 
-	public function applyRelativeLocal () : void {
-		var rotateMix:Number = this.rotateMix, translateMix:Number = this.translateMix, scaleMix:Number = this.scaleMix, shearMix:Number = this.shearMix;
-		var target:Bone = this.target;
-		if (!target.appliedValid) target.updateAppliedTransform();
-		var bones:Vector.<Bone> = this.bones;
-		for (var i:int = 0, n:int = bones.length; i < n; i++) {
-			var bone:Bone = bones[i];
-			if (!bone.appliedValid) bone.updateAppliedTransform();
-
-			var rotation:Number = bone.arotation;
-			if (rotateMix != 0) rotation += (target.arotation + this.data.offsetRotation) * rotateMix;
-
-			var x:Number = bone.ax, y:Number = bone.ay;
-			if (translateMix != 0) {
-				x += (target.ax + this.data.offsetX) * translateMix;
-				y += (target.ay + this.data.offsetY) * translateMix;
+				bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
 			}
+		}
+
+		public function applyRelativeLocal() : void {
+			var rotateMix : Number = this.rotateMix, translateMix : Number = this.translateMix, scaleMix : Number = this.scaleMix, shearMix : Number = this.shearMix;
+			var target : Bone = this.target;
+			if (!target.appliedValid) target.updateAppliedTransform();
+			var bones : Vector.<Bone> = this.bones;
+			for (var i : int = 0, n : int = bones.length; i < n; i++) {
+				var bone : Bone = bones[i];
+				if (!bone.appliedValid) bone.updateAppliedTransform();
+
+				var rotation : Number = bone.arotation;
+				if (rotateMix != 0) rotation += (target.arotation + this.data.offsetRotation) * rotateMix;
+
+				var x : Number = bone.ax, y : Number = bone.ay;
+				if (translateMix != 0) {
+					x += (target.ax + this.data.offsetX) * translateMix;
+					y += (target.ay + this.data.offsetY) * translateMix;
+				}
+
+				var scaleX : Number = bone.ascaleX, scaleY : Number = bone.ascaleY;
+				if (scaleMix > 0) {
+					if (scaleX > 0.00001) scaleX *= ((target.ascaleX - 1 + this.data.offsetScaleX) * scaleMix) + 1;
+					if (scaleY > 0.00001) scaleY *= ((target.ascaleY - 1 + this.data.offsetScaleY) * scaleMix) + 1;
+				}
 
-			var scaleX:Number = bone.ascaleX, scaleY:Number = bone.ascaleY;
-			if (scaleMix > 0) {
-				if (scaleX > 0.00001) scaleX *= ((target.ascaleX - 1 + this.data.offsetScaleX) * scaleMix) + 1;
-				if (scaleY > 0.00001) scaleY *= ((target.ascaleY - 1 + this.data.offsetScaleY) * scaleMix) + 1;
+				var shearY : Number = bone.ashearY;
+				if (shearMix > 0) shearY += (target.ashearY + this.data.offsetShearY) * shearMix;
+
+				bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
 			}
+		}
 
-			var shearY:Number = bone.ashearY;
-			if (shearMix > 0) shearY += (target.ashearY + this.data.offsetShearY) * shearMix;
+		public function getOrder() : Number {
+			return _data.order;
+		}
 
-			bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
+		public function get data() : TransformConstraintData {
+			return _data;
 		}
-	}
-	
-	
-	
-	public function getOrder () : Number {
-		return _data.order;
-	}
 
-	public function get data () : TransformConstraintData {
-		return _data;
-	}
-	
-	public function get bones () : Vector.<Bone> {
-		return _bones;
-	}
+		public function get bones() : Vector.<Bone> {
+			return _bones;
+		}
 
-	public function toString () : String {
-		return _data._name;
+		public function toString() : String {
+			return _data._name;
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/TransformConstraintData.as

@@ -29,41 +29,40 @@
  *****************************************************************************/
 
 package spine {
+	public class TransformConstraintData {
+		internal var _name : String;
+		public var order : Number;
+		internal var _bones : Vector.<BoneData> = new Vector.<BoneData>();
+		public var target : BoneData;
+		public var rotateMix : Number;
+		public var translateMix : Number;
+		public var scaleMix : Number;
+		public var shearMix : Number;
+		public var offsetRotation : Number;
+		public var offsetX : Number;
+		public var offsetY : Number;
+		public var offsetScaleX : Number;
+		public var offsetScaleY : Number;
+		public var offsetShearY : Number;
+		public var relative : Boolean = false;
+		public var local : Boolean = false;
 
-public class TransformConstraintData {
-	internal var _name:String;
-	public var order:Number;
-	internal var _bones:Vector.<BoneData> = new Vector.<BoneData>();
-	public var target:BoneData;
-	public var rotateMix:Number;
-	public var translateMix:Number;
-	public var scaleMix:Number;
-	public var shearMix:Number;
-	public var offsetRotation:Number;
-	public var offsetX:Number;
-	public var offsetY:Number;
-	public var offsetScaleX:Number;
-	public var offsetScaleY:Number;
-	public var offsetShearY:Number;
-	public var relative:Boolean = false;
-	public var local:Boolean = false;
+		public function TransformConstraintData(name : String) {
+			if (name == null) throw new ArgumentError("name cannot be null.");
+			_name = name;
+		}
 
-	public function TransformConstraintData (name:String) {
-		if (name == null) throw new ArgumentError("name cannot be null.");
-		_name = name;
-	}
-	
-	public function get bones () : Vector.<BoneData> {;
-		return _bones;
-	}
+		public function get bones() : Vector.<BoneData> {
+			;
+			return _bones;
+		}
 
-	public function get name () : String {
-		return _name;
-	}
+		public function get name() : String {
+			return _name;
+		}
 
-	public function toString () : String {
-		return _name;
+		public function toString() : String {
+			return _name;
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/TransformMode.as

@@ -29,13 +29,11 @@
  *****************************************************************************/
 
 package spine {
-
-public class TransformMode {
-	public static const normal:TransformMode = new TransformMode();
-	public static const onlyTranslation:TransformMode = new TransformMode();
-	public static const noRotationOrReflection:TransformMode = new TransformMode();
-	public static const noScale:TransformMode = new TransformMode();
-	public static const noScaleOrReflection:TransformMode = new TransformMode();
-}
-
-}
+	public class TransformMode {
+		public static const normal : TransformMode = new TransformMode();
+		public static const onlyTranslation : TransformMode = new TransformMode();
+		public static const noRotationOrReflection : TransformMode = new TransformMode();
+		public static const noScale : TransformMode = new TransformMode();
+		public static const noScaleOrReflection : TransformMode = new TransformMode();
+	}
+}

spine-as3/spine-as3/src/spine/Updatable.as

@@ -29,9 +29,7 @@
  *****************************************************************************/
 
 package spine {
-
-public interface Updatable {
-	function update () : void;
-}
-
-}
+	public interface Updatable {
+		function update() : void;
+	}
+}

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

@@ -29,91 +29,90 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Event;
-import spine.Skeleton;
+	import spine.Event;
+	import spine.Skeleton;
 
-public class Animation {
-	internal var _name:String;
-	public var _timelines:Vector.<Timeline>;
-	public var duration:Number;
+	public class Animation {
+		internal var _name : String;
+		public var _timelines : Vector.<Timeline>;
+		public var duration : Number;
 
-	public function Animation (name:String, timelines:Vector.<Timeline>, duration:Number) {
-		if (name == null) throw new ArgumentError("name cannot be null.");
-		if (timelines == null) throw new ArgumentError("timelines cannot be null.");
-		_name = name;
-		_timelines = timelines;
-		this.duration = duration;
-	}
+		public function Animation(name : String, timelines : Vector.<Timeline>, duration : Number) {
+			if (name == null) throw new ArgumentError("name cannot be null.");
+			if (timelines == null) throw new ArgumentError("timelines cannot be null.");
+			_name = name;
+			_timelines = timelines;
+			this.duration = duration;
+		}
 
-	public function get timelines () : Vector.<Timeline> {
-		return _timelines;
-	}
+		public function get timelines() : Vector.<Timeline> {
+			return _timelines;
+		}
 
-	/** Poses the skeleton at the specified time for this animation. */
-	public function apply (skeleton:Skeleton, lastTime:Number, time:Number, loop:Boolean, events:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
+		/** Poses the skeleton at the specified time for this animation. */
+		public function apply(skeleton : Skeleton, lastTime : Number, time : Number, loop : Boolean, events : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
 
-		if (loop && duration != 0) {
-			time %= duration;
-			if (lastTime > 0) lastTime %= duration;
-		}
+			if (loop && duration != 0) {
+				time %= duration;
+				if (lastTime > 0) lastTime %= duration;
+			}
 
-		for (var i:int = 0, n:int = timelines.length; i < n; i++)
-			timelines[i].apply(skeleton, lastTime, time, events, alpha, setupPose, mixingOut);
-	}
+			for (var i : int = 0, n : int = timelines.length; i < n; i++)
+				timelines[i].apply(skeleton, lastTime, time, events, alpha, setupPose, mixingOut);
+		}
 
-	public function get name () : String {
-		return _name;
-	}
+		public function get name() : String {
+			return _name;
+		}
 
-	public function toString () : String {
-		return _name;
-	}
+		public function toString() : String {
+			return _name;
+		}
 
-	/** @param target After the first and before the last entry. */
-	static public function binarySearch (values:Vector.<Number>, target:Number, step:int) : int {
-		var low:int = 0;
-		var high:int = values.length / step - 2;
-		if (high == 0)
-			return step;
-		var current:int = high >>> 1;
-		while (true) {
-			if (values[int((current + 1) * step)] <= target)
-				low = current + 1;
-			else
-				high = current;
-			if (low == high)
-				return (low + 1) * step;
-			current = (low + high) >>> 1;
+		/** @param target After the first and before the last entry. */
+		static public function binarySearch(values : Vector.<Number>, target : Number, step : int) : int {
+			var low : int = 0;
+			var high : int = values.length / step - 2;
+			if (high == 0)
+				return step;
+			var current : int = high >>> 1;
+			while (true) {
+				if (values[int((current + 1) * step)] <= target)
+					low = current + 1;
+				else
+					high = current;
+				if (low == high)
+					return (low + 1) * step;
+				current = (low + high) >>> 1;
+			}
+			return 0; // Can't happen.
 		}
-		return 0; // Can't happen.
-	}
 
-	/** @param target After the first and before the last entry. */
-	static public function binarySearch1 (values:Vector.<Number>, target:Number) : int {
-		var low:int = 0;
-		var high:int = values.length - 2;
-		if (high == 0)
-			return 1;
-		var current:int = high >>> 1;
-		while (true) {
-			if (values[int(current + 1)] <= target)
-				low = current + 1;
-			else
-				high = current;
-			if (low == high)
-				return low + 1;
-			current = (low + high) >>> 1;
+		/** @param target After the first and before the last entry. */
+		static public function binarySearch1(values : Vector.<Number>, target : Number) : int {
+			var low : int = 0;
+			var high : int = values.length - 2;
+			if (high == 0)
+				return 1;
+			var current : int = high >>> 1;
+			while (true) {
+				if (values[int(current + 1)] <= target)
+					low = current + 1;
+				else
+					high = current;
+				if (low == high)
+					return low + 1;
+				current = (low + high) >>> 1;
+			}
+			return 0; // Can't happen.
 		}
-		return 0; // Can't happen.
-	}
 
-	static public function linearSearch (values:Vector.<Number>, target:Number, step:int) : int {
-		for (var i:int = 0, last:int = values.length - step; i <= last; i += step)
-			if (values[i] > target)
-				return i;
-		return -1;
+		static public function linearSearch(values : Vector.<Number>, target : Number, step : int) : int {
+			for (var i : int = 0, last : int = values.length - step; i <= last; i += step)
+				if (values[i] > target)
+					return i;
+			return -1;
+		}
 	}
-}
-
-}
+}

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

@@ -29,560 +29,555 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.MathUtils;
-import spine.Bone;
-import spine.Pool;
-import flash.utils.Dictionary;
-import spine.Event;
-import spine.Skeleton;
-
-public class AnimationState {
-	internal static var emptyAnimation:Animation = new Animation("<empty>", new Vector.<Timeline>(), 0);
-	
-	public var data:AnimationStateData;
-	public var tracks:Vector.<TrackEntry> = new Vector.<TrackEntry>();
-	internal var events:Vector.<Event> = new Vector.<Event>();
-	public var onStart:Listeners = new Listeners();
-	public var onInterrupt:Listeners = new Listeners();
-	public var onEnd:Listeners = new Listeners();
-	public var onDispose:Listeners = new Listeners();
-	public var onComplete:Listeners = new Listeners();
-	public var onEvent:Listeners = new Listeners();
-	internal var queue:EventQueue;
-	internal var propertyIDs:Dictionary = new Dictionary();
-	internal var animationsChanged:Boolean;
-	public var timeScale:Number = 1;
-	internal var trackEntryPool:Pool;
-	
-	public function AnimationState(data:AnimationStateData) {
-		if (data == null) throw new ArgumentError("data can not be null");
-		this.data = data;
-		this.queue = new EventQueue(this);
-		this.trackEntryPool = new Pool(function():Object {
-			return new TrackEntry();
-		});
-	}
-	
-	public function update (delta:Number):void {
-		delta *= timeScale;
-		for (var i:int = 0, n:int = tracks.length; i < n; i++) {
-			var current:TrackEntry = tracks[i];
-			if (current == null) continue;
-
-			current.animationLast = current.nextAnimationLast;
-			current.trackLast = current.nextTrackLast;
-
-			var currentDelta:Number = delta * current.timeScale;
-
-			if (current.delay > 0) {
-				current.delay -= currentDelta;
-				if (current.delay > 0) continue;
-				currentDelta = -current.delay;
-				current.delay = 0;
-			}
+	import spine.MathUtils;
+	import spine.Bone;
+	import spine.Pool;
+
+	import flash.utils.Dictionary;
+
+	import spine.Event;
+	import spine.Skeleton;
+
+	public class AnimationState {
+		internal static var emptyAnimation : Animation = new Animation("<empty>", new Vector.<Timeline>(), 0);
+		public var data : AnimationStateData;
+		public var tracks : Vector.<TrackEntry> = new Vector.<TrackEntry>();
+		internal var events : Vector.<Event> = new Vector.<Event>();
+		public var onStart : Listeners = new Listeners();
+		public var onInterrupt : Listeners = new Listeners();
+		public var onEnd : Listeners = new Listeners();
+		public var onDispose : Listeners = new Listeners();
+		public var onComplete : Listeners = new Listeners();
+		public var onEvent : Listeners = new Listeners();
+		internal var queue : EventQueue;
+		internal var propertyIDs : Dictionary = new Dictionary();
+		internal var animationsChanged : Boolean;
+		public var timeScale : Number = 1;
+		internal var trackEntryPool : Pool;
+
+		public function AnimationState(data : AnimationStateData) {
+			if (data == null) throw new ArgumentError("data can not be null");
+			this.data = data;
+			this.queue = new EventQueue(this);
+			this.trackEntryPool = new Pool(function() : Object {
+				return new TrackEntry();
+			});
+		}
+
+		public function update(delta : Number) : void {
+			delta *= timeScale;
+			for (var i : int = 0, n : int = tracks.length; i < n; i++) {
+				var current : TrackEntry = tracks[i];
+				if (current == null) continue;
+
+				current.animationLast = current.nextAnimationLast;
+				current.trackLast = current.nextTrackLast;
+
+				var currentDelta : Number = delta * current.timeScale;
+
+				if (current.delay > 0) {
+					current.delay -= currentDelta;
+					if (current.delay > 0) continue;
+					currentDelta = -current.delay;
+					current.delay = 0;
+				}
 
-			var next:TrackEntry = current.next;
-			if (next != null) {
-				// When the next entry's delay is passed, change to the next entry, preserving leftover time.
-				var nextTime:Number = current.trackLast - next.delay;
-				if (nextTime >= 0) {
-					next.delay = 0;
-					next.trackTime = nextTime + delta * next.timeScale;
-					current.trackTime += currentDelta;
-					setCurrent(i, next, true);
-					while (next.mixingFrom != null) {
-						next.mixTime += currentDelta;
-						next = next.mixingFrom;
+				var next : TrackEntry = current.next;
+				if (next != null) {
+					// When the next entry's delay is passed, change to the next entry, preserving leftover time.
+					var nextTime : Number = current.trackLast - next.delay;
+					if (nextTime >= 0) {
+						next.delay = 0;
+						next.trackTime = nextTime + delta * next.timeScale;
+						current.trackTime += currentDelta;
+						setCurrent(i, next, true);
+						while (next.mixingFrom != null) {
+							next.mixTime += currentDelta;
+							next = next.mixingFrom;
+						}
+						continue;
+					}
+				} else {
+					// Clear the track when there is no next entry, the track end time is reached, and there is no mixingFrom.
+					if (current.trackLast >= current.trackEnd && current.mixingFrom == null) {
+						tracks[i] = null;
+						queue.end(current);
+						disposeNext(current);
+						continue;
 					}
-					continue;
-				}				
-			} else {
-				// Clear the track when there is no next entry, the track end time is reached, and there is no mixingFrom.
-				if (current.trackLast >= current.trackEnd && current.mixingFrom == null) {
-					tracks[i] = null;
-					queue.end(current);
-					disposeNext(current);
-					continue;
 				}
+				updateMixingFrom(current, delta);
+
+				current.trackTime += currentDelta;
 			}
-			updateMixingFrom(current, delta);
 
-			current.trackTime += currentDelta;
+			queue.drain();
 		}
 
-		queue.drain();
-	}
-	
-	private function updateMixingFrom (entry:TrackEntry, delta:Number):void {
-		var from:TrackEntry = entry.mixingFrom;
-		if (from == null) return;
-		
-		updateMixingFrom(from, delta);
-
-		if (entry.mixTime >= entry.mixDuration && from.mixingFrom == null && entry.mixTime > 0) {
-			entry.mixingFrom = null;
-			queue.end(from);
-			return;
+		private function updateMixingFrom(entry : TrackEntry, delta : Number) : void {
+			var from : TrackEntry = entry.mixingFrom;
+			if (from == null) return;
+
+			updateMixingFrom(from, delta);
+
+			if (entry.mixTime >= entry.mixDuration && from.mixingFrom == null && entry.mixTime > 0) {
+				entry.mixingFrom = null;
+				queue.end(from);
+				return;
+			}
+
+			from.animationLast = from.nextAnimationLast;
+			from.trackLast = from.nextTrackLast;
+			from.trackTime += delta * from.timeScale;
+			entry.mixTime += delta * entry.timeScale;
 		}
 
-		from.animationLast = from.nextAnimationLast;
-		from.trackLast = from.nextTrackLast;		
-		from.trackTime += delta * from.timeScale;
-		entry.mixTime += delta * entry.timeScale;		
-	}
-	
-	public function apply (skeleton:Skeleton):void {
-		if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
-		if (animationsChanged) _animationsChanged();
-
-		var events:Vector.<Event> = this.events;
-
-		for (var i:int = 0, n:int = tracks.length; i < n; i++) {
-			var current:TrackEntry = tracks[i];
-			if (current == null || current.delay > 0) continue;
-
-			// Apply mixing from entries first.
-			var mix:Number = current.alpha;
-			if (current.mixingFrom != null) 
-				mix *= applyMixingFrom(current, skeleton);
-			else if (current.trackTime >= current.trackEnd)
-				mix = 0;
-
-			// Apply current entry.
-			var animationLast:Number = current.animationLast, animationTime:Number = current.getAnimationTime();
-			var timelineCount:int = current.animation.timelines.length;
-			var timelines:Vector.<Timeline> = current.animation.timelines;
-			var ii:int = 0;
-			if (mix == 1) {
-				for (ii = 0; ii < timelineCount; ii++)
-					Timeline(timelines[ii]).apply(skeleton, animationLast, animationTime, events, 1, true, false);
-			} else {
-				var firstFrame:Boolean = current.timelinesRotation.length == 0;
-				if (firstFrame) current.timelinesRotation.length = timelineCount << 1;
-				var timelinesRotation:Vector.<Number> = current.timelinesRotation;
-
-				var timelinesFirst:Vector.<Boolean> = current.timelinesFirst;
-				for (ii = 0; ii < timelineCount; ii++) {
-					var timeline:Timeline = timelines[ii];
-					if (timeline is RotateTimeline) {
-						applyRotateTimeline(timeline, skeleton, animationTime, mix, timelinesFirst[ii], timelinesRotation, ii << 1,
-							firstFrame);
-					} else
-						timeline.apply(skeleton, animationLast, animationTime, events, mix, timelinesFirst[ii], false);
+		public function apply(skeleton : Skeleton) : void {
+			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
+			if (animationsChanged) _animationsChanged();
+
+			var events : Vector.<Event> = this.events;
+
+			for (var i : int = 0, n : int = tracks.length; i < n; i++) {
+				var current : TrackEntry = tracks[i];
+				if (current == null || current.delay > 0) continue;
+
+				// Apply mixing from entries first.
+				var mix : Number = current.alpha;
+				if (current.mixingFrom != null)
+					mix *= applyMixingFrom(current, skeleton);
+				else if (current.trackTime >= current.trackEnd)
+					mix = 0;
+
+				// Apply current entry.
+				var animationLast : Number = current.animationLast, animationTime : Number = current.getAnimationTime();
+				var timelineCount : int = current.animation.timelines.length;
+				var timelines : Vector.<Timeline> = current.animation.timelines;
+				var ii : int = 0;
+				if (mix == 1) {
+					for (ii = 0; ii < timelineCount; ii++)
+						Timeline(timelines[ii]).apply(skeleton, animationLast, animationTime, events, 1, true, false);
+				} else {
+					var firstFrame : Boolean = current.timelinesRotation.length == 0;
+					if (firstFrame) current.timelinesRotation.length = timelineCount << 1;
+					var timelinesRotation : Vector.<Number> = current.timelinesRotation;
+
+					var timelinesFirst : Vector.<Boolean> = current.timelinesFirst;
+					for (ii = 0; ii < timelineCount; ii++) {
+						var timeline : Timeline = timelines[ii];
+						if (timeline is RotateTimeline) {
+							applyRotateTimeline(timeline, skeleton, animationTime, mix, timelinesFirst[ii], timelinesRotation, ii << 1, firstFrame);
+						} else
+							timeline.apply(skeleton, animationLast, animationTime, events, mix, timelinesFirst[ii], false);
+					}
 				}
+				queueEvents(current, animationTime);
+				events.length = 0;
+				current.nextAnimationLast = animationTime;
+				current.nextTrackLast = current.trackTime;
 			}
-			queueEvents(current, animationTime);
-			events.length = 0;
-			current.nextAnimationLast = animationTime;
-			current.nextTrackLast = current.trackTime;
-		}
 
-		queue.drain();
-	}
-	
-	private function applyMixingFrom (entry:TrackEntry, skeleton:Skeleton):Number {
-		var from:TrackEntry = entry.mixingFrom;
-		if (from.mixingFrom != null) applyMixingFrom(from, skeleton);
-
-		var mix:Number = 0;
-		if (entry.mixDuration == 0) // Single frame mix to undo mixingFrom changes.
-			mix = 1;
-		else {
-			mix = entry.mixTime / entry.mixDuration;
-			if (mix > 1) mix = 1;			
+			queue.drain();
 		}
 
-		var events:Vector.<Event> = mix < from.eventThreshold ? this.events : null;
-		var attachments:Boolean = mix < from.attachmentThreshold, drawOrder:Boolean = mix < from.drawOrderThreshold;
-		var animationLast:Number = from.animationLast, animationTime:Number = from.getAnimationTime();
-		var timelineCount:int = from.animation.timelines.length;
-		var timelines:Vector.<Timeline> = from.animation.timelines;
-		var timelinesFirst:Vector.<Boolean> = from.timelinesFirst;
-		var alpha:Number = from.alpha * entry.mixAlpha * (1 - mix);
-
-		var firstFrame:Boolean = from.timelinesRotation.length == 0;
-		if (firstFrame) from.timelinesRotation.length = timelineCount << 1;
-		var timelinesRotation:Vector.<Number> = from.timelinesRotation;
-
-		for (var i:int = 0; i < timelineCount; i++) {
-			var timeline:Timeline = timelines[i];
-			var setupPose:Boolean = timelinesFirst[i];
-			if (timeline is RotateTimeline)
-				applyRotateTimeline(timeline, skeleton, animationTime, alpha, setupPose, timelinesRotation, i << 1, firstFrame);
+		private function applyMixingFrom(entry : TrackEntry, skeleton : Skeleton) : Number {
+			var from : TrackEntry = entry.mixingFrom;
+			if (from.mixingFrom != null) applyMixingFrom(from, skeleton);
+
+			var mix : Number = 0;
+			if (entry.mixDuration == 0) // Single frame mix to undo mixingFrom changes.
+				mix = 1;
 			else {
-				if (!setupPose) {
-					if (!attachments && timeline is AttachmentTimeline) continue;
-					if (!drawOrder && timeline is DrawOrderTimeline) continue;
+				mix = entry.mixTime / entry.mixDuration;
+				if (mix > 1) mix = 1;
+			}
+
+			var events : Vector.<Event> = mix < from.eventThreshold ? this.events : null;
+			var attachments : Boolean = mix < from.attachmentThreshold, drawOrder : Boolean = mix < from.drawOrderThreshold;
+			var animationLast : Number = from.animationLast, animationTime : Number = from.getAnimationTime();
+			var timelineCount : int = from.animation.timelines.length;
+			var timelines : Vector.<Timeline> = from.animation.timelines;
+			var timelinesFirst : Vector.<Boolean> = from.timelinesFirst;
+			var alpha : Number = from.alpha * entry.mixAlpha * (1 - mix);
+
+			var firstFrame : Boolean = from.timelinesRotation.length == 0;
+			if (firstFrame) from.timelinesRotation.length = timelineCount << 1;
+			var timelinesRotation : Vector.<Number> = from.timelinesRotation;
+
+			for (var i : int = 0; i < timelineCount; i++) {
+				var timeline : Timeline = timelines[i];
+				var setupPose : Boolean = timelinesFirst[i];
+				if (timeline is RotateTimeline)
+					applyRotateTimeline(timeline, skeleton, animationTime, alpha, setupPose, timelinesRotation, i << 1, firstFrame);
+				else {
+					if (!setupPose) {
+						if (!attachments && timeline is AttachmentTimeline) continue;
+						if (!drawOrder && timeline is DrawOrderTimeline) continue;
+					}
+					timeline.apply(skeleton, animationLast, animationTime, events, alpha, setupPose, true);
 				}
-				timeline.apply(skeleton, animationLast, animationTime, events, alpha, setupPose, true);
 			}
+
+			if (entry.mixDuration > 0) queueEvents(from, animationTime);
+			this.events.length = 0;
+			from.nextAnimationLast = animationTime;
+			from.nextTrackLast = from.trackTime;
+
+			return mix;
 		}
 
-		if (entry.mixDuration > 0) queueEvents(from, animationTime);
-		this.events.length = 0;
-		from.nextAnimationLast = animationTime;
-		from.nextTrackLast = from.trackTime;
+		private function applyRotateTimeline(timeline : Timeline, skeleton : Skeleton, time : Number, alpha : Number, setupPose : Boolean, timelinesRotation : Vector.<Number>, i : int, firstFrame : Boolean) : void {
+			if (firstFrame) timelinesRotation[i] = 0;
 
-		return mix;
-	}
-	
-	private function applyRotateTimeline (timeline:Timeline, skeleton:Skeleton, time:Number, alpha:Number, setupPose:Boolean,
-		timelinesRotation:Vector.<Number>, i:int, firstFrame:Boolean):void {
-			
-		if (firstFrame) timelinesRotation[i] = 0;
-			
-		if (alpha == 1) {
-			timeline.apply(skeleton, 0, time, null, 1, setupPose, false);
-			return;
+			if (alpha == 1) {
+				timeline.apply(skeleton, 0, time, null, 1, setupPose, false);
+				return;
+			}
+
+			var rotateTimeline : RotateTimeline = RotateTimeline(timeline);
+			var frames : Vector.<Number> = rotateTimeline.frames;
+			var bone : Bone = skeleton.bones[rotateTimeline.boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) bone.rotation = bone.data.rotation;
+				return;
+			}
+
+			var r2 : Number;
+			if (time >= frames[frames.length - RotateTimeline.ENTRIES]) // Time is after last frame.
+				r2 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION];
+			else {
+				// Interpolate between the previous frame and the current frame.
+				var frame : int = Animation.binarySearch(frames, time, RotateTimeline.ENTRIES);
+				var prevRotation : Number = frames[frame + RotateTimeline.PREV_ROTATION];
+				var frameTime : Number = frames[frame];
+				var percent : Number = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
+
+				r2 = frames[frame + RotateTimeline.ROTATION] - prevRotation;
+				r2 -= (16384 - int((16384.499999999996 - r2 / 360))) * 360;
+				r2 = prevRotation + r2 * percent + bone.data.rotation;
+				r2 -= (16384 - int((16384.499999999996 - r2 / 360))) * 360;
+			}
+
+			// Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.
+			var r1 : Number = setupPose ? bone.data.rotation : bone.rotation;
+			var total : Number, diff : Number = r2 - r1;
+			if (diff == 0) {
+				total = timelinesRotation[i];
+			} else {
+				diff -= (16384 - int((16384.499999999996 - diff / 360))) * 360;
+				var lastTotal : Number, lastDiff : Number;
+				if (firstFrame) {
+					lastTotal = 0;
+					lastDiff = diff;
+				} else {
+					lastTotal = timelinesRotation[i]; // Angle and direction of mix, including loops.
+					lastDiff = timelinesRotation[i + 1]; // Difference between bones.
+				}
+				var current : Boolean = diff > 0, dir : Boolean = lastTotal >= 0;
+				// Detect cross at 0 (not 180).
+				if (MathUtils.signum(lastDiff) != MathUtils.signum(diff) && Math.abs(lastDiff) <= 90) {
+					// A cross after a 360 rotation is a loop.
+					if (Math.abs(lastTotal) > 180) lastTotal += 360 * MathUtils.signum(lastTotal);
+					dir = current;
+				}
+				total = diff + lastTotal - lastTotal % 360; // Store loops as part of lastTotal.
+				if (dir != current) total += 360 * MathUtils.signum(lastTotal);
+				timelinesRotation[i] = total;
+			}
+			timelinesRotation[i + 1] = diff;
+			r1 += total * alpha;
+			bone.rotation = r1 - (16384 - int((16384.499999999996 - r1 / 360))) * 360;
 		}
 
-		var rotateTimeline:RotateTimeline = RotateTimeline(timeline);
-		var frames:Vector.<Number> = rotateTimeline.frames;		
-		var bone:Bone = skeleton.bones[rotateTimeline.boneIndex];
-		if (time < frames[0]) {
-			if (setupPose) bone.rotation = bone.data.rotation;
-			return;
+		private function queueEvents(entry : TrackEntry, animationTime : Number) : void {
+			var animationStart : Number = entry.animationStart, animationEnd : Number = entry.animationEnd;
+			var duration : Number = animationEnd - animationStart;
+			var trackLastWrapped : Number = entry.trackLast % duration;
+
+			// Queue events before complete.
+			var events : Vector.<Event> = this.events;
+			var event : Event;
+			var i : int = 0, n : int = events.length;
+			for (; i < n; i++) {
+				event = events[i];
+				if (event.time < trackLastWrapped) break;
+				if (event.time > animationEnd) continue; // Discard events outside animation start/end.
+				queue.event(entry, event);
+			}
+
+			// Queue complete if completed a loop iteration or the animation.
+			if (entry.loop ? (trackLastWrapped > entry.trackTime % duration) : (animationTime >= animationEnd && entry.animationLast < animationEnd)) {
+				queue.complete(entry);
+			}
+
+			// Queue events after complete.
+			for (; i < n; i++) {
+				event = events[i];
+				if (event.time < animationStart) continue; // Discard events outside animation start/end.
+				queue.event(entry, events[i]);
+			}
 		}
 
-		var r2:Number;
-		if (time >= frames[frames.length - RotateTimeline.ENTRIES]) // Time is after last frame.
-			r2 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION];
-		else {
-			// Interpolate between the previous frame and the current frame.
-			var frame:int = Animation.binarySearch(frames, time, RotateTimeline.ENTRIES);
-			var prevRotation:Number = frames[frame + RotateTimeline.PREV_ROTATION];
-			var frameTime:Number = frames[frame];
-			var percent:Number = rotateTimeline.getCurvePercent((frame >> 1) - 1,
-				1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
-
-			r2 = frames[frame + RotateTimeline.ROTATION] - prevRotation;
-			r2 -= (16384 - int((16384.499999999996 - r2 / 360))) * 360;
-			r2 = prevRotation + r2 * percent + bone.data.rotation;
-			r2 -= (16384 - int((16384.499999999996 - r2 / 360))) * 360;
+		public function clearTracks() : void {
+			var oldTrainDisabled : Boolean = queue.drainDisabled;
+			queue.drainDisabled = true;
+			for (var i : int = 0, n : int = tracks.length; i < n; i++)
+				clearTrack(i);
+			tracks.length = 0;
+			queue.drainDisabled = oldTrainDisabled;
+			queue.drain();
 		}
 
-		// Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.
-		var r1:Number = setupPose ? bone.data.rotation : bone.rotation;
-		var total:Number, diff:Number = r2 - r1;
-		if (diff == 0) {
-			total = timelinesRotation[i];
-		} else {
-			diff -= (16384 - int((16384.499999999996 - diff / 360))) * 360;
-			var lastTotal:Number, lastDiff:Number;
-			if (firstFrame) {
-				lastTotal = 0;
-				lastDiff = diff;
-			} else {
-				lastTotal = timelinesRotation[i]; // Angle and direction of mix, including loops.
-				lastDiff = timelinesRotation[i + 1]; // Difference between bones.
+		public function clearTrack(trackIndex : int) : void {
+			if (trackIndex >= tracks.length) return;
+			var current : TrackEntry = tracks[trackIndex];
+			if (current == null) return;
+
+			queue.end(current);
+
+			disposeNext(current);
+
+			var entry : TrackEntry = current;
+			while (true) {
+				var from : TrackEntry = entry.mixingFrom;
+				if (from == null) break;
+				queue.end(from);
+				entry.mixingFrom = null;
+				entry = from;
 			}
-			var current:Boolean = diff > 0, dir:Boolean = lastTotal >= 0;
-			// Detect cross at 0 (not 180).			
-			if (MathUtils.signum(lastDiff) != MathUtils.signum(diff) && Math.abs(lastDiff) <= 90) {
-				// A cross after a 360 rotation is a loop.
-				if (Math.abs(lastTotal) > 180) lastTotal += 360 * MathUtils.signum(lastTotal);
-				dir = current;
+
+			tracks[current.trackIndex] = null;
+
+			queue.drain();
+		}
+
+		private function setCurrent(index : int, current : TrackEntry, interrupt : Boolean) : void {
+			var from : TrackEntry = expandToIndex(index);
+			tracks[index] = current;
+
+			if (from != null) {
+				if (interrupt) queue.interrupt(from);
+				current.mixingFrom = from;
+				current.mixTime = 0;
+
+				from.timelinesRotation.length = 0;
+
+				// If not completely mixed in, set mixAlpha so mixing out happens from current mix to zero.
+				if (from.mixingFrom != null && from.mixDuration > 0) current.mixAlpha *= Math.min(from.mixTime / from.mixDuration, 1);
 			}
-			total = diff + lastTotal - lastTotal % 360; // Store loops as part of lastTotal.
-			if (dir != current) total += 360 * MathUtils.signum(lastTotal);
-			timelinesRotation[i] = total;
+
+			queue.start(current);
 		}
-		timelinesRotation[i + 1] = diff;
-		r1 += total * alpha;
-		bone.rotation = r1 - (16384 - int((16384.499999999996 - r1 / 360))) * 360;
-	}
-	
-	private function queueEvents (entry:TrackEntry, animationTime:Number):void {
-		var animationStart:Number = entry.animationStart, animationEnd:Number = entry.animationEnd;
-		var duration:Number = animationEnd - animationStart;
-		var trackLastWrapped:Number = entry.trackLast % duration;
-
-		// Queue events before complete.
-		var events:Vector.<Event> = this.events;
-		var event:Event;
-		var i:int = 0, n:int = events.length;
-		for (; i < n; i++) {
-			event = events[i];
-			if (event.time < trackLastWrapped) break;
-			if (event.time > animationEnd) continue; // Discard events outside animation start/end.
-			queue.event(entry, event);
+
+		public function setAnimationByName(trackIndex : int, animationName : String, loop : Boolean) : TrackEntry {
+			var animation : Animation = data.skeletonData.findAnimation(animationName);
+			if (animation == null) throw new ArgumentError("Animation not found: " + animationName);
+			return setAnimation(trackIndex, animation, loop);
 		}
 
-		// Queue complete if completed a loop iteration or the animation.
-		if (entry.loop ? (trackLastWrapped > entry.trackTime % duration)
-			: (animationTime >= animationEnd && entry.animationLast < animationEnd)) {
-			queue.complete(entry);
+		public function setAnimation(trackIndex : int, animation : Animation, loop : Boolean) : TrackEntry {
+			if (animation == null) throw new ArgumentError("animation cannot be null.");
+			var interrupt : Boolean = true;
+			var current : TrackEntry = expandToIndex(trackIndex);
+			if (current != null) {
+				if (current.nextTrackLast == -1) {
+					// Don't mix from an entry that was never applied.
+					tracks[trackIndex] = current.mixingFrom;
+					queue.interrupt(current);
+					queue.end(current);
+					disposeNext(current);
+					current = current.mixingFrom;
+					interrupt = false;
+				} else
+					disposeNext(current);
+			}
+			var entry : TrackEntry = trackEntry(trackIndex, animation, loop, current);
+			setCurrent(trackIndex, entry, interrupt);
+			queue.drain();
+			return entry;
 		}
 
-		// Queue events after complete.
-		for (; i < n; i++) {
-			event = events[i];
-			if (event.time < animationStart) continue; // Discard events outside animation start/end.
-			queue.event(entry, events[i]);
-		}		
-	}
-	
-	public function clearTracks ():void {
-		var oldTrainDisabled:Boolean = queue.drainDisabled;
-		queue.drainDisabled = true;
-		for (var i:int = 0, n:int = tracks.length; i < n; i++)
-			clearTrack(i);
-		tracks.length = 0;
-		queue.drainDisabled = oldTrainDisabled;
-		queue.drain();
-	}
-	
-	public function clearTrack (trackIndex:int):void {
-		if (trackIndex >= tracks.length) return;
-		var current:TrackEntry = tracks[trackIndex];
-		if (current == null) return;
-
-		queue.end(current);
-
-		disposeNext(current);
-
-		var entry:TrackEntry = current;
-		while (true) {
-			var from:TrackEntry = entry.mixingFrom;
-			if (from == null) break;
-			queue.end(from);
-			entry.mixingFrom = null;
-			entry = from;
+		public function addAnimationByName(trackIndex : int, animationName : String, loop : Boolean, delay : Number) : TrackEntry {
+			var animation : Animation = data.skeletonData.findAnimation(animationName);
+			if (animation == null) throw new ArgumentError("Animation not found: " + animationName);
+			return addAnimation(trackIndex, animation, loop, delay);
 		}
 
-		tracks[current.trackIndex] = null;
+		public function addAnimation(trackIndex : int, animation : Animation, loop : Boolean, delay : Number) : TrackEntry {
+			if (animation == null) throw new ArgumentError("animation cannot be null.");
 
-		queue.drain();
-	}
-	
-	
-	private function setCurrent (index:int, current:TrackEntry, interrupt:Boolean):void {
-		var from:TrackEntry = expandToIndex(index);
-		tracks[index] = current;
+			var last : TrackEntry = expandToIndex(trackIndex);
+			if (last != null) {
+				while (last.next != null)
+					last = last.next;
+			}
 
-		if (from != null) {
-			if (interrupt) queue.interrupt(from);
-			current.mixingFrom = from;
-			current.mixTime = 0;
+			var entry : TrackEntry = trackEntry(trackIndex, animation, loop, last);
 
-			from.timelinesRotation.length = 0;
+			if (last == null) {
+				setCurrent(trackIndex, entry, true);
+				queue.drain();
+			} else {
+				last.next = entry;
+				if (delay <= 0) {
+					var duration : Number = last.animationEnd - last.animationStart;
+					if (duration != 0)
+						delay += duration * (1 + (int)(last.trackTime / duration)) - data.getMix(last.animation, animation);
+					else
+						delay = 0;
+				}
+			}
 
-			// If not completely mixed in, set mixAlpha so mixing out happens from current mix to zero.
-			if (from.mixingFrom != null && from.mixDuration > 0) current.mixAlpha *= Math.min(from.mixTime / from.mixDuration, 1);
+			entry.delay = delay;
+			return entry;
 		}
 
-		queue.start(current);
-	}
-	
-	public function setAnimationByName (trackIndex:int, animationName:String, loop:Boolean):TrackEntry {
-		var animation:Animation = data.skeletonData.findAnimation(animationName);
-		if (animation == null) throw new ArgumentError("Animation not found: " + animationName);
-		return setAnimation(trackIndex, animation, loop);
-	}
-	
-	public function setAnimation (trackIndex:int, animation:Animation, loop:Boolean):TrackEntry {
-		if (animation == null) throw new ArgumentError("animation cannot be null.");
-		var interrupt:Boolean = true;
-		var current:TrackEntry = expandToIndex(trackIndex);
-		if (current != null) {
-			if (current.nextTrackLast == -1) {
-				// Don't mix from an entry that was never applied.
-				tracks[trackIndex] = current.mixingFrom;
-				queue.interrupt(current);
-				queue.end(current);
-				disposeNext(current);
-				current = current.mixingFrom;
-				interrupt = false;
-			} else
-				disposeNext(current);
-		}
-		var entry:TrackEntry = trackEntry(trackIndex, animation, loop, current);
-		setCurrent(trackIndex, entry, interrupt);
-		queue.drain();
-		return entry;
-	}
-	
-	public function addAnimationByName (trackIndex:int, animationName:String, loop:Boolean, delay:Number):TrackEntry {
-		var animation:Animation = data.skeletonData.findAnimation(animationName);
-		if (animation == null) throw new ArgumentError("Animation not found: " + animationName);
-		return addAnimation(trackIndex, animation, loop, delay);
-	}
-	
-	public function addAnimation (trackIndex:int, animation:Animation, loop:Boolean, delay:Number):TrackEntry {
-		if (animation == null) throw new ArgumentError("animation cannot be null.");
-
-		var last:TrackEntry = expandToIndex(trackIndex);
-		if (last != null) {
-			while (last.next != null)
-				last = last.next;
+		public function setEmptyAnimation(trackIndex : int, mixDuration : Number) : TrackEntry {
+			var entry : TrackEntry = setAnimation(trackIndex, emptyAnimation, false);
+			entry.mixDuration = mixDuration;
+			entry.trackEnd = mixDuration;
+			return entry;
 		}
 
-		var entry:TrackEntry = trackEntry(trackIndex, animation, loop, last);
+		public function addEmptyAnimation(trackIndex : int, mixDuration : Number, delay : Number) : TrackEntry {
+			if (delay <= 0) delay -= mixDuration;
+			var entry : TrackEntry = addAnimation(trackIndex, emptyAnimation, false, delay);
+			entry.mixDuration = mixDuration;
+			entry.trackEnd = mixDuration;
+			return entry;
+		}
 
-		if (last == null) {
-			setCurrent(trackIndex, entry, true);
-			queue.drain();
-		} else {
-			last.next = entry;
-			if (delay <= 0) {
-				var duration:Number = last.animationEnd - last.animationStart;
-				if (duration != 0)
-					delay += duration * (1 + (int)(last.trackTime / duration)) - data.getMix(last.animation, animation);
-				else
-					delay = 0;
+		public function setEmptyAnimations(mixDuration : Number) : void {
+			var oldDrainDisabled : Boolean = queue.drainDisabled;
+			queue.drainDisabled = true;
+			for (var i : int = 0, n : int = tracks.length; i < n; i++) {
+				var current : TrackEntry = tracks[i];
+				if (current != null) setEmptyAnimation(current.trackIndex, mixDuration);
 			}
+			queue.drainDisabled = oldDrainDisabled;
+			queue.drain();
 		}
 
-		entry.delay = delay;
-		return entry;
-	}
-	
-	public function setEmptyAnimation (trackIndex:int, mixDuration:Number):TrackEntry {
-		var entry:TrackEntry = setAnimation(trackIndex, emptyAnimation, false);
-		entry.mixDuration = mixDuration;
-		entry.trackEnd = mixDuration;
-		return entry;
-	}
-	
-	public function addEmptyAnimation (trackIndex:int, mixDuration:Number, delay:Number):TrackEntry {
-		if (delay <= 0) delay -= mixDuration;
-		var entry:TrackEntry = addAnimation(trackIndex, emptyAnimation, false, delay);
-		entry.mixDuration = mixDuration;
-		entry.trackEnd = mixDuration;
-		return entry;
-	}
-	
-	public function setEmptyAnimations (mixDuration:Number):void {
-		var oldDrainDisabled:Boolean = queue.drainDisabled;
-		queue.drainDisabled = true;
-		for (var i:int = 0, n:int = tracks.length; i < n; i++) {
-			var current:TrackEntry = tracks[i];
-			if (current != null) setEmptyAnimation(current.trackIndex, mixDuration);
-		}
-		queue.drainDisabled = oldDrainDisabled;
-		queue.drain();
-	}
-	
-	private function expandToIndex (index:int):TrackEntry {
-		if (index < tracks.length) return tracks[index];		
-		tracks.length = index + 1;
-		return null;
-	}
-	
-	private function trackEntry (trackIndex:int, animation:Animation, loop:Boolean, last:TrackEntry):TrackEntry {
-		var entry:TrackEntry = TrackEntry(trackEntryPool.obtain());
-		entry.trackIndex = trackIndex;
-		entry.animation = animation;
-		entry.loop = loop;
-
-		entry.eventThreshold = 0;
-		entry.attachmentThreshold = 0;
-		entry.drawOrderThreshold = 0;
-
-		entry.animationStart = 0;
-		entry.animationEnd = animation.duration;
-		entry.animationLast = -1;
-		entry.nextAnimationLast = -1;
-
-		entry.delay = 0;
-		entry.trackTime = 0;
-		entry.trackLast = -1;
-		entry.nextTrackLast = -1;
-		entry.trackEnd = int.MAX_VALUE;
-		entry.timeScale = 1;
-
-		entry.alpha = 1;
-		entry.mixAlpha = 1;
-		entry.mixTime = 0;
-		entry.mixDuration = last == null ? 0 : data.getMix(last.animation, animation);
-		return entry;
-	}
-	
-	private function disposeNext (entry:TrackEntry):void{
-		var next:TrackEntry = entry.next;
-		while (next != null) {
-			queue.dispose(next);
-			next = next.next;
+		private function expandToIndex(index : int) : TrackEntry {
+			if (index < tracks.length) return tracks[index];
+			tracks.length = index + 1;
+			return null;
 		}
-		entry.next = null;
-	}
-	
-	private function _animationsChanged ():void {
-		animationsChanged = false;
 
-		var propertyIDs:Dictionary = this.propertyIDs = new Dictionary();
+		private function trackEntry(trackIndex : int, animation : Animation, loop : Boolean, last : TrackEntry) : TrackEntry {
+			var entry : TrackEntry = TrackEntry(trackEntryPool.obtain());
+			entry.trackIndex = trackIndex;
+			entry.animation = animation;
+			entry.loop = loop;
+
+			entry.eventThreshold = 0;
+			entry.attachmentThreshold = 0;
+			entry.drawOrderThreshold = 0;
+
+			entry.animationStart = 0;
+			entry.animationEnd = animation.duration;
+			entry.animationLast = -1;
+			entry.nextAnimationLast = -1;
+
+			entry.delay = 0;
+			entry.trackTime = 0;
+			entry.trackLast = -1;
+			entry.nextTrackLast = -1;
+			entry.trackEnd = int.MAX_VALUE;
+			entry.timeScale = 1;
+
+			entry.alpha = 1;
+			entry.mixAlpha = 1;
+			entry.mixTime = 0;
+			entry.mixDuration = last == null ? 0 : data.getMix(last.animation, animation);
+			return entry;
+		}
 
-		// Compute timelinesFirst from lowest to highest track entries.
-		var i:int = 0, n:int = tracks.length;
-		for (var key:String in propertyIDs) {
-    		delete propertyIDs[key];
+		private function disposeNext(entry : TrackEntry) : void {
+			var next : TrackEntry = entry.next;
+			while (next != null) {
+				queue.dispose(next);
+				next = next.next;
+			}
+			entry.next = null;
 		}
-		var entry:TrackEntry;
-		for (; i < n; i++) { // Find first non-null entry.
-			entry = tracks[i];
-			if (entry == null) continue;
-			setTimelinesFirst(entry);
-			i++;
-			break;
+
+		private function _animationsChanged() : void {
+			animationsChanged = false;
+
+			var propertyIDs : Dictionary = this.propertyIDs = new Dictionary();
+
+			// Compute timelinesFirst from lowest to highest track entries.
+			var i : int = 0, n : int = tracks.length;
+			for (var key : String in propertyIDs) {
+				delete propertyIDs[key];
+			}
+			var entry : TrackEntry;
+			for (; i < n; i++) { // Find first non-null entry.
+				entry = tracks[i];
+				if (entry == null) continue;
+				setTimelinesFirst(entry);
+				i++;
+				break;
+			}
+			for (; i < n; i++) { // Rest of entries.
+				entry = tracks[i];
+				if (entry != null) checkTimelinesFirst(entry);
+			}
 		}
-		for (; i < n; i++) { // Rest of entries.
-			entry = tracks[i];
-			if (entry != null) checkTimelinesFirst(entry);
+
+		private function setTimelinesFirst(entry : TrackEntry) : void {
+			if (entry.mixingFrom != null) {
+				setTimelinesFirst(entry.mixingFrom);
+				checkTimelinesUsage(entry, entry.timelinesFirst);
+				return;
+			}
+			var propertyIDs : Dictionary = this.propertyIDs;
+			var timelines : Vector.<Timeline> = entry.animation.timelines;
+			var n : int = timelines.length;
+			var usage : Vector.<Boolean> = entry.timelinesFirst;
+			usage.length = n;
+			for (var i : int = 0; i < n; i++) {
+				var id : String = timelines[i].getPropertyId().toString();
+				propertyIDs[id] = id;
+				usage[i] = true;
+			}
 		}
-	}
-	
-	private function setTimelinesFirst (entry:TrackEntry):void {
-		if (entry.mixingFrom != null) {
-			setTimelinesFirst(entry.mixingFrom);
+
+		private function checkTimelinesFirst(entry : TrackEntry) : void {
+			if (entry.mixingFrom != null) checkTimelinesFirst(entry.mixingFrom);
 			checkTimelinesUsage(entry, entry.timelinesFirst);
-			return;
 		}
-		var propertyIDs:Dictionary = this.propertyIDs;
-		var timelines:Vector.<Timeline> = entry.animation.timelines;
-		var n:int = timelines.length;
-		var usage:Vector.<Boolean> = entry.timelinesFirst;
-		usage.length = n;
-		for (var i:int = 0; i < n; i++) {
-			var id:String = timelines[i].getPropertyId().toString();
-			propertyIDs[id] = id;
-			usage[i] = true;
+
+		private function checkTimelinesUsage(entry : TrackEntry, usageArray : Vector.<Boolean>) : void {
+			var propertyIDs : Dictionary = this.propertyIDs;
+			var timelines : Vector.<Timeline> = entry.animation.timelines;
+			var n : int = timelines.length;
+			var usage : Vector.<Boolean> = usageArray;
+			usageArray.length = n;
+			for (var i : int = 0; i < n; i++) {
+				var id : String = timelines[i].getPropertyId().toString();
+				usage[i] = !propertyIDs.hasOwnProperty(id);
+				propertyIDs[id] = id;
+			}
 		}
-	}
-	
-	private function checkTimelinesFirst (entry:TrackEntry):void {
-		if (entry.mixingFrom != null) checkTimelinesFirst(entry.mixingFrom);
-		checkTimelinesUsage(entry, entry.timelinesFirst);
-	}
-	
-	private function checkTimelinesUsage (entry:TrackEntry, usageArray:Vector.<Boolean>):void {
-		var propertyIDs:Dictionary = this.propertyIDs;
-		var timelines:Vector.<Timeline> = entry.animation.timelines;
-		var n:int = timelines.length;
-		var usage:Vector.<Boolean> = usageArray;
-		usageArray.length = n;
-		for (var i:int = 0; i < n; i++) {
-			var id:String = timelines[i].getPropertyId().toString();
-			usage[i] = !propertyIDs.hasOwnProperty(id);			
-			propertyIDs[id] = id;
+
+		public function getCurrent(trackIndex : int) : TrackEntry {
+			if (trackIndex >= tracks.length) return null;
+			return tracks[trackIndex];
+		}
+
+		public function clearListeners() : void {
+			onStart.listeners.length = 0;
+			onInterrupt.listeners.length = 0;
+			onEnd.listeners.length = 0;
+			onDispose.listeners.length = 0;
+			onComplete.listeners.length = 0;
+			onEvent.listeners.length = 0;
+		}
+
+		public function clearListenerNotifications() : void {
+			queue.clear();
 		}
 	}
-	
-	public function getCurrent (trackIndex:int):TrackEntry {
-		if (trackIndex >= tracks.length) return null;
-		return tracks[trackIndex];
-	}
-	
-	public function clearListeners ():void {
-		onStart.listeners.length = 0;
-		onInterrupt.listeners.length = 0;
-		onEnd.listeners.length = 0;
-		onDispose.listeners.length = 0;
-		onComplete.listeners.length = 0;
-		onEvent.listeners.length = 0;	
-	}
-	
-	public function clearListenerNotifications ():void {
-		queue.clear();
-	}
-}
-}
+}

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

@@ -29,40 +29,39 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.SkeletonData;
+	import spine.SkeletonData;
 
-public class AnimationStateData {
-	internal var _skeletonData:SkeletonData;
-	private var animationToMixTime:Object = new Object();
-	public var defaultMix:Number = 0;
+	public class AnimationStateData {
+		internal var _skeletonData : SkeletonData;
+		private var animationToMixTime : Object = new Object();
+		public var defaultMix : Number = 0;
 
-	public function AnimationStateData (skeletonData:SkeletonData) {
-		_skeletonData = skeletonData;
-	}
+		public function AnimationStateData(skeletonData : SkeletonData) {
+			_skeletonData = skeletonData;
+		}
 
-	public function get skeletonData () : SkeletonData {
-		return _skeletonData;
-	}
+		public function get skeletonData() : SkeletonData {
+			return _skeletonData;
+		}
 
-	public function setMixByName (fromName:String, toName:String, duration:Number) : void {
-		var from:Animation = _skeletonData.findAnimation(fromName);
-		if (from == null) throw new ArgumentError("Animation not found: " + fromName);
-		var to:Animation = _skeletonData.findAnimation(toName);
-		if (to == null) throw new ArgumentError("Animation not found: " + toName);
-		setMix(from, to, duration);
-	}
+		public function setMixByName(fromName : String, toName : String, duration : Number) : void {
+			var from : Animation = _skeletonData.findAnimation(fromName);
+			if (from == null) throw new ArgumentError("Animation not found: " + fromName);
+			var to : Animation = _skeletonData.findAnimation(toName);
+			if (to == null) throw new ArgumentError("Animation not found: " + toName);
+			setMix(from, to, duration);
+		}
 
-	public function setMix (from:Animation, to:Animation, duration:Number) : void {
-		if (from == null) throw new ArgumentError("from cannot be null.");
-		if (to == null) throw new ArgumentError("to cannot be null.");
-		animationToMixTime[from.name + ":" + to.name] = duration;
-	}
+		public function setMix(from : Animation, to : Animation, duration : Number) : void {
+			if (from == null) throw new ArgumentError("from cannot be null.");
+			if (to == null) throw new ArgumentError("to cannot be null.");
+			animationToMixTime[from.name + ":" + to.name] = duration;
+		}
 
-	public function getMix (from:Animation, to:Animation) : Number {
-		var time:Object = animationToMixTime[from.name + ":" + to.name];
-		if (time == null) return defaultMix;
-		return time as Number;
+		public function getMix(from : Animation, to : Animation) : Number {
+			var time : Object = animationToMixTime[from.name + ":" + to.name];
+			if (time == null) return defaultMix;
+			return time as Number;
+		}
 	}
-}
-
-}
+}

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

@@ -29,60 +29,59 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Slot;
-import spine.Event;
-import spine.Skeleton;
+	import spine.Slot;
+	import spine.Event;
+	import spine.Skeleton;
 
-public class AttachmentTimeline implements Timeline {
-	public var slotIndex:int;
-	public var frames:Vector.<Number>; // time, ...
-	public var attachmentNames:Vector.<String>;
+	public class AttachmentTimeline implements Timeline {
+		public var slotIndex : int;
+		public var frames : Vector.<Number>; // time, ...
+		public var attachmentNames : Vector.<String>;
 
-	public function AttachmentTimeline (frameCount:int) {
-		frames = new Vector.<Number>(frameCount, true);
-		attachmentNames = new Vector.<String>(frameCount, true);
-	}
+		public function AttachmentTimeline(frameCount : int) {
+			frames = new Vector.<Number>(frameCount, true);
+			attachmentNames = new Vector.<String>(frameCount, true);
+		}
 
-	public function get frameCount () : int {
-		return frames.length;
-	}
-	
-	public function getPropertyId () : int {
-		return (TimelineType.attachment.ordinal << 24) + slotIndex;
-	}
+		public function get frameCount() : int {
+			return frames.length;
+		}
 
-	/** Sets the time and value of the specified keyframe. */
-	public function setFrame (frameIndex:int, time:Number, attachmentName:String) : void {
-		frames[frameIndex] = time;
-		attachmentNames[frameIndex] = attachmentName;
-	}
+		public function getPropertyId() : int {
+			return (TimelineType.attachment.ordinal << 24) + slotIndex;
+		}
 
-	public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		var attachmentName:String;
-		var slot:Slot = skeleton.slots[slotIndex];
-		if (mixingOut && setupPose) {			
-			attachmentName = slot.data.attachmentName;
-			slot.attachment = attachmentName == null ? null : skeleton.getAttachmentForSlotIndex(slotIndex, attachmentName);
-			return;
+		/** Sets the time and value of the specified keyframe. */
+		public function setFrame(frameIndex : int, time : Number, attachmentName : String) : void {
+			frames[frameIndex] = time;
+			attachmentNames[frameIndex] = attachmentName;
 		}
-		var frames:Vector.<Number> = this.frames;
-		if (time < frames[0]) {
-			if (setupPose) {
+
+		public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var attachmentName : String;
+			var slot : Slot = skeleton.slots[slotIndex];
+			if (mixingOut && setupPose) {
 				attachmentName = slot.data.attachmentName;
 				slot.attachment = attachmentName == null ? null : skeleton.getAttachmentForSlotIndex(slotIndex, attachmentName);
+				return;
+			}
+			var frames : Vector.<Number> = this.frames;
+			if (time < frames[0]) {
+				if (setupPose) {
+					attachmentName = slot.data.attachmentName;
+					slot.attachment = attachmentName == null ? null : skeleton.getAttachmentForSlotIndex(slotIndex, attachmentName);
+				}
+				return;
 			}
-			return;
-		}
 
-		var frameIndex:int;
-		if (time >= frames[frames.length - 1]) // Time is after last frame.
-			frameIndex = frames.length - 1;
-		else
-			frameIndex = Animation.binarySearch(frames, time, 1) - 1;
+			var frameIndex : int;
+			if (time >= frames[frames.length - 1]) // Time is after last frame.
+				frameIndex = frames.length - 1;
+			else
+				frameIndex = Animation.binarySearch(frames, time, 1) - 1;
 
-		attachmentName = attachmentNames[frameIndex];
-		skeleton.slots[slotIndex].attachment = attachmentName == null ? null : skeleton.getAttachmentForSlotIndex(slotIndex, attachmentName);
+			attachmentName = attachmentNames[frameIndex];
+			skeleton.slots[slotIndex].attachment = attachmentName == null ? null : skeleton.getAttachmentForSlotIndex(slotIndex, attachmentName);
+		}
 	}
-}
-
-}
+}

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

@@ -29,83 +29,80 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Event;
-import spine.Skeleton;
-import spine.Slot;
+	import spine.Event;
+	import spine.Skeleton;
+	import spine.Slot;
 
-public class ColorTimeline extends CurveTimeline {
-	static public const ENTRIES:int = 5;
-	static internal const PREV_TIME:int = -5, PREV_R:int = -4, PREV_G:int = -3, PREV_B:int = -2, PREV_A:int = -1;
-	static internal const R:int = 1, G:int = 2, B:int = 3, A:int = 4;
+	public class ColorTimeline extends CurveTimeline {
+		static public const ENTRIES : int = 5;
+		static internal const PREV_TIME : int = -5, PREV_R : int = -4, PREV_G : int = -3, PREV_B : int = -2, PREV_A : int = -1;
+		static internal const R : int = 1, G : int = 2, B : int = 3, A : int = 4;
+		public var slotIndex : int;
+		public var frames : Vector.<Number>; // time, r, g, b, a, ...
 
-	public var slotIndex:int;
-	public var frames:Vector.<Number>; // time, r, g, b, a, ...
+		public function ColorTimeline(frameCount : int) {
+			super(frameCount);
+			frames = new Vector.<Number>(frameCount * 5, true);
+		}
 
-	public function ColorTimeline (frameCount:int) {
-		super(frameCount);
-		frames = new Vector.<Number>(frameCount * 5, true);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.color.ordinal << 24) + slotIndex;
-	}
+		override public function getPropertyId() : int {
+			return (TimelineType.color.ordinal << 24) + slotIndex;
+		}
 
-	/** Sets the time and value of the specified keyframe. */
-	public function setFrame (frameIndex:int, time:Number, r:Number, g:Number, b:Number, a:Number) : void {
-		frameIndex *= ENTRIES;
-		frames[frameIndex] = time;
-		frames[int(frameIndex + R)] = r;
-		frames[int(frameIndex + G)] = g;
-		frames[int(frameIndex + B)] = b;
-		frames[int(frameIndex + A)] = a;
-	}
+		/** Sets the time and value of the specified keyframe. */
+		public function setFrame(frameIndex : int, time : Number, r : Number, g : Number, b : Number, a : Number) : void {
+			frameIndex *= ENTRIES;
+			frames[frameIndex] = time;
+			frames[int(frameIndex + R)] = r;
+			frames[int(frameIndex + G)] = g;
+			frames[int(frameIndex + B)] = b;
+			frames[int(frameIndex + A)] = a;
+		}
+
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var frames : Vector.<Number> = this.frames;
+			var slot : Slot = skeleton.slots[slotIndex];
 
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		var frames:Vector.<Number> = this.frames;
-		var slot:Slot = skeleton.slots[slotIndex];
-		
-		if (time < frames[0]) {
-			if (setupPose) {
-				slot.color.setFromColor(slot.data.color);				
+			if (time < frames[0]) {
+				if (setupPose) {
+					slot.color.setFromColor(slot.data.color);
+				}
+				return;
 			}
-			return;
-		}
 
-		var r:Number, g:Number, b:Number, a:Number;
-		if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
-			var i:int = frames.length;
-			r = frames[i + PREV_R];
-			g = frames[i + PREV_G];
-			b = frames[i + PREV_B];
-			a = frames[i + PREV_A];
-		} else {
-			// Interpolate between the previous frame and the current frame.
-			var frame:int = Animation.binarySearch(frames, time, ENTRIES);
-			r = frames[frame + PREV_R];
-			g = frames[frame + PREV_G];
-			b = frames[frame + PREV_B];
-			a = frames[frame + PREV_A];
-			var frameTime:Number = frames[frame];
-			var percent:Number = getCurvePercent(frame / ENTRIES - 1,
-				1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+			var r : Number, g : Number, b : Number, a : Number;
+			if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
+				var i : int = frames.length;
+				r = frames[i + PREV_R];
+				g = frames[i + PREV_G];
+				b = frames[i + PREV_B];
+				a = frames[i + PREV_A];
+			} else {
+				// Interpolate between the previous frame and the current frame.
+				var frame : int = Animation.binarySearch(frames, time, ENTRIES);
+				r = frames[frame + PREV_R];
+				g = frames[frame + PREV_G];
+				b = frames[frame + PREV_B];
+				a = frames[frame + PREV_A];
+				var frameTime : Number = frames[frame];
+				var percent : Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
 
-			r += (frames[frame + R] - r) * percent;
-			g += (frames[frame + G] - g) * percent;
-			b += (frames[frame + B] - b) * percent;
-			a += (frames[frame + A] - a) * percent;
-		}		
-		if (alpha == 1) {
-			slot.color.setFrom(r, g, b, a);
-		} else {			
-			if (setupPose) {
-				slot.color.setFromColor(slot.data.color);			 
+				r += (frames[frame + R] - r) * percent;
+				g += (frames[frame + G] - g) * percent;
+				b += (frames[frame + B] - b) * percent;
+				a += (frames[frame + A] - a) * percent;
+			}
+			if (alpha == 1) {
+				slot.color.setFrom(r, g, b, a);
+			} else {
+				if (setupPose) {
+					slot.color.setFromColor(slot.data.color);
+				}
+				slot.color.r += (r - slot.color.r) * alpha;
+				slot.color.g += (g - slot.color.g) * alpha;
+				slot.color.b += (b - slot.color.b) * alpha;
+				slot.color.a += (a - slot.color.a) * alpha;
 			}
-			slot.color.r += (r - slot.color.r) * alpha;
-			slot.color.g += (g - slot.color.g) * alpha;
-			slot.color.b += (b - slot.color.b) * alpha;
-			slot.color.a += (a - slot.color.a) * alpha;			
 		}
 	}
-}
-
-}
+}

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

@@ -30,93 +30,91 @@
 
 package spine.animation {
 	import spine.MathUtils;
-import spine.Event;
-import spine.Skeleton;
+	import spine.Event;
+	import spine.Skeleton;
 
-/** Base class for frames that use an interpolation bezier curve. */
-public class CurveTimeline implements Timeline {
-	static private const LINEAR:Number = 0;
-	static private const STEPPED:Number = 1;
-	static private const BEZIER:Number = 2;
-	static private const BEZIER_SIZE:int = 10 * 2 - 1;
+	/** Base class for frames that use an interpolation bezier curve. */
+	public class CurveTimeline implements Timeline {
+		static private const LINEAR : Number = 0;
+		static private const STEPPED : Number = 1;
+		static private const BEZIER : Number = 2;
+		static private const BEZIER_SIZE : int = 10 * 2 - 1;
+		private var curves : Vector.<Number>; // type, x, y, ...
 
-	private var curves:Vector.<Number>; // type, x, y, ...
+		public function CurveTimeline(frameCount : int) {
+			curves = new Vector.<Number>((frameCount - 1) * BEZIER_SIZE, true);
+		}
 
-	public function CurveTimeline (frameCount:int) {
-		curves = new Vector.<Number>((frameCount - 1) * BEZIER_SIZE, true);
-	}
+		public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+		}
 
-	public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-	}
-	
-	public function getPropertyId () : int {
-		return 0;
-	}
+		public function getPropertyId() : int {
+			return 0;
+		}
 
-	public function get frameCount () : int {
-		return curves.length / BEZIER_SIZE + 1;
-	}
+		public function get frameCount() : int {
+			return curves.length / BEZIER_SIZE + 1;
+		}
 
-	public function setLinear (frameIndex:int) : void {
-		curves[int(frameIndex * BEZIER_SIZE)] = LINEAR;
-	}
+		public function setLinear(frameIndex : int) : void {
+			curves[int(frameIndex * BEZIER_SIZE)] = LINEAR;
+		}
 
-	public function setStepped (frameIndex:int) : void {
-		curves[int(frameIndex * BEZIER_SIZE)] = STEPPED;
-	}
+		public function setStepped(frameIndex : int) : void {
+			curves[int(frameIndex * BEZIER_SIZE)] = STEPPED;
+		}
 
-	/** Sets the control handle positions for an interpolation bezier curve used to transition from this keyframe to the next.
-	 * cx1 and cx2 are from 0 to 1, representing the percent of time between the two keyframes. cy1 and cy2 are the percent of
-	 * the difference between the keyframe's values. */
-	public function setCurve (frameIndex:int, cx1:Number, cy1:Number, cx2:Number, cy2:Number) : void {
-		var tmpx:Number = (-cx1 * 2 + cx2) * 0.03, tmpy:Number = (-cy1 * 2 + cy2) * 0.03;
-		var dddfx:Number = ((cx1 - cx2) * 3 + 1) * 0.006, dddfy:Number = ((cy1 - cy2) * 3 + 1) * 0.006;
-		var ddfx:Number = tmpx * 2 + dddfx, ddfy:Number = tmpy * 2 + dddfy;
-		var dfx:Number = cx1 * 0.3 + tmpx + dddfx * 0.16666667, dfy:Number = cy1 * 0.3 + tmpy + dddfy * 0.16666667;
+		/** Sets the control handle positions for an interpolation bezier curve used to transition from this keyframe to the next.
+		 * cx1 and cx2 are from 0 to 1, representing the percent of time between the two keyframes. cy1 and cy2 are the percent of
+		 * the difference between the keyframe's values. */
+		public function setCurve(frameIndex : int, cx1 : Number, cy1 : Number, cx2 : Number, cy2 : Number) : void {
+			var tmpx : Number = (-cx1 * 2 + cx2) * 0.03, tmpy : Number = (-cy1 * 2 + cy2) * 0.03;
+			var dddfx : Number = ((cx1 - cx2) * 3 + 1) * 0.006, dddfy : Number = ((cy1 - cy2) * 3 + 1) * 0.006;
+			var ddfx : Number = tmpx * 2 + dddfx, ddfy : Number = tmpy * 2 + dddfy;
+			var dfx : Number = cx1 * 0.3 + tmpx + dddfx * 0.16666667, dfy : Number = cy1 * 0.3 + tmpy + dddfy * 0.16666667;
 
-		var i:int = frameIndex * BEZIER_SIZE;
-		var curves:Vector.<Number> = this.curves;
-		curves[int(i++)] = BEZIER;
+			var i : int = frameIndex * BEZIER_SIZE;
+			var curves : Vector.<Number> = this.curves;
+			curves[int(i++)] = BEZIER;
 
-		var x:Number = dfx, y:Number = dfy;
-		for (var n:int = i + BEZIER_SIZE - 1; i < n; i += 2) {
-			curves[i] = x;
-			curves[int(i + 1)] = y;
-			dfx += ddfx;
-			dfy += ddfy;
-			ddfx += dddfx;
-			ddfy += dddfy;
-			x += dfx;
-			y += dfy;
+			var x : Number = dfx, y : Number = dfy;
+			for (var n : int = i + BEZIER_SIZE - 1; i < n; i += 2) {
+				curves[i] = x;
+				curves[int(i + 1)] = y;
+				dfx += ddfx;
+				dfy += ddfy;
+				ddfx += dddfx;
+				ddfy += dddfy;
+				x += dfx;
+				y += dfy;
+			}
 		}
-	}
 
-	public function getCurvePercent (frameIndex:int, percent:Number) : Number {
-		percent = MathUtils.clamp(percent, 0, 1);
-		var curves:Vector.<Number> = this.curves;
-		var i:int = frameIndex * BEZIER_SIZE;
-		var type:Number = curves[i];
-		if (type == LINEAR) return percent;
-		if (type == STEPPED) return 0;
-		i++;
-		var x:Number = 0;
-		for (var start:int = i, n:int = i + BEZIER_SIZE - 1; i < n; i += 2) {
-			x = curves[i];
-			if (x >= percent) {
-				var prevX:Number, prevY:Number;
-				if (i == start) {
-					prevX = 0;
-					prevY = 0;
-				} else {
-					prevX = curves[int(i - 2)];
-					prevY = curves[int(i - 1)];
+		public function getCurvePercent(frameIndex : int, percent : Number) : Number {
+			percent = MathUtils.clamp(percent, 0, 1);
+			var curves : Vector.<Number> = this.curves;
+			var i : int = frameIndex * BEZIER_SIZE;
+			var type : Number = curves[i];
+			if (type == LINEAR) return percent;
+			if (type == STEPPED) return 0;
+			i++;
+			var x : Number = 0;
+			for (var start : int = i, n : int = i + BEZIER_SIZE - 1; i < n; i += 2) {
+				x = curves[i];
+				if (x >= percent) {
+					var prevX : Number, prevY : Number;
+					if (i == start) {
+						prevX = 0;
+						prevY = 0;
+					} else {
+						prevX = curves[int(i - 2)];
+						prevY = curves[int(i - 1)];
+					}
+					return prevY + (curves[int(i + 1)] - prevY) * (percent - prevX) / (x - prevX);
 				}
-				return prevY + (curves[int(i + 1)] - prevY) * (percent - prevX) / (x - prevX);
 			}
+			var y : Number = curves[int(i - 1)];
+			return y + (1 - y) * (percent - x) / (1 - x); // Last point is 1,1.
 		}
-		var y:Number = curves[int(i - 1)];
-		return y + (1 - y) * (percent - x) / (1 - x); // Last point is 1,1.
 	}
-}
-
-}
+}

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

@@ -29,123 +29,122 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.attachments.Attachment;
-import spine.attachments.VertexAttachment;
-import spine.Event;
-import spine.Skeleton;
-import spine.Slot;
+	import spine.attachments.Attachment;
+	import spine.attachments.VertexAttachment;
+	import spine.Event;
+	import spine.Skeleton;
+	import spine.Slot;
 
-public class DeformTimeline extends CurveTimeline {
-	public var slotIndex:int;
-	public var frames:Vector.<Number>;
-	public var frameVertices:Vector.<Vector.<Number>>;
-	public var attachment:VertexAttachment;
+	public class DeformTimeline extends CurveTimeline {
+		public var slotIndex : int;
+		public var frames : Vector.<Number>;
+		public var frameVertices : Vector.<Vector.<Number>>;
+		public var attachment : VertexAttachment;
 
-	public function DeformTimeline (frameCount:int) {
-		super(frameCount);
-		frames = new Vector.<Number>(frameCount, true);
-		frameVertices = new Vector.<Vector.<Number>>(frameCount, true);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.deform.ordinal << 24) + slotIndex;
-	}
-
-	/** Sets the time and value of the specified keyframe. */
-	public function setFrame (frameIndex:int, time:Number, vertices:Vector.<Number>) : void {
-		frames[frameIndex] = time;
-		frameVertices[frameIndex] = vertices;
-	}
+		public function DeformTimeline(frameCount : int) {
+			super(frameCount);
+			frames = new Vector.<Number>(frameCount, true);
+			frameVertices = new Vector.<Vector.<Number>>(frameCount, true);
+		}
 
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		var slot:Slot = skeleton.slots[slotIndex];
-		var slotAttachment:Attachment = slot.attachment;
-		if (!(slotAttachment is VertexAttachment) || !(VertexAttachment(slotAttachment)).applyDeform(attachment)) return;
+		override public function getPropertyId() : int {
+			return (TimelineType.deform.ordinal << 24) + slotIndex;
+		}
 
-		var frames:Vector.<Number> = this.frames;
-		var verticesArray:Vector.<Number> = slot.attachmentVertices;
-		if (time < frames[0]) {
-			if (setupPose) verticesArray.length = 0;
-			return;
+		/** Sets the time and value of the specified keyframe. */
+		public function setFrame(frameIndex : int, time : Number, vertices : Vector.<Number>) : void {
+			frames[frameIndex] = time;
+			frameVertices[frameIndex] = vertices;
 		}
 
-		var frameVertices:Vector.<Vector.<Number>> = this.frameVertices;
-		var vertexCount:int = frameVertices[0].length;
-		
-		if (verticesArray.length != vertexCount) alpha = 1; // Don't mix from uninitialized slot vertices.
-		verticesArray.length = vertexCount;
-		var vertices:Vector.<Number> = verticesArray;
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var slot : Slot = skeleton.slots[slotIndex];
+			var slotAttachment : Attachment = slot.attachment;
+			if (!(slotAttachment is VertexAttachment) || !(VertexAttachment(slotAttachment)).applyDeform(attachment)) return;
+
+			var frames : Vector.<Number> = this.frames;
+			var verticesArray : Vector.<Number> = slot.attachmentVertices;
+			if (time < frames[0]) {
+				if (setupPose) verticesArray.length = 0;
+				return;
+			}
+
+			var frameVertices : Vector.<Vector.<Number>> = this.frameVertices;
+			var vertexCount : int = frameVertices[0].length;
+
+			if (verticesArray.length != vertexCount) alpha = 1; // Don't mix from uninitialized slot vertices.
+			verticesArray.length = vertexCount;
+			var vertices : Vector.<Number> = verticesArray;
+
+			var i : int, n : int;
+			var vertexAttachment : VertexAttachment;
+			var setupVertices : Vector.<Number>;
+			var setup : Number, prev : Number;
+			if (time >= frames[frames.length - 1]) { // Time is after last frame.
+				var lastVertices : Vector.<Number> = frameVertices[frames.length - 1];
+				if (alpha == 1) {
+					// Vertex positions or deform offsets, no alpha.
+					for (i = 0, n = vertexCount; i < n; i++)
+						vertices[i] = lastVertices[i];
+				} else if (setupPose) {
+					vertexAttachment = VertexAttachment(slotAttachment);
+					if (vertexAttachment.bones == null) {
+						// Unweighted vertex positions, with alpha.
+						setupVertices = vertexAttachment.vertices;
+						for (i = 0; i < vertexCount; i++) {
+							setup = setupVertices[i];
+							vertices[i] = setup + (lastVertices[i] - setup) * alpha;
+						}
+					} else {
+						// Weighted deform offsets, with alpha.
+						for (i = 0; i < vertexCount; i++)
+							vertices[i] = lastVertices[i] * alpha;
+					}
+				} else {
+					// Vertex positions or deform offsets, with alpha.
+					for (i = 0; i < vertexCount; i++)
+						vertices[i] += (lastVertices[i] - vertices[i]) * alpha;
+				}
+				return;
+			}
+
+			// Interpolate between the previous frame and the current frame.
+			var frame : int = Animation.binarySearch1(frames, time);
+			var prevVertices : Vector.<Number> = frameVertices[frame - 1];
+			var nextVertices : Vector.<Number> = frameVertices[frame];
+			var frameTime : Number = frames[frame];
+			var percent : Number = getCurvePercent(frame - 1, 1 - (time - frameTime) / (frames[frame - 1] - frameTime));
 
-		var i:int, n:int;
-		var vertexAttachment:VertexAttachment;
-		var setupVertices:Vector.<Number>;
-		var setup:Number, prev:Number;
-		if (time >= frames[frames.length - 1]) { // Time is after last frame.
-			var lastVertices:Vector.<Number> = frameVertices[frames.length - 1];
 			if (alpha == 1) {
 				// Vertex positions or deform offsets, no alpha.
-				for (i = 0, n = vertexCount; i < n; i++)
-					vertices[i] = lastVertices[i];
+				for (i = 0; i < vertexCount; i++) {
+					prev = prevVertices[i];
+					vertices[i] = prev + (nextVertices[i] - prev) * percent;
+				}
 			} else if (setupPose) {
 				vertexAttachment = VertexAttachment(slotAttachment);
 				if (vertexAttachment.bones == null) {
 					// Unweighted vertex positions, with alpha.
 					setupVertices = vertexAttachment.vertices;
 					for (i = 0; i < vertexCount; i++) {
+						prev = prevVertices[i];
 						setup = setupVertices[i];
-						vertices[i] = setup + (lastVertices[i] - setup) * alpha;
+						vertices[i] = setup + (prev + (nextVertices[i] - prev) * percent - setup) * alpha;
 					}
 				} else {
 					// Weighted deform offsets, with alpha.
-					for (i = 0; i < vertexCount; i++)
-						vertices[i] = lastVertices[i] * alpha;
+					for (i = 0; i < vertexCount; i++) {
+						prev = prevVertices[i];
+						vertices[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;
+					}
 				}
 			} else {
 				// Vertex positions or deform offsets, with alpha.
-				for (i = 0; i < vertexCount; i++)
-					vertices[i] += (lastVertices[i] - vertices[i]) * alpha;
-			}
-			return;
-		}
-
-		// Interpolate between the previous frame and the current frame.
-		var frame:int = Animation.binarySearch1(frames, time);
-		var prevVertices:Vector.<Number> = frameVertices[frame - 1];
-		var nextVertices:Vector.<Number> = frameVertices[frame];
-		var frameTime:Number = frames[frame];
-		var percent:Number = getCurvePercent(frame - 1, 1 - (time - frameTime) / (frames[frame - 1] - frameTime));
-
-		if (alpha == 1) {
-			// Vertex positions or deform offsets, no alpha.
-			for (i = 0; i < vertexCount; i++) {
-				prev = prevVertices[i];
-				vertices[i] = prev + (nextVertices[i] - prev) * percent;
-			}
-		} else if (setupPose) {
-			vertexAttachment = VertexAttachment(slotAttachment);
-			if (vertexAttachment.bones == null) {
-				// Unweighted vertex positions, with alpha.
-				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;
-				}
-			} else {
-				// Weighted deform offsets, with alpha.
 				for (i = 0; i < vertexCount; i++) {
 					prev = prevVertices[i];
-					vertices[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;
+					vertices[i] += (prev + (nextVertices[i] - prev) * percent - vertices[i]) * alpha;
 				}
 			}
-		} else {
-			// Vertex positions or deform offsets, with alpha.
-			for (i = 0; i < vertexCount; i++) {
-				prev = prevVertices[i];
-				vertices[i] += (prev + (nextVertices[i] - prev) * percent - vertices[i]) * alpha;
-			}
 		}
 	}
-}
-
-}
+}

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

@@ -29,68 +29,67 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Event;
-import spine.Skeleton;
-import spine.Slot;
+	import spine.Event;
+	import spine.Skeleton;
+	import spine.Slot;
 
-public class DrawOrderTimeline implements Timeline {
-	public var frames:Vector.<Number>; // time, ...
-	public var drawOrders:Vector.<Vector.<int>>;
+	public class DrawOrderTimeline implements Timeline {
+		public var frames : Vector.<Number>; // time, ...
+		public var drawOrders : Vector.<Vector.<int>>;
 
-	public function DrawOrderTimeline (frameCount:int) {
-		frames = new Vector.<Number>(frameCount, true);
-		drawOrders = new Vector.<Vector.<int>>(frameCount, true);
-	}
+		public function DrawOrderTimeline(frameCount : int) {
+			frames = new Vector.<Number>(frameCount, true);
+			drawOrders = new Vector.<Vector.<int>>(frameCount, true);
+		}
 
-	public function get frameCount () : int {
-		return frames.length;
-	}
-	
-	public function getPropertyId () : int {
-		return TimelineType.drawOrder.ordinal << 24;
-	}
+		public function get frameCount() : int {
+			return frames.length;
+		}
 
-	/** Sets the time and value of the specified keyframe. */
-	public function setFrame (frameIndex:int, time:Number, drawOrder:Vector.<int>) : void {
-		frames[frameIndex] = time;
-		drawOrders[frameIndex] = drawOrder;
-	}
+		public function getPropertyId() : int {
+			return TimelineType.drawOrder.ordinal << 24;
+		}
 
-	public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		if (mixingOut && setupPose) {
-			for (var ii:int = 0, n:int = skeleton.slots.length; ii < n; ii++)
-				skeleton.drawOrder[ii] = skeleton.slots[ii];
-			return;
+		/** Sets the time and value of the specified keyframe. */
+		public function setFrame(frameIndex : int, time : Number, drawOrder : Vector.<int>) : void {
+			frames[frameIndex] = time;
+			drawOrders[frameIndex] = drawOrder;
 		}
 
-		var drawOrder:Vector.<Slot> = skeleton.drawOrder;
-		var slots:Vector.<Slot> = skeleton.slots;
-		var slot:Slot;
-		var i:int = 0;
-		if (time < frames[0]) {
-			if (setupPose) {
-				for each (slot in slots)
-					drawOrder[i++] = slot;			
+		public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			if (mixingOut && setupPose) {
+				for (var ii : int = 0, n : int = skeleton.slots.length; ii < n; ii++)
+					skeleton.drawOrder[ii] = skeleton.slots[ii];
+				return;
+			}
+
+			var drawOrder : Vector.<Slot> = skeleton.drawOrder;
+			var slots : Vector.<Slot> = skeleton.slots;
+			var slot : Slot;
+			var i : int = 0;
+			if (time < frames[0]) {
+				if (setupPose) {
+					for each (slot in slots)
+						drawOrder[i++] = slot;
+				}
+				return;
 			}
-			return;
-		}
 
-		var frameIndex:int;
-		if (time >= frames[int(frames.length - 1)]) // Time is after last frame.
-			frameIndex = frames.length - 1;
-		else
-			frameIndex = Animation.binarySearch1(frames, time) - 1;
+			var frameIndex : int;
+			if (time >= frames[int(frames.length - 1)]) // Time is after last frame.
+				frameIndex = frames.length - 1;
+			else
+				frameIndex = Animation.binarySearch1(frames, time) - 1;
 
-		var drawOrderToSetupIndex:Vector.<int> = drawOrders[frameIndex];
-		i = 0;		
-		if (!drawOrderToSetupIndex) {
-			for each (slot in slots)
-				drawOrder[i++] = slot;
-		} else {
-			for each (var setupIndex:int in drawOrderToSetupIndex)
-				drawOrder[i++] = slots[setupIndex];
+			var drawOrderToSetupIndex : Vector.<int> = drawOrders[frameIndex];
+			i = 0;
+			if (!drawOrderToSetupIndex) {
+				for each (slot in slots)
+					drawOrder[i++] = slot;
+			} else {
+				for each (var setupIndex : int in drawOrderToSetupIndex)
+					drawOrder[i++] = slots[setupIndex];
+			}
 		}
 	}
-}
-
-}
+}

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

@@ -29,94 +29,94 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Event;
+	import spine.Event;
 
-public class EventQueue {
-	internal var objects:Vector.<Object> = new Vector.<Object>();
-	internal var animationState:AnimationState;
-	public var drainDisabled:Boolean;
+	public class EventQueue {
+		internal var objects : Vector.<Object> = new Vector.<Object>();
+		internal var animationState : AnimationState;
+		public var drainDisabled : Boolean;
 
-	public function EventQueue(animationState:AnimationState) {
-		this.animationState = animationState;
-	}
+		public function EventQueue(animationState : AnimationState) {
+			this.animationState = animationState;
+		}
 
-	public function start (entry:TrackEntry):void {
-		objects.push(EventType.start);
-		objects.push(entry);
-		animationState.animationsChanged = true;
-	}
+		public function start(entry : TrackEntry) : void {
+			objects.push(EventType.start);
+			objects.push(entry);
+			animationState.animationsChanged = true;
+		}
 
-	public function interrupt (entry:TrackEntry):void {
-		objects.push(EventType.interrupt);
-		objects.push(entry);
-	}
+		public function interrupt(entry : TrackEntry) : void {
+			objects.push(EventType.interrupt);
+			objects.push(entry);
+		}
 
-	public function end (entry:TrackEntry):void {
-		objects.push(EventType.end);
-		objects.push(entry);
-		animationState.animationsChanged = true;
-	}
+		public function end(entry : TrackEntry) : void {
+			objects.push(EventType.end);
+			objects.push(entry);
+			animationState.animationsChanged = true;
+		}
 
-	public function dispose (entry:TrackEntry):void {
-		objects.push(EventType.dispose);
-		objects.push(entry);
-	}
+		public function dispose(entry : TrackEntry) : void {
+			objects.push(EventType.dispose);
+			objects.push(entry);
+		}
 
-	public function complete (entry:TrackEntry):void {
-		objects.push(EventType.complete);
-		objects.push(entry);
-	}
+		public function complete(entry : TrackEntry) : void {
+			objects.push(EventType.complete);
+			objects.push(entry);
+		}
 
-	public function event (entry:TrackEntry, event:Event):void {
-		objects.push(EventType.event);
-		objects.push(entry);
-		objects.push(event);
-	}
+		public function event(entry : TrackEntry, event : Event) : void {
+			objects.push(EventType.event);
+			objects.push(entry);
+			objects.push(event);
+		}
 
-	public function drain ():void {
-		if (drainDisabled) return; // Not reentrant.
-		drainDisabled = true;
+		public function drain() : void {
+			if (drainDisabled) return; // Not reentrant.
+			drainDisabled = true;
 
-		var objects:Vector.<Object> = this.objects;		
-		for (var i:int = 0; i < objects.length; i += 2) {
-			var type:EventType = EventType(objects[i]);
-			var entry:TrackEntry = TrackEntry(objects[i + 1]);			
-			switch (type) {
-			case EventType.start:
-				entry.onStart.invoke(entry);
-				animationState.onStart.invoke(entry);				
-				break;
-			case EventType.interrupt:
-				entry.onInterrupt.invoke(entry);
-				animationState.onInterrupt.invoke(entry);
-				break;
-			case EventType.end:
-				entry.onEnd.invoke(entry);
-				animationState.onEnd.invoke(entry);
-				// Fall through.
-			case EventType.dispose:
-				entry.onDispose.invoke(entry);
-				animationState.onDispose.invoke(entry);
-				animationState.trackEntryPool.free(entry);
-				break;
-			case EventType.complete:
-				entry.onComplete.invoke(entry);
-				animationState.onComplete.invoke(entry);
-				break;
-			case EventType.event:
-				var event:Event = Event(objects[i++ + 2]);
-				entry.onEvent.invoke(entry, event);
-				animationState.onEvent.invoke(entry, event);
-				break;
+			var objects : Vector.<Object> = this.objects;
+			for (var i : int = 0; i < objects.length; i += 2) {
+				var type : EventType = EventType(objects[i]);
+				var entry : TrackEntry = TrackEntry(objects[i + 1]);
+				switch (type) {
+					case EventType.start:
+						entry.onStart.invoke(entry);
+						animationState.onStart.invoke(entry);
+						break;
+					case EventType.interrupt:
+						entry.onInterrupt.invoke(entry);
+						animationState.onInterrupt.invoke(entry);
+						break;
+					case EventType.end:
+						entry.onEnd.invoke(entry);
+						animationState.onEnd.invoke(entry);
+					// Fall through.
+					case EventType.dispose:
+						entry.onDispose.invoke(entry);
+						animationState.onDispose.invoke(entry);
+						animationState.trackEntryPool.free(entry);
+						break;
+					case EventType.complete:
+						entry.onComplete.invoke(entry);
+						animationState.onComplete.invoke(entry);
+						break;
+					case EventType.event:
+						var event : Event = Event(objects[i++ + 2]);
+						entry.onEvent.invoke(entry, event);
+						animationState.onEvent.invoke(entry, event);
+						break;
+				}
 			}
-		}
-		clear();
+			clear();
 
-		drainDisabled = false;
-	}
+			drainDisabled = false;
+		}
 
-	public function clear ():void {
-		objects.length = 0;
+		public function clear() : void {
+			objects.length = 0;
+		}
 	}
-}
-}
+}

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

@@ -29,57 +29,56 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Event;
-import spine.Skeleton;
+	import spine.Event;
+	import spine.Skeleton;
 
-public class EventTimeline implements Timeline {
-	public var frames:Vector.<Number>; // time, ...
-	public var events:Vector.<Event>;
+	public class EventTimeline implements Timeline {
+		public var frames : Vector.<Number>; // time, ...
+		public var events : Vector.<Event>;
 
-	public function EventTimeline (frameCount:int) {
-		frames = new Vector.<Number>(frameCount, true);
-		events = new Vector.<Event>(frameCount, true);
-	}
+		public function EventTimeline(frameCount : int) {
+			frames = new Vector.<Number>(frameCount, true);
+			events = new Vector.<Event>(frameCount, true);
+		}
 
-	public function get frameCount () : int {
-		return frames.length;
-	}
-	
-	public function getPropertyId () : int {
-		return TimelineType.event.ordinal << 24;
-	}
+		public function get frameCount() : int {
+			return frames.length;
+		}
 
-	/** Sets the time and value of the specified keyframe. */
-	public function setFrame (frameIndex:int, event:Event) : void {
-		frames[frameIndex] = event.time;
-		events[frameIndex] = event;
-	}
+		public function getPropertyId() : int {
+			return TimelineType.event.ordinal << 24;
+		}
 
-	/** Fires events for frames > lastTime and <= time. */
-	public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		if (!firedEvents) return;
+		/** Sets the time and value of the specified keyframe. */
+		public function setFrame(frameIndex : int, event : Event) : void {
+			frames[frameIndex] = event.time;
+			events[frameIndex] = event;
+		}
 
-		if (lastTime > time) { // Fire events after last time for looped animations.
-			apply(skeleton, lastTime, int.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
-			lastTime = -1;
-		} else if (lastTime >= frames[int(frameCount - 1)]) // Last time is after last frame.
-			return;
-		if (time < frames[0]) return; // Time is before first frame.
+		/** Fires events for frames > lastTime and <= time. */
+		public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			if (!firedEvents) return;
 
-		var frame:int;
-		if (lastTime < frames[0])
-			frame = 0;
-		else {
-			frame = Animation.binarySearch1(frames, lastTime);
-			var frameTime:Number = frames[frame];
-			while (frame > 0) { // Fire multiple events with the same frame.
-				if (frames[int(frame - 1)] != frameTime) break;
-				frame--;
+			if (lastTime > time) { // Fire events after last time for looped animations.
+				apply(skeleton, lastTime, int.MAX_VALUE, firedEvents, alpha, setupPose, mixingOut);
+				lastTime = -1;
+			} else if (lastTime >= frames[int(frameCount - 1)]) // Last time is after last frame.
+				return;
+			if (time < frames[0]) return; // Time is before first frame.
+
+			var frame : int;
+			if (lastTime < frames[0])
+				frame = 0;
+			else {
+				frame = Animation.binarySearch1(frames, lastTime);
+				var frameTime : Number = frames[frame];
+				while (frame > 0) { // Fire multiple events with the same frame.
+					if (frames[int(frame - 1)] != frameTime) break;
+					frame--;
+				}
 			}
+			for (; frame < frameCount && time >= frames[frame]; frame++)
+				firedEvents[firedEvents.length] = events[frame];
 		}
-		for (; frame < frameCount && time >= frames[frame]; frame++)
-			firedEvents[firedEvents.length] = events[frame];
 	}
-}
-
-}
+}

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

@@ -29,13 +29,12 @@
  *****************************************************************************/
 
 package spine.animation {
-
-public class EventType {
-	public static const start:EventType = new EventType();
-	public static const interrupt:EventType = new EventType();
-	public static const end:EventType = new EventType();
-	public static const dispose:EventType = new EventType();
-	public static const complete:EventType = new EventType();
-	public static const event:EventType = new EventType();
-}
-}
+	public class EventType {
+		public static const start : EventType = new EventType();
+		public static const interrupt : EventType = new EventType();
+		public static const end : EventType = new EventType();
+		public static const dispose : EventType = new EventType();
+		public static const complete : EventType = new EventType();
+		public static const event : EventType = new EventType();
+	}
+}

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

@@ -29,71 +29,68 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Event;
-import spine.IkConstraint;
-import spine.Skeleton;
+	import spine.Event;
+	import spine.IkConstraint;
+	import spine.Skeleton;
 
-public class IkConstraintTimeline extends CurveTimeline {
-	static public const ENTRIES:int = 3;
-	static internal const PREV_TIME:int = -3, PREV_MIX:int = -2, PREV_BEND_DIRECTION:int = -1;
-	static internal const MIX:int = 1, BEND_DIRECTION:int = 2;
+	public class IkConstraintTimeline extends CurveTimeline {
+		static public const ENTRIES : int = 3;
+		static internal const PREV_TIME : int = -3, PREV_MIX : int = -2, PREV_BEND_DIRECTION : int = -1;
+		static internal const MIX : int = 1, BEND_DIRECTION : int = 2;
+		public var ikConstraintIndex : int;
+		public var frames : Vector.<Number>; // time, mix, bendDirection, ...
 
-	public var ikConstraintIndex:int;
-	public var frames:Vector.<Number>; // time, mix, bendDirection, ...
+		public function IkConstraintTimeline(frameCount : int) {
+			super(frameCount);
+			frames = new Vector.<Number>(frameCount * ENTRIES, true);
+		}
 
-	public function IkConstraintTimeline (frameCount:int) {
-		super(frameCount);
-		frames = new Vector.<Number>(frameCount * ENTRIES, true);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.ikConstraint.ordinal << 24) + ikConstraintIndex;
-	}
+		override public function getPropertyId() : int {
+			return (TimelineType.ikConstraint.ordinal << 24) + ikConstraintIndex;
+		}
 
-	/** Sets the time, mix and bend direction of the specified keyframe. */
-	public function setFrame (frameIndex:int, time:Number, mix:Number, bendDirection:int) : void {
-		frameIndex *= ENTRIES;
-		frames[frameIndex] = time;
-		frames[int(frameIndex + MIX)] = mix;
-		frames[int(frameIndex + BEND_DIRECTION)] = bendDirection;
-	}
+		/** Sets the time, mix and bend direction of the specified keyframe. */
+		public function setFrame(frameIndex : int, time : Number, mix : Number, bendDirection : int) : void {
+			frameIndex *= ENTRIES;
+			frames[frameIndex] = time;
+			frames[int(frameIndex + MIX)] = mix;
+			frames[int(frameIndex + BEND_DIRECTION)] = bendDirection;
+		}
 
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		var constraint:IkConstraint = skeleton.ikConstraints[ikConstraintIndex];
-		if (time < frames[0]) {
-			if (setupPose) {
-				constraint.mix = constraint.data.mix;
-				constraint.bendDirection = constraint.data.bendDirection;
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var constraint : IkConstraint = skeleton.ikConstraints[ikConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.mix = constraint.data.mix;
+					constraint.bendDirection = constraint.data.bendDirection;
+				}
+				return;
 			}
-			return;
-		}
 
-		if (time >= frames[int(frames.length - ENTRIES)]) { // Time is after last frame.
-			if (setupPose) {
-				constraint.mix = constraint.data.mix + (frames[frames.length + PREV_MIX] - constraint.data.mix) * alpha;
-				constraint.bendDirection = mixingOut ? constraint.data.bendDirection
-					: int(frames[frames.length + PREV_BEND_DIRECTION]);
-			} else {
-				constraint.mix += (frames[frames.length + PREV_MIX] - constraint.mix) * alpha;
-				if (!mixingOut) constraint.bendDirection = int(frames[frames.length + PREV_BEND_DIRECTION]);
+			if (time >= frames[int(frames.length - ENTRIES)]) { // Time is after last frame.
+				if (setupPose) {
+					constraint.mix = constraint.data.mix + (frames[frames.length + PREV_MIX] - constraint.data.mix) * alpha;
+					constraint.bendDirection = mixingOut ? constraint.data.bendDirection : int(frames[frames.length + PREV_BEND_DIRECTION]);
+				} else {
+					constraint.mix += (frames[frames.length + PREV_MIX] - constraint.mix) * alpha;
+					if (!mixingOut) constraint.bendDirection = int(frames[frames.length + PREV_BEND_DIRECTION]);
+				}
+				return;
 			}
-			return;
-		}
 
-		// Interpolate between the previous frame and the current frame.
-		var frame:int = Animation.binarySearch(frames, time, ENTRIES);
-		var mix:Number = frames[int(frame + PREV_MIX)];
-		var frameTime:Number = frames[frame];
-		var percent:Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+			// Interpolate between the previous frame and the current frame.
+			var frame : int = Animation.binarySearch(frames, time, ENTRIES);
+			var mix : Number = frames[int(frame + PREV_MIX)];
+			var frameTime : Number = frames[frame];
+			var percent : Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
 
-		if (setupPose) {
-			constraint.mix = constraint.data.mix + (mix + (frames[frame + MIX] - mix) * percent - constraint.data.mix) * alpha;
-			constraint.bendDirection = mixingOut ? constraint.data.bendDirection : int(frames[frame + PREV_BEND_DIRECTION]);
-		} else {
-			constraint.mix += (mix + (frames[frame + MIX] - mix) * percent - constraint.mix) * alpha;
-			if (!mixingOut) constraint.bendDirection = int(frames[frame + PREV_BEND_DIRECTION]);
+			if (setupPose) {
+				constraint.mix = constraint.data.mix + (mix + (frames[frame + MIX] - mix) * percent - constraint.data.mix) * alpha;
+				constraint.bendDirection = mixingOut ? constraint.data.bendDirection : int(frames[frame + PREV_BEND_DIRECTION]);
+			} else {
+				constraint.mix += (mix + (frames[frame + MIX] - mix) * percent - constraint.mix) * alpha;
+				if (!mixingOut) constraint.bendDirection = int(frames[frame + PREV_BEND_DIRECTION]);
+			}
 		}
 	}
-}
-
-}
+}

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

@@ -30,34 +30,34 @@
 
 package spine.animation {
 	public class Listeners {
-		private var _listeners:Vector.<Function> = new Vector.<Function>();
+		private var _listeners : Vector.<Function> = new Vector.<Function>();
 
-		public function Listeners () {
+		public function Listeners() {
 		}
 
-		public function get listeners () : Vector.<Function> {
+		public function get listeners() : Vector.<Function> {
 			return _listeners;
 		}
 
-		public function add (listener:Function) : void {
+		public function add(listener : Function) : void {
 			if (listener == null)
 				throw new ArgumentError("listener cannot be null.");
-			var indexOf:int = _listeners.indexOf(listener);
+			var indexOf : int = _listeners.indexOf(listener);
 			if (indexOf == -1)
 				_listeners[_listeners.length] = listener;
 		}
 
-		public function remove (listener:Function) : void {
+		public function remove(listener : Function) : void {
 			if (listener == null)
 				throw new ArgumentError("listener cannot be null.");
-			var indexOf:int = _listeners.indexOf(listener);
+			var indexOf : int = _listeners.indexOf(listener);
 			if (indexOf != -1)
 				_listeners.splice(_listeners.indexOf(listener), 1);
 		}
 
-		public function invoke (... args:*) : void {
-			for each (var listener:Function in _listeners)
+		public function invoke(... args : *) : void {
+			for each (var listener : Function in _listeners)
 				listener.apply(null, args);
 		}
 	}
-}
+}

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

@@ -29,70 +29,67 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Event;
-import spine.Skeleton;
-import spine.PathConstraint;
+	import spine.Event;
+	import spine.Skeleton;
+	import spine.PathConstraint;
 
-public class PathConstraintMixTimeline extends CurveTimeline {
-	static public const ENTRIES:int = 3;
-	static internal const PREV_TIME:int = -3, PREV_ROTATE:int = -2, PREV_TRANSLATE:int = -1;
-	static internal const ROTATE:int = 1, TRANSLATE:int = 2;
+	public class PathConstraintMixTimeline extends CurveTimeline {
+		static public const ENTRIES : int = 3;
+		static internal const PREV_TIME : int = -3, PREV_ROTATE : int = -2, PREV_TRANSLATE : int = -1;
+		static internal const ROTATE : int = 1, TRANSLATE : int = 2;
+		public var pathConstraintIndex : int;
+		public var frames : Vector.<Number>; // time, rotate mix, translate mix, ...
 
-	public var pathConstraintIndex:int;
-
-	public var frames:Vector.<Number>; // time, rotate mix, translate mix, ...
+		public function PathConstraintMixTimeline(frameCount : int) {
+			super(frameCount);
+			frames = new Vector.<Number>(frameCount * ENTRIES, true);
+		}
 
-	public function PathConstraintMixTimeline (frameCount:int) {
-		super(frameCount);
-		frames = new Vector.<Number>(frameCount * ENTRIES, true);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.pathConstraintMix.ordinal << 24) + pathConstraintIndex;
-	}
+		override public function getPropertyId() : int {
+			return (TimelineType.pathConstraintMix.ordinal << 24) + pathConstraintIndex;
+		}
 
-	/** Sets the time and mixes of the specified keyframe. */
-	public function setFrame (frameIndex:int, time:Number, rotateMix:Number, translateMix:Number) : void {
-		frameIndex *= ENTRIES;
-		frames[frameIndex] = time;
-		frames[frameIndex + ROTATE] = rotateMix;
-		frames[frameIndex + TRANSLATE] = translateMix;
-	}
+		/** Sets the time and mixes of the specified keyframe. */
+		public function setFrame(frameIndex : int, time : Number, rotateMix : Number, translateMix : Number) : void {
+			frameIndex *= ENTRIES;
+			frames[frameIndex] = time;
+			frames[frameIndex + ROTATE] = rotateMix;
+			frames[frameIndex + TRANSLATE] = translateMix;
+		}
 
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {		
-		var constraint:PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
-		if (time < frames[0]) {
-			if (setupPose) {
-				constraint.rotateMix = constraint.data.rotateMix;
-				constraint.translateMix = constraint.data.translateMix;
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var constraint : PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					constraint.rotateMix = constraint.data.rotateMix;
+					constraint.translateMix = constraint.data.translateMix;
+				}
+				return;
 			}
-			return;
-		}
 
-		var rotate:Number, translate:Number;
-		if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
-			rotate = frames[frames.length + PREV_ROTATE];
-			translate = frames[frames.length + PREV_TRANSLATE];
-		} else {
-			// Interpolate between the previous frame and the current frame.
-			var frame:int = Animation.binarySearch(frames, time, ENTRIES);
-			rotate = frames[frame + PREV_ROTATE];
-			translate = frames[frame + PREV_TRANSLATE];
-			var frameTime:Number = frames[frame];
-			var percent:Number = getCurvePercent(frame / ENTRIES - 1,
-				1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+			var rotate : Number, translate : Number;
+			if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
+				rotate = frames[frames.length + PREV_ROTATE];
+				translate = frames[frames.length + PREV_TRANSLATE];
+			} else {
+				// Interpolate between the previous frame and the current frame.
+				var frame : int = Animation.binarySearch(frames, time, ENTRIES);
+				rotate = frames[frame + PREV_ROTATE];
+				translate = frames[frame + PREV_TRANSLATE];
+				var frameTime : Number = frames[frame];
+				var percent : Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
 
-			rotate += (frames[frame + ROTATE] - rotate) * percent;
-			translate += (frames[frame + TRANSLATE] - translate) * percent;
-		}
+				rotate += (frames[frame + ROTATE] - rotate) * percent;
+				translate += (frames[frame + TRANSLATE] - translate) * percent;
+			}
 
-		if (setupPose) {
-			constraint.rotateMix = constraint.data.rotateMix + (rotate - constraint.data.rotateMix) * alpha;
-			constraint.translateMix = constraint.data.translateMix + (translate - constraint.data.translateMix) * alpha;
-		} else {
-			constraint.rotateMix += (rotate - constraint.rotateMix) * alpha;
-			constraint.translateMix += (translate - constraint.translateMix) * alpha;
+			if (setupPose) {
+				constraint.rotateMix = constraint.data.rotateMix + (rotate - constraint.data.rotateMix) * alpha;
+				constraint.translateMix = constraint.data.translateMix + (translate - constraint.data.translateMix) * alpha;
+			} else {
+				constraint.rotateMix += (rotate - constraint.rotateMix) * alpha;
+				constraint.translateMix += (translate - constraint.translateMix) * alpha;
+			}
 		}
 	}
-}
-}
+}

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

@@ -29,59 +29,56 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.PathConstraint;
-import spine.Event;
-import spine.Skeleton;
+	import spine.PathConstraint;
+	import spine.Event;
+	import spine.Skeleton;
 
-public class PathConstraintPositionTimeline extends CurveTimeline {
-	static public const ENTRIES:int = 2;
-	static internal const PREV_TIME:int = -2, PREV_VALUE:int = -1;
-	static internal const VALUE:int = 1;
+	public class PathConstraintPositionTimeline extends CurveTimeline {
+		static public const ENTRIES : int = 2;
+		static internal const PREV_TIME : int = -2, PREV_VALUE : int = -1;
+		static internal const VALUE : int = 1;
+		public var pathConstraintIndex : int;
+		public var frames : Vector.<Number>; // time, position, ...
 
-	public var pathConstraintIndex:int;
-
-	public var frames:Vector.<Number>; // time, position, ...
-
-	public function PathConstraintPositionTimeline (frameCount:int) {
-		super(frameCount);
-		frames = new Vector.<Number>(frameCount * ENTRIES, true);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.pathConstraintPosition.ordinal << 24) + pathConstraintIndex;
-	}
+		public function PathConstraintPositionTimeline(frameCount : int) {
+			super(frameCount);
+			frames = new Vector.<Number>(frameCount * ENTRIES, true);
+		}
 
-	/** Sets the time and value of the specified keyframe. */
-	public function setFrame (frameIndex:int, time:Number, value:Number) : void {
-		frameIndex *= ENTRIES;
-		frames[frameIndex] = time;
-		frames[frameIndex + VALUE] = value;
-	}
+		override public function getPropertyId() : int {
+			return (TimelineType.pathConstraintPosition.ordinal << 24) + pathConstraintIndex;
+		}
 
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {		
-		var constraint:PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
-		if (time < frames[0]) {
-			if (setupPose) constraint.position = constraint.data.position;
-			return;
+		/** Sets the time and value of the specified keyframe. */
+		public function setFrame(frameIndex : int, time : Number, value : Number) : void {
+			frameIndex *= ENTRIES;
+			frames[frameIndex] = time;
+			frames[frameIndex + VALUE] = value;
 		}
 
-		var position:Number;
-		if (time >= frames[frames.length - ENTRIES]) // Time is after last frame.
-			position = frames[frames.length + PREV_VALUE];
-		else {
-			// Interpolate between the previous frame and the current frame.
-			var frame:int = Animation.binarySearch(frames, time, ENTRIES);
-			position = frames[frame + PREV_VALUE];
-			var frameTime:Number = frames[frame];
-			var percent:Number = getCurvePercent(frame / ENTRIES - 1,
-				1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var constraint : PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) constraint.position = constraint.data.position;
+				return;
+			}
+
+			var position : Number;
+			if (time >= frames[frames.length - ENTRIES]) // Time is after last frame.
+				position = frames[frames.length + PREV_VALUE];
+			else {
+				// Interpolate between the previous frame and the current frame.
+				var frame : int = Animation.binarySearch(frames, time, ENTRIES);
+				position = frames[frame + PREV_VALUE];
+				var frameTime : Number = frames[frame];
+				var percent : Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
 
-			position += (frames[frame + VALUE] - position) * percent;
+				position += (frames[frame + VALUE] - position) * percent;
+			}
+			if (setupPose)
+				constraint.position = constraint.data.position + (position - constraint.data.position) * alpha;
+			else
+				constraint.position += (position - constraint.position) * alpha;
 		}
-		if (setupPose)
-			constraint.position = constraint.data.position + (position - constraint.data.position) * alpha;
-		else
-			constraint.position += (position - constraint.position) * alpha;
 	}
-}
-}
+}

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

@@ -29,44 +29,43 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Skeleton;
-import spine.Event;
-import spine.PathConstraint;
+	import spine.Skeleton;
+	import spine.Event;
+	import spine.PathConstraint;
 
-public class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline {
-	public function PathConstraintSpacingTimeline (frameCount:int) {
-		super(frameCount);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.pathConstraintSpacing.ordinal << 24) + pathConstraintIndex;
-	}
+	public class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline {
+		public function PathConstraintSpacingTimeline(frameCount : int) {
+			super(frameCount);
+		}
 
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		var constraint:PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
-		if (time < frames[0]) {
-			if (setupPose) constraint.spacing = constraint.data.spacing;
-			return;
+		override public function getPropertyId() : int {
+			return (TimelineType.pathConstraintSpacing.ordinal << 24) + pathConstraintIndex;
 		}
 
-		var spacing:Number;
-		if (time >= frames[frames.length - ENTRIES]) // Time is after last frame.
-			spacing = frames[frames.length + PREV_VALUE];
-		else {
-			// Interpolate between the previous frame and the current frame.
-			var frame:int = Animation.binarySearch(frames, time, ENTRIES);
-			spacing = frames[frame + PREV_VALUE];
-			var frameTime:Number = frames[frame];
-			var percent:Number = getCurvePercent(frame / ENTRIES - 1,
-				1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var constraint : PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
+			if (time < frames[0]) {
+				if (setupPose) constraint.spacing = constraint.data.spacing;
+				return;
+			}
 
-			spacing += (frames[frame + VALUE] - spacing) * percent;
-		}
+			var spacing : Number;
+			if (time >= frames[frames.length - ENTRIES]) // Time is after last frame.
+				spacing = frames[frames.length + PREV_VALUE];
+			else {
+				// Interpolate between the previous frame and the current frame.
+				var frame : int = Animation.binarySearch(frames, time, ENTRIES);
+				spacing = frames[frame + PREV_VALUE];
+				var frameTime : Number = frames[frame];
+				var percent : Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+
+				spacing += (frames[frame + VALUE] - spacing) * percent;
+			}
 
-		if (setupPose)
-			constraint.spacing = constraint.data.spacing + (spacing - constraint.data.spacing) * alpha;
-		else
-			constraint.spacing += (spacing - constraint.spacing) * alpha;
+			if (setupPose)
+				constraint.spacing = constraint.data.spacing + (spacing - constraint.data.spacing) * alpha;
+			else
+				constraint.spacing += (spacing - constraint.spacing) * alpha;
+		}
 	}
-}
-}
+}

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

@@ -29,73 +29,71 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Bone;
-import spine.Event;
-import spine.Skeleton;
+	import spine.Bone;
+	import spine.Event;
+	import spine.Skeleton;
 
-public class RotateTimeline extends CurveTimeline {
-	static public const ENTRIES:int = 2;
-	static public const PREV_TIME:int = -2, PREV_ROTATION:int = -1;
-	static public const ROTATION:int = 1;
+	public class RotateTimeline extends CurveTimeline {
+		static public const ENTRIES : int = 2;
+		static public const PREV_TIME : int = -2, PREV_ROTATION : int = -1;
+		static public const ROTATION : int = 1;
+		public var boneIndex : int;
+		public var frames : Vector.<Number>; // time, value, ...
 
-	public var boneIndex:int;
-	public var frames:Vector.<Number>; // time, value, ...
-
-	public function RotateTimeline (frameCount:int) {
-		super(frameCount);
-		frames = new Vector.<Number>(frameCount * 2, true);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.rotate.ordinal << 24) + boneIndex;
-	}
+		public function RotateTimeline(frameCount : int) {
+			super(frameCount);
+			frames = new Vector.<Number>(frameCount * 2, true);
+		}
 
-	/** Sets the time and angle of the specified keyframe. */
-	public function setFrame (frameIndex:int, time:Number, degrees:Number) : void {
-		frameIndex <<= 1;
-		frames[frameIndex] = time;
-		frames[int(frameIndex + ROTATION)] = degrees;
-	}
-                    
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {			
-		var frames:Vector.<Number> = this.frames;		
+		override public function getPropertyId() : int {
+			return (TimelineType.rotate.ordinal << 24) + boneIndex;
+		}
 
-		var bone:Bone = skeleton.bones[boneIndex];
-		var r:Number;
-		if (time < frames[0]) {
-			if (setupPose) bone.rotation = bone.data.rotation;
-			return;
+		/** Sets the time and angle of the specified keyframe. */
+		public function setFrame(frameIndex : int, time : Number, degrees : Number) : void {
+			frameIndex <<= 1;
+			frames[frameIndex] = time;
+			frames[int(frameIndex + ROTATION)] = degrees;
 		}
 
-		if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
-			if (setupPose)
-				bone.rotation = bone.data.rotation + frames[frames.length + PREV_ROTATION] * alpha;
-			else {
-				r = bone.data.rotation + frames[frames.length + PREV_ROTATION] - bone.rotation;
-				r -= (16384 - int((16384.499999999996 - r / 360))) * 360; // Wrap within -180 and 180.
-				bone.rotation += r * alpha;
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var frames : Vector.<Number> = this.frames;
+
+			var bone : Bone = skeleton.bones[boneIndex];
+			var r : Number;
+			if (time < frames[0]) {
+				if (setupPose) bone.rotation = bone.data.rotation;
+				return;
+			}
+
+			if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
+				if (setupPose)
+					bone.rotation = bone.data.rotation + frames[frames.length + PREV_ROTATION] * alpha;
+				else {
+					r = bone.data.rotation + frames[frames.length + PREV_ROTATION] - bone.rotation;
+					r -= (16384 - int((16384.499999999996 - r / 360))) * 360; // Wrap within -180 and 180.
+					bone.rotation += r * alpha;
+				}
+				return;
 			}
-			return;
-		}
 
-		// Interpolate between the previous frame and the current frame.
-		var frame:int = Animation.binarySearch(frames, time, ENTRIES);
-		var prevRotation:Number = frames[frame + PREV_ROTATION];
-		var frameTime:Number = frames[frame];
-		var percent:Number = getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+			// Interpolate between the previous frame and the current frame.
+			var frame : int = Animation.binarySearch(frames, time, ENTRIES);
+			var prevRotation : Number = frames[frame + PREV_ROTATION];
+			var frameTime : Number = frames[frame];
+			var percent : Number = getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
 
-		r = frames[frame + ROTATION] - prevRotation;
-		r -= (16384 - int((16384.499999999996 - r / 360))) * 360;
-		r = prevRotation + r * percent;
-		if (setupPose) {
-			r -= (16384 - int((16384.499999999996 - r / 360))) * 360;
-			bone.rotation = bone.data.rotation + r * alpha;
-		} else {
-			r = bone.data.rotation + r - bone.rotation;
+			r = frames[frame + ROTATION] - prevRotation;
 			r -= (16384 - int((16384.499999999996 - r / 360))) * 360;
-			bone.rotation += r * alpha;
+			r = prevRotation + r * percent;
+			if (setupPose) {
+				r -= (16384 - int((16384.499999999996 - r / 360))) * 360;
+				bone.rotation = bone.data.rotation + r * alpha;
+			} else {
+				r = bone.data.rotation + r - bone.rotation;
+				r -= (16384 - int((16384.499999999996 - r / 360))) * 360;
+				bone.rotation += r * alpha;
+			}
 		}
 	}
-}
-
-}
+}

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

@@ -29,72 +29,70 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.MathUtils;
-import spine.Bone;
-import spine.Event;
-import spine.Skeleton;
+	import spine.MathUtils;
+	import spine.Bone;
+	import spine.Event;
+	import spine.Skeleton;
 
-public class ScaleTimeline extends TranslateTimeline {
-	public function ScaleTimeline (frameCount:int) {
-		super(frameCount);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.scale.ordinal << 24) + boneIndex;
-	}
+	public class ScaleTimeline extends TranslateTimeline {
+		public function ScaleTimeline(frameCount : int) {
+			super(frameCount);
+		}
 
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		var frames:Vector.<Number> = this.frames;
-		var bone:Bone = skeleton.bones[boneIndex];
-		
-		if (time < frames[0]) {
-			if (setupPose) {
-				bone.scaleX = bone.data.scaleX;
-				bone.scaleY = bone.data.scaleY;	
-			}
-			return;
+		override public function getPropertyId() : int {
+			return (TimelineType.scale.ordinal << 24) + boneIndex;
 		}
 
-		var x:Number, y:Number;
-		if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
-			x = frames[frames.length + PREV_X] * bone.data.scaleX;
-			y = frames[frames.length + PREV_Y] * bone.data.scaleY;
-		} else {
-			// Interpolate between the previous frame and the current frame.
-			var frame:int = Animation.binarySearch(frames, time, ENTRIES);
-			x = frames[frame + PREV_X];
-			y = frames[frame + PREV_Y];
-			var frameTime:Number = frames[frame];
-			var percent:Number = getCurvePercent(frame / ENTRIES - 1,
-				1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var frames : Vector.<Number> = this.frames;
+			var bone : Bone = skeleton.bones[boneIndex];
 
-			x = (x + (frames[frame + X] - x) * percent) * bone.data.scaleX;
-			y = (y + (frames[frame + Y] - y) * percent) * bone.data.scaleY;
-		}
-		if (alpha == 1) {
-			bone.scaleX = x;
-			bone.scaleY = y;
-		} else {
-			var bx:Number, by:Number;
-			if (setupPose) {
-				bx = bone.data.scaleX;
-				by = bone.data.scaleY;
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.scaleX = bone.data.scaleX;
+					bone.scaleY = bone.data.scaleY;
+				}
+				return;
+			}
+
+			var x : Number, y : Number;
+			if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
+				x = frames[frames.length + PREV_X] * bone.data.scaleX;
+				y = frames[frames.length + PREV_Y] * bone.data.scaleY;
 			} else {
-				bx = bone.scaleX;
-				by = bone.scaleY;
+				// Interpolate between the previous frame and the current frame.
+				var frame : int = Animation.binarySearch(frames, time, ENTRIES);
+				x = frames[frame + PREV_X];
+				y = frames[frame + PREV_Y];
+				var frameTime : Number = frames[frame];
+				var percent : Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+
+				x = (x + (frames[frame + X] - x) * percent) * bone.data.scaleX;
+				y = (y + (frames[frame + Y] - y) * percent) * bone.data.scaleY;
 			}
-			// Mixing out uses sign of setup or current pose, else use sign of key.
-			if (mixingOut) {
-				x = Math.abs(x) * MathUtils.signum(bx);
-				y = Math.abs(y) * MathUtils.signum(by);
+			if (alpha == 1) {
+				bone.scaleX = x;
+				bone.scaleY = y;
 			} else {
-				bx = Math.abs(bx) * MathUtils.signum(x);
-				by = Math.abs(by) * MathUtils.signum(y);
+				var bx : Number, by : Number;
+				if (setupPose) {
+					bx = bone.data.scaleX;
+					by = bone.data.scaleY;
+				} else {
+					bx = bone.scaleX;
+					by = bone.scaleY;
+				}
+				// Mixing out uses sign of setup or current pose, else use sign of key.
+				if (mixingOut) {
+					x = Math.abs(x) * MathUtils.signum(bx);
+					y = Math.abs(y) * MathUtils.signum(by);
+				} else {
+					bx = Math.abs(bx) * MathUtils.signum(x);
+					by = Math.abs(by) * MathUtils.signum(y);
+				}
+				bone.scaleX = bx + (x - bx) * alpha;
+				bone.scaleY = by + (y - by) * alpha;
 			}
-			bone.scaleX = bx + (x - bx) * alpha;
-			bone.scaleY = by + (y - by) * alpha;
 		}
 	}
-}
-
-}
+}

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

@@ -29,55 +29,53 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Event;
-import spine.Skeleton;
-import spine.Bone;
+	import spine.Event;
+	import spine.Skeleton;
+	import spine.Bone;
 
-public class ShearTimeline extends TranslateTimeline {
-	public function ShearTimeline (frameCount:int) {
-		super(frameCount);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.shear.ordinal << 24) + boneIndex;
-	}
+	public class ShearTimeline extends TranslateTimeline {
+		public function ShearTimeline(frameCount : int) {
+			super(frameCount);
+		}
 
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		var frames:Vector.<Number> = this.frames;		
-		var bone:Bone = skeleton.bones[boneIndex];
-		
-		if (time < frames[0]) {
-			if (setupPose) {
-				bone.shearX = bone.data.shearX;
-				bone.shearY = bone.data.shearY;
-			}
-			return;
+		override public function getPropertyId() : int {
+			return (TimelineType.shear.ordinal << 24) + boneIndex;
 		}
 
-		var x:Number, y:Number;
-		if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
-			x = frames[frames.length + PREV_X];
-			y = frames[frames.length + PREV_Y];
-		} else {
-			// Interpolate between the previous frame and the current frame.
-			var frame:int = Animation.binarySearch(frames, time, ENTRIES);
-			x = frames[frame + PREV_X];
-			y = frames[frame + PREV_Y];
-			var frameTime:Number = frames[frame];
-			var percent:Number = getCurvePercent(frame / ENTRIES - 1,
-				1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var frames : Vector.<Number> = this.frames;
+			var bone : Bone = skeleton.bones[boneIndex];
 
-			x = x + (frames[frame + X] - x) * percent;
-			y = y + (frames[frame + Y] - y) * percent;
-		}
-		if (setupPose) {
-			bone.shearX = bone.data.shearX + x * alpha;
-			bone.shearY = bone.data.shearY + y * alpha;
-		} else {
-			bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha;
-			bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha;
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.shearX = bone.data.shearX;
+					bone.shearY = bone.data.shearY;
+				}
+				return;
+			}
+
+			var x : Number, y : Number;
+			if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
+				x = frames[frames.length + PREV_X];
+				y = frames[frames.length + PREV_Y];
+			} else {
+				// Interpolate between the previous frame and the current frame.
+				var frame : int = Animation.binarySearch(frames, time, ENTRIES);
+				x = frames[frame + PREV_X];
+				y = frames[frame + PREV_Y];
+				var frameTime : Number = frames[frame];
+				var percent : Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+
+				x = x + (frames[frame + X] - x) * percent;
+				y = y + (frames[frame + Y] - y) * percent;
+			}
+			if (setupPose) {
+				bone.shearX = bone.data.shearX + x * alpha;
+				bone.shearY = bone.data.shearY + y * alpha;
+			} else {
+				bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha;
+				bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha;
+			}
 		}
 	}
-}
-
-}
+}

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

@@ -29,14 +29,13 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Event;
-import spine.Skeleton;
+	import spine.Event;
+	import spine.Skeleton;
 
-public interface Timeline {
-	/** Sets the value(s) for the specified time. */
-	function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void;
-	
-	function getPropertyId() : int;
-}
+	public interface Timeline {
+		/** Sets the value(s) for the specified time. */
+		function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void;
 
-}
+		function getPropertyId() : int;
+	}
+}

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

@@ -29,29 +29,27 @@
  *****************************************************************************/
 
 package spine.animation {
+	public class TimelineType {
+		public var ordinal : int;
 
-public class TimelineType {
-	public var ordinal:int;
-	
-	public function TimelineType(order:int) {
-		this.ordinal = order;
-	}
-	
-	public static const rotate:TimelineType = new TimelineType(0);
-	public static const translate:TimelineType = new TimelineType(1);
-	public static const scale:TimelineType = new TimelineType(2);
-	public static const shear:TimelineType = new TimelineType(3);
-	public static const attachment:TimelineType = new TimelineType(4);
-	public static const color:TimelineType = new TimelineType(5);
-	public static const deform:TimelineType = new TimelineType(6);
-	public static const event:TimelineType = new TimelineType(7);
-	public static const drawOrder:TimelineType = new TimelineType(8);
-	public static const ikConstraint:TimelineType = new TimelineType(9);
-	public static const transformConstraint:TimelineType = new TimelineType(10);
-	public static const pathConstraintPosition:TimelineType = new TimelineType(11);
-	public static const pathConstraintSpacing:TimelineType = new TimelineType(12);
-	public static const pathConstraintMix:TimelineType = new TimelineType(13);
-	public static const twoColor:TimelineType = new TimelineType(14);
-}
+		public function TimelineType(order : int) {
+			this.ordinal = order;
+		}
 
-}
+		public static const rotate : TimelineType = new TimelineType(0);
+		public static const translate : TimelineType = new TimelineType(1);
+		public static const scale : TimelineType = new TimelineType(2);
+		public static const shear : TimelineType = new TimelineType(3);
+		public static const attachment : TimelineType = new TimelineType(4);
+		public static const color : TimelineType = new TimelineType(5);
+		public static const deform : TimelineType = new TimelineType(6);
+		public static const event : TimelineType = new TimelineType(7);
+		public static const drawOrder : TimelineType = new TimelineType(8);
+		public static const ikConstraint : TimelineType = new TimelineType(9);
+		public static const transformConstraint : TimelineType = new TimelineType(10);
+		public static const pathConstraintPosition : TimelineType = new TimelineType(11);
+		public static const pathConstraintSpacing : TimelineType = new TimelineType(12);
+		public static const pathConstraintMix : TimelineType = new TimelineType(13);
+		public static const twoColor : TimelineType = new TimelineType(14);
+	}
+}

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

@@ -29,54 +29,54 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Poolable;
+	import spine.Poolable;
 
-public class TrackEntry implements Poolable {
-	public var animation:Animation;
-	public var next:TrackEntry, mixingFrom:TrackEntry;
-	public var onStart:Listeners = new Listeners();
-	public var onInterrupt:Listeners = new Listeners();
-	public var onEnd:Listeners = new Listeners();
-	public var onDispose:Listeners = new Listeners();
-	public var onComplete:Listeners = new Listeners();
-	public var onEvent:Listeners = new Listeners();
-	public var trackIndex:int;
-	public var loop:Boolean;
-	public var eventThreshold:Number, attachmentThreshold:Number, drawOrderThreshold:Number;
-	public var animationStart:Number, animationEnd:Number, animationLast:Number, nextAnimationLast:Number;
-	public var delay:Number, trackTime:Number, trackLast:Number, nextTrackLast:Number, trackEnd:Number, timeScale:Number;
-	public var alpha:Number, mixTime:Number, mixDuration:Number, mixAlpha:Number;
-	public var timelinesFirst:Vector.<Boolean> = new Vector.<Boolean>();
-	public var timelinesRotation:Vector.<Number> = new Vector.<Number>();
-	
-	public function TrackEntry () {		
-	}
-	
-	public function getAnimationTime():Number {
-		if (loop) {
-			var duration:Number = animationEnd - animationStart;
-			if (duration == 0) return animationStart;
-			return (trackTime % duration) + animationStart;
+	public class TrackEntry implements Poolable {
+		public var animation : Animation;
+		public var next : TrackEntry, mixingFrom : TrackEntry;
+		public var onStart : Listeners = new Listeners();
+		public var onInterrupt : Listeners = new Listeners();
+		public var onEnd : Listeners = new Listeners();
+		public var onDispose : Listeners = new Listeners();
+		public var onComplete : Listeners = new Listeners();
+		public var onEvent : Listeners = new Listeners();
+		public var trackIndex : int;
+		public var loop : Boolean;
+		public var eventThreshold : Number, attachmentThreshold : Number, drawOrderThreshold : Number;
+		public var animationStart : Number, animationEnd : Number, animationLast : Number, nextAnimationLast : Number;
+		public var delay : Number, trackTime : Number, trackLast : Number, nextTrackLast : Number, trackEnd : Number, timeScale : Number;
+		public var alpha : Number, mixTime : Number, mixDuration : Number, mixAlpha : Number;
+		public var timelinesFirst : Vector.<Boolean> = new Vector.<Boolean>();
+		public var timelinesRotation : Vector.<Number> = new Vector.<Number>();
+
+		public function TrackEntry() {
+		}
+
+		public function getAnimationTime() : Number {
+			if (loop) {
+				var duration : Number = animationEnd - animationStart;
+				if (duration == 0) return animationStart;
+				return (trackTime % duration) + animationStart;
+			}
+			return Math.min(trackTime + animationStart, animationEnd);
+		}
+
+		public function reset() : void {
+			next = null;
+			mixingFrom = null;
+			animation = null;
+			onStart.listeners.length = 0;
+			onInterrupt.listeners.length = 0;
+			onEnd.listeners.length = 0;
+			onDispose.listeners.length = 0;
+			onComplete.listeners.length = 0;
+			onEvent.listeners.length = 0;
+			timelinesFirst.length = 0;
+			timelinesRotation.length = 0;
+		}
+
+		public function resetRotationDirection() : void {
+			timelinesRotation.length = 0;
 		}
-		return Math.min(trackTime + animationStart, animationEnd);
-	}
-	
-	public function reset ():void {
-		next = null;
-		mixingFrom = null;
-		animation = null;
-		onStart.listeners.length = 0;
-		onInterrupt.listeners.length = 0;
-		onEnd.listeners.length = 0;
-		onDispose.listeners.length = 0;
-		onComplete.listeners.length = 0;
-		onEvent.listeners.length = 0;
-		timelinesFirst.length = 0;
-		timelinesRotation.length = 0;
-	}
-	
-	public function resetRotationDirection ():void {
-		timelinesRotation.length = 0;
 	}
-}
-}
+}

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

@@ -29,89 +29,87 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.TransformConstraintData;
-import spine.Event;
-import spine.Skeleton;
-import spine.TransformConstraint;
+	import spine.TransformConstraintData;
+	import spine.Event;
+	import spine.Skeleton;
+	import spine.TransformConstraint;
 
-public class TransformConstraintTimeline extends CurveTimeline {
-	static public const ENTRIES:int = 5;
-	static internal const PREV_TIME:int = -5, PREV_ROTATE:int = -4, PREV_TRANSLATE:int = -3, PREV_SCALE:int = -2, PREV_SHEAR:int = -1;
-	static internal const ROTATE:int = 1, TRANSLATE:int = 2, SCALE:int = 3, SHEAR:int = 4;
+	public class TransformConstraintTimeline extends CurveTimeline {
+		static public const ENTRIES : int = 5;
+		static internal const PREV_TIME : int = -5, PREV_ROTATE : int = -4, PREV_TRANSLATE : int = -3, PREV_SCALE : int = -2, PREV_SHEAR : int = -1;
+		static internal const ROTATE : int = 1, TRANSLATE : int = 2, SCALE : int = 3, SHEAR : int = 4;
+		public var transformConstraintIndex : int;
+		public var frames : Vector.<Number>; // time, rotate mix, translate mix, scale mix, shear mix, ...
 
-	public var transformConstraintIndex:int;
-	public var frames:Vector.<Number>; // time, rotate mix, translate mix, scale mix, shear mix, ...
+		public function TransformConstraintTimeline(frameCount : int) {
+			super(frameCount);
+			frames = new Vector.<Number>(frameCount * ENTRIES, true);
+		}
 
-	public function TransformConstraintTimeline (frameCount:int) {
-		super(frameCount);
-		frames = new Vector.<Number>(frameCount * ENTRIES, true);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.transformConstraint.ordinal << 24) + transformConstraintIndex;
-	}
+		override public function getPropertyId() : int {
+			return (TimelineType.transformConstraint.ordinal << 24) + transformConstraintIndex;
+		}
 
-	/** Sets the time and mixes of the specified keyframe. */
-	public function setFrame (frameIndex:int, time:Number, rotateMix:Number, translateMix:Number, scaleMix:Number, shearMix:Number) : void {
-		frameIndex *= ENTRIES;
-		frames[frameIndex] = time;
-		frames[frameIndex + ROTATE] = rotateMix;
-		frames[frameIndex + TRANSLATE] = translateMix;
-		frames[frameIndex + SCALE] = scaleMix;
-		frames[frameIndex + SHEAR] = shearMix;
-	}
+		/** Sets the time and mixes of the specified keyframe. */
+		public function setFrame(frameIndex : int, time : Number, rotateMix : Number, translateMix : Number, scaleMix : Number, shearMix : Number) : void {
+			frameIndex *= ENTRIES;
+			frames[frameIndex] = time;
+			frames[frameIndex + ROTATE] = rotateMix;
+			frames[frameIndex + TRANSLATE] = translateMix;
+			frames[frameIndex + SCALE] = scaleMix;
+			frames[frameIndex + SHEAR] = shearMix;
+		}
 
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		var frames:Vector.<Number> = this.frames;		
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var frames : Vector.<Number> = this.frames;
 
-		var constraint:TransformConstraint  = skeleton.transformConstraints[transformConstraintIndex];
-		var data:TransformConstraintData;
-		if (time < frames[0]) {
-			if (setupPose) {
-				data = constraint.data;
-				constraint.rotateMix = constraint.data.rotateMix;
-				constraint.translateMix = constraint.data.translateMix;
-				constraint.scaleMix = constraint.data.scaleMix;
-				constraint.shearMix = constraint.data.shearMix;
+			var constraint : TransformConstraint = skeleton.transformConstraints[transformConstraintIndex];
+			var data : TransformConstraintData;
+			if (time < frames[0]) {
+				if (setupPose) {
+					data = constraint.data;
+					constraint.rotateMix = constraint.data.rotateMix;
+					constraint.translateMix = constraint.data.translateMix;
+					constraint.scaleMix = constraint.data.scaleMix;
+					constraint.shearMix = constraint.data.shearMix;
+				}
+				return;
 			}
-			return;
-		}
 
-		var rotate:Number, translate:Number, scale:Number, shear:Number;
-		if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
-			var i:int = frames.length;
-			rotate = frames[i + PREV_ROTATE];
-			translate = frames[i + PREV_TRANSLATE];
-			scale = frames[i + PREV_SCALE];
-			shear = frames[i + PREV_SHEAR];
-		} else {
-			// Interpolate between the previous frame and the current frame.
-			var frame:int = Animation.binarySearch(frames, time, ENTRIES);
-			rotate = frames[frame + PREV_ROTATE];
-			translate = frames[frame + PREV_TRANSLATE];
-			scale = frames[frame + PREV_SCALE];
-			shear = frames[frame + PREV_SHEAR];
-			var frameTime:Number = frames[frame];
-			var percent:Number = getCurvePercent(frame / ENTRIES - 1,
-				1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+			var rotate : Number, translate : Number, scale : Number, shear : Number;
+			if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
+				var i : int = frames.length;
+				rotate = frames[i + PREV_ROTATE];
+				translate = frames[i + PREV_TRANSLATE];
+				scale = frames[i + PREV_SCALE];
+				shear = frames[i + PREV_SHEAR];
+			} else {
+				// Interpolate between the previous frame and the current frame.
+				var frame : int = Animation.binarySearch(frames, time, ENTRIES);
+				rotate = frames[frame + PREV_ROTATE];
+				translate = frames[frame + PREV_TRANSLATE];
+				scale = frames[frame + PREV_SCALE];
+				shear = frames[frame + PREV_SHEAR];
+				var frameTime : Number = frames[frame];
+				var percent : Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
 
-			rotate += (frames[frame + ROTATE] - rotate) * percent;
-			translate += (frames[frame + TRANSLATE] - translate) * percent;
-			scale += (frames[frame + SCALE] - scale) * percent;
-			shear += (frames[frame + SHEAR] - shear) * percent;
-		}
-		if (setupPose) {
-			data = constraint.data;
-			constraint.rotateMix = data.rotateMix + (rotate - data.rotateMix) * alpha;
-			constraint.translateMix = data.translateMix + (translate - data.translateMix) * alpha;
-			constraint.scaleMix = data.scaleMix + (scale - data.scaleMix) * alpha;
-			constraint.shearMix = data.shearMix + (shear - data.shearMix) * alpha;
-		} else {
-			constraint.rotateMix += (rotate - constraint.rotateMix) * alpha;
-			constraint.translateMix += (translate - constraint.translateMix) * alpha;
-			constraint.scaleMix += (scale - constraint.scaleMix) * alpha;
-			constraint.shearMix += (shear - constraint.shearMix) * alpha;
+				rotate += (frames[frame + ROTATE] - rotate) * percent;
+				translate += (frames[frame + TRANSLATE] - translate) * percent;
+				scale += (frames[frame + SCALE] - scale) * percent;
+				shear += (frames[frame + SHEAR] - shear) * percent;
+			}
+			if (setupPose) {
+				data = constraint.data;
+				constraint.rotateMix = data.rotateMix + (rotate - data.rotateMix) * alpha;
+				constraint.translateMix = data.translateMix + (translate - data.translateMix) * alpha;
+				constraint.scaleMix = data.scaleMix + (scale - data.scaleMix) * alpha;
+				constraint.shearMix = data.shearMix + (shear - data.shearMix) * alpha;
+			} else {
+				constraint.rotateMix += (rotate - constraint.rotateMix) * alpha;
+				constraint.translateMix += (translate - constraint.translateMix) * alpha;
+				constraint.scaleMix += (scale - constraint.scaleMix) * alpha;
+				constraint.shearMix += (shear - constraint.shearMix) * alpha;
+			}
 		}
 	}
-}
-}
+}

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

@@ -29,71 +29,68 @@
  *****************************************************************************/
 
 package spine.animation {
-import spine.Bone;
-import spine.Event;
-import spine.Skeleton;
+	import spine.Bone;
+	import spine.Event;
+	import spine.Skeleton;
 
-public class TranslateTimeline extends CurveTimeline {
-	static public const ENTRIES:int = 3;
-	static internal const PREV_TIME:int = -3, PREV_X:int = -2, PREV_Y:int = -1;
-	static internal const X:int = 1, Y:int = 2;
+	public class TranslateTimeline extends CurveTimeline {
+		static public const ENTRIES : int = 3;
+		static internal const PREV_TIME : int = -3, PREV_X : int = -2, PREV_Y : int = -1;
+		static internal const X : int = 1, Y : int = 2;
+		public var boneIndex : int;
+		public var frames : Vector.<Number>; // time, value, value, ...
 
-	public var boneIndex:int;
-	public var frames:Vector.<Number>; // time, value, value, ...
+		public function TranslateTimeline(frameCount : int) {
+			super(frameCount);
+			frames = new Vector.<Number>(frameCount * ENTRIES, true);
+		}
 
-	public function TranslateTimeline (frameCount:int) {
-		super(frameCount);
-		frames = new Vector.<Number>(frameCount * ENTRIES, true);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.translate.ordinal << 24) + boneIndex;
-	}
+		override public function getPropertyId() : int {
+			return (TimelineType.translate.ordinal << 24) + boneIndex;
+		}
 
-	/** Sets the time and value of the specified keyframe. */
-	public function setFrame (frameIndex:int, time:Number, x:Number, y:Number) : void {
-		frameIndex *= ENTRIES;
-		frames[frameIndex] = time;
-		frames[int(frameIndex + X)] = x;
-		frames[int(frameIndex + Y)] = y;
-	}
+		/** Sets the time and value of the specified keyframe. */
+		public function setFrame(frameIndex : int, time : Number, x : Number, y : Number) : void {
+			frameIndex *= ENTRIES;
+			frames[frameIndex] = time;
+			frames[int(frameIndex + X)] = x;
+			frames[int(frameIndex + Y)] = y;
+		}
 
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		var frames:Vector.<Number> = this.frames;		
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var frames : Vector.<Number> = this.frames;
 
-		var bone:Bone = skeleton.bones[boneIndex];
-		if (time < frames[0]) {
-			if (setupPose) {
-				bone.x = bone.data.x;
-				bone.y = bone.data.y;
+			var bone : Bone = skeleton.bones[boneIndex];
+			if (time < frames[0]) {
+				if (setupPose) {
+					bone.x = bone.data.x;
+					bone.y = bone.data.y;
+				}
+				return;
 			}
-			return;
-		}
 
-		var x:Number, y:Number;
-		if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
-			x = frames[frames.length + PREV_X];
-			y = frames[frames.length + PREV_Y];
-		} else {
-			// Interpolate between the previous frame and the current frame.
-			var frame:int = Animation.binarySearch(frames, time, ENTRIES);
-			x = frames[frame + PREV_X];
-			y = frames[frame + PREV_Y];
-			var frameTime:Number = frames[frame];
-			var percent:Number = getCurvePercent(frame / ENTRIES - 1,
-				1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+			var x : Number, y : Number;
+			if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
+				x = frames[frames.length + PREV_X];
+				y = frames[frames.length + PREV_Y];
+			} else {
+				// Interpolate between the previous frame and the current frame.
+				var frame : int = Animation.binarySearch(frames, time, ENTRIES);
+				x = frames[frame + PREV_X];
+				y = frames[frame + PREV_Y];
+				var frameTime : Number = frames[frame];
+				var percent : Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
 
-			x += (frames[frame + X] - x) * percent;
-			y += (frames[frame + Y] - y) * percent;
-		}
-		if (setupPose) {
-			bone.x = bone.data.x + x * alpha;
-			bone.y = bone.data.y + y * alpha;
-		} else {
-			bone.x += (bone.data.x + x - bone.x) * alpha;
-			bone.y += (bone.data.y + y - bone.y) * alpha;
+				x += (frames[frame + X] - x) * percent;
+				y += (frames[frame + Y] - y) * percent;
+			}
+			if (setupPose) {
+				bone.x = bone.data.x + x * alpha;
+				bone.y = bone.data.y + y * alpha;
+			} else {
+				bone.x += (bone.data.x + x - bone.x) * alpha;
+				bone.y += (bone.data.y + y - bone.y) * alpha;
+			}
 		}
 	}
-}
-
-}
+}

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

@@ -30,99 +30,96 @@
 
 package spine.animation {
 	import spine.Color;
-import spine.Event;
-import spine.Skeleton;
-import spine.Slot;
+	import spine.Event;
+	import spine.Skeleton;
+	import spine.Slot;
 
-public class TwoColorTimeline extends CurveTimeline {
-	static public const ENTRIES:int = 8;
-	static internal const PREV_TIME:int = -8, PREV_R:int = -7, PREV_G:int = -6, PREV_B:int = -5, PREV_A:int = -4;
-	static internal const PREV_R2:int = -3, PREV_G2:int = -2, PREV_B2:int = -1;
-	static internal const R:int = 1, G:int = 2, B:int = 3, A:int = 4, R2:int = 5, G2:int = 6, B2:int = 7;
+	public class TwoColorTimeline extends CurveTimeline {
+		static public const ENTRIES : int = 8;
+		static internal const PREV_TIME : int = -8, PREV_R : int = -7, PREV_G : int = -6, PREV_B : int = -5, PREV_A : int = -4;
+		static internal const PREV_R2 : int = -3, PREV_G2 : int = -2, PREV_B2 : int = -1;
+		static internal const R : int = 1, G : int = 2, B : int = 3, A : int = 4, R2 : int = 5, G2 : int = 6, B2 : int = 7;
+		public var slotIndex : int;
+		public var frames : Vector.<Number>; // time, r, g, b, a, ...
 
-	public var slotIndex:int;
-	public var frames:Vector.<Number>; // time, r, g, b, a, ...
+		public function TwoColorTimeline(frameCount : int) {
+			super(frameCount);
+			frames = new Vector.<Number>(frameCount * ENTRIES, true);
+		}
 
-	public function TwoColorTimeline (frameCount:int) {
-		super(frameCount);
-		frames = new Vector.<Number>(frameCount * ENTRIES, true);
-	}
-	
-	override public function getPropertyId () : int {
-		return (TimelineType.twoColor.ordinal << 24) + slotIndex;
-	}
+		override public function getPropertyId() : int {
+			return (TimelineType.twoColor.ordinal << 24) + slotIndex;
+		}
 
-	/** Sets the time and value of the specified keyframe. */
-	public function setFrame (frameIndex:int, time:Number, r:Number, g:Number, b:Number, a:Number, r2:Number, g2:Number, b2:Number) : void {
-		frameIndex *= TwoColorTimeline.ENTRIES;
-		this.frames[frameIndex] = time;
-		this.frames[frameIndex + TwoColorTimeline.R] = r;
-		this.frames[frameIndex + TwoColorTimeline.G] = g;
-		this.frames[frameIndex + TwoColorTimeline.B] = b;
-		this.frames[frameIndex + TwoColorTimeline.A] = a;
-		this.frames[frameIndex + TwoColorTimeline.R2] = r2;
-		this.frames[frameIndex + TwoColorTimeline.G2] = g2;
-		this.frames[frameIndex + TwoColorTimeline.B2] = b2;
-	}
+		/** Sets the time and value of the specified keyframe. */
+		public function setFrame(frameIndex : int, time : Number, r : Number, g : Number, b : Number, a : Number, r2 : Number, g2 : Number, b2 : Number) : void {
+			frameIndex *= TwoColorTimeline.ENTRIES;
+			this.frames[frameIndex] = time;
+			this.frames[frameIndex + TwoColorTimeline.R] = r;
+			this.frames[frameIndex + TwoColorTimeline.G] = g;
+			this.frames[frameIndex + TwoColorTimeline.B] = b;
+			this.frames[frameIndex + TwoColorTimeline.A] = a;
+			this.frames[frameIndex + TwoColorTimeline.R2] = r2;
+			this.frames[frameIndex + TwoColorTimeline.G2] = g2;
+			this.frames[frameIndex + TwoColorTimeline.B2] = b2;
+		}
+
+		override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, setupPose : Boolean, mixingOut : Boolean) : void {
+			var frames : Vector.<Number> = this.frames;
+			var slot : Slot = skeleton.slots[slotIndex];
 
-	override public function apply (skeleton:Skeleton, lastTime:Number, time:Number, firedEvents:Vector.<Event>, alpha:Number, setupPose:Boolean, mixingOut:Boolean) : void {
-		var frames:Vector.<Number> = this.frames;
-		var slot:Slot = skeleton.slots[slotIndex];
-		
-		if (time < frames[0]) {
-			if (setupPose) {
-				slot.color.setFromColor(slot.data.color);
-				slot.darkColor.setFromColor(slot.data.darkColor);	
+			if (time < frames[0]) {
+				if (setupPose) {
+					slot.color.setFromColor(slot.data.color);
+					slot.darkColor.setFromColor(slot.data.darkColor);
+				}
+				return;
 			}
-			return;
-		}
 
-		var r:Number, g:Number, b:Number, a:Number, r2:Number, g2:Number, b2:Number;
-		if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
-			var i:int = frames.length;
-			r = frames[i + PREV_R];
-			g = frames[i + PREV_G];
-			b = frames[i + PREV_B];
-			a = frames[i + PREV_A];
-			r2 = frames[i + PREV_R2];
-			g2 = frames[i + PREV_G2];
-			b2 = frames[i + PREV_B2];
-		} else {
-			// Interpolate between the previous frame and the current frame.
-			var frame:int = Animation.binarySearch(frames, time, ENTRIES);
-			r = frames[frame + PREV_R];
-			g = frames[frame + PREV_G];
-			b = frames[frame + PREV_B];
-			a = frames[frame + PREV_A];
-			r2 = frames[frame + PREV_R2];
-			g2 = frames[frame + PREV_G2];
-			b2 = frames[frame + PREV_B2];
-			var frameTime:Number = frames[frame];
-			var percent:Number = getCurvePercent(frame / ENTRIES - 1,
-				1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
+			var r : Number, g : Number, b : Number, a : Number, r2 : Number, g2 : Number, b2 : Number;
+			if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
+				var i : int = frames.length;
+				r = frames[i + PREV_R];
+				g = frames[i + PREV_G];
+				b = frames[i + PREV_B];
+				a = frames[i + PREV_A];
+				r2 = frames[i + PREV_R2];
+				g2 = frames[i + PREV_G2];
+				b2 = frames[i + PREV_B2];
+			} else {
+				// Interpolate between the previous frame and the current frame.
+				var frame : int = Animation.binarySearch(frames, time, ENTRIES);
+				r = frames[frame + PREV_R];
+				g = frames[frame + PREV_G];
+				b = frames[frame + PREV_B];
+				a = frames[frame + PREV_A];
+				r2 = frames[frame + PREV_R2];
+				g2 = frames[frame + PREV_G2];
+				b2 = frames[frame + PREV_B2];
+				var frameTime : Number = frames[frame];
+				var percent : Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
 
-			r += (frames[frame + R] - r) * percent;
-			g += (frames[frame + G] - g) * percent;
-			b += (frames[frame + B] - b) * percent;
-			a += (frames[frame + A] - a) * percent;
-			r2 += (frames[frame + R2] - a) * percent;
-			g2 += (frames[frame + G2] - a) * percent;
-			b2 += (frames[frame + B2] - a) * percent;
-		}		
-		if (alpha == 1) {
-			slot.color.setFrom(r, g, b, a);
-			slot.darkColor.setFrom(r2, g2, b2, 1);
-		} else {			
-			var light:Color = slot.color;
-			var dark:Color = slot.darkColor;
-			if (setupPose) {
-				light.setFromColor(slot.data.color);
-				dark.setFromColor(slot.data.darkColor);
+				r += (frames[frame + R] - r) * percent;
+				g += (frames[frame + G] - g) * percent;
+				b += (frames[frame + B] - b) * percent;
+				a += (frames[frame + A] - a) * percent;
+				r2 += (frames[frame + R2] - a) * percent;
+				g2 += (frames[frame + G2] - a) * percent;
+				b2 += (frames[frame + B2] - a) * percent;
+			}
+			if (alpha == 1) {
+				slot.color.setFrom(r, g, b, a);
+				slot.darkColor.setFrom(r2, g2, b2, 1);
+			} else {
+				var light : Color = slot.color;
+				var dark : Color = slot.darkColor;
+				if (setupPose) {
+					light.setFromColor(slot.data.color);
+					dark.setFromColor(slot.data.darkColor);
+				}
+				light.add((r - light.r) * alpha, (g - light.g) * alpha, (b - light.b) * alpha, (a - light.a) * alpha);
+				dark.add((r2 - dark.r) * alpha, (g2 - dark.g) * alpha, (b2 - dark.b) * alpha, 0);
 			}
-			light.add((r - light.r) * alpha, (g - light.g) * alpha, (b - light.b) * alpha, (a - light.a) * alpha);
-			dark.add((r2 - dark.r) * alpha, (g2 - dark.g) * alpha, (b2 - dark.b) * alpha, 0);		
 		}
 	}
-}
-
-}
+}

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

@@ -29,177 +29,175 @@
  *****************************************************************************/
 
 package spine.atlas {
-import flash.utils.ByteArray;
-
-public class Atlas {
-	private var pages:Vector.<AtlasPage> = new Vector.<AtlasPage>();
-	private var regions:Vector.<AtlasRegion> = new Vector.<AtlasRegion>();
-	private var textureLoader:TextureLoader;
-
-	/** @param object A String or ByteArray. */
-	public function Atlas (object:*, textureLoader:TextureLoader) {
-		if (!object)
-			return;
-		if (object is String)
-			load(String(object), textureLoader);
-		else if (object is ByteArray)
-			load(ByteArray(object).readUTFBytes(ByteArray(object).length), textureLoader);
-		else
-			throw new ArgumentError("object must be a TextureAtlas or AttachmentLoader.");
-	}
+	import flash.utils.ByteArray;
+
+	public class Atlas {
+		private var pages : Vector.<AtlasPage> = new Vector.<AtlasPage>();
+		private var regions : Vector.<AtlasRegion> = new Vector.<AtlasRegion>();
+		private var textureLoader : TextureLoader;
+
+		/** @param object A String or ByteArray. */
+		public function Atlas(object : *, textureLoader : TextureLoader) {
+			if (!object)
+				return;
+			if (object is String)
+				load(String(object), textureLoader);
+			else if (object is ByteArray)
+				load(ByteArray(object).readUTFBytes(ByteArray(object).length), textureLoader);
+			else
+				throw new ArgumentError("object must be a TextureAtlas or AttachmentLoader.");
+		}
+
+		protected function load(atlasText : String, textureLoader : TextureLoader) : void {
+			if (textureLoader == null)
+				throw new ArgumentError("textureLoader cannot be null.");
+			this.textureLoader = textureLoader;
+
+			var reader : Reader = new Reader(atlasText);
+			var tuple : Array = new Array();
+			tuple.length = 4;
+			var page : AtlasPage = null;
+			while (true) {
+				var line : String = reader.readLine();
+				if (line == null)
+					break;
+				line = reader.trim(line);
+				if (line.length == 0)
+					page = null;
+				else if (!page) {
+					page = new AtlasPage();
+					page.name = line;
+
+					if (reader.readTuple(tuple) == 2) { // size is only optional for an atlas packed with an old TexturePacker.
+						page.width = parseInt(tuple[0]);
+						page.height = parseInt(tuple[1]);
+						reader.readTuple(tuple);
+					}
+					page.format = Format[tuple[0]];
 
-	protected function load (atlasText:String, textureLoader:TextureLoader) : void {
-		if (textureLoader == null)
-			throw new ArgumentError("textureLoader cannot be null.");
-		this.textureLoader = textureLoader;
-
-		var reader:Reader = new Reader(atlasText);
-		var tuple:Array = new Array();
-		tuple.length = 4;
-		var page:AtlasPage = null;
-		while (true) {
-			var line:String = reader.readLine();
-			if (line == null)
-				break;
-			line = reader.trim(line);
-			if (line.length == 0)
-				page = null;
-			else if (!page) {
-				page = new AtlasPage();
-				page.name = line;
-
-				if (reader.readTuple(tuple) == 2) { // size is only optional for an atlas packed with an old TexturePacker.
-					page.width = parseInt(tuple[0]);
-					page.height = parseInt(tuple[1]);
 					reader.readTuple(tuple);
-				}
-				page.format = Format[tuple[0]];
-
-				reader.readTuple(tuple);
-				page.minFilter = TextureFilter[tuple[0]];
-				page.magFilter = TextureFilter[tuple[1]];
-
-				var direction:String = reader.readValue();
-				page.uWrap = TextureWrap.clampToEdge;
-				page.vWrap = TextureWrap.clampToEdge;
-				if (direction == "x")
-					page.uWrap = TextureWrap.repeat;
-				else if (direction == "y")
-					page.vWrap = TextureWrap.repeat;
-				else if (direction == "xy")
-					page.uWrap = page.vWrap = TextureWrap.repeat;
-
-				textureLoader.loadPage(page, line);
-
-				pages[pages.length] = page;
-
-			} else {
-				var region:AtlasRegion = new AtlasRegion();
-				region.name = line;
-				region.page = page;
-
-				region.rotate = reader.readValue() == "true";
-
-				reader.readTuple(tuple);
-				var x:int = parseInt(tuple[0]);
-				var y:int = parseInt(tuple[1]);
-
-				reader.readTuple(tuple);
-				var width:int = parseInt(tuple[0]);
-				var height:int = parseInt(tuple[1]);
-
-				region.u = x / page.width;
-				region.v = y / page.height;
-				if (region.rotate) {
-					region.u2 = (x + height) / page.width;
-					region.v2 = (y + width) / page.height;
+					page.minFilter = TextureFilter[tuple[0]];
+					page.magFilter = TextureFilter[tuple[1]];
+
+					var direction : String = reader.readValue();
+					page.uWrap = TextureWrap.clampToEdge;
+					page.vWrap = TextureWrap.clampToEdge;
+					if (direction == "x")
+						page.uWrap = TextureWrap.repeat;
+					else if (direction == "y")
+						page.vWrap = TextureWrap.repeat;
+					else if (direction == "xy")
+						page.uWrap = page.vWrap = TextureWrap.repeat;
+
+					textureLoader.loadPage(page, line);
+
+					pages[pages.length] = page;
 				} else {
-					region.u2 = (x + width) / page.width;
-					region.v2 = (y + height) / page.height;
-				}
-				region.x = x;
-				region.y = y;
-				region.width = Math.abs(width);
-				region.height = Math.abs(height);
+					var region : AtlasRegion = new AtlasRegion();
+					region.name = line;
+					region.page = page;
 
-				if (reader.readTuple(tuple) == 4) { // split is optional
-					region.splits = new Vector.<int>(parseInt(tuple[0]), parseInt(tuple[1]), parseInt(tuple[2]), parseInt(tuple[3]));
+					region.rotate = reader.readValue() == "true";
 
-					if (reader.readTuple(tuple) == 4) { // pad is optional, but only present with splits
-						region.pads = new Vector.<int>(parseInt(tuple[0]), parseInt(tuple[1]), parseInt(tuple[2]), parseInt(tuple[3]));
+					reader.readTuple(tuple);
+					var x : int = parseInt(tuple[0]);
+					var y : int = parseInt(tuple[1]);
 
-						reader.readTuple(tuple);
+					reader.readTuple(tuple);
+					var width : int = parseInt(tuple[0]);
+					var height : int = parseInt(tuple[1]);
+
+					region.u = x / page.width;
+					region.v = y / page.height;
+					if (region.rotate) {
+						region.u2 = (x + height) / page.width;
+						region.v2 = (y + width) / page.height;
+					} else {
+						region.u2 = (x + width) / page.width;
+						region.v2 = (y + height) / page.height;
 					}
-				}
+					region.x = x;
+					region.y = y;
+					region.width = Math.abs(width);
+					region.height = Math.abs(height);
+
+					if (reader.readTuple(tuple) == 4) { // split is optional
+						region.splits = new Vector.<int>(parseInt(tuple[0]), parseInt(tuple[1]), parseInt(tuple[2]), parseInt(tuple[3]));
 
-				region.originalWidth = parseInt(tuple[0]);
-				region.originalHeight = parseInt(tuple[1]);
+						if (reader.readTuple(tuple) == 4) { // pad is optional, but only present with splits
+							region.pads = new Vector.<int>(parseInt(tuple[0]), parseInt(tuple[1]), parseInt(tuple[2]), parseInt(tuple[3]));
 
-				reader.readTuple(tuple);
-				region.offsetX = parseInt(tuple[0]);
-				region.offsetY = parseInt(tuple[1]);
+							reader.readTuple(tuple);
+						}
+					}
 
-				region.index = parseInt(reader.readValue());
+					region.originalWidth = parseInt(tuple[0]);
+					region.originalHeight = parseInt(tuple[1]);
 
-				textureLoader.loadRegion(region);
-				regions[regions.length] = region;
+					reader.readTuple(tuple);
+					region.offsetX = parseInt(tuple[0]);
+					region.offsetY = parseInt(tuple[1]);
+
+					region.index = parseInt(reader.readValue());
+
+					textureLoader.loadRegion(region);
+					regions[regions.length] = region;
+				}
 			}
 		}
-	}
 
-	/** Returns the first region found with the specified name. This method uses string comparison to find the region, so the result
-	 * should be cached rather than calling this method multiple times.
-	 * @return The region, or null. */
-	public function findRegion (name:String) : AtlasRegion {
-		for (var i:int = 0, n:int = regions.length; i < n; i++)
-			if (regions[i].name == name)
-				return regions[i];
-		return null;
-	}
+		/** Returns the first region found with the specified name. This method uses string comparison to find the region, so the result
+		 * should be cached rather than calling this method multiple times.
+		 * @return The region, or null. */
+		public function findRegion(name : String) : AtlasRegion {
+			for (var i : int = 0, n : int = regions.length; i < n; i++)
+				if (regions[i].name == name)
+					return regions[i];
+			return null;
+		}
 
-	public function dispose () : void {
-		for (var i:int = 0, n:int = pages.length; i < n; i++)
-			textureLoader.unloadPage(pages[i]);
+		public function dispose() : void {
+			for (var i : int = 0, n : int = pages.length; i < n; i++)
+				textureLoader.unloadPage(pages[i]);
+		}
 	}
 }
 
-}
-
 class Reader {
-	private var lines:Array;
-	private var index:int;
+	private var lines : Array;
+	private var index : int;
 
-	public function Reader (text:String) {
+	public function Reader(text : String) {
 		lines = text.split(/\r\n|\r|\n/);
 	}
 
-	public function trim (value:String) : String {
+	public function trim(value : String) : String {
 		return value.replace(/^\s+|\s+$/gs, "");
 	}
 
-	public function readLine () : String {
+	public function readLine() : String {
 		if (index >= lines.length)
 			return null;
 		return lines[index++];
 	}
 
-	public function readValue () : String {
-		var line:String = readLine();
-		var colon:int = line.indexOf(":");
+	public function readValue() : String {
+		var line : String = readLine();
+		var colon : int = line.indexOf(":");
 		if (colon == -1)
 			throw new Error("Invalid line: " + line);
 		return trim(line.substring(colon + 1));
 	}
 
 	/** Returns the number of tuple values read (1, 2 or 4). */
-	public function readTuple (tuple:Array) : int {
-		var line:String = readLine();
-		var colon:int = line.indexOf(":");
+	public function readTuple(tuple : Array) : int {
+		var line : String = readLine();
+		var colon : int = line.indexOf(":");
 		if (colon == -1)
 			throw new Error("Invalid line: " + line);
-		var i:int = 0, lastMatch:int = colon + 1;
+		var i : int = 0, lastMatch : int = colon + 1;
 		for (; i < 3; i++) {
-			var comma:int = line.indexOf(",", lastMatch);
+			var comma : int = line.indexOf(",", lastMatch);
 			if (comma == -1) break;
 			tuple[i] = trim(line.substr(lastMatch, comma - lastMatch));
 			lastMatch = comma + 1;
@@ -207,4 +205,4 @@ class Reader {
 		tuple[i] = trim(line.substring(lastMatch));
 		return i + 1;
 	}
-}
+}

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

@@ -29,20 +29,18 @@
  *****************************************************************************/
 
 package spine.atlas {
+	public class AtlasPage {
+		public var name : String;
+		public var format : Format;
+		public var minFilter : TextureFilter;
+		public var magFilter : TextureFilter;
+		public var uWrap : TextureWrap;
+		public var vWrap : TextureWrap;
+		public var rendererObject : Object;
+		public var width : int;
+		public var height : int;
 
-public class AtlasPage {
-	public var name:String;
-	public var format:Format;
-	public var minFilter:TextureFilter;
-	public var magFilter:TextureFilter;
-	public var uWrap:TextureWrap;
-	public var vWrap:TextureWrap;
-	public var rendererObject:Object;
-	public var width:int;
-	public var height:int;
-	
-	public function AtlasPage () {		
+		public function AtlasPage() {
+		}
 	}
-}
-
-}
+}

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

@@ -29,30 +29,28 @@
  *****************************************************************************/
 
 package spine.atlas {
+	public class AtlasRegion {
+		public var page : AtlasPage;
+		public var name : String;
+		public var x : int;
+		public var y : int;
+		public var width : int;
+		public var height : int;
+		public var u : Number;
+		public var v : Number;
+		public var u2 : Number;
+		public var v2 : Number;
+		public var offsetX : Number;
+		public var offsetY : Number;
+		public var originalWidth : int;
+		public var originalHeight : int;
+		public var index : int;
+		public var rotate : Boolean;
+		public var splits : Vector.<int>;
+		public var pads : Vector.<int>;
+		public var rendererObject : Object;
 
-public class AtlasRegion {
-	public var page:AtlasPage;
-	public var name:String;
-	public var x:int;
-	public var y:int;
-	public var width:int;
-	public var height:int;
-	public var u:Number;
-	public var v:Number;
-	public var u2:Number;
-	public var v2:Number;
-	public var offsetX:Number;
-	public var offsetY:Number;
-	public var originalWidth:int;
-	public var originalHeight:int;
-	public var index:int;
-	public var rotate:Boolean;
-	public var splits:Vector.<int>;
-	public var pads:Vector.<int>;
-	public var rendererObject:Object;
-	
-	public function AtlasRegion () {		
+		public function AtlasRegion() {
+		}
 	}
-}
-
-}
+}

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

@@ -29,23 +29,20 @@
  *****************************************************************************/
 
 package spine.atlas {
+	public class Format {
+		public static const alpha : Format = new Format(0, "alpha");
+		public static const intensity : Format = new Format(1, "intensity");
+		public static const luminanceAlpha : Format = new Format(2, "luminanceAlpha");
+		public static const rgb565 : Format = new Format(3, "rgb565");
+		public static const rgba4444 : Format = new Format(4, "rgba4444");
+		public static const rgb888 : Format = new Format(5, "rgb888");
+		public static const rgba8888 : Format = new Format(6, "rgba8888");
+		public var ordinal : int;
+		public var name : String;
 
-public class Format {
-	public static const alpha:Format = new Format(0, "alpha");
-	public static const intensity:Format = new Format(1, "intensity");
-	public static const luminanceAlpha:Format = new Format(2, "luminanceAlpha");
-	public static const rgb565:Format = new Format(3, "rgb565");
-	public static const rgba4444:Format = new Format(4, "rgba4444");
-	public static const rgb888:Format = new Format(5, "rgb888");
-	public static const rgba8888:Format = new Format(6, "rgba8888");
-
-	public var ordinal:int;
-	public var name:String;
-
-	public function Format (ordinal:int, name:String) {
-		this.ordinal = ordinal;
-		this.name = name;
+		public function Format(ordinal : int, name : String) {
+			this.ordinal = ordinal;
+			this.name = name;
+		}
 	}
-}
-
-}
+}

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

@@ -29,23 +29,20 @@
  *****************************************************************************/
 
 package spine.atlas {
+	public class TextureFilter {
+		public static const nearest : TextureFilter = new TextureFilter(0, "nearest");
+		public static const linear : TextureFilter = new TextureFilter(1, "linear");
+		public static const mipMap : TextureFilter = new TextureFilter(2, "mipMap");
+		public static const mipMapNearestNearest : TextureFilter = new TextureFilter(3, "mipMapNearestNearest");
+		public static const mipMapLinearNearest : TextureFilter = new TextureFilter(4, "mipMapLinearNearest");
+		public static const mipMapNearestLinear : TextureFilter = new TextureFilter(5, "mipMapNearestLinear");
+		public static const mipMapLinearLinear : TextureFilter = new TextureFilter(6, "mipMapLinearLinear");
+		public var ordinal : int;
+		public var name : String;
 
-public class TextureFilter {
-	public static const nearest:TextureFilter = new TextureFilter(0, "nearest");
-	public static const linear:TextureFilter = new TextureFilter(1, "linear");
-	public static const mipMap:TextureFilter = new TextureFilter(2, "mipMap");
-	public static const mipMapNearestNearest:TextureFilter = new TextureFilter(3, "mipMapNearestNearest");
-	public static const mipMapLinearNearest:TextureFilter = new TextureFilter(4, "mipMapLinearNearest");
-	public static const mipMapNearestLinear:TextureFilter = new TextureFilter(5, "mipMapNearestLinear");
-	public static const mipMapLinearLinear:TextureFilter = new TextureFilter(6, "mipMapLinearLinear");
-
-	public var ordinal:int;
-	public var name:String;
-
-	public function TextureFilter (ordinal:int, name:String) {
-		this.ordinal = ordinal;
-		this.name = name;
+		public function TextureFilter(ordinal : int, name : String) {
+			this.ordinal = ordinal;
+			this.name = name;
+		}
 	}
-}
-
-}
+}

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

@@ -29,11 +29,11 @@
  *****************************************************************************/
 
 package spine.atlas {
+	public interface TextureLoader {
+		function loadPage(page : AtlasPage, path : String) : void;
 
-public interface TextureLoader {
-	function loadPage (page:AtlasPage, path:String) : void;
-	function loadRegion (region:AtlasRegion) : void;
-	function unloadPage (page:AtlasPage) : void;
-}
+		function loadRegion(region : AtlasRegion) : void;
 
-}
+		function unloadPage(page : AtlasPage) : void;
+	}
+}

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

@@ -29,19 +29,16 @@
  *****************************************************************************/
 
 package spine.atlas {
+	public class TextureWrap {
+		public static const mirroredRepeat : TextureWrap = new TextureWrap(0, "mirroredRepeat");
+		public static const clampToEdge : TextureWrap = new TextureWrap(1, "clampToEdge");
+		public static const repeat : TextureWrap = new TextureWrap(2, "repeat");
+		public var ordinal : int;
+		public var name : String;
 
-public class TextureWrap {
-	public static const mirroredRepeat:TextureWrap = new TextureWrap(0, "mirroredRepeat");
-	public static const clampToEdge:TextureWrap = new TextureWrap(1, "clampToEdge");
-	public static const repeat:TextureWrap = new TextureWrap(2, "repeat");
-
-	public var ordinal:int;
-	public var name:String;
-
-	public function TextureWrap (ordinal:int, name:String) {
-		this.ordinal = ordinal;
-		this.name = name;
+		public function TextureWrap(ordinal : int, name : String) {
+			this.ordinal = ordinal;
+			this.name = name;
+		}
 	}
-}
-
-}
+}

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

@@ -29,80 +29,79 @@
  *****************************************************************************/
 
 package spine.attachments {
-import spine.Skin;
-import spine.atlas.Atlas;
-import spine.atlas.AtlasRegion;
+	import spine.Skin;
+	import spine.atlas.Atlas;
+	import spine.atlas.AtlasRegion;
 
-public class AtlasAttachmentLoader implements AttachmentLoader {
-	private var atlas:Atlas;
+	public class AtlasAttachmentLoader implements AttachmentLoader {
+		private var atlas : Atlas;
 
-	public function AtlasAttachmentLoader (atlas:Atlas) {
-		if (atlas == null)
-			throw new ArgumentError("atlas cannot be null.");
-		this.atlas = atlas;
-	}
-	
-	public function newRegionAttachment (skin:Skin, name:String, path:String) : RegionAttachment {
-		var region:AtlasRegion = atlas.findRegion(path);
-		if (region == null)
-			throw new Error("Region not found in atlas: " + path + " (region attachment: " + name + ")");
-		var attachment:RegionAttachment = new RegionAttachment(name);
-		attachment.rendererObject = region;
-		var scaleX:Number = region.page.width / nextPOT(region.page.width);
-		var scaleY:Number = region.page.height / nextPOT(region.page.height);
-		attachment.setUVs(region.u * scaleX, region.v * scaleY, region.u2 * scaleX, region.v2 * scaleY, region.rotate);
-		attachment.regionOffsetX = region.offsetX;
-		attachment.regionOffsetY = region.offsetY;
-		attachment.regionWidth = region.width;
-		attachment.regionHeight = region.height;
-		attachment.regionOriginalWidth = region.originalWidth;
-		attachment.regionOriginalHeight = region.originalHeight;
-		return attachment;
-	}
-	
-	public function newMeshAttachment (skin:Skin, name:String, path:String) : MeshAttachment {
-		var region:AtlasRegion = atlas.findRegion(path);
-		if (region == null)
-			throw new Error("Region not found in atlas: " + path + " (mesh attachment: " + name + ")");
-		var attachment:MeshAttachment = new MeshAttachment(name);
-		attachment.rendererObject = region;
-		var scaleX:Number = region.page.width / nextPOT(region.page.width);
-		var scaleY:Number = region.page.height / nextPOT(region.page.height);
-		attachment.regionU = region.u * scaleX;
-		attachment.regionV = region.v * scaleY;
-		attachment.regionU2 = region.u2 * scaleX;
-		attachment.regionV2 = region.v2 * scaleY;
-		attachment.regionRotate = region.rotate;
-		attachment.regionOffsetX = region.offsetX;
-		attachment.regionOffsetY = region.offsetY;
-		attachment.regionWidth = region.width;
-		attachment.regionHeight = region.height;
-		attachment.regionOriginalWidth = region.originalWidth;
-		attachment.regionOriginalHeight = region.originalHeight;
-		return attachment;
-	}
+		public function AtlasAttachmentLoader(atlas : Atlas) {
+			if (atlas == null)
+				throw new ArgumentError("atlas cannot be null.");
+			this.atlas = atlas;
+		}
 
-	public function newBoundingBoxAttachment (skin:Skin, name:String) : BoundingBoxAttachment {
-		return new BoundingBoxAttachment(name);
-	}
-	
-	public function newPathAttachment(skin:Skin, name:String) : PathAttachment {
-		return new PathAttachment(name);
-	}
-	
-	public function newPointAttachment(skin:Skin, name:String) : PointAttachment {
-		return new PointAttachment(name);
-	}
+		public function newRegionAttachment(skin : Skin, name : String, path : String) : RegionAttachment {
+			var region : AtlasRegion = atlas.findRegion(path);
+			if (region == null)
+				throw new Error("Region not found in atlas: " + path + " (region attachment: " + name + ")");
+			var attachment : RegionAttachment = new RegionAttachment(name);
+			attachment.rendererObject = region;
+			var scaleX : Number = region.page.width / nextPOT(region.page.width);
+			var scaleY : Number = region.page.height / nextPOT(region.page.height);
+			attachment.setUVs(region.u * scaleX, region.v * scaleY, region.u2 * scaleX, region.v2 * scaleY, region.rotate);
+			attachment.regionOffsetX = region.offsetX;
+			attachment.regionOffsetY = region.offsetY;
+			attachment.regionWidth = region.width;
+			attachment.regionHeight = region.height;
+			attachment.regionOriginalWidth = region.originalWidth;
+			attachment.regionOriginalHeight = region.originalHeight;
+			return attachment;
+		}
 
-	static public function nextPOT (value:int) : int {
-		value--;
-		value |= value >> 1;
-		value |= value >> 2;
-		value |= value >> 4;
-		value |= value >> 8;
-		value |= value >> 16;
-		return value + 1;
-	}
-}
+		public function newMeshAttachment(skin : Skin, name : String, path : String) : MeshAttachment {
+			var region : AtlasRegion = atlas.findRegion(path);
+			if (region == null)
+				throw new Error("Region not found in atlas: " + path + " (mesh attachment: " + name + ")");
+			var attachment : MeshAttachment = new MeshAttachment(name);
+			attachment.rendererObject = region;
+			var scaleX : Number = region.page.width / nextPOT(region.page.width);
+			var scaleY : Number = region.page.height / nextPOT(region.page.height);
+			attachment.regionU = region.u * scaleX;
+			attachment.regionV = region.v * scaleY;
+			attachment.regionU2 = region.u2 * scaleX;
+			attachment.regionV2 = region.v2 * scaleY;
+			attachment.regionRotate = region.rotate;
+			attachment.regionOffsetX = region.offsetX;
+			attachment.regionOffsetY = region.offsetY;
+			attachment.regionWidth = region.width;
+			attachment.regionHeight = region.height;
+			attachment.regionOriginalWidth = region.originalWidth;
+			attachment.regionOriginalHeight = region.originalHeight;
+			return attachment;
+		}
+
+		public function newBoundingBoxAttachment(skin : Skin, name : String) : BoundingBoxAttachment {
+			return new BoundingBoxAttachment(name);
+		}
+
+		public function newPathAttachment(skin : Skin, name : String) : PathAttachment {
+			return new PathAttachment(name);
+		}
 
-}
+		public function newPointAttachment(skin : Skin, name : String) : PointAttachment {
+			return new PointAttachment(name);
+		}
+
+		static public function nextPOT(value : int) : int {
+			value--;
+			value |= value >> 1;
+			value |= value >> 2;
+			value |= value >> 4;
+			value |= value >> 8;
+			value |= value >> 16;
+			return value + 1;
+		}
+	}
+}

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

@@ -29,23 +29,21 @@
  *****************************************************************************/
 
 package spine.attachments {
+	public class Attachment {
+		internal var _name : String;
 
-public class Attachment {
-	internal var _name:String;
+		public function Attachment(name : String) {
+			if (name == null)
+				throw new ArgumentError("name cannot be null.");
+			_name = name;
+		}
 
-	public function Attachment (name:String) {
-		if (name == null)
-			throw new ArgumentError("name cannot be null.");
-		_name = name;
-	}
-
-	public function get name () : String {
-		return _name;
-	}
+		public function get name() : String {
+			return _name;
+		}
 
-	public function toString () : String {
-		return name;
+		public function toString() : String {
+			return name;
+		}
 	}
-}
-
-}
+}

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

@@ -29,23 +29,22 @@
  *****************************************************************************/
 
 package spine.attachments {
-import spine.Skin;
+	import spine.Skin;
 
-public interface AttachmentLoader {
-	/** @return May be null to not load an attachment. */
-	function newRegionAttachment (skin:Skin, name:String, path:String) : RegionAttachment;
+	public interface AttachmentLoader {
+		/** @return May be null to not load an attachment. */
+		function newRegionAttachment(skin : Skin, name : String, path : String) : RegionAttachment;
 
-	/** @return May be null to not load an attachment. */
-	function newMeshAttachment (skin:Skin, name:String, path:String) : MeshAttachment;
+		/** @return May be null to not load an attachment. */
+		function newMeshAttachment(skin : Skin, name : String, path : String) : MeshAttachment;
 
-	/** @return May be null to not load an attachment. */
-	function newBoundingBoxAttachment (skin:Skin, name:String) : BoundingBoxAttachment;
-	
-	/** @return May be null to not load an attachment */
-	function newPathAttachment(skin:Skin, name:String): PathAttachment;
-	
-	/** @return May be null to not load an attachment */
-	function newPointAttachment(skin:Skin, name:String): PointAttachment;
-}
+		/** @return May be null to not load an attachment. */
+		function newBoundingBoxAttachment(skin : Skin, name : String) : BoundingBoxAttachment;
 
-}
+		/** @return May be null to not load an attachment */
+		function newPathAttachment(skin : Skin, name : String) : PathAttachment;
+
+		/** @return May be null to not load an attachment */
+		function newPointAttachment(skin : Skin, name : String) : PointAttachment;
+	}
+}

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

@@ -29,23 +29,20 @@
  *****************************************************************************/
 
 package spine.attachments {
+	public class AttachmentType {
+		public static const region : AttachmentType = new AttachmentType(0, "region");
+		public static const regionsequence : AttachmentType = new AttachmentType(1, "regionsequence");
+		public static const boundingbox : AttachmentType = new AttachmentType(2, "boundingbox");
+		public static const mesh : AttachmentType = new AttachmentType(3, "mesh");
+		public static const linkedmesh : AttachmentType = new AttachmentType(3, "linkedmesh");
+		public static const path : AttachmentType = new AttachmentType(4, "path");
+		public static const point : AttachmentType = new AttachmentType(5, "point");
+		public var ordinal : int;
+		public var name : String;
 
-public class AttachmentType {
-	public static const region:AttachmentType = new AttachmentType(0, "region");
-	public static const regionsequence:AttachmentType = new AttachmentType(1, "regionsequence");
-	public static const boundingbox:AttachmentType = new AttachmentType(2, "boundingbox");
-	public static const mesh:AttachmentType = new AttachmentType(3, "mesh");	
-	public static const linkedmesh:AttachmentType = new AttachmentType(3, "linkedmesh");
-	public static const path:AttachmentType = new AttachmentType(4, "path");
-	public static const point:AttachmentType = new AttachmentType(5, "point");
-
-	public var ordinal:int;
-	public var name:String;
-
-	public function AttachmentType (ordinal:int, name:String) {
-		this.ordinal = ordinal;
-		this.name = name;
+		public function AttachmentType(ordinal : int, name : String) {
+			this.ordinal = ordinal;
+			this.name = name;
+		}
 	}
-}
-
-}
+}

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

@@ -29,10 +29,9 @@
  *****************************************************************************/
 
 package spine.attachments {
-
-public dynamic class BoundingBoxAttachment extends VertexAttachment {	
-	public function BoundingBoxAttachment (name:String) {
-		super(name);
-	}		
-}
-}
+	public dynamic class BoundingBoxAttachment extends VertexAttachment {
+		public function BoundingBoxAttachment(name : String) {
+			super(name);
+		}
+	}
+}

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

@@ -29,79 +29,76 @@
  *****************************************************************************/
 
 package spine.attachments {
-import spine.Color;
+	import spine.Color;
 
-public dynamic class MeshAttachment extends VertexAttachment {	
-	public var uvs:Vector.<Number>;
-	public var regionUVs:Vector.<Number>;
-	public var triangles:Vector.<uint>;	
-	public var color:Color = new Color(1, 1, 1, 1);
-	public var hullLength:int;
-	private var _parentMesh:MeshAttachment;
-	public var inheritDeform:Boolean;
+	public dynamic class MeshAttachment extends VertexAttachment {
+		public var uvs : Vector.<Number>;
+		public var regionUVs : Vector.<Number>;
+		public var triangles : Vector.<uint>;
+		public var color : Color = new Color(1, 1, 1, 1);
+		public var hullLength : int;
+		private var _parentMesh : MeshAttachment;
+		public var inheritDeform : Boolean;
+		public var path : String;
+		public var rendererObject : Object;
+		public var regionU : Number;
+		public var regionV : Number;
+		public var regionU2 : Number;
+		public var regionV2 : Number;
+		public var regionRotate : Boolean;
+		public var regionOffsetX : Number; // Pixels stripped from the bottom left, unrotated.
+		public var regionOffsetY : Number;
+		public var regionWidth : Number; // Unrotated, stripped size.
+		public var regionHeight : Number;
+		public var regionOriginalWidth : Number; // Unrotated, unstripped size.
+		public var regionOriginalHeight : Number;
+		// Nonessential.
+		public var edges : Vector.<int>;
+		public var width : Number;
+		public var height : Number;
 
-	public var path:String;
-	public var rendererObject:Object;
-	public var regionU:Number;
-	public var regionV:Number;
-	public var regionU2:Number;
-	public var regionV2:Number;
-	public var regionRotate:Boolean;
-	public var regionOffsetX:Number; // Pixels stripped from the bottom left, unrotated.
-	public var regionOffsetY:Number;
-	public var regionWidth:Number; // Unrotated, stripped size.
-	public var regionHeight:Number;
-	public var regionOriginalWidth:Number; // Unrotated, unstripped size.
-	public var regionOriginalHeight:Number;
-
-	// Nonessential.
-	public var edges:Vector.<int>;
-	public var width:Number;
-	public var height:Number;
-
-	public function MeshAttachment (name:String) {
-		super(name);
-	}
+		public function MeshAttachment(name : String) {
+			super(name);
+		}
 
-	public function updateUVs () : void {
-		var width:Number = regionU2 - regionU, height:Number = regionV2 - regionV;
-		var i:int, n:int = regionUVs.length;
-		if (!uvs || uvs.length != n) uvs = new Vector.<Number>(n, true);
-		if (regionRotate) {
-			for (i = 0; i < n; i += 2) {
-				uvs[i] = regionU + regionUVs[int(i + 1)] * width;
-				uvs[int(i + 1)] = regionV + height - regionUVs[i] * height;
-			}
-		} else {
-			for (i = 0; i < n; i += 2) {
-				uvs[i] = regionU + regionUVs[i] * width;
-				uvs[int(i + 1)] = regionV + regionUVs[int(i + 1)] * height;
+		public function updateUVs() : void {
+			var width : Number = regionU2 - regionU, height : Number = regionV2 - regionV;
+			var i : int, n : int = regionUVs.length;
+			if (!uvs || uvs.length != n) uvs = new Vector.<Number>(n, true);
+			if (regionRotate) {
+				for (i = 0; i < n; i += 2) {
+					uvs[i] = regionU + regionUVs[int(i + 1)] * width;
+					uvs[int(i + 1)] = regionV + height - regionUVs[i] * height;
+				}
+			} else {
+				for (i = 0; i < n; i += 2) {
+					uvs[i] = regionU + regionUVs[i] * width;
+					uvs[int(i + 1)] = regionV + regionUVs[int(i + 1)] * height;
+				}
 			}
 		}
-	}
 
-	override public function applyDeform (sourceAttachment:VertexAttachment) : Boolean {
-		return this == sourceAttachment || (inheritDeform && _parentMesh == sourceAttachment);
-	}
+		override public function applyDeform(sourceAttachment : VertexAttachment) : Boolean {
+			return this == sourceAttachment || (inheritDeform && _parentMesh == sourceAttachment);
+		}
 
-	public function get parentMesh () : MeshAttachment {
-		return _parentMesh;
-	}
+		public function get parentMesh() : MeshAttachment {
+			return _parentMesh;
+		}
 
-	public function set parentMesh (parentMesh:MeshAttachment) : void {
-		_parentMesh = parentMesh;
-		if (parentMesh != null) {
-			bones = parentMesh.bones;
-			vertices = parentMesh.vertices;
-			worldVerticesLength = parentMesh.worldVerticesLength;
-			regionUVs = parentMesh.regionUVs;
-			triangles = parentMesh.triangles;
-			hullLength = parentMesh.hullLength;
-			edges = parentMesh.edges;
-			width = parentMesh.width;
-			height = parentMesh.height;
+		public function set parentMesh(parentMesh : MeshAttachment) : void {
+			_parentMesh = parentMesh;
+			if (parentMesh != null) {
+				bones = parentMesh.bones;
+				vertices = parentMesh.vertices;
+				worldVerticesLength = parentMesh.worldVerticesLength;
+				regionUVs = parentMesh.regionUVs;
+				triangles = parentMesh.triangles;
+				hullLength = parentMesh.hullLength;
+				edges = parentMesh.edges;
+				width = parentMesh.width;
+				height = parentMesh.height;
+			}
 		}
 	}
-}
-
-}
+}

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

@@ -29,14 +29,12 @@
  *****************************************************************************/
 
 package spine.attachments {
+	public dynamic class PathAttachment extends VertexAttachment {
+		public var lengths : Vector.<Number>;
+		public var closed : Boolean, constantSpeed : Boolean;
 
-public dynamic class PathAttachment extends VertexAttachment {
-	public var lengths:Vector.<Number>;
-	public var closed:Boolean, constantSpeed:Boolean;
-
-	public function PathAttachment (name:String) {
-		super(name);
+		public function PathAttachment(name : String) {
+			super(name);
+		}
 	}
-}
-
-}
+}

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

@@ -29,29 +29,29 @@
  *****************************************************************************/
 
 package spine.attachments {
-import spine.Color;
-import spine.MathUtils;
-import spine.Bone;
+	import spine.Color;
+	import spine.MathUtils;
+	import spine.Bone;
 
-public dynamic class PointAttachment extends VertexAttachment {
-	public var x: Number, y: Number, rotation: Number;
-	public var color:Color = new Color(0.38, 0.94, 0, 1);
-	
-	public function PointAttachment (name:String) {
-		super(name);
-	}
-	
-	public function computeWorldPosition (bone: Bone, point: Vector.<Number>): Vector.<Number> {
-		point[0] = this.x * bone.a + this.y * bone.b + bone.worldX;
-		point[1] = this.x * bone.c + this.y * bone.d + bone.worldY;
-		return point;
-	}
+	public dynamic class PointAttachment extends VertexAttachment {
+		public var x : Number, y : Number, rotation : Number;
+		public var color : Color = new Color(0.38, 0.94, 0, 1);
+
+		public function PointAttachment(name : String) {
+			super(name);
+		}
 
-	public function computeWorldRotation (bone: Bone): Number {
-		var cos:Number = MathUtils.cosDeg(this.rotation), sin: Number = MathUtils.sinDeg(this.rotation);
-		var x:Number = cos * bone.a + sin * bone.b;
-		var y:Number = cos * bone.c + sin * bone.d;
-		return Math.atan2(y, x) * MathUtils.radDeg;
-	}	
-}
-}
+		public function computeWorldPosition(bone : Bone, point : Vector.<Number>) : Vector.<Number> {
+			point[0] = this.x * bone.a + this.y * bone.b + bone.worldX;
+			point[1] = this.x * bone.c + this.y * bone.d + bone.worldY;
+			return point;
+		}
+
+		public function computeWorldRotation(bone : Bone) : Number {
+			var cos : Number = MathUtils.cosDeg(this.rotation), sin : Number = MathUtils.sinDeg(this.rotation);
+			var x : Number = cos * bone.a + sin * bone.b;
+			var y : Number = cos * bone.c + sin * bone.d;
+			return Math.atan2(y, x) * MathUtils.radDeg;
+		}
+	}
+}

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

@@ -29,126 +29,122 @@
  *****************************************************************************/
 
 package spine.attachments {
-import spine.Color;
-import spine.Bone;
+	import spine.Color;
+	import spine.Bone;
 
-public dynamic class RegionAttachment extends Attachment {
-	public const X1:int = 0;
-	public const Y1:int = 1;
-	public const X2:int = 2;
-	public const Y2:int = 3;
-	public const X3:int = 4;
-	public const Y3:int = 5;
-	public const X4:int = 6;
-	public const Y4:int = 7;
+	public dynamic class RegionAttachment extends Attachment {
+		public const X1 : int = 0;
+		public const Y1 : int = 1;
+		public const X2 : int = 2;
+		public const Y2 : int = 3;
+		public const X3 : int = 4;
+		public const Y3 : int = 5;
+		public const X4 : int = 6;
+		public const Y4 : int = 7;
+		public var x : Number;
+		public var y : Number;
+		public var scaleX : Number = 1;
+		public var scaleY : Number = 1;
+		public var rotation : Number;
+		public var width : Number;
+		public var height : Number;
+		public var color : Color = new Color(1, 1, 1, 1);
+		public var path : String;
+		public var rendererObject : Object;
+		public var regionOffsetX : Number; // Pixels stripped from the bottom left, unrotated.
+		public var regionOffsetY : Number;
+		public var regionWidth : Number; // Unrotated, stripped size.
+		public var regionHeight : Number;
+		public var regionOriginalWidth : Number; // Unrotated, unstripped size.
+		public var regionOriginalHeight : Number;
+		public var offset : Vector.<Number> = new Vector.<Number>();
+		public var uvs : Vector.<Number> = new Vector.<Number>();
 
-	public var x:Number;
-	public var y:Number;
-	public var scaleX:Number = 1;
-	public var scaleY:Number = 1;
-	public var rotation:Number;
-	public var width:Number;
-	public var height:Number;
-	public var color:Color = new Color(1, 1, 1, 1);
-
-	public var path:String;
-	public var rendererObject:Object;
-	public var regionOffsetX:Number; // Pixels stripped from the bottom left, unrotated.
-	public var regionOffsetY:Number;
-	public var regionWidth:Number; // Unrotated, stripped size.
-	public var regionHeight:Number;
-	public var regionOriginalWidth:Number; // Unrotated, unstripped size.
-	public var regionOriginalHeight:Number;
-
-	public var offset:Vector.<Number> = new Vector.<Number>();
-	public var uvs:Vector.<Number> = new Vector.<Number>();
+		public function RegionAttachment(name : String) {
+			super(name);
+			offset.length = 8;
+			uvs.length = 8;
+		}
 
-	public function RegionAttachment (name:String) {
-		super(name);
-		offset.length = 8;
-		uvs.length = 8;
-	}
+		public function updateOffset() : void {
+			var regionScaleX : Number = width / regionOriginalWidth * scaleX;
+			var regionScaleY : Number = height / regionOriginalHeight * scaleY;
+			var localX : Number = -width / 2 * scaleX + regionOffsetX * regionScaleX;
+			var localY : Number = -height / 2 * scaleY + regionOffsetY * regionScaleY;
+			var localX2 : Number = localX + regionWidth * regionScaleX;
+			var localY2 : Number = localY + regionHeight * regionScaleY;
+			var radians : Number = rotation * Math.PI / 180;
+			var cos : Number = Math.cos(radians);
+			var sin : Number = Math.sin(radians);
+			var localXCos : Number = localX * cos + x;
+			var localXSin : Number = localX * sin;
+			var localYCos : Number = localY * cos + y;
+			var localYSin : Number = localY * sin;
+			var localX2Cos : Number = localX2 * cos + x;
+			var localX2Sin : Number = localX2 * sin;
+			var localY2Cos : Number = localY2 * cos + y;
+			var localY2Sin : Number = localY2 * sin;
+			offset[X1] = localXCos - localYSin;
+			offset[Y1] = localYCos + localXSin;
+			offset[X2] = localXCos - localY2Sin;
+			offset[Y2] = localY2Cos + localXSin;
+			offset[X3] = localX2Cos - localY2Sin;
+			offset[Y3] = localY2Cos + localX2Sin;
+			offset[X4] = localX2Cos - localYSin;
+			offset[Y4] = localYCos + localX2Sin;
+		}
 
-	public function updateOffset () : void {
-		var regionScaleX:Number = width / regionOriginalWidth * scaleX;
-		var regionScaleY:Number = height / regionOriginalHeight * scaleY;
-		var localX:Number = -width / 2 * scaleX + regionOffsetX * regionScaleX;
-		var localY:Number = -height / 2 * scaleY + regionOffsetY * regionScaleY;
-		var localX2:Number = localX + regionWidth * regionScaleX;
-		var localY2:Number = localY + regionHeight * regionScaleY;
-		var radians:Number = rotation * Math.PI / 180;
-		var cos:Number = Math.cos(radians);
-		var sin:Number = Math.sin(radians);
-		var localXCos:Number = localX * cos + x;
-		var localXSin:Number = localX * sin;
-		var localYCos:Number = localY * cos + y;
-		var localYSin:Number = localY * sin;
-		var localX2Cos:Number = localX2 * cos + x;
-		var localX2Sin:Number = localX2 * sin;
-		var localY2Cos:Number = localY2 * cos + y;
-		var localY2Sin:Number = localY2 * sin;
-		offset[X1] = localXCos - localYSin;
-		offset[Y1] = localYCos + localXSin;
-		offset[X2] = localXCos - localY2Sin;
-		offset[Y2] = localY2Cos + localXSin;
-		offset[X3] = localX2Cos - localY2Sin;
-		offset[Y3] = localY2Cos + localX2Sin;
-		offset[X4] = localX2Cos - localYSin;
-		offset[Y4] = localYCos + localX2Sin;
-	}
-	
-	public function setUVs (u:Number, v:Number, u2:Number, v2:Number, rotate:Boolean) : void {
-		var uvs:Vector.<Number> = this.uvs; 
-		if (rotate) {
-			uvs[X2] = u;
-			uvs[Y2] = v2;
-			uvs[X3] = u;
-			uvs[Y3] = v;
-			uvs[X4] = u2;
-			uvs[Y4] = v;
-			uvs[X1] = u2;
-			uvs[Y1] = v2;
-		} else {
-			uvs[X1] = u;
-			uvs[Y1] = v2;
-			uvs[X2] = u;
-			uvs[Y2] = v;
-			uvs[X3] = u2;
-			uvs[Y3] = v;
-			uvs[X4] = u2;
-			uvs[Y4] = v2;
+		public function setUVs(u : Number, v : Number, u2 : Number, v2 : Number, rotate : Boolean) : void {
+			var uvs : Vector.<Number> = this.uvs;
+			if (rotate) {
+				uvs[X2] = u;
+				uvs[Y2] = v2;
+				uvs[X3] = u;
+				uvs[Y3] = v;
+				uvs[X4] = u2;
+				uvs[Y4] = v;
+				uvs[X1] = u2;
+				uvs[Y1] = v2;
+			} else {
+				uvs[X1] = u;
+				uvs[Y1] = v2;
+				uvs[X2] = u;
+				uvs[Y2] = v;
+				uvs[X3] = u2;
+				uvs[Y3] = v;
+				uvs[X4] = u2;
+				uvs[Y4] = v2;
+			}
 		}
-	}
 
-	public function computeWorldVertices (bone:Bone, worldVertices:Vector.<Number>, offset:int, stride:int) : void {
-		var vertexOffset:Vector.<Number> = this.offset;
-		var x:Number = bone.worldX, y:Number = bone.worldY;
-		var a:Number = bone.a, b:Number = bone.b, c:Number = bone.c, d:Number = bone.d;
-		var offsetX:Number = 0, offsetY:Number = 0;
+		public function computeWorldVertices(bone : Bone, worldVertices : Vector.<Number>, offset : int, stride : int) : void {
+			var vertexOffset : Vector.<Number> = this.offset;
+			var x : Number = bone.worldX, y : Number = bone.worldY;
+			var a : Number = bone.a, b : Number = bone.b, c : Number = bone.c, d : Number = bone.d;
+			var offsetX : Number = 0, offsetY : Number = 0;
 
-		offsetX = vertexOffset[X1];
-		offsetY = vertexOffset[Y1];
-		worldVertices[offset] = offsetX * a + offsetY * b + x; // br
-		worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
-		offset += stride;
+			offsetX = vertexOffset[X1];
+			offsetY = vertexOffset[Y1];
+			worldVertices[offset] = offsetX * a + offsetY * b + x; // br
+			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
+			offset += stride;
 
-		offsetX = vertexOffset[X2];
-		offsetY = vertexOffset[Y2];
-		worldVertices[offset] = offsetX * a + offsetY * b + x; // bl
-		worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
-		offset += stride;
+			offsetX = vertexOffset[X2];
+			offsetY = vertexOffset[Y2];
+			worldVertices[offset] = offsetX * a + offsetY * b + x; // bl
+			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
+			offset += stride;
 
-		offsetX = vertexOffset[X3];
-		offsetY = vertexOffset[Y3];
-		worldVertices[offset] = offsetX * a + offsetY * b + x; // ul
-		worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
-		offset += stride;
+			offsetX = vertexOffset[X3];
+			offsetY = vertexOffset[Y3];
+			worldVertices[offset] = offsetX * a + offsetY * b + x; // ul
+			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
+			offset += stride;
 
-		offsetX = vertexOffset[X4];
-		offsetY = vertexOffset[Y4];
-		worldVertices[offset] = offsetX * a + offsetY * b + x; // ur
-		worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
+			offsetX = vertexOffset[X4];
+			offsetY = vertexOffset[Y4];
+			worldVertices[offset] = offsetX * a + offsetY * b + x; // ur
+			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
+		}
 	}
-}
-
-}
+}

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

@@ -33,89 +33,99 @@ package spine.attachments {
 	import spine.Skeleton;
 	import spine.Slot;
 
-public dynamic class VertexAttachment extends Attachment {
-	public var bones:Vector.<int>;
-	public var vertices:Vector.<Number>;
-	public var worldVerticesLength:int;
+	public dynamic class VertexAttachment extends Attachment {
+		public var bones : Vector.<int>;
+		public var vertices : Vector.<Number>;
+		public var worldVerticesLength : int;
 
-	public function VertexAttachment (name:String) {
-		super(name);
-	}
-
-	/** Transforms local vertices to world coordinates.
-	 * @param start The index of the first local vertex value to transform. Each vertex has 2 values, x and y.
-	 * @param count The number of world vertex values to output. Must be <= {@link #getWorldVerticesLength()} - start.
-	 * @param worldVertices The output world vertices. Must have a length >= offset + count.
-	 * @param offset The worldVertices index to begin writing values. */
-	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 vertices:Vector.<Number> = this.vertices;
-		var bones:Vector.<int> = this.bones;
-		var deform:Vector.<Number>;
-		
-		var v:int, w:int, n:int, i:int, skip:int, b:int, f:int;
-		var vx:Number, vy:Number;
-		var wx:Number, wy:Number;
-		var bone:Bone;
-		
-		if (bones == null) {
-			if (deformArray.length > 0) vertices = deformArray;
-			bone = slot.bone;
-			var x:Number = bone.worldX;
-			var y:Number = bone.worldY;
-			var a:Number = bone.a, bb:Number = bone.b, c:Number = bone.c, d:Number = bone.d;
-			for (v = start, w = offset; w < count; v += 2, w += stride) {
-				vx = vertices[v], vy = vertices[v + 1];
-				worldVertices[w] = vx * a + vy * bb + x;
-				worldVertices[w + 1] = vx * c + vy * d + y;
-			}
-			return;
+		public function VertexAttachment(name : String) {
+			super(name);
 		}
-		v = 0, skip = 0;
-		for (i = 0; i < start; i += 2) {
-			n = bones[v];
-			v += n + 1;
-			skip += n;
-		}
-		var skeletonBones:Vector.<Bone> = skeleton.bones;
-		if (deformArray.length == 0) {
-			for (w = offset, b = skip * 3; w < count; w += stride) {
-				wx = 0, wy = 0;
-				n = bones[v++];
-				n += v;
-				for (; v < n; v++, b += 3) {
-					bone = skeletonBones[bones[v]];
-					vx = vertices[b]; vy = vertices[b + 1]; var weight:Number = vertices[b + 2];
-					wx += (vx * bone.a + vy * bone.b + bone.worldX) * weight;
-					wy += (vx * bone.c + vy * bone.d + bone.worldY) * weight;
+
+		/** Transforms local vertices to world coordinates.
+		 * @param start The index of the first local vertex value to transform. Each vertex has 2 values, x and y.
+		 * @param count The number of world vertex values to output. Must be <= {@link #getWorldVerticesLength()} - start.
+		 * @param worldVertices The output world vertices. Must have a length >= offset + count.
+		 * @param offset The worldVertices index to begin writing values. */
+		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 vertices : Vector.<Number> = this.vertices;
+			var bones : Vector.<int> = this.bones;
+			var deform : Vector.<Number>;
+
+			var v : int, w : int, n : int, i : int, skip : int, b : int, f : int;
+			var vx : Number, vy : Number;
+			var wx : Number, wy : Number;
+			var bone : Bone;
+
+			if (bones == null) {
+				if (deformArray.length > 0) vertices = deformArray;
+				bone = slot.bone;
+				var x : Number = bone.worldX;
+				var y : Number = bone.worldY;
+				var a : Number = bone.a, bb : Number = bone.b, c : Number = bone.c, d : Number = bone.d;
+				for (v = start, w = offset; w < count; v += 2, w += stride) {
+					vx = vertices[v]
+					,
+					vy = vertices[v + 1];
+					worldVertices[w] = vx * a + vy * bb + x;
+					worldVertices[w + 1] = vx * c + vy * d + y;
 				}
-				worldVertices[w] = wx;
-				worldVertices[w + 1] = wy;
+				return;
+			}
+			v = 0
+			,
+			skip = 0;
+			for (i = 0; i < start; i += 2) {
+				n = bones[v];
+				v += n + 1;
+				skip += n;
 			}
-		} else {
-			deform = deformArray;
-			for (w = offset, b = skip * 3, f = skip << 1; w < count; w += stride) {
-				wx = 0; wy = 0;
-				n = bones[v++];
-				n += v;
-				for (; v < n; v++, b += 3, f += 2) {
-					bone = skeletonBones[bones[v]];
-					vx = vertices[b] + deform[f]; vy = vertices[b + 1] + deform[f + 1]; weight = vertices[b + 2];
-					wx += (vx * bone.a + vy * bone.b + bone.worldX) * weight;
-					wy += (vx * bone.c + vy * bone.d + bone.worldY) * weight;
+			var skeletonBones : Vector.<Bone> = skeleton.bones;
+			if (deformArray.length == 0) {
+				for (w = offset, b = skip * 3; w < count; w += stride) {
+					wx = 0
+					,
+					wy = 0;
+					n = bones[v++];
+					n += v;
+					for (; v < n; v++, b += 3) {
+						bone = skeletonBones[bones[v]];
+						vx = vertices[b];
+						vy = vertices[b + 1];
+						var weight : Number = vertices[b + 2];
+						wx += (vx * bone.a + vy * bone.b + bone.worldX) * weight;
+						wy += (vx * bone.c + vy * bone.d + bone.worldY) * weight;
+					}
+					worldVertices[w] = wx;
+					worldVertices[w + 1] = wy;
+				}
+			} else {
+				deform = deformArray;
+				for (w = offset, b = skip * 3, f = skip << 1; w < count; w += stride) {
+					wx = 0;
+					wy = 0;
+					n = bones[v++];
+					n += v;
+					for (; v < n; v++, b += 3, f += 2) {
+						bone = skeletonBones[bones[v]];
+						vx = vertices[b] + deform[f];
+						vy = vertices[b + 1] + deform[f + 1];
+						weight = vertices[b + 2];
+						wx += (vx * bone.a + vy * bone.b + bone.worldX) * weight;
+						wy += (vx * bone.c + vy * bone.d + bone.worldY) * weight;
+					}
+					worldVertices[w] = wx;
+					worldVertices[w + 1] = wy;
 				}
-				worldVertices[w] = wx;
-				worldVertices[w + 1] = wy;
 			}
 		}
-	}
 
-	/** Returns true if a deform originally applied to the specified attachment should be applied to this attachment. */
-	public function applyDeform (sourceAttachment:VertexAttachment): Boolean {
-		return this == sourceAttachment;
+		/** Returns true if a deform originally applied to the specified attachment should be applied to this attachment. */
+		public function applyDeform(sourceAttachment : VertexAttachment) : Boolean {
+			return this == sourceAttachment;
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/flash/FlashTextureLoader.as

@@ -29,57 +29,56 @@
  *****************************************************************************/
 
 package spine.flash {
-import flash.display.Bitmap;
-import flash.display.BitmapData;
+	import flash.display.Bitmap;
+	import flash.display.BitmapData;
 
-import spine.atlas.AtlasPage;
-import spine.atlas.AtlasRegion;
-import spine.atlas.TextureLoader;
+	import spine.atlas.AtlasPage;
+	import spine.atlas.AtlasRegion;
+	import spine.atlas.TextureLoader;
 
-public class FlashTextureLoader implements TextureLoader {
-	public var bitmapDatas:Object = {};
-	public var singleBitmapData:BitmapData;
+	public class FlashTextureLoader implements TextureLoader {
+		public var bitmapDatas : Object = {};
+		public var singleBitmapData : BitmapData;
 
-	/** @param bitmaps A Bitmap or BitmapData for an atlas that has only one page, or for a multi page atlas an object where the
-	 * key is the image path and the value is the Bitmap or BitmapData. */
-	public function FlashTextureLoader (bitmaps:Object) {
-		if (bitmaps is BitmapData) {
-			singleBitmapData = BitmapData(bitmaps);
-			return;
-		}
-		if (bitmaps is Bitmap) {
-			singleBitmapData = Bitmap(bitmaps).bitmapData;
-			return;
+		/** @param bitmaps A Bitmap or BitmapData for an atlas that has only one page, or for a multi page atlas an object where the
+		 * key is the image path and the value is the Bitmap or BitmapData. */
+		public function FlashTextureLoader(bitmaps : Object) {
+			if (bitmaps is BitmapData) {
+				singleBitmapData = BitmapData(bitmaps);
+				return;
+			}
+			if (bitmaps is Bitmap) {
+				singleBitmapData = Bitmap(bitmaps).bitmapData;
+				return;
+			}
+
+			for (var path : * in bitmaps) {
+				var object : * = bitmaps[path];
+				var bitmapData : BitmapData;
+				if (object is BitmapData)
+					bitmapData = BitmapData(object);
+				else if (object is Bitmap)
+					bitmapData = Bitmap(object).bitmapData;
+				else
+					throw new ArgumentError("Object for path \"" + path + "\" must be a Bitmap or BitmapData: " + object);
+				bitmapDatas[path] = bitmapData;
+			}
 		}
 
-		for (var path:* in bitmaps) {
-			var object:* = bitmaps[path];
-			var bitmapData:BitmapData;
-			if (object is BitmapData)
-				bitmapData = BitmapData(object);
-			else if (object is Bitmap)
-				bitmapData = Bitmap(object).bitmapData;
-			else
-				throw new ArgumentError("Object for path \"" + path + "\" must be a Bitmap or BitmapData: " + object);
-			bitmapDatas[path] = bitmapData;
+		public function loadPage(page : AtlasPage, path : String) : void {
+			var bitmapData : BitmapData = singleBitmapData || bitmapDatas[path];
+			if (!bitmapData)
+				throw new ArgumentError("BitmapData not found with name: " + path);
+			page.rendererObject = bitmapData;
+			page.width = bitmapData.width;
+			page.height = bitmapData.height;
 		}
-	}
 
-	public function loadPage (page:AtlasPage, path:String) : void {
-		var bitmapData:BitmapData = singleBitmapData || bitmapDatas[path];
-		if (!bitmapData)
-			throw new ArgumentError("BitmapData not found with name: " + path);
-		page.rendererObject = bitmapData;
-		page.width = bitmapData.width;
-		page.height = bitmapData.height;
-	}
-	
-	public function loadRegion (region:AtlasRegion) : void {
-	}
+		public function loadRegion(region : AtlasRegion) : void {
+		}
 
-	public function unloadPage (page:AtlasPage) : void {
-		BitmapData(page.rendererObject).dispose();
+		public function unloadPage(page : AtlasPage) : void {
+			BitmapData(page.rendererObject).dispose();
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/flash/SkeletonAnimation.as

@@ -29,24 +29,23 @@
  *****************************************************************************/
 
 package spine.flash {
-import spine.SkeletonData;
-import spine.animation.AnimationState;
-import spine.animation.AnimationStateData;
+	import spine.SkeletonData;
+	import spine.animation.AnimationState;
+	import spine.animation.AnimationStateData;
 
-public class SkeletonAnimation extends SkeletonSprite {
-	public var state:AnimationState;
+	public class SkeletonAnimation extends SkeletonSprite {
+		public var state : AnimationState;
 
-	public function SkeletonAnimation (skeletonData:SkeletonData, stateData:AnimationStateData = null) {
-		super(skeletonData);
-		state = new AnimationState(stateData ? stateData : new AnimationStateData(skeletonData));
-	}
+		public function SkeletonAnimation(skeletonData : SkeletonData, stateData : AnimationStateData = null) {
+			super(skeletonData);
+			state = new AnimationState(stateData ? stateData : new AnimationStateData(skeletonData));
+		}
 
-	override public function advanceTime (time:Number) : void {
-		state.update(time * timeScale);
-		state.apply(skeleton);
-		skeleton.updateWorldTransform();
-		super.advanceTime(time);
+		override public function advanceTime(time : Number) : void {
+			state.update(time * timeScale);
+			state.apply(skeleton);
+			skeleton.updateWorldTransform();
+			super.advanceTime(time);
+		}
 	}
-}
-
-}
+}

spine-as3/spine-as3/src/spine/flash/SkeletonSprite.as

@@ -29,124 +29,121 @@
  *****************************************************************************/
 
 package spine.flash {
-import flash.utils.Dictionary;
-import flash.display.Bitmap;
-import flash.display.BitmapData;
-import flash.display.BlendMode;
-import flash.display.Sprite;
-import flash.events.Event;
-import flash.geom.ColorTransform;
-import flash.geom.Point;
-import flash.geom.Rectangle;
-import flash.utils.getTimer;
-
-import spine.Bone;
-import spine.Skeleton;
-import spine.SkeletonData;
-import spine.Slot;
-import spine.atlas.AtlasRegion;
-import spine.attachments.RegionAttachment;
-
-public class SkeletonSprite extends Sprite {
-	static private var blendModes:Vector.<String> = new <String>[
-		BlendMode.NORMAL, BlendMode.ADD, BlendMode.MULTIPLY, BlendMode.SCREEN];
-
-	private var _skeleton:Skeleton;
-	public var timeScale:Number = 1;
-	private var lastTime:int;
-	private var wrappers:Dictionary = new Dictionary(true);
-
-	public function SkeletonSprite (skeletonData:SkeletonData) {
-		Bone.yDown = true;
-
-		_skeleton = new Skeleton(skeletonData);
-		_skeleton.updateWorldTransform();
-
-		addEventListener(Event.ENTER_FRAME, enterFrame);
-	}
+	import flash.utils.Dictionary;
+	import flash.display.Bitmap;
+	import flash.display.BitmapData;
+	import flash.display.BlendMode;
+	import flash.display.Sprite;
+	import flash.events.Event;
+	import flash.geom.ColorTransform;
+	import flash.geom.Point;
+	import flash.geom.Rectangle;
+	import flash.utils.getTimer;
+
+	import spine.Bone;
+	import spine.Skeleton;
+	import spine.SkeletonData;
+	import spine.Slot;
+	import spine.atlas.AtlasRegion;
+	import spine.attachments.RegionAttachment;
+
+	public class SkeletonSprite extends Sprite {
+		static private var blendModes : Vector.<String> = new <String>[BlendMode.NORMAL, BlendMode.ADD, BlendMode.MULTIPLY, BlendMode.SCREEN];
+		private var _skeleton : Skeleton;
+		public var timeScale : Number = 1;
+		private var lastTime : int;
+		private var wrappers : Dictionary = new Dictionary(true);
+
+		public function SkeletonSprite(skeletonData : SkeletonData) {
+			Bone.yDown = true;
+
+			_skeleton = new Skeleton(skeletonData);
+			_skeleton.updateWorldTransform();
+
+			addEventListener(Event.ENTER_FRAME, enterFrame);
+		}
 
-	private function enterFrame (event:Event) : void {
-		var time:int = getTimer();
-		advanceTime((time - lastTime) / 1000);
-		lastTime = time;
-	}
+		private function enterFrame(event : Event) : void {
+			var time : int = getTimer();
+			advanceTime((time - lastTime) / 1000);
+			lastTime = time;
+		}
 
-	public function advanceTime (delta:Number) : void {
-		_skeleton.update(delta * timeScale);
-
-		removeChildren();
-		var drawOrder:Vector.<Slot> = skeleton.drawOrder;
-		for (var i:int = 0, n:int = drawOrder.length; i < n; i++) {
-			var slot:Slot = drawOrder[i];
-			var regionAttachment:RegionAttachment = slot.attachment as RegionAttachment;
-			if (!regionAttachment) continue;
-
-			var wrapper:Sprite = wrappers[regionAttachment];
-			if (!wrapper) {
-				var region:AtlasRegion = AtlasRegion(regionAttachment.rendererObject);
-				var regionHeight:Number = region.rotate ? region.width : region.height;
-				var regionData:BitmapData = region.rendererObject as BitmapData;
-				if (!regionData) {
-					var bitmapData:BitmapData = region.page.rendererObject as BitmapData;
-					var regionWidth:Number = region.rotate ? region.height : region.width;
-					regionData = new BitmapData(regionWidth, regionHeight);
-					regionData.copyPixels(bitmapData, new Rectangle(region.x, region.y, regionWidth, regionHeight), new Point());
-					region.rendererObject = regionData;
+		public function advanceTime(delta : Number) : void {
+			_skeleton.update(delta * timeScale);
+
+			removeChildren();
+			var drawOrder : Vector.<Slot> = skeleton.drawOrder;
+			for (var i : int = 0, n : int = drawOrder.length; i < n; i++) {
+				var slot : Slot = drawOrder[i];
+				var regionAttachment : RegionAttachment = slot.attachment as RegionAttachment;
+				if (!regionAttachment) continue;
+
+				var wrapper : Sprite = wrappers[regionAttachment];
+				if (!wrapper) {
+					var region : AtlasRegion = AtlasRegion(regionAttachment.rendererObject);
+					var regionHeight : Number = region.rotate ? region.width : region.height;
+					var regionData : BitmapData = region.rendererObject as BitmapData;
+					if (!regionData) {
+						var bitmapData : BitmapData = region.page.rendererObject as BitmapData;
+						var regionWidth : Number = region.rotate ? region.height : region.width;
+						regionData = new BitmapData(regionWidth, regionHeight);
+						regionData.copyPixels(bitmapData, new Rectangle(region.x, region.y, regionWidth, regionHeight), new Point());
+						region.rendererObject = regionData;
+					}
+
+					var bitmap : Bitmap = new Bitmap(regionData);
+					bitmap.smoothing = true;
+
+					// Rotate and scale using default registration point (top left corner, y-down, CW) instead of image center.
+					bitmap.rotation = -regionAttachment.rotation;
+					bitmap.scaleX = regionAttachment.scaleX * (regionAttachment.width / region.width);
+					bitmap.scaleY = regionAttachment.scaleY * (regionAttachment.height / region.height);
+
+					// Position using attachment translation, shifted as if scale and rotation were at image center.
+					var radians : Number = -regionAttachment.rotation * Math.PI / 180;
+					var cos : Number = Math.cos(radians);
+					var sin : Number = Math.sin(radians);
+					var shiftX : Number = -regionAttachment.width / 2 * regionAttachment.scaleX;
+					var shiftY : Number = -regionAttachment.height / 2 * regionAttachment.scaleY;
+					if (region.rotate) {
+						bitmap.rotation += 90;
+						shiftX += regionHeight * (regionAttachment.width / region.width);
+					}
+					bitmap.x = regionAttachment.x + shiftX * cos - shiftY * sin;
+					bitmap.y = -regionAttachment.y + shiftX * sin + shiftY * cos;
+
+					// Use bone as registration point.
+					wrapper = new Sprite();
+					wrapper.transform.colorTransform = new ColorTransform();
+					wrapper.addChild(bitmap);
+					wrappers[regionAttachment] = wrapper;
 				}
 
-				var bitmap:Bitmap = new Bitmap(regionData);
-				bitmap.smoothing = true;
-
-				// Rotate and scale using default registration point (top left corner, y-down, CW) instead of image center.
-				bitmap.rotation = -regionAttachment.rotation;
-				bitmap.scaleX = regionAttachment.scaleX * (regionAttachment.width / region.width);
-				bitmap.scaleY = regionAttachment.scaleY * (regionAttachment.height / region.height);
-
-				// Position using attachment translation, shifted as if scale and rotation were at image center.
-				var radians:Number = -regionAttachment.rotation * Math.PI / 180;
-				var cos:Number = Math.cos(radians);
-				var sin:Number = Math.sin(radians);
-				var shiftX:Number = -regionAttachment.width / 2 * regionAttachment.scaleX;
-				var shiftY:Number = -regionAttachment.height / 2 * regionAttachment.scaleY;
-				if (region.rotate) {
-					bitmap.rotation += 90;
-					shiftX += regionHeight * (regionAttachment.width / region.width);
-				}
-				bitmap.x = regionAttachment.x + shiftX * cos - shiftY * sin;
-				bitmap.y = -regionAttachment.y + shiftX * sin + shiftY * cos;
-
-				// Use bone as registration point.
-				wrapper = new Sprite();
-				wrapper.transform.colorTransform = new ColorTransform();
-				wrapper.addChild(bitmap);
-				wrappers[regionAttachment] = wrapper;
+				wrapper.blendMode = blendModes[slot.data.blendMode.ordinal];
+
+				var colorTransform : ColorTransform = wrapper.transform.colorTransform;
+				colorTransform.redMultiplier = skeleton.color.r * slot.color.r * regionAttachment.color.r;
+				colorTransform.greenMultiplier = skeleton.color.g * slot.color.g * regionAttachment.color.g;
+				colorTransform.blueMultiplier = skeleton.color.b * slot.color.b * regionAttachment.color.b;
+				colorTransform.alphaMultiplier = skeleton.color.a * slot.color.a * regionAttachment.color.a;
+				wrapper.transform.colorTransform = colorTransform;
+
+				var bone : Bone = slot.bone;
+				var flipX : int = skeleton.flipX ? -1 : 1;
+				var flipY : int = skeleton.flipY ? -1 : 1;
+
+				wrapper.x = bone.worldX;
+				wrapper.y = bone.worldY;
+				wrapper.rotation = bone.worldRotationX * flipX * flipY;
+				wrapper.scaleX = bone.worldScaleX * flipX;
+				wrapper.scaleY = bone.worldScaleY * flipY;
+				addChild(wrapper);
 			}
-
-			wrapper.blendMode = blendModes[slot.data.blendMode.ordinal];
-
-			var colorTransform:ColorTransform = wrapper.transform.colorTransform;
-			colorTransform.redMultiplier = skeleton.color.r * slot.color.r * regionAttachment.color.r;
-			colorTransform.greenMultiplier = skeleton.color.g * slot.color.g * regionAttachment.color.g;
-			colorTransform.blueMultiplier = skeleton.color.b * slot.color.b * regionAttachment.color.b;
-			colorTransform.alphaMultiplier = skeleton.color.a * slot.color.a * regionAttachment.color.a;
-			wrapper.transform.colorTransform = colorTransform;
-
-			var bone:Bone = slot.bone;
-			var flipX:int = skeleton.flipX ? -1 : 1;
-			var flipY:int = skeleton.flipY ? -1 : 1;
-
-			wrapper.x = bone.worldX;
-			wrapper.y = bone.worldY;
-			wrapper.rotation = bone.worldRotationX * flipX * flipY;
-			wrapper.scaleX = bone.worldScaleX * flipX;
-			wrapper.scaleY = bone.worldScaleY * flipY;
-			addChild(wrapper);
 		}
-	}
 
-	public function get skeleton () : Skeleton {
-		return _skeleton;
+		public function get skeleton() : Skeleton {
+			return _skeleton;
+		}
 	}
-}
-
-}
+}

spine-starling/spine-starling-example/src/spine/examples/GoblinsExample.as

@@ -27,78 +27,77 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
-
+ 
 package spine.examples {
-import spine.*;
-import spine.atlas.Atlas;
-import spine.attachments.AtlasAttachmentLoader;
-import spine.attachments.AttachmentLoader;
-import spine.starling.SkeletonAnimation;
-import spine.starling.StarlingAtlasAttachmentLoader;
-import spine.starling.StarlingTextureLoader;
+	import spine.*;
+	import spine.atlas.Atlas;
+	import spine.attachments.AtlasAttachmentLoader;
+	import spine.attachments.AttachmentLoader;
+	import spine.starling.SkeletonAnimation;
+	import spine.starling.StarlingAtlasAttachmentLoader;
+	import spine.starling.StarlingTextureLoader;
 
-import starling.core.Starling;
-import starling.display.Sprite;
-import starling.events.Touch;
-import starling.events.TouchEvent;
-import starling.events.TouchPhase;
-import starling.textures.Texture;
-import starling.textures.TextureAtlas;
+	import starling.core.Starling;
+	import starling.display.Sprite;
+	import starling.events.Touch;
+	import starling.events.TouchEvent;
+	import starling.events.TouchPhase;
+	import starling.textures.Texture;
+	import starling.textures.TextureAtlas;
 
-public class GoblinsExample extends Sprite {
-	[Embed(source = "/goblins-mesh.json", mimeType = "application/octet-stream")]
-	static public const GoblinsJson:Class;
-	
-	[Embed(source = "/goblins.atlas", mimeType = "application/octet-stream")]
-	static public const GoblinsAtlas:Class;
-	
-	[Embed(source = "/goblins.png")]
-	static public const GoblinsAtlasTexture:Class;
-	
-	[Embed(source = "/goblins-mesh-starling.xml", mimeType = "application/octet-stream")]
-	static public const GoblinsStarlingAtlas:Class;
-	
-	[Embed(source = "/goblins-mesh-starling.png")]
-	static public const GoblinsStarlingAtlasTexture:Class;
+	public class GoblinsExample extends Sprite {
+		[Embed(source = "/goblins-mesh.json", mimeType = "application/octet-stream")]
+		static public const GoblinsJson : Class;
 
-	private var skeleton:SkeletonAnimation;
+		[Embed(source = "/goblins.atlas", mimeType = "application/octet-stream")]
+		static public const GoblinsAtlas : Class;
 
-	public function GoblinsExample () {
-		var useStarlingAtlas:Boolean = false;
+		[Embed(source = "/goblins.png")]
+		static public const GoblinsAtlasTexture : Class;
 
-		var attachmentLoader:AttachmentLoader;
-		if (useStarlingAtlas) {
-			var texture:Texture = Texture.fromBitmap(new GoblinsStarlingAtlasTexture());
-			var xml:XML = XML(new GoblinsStarlingAtlas());
-			var starlingAtlas:TextureAtlas = new TextureAtlas(texture, xml);
-			attachmentLoader = new StarlingAtlasAttachmentLoader(starlingAtlas);
-		} else {
-			var spineAtlas:Atlas = new Atlas(new GoblinsAtlas(), new StarlingTextureLoader(new GoblinsAtlasTexture()));
-			attachmentLoader = new AtlasAttachmentLoader(spineAtlas);
-		}
+		[Embed(source = "/goblins-mesh-starling.xml", mimeType = "application/octet-stream")]
+		static public const GoblinsStarlingAtlas : Class;
 
-		var json:SkeletonJson = new SkeletonJson(attachmentLoader);
-		var skeletonData:SkeletonData = json.readSkeletonData(new GoblinsJson());
+		[Embed(source = "/goblins-mesh-starling.png")]
+		static public const GoblinsStarlingAtlasTexture : Class;
+		private var skeleton : SkeletonAnimation;
 
-		skeleton = new SkeletonAnimation(skeletonData);
-		skeleton.x = 320;
-		skeleton.y = 420;
-		skeleton.skeleton.skinName = "goblin";
-		skeleton.skeleton.setSlotsToSetupPose();
-		skeleton.state.setAnimationByName(0, "walk", true);
+		public function GoblinsExample() {
+			var useStarlingAtlas : Boolean = false;
 
-		addChild(skeleton);
-		Starling.juggler.add(skeleton);
+			var attachmentLoader : AttachmentLoader;
+			if (useStarlingAtlas) {
+				var texture : Texture = Texture.fromBitmap(new GoblinsStarlingAtlasTexture());
+				var xml : XML = XML(new GoblinsStarlingAtlas());
+				var starlingAtlas : TextureAtlas = new TextureAtlas(texture, xml);
+				attachmentLoader = new StarlingAtlasAttachmentLoader(starlingAtlas);
+			} else {
+				var spineAtlas : Atlas = new Atlas(new GoblinsAtlas(), new StarlingTextureLoader(new GoblinsAtlasTexture()));
+				attachmentLoader = new AtlasAttachmentLoader(spineAtlas);
+			}
 
-		addEventListener(TouchEvent.TOUCH, onClick);
-	}
+			var json : SkeletonJson = new SkeletonJson(attachmentLoader);
+			var skeletonData : SkeletonData = json.readSkeletonData(new GoblinsJson());
 
-	private function onClick (event:TouchEvent) : void {
-		var touch:Touch = event.getTouch(this);
-		if (touch && touch.phase == TouchPhase.BEGAN) {
-			skeleton.skeleton.skinName = skeleton.skeleton.skin.name == "goblin" ? "goblingirl" : "goblin";
+			skeleton = new SkeletonAnimation(skeletonData);
+			skeleton.x = 320;
+			skeleton.y = 420;
+			skeleton.skeleton.skinName = "goblin";
 			skeleton.skeleton.setSlotsToSetupPose();
+			skeleton.state.setAnimationByName(0, "walk", true);
+
+			addChild(skeleton);
+			Starling.juggler.add(skeleton);
+
+			addEventListener(TouchEvent.TOUCH, onClick);
+		}
+
+		private function onClick(event : TouchEvent) : void {
+			var touch : Touch = event.getTouch(this);
+			if (touch && touch.phase == TouchPhase.BEGAN) {
+				skeleton.skeleton.skinName = skeleton.skeleton.skin.name == "goblin" ? "goblingirl" : "goblin";
+				skeleton.skeleton.setSlotsToSetupPose();
+			}
 		}
 	}
-}
-}
+}

spine-starling/spine-starling-example/src/spine/examples/Main.as

@@ -27,32 +27,30 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
-
+ 
 package spine.examples {
+	import flash.display.Sprite;
 
-import flash.display.Sprite;
-
-import starling.core.Starling;
+	import starling.core.Starling;
 
-[SWF(width = "800", height = "600", frameRate = "60", backgroundColor = "#dddddd")]
-public class Main extends Sprite {
-	private var _starling:Starling;
+	[SWF(width = "800", height = "600", frameRate = "60", backgroundColor = "#dddddd")]
+	public class Main extends Sprite {
+		private var _starling : Starling;
 
-	public function Main () {
-		var example:Class;
-		// example = SpineboyExample;
-		// example = GoblinsExample;
-		// example = RaptorExample;
-		// example = TankExample;
-		// example = VineExample;
-		example = StretchymanExample;
+		public function Main() {
+			var example : Class;
+			// example = SpineboyExample;
+			// example = GoblinsExample;
+			// example = RaptorExample;
+			// example = TankExample;
+			// example = VineExample;
+			example = StretchymanExample;
 
-		_starling = new Starling(example, stage);
-		_starling.enableErrorChecking = true;
-		_starling.showStats = true;
-		_starling.skipUnchangedFrames = false;
-		_starling.start();
+			_starling = new Starling(example, stage);
+			_starling.enableErrorChecking = true;
+			_starling.showStats = true;
+			_starling.skipUnchangedFrames = false;
+			_starling.start();			
+		}
 	}
-}
-
-}
+}

spine-starling/spine-starling-example/src/spine/examples/RaptorExample.as

@@ -29,61 +29,60 @@
  *****************************************************************************/
 
 package spine.examples {
-import spine.atlas.Atlas;
-import spine.*;
-import spine.attachments.AtlasAttachmentLoader;
-import spine.attachments.AttachmentLoader;
-import spine.starling.SkeletonAnimation;
-import spine.starling.StarlingTextureLoader;
+	import spine.atlas.Atlas;
+	import spine.*;
+	import spine.attachments.AtlasAttachmentLoader;
+	import spine.attachments.AttachmentLoader;
+	import spine.starling.SkeletonAnimation;
+	import spine.starling.StarlingTextureLoader;
 
-import starling.core.Starling;
-import starling.display.Sprite;
-import starling.events.Touch;
-import starling.events.TouchEvent;
-import starling.events.TouchPhase;
+	import starling.core.Starling;
+	import starling.display.Sprite;
+	import starling.events.Touch;
+	import starling.events.TouchEvent;
+	import starling.events.TouchPhase;
 
-public class RaptorExample extends Sprite {
-	[Embed(source = "/raptor.json", mimeType = "application/octet-stream")]
-	static public const RaptorJson:Class;
-	
-	[Embed(source = "/raptor.atlas", mimeType = "application/octet-stream")]
-	static public const RaptorAtlas:Class;
-	
-	[Embed(source = "/raptor.png")]
-	static public const RaptorAtlasTexture:Class;
-	
-	private var skeleton:SkeletonAnimation;
-	private var gunGrabbed:Boolean;
+	public class RaptorExample extends Sprite {
+		[Embed(source = "/raptor.json", mimeType = "application/octet-stream")]
+		static public const RaptorJson : Class;
 
-	public function RaptorExample () {
-		var attachmentLoader:AttachmentLoader;
-		var spineAtlas:Atlas = new Atlas(new RaptorAtlas(), new StarlingTextureLoader(new RaptorAtlasTexture()));
-		attachmentLoader = new AtlasAttachmentLoader(spineAtlas);
+		[Embed(source = "/raptor.atlas", mimeType = "application/octet-stream")]
+		static public const RaptorAtlas : Class;
 
-		var json:SkeletonJson = new SkeletonJson(attachmentLoader);
-		json.scale = 0.5;
-		var skeletonData:SkeletonData = json.readSkeletonData(new RaptorJson());
+		[Embed(source = "/raptor.png")]
+		static public const RaptorAtlasTexture : Class;
+		private var skeleton : SkeletonAnimation;
+		private var gunGrabbed : Boolean;
 
-		skeleton = new SkeletonAnimation(skeletonData);
-		skeleton.x = 400;
-		skeleton.y = 560;
-		skeleton.state.setAnimationByName(0, "walk", true);
+		public function RaptorExample() {
+			var attachmentLoader : AttachmentLoader;
+			var spineAtlas : Atlas = new Atlas(new RaptorAtlas(), new StarlingTextureLoader(new RaptorAtlasTexture()));
+			attachmentLoader = new AtlasAttachmentLoader(spineAtlas);
 
-		addChild(skeleton);
-		Starling.juggler.add(skeleton);
+			var json : SkeletonJson = new SkeletonJson(attachmentLoader);
+			json.scale = 0.5;
+			var skeletonData : SkeletonData = json.readSkeletonData(new RaptorJson());
 
-		addEventListener(TouchEvent.TOUCH, onClick);
-	}
+			skeleton = new SkeletonAnimation(skeletonData);
+			skeleton.x = 400;
+			skeleton.y = 560;
+			skeleton.state.setAnimationByName(0, "walk", true);
+
+			addChild(skeleton);
+			Starling.juggler.add(skeleton);
+
+			addEventListener(TouchEvent.TOUCH, onClick);
+		}
 
-	private function onClick (event:TouchEvent) : void {
-		var touch:Touch = event.getTouch(this);
-		if (touch && touch.phase == TouchPhase.BEGAN) {
-			if (gunGrabbed)
-				skeleton.skeleton.setToSetupPose();
-			else
-				skeleton.state.setAnimationByName(1, "gungrab", false);
-			gunGrabbed = !gunGrabbed;
+		private function onClick(event : TouchEvent) : void {
+			var touch : Touch = event.getTouch(this);
+			if (touch && touch.phase == TouchPhase.BEGAN) {
+				if (gunGrabbed)
+					skeleton.skeleton.setToSetupPose();
+				else
+					skeleton.state.setAnimationByName(1, "gungrab", false);
+				gunGrabbed = !gunGrabbed;
+			}
 		}
 	}
-}
-}
+}

spine-starling/spine-starling-example/src/spine/examples/SpineboyExample.as

@@ -27,88 +27,86 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
-
+ 
 package spine.examples {
 	import spine.animation.TrackEntry;
-import spine.animation.AnimationStateData;
-import spine.*;
-import spine.atlas.Atlas;
-import spine.attachments.AtlasAttachmentLoader;
-import spine.attachments.AttachmentLoader;
-import spine.starling.SkeletonAnimation;
-import spine.starling.StarlingTextureLoader;
+	import spine.animation.AnimationStateData;
+	import spine.*;
+	import spine.atlas.Atlas;
+	import spine.attachments.AtlasAttachmentLoader;
+	import spine.attachments.AttachmentLoader;
+	import spine.starling.SkeletonAnimation;
+	import spine.starling.StarlingTextureLoader;
 
-import starling.core.Starling;
-import starling.display.Sprite;
-import starling.events.Touch;
-import starling.events.TouchEvent;
-import starling.events.TouchPhase;
+	import starling.core.Starling;
+	import starling.display.Sprite;
+	import starling.events.Touch;
+	import starling.events.TouchEvent;
+	import starling.events.TouchPhase;
 
-public class SpineboyExample extends Sprite {
-	[Embed(source = "/spineboy.json", mimeType = "application/octet-stream")]
-	static public const SpineboyJson:Class;
+	public class SpineboyExample extends Sprite {
+		[Embed(source = "/spineboy.json", mimeType = "application/octet-stream")]
+		static public const SpineboyJson : Class;
 
-	[Embed(source = "/spineboy.atlas", mimeType = "application/octet-stream")]
-	static public const SpineboyAtlas:Class;
+		[Embed(source = "/spineboy.atlas", mimeType = "application/octet-stream")]
+		static public const SpineboyAtlas : Class;
 
-	[Embed(source = "/spineboy.png")]
-	static public const SpineboyAtlasTexture:Class;
+		[Embed(source = "/spineboy.png")]
+		static public const SpineboyAtlasTexture : Class;
+		private var skeleton : SkeletonAnimation;
 
-	private var skeleton:SkeletonAnimation;
+		public function SpineboyExample() {
+			var spineAtlas : Atlas = new Atlas(new SpineboyAtlas(), new StarlingTextureLoader(new SpineboyAtlasTexture()));
+			var attachmentLoader : AttachmentLoader = new AtlasAttachmentLoader(spineAtlas);
+			var json : SkeletonJson = new SkeletonJson(attachmentLoader);
+			json.scale = 0.6;
+			var skeletonData : SkeletonData = json.readSkeletonData(new SpineboyJson());
 
-	public function SpineboyExample () {
-		var spineAtlas:Atlas = new Atlas(new SpineboyAtlas(), new StarlingTextureLoader(new SpineboyAtlasTexture()));
-		var attachmentLoader:AttachmentLoader = new AtlasAttachmentLoader(spineAtlas);
-		var json:SkeletonJson = new SkeletonJson(attachmentLoader);
-		json.scale = 0.6;
-		var skeletonData:SkeletonData = json.readSkeletonData(new SpineboyJson());
+			var stateData : AnimationStateData = new AnimationStateData(skeletonData);
+			stateData.setMixByName("run", "jump", 0.4);
+			stateData.setMixByName("jump", "run", 0.4);
+			stateData.setMixByName("jump", "jump", 0.4);
 
-		var stateData:AnimationStateData = new AnimationStateData(skeletonData);
-		stateData.setMixByName("run", "jump", 0.4);
-		stateData.setMixByName("jump", "run", 0.4);
-		stateData.setMixByName("jump", "jump", 0.4);
+			skeleton = new SkeletonAnimation(skeletonData, stateData);
+			skeleton.x = 400;
+			skeleton.y = 560;
 
-		skeleton = new SkeletonAnimation(skeletonData, stateData);
-		skeleton.x = 400;
-		skeleton.y = 560;
-		
-		skeleton.state.onStart.add(function (entry:TrackEntry) : void {
-			trace(entry.trackIndex + " start: " + entry.animation.name);
-		});
-		skeleton.state.onInterrupt.add(function (entry:TrackEntry) : void {
-			trace(entry.trackIndex + " interrupt: " + entry.animation.name);
-		});
-		skeleton.state.onEnd.add(function (entry:TrackEntry) : void {
-			trace(entry.trackIndex + " end: " + entry.animation.name);
-		});
-		skeleton.state.onComplete.add(function (entry:TrackEntry) : void {
-			trace(entry.trackIndex + " complete: " + entry.animation.name);
-		});
-		skeleton.state.onDispose.add(function (entry:TrackEntry) : void {
-			trace(entry.trackIndex + " dispose: " + entry.animation.name);
-		});
-		skeleton.state.onEvent.add(function (entry:TrackEntry, event:Event) : void {
-			trace(entry.trackIndex + " event: " + entry.animation.name + ", "
-				+ event.data.name + ": " + event.intValue + ", " + event.floatValue + ", " + event.stringValue);
-		});
+			skeleton.state.onStart.add(function(entry : TrackEntry) : void {
+				trace(entry.trackIndex + " start: " + entry.animation.name);
+			});
+			skeleton.state.onInterrupt.add(function(entry : TrackEntry) : void {
+				trace(entry.trackIndex + " interrupt: " + entry.animation.name);
+			});
+			skeleton.state.onEnd.add(function(entry : TrackEntry) : void {
+				trace(entry.trackIndex + " end: " + entry.animation.name);
+			});
+			skeleton.state.onComplete.add(function(entry : TrackEntry) : void {
+				trace(entry.trackIndex + " complete: " + entry.animation.name);
+			});
+			skeleton.state.onDispose.add(function(entry : TrackEntry) : void {
+				trace(entry.trackIndex + " dispose: " + entry.animation.name);
+			});
+			skeleton.state.onEvent.add(function(entry : TrackEntry, event : Event) : void {
+				trace(entry.trackIndex + " event: " + entry.animation.name + ", " + event.data.name + ": " + event.intValue + ", " + event.floatValue + ", " + event.stringValue);
+			});
 
-		skeleton.skeleton.setToSetupPose();
-		skeleton.state.setAnimationByName(0, "run", true);
-		skeleton.state.addAnimationByName(0, "jump", false, 3);
-		skeleton.state.addAnimationByName(0, "run", true, 0);
+			skeleton.skeleton.setToSetupPose();
+			skeleton.state.setAnimationByName(0, "run", true);
+			skeleton.state.addAnimationByName(0, "jump", false, 3);
+			skeleton.state.addAnimationByName(0, "run", true, 0);
 
-		addChild(skeleton);
-		Starling.juggler.add(skeleton);
+			addChild(skeleton);
+			Starling.juggler.add(skeleton);
 
-		addEventListener(TouchEvent.TOUCH, onClick);
-	}
+			addEventListener(TouchEvent.TOUCH, onClick);
+		}
 
-	private function onClick (event:TouchEvent) : void {
-		var touch:Touch = event.getTouch(this);
-		if (touch && touch.phase == TouchPhase.BEGAN) {
-			skeleton.state.setAnimationByName(0, "jump", false);
-			skeleton.state.addAnimationByName(0, "run", true, 0);
+		private function onClick(event : TouchEvent) : void {
+			var touch : Touch = event.getTouch(this);
+			if (touch && touch.phase == TouchPhase.BEGAN) {
+				skeleton.state.setAnimationByName(0, "jump", false);
+				skeleton.state.addAnimationByName(0, "run", true, 0);
+			}
 		}
 	}
-}
-}
+}

spine-starling/spine-starling-example/src/spine/examples/StretchymanExample.as

@@ -29,70 +29,68 @@
  *****************************************************************************/
 
 package spine.examples {
-import spine.*;
-import spine.animation.AnimationStateData;
-import spine.animation.TrackEntry;
-import spine.atlas.Atlas;
-import spine.attachments.AtlasAttachmentLoader;
-import spine.attachments.AttachmentLoader;
-import spine.starling.SkeletonAnimation;
-import spine.starling.StarlingTextureLoader;
+	import spine.*;
+	import spine.animation.AnimationStateData;
+	import spine.animation.TrackEntry;
+	import spine.atlas.Atlas;
+	import spine.attachments.AtlasAttachmentLoader;
+	import spine.attachments.AttachmentLoader;
+	import spine.starling.SkeletonAnimation;
+	import spine.starling.StarlingTextureLoader;
 
-import starling.core.Starling;
-import starling.display.Sprite;
+	import starling.core.Starling;
+	import starling.display.Sprite;
 
-public class StretchymanExample extends Sprite {
-	[Embed(source = "/stretchyman.json", mimeType = "application/octet-stream")]
-	static public const StretchymanJson:Class;
+	public class StretchymanExample extends Sprite {
+		[Embed(source = "/stretchyman.json", mimeType = "application/octet-stream")]
+		static public const StretchymanJson : Class;
 
-	[Embed(source = "/stretchyman.atlas", mimeType = "application/octet-stream")]
-	static public const StretchymanAtlas:Class;
+		[Embed(source = "/stretchyman.atlas", mimeType = "application/octet-stream")]
+		static public const StretchymanAtlas : Class;
 
-	[Embed(source = "/stretchyman.png")]
-	static public const StretchymanAtlasTexture:Class;
+		[Embed(source = "/stretchyman.png")]
+		static public const StretchymanAtlasTexture : Class;
+		private var skeleton : SkeletonAnimation;
 
-	private var skeleton:SkeletonAnimation;
+		public function StretchymanExample() {
+			var spineAtlas : Atlas = new Atlas(new StretchymanAtlas(), new StarlingTextureLoader(new StretchymanAtlasTexture()));
+			var attachmentLoader : AttachmentLoader = new AtlasAttachmentLoader(spineAtlas);
+			var json : SkeletonJson = new SkeletonJson(attachmentLoader);
+			json.scale = 0.4;
+			var skeletonData : SkeletonData = json.readSkeletonData(new StretchymanJson());
 
-	public function StretchymanExample () {
-		var spineAtlas:Atlas = new Atlas(new StretchymanAtlas(), new StarlingTextureLoader(new StretchymanAtlasTexture()));
-		var attachmentLoader:AttachmentLoader = new AtlasAttachmentLoader(spineAtlas);
-		var json:SkeletonJson = new SkeletonJson(attachmentLoader);
-		json.scale = 0.4;
-		var skeletonData:SkeletonData = json.readSkeletonData(new StretchymanJson());
+			var stateData : AnimationStateData = new AnimationStateData(skeletonData);
 
-		var stateData:AnimationStateData = new AnimationStateData(skeletonData);
+			skeleton = new SkeletonAnimation(skeletonData, stateData);
+			skeleton.x = 100;
+			skeleton.y = 560;
 
-		skeleton = new SkeletonAnimation(skeletonData, stateData);
-		skeleton.x = 100;
-		skeleton.y = 560;
-		
-		skeleton.state.timeScale = 0.1;
-		
-		skeleton.state.onStart.add(function (entry:TrackEntry) : void {
-			trace(entry.trackIndex + " start: " + entry.animation.name);
-		});
-		skeleton.state.onInterrupt.add(function (entry:TrackEntry) : void {
-			trace(entry.trackIndex + " interrupt: " + entry.animation.name);
-		});
-		skeleton.state.onEnd.add(function (entry:TrackEntry) : void {
-			trace(entry.trackIndex + " end: " + entry.animation.name);
-		});
-		skeleton.state.onComplete.add(function (entry:TrackEntry) : void {
-			trace(entry.trackIndex + " complete: " + entry.animation.name);
-		});
-		skeleton.state.onDispose.add(function (entry:TrackEntry) : void {
-			trace(entry.trackIndex + " dispose: " + entry.animation.name);
-		});
-		skeleton.state.onEvent.add(function (entry:TrackEntry, event:Event) : void {
-			trace(entry.trackIndex + " event: " + entry.animation.name + ", "
-				+ event.data.name + ": " + event.intValue + ", " + event.floatValue + ", " + event.stringValue);
-		});
+			skeleton.state.timeScale = 0.1;
 
-		skeleton.skeleton.setToSetupPose();
-		skeleton.state.setAnimationByName(0, "sneak", true);
+			skeleton.state.onStart.add(function(entry : TrackEntry) : void {
+				trace(entry.trackIndex + " start: " + entry.animation.name);
+			});
+			skeleton.state.onInterrupt.add(function(entry : TrackEntry) : void {
+				trace(entry.trackIndex + " interrupt: " + entry.animation.name);
+			});
+			skeleton.state.onEnd.add(function(entry : TrackEntry) : void {
+				trace(entry.trackIndex + " end: " + entry.animation.name);
+			});
+			skeleton.state.onComplete.add(function(entry : TrackEntry) : void {
+				trace(entry.trackIndex + " complete: " + entry.animation.name);
+			});
+			skeleton.state.onDispose.add(function(entry : TrackEntry) : void {
+				trace(entry.trackIndex + " dispose: " + entry.animation.name);
+			});
+			skeleton.state.onEvent.add(function(entry : TrackEntry, event : Event) : void {
+				trace(entry.trackIndex + " event: " + entry.animation.name + ", " + event.data.name + ": " + event.intValue + ", " + event.floatValue + ", " + event.stringValue);
+			});
 
-		addChild(skeleton);
-		Starling.juggler.add(skeleton);		
+			skeleton.skeleton.setToSetupPose();
+			skeleton.state.setAnimationByName(0, "sneak", true);
+
+			addChild(skeleton);
+			Starling.juggler.add(skeleton);
+		}
 	}
-}
-}
+}

spine-starling/spine-starling-example/src/spine/examples/TankExample.as

@@ -29,44 +29,43 @@
  *****************************************************************************/
 
 package spine.examples {
-import spine.atlas.Atlas;
-import spine.*;
-import spine.attachments.AtlasAttachmentLoader;
-import spine.attachments.AttachmentLoader;
-import spine.starling.SkeletonAnimation;
-import spine.starling.StarlingTextureLoader;
+	import spine.atlas.Atlas;
+	import spine.*;
+	import spine.attachments.AtlasAttachmentLoader;
+	import spine.attachments.AttachmentLoader;
+	import spine.starling.SkeletonAnimation;
+	import spine.starling.StarlingTextureLoader;
 
-import starling.core.Starling;
-import starling.display.Sprite;
+	import starling.core.Starling;
+	import starling.display.Sprite;
 
-public class TankExample extends Sprite {
-	[Embed(source = "/tank.json", mimeType = "application/octet-stream")]
-	static public const TankJson:Class;
-	
-	[Embed(source = "/tank.atlas", mimeType = "application/octet-stream")]
-	static public const TankAtlas:Class;
-	
-	[Embed(source = "/tank.png")]
-	static public const TankAtlasTexture:Class;
-	
-	private var skeleton:SkeletonAnimation;	
+	public class TankExample extends Sprite {
+		[Embed(source = "/tank.json", mimeType = "application/octet-stream")]
+		static public const TankJson : Class;
 
-	public function TankExample () {
-		var attachmentLoader:AttachmentLoader;
-		var spineAtlas:Atlas = new Atlas(new TankAtlas(), new StarlingTextureLoader(new TankAtlasTexture()));
-		attachmentLoader = new AtlasAttachmentLoader(spineAtlas);
+		[Embed(source = "/tank.atlas", mimeType = "application/octet-stream")]
+		static public const TankAtlas : Class;
 
-		var json:SkeletonJson = new SkeletonJson(attachmentLoader);
-		json.scale = 0.5;
-		var skeletonData:SkeletonData = json.readSkeletonData(new TankJson());
+		[Embed(source = "/tank.png")]
+		static public const TankAtlasTexture : Class;
+		private var skeleton : SkeletonAnimation;
 
-		skeleton = new SkeletonAnimation(skeletonData);
-		skeleton.x = 400;
-		skeleton.y = 560;
-		skeleton.state.setAnimationByName(0, "drive", true);
+		public function TankExample() {
+			var attachmentLoader : AttachmentLoader;
+			var spineAtlas : Atlas = new Atlas(new TankAtlas(), new StarlingTextureLoader(new TankAtlasTexture()));
+			attachmentLoader = new AtlasAttachmentLoader(spineAtlas);
 
-		addChild(skeleton);
-		Starling.juggler.add(skeleton);	
-	}	
-}
-}
+			var json : SkeletonJson = new SkeletonJson(attachmentLoader);
+			json.scale = 0.5;
+			var skeletonData : SkeletonData = json.readSkeletonData(new TankJson());
+
+			skeleton = new SkeletonAnimation(skeletonData);
+			skeleton.x = 400;
+			skeleton.y = 560;
+			skeleton.state.setAnimationByName(0, "drive", true);
+
+			addChild(skeleton);
+			Starling.juggler.add(skeleton);
+		}
+	}
+}

spine-starling/spine-starling-example/src/spine/examples/VineExample.as

@@ -29,44 +29,43 @@
  *****************************************************************************/
 
 package spine.examples {
-import spine.*;
-import spine.atlas.Atlas;
-import spine.attachments.AtlasAttachmentLoader;
-import spine.attachments.AttachmentLoader;
-import spine.starling.SkeletonAnimation;
-import spine.starling.StarlingTextureLoader;
+	import spine.*;
+	import spine.atlas.Atlas;
+	import spine.attachments.AtlasAttachmentLoader;
+	import spine.attachments.AttachmentLoader;
+	import spine.starling.SkeletonAnimation;
+	import spine.starling.StarlingTextureLoader;
 
-import starling.core.Starling;
-import starling.display.Sprite;
+	import starling.core.Starling;
+	import starling.display.Sprite;
 
-public class VineExample extends Sprite {
-	[Embed(source = "/vine.json", mimeType = "application/octet-stream")]
-	static public const VineJson:Class;
-	
-	[Embed(source = "/vine.atlas", mimeType = "application/octet-stream")]
-	static public const VineAtlas:Class;
-	
-	[Embed(source = "/vine.png")]
-	static public const VineAtlasTexture:Class;
-	
-	private var skeleton:SkeletonAnimation;	
+	public class VineExample extends Sprite {
+		[Embed(source = "/vine.json", mimeType = "application/octet-stream")]
+		static public const VineJson : Class;
 
-	public function VineExample () {
-		var attachmentLoader:AttachmentLoader;
-		var spineAtlas:Atlas = new Atlas(new VineAtlas(), new StarlingTextureLoader(new VineAtlasTexture()));
-		attachmentLoader = new AtlasAttachmentLoader(spineAtlas);
+		[Embed(source = "/vine.atlas", mimeType = "application/octet-stream")]
+		static public const VineAtlas : Class;
 
-		var json:SkeletonJson = new SkeletonJson(attachmentLoader);
-		json.scale = 0.5;
-		var skeletonData:SkeletonData = json.readSkeletonData(new VineJson());
+		[Embed(source = "/vine.png")]
+		static public const VineAtlasTexture : Class;
+		private var skeleton : SkeletonAnimation;
 
-		skeleton = new SkeletonAnimation(skeletonData);
-		skeleton.x = 400;
-		skeleton.y = 560;
-		skeleton.state.setAnimationByName(0, "animation", true);
+		public function VineExample() {
+			var attachmentLoader : AttachmentLoader;
+			var spineAtlas : Atlas = new Atlas(new VineAtlas(), new StarlingTextureLoader(new VineAtlasTexture()));
+			attachmentLoader = new AtlasAttachmentLoader(spineAtlas);
 
-		addChild(skeleton);
-		Starling.juggler.add(skeleton);		
-	}	
-}
-}
+			var json : SkeletonJson = new SkeletonJson(attachmentLoader);
+			json.scale = 0.5;
+			var skeletonData : SkeletonData = json.readSkeletonData(new VineJson());
+
+			skeleton = new SkeletonAnimation(skeletonData);
+			skeleton.x = 400;
+			skeleton.y = 560;
+			skeleton.state.setAnimationByName(0, "animation", true);
+
+			addChild(skeleton);
+			Starling.juggler.add(skeleton);
+		}
+	}
+}

spine-starling/spine-starling/src/spine/starling/SkeletonAnimation.as

@@ -29,29 +29,28 @@
  *****************************************************************************/
 
 package spine.starling {
-import spine.SkeletonData;
-import spine.animation.AnimationState;
-import spine.animation.AnimationStateData;
+	import spine.SkeletonData;
+	import spine.animation.AnimationState;
+	import spine.animation.AnimationStateData;
 
-import starling.animation.IAnimatable;
+	import starling.animation.IAnimatable;
 
-public class SkeletonAnimation extends SkeletonSprite implements IAnimatable {
-	public var state:AnimationState;
-	public var timeScale:Number = 1;
+	public class SkeletonAnimation extends SkeletonSprite implements IAnimatable {
+		public var state : AnimationState;
+		public var timeScale : Number = 1;
 
-	public function SkeletonAnimation (skeletonData:SkeletonData, stateData:AnimationStateData = null) {
-		super(skeletonData);
-		state = new AnimationState(stateData ? stateData : new AnimationStateData(skeletonData));
-	}
+		public function SkeletonAnimation(skeletonData : SkeletonData, stateData : AnimationStateData = null) {
+			super(skeletonData);
+			state = new AnimationState(stateData ? stateData : new AnimationStateData(skeletonData));
+		}
 
-	public function advanceTime (time:Number) : void {
-		time *= timeScale;
-		skeleton.update(time);
-		state.update(time);
-		state.apply(skeleton);
-		skeleton.updateWorldTransform();
-		this.setRequiresRedraw();
+		public function advanceTime(time : Number) : void {
+			time *= timeScale;
+			skeleton.update(time);
+			state.update(time);
+			state.apply(skeleton);
+			skeleton.updateWorldTransform();
+			this.setRequiresRedraw();
+		}
 	}
-}
-
-}
+}

spine-starling/spine-starling/src/spine/starling/SkeletonMesh.as

@@ -29,26 +29,24 @@
  *****************************************************************************/
 
 package spine.starling {
-import starling.textures.Texture;
-import starling.styles.MeshStyle;
-import starling.rendering.IndexData;
-import starling.rendering.VertexData;
-import starling.display.Mesh;
+	import starling.textures.Texture;
+	import starling.styles.MeshStyle;
+	import starling.rendering.IndexData;
+	import starling.rendering.VertexData;
+	import starling.display.Mesh;
 
-public class SkeletonMesh extends Mesh {
+	public class SkeletonMesh extends Mesh {
+		public function SkeletonMesh(texture : Texture, vertexData : VertexData = null, indexData : IndexData = null, style : MeshStyle = null) {
+			super(vertexData == null ? new VertexData() : vertexData, indexData == null ? new IndexData() : indexData, style);
+			this.texture = texture;
+		}
 
-	public function SkeletonMesh(texture:Texture, vertexData:VertexData = null, indexData:IndexData = null, style:MeshStyle=null) {
-		super(vertexData == null? new VertexData(): vertexData, indexData == null? new IndexData(): indexData, style);
-		this.texture = texture;
-	}
-
-	public function getVertexData(): VertexData {
-		return this.vertexData;
-	}
+		public function getVertexData() : VertexData {
+			return this.vertexData;
+		}
 
-	public function getIndexData(): IndexData {
-		return this.indexData;
+		public function getIndexData() : IndexData {
+			return this.indexData;
+		}
 	}
-}
-
-}
+}

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

@@ -29,250 +29,241 @@
  *****************************************************************************/
 
 package spine.starling {
-import spine.Bone;
-import spine.Skeleton;
-import spine.SkeletonData;
-import spine.Slot;
-import spine.atlas.AtlasRegion;
-import spine.attachments.Attachment;
-import spine.attachments.MeshAttachment;
-import spine.attachments.RegionAttachment;
+	import spine.Bone;
+	import spine.Skeleton;
+	import spine.SkeletonData;
+	import spine.Slot;
+	import spine.atlas.AtlasRegion;
+	import spine.attachments.Attachment;
+	import spine.attachments.MeshAttachment;
+	import spine.attachments.RegionAttachment;
 
-import starling.display.BlendMode;
-import starling.display.DisplayObject;
-import starling.display.Image;
-import starling.rendering.IndexData;
-import starling.rendering.Painter;
-import starling.rendering.VertexData;
-import starling.utils.Color;
-import starling.utils.MatrixUtil;
+	import starling.display.BlendMode;
+	import starling.display.DisplayObject;
+	import starling.display.Image;
+	import starling.rendering.IndexData;
+	import starling.rendering.Painter;
+	import starling.rendering.VertexData;
+	import starling.utils.Color;
+	import starling.utils.MatrixUtil;
 
-import flash.geom.Matrix;
-import flash.geom.Point;
-import flash.geom.Rectangle;
+	import flash.geom.Matrix;
+	import flash.geom.Point;
+	import flash.geom.Rectangle;
 
-public class SkeletonSprite extends DisplayObject {
-	static private var _tempPoint:Point = new Point();
-	static private var _tempMatrix:Matrix = new Matrix();
-	static private var _tempVertices:Vector.<Number> = new Vector.<Number>(8);
-	static internal var blendModes:Vector.<String> = new <String>[
-		BlendMode.NORMAL, BlendMode.ADD, BlendMode.MULTIPLY, BlendMode.SCREEN];
+	public class SkeletonSprite extends DisplayObject {
+		static private var _tempPoint : Point = new Point();
+		static private var _tempMatrix : Matrix = new Matrix();
+		static private var _tempVertices : Vector.<Number> = new Vector.<Number>(8);
+		static internal var blendModes : Vector.<String> = new <String>[BlendMode.NORMAL, BlendMode.ADD, BlendMode.MULTIPLY, BlendMode.SCREEN];
+		private var _skeleton : Skeleton;
+		public var batchable : Boolean = true;
+		private var _smoothing : String = "bilinear";
+		private static var _twoColorStyle : TwoColorMeshStyle;
 
-	private var _skeleton:Skeleton;
-	public var batchable:Boolean = true;
-	private var _smoothing:String = "bilinear";	
-	private static var _twoColorStyle:TwoColorMeshStyle;
-
-	public function SkeletonSprite (skeletonData:SkeletonData) {
-		Bone.yDown = true;
-		_skeleton = new Skeleton(skeletonData);
-		_skeleton.updateWorldTransform();
-		if (_twoColorStyle == null) {
-			_twoColorStyle = new TwoColorMeshStyle();
+		public function SkeletonSprite(skeletonData : SkeletonData) {
+			Bone.yDown = true;
+			_skeleton = new Skeleton(skeletonData);
+			_skeleton.updateWorldTransform();
+			if (_twoColorStyle == null) {
+				_twoColorStyle = new TwoColorMeshStyle();
+			}
 		}
-	}
 
-	override public function render (painter:Painter) : void {
-		painter.state.alpha *= skeleton.color.a;
-		var originalBlendMode:String = painter.state.blendMode;
-		var r:Number = skeleton.color.r * 255;
-		var g:Number = skeleton.color.g * 255;
-		var b:Number = skeleton.color.b * 255;
-		var drawOrder:Vector.<Slot> = skeleton.drawOrder;
-		var worldVertices:Vector.<Number> = _tempVertices;
-		var ii:int, iii:int;
-		var rgb:uint, a:Number;
-		var dark:uint;
-		var mesh:SkeletonMesh;
-		var verticesLength:int, verticesCount:int, indicesLength:int;
-		var indexData:IndexData, indices:Vector.<uint>, vertexData:VertexData;
-		var uvs: Vector.<Number>;		
+		override public function render(painter : Painter) : void {
+			painter.state.alpha *= skeleton.color.a;
+			var originalBlendMode : String = painter.state.blendMode;
+			var r : Number = skeleton.color.r * 255;
+			var g : Number = skeleton.color.g * 255;
+			var b : Number = skeleton.color.b * 255;
+			var drawOrder : Vector.<Slot> = skeleton.drawOrder;
+			var worldVertices : Vector.<Number> = _tempVertices;
+			var ii : int, iii : int;
+			var rgb : uint, a : Number;
+			var dark : uint;
+			var mesh : SkeletonMesh;
+			var verticesLength : int, verticesCount : int, indicesLength : int;
+			var indexData : IndexData, indices : Vector.<uint>, vertexData : VertexData;
+			var uvs : Vector.<Number>;
 
-		for (var i:int = 0, n:int = drawOrder.length; i < n; ++i) {
-			var slot:Slot = drawOrder[i];
-			if (slot.attachment is RegionAttachment) {
-				var region:RegionAttachment = slot.attachment as RegionAttachment;
-				region.computeWorldVertices(slot.bone, worldVertices, 0, 2);				
-				a = slot.color.a * region.color.a;
-				rgb = Color.rgb(
-					r * slot.color.r * region.color.r,
-					g * slot.color.g * region.color.g,
-					b * slot.color.b * region.color.b);
+			for (var i : int = 0, n : int = drawOrder.length; i < n; ++i) {
+				var slot : Slot = drawOrder[i];
+				if (slot.attachment is RegionAttachment) {
+					var region : RegionAttachment = slot.attachment as RegionAttachment;
+					region.computeWorldVertices(slot.bone, worldVertices, 0, 2);
+					a = slot.color.a * region.color.a;
+					rgb = Color.rgb(r * slot.color.r * region.color.r, g * slot.color.g * region.color.g, b * slot.color.b * region.color.b);
 
-				var image:Image = region.rendererObject as Image;				
-				if (image == null) {
-					var origImage:Image = Image(AtlasRegion(region.rendererObject).rendererObject);					
-					region.rendererObject = image = new Image(origImage.texture);
-					image.style = _twoColorStyle;
-					for (var j:int = 0; j < 4; j++) {
-						var p: Point = origImage.getTexCoords(j);
-						image.setTexCoords(j, p.x, p.y);
+					var image : Image = region.rendererObject as Image;
+					if (image == null) {
+						var origImage : Image = Image(AtlasRegion(region.rendererObject).rendererObject);
+						region.rendererObject = image = new Image(origImage.texture);
+						image.style = _twoColorStyle;
+						for (var j : int = 0; j < 4; j++) {
+							var p : Point = origImage.getTexCoords(j);
+							image.setTexCoords(j, p.x, p.y);
+						}
 					}
-				}
-								
-				if (slot.darkColor == null) dark = Color.rgb(0, 0, 0);
-				else dark = Color.rgb(slot.darkColor.r * 255, slot.darkColor.g * 255, slot.darkColor.b * 255);						
 
-				image.setVertexPosition(0, worldVertices[2], worldVertices[3]);
-				image.setVertexColor(0, rgb);
-				image.setVertexAlpha(0, a);				
+					if (slot.darkColor == null) dark = Color.rgb(0, 0, 0);
+					else dark = Color.rgb(slot.darkColor.r * 255, slot.darkColor.g * 255, slot.darkColor.b * 255);
 
-				image.setVertexPosition(1, worldVertices[4], worldVertices[5]);
-				image.setVertexColor(1, rgb);
-				image.setVertexAlpha(1, a);
+					image.setVertexPosition(0, worldVertices[2], worldVertices[3]);
+					image.setVertexColor(0, rgb);
+					image.setVertexAlpha(0, a);
 
-				image.setVertexPosition(2, worldVertices[0], worldVertices[1]);
-				image.setVertexColor(2, rgb);
-				image.setVertexAlpha(2, a);
+					image.setVertexPosition(1, worldVertices[4], worldVertices[5]);
+					image.setVertexColor(1, rgb);
+					image.setVertexAlpha(1, a);
 
-				image.setVertexPosition(3, worldVertices[6], worldVertices[7]);
-				image.setVertexColor(3, rgb);
-				image.setVertexAlpha(3, a);
+					image.setVertexPosition(2, worldVertices[0], worldVertices[1]);
+					image.setVertexColor(2, rgb);
+					image.setVertexAlpha(2, a);
 
-				image.setRequiresRedraw();
-				painter.state.blendMode = blendModes[slot.data.blendMode.ordinal];
-				// FIXME set smoothing/filter
-				painter.batchMesh(image);
-			} else if (slot.attachment is MeshAttachment) {
-				var meshAttachment:MeshAttachment = MeshAttachment(slot.attachment);
-				verticesLength = meshAttachment.worldVerticesLength;
-				verticesCount = verticesLength >> 1;
-				if (worldVertices.length < verticesLength) worldVertices.length = verticesLength;
-				meshAttachment.computeWorldVertices(slot, 0, meshAttachment.worldVerticesLength, worldVertices, 0, 2);
-				mesh = meshAttachment.rendererObject as SkeletonMesh;
-				if (mesh == null) {
-					if (meshAttachment.rendererObject is Image)
-						meshAttachment.rendererObject = mesh = new SkeletonMesh(Image(meshAttachment.rendererObject).texture);
-					if (meshAttachment.rendererObject is AtlasRegion)
-						meshAttachment.rendererObject = mesh = new SkeletonMesh(Image(AtlasRegion(meshAttachment.rendererObject).rendererObject).texture);				
-				}
+					image.setVertexPosition(3, worldVertices[6], worldVertices[7]);
+					image.setVertexColor(3, rgb);
+					image.setVertexAlpha(3, a);
 
-				if (mesh.numIndices != meshAttachment.triangles.length) {
-					indexData = mesh.getIndexData();
-					indices = meshAttachment.triangles;
-					indicesLength = meshAttachment.triangles.length;
-					for (ii = 0; ii < indicesLength; ii++) {
-						indexData.setIndex(ii, indices[ii]);
+					image.setRequiresRedraw();
+					painter.state.blendMode = blendModes[slot.data.blendMode.ordinal];
+					// FIXME set smoothing/filter
+					painter.batchMesh(image);
+				} else if (slot.attachment is MeshAttachment) {
+					var meshAttachment : MeshAttachment = MeshAttachment(slot.attachment);
+					verticesLength = meshAttachment.worldVerticesLength;
+					verticesCount = verticesLength >> 1;
+					if (worldVertices.length < verticesLength) worldVertices.length = verticesLength;
+					meshAttachment.computeWorldVertices(slot, 0, meshAttachment.worldVerticesLength, worldVertices, 0, 2);
+					mesh = meshAttachment.rendererObject as SkeletonMesh;
+					if (mesh == null) {
+						if (meshAttachment.rendererObject is Image)
+							meshAttachment.rendererObject = mesh = new SkeletonMesh(Image(meshAttachment.rendererObject).texture);
+						if (meshAttachment.rendererObject is AtlasRegion)
+							meshAttachment.rendererObject = mesh = new SkeletonMesh(Image(AtlasRegion(meshAttachment.rendererObject).rendererObject).texture);
+					}
+
+					if (mesh.numIndices != meshAttachment.triangles.length) {
+						indexData = mesh.getIndexData();
+						indices = meshAttachment.triangles;
+						indicesLength = meshAttachment.triangles.length;
+						for (ii = 0; ii < indicesLength; ii++) {
+							indexData.setIndex(ii, indices[ii]);
+						}
+						indexData.numIndices = indicesLength;
+						indexData.trim();
 					}
-					indexData.numIndices = indicesLength;
-					indexData.trim();
-				}
 
-				// FIXME pre-multiplied alpha?
-				a = slot.color.a * meshAttachment.color.a;
-				rgb = Color.rgb(
-					r * slot.color.r * meshAttachment.color.r,
-					g * slot.color.g * meshAttachment.color.g,
-					b * slot.color.b * meshAttachment.color.b);
-					
-				if (slot.darkColor == null) dark = Color.rgb(0, 0, 0);
-				else dark = Color.rgb(slot.darkColor.r * 255, slot.darkColor.g * 255, slot.darkColor.b * 255);
+					// FIXME pre-multiplied alpha?
+					a = slot.color.a * meshAttachment.color.a;
+					rgb = Color.rgb(r * slot.color.r * meshAttachment.color.r, g * slot.color.g * meshAttachment.color.g, b * slot.color.b * meshAttachment.color.b);
 
-				if (mesh.style.vertexFormat != _twoColorStyle.vertexFormat) 
-					mesh.style = _twoColorStyle;
-				vertexData = mesh.getVertexData();
-				uvs = meshAttachment.uvs;				
-				vertexData.colorize("color", rgb, a);						
-				vertexData.colorize("color2", dark);
-				for (ii = 0, iii = 0; ii < verticesCount; ii++, iii+=2) {
-					mesh.setVertexPosition(ii, worldVertices[iii], worldVertices[iii+1]);
-					mesh.setTexCoords(ii, uvs[iii], uvs[iii+1]);					
+					if (slot.darkColor == null) dark = Color.rgb(0, 0, 0);
+					else dark = Color.rgb(slot.darkColor.r * 255, slot.darkColor.g * 255, slot.darkColor.b * 255);
+
+					if (mesh.style.vertexFormat != _twoColorStyle.vertexFormat)
+						mesh.style = _twoColorStyle;
+					vertexData = mesh.getVertexData();
+					uvs = meshAttachment.uvs;
+					vertexData.colorize("color", rgb, a);
+					vertexData.colorize("color2", dark);
+					for (ii = 0, iii = 0; ii < verticesCount; ii++, iii += 2) {
+						mesh.setVertexPosition(ii, worldVertices[iii], worldVertices[iii + 1]);
+						mesh.setTexCoords(ii, uvs[iii], uvs[iii + 1]);
+					}
+					vertexData.numVertices = verticesCount;
+					painter.state.blendMode = blendModes[slot.data.blendMode.ordinal];
+					// FIXME set smoothing/filter
+					painter.batchMesh(mesh);
 				}
-				vertexData.numVertices = verticesCount;
-				painter.state.blendMode = blendModes[slot.data.blendMode.ordinal];
-				// FIXME set smoothing/filter
-				painter.batchMesh(mesh);
 			}
+			painter.state.blendMode = originalBlendMode;
 		}
-		painter.state.blendMode = originalBlendMode;
-	}
 
-	override public function hitTest (localPoint:Point) : DisplayObject {
-		// FIXME what to do here?
-//		if (forTouch && (!visible || !touchable))
-//			return null;
+		override public function hitTest(localPoint : Point) : DisplayObject {
+			// FIXME what to do here?
+			// if (forTouch && (!visible || !touchable))
+			// return null;
+
+			var minX : Number = Number.MAX_VALUE, minY : Number = Number.MAX_VALUE;
+			var maxX : Number = -Number.MAX_VALUE, maxY : Number = -Number.MAX_VALUE;
+			var slots : Vector.<Slot> = skeleton.slots;
+			var worldVertices : Vector.<Number> = _tempVertices;
+			var empty : Boolean = true;
+			for (var i : int = 0, n : int = slots.length; i < n; ++i) {
+				var slot : Slot = slots[i];
+				var attachment : Attachment = slot.attachment;
+				if (!attachment) continue;
+				var verticesLength : int;
+				if (attachment is RegionAttachment) {
+					var region : RegionAttachment = RegionAttachment(slot.attachment);
+					verticesLength = 8;
+					region.computeWorldVertices(slot.bone, worldVertices, 0, 2);
+				} else if (attachment is MeshAttachment) {
+					var mesh : MeshAttachment = MeshAttachment(attachment);
+					verticesLength = mesh.worldVerticesLength;
+					if (worldVertices.length < verticesLength) worldVertices.length = verticesLength;
+					mesh.computeWorldVertices(slot, 0, verticesLength, worldVertices, 0, 2);
+				} else
+					continue;
 
-		var minX:Number = Number.MAX_VALUE, minY:Number = Number.MAX_VALUE;
-		var maxX:Number = -Number.MAX_VALUE, maxY:Number = -Number.MAX_VALUE;
-		var slots:Vector.<Slot> = skeleton.slots;
-		var worldVertices:Vector.<Number> = _tempVertices;
-		var empty:Boolean = true;
-		for (var i:int = 0, n:int = slots.length; i < n; ++i) {
-			var slot:Slot = slots[i];
-			var attachment:Attachment = slot.attachment;
-			if (!attachment) continue;
-			var verticesLength:int;
-			if (attachment is RegionAttachment) {
-				var region:RegionAttachment = RegionAttachment(slot.attachment);
-				verticesLength = 8;
-				region.computeWorldVertices(slot.bone, worldVertices, 0, 2);
-			} else if (attachment is MeshAttachment) {
-				var mesh:MeshAttachment = MeshAttachment(attachment);
-				verticesLength = mesh.worldVerticesLength;
-				if (worldVertices.length < verticesLength) worldVertices.length = verticesLength;
-				mesh.computeWorldVertices(slot, 0, verticesLength, worldVertices, 0, 2);
-			} else
-				continue;
-				
-			if (verticesLength != 0)
-				empty = false;
-			  
-			for (var ii:int = 0; ii < verticesLength; ii += 2) {
-				var x:Number = worldVertices[ii], y:Number = worldVertices[ii + 1];
-				minX = minX < x ? minX : x;
-				minY = minY < y ? minY : y;
-				maxX = maxX > x ? maxX : x;
-				maxY = maxY > y ? maxY : y;
+				if (verticesLength != 0)
+					empty = false;
+
+				for (var ii : int = 0; ii < verticesLength; ii += 2) {
+					var x : Number = worldVertices[ii], y : Number = worldVertices[ii + 1];
+					minX = minX < x ? minX : x;
+					minY = minY < y ? minY : y;
+					maxX = maxX > x ? maxX : x;
+					maxY = maxY > y ? maxY : y;
+				}
 			}
-		}
-		
-		if (empty)
-			return null;
 
-		var temp:Number;
-		if (maxX < minX) {
-			temp = maxX;
-			maxX = minX;
-			minX = temp;
-		}
-		if (maxY < minY) {
-			temp = maxY;
-			maxY = minY;
-			minY = temp;
-		}
+			if (empty)
+				return null;
 
-		if (localPoint.x >= minX && localPoint.x < maxX && localPoint.y >= minY && localPoint.y < maxY)
-			return this;
+			var temp : Number;
+			if (maxX < minX) {
+				temp = maxX;
+				maxX = minX;
+				minX = temp;
+			}
+			if (maxY < minY) {
+				temp = maxY;
+				maxY = minY;
+				minY = temp;
+			}
 
-		return null;
-	}
+			if (localPoint.x >= minX && localPoint.x < maxX && localPoint.y >= minY && localPoint.y < maxY)
+				return this;
 
-	override public function getBounds (targetSpace:DisplayObject, resultRect:Rectangle = null) : Rectangle {
-		if (!resultRect)
-			resultRect = new Rectangle();
-		if (targetSpace == this)
-			resultRect.setTo(0, 0, 0, 0);
-		else if (targetSpace == parent)
-			resultRect.setTo(x, y, 0, 0);
-		else {
-			getTransformationMatrix(targetSpace, _tempMatrix);
-			MatrixUtil.transformCoords(_tempMatrix, 0, 0, _tempPoint);
-			resultRect.setTo(_tempPoint.x, _tempPoint.y, 0, 0);
+			return null;
 		}
-		return resultRect;
-	}
 
-	public function get skeleton () : Skeleton {
-		return _skeleton;
-	}
+		override public function getBounds(targetSpace : DisplayObject, resultRect : Rectangle = null) : Rectangle {
+			if (!resultRect)
+				resultRect = new Rectangle();
+			if (targetSpace == this)
+				resultRect.setTo(0, 0, 0, 0);
+			else if (targetSpace == parent)
+				resultRect.setTo(x, y, 0, 0);
+			else {
+				getTransformationMatrix(targetSpace, _tempMatrix);
+				MatrixUtil.transformCoords(_tempMatrix, 0, 0, _tempPoint);
+				resultRect.setTo(_tempPoint.x, _tempPoint.y, 0, 0);
+			}
+			return resultRect;
+		}
 
-	public function get smoothing () : String {
-		return _smoothing;
-	}
+		public function get skeleton() : Skeleton {
+			return _skeleton;
+		}
 
-	public function set smoothing (smoothing:String) : void {
-		_smoothing = smoothing;
-	}
-}
+		public function get smoothing() : String {
+			return _smoothing;
+		}
 
-}
+		public function set smoothing(smoothing : String) : void {
+			_smoothing = smoothing;
+		}
+	}
+}

spine-starling/spine-starling/src/spine/starling/StarlingAtlasAttachmentLoader.as

@@ -30,104 +30,104 @@
 
 package spine.starling {
 	import spine.attachments.PointAttachment;
-import spine.attachments.PathAttachment;
-import starling.display.Image;
-import spine.Bone;
-import spine.Skin;
-import spine.attachments.AttachmentLoader;
-import spine.attachments.BoundingBoxAttachment;
-import spine.attachments.MeshAttachment;
-import spine.attachments.RegionAttachment;
+	import spine.attachments.PathAttachment;
 
-import starling.textures.SubTexture;
-import starling.textures.Texture;
-import starling.textures.TextureAtlas;
+	import starling.display.Image;
 
-import flash.geom.Rectangle;
+	import spine.Bone;
+	import spine.Skin;
+	import spine.attachments.AttachmentLoader;
+	import spine.attachments.BoundingBoxAttachment;
+	import spine.attachments.MeshAttachment;
+	import spine.attachments.RegionAttachment;
 
-public class StarlingAtlasAttachmentLoader implements AttachmentLoader {
-	private var atlas:TextureAtlas;
+	import starling.textures.SubTexture;
+	import starling.textures.Texture;
+	import starling.textures.TextureAtlas;
 
-	public function StarlingAtlasAttachmentLoader (atlas:TextureAtlas) {
-		this.atlas = atlas;
+	import flash.geom.Rectangle;
 
-		Bone.yDown = true;
-	}
+	public class StarlingAtlasAttachmentLoader implements AttachmentLoader {
+		private var atlas : TextureAtlas;
+
+		public function StarlingAtlasAttachmentLoader(atlas : TextureAtlas) {
+			this.atlas = atlas;
 
-	public function newRegionAttachment (skin:Skin, name:String, path:String) : RegionAttachment {
-		var texture:Texture = atlas.getTexture(path);
-		if (texture == null)
-			throw new Error("Region not found in Starling atlas: " + path + " (region attachment: " + name + ")");
-		var attachment:RegionAttachment = new RegionAttachment(name);
-		attachment.rendererObject = new Image(Texture.fromTexture(texture)); // Discard frame.
-		var frame:Rectangle = texture.frame;
-		attachment.regionOffsetX = frame ? -frame.x : 0;
-		attachment.regionOffsetY = frame ? -frame.y : 0;
-		attachment.regionWidth = texture.width;
-		attachment.regionHeight = texture.height;
-		attachment.regionOriginalWidth = frame ? frame.width : texture.width;
-		attachment.regionOriginalHeight = frame ? frame.height : texture.height;
-		var subTexture:SubTexture = texture as SubTexture;
-		if (subTexture) {
-			var root:Texture = subTexture.root;
-			var rectRegion:Rectangle = atlas.getRegion(path);
-			attachment["regionU"] = rectRegion.x / root.width;
-			attachment["regionV"] = rectRegion.y / root.height;
-			attachment["regionU2"] = (rectRegion.x + subTexture.width) / root.width;
-			attachment["regionV2"] = (rectRegion.y + subTexture.height) / root.height;
-			attachment.setUVs(attachment["regionU"], attachment["regionV"], attachment["regionU2"], attachment["regionV2"],
-				atlas.getRotation(path));
-		} else {
-			attachment["regionU"] = 0;
-			attachment["regionV"] = 1;
-			attachment["regionU2"] = 1;
-			attachment["regionV2"] = 0;
+			Bone.yDown = true;
 		}
-		return attachment;
-	}
 
-	public function newMeshAttachment (skin:Skin, name:String, path:String) : MeshAttachment {
-		var texture:Texture = atlas.getTexture(path);
-		if (texture == null)
-			throw new Error("Region not found in Starling atlas: " + path + " (mesh attachment: " + name + ")");
-		var attachment:MeshAttachment = new MeshAttachment(name);
-		attachment.rendererObject = new Image(Texture.fromTexture(texture)); // Discard frame.
-		var subTexture:SubTexture = texture as SubTexture;
-		if (subTexture) {
-			var root:Texture = subTexture.root;
-			var rectRegion:Rectangle = atlas.getRegion(path);
-			attachment.regionU = rectRegion.x / root.width;
-			attachment.regionV = rectRegion.y / root.height;
-			attachment.regionU2 = (rectRegion.x + subTexture.width) / root.width;
-			attachment.regionV2 = (rectRegion.y + subTexture.height) / root.height;
-			attachment.rendererObject = new Image(root);
-		} else {
-			attachment.regionU = 0;
-			attachment.regionV = 1;
-			attachment.regionU2 = 1;
-			attachment.regionV2 = 0;
+		public function newRegionAttachment(skin : Skin, name : String, path : String) : RegionAttachment {
+			var texture : Texture = atlas.getTexture(path);
+			if (texture == null)
+				throw new Error("Region not found in Starling atlas: " + path + " (region attachment: " + name + ")");
+			var attachment : RegionAttachment = new RegionAttachment(name);
+			attachment.rendererObject = new Image(Texture.fromTexture(texture)); // Discard frame.
+			var frame : Rectangle = texture.frame;
+			attachment.regionOffsetX = frame ? -frame.x : 0;
+			attachment.regionOffsetY = frame ? -frame.y : 0;
+			attachment.regionWidth = texture.width;
+			attachment.regionHeight = texture.height;
+			attachment.regionOriginalWidth = frame ? frame.width : texture.width;
+			attachment.regionOriginalHeight = frame ? frame.height : texture.height;
+			var subTexture : SubTexture = texture as SubTexture;
+			if (subTexture) {
+				var root : Texture = subTexture.root;
+				var rectRegion : Rectangle = atlas.getRegion(path);
+				attachment["regionU"] = rectRegion.x / root.width;
+				attachment["regionV"] = rectRegion.y / root.height;
+				attachment["regionU2"] = (rectRegion.x + subTexture.width) / root.width;
+				attachment["regionV2"] = (rectRegion.y + subTexture.height) / root.height;
+				attachment.setUVs(attachment["regionU"], attachment["regionV"], attachment["regionU2"], attachment["regionV2"], atlas.getRotation(path));
+			} else {
+				attachment["regionU"] = 0;
+				attachment["regionV"] = 1;
+				attachment["regionU2"] = 1;
+				attachment["regionV2"] = 0;
+			}
+			return attachment;
 		}
-		var frame:Rectangle = texture.frame;
-		attachment.regionOffsetX = frame ? -frame.x : 0;
-		attachment.regionOffsetY = frame ? -frame.y : 0;
-		attachment.regionWidth = texture.width;
-		attachment.regionHeight = texture.height;
-		attachment.regionOriginalWidth = frame ? frame.width : texture.width;
-		attachment.regionOriginalHeight = frame ? frame.height : texture.height;
-		return attachment;
-	}
 
-	public function newBoundingBoxAttachment (skin:Skin, name:String) : BoundingBoxAttachment {
-		return new BoundingBoxAttachment(name);
-	}
+		public function newMeshAttachment(skin : Skin, name : String, path : String) : MeshAttachment {
+			var texture : Texture = atlas.getTexture(path);
+			if (texture == null)
+				throw new Error("Region not found in Starling atlas: " + path + " (mesh attachment: " + name + ")");
+			var attachment : MeshAttachment = new MeshAttachment(name);
+			attachment.rendererObject = new Image(Texture.fromTexture(texture)); // Discard frame.
+			var subTexture : SubTexture = texture as SubTexture;
+			if (subTexture) {
+				var root : Texture = subTexture.root;
+				var rectRegion : Rectangle = atlas.getRegion(path);
+				attachment.regionU = rectRegion.x / root.width;
+				attachment.regionV = rectRegion.y / root.height;
+				attachment.regionU2 = (rectRegion.x + subTexture.width) / root.width;
+				attachment.regionV2 = (rectRegion.y + subTexture.height) / root.height;
+				attachment.rendererObject = new Image(root);
+			} else {
+				attachment.regionU = 0;
+				attachment.regionV = 1;
+				attachment.regionU2 = 1;
+				attachment.regionV2 = 0;
+			}
+			var frame : Rectangle = texture.frame;
+			attachment.regionOffsetX = frame ? -frame.x : 0;
+			attachment.regionOffsetY = frame ? -frame.y : 0;
+			attachment.regionWidth = texture.width;
+			attachment.regionHeight = texture.height;
+			attachment.regionOriginalWidth = frame ? frame.width : texture.width;
+			attachment.regionOriginalHeight = frame ? frame.height : texture.height;
+			return attachment;
+		}
 
-	public function newPathAttachment (skin:Skin, name:String) : PathAttachment {
-		return new PathAttachment(name);
-	}
-	
-	public function newPointAttachment (skin:Skin, name:String) : PointAttachment {
-		return new PointAttachment(name);
-	}
-}
+		public function newBoundingBoxAttachment(skin : Skin, name : String) : BoundingBoxAttachment {
+			return new BoundingBoxAttachment(name);
+		}
+
+		public function newPathAttachment(skin : Skin, name : String) : PathAttachment {
+			return new PathAttachment(name);
+		}
 
-}
+		public function newPointAttachment(skin : Skin, name : String) : PointAttachment {
+			return new PointAttachment(name);
+		}
+	}
+}

spine-starling/spine-starling/src/spine/starling/StarlingTextureLoader.as

@@ -30,86 +30,86 @@
 
 package spine.starling {
 	import starling.display.Image;
-import spine.atlas.AtlasPage;
-import spine.atlas.AtlasRegion;
-import spine.atlas.TextureLoader;
 
-import starling.textures.Texture;
+	import spine.atlas.AtlasPage;
+	import spine.atlas.AtlasRegion;
+	import spine.atlas.TextureLoader;
 
-import flash.display.Bitmap;
-import flash.display.BitmapData;
+	import starling.textures.Texture;
 
-public class StarlingTextureLoader implements TextureLoader {
-	public var bitmapDatasOrTextures:Object = {};
-	public var singleBitmapDataOrTexture:Object;	
+	import flash.display.Bitmap;
+	import flash.display.BitmapData;
 
-	/** @param bitmaps A Bitmap or BitmapData or Texture for an atlas that has only one page, or for a multi page atlas an object where the
-	 * key is the image path and the value is the Bitmap or BitmapData or Texture. */
-	public function StarlingTextureLoader (bitmapsOrTextures:Object) {
-		if (bitmapsOrTextures is BitmapData) {
-			singleBitmapDataOrTexture = BitmapData(bitmapsOrTextures);
-			return;
-		}
-		if (bitmapsOrTextures is Bitmap) {
-			singleBitmapDataOrTexture = Bitmap(bitmapsOrTextures).bitmapData;
-			return;
-		}
-		if (bitmapsOrTextures is Texture) {
-			singleBitmapDataOrTexture = Texture(bitmapsOrTextures);
-			return;
-		}		
+	public class StarlingTextureLoader implements TextureLoader {
+		public var bitmapDatasOrTextures : Object = {};
+		public var singleBitmapDataOrTexture : Object;
+
+		/** @param bitmaps A Bitmap or BitmapData or Texture for an atlas that has only one page, or for a multi page atlas an object where the
+		 * key is the image path and the value is the Bitmap or BitmapData or Texture. */
+		public function StarlingTextureLoader(bitmapsOrTextures : Object) {
+			if (bitmapsOrTextures is BitmapData) {
+				singleBitmapDataOrTexture = BitmapData(bitmapsOrTextures);
+				return;
+			}
+			if (bitmapsOrTextures is Bitmap) {
+				singleBitmapDataOrTexture = Bitmap(bitmapsOrTextures).bitmapData;
+				return;
+			}
+			if (bitmapsOrTextures is Texture) {
+				singleBitmapDataOrTexture = Texture(bitmapsOrTextures);
+				return;
+			}
 
-		for (var path:* in bitmapsOrTextures) {
-			var object:* = bitmapsOrTextures[path];
-			var bitmapDataOrTexture:Object;
-			if (object is BitmapData)
-				bitmapDataOrTexture = BitmapData(object);
-			else if (object is Bitmap)
-				bitmapDataOrTexture = Bitmap(object).bitmapData;
-			else if (object is Texture)
-				bitmapDataOrTexture = Texture(object);
-			else
-				throw new ArgumentError("Object for path \"" + path + "\" must be a Bitmap, BitmapData or Texture: " + object);
-			bitmapDatasOrTextures[path] = bitmapDataOrTexture;
+			for (var path : * in bitmapsOrTextures) {
+				var object : * = bitmapsOrTextures[path];
+				var bitmapDataOrTexture : Object;
+				if (object is BitmapData)
+					bitmapDataOrTexture = BitmapData(object);
+				else if (object is Bitmap)
+					bitmapDataOrTexture = Bitmap(object).bitmapData;
+				else if (object is Texture)
+					bitmapDataOrTexture = Texture(object);
+				else
+					throw new ArgumentError("Object for path \"" + path + "\" must be a Bitmap, BitmapData or Texture: " + object);
+				bitmapDatasOrTextures[path] = bitmapDataOrTexture;
+			}
 		}
-	}
 
-	public function loadPage (page:AtlasPage, path:String) : void {
-		var bitmapDataOrTexture:Object = singleBitmapDataOrTexture || bitmapDatasOrTextures[path];
-		if (!bitmapDataOrTexture)
-			throw new ArgumentError("BitmapData/Texture not found with name: " + path);
-		if (bitmapDataOrTexture is BitmapData) {
-			var bitmapData:BitmapData = BitmapData(bitmapDataOrTexture);
-			page.rendererObject = Texture.fromBitmapData(bitmapData);
-			page.width = bitmapData.width;
-			page.height = bitmapData.height;
-		} else {
-			var texture:Texture = Texture(bitmapDataOrTexture);
-			page.rendererObject = texture;
-			page.width = texture.width;
-			page.height = texture.height;
-		}		
-	}
+		public function loadPage(page : AtlasPage, path : String) : void {
+			var bitmapDataOrTexture : Object = singleBitmapDataOrTexture || bitmapDatasOrTextures[path];
+			if (!bitmapDataOrTexture)
+				throw new ArgumentError("BitmapData/Texture not found with name: " + path);
+			if (bitmapDataOrTexture is BitmapData) {
+				var bitmapData : BitmapData = BitmapData(bitmapDataOrTexture);
+				page.rendererObject = Texture.fromBitmapData(bitmapData);
+				page.width = bitmapData.width;
+				page.height = bitmapData.height;
+			} else {
+				var texture : Texture = Texture(bitmapDataOrTexture);
+				page.rendererObject = texture;
+				page.width = texture.width;
+				page.height = texture.height;
+			}
+		}
 
-	public function loadRegion (region:AtlasRegion) : void {
-		var image:Image = new Image(Texture(region.page.rendererObject));
-		if (region.rotate) {
-			image.setTexCoords(0, region.u, region.v2);
-			image.setTexCoords(1, region.u, region.v);
-			image.setTexCoords(2, region.u2, region.v2);
-			image.setTexCoords(3, region.u2, region.v);
-		} else {
-			image.setTexCoords(0, region.u, region.v);
-			image.setTexCoords(1, region.u2, region.v);
-			image.setTexCoords(2, region.u, region.v2);
-			image.setTexCoords(3, region.u2, region.v2);
+		public function loadRegion(region : AtlasRegion) : void {
+			var image : Image = new Image(Texture(region.page.rendererObject));
+			if (region.rotate) {
+				image.setTexCoords(0, region.u, region.v2);
+				image.setTexCoords(1, region.u, region.v);
+				image.setTexCoords(2, region.u2, region.v2);
+				image.setTexCoords(3, region.u2, region.v);
+			} else {
+				image.setTexCoords(0, region.u, region.v);
+				image.setTexCoords(1, region.u2, region.v);
+				image.setTexCoords(2, region.u, region.v2);
+				image.setTexCoords(3, region.u2, region.v2);
+			}
+			region.rendererObject = image;
 		}
-		region.rendererObject = image;
-	}
 
-	public function unloadPage (page:AtlasPage) : void {
-		Texture(page.rendererObject).dispose();
+		public function unloadPage(page : AtlasPage) : void {
+			Texture(page.rendererObject).dispose();
+		}
 	}
-}
-
-}
+}

spine-starling/spine-starling/src/spine/starling/TwoColorEffect.as

@@ -30,44 +30,44 @@
 
 package spine.starling {
 	import starling.rendering.Program;
-import flash.display3D.Context3D;
-import starling.rendering.VertexDataFormat;
-import starling.rendering.MeshEffect;
 
-public class TwoColorEffect extends MeshEffect {
-	public  static const VERTEX_FORMAT:VertexDataFormat = TwoColorMeshStyle.VERTEX_FORMAT;
-	
-	override protected function createProgram():Program {
-		var vertexShader:String = [
-		"m44 op, va0, vc0", // 4x4 matrix transform to output clip-space
-		"mov v0, va1     ", // pass texture coordinates to fragment program
-		"mul v1, va2, vc4", // multiply alpha (vc4) with color (va2), pass to fp
-		"mov v2, va3     "  // pass offset to fp
-		].join("\n");
- 
-		var fragmentShader:String = [
-		    tex("ft0", "v0", 0, texture) +  // get color from texture
-		"mul ft0, ft0, v1",             // multiply color with texel color
-		"mov ft1, v2",                  // copy complete offset to ft1
-		"mul ft1.xyz, v2.xyz, ft0.www", // multiply offset.rgb with alpha (pma!)
-		"add oc, ft0, ft1"              // add offset, copy to output
-		].join("\n");
- 		
-		return Program.fromSource(vertexShader, fragmentShader);
-    }
-	
-	override public function get vertexFormat():VertexDataFormat {
-		return VERTEX_FORMAT;
-	}
- 
-	override protected function beforeDraw(context:Context3D):void {
-		super.beforeDraw(context);
-		vertexFormat.setVertexBufferAt(3, vertexBuffer, "color2");
-	}
- 
-	override protected function afterDraw(context:Context3D):void {
-		context.setVertexBufferAt(3, null);
-		super.afterDraw(context);
+	import flash.display3D.Context3D;
+
+	import starling.rendering.VertexDataFormat;
+	import starling.rendering.MeshEffect;
+
+	public class TwoColorEffect extends MeshEffect {
+		public  static const VERTEX_FORMAT : VertexDataFormat = TwoColorMeshStyle.VERTEX_FORMAT;
+
+		override protected function createProgram() : Program {
+			var vertexShader : String = ["m44 op, va0, vc0", // 4x4 matrix transform to output clip-space 
+			"mov v0, va1     ", // pass texture coordinates to fragment program 
+			"mul v1, va2, vc4", // multiply alpha (vc4) with color (va2), pass to fp 
+			"mov v2, va3     "  // pass offset to fp
+			].join("\n");
+
+			var fragmentShader : String = [tex("ft0", "v0", 0, texture) +  // get color from texture 
+			"mul ft0, ft0, v1",             // multiply color with texel color 
+			"mov ft1, v2",                  // copy complete offset to ft1 
+			"mul ft1.xyz, v2.xyz, ft0.www", // multiply offset.rgb with alpha (pma!) 
+			"add oc, ft0, ft1"              // add offset, copy to output
+			].join("\n");
+
+			return Program.fromSource(vertexShader, fragmentShader);
+		}
+
+		override public function get vertexFormat() : VertexDataFormat {
+			return VERTEX_FORMAT;
+		}
+
+		override protected function beforeDraw(context : Context3D) : void {
+			super.beforeDraw(context);
+			vertexFormat.setVertexBufferAt(3, vertexBuffer, "color2");
+		}
+
+		override protected function afterDraw(context : Context3D) : void {
+			context.setVertexBufferAt(3, null);
+			super.afterDraw(context);
+		}
 	}
-}
 }

spine-starling/spine-starling/src/spine/starling/TwoColorMeshStyle.as

@@ -30,18 +30,18 @@
 
 package spine.starling {
 	import starling.rendering.MeshEffect;
-import starling.rendering.VertexDataFormat;
-import starling.styles.MeshStyle;
+	import starling.rendering.VertexDataFormat;
+	import starling.styles.MeshStyle;
 
-public class TwoColorMeshStyle extends MeshStyle {
-	public static const VERTEX_FORMAT:VertexDataFormat = MeshStyle.VERTEX_FORMAT.extend("color2:bytes4");
-	
-	override public function get vertexFormat():VertexDataFormat {
-		return VERTEX_FORMAT;
+	public class TwoColorMeshStyle extends MeshStyle {
+		public static const VERTEX_FORMAT : VertexDataFormat = MeshStyle.VERTEX_FORMAT.extend("color2:bytes4");
+
+		override public function get vertexFormat() : VertexDataFormat {
+			return VERTEX_FORMAT;
+		}
+
+		override public function createEffect() : MeshEffect {
+			return new TwoColorEffect();
+		}
 	}
-	
-	override public function createEffect():MeshEffect {
-        return new TwoColorEffect();
-    }
-}
 }