[as3][starling] Updated to 3.5, path constraint may still have an issue, see stretchyman

examples/export/runtimes.sh

@@ -152,6 +152,10 @@ cp -f ../vine/export/vine.json ../../spine-starling/spine-starling-example/src/
 cp -f ../vine/export/vine.atlas ../../spine-starling/spine-starling-example/src/
 cp -f ../vine/export/vine.png ../../spine-starling/spine-starling-example/src/
 
+cp -f ../stretchyman/export/stretchyman.json ../../spine-starling/spine-starling-example/src/
+cp -f ../stretchyman/export/stretchyman.atlas ../../spine-starling/spine-starling-example/src/
+cp -f ../stretchyman/export/stretchyman.png ../../spine-starling/spine-starling-example/src/
+
 
 echo "spine-ts"
 rm -f ../../spine-ts/webgl/example/assets/*

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

@@ -44,7 +44,14 @@ public class Bone implements Updatable {
 	public var scaleY:Number;
 	public var shearX:Number;
 	public var shearY:Number;
-	public var appliedRotation: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;	
 
 	internal var _a:Number;
 	internal var _b:Number;
@@ -52,8 +59,6 @@ public class Bone implements Updatable {
 	internal var _d:Number;
 	internal var _worldX:Number;
 	internal var _worldY:Number;
-	internal var _worldSignX:Number;
-	internal var _worldSignY:Number;
 	
 	internal var _sorted:Boolean;
 
@@ -79,14 +84,26 @@ public class Bone implements Updatable {
 
 	/** 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 {
-		appliedRotation = rotation;
+		ax = x;
-
+		ay = y;
-		var rotationY:Number = rotation + 90 + shearY;
+		arotation = rotation;
-		var la:Number = MathUtils.cosDeg(rotation + shearX) * scaleX, lb:Number = MathUtils.cosDeg(rotationY) * scaleY;
+		ascaleX = scaleX;
-		var lc:Number = MathUtils.sinDeg(rotation + shearX) * scaleX, ld:Number = MathUtils.sinDeg(rotationY) * scaleY;
+		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;
@@ -102,91 +119,103 @@ public class Bone implements Updatable {
 			_b = lb;
 			_c = lc;
 			_d = ld;
-			_worldX = x;
+			_worldX = x + skeleton.x;
-			_worldY = y;
+			_worldY = y + skeleton.y;	
-			_worldSignX = scaleX < 0 ? -1 : 1;
-			_worldSignY = scaleY < 0 ? -1 : 1;
 			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;
+		_worldY = pc * x + pd * y + parent._worldY;		
-		_worldSignX = parent._worldSignX * (scaleX < 0 ? -1 : 1);
-		_worldSignY = parent._worldSignY * (scaleY < 0 ? -1 : 1);
 
-		if (data.inheritRotation && data.inheritScale) {
+		switch (_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;
 			_a = pa * la + pb * lc;
 			_b = pa * lb + pb * ld;
 			_c = pc * la + pd * lc;
 			_d = pc * lb + pd * ld;
-		} else {
+			return;
-			if (data.inheritRotation) { // No scale inheritance.
+		}
-				pa = 1;
+		case TransformMode.onlyTranslation: {
-				pb = 0;
+			rotationY = rotation + 90 + shearY;
-				pc = 0;
+			_a = MathUtils.cosDeg(rotation + shearX) * scaleX;
-				pd = 1;
+			_b = MathUtils.cosDeg(rotationY) * scaleY;
-				do {
+			_c = MathUtils.sinDeg(rotation + shearX) * scaleX;
-					var cos:Number = MathUtils.cosDeg(parent.appliedRotation), sin:Number = MathUtils.sinDeg(parent.appliedRotation);
+			_d = MathUtils.sinDeg(rotationY) * scaleY;
-					var temp:Number = pa * cos + pb * sin;
+			break;
-					pb = pb * cos - pa * sin;
+		}
-					pa = temp;
+		case TransformMode.noRotationOrReflection: {
-					temp = pc * cos + pd * sin;
+			var psx:Number = Math.sqrt(pa * pa + pc * pc);
-					pd = pd * cos - pc * sin;
+			var psy:Number = 0;
-					pc = temp;
+			var prx:Number = 0;
-	
+			if (psx > 0.0001) {
-					if (!parent.data.inheritRotation) break;
+				psy = Math.abs((pa * pd - pb * pc) / psx);
-					parent = parent.parent;
+				prx = Math.atan2(pc, pa) * MathUtils.radDeg;
-				} while (parent != null);
-				_a = pa * la + pb * lc;
-				_b = pa * lb + pb * ld;
-				_c = pc * la + pd * lc;
-				_d = pc * lb + pd * ld;
-			} else if (data.inheritScale) { // No rotation inheritance.
-				pa = 1;
-				pb = 0;
-				pc = 0;
-				pd = 1;
-				do {
-					cos = MathUtils.cosDeg(parent.appliedRotation), sin = MathUtils.sinDeg(parent.appliedRotation);
-					var psx:Number = parent.scaleX, psy:Number = parent.scaleY;
-					var za:Number = cos * psx, zb:Number = sin * psy, zc:Number = sin * psx, zd:Number = cos * psy;
-					temp = pa * za + pb * zc;
-					pb = pb * zd - pa * zb;
-					pa = temp;
-					temp = pc * za + pd * zc;
-					pd = pd * zd - pc * zb;
-					pc = temp;
-
-					if (psx >= 0) sin = -sin;
-					temp = pa * cos + pb * sin;
-					pb = pb * cos - pa * sin;
-					pa = temp;
-					temp = pc * cos + pd * sin;
-					pd = pd * cos - pc * sin;
-					pc = temp;
-	
-					if (!parent.data.inheritScale) break;
-					parent = parent.parent;
-				} while (parent != null);
-				_a = pa * la + pb * lc;
-				_b = pa * lb + pb * ld;
-				_c = pc * la + pd * lc;
-				_d = pc * lb + pd * ld;
 			} else {
-				_a = la;
+				psx = 0;
-				_b = lb;
+				psy = Math.sqrt(pb * pb + pd * pd);
-				_c = lc;
+				prx = 90 - Math.atan2(pd, pb) * MathUtils.radDeg;
-				_d = ld;
 			}
-			if (_skeleton.flipX) {
+			cos = MathUtils.cosDeg(prx);
-				_a = -_a;
+			sin = MathUtils.sinDeg(prx);
+			pa = cos * psx;
+			pb = -sin * psy;
+			pc = sin * psx;
+			pd = cos * psy;
+			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;
+			_a = pa * la + pb * lc;
+			_b = pa * lb + pb * ld;
+			_c = pc * la + pd * lc;
+			_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;
+			_a = za * la + zb * lc;
+			_b = za * lb + zb * ld;
+			_c = zc * la + zd * lc;
+			_d = zc * lb + zd * ld;
+			if (_data.transformMode != TransformMode.noScaleOrReflection ? pa * pd - pb * pc < 0 : skeleton.flipX != skeleton.flipY) {
 				_b = -_b;
-			}
-			if (_skeleton.flipY != yDown) {
-				_c = -_c;
 				_d = -_d;
 			}
+			return;
+		}
+		}
+		if (_skeleton.flipX) {
+			_a = -_a;
+			_b = -_b;
+		}
+		if (_skeleton.flipY != yDown) {
+			_c = -_c;
+			_d = -_d;
 		}
 	}
 
@@ -240,14 +269,6 @@ public class Bone implements Updatable {
 		return _worldY;
 	}
 
-	public function get worldSignX () : Number {
-		return _worldSignX;
-	}
-
-	public function get worldSignY () : Number {
-		return _worldSignY;
-	}
-
 	public function get worldRotationX () : Number {
 		return Math.atan2(_c, _a) * MathUtils.radDeg;
 	}
@@ -257,23 +278,23 @@ public class Bone implements Updatable {
 	}
 
 	public function get worldScaleX () : Number {
-		return Math.sqrt(_a * _a + _b * _b) * _worldSignX;
+		return Math.sqrt(_a * _a + _c * _c);
 	}
 
 	public function get worldScaleY () : Number {
-		return Math.sqrt(_c * _c + _d * _d) * _worldSignY;
+		return Math.sqrt(_b * _b + _d * _d);
 	}
 	
 	public function worldToLocalRotationX () : Number {
 		var parent:Bone = _parent;
-		if (parent == null) return rotation;
+		if (parent == null) return arotation;
 		var pa:Number = parent.a, pb:Number = parent.b, pc:Number = parent.c, pd:Number = parent.d, a:Number = this.a, c:Number = this.c;
 		return Math.atan2(pa * c - pc * a, pd * a - pb * c) * MathUtils.radDeg;
 	}
 
 	public function worldToLocalRotationY () : Number {
 		var parent:Bone = _parent;
-		if (parent == null) return rotation;
+		if (parent == null) return arotation;
 		var pa:Number = parent.a, pb:Number = parent.b, pc:Number = parent.c, pd:Number = parent.d, b:Number = this.b, d:Number = this.d;
 		return Math.atan2(pa * d - pc * b, pd * b - pb * d) * MathUtils.radDeg;
 	}
@@ -285,31 +306,31 @@ public class Bone implements Updatable {
 		this._b = cos * b - sin * d;
 		this._c = sin * a + cos * c;
 		this._d = sin * b + cos * d;
+		this.appliedValid = false;
 	}
 
-	/** Computes the local transform from the world transform. This can be useful to perform processing on the local transform
+	/** Computes the individual applied transform values from the world transform. This can be useful to perform processing using
-	 * after the world transform has been modified directly (eg, by a constraint).
+	 * the applied transform after the world transform has been modified directly (eg, by a constraint).
 	 * <p>
-	 * Some redundant information is lost by the world transform, such as -1,-1 scale versus 180 rotation. The computed local
+	 * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. */
-	 * transform values may differ from the original values but are functionally the same. */
+	public function updateAppliedTransform () : void {
-	public function updateLocalTransform () : void {
+		appliedValid = true;
 		var parent:Bone = this.parent;
 		if (parent == null) {
-			x = worldX;
+			ax = worldX;
-			y = worldY;
+			ay = worldY;
-			rotation = Math.atan2(c, a) * MathUtils.radDeg;
+			arotation = Math.atan2(c, a) * MathUtils.radDeg;
-			scaleX = Math.sqrt(a * a + c * c);
+			ascaleX = Math.sqrt(a * a + c * c);
-			scaleY = Math.sqrt(b * b + d * d);
+			ascaleY = Math.sqrt(b * b + d * d);			
-			var det:Number = a * d - b * c;
+			ashearX = 0;
-			shearX = 0;
+			ashearY = Math.atan2(a * b + c * d, a * d - b * c) * MathUtils.radDeg;
-			shearY = Math.atan2(a * b + c * d, det) * 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;
-		x = (dx * pd * pid - dy * pb * pid);
+		ax = (dx * pd * pid - dy * pb * pid);
-		y = (dy * pa * pid - dx * pc * pid);
+		ay = (dy * pa * pid - dx * pc * pid);
 		var ia:Number = pid * pd;
 		var id:Number = pid * pa;
 		var ib:Number = pid * pb;
@@ -318,20 +339,19 @@ public class Bone implements Updatable {
 		var rb:Number = ia * b - ib * d;
 		var rc:Number = id * c - ic * a;
 		var rd:Number = id * d - ic * b;
-		shearX = 0;
+		ashearX = 0;
-		scaleX = Math.sqrt(ra * ra + rc * rc);
+		ascaleX = Math.sqrt(ra * ra + rc * rc);
 		if (scaleX > 0.0001) {
-			det = ra * rd - rb * rc;
+			var det:Number = ra * rd - rb * rc;
-			scaleY = det / scaleX;
+			ascaleY = det /ascaleX;
-			shearY = Math.atan2(ra * rb + rc * rd, det) * MathUtils.radDeg;
+			ashearY = Math.atan2(ra * rb + rc * rd, det) * MathUtils.radDeg;
-			rotation = Math.atan2(rc, ra) * MathUtils.radDeg;
+			arotation = Math.atan2(rc, ra) * MathUtils.radDeg;
 		} else {
-			scaleX = 0;
+			ascaleX = 0;
-			scaleY = Math.sqrt(rb * rb + rd * rd);
+			ascaleY = Math.sqrt(rb * rb + rd * rd);
-			shearY = 0;
+			ashearY = 0;
-			rotation = 90 - Math.atan2(rd, rb) * MathUtils.radDeg;
+			arotation = 90 - Math.atan2(rd, rb) * MathUtils.radDeg;
-		}
+		}		
-		appliedRotation = rotation;
 	}
 
 	public function worldToLocal (world:Vector.<Number>) : void {

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

@@ -42,8 +42,7 @@ public class BoneData {
 	public var scaleY:Number = 1;
 	public var shearX:Number;
 	public var shearY:Number;	
-	public var inheritRotation:Boolean = true;
+	public var transformMode:TransformMode = TransformMode.normal;
-	public var inheritScale:Boolean = true;
 
 	/** @param parent May be null. */
 	public function BoneData (index:int, name:String, parent:BoneData) {

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

@@ -0,0 +1,37 @@
+/******************************************************************************
+ * 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 Constraint extends Updatable {
+	function getOrder () : Number;
+}
+
+}

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

@@ -30,14 +30,12 @@
 
 package spine {
 
-public class IkConstraint implements Updatable {
+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 var level:int;	
 
 	public function IkConstraint (data:IkConstraintData, skeleton:Skeleton) {
 		if (data == null) throw new ArgumentError("data cannot be null.");
@@ -66,6 +64,10 @@ public class IkConstraint implements Updatable {
 			break;
 		}
 	}
+	
+	public function getOrder() : Number {
+		return _data.order;
+	}
 
 	public function get data () : IkConstraintData {
 		return _data;
@@ -78,17 +80,18 @@ public class IkConstraint implements Updatable {
 	/** 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 {
-		var pp:Bone = bone.parent;
+		if (!bone.appliedValid) bone.updateAppliedTransform();
-		var id:Number = 1 / (pp.a * pp.d - pp.b * pp.c);
+		var p:Bone = bone.parent;
-		var x:Number = targetX - pp.worldX, y:Number = targetY - pp.worldY;
+		var id:Number = 1 / (p.a * p.d - p.b * p.c);
-		var tx:Number = (x * pp.d - y * pp.b) * id - bone.x, ty:Number = (y * pp.a - x * pp.c) * id - bone.y;
+		var x:Number = targetX - p.worldX, y:Number = targetY - p.worldY;
-		var rotationIK:Number = Math.atan2(ty, tx) * MathUtils.radDeg - bone.shearX - bone.rotation;
+		var tx:Number = (x * p.d - y * p.b) * id - bone.ax, ty:Number = (y * p.a - x * p.c) * id - bone.ay;
-		if (bone.scaleX < 0) rotationIK += 180;
+		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.x, bone.y, bone.rotation + rotationIK * alpha, bone.scaleX, bone.scaleY, bone.shearX,
+		bone.updateWorldTransformWith(bone.ax, bone.ay, bone.arotation + rotationIK * alpha, bone.ascaleX, bone.ascaleY, bone.ashearX,
-			bone.shearY);
+			bone.ashearY);
 	}
 
 	/** Adjusts the parent and child bone rotations so the tip of the child is as close to the target position as possible. The
@@ -99,7 +102,9 @@ public class IkConstraint implements Updatable {
 			child.updateWorldTransform();
 			return;
 		}
-		var px:Number = parent.x, py:Number = parent.y, psx:Number = parent.scaleX, psy:Number = parent.scaleY, csx:Number = child.scaleX;;
+		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;
@@ -118,14 +123,14 @@ public class IkConstraint implements Updatable {
 			os2 = 180;
 		} else
 			os2 = 0;
-		var cx:Number = child.x, cy:Number, cwx:Number, cwy:Number, a:Number = parent.a, b:Number = parent.b, c:Number = parent.c, d:Number = parent.d;
+		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.y;
+			cy = child.ay;
 			cwx = a * cx + b * cy + parent.worldX;
 			cwy = c * cx + d * cy + parent.worldY;
 		}
@@ -212,18 +217,18 @@ public class IkConstraint implements Updatable {
 			}
 		}
 		var os:Number = Math.atan2(cy, cx) * s2;
-		var rotation:Number = parent.rotation;
+		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.scaleX, parent.scaleY, 0, 0);
+		parent.updateWorldTransformWith(px, py, rotation + a1 * alpha, parent.ascaleX, parent.ascaleY, 0, 0);
-		rotation = child.rotation;
+		rotation = child.arotation;
-		a2 = ((a2 + os) * MathUtils.radDeg - child.shearX) * s2 + os2 - rotation;
+		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.scaleX, child.scaleY, child.shearX, child.shearY);
+		child.updateWorldTransformWith(cx, cy, rotation + a2 * alpha, child.ascaleX, child.ascaleY, child.ashearX, child.ashearY);
 	}
 }
 

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

@@ -32,6 +32,7 @@ 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;

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

@@ -31,7 +31,7 @@
 package spine {
 import spine.attachments.PathAttachment;
 
-public class PathConstraint implements Updatable {
+public class PathConstraint implements Constraint {
 	private static const NONE:int = -1, BEFORE:int = -2, AFTER:int = -3;
 
 	internal var _data:PathConstraintData;
@@ -100,16 +100,14 @@ public class PathConstraint implements Updatable {
 		}
 
 		var positions:Vector.<Number> = computeWorldPositions(attachment, spacesCount, tangents,
-			data.positionMode == PositionMode.percent, spacingMode == SpacingMode.percent);
+			data.positionMode == PositionMode.percent, spacingMode == SpacingMode.percent);		
-		var skeleton:Skeleton = target.skeleton;
-		var skeletonX:Number = skeleton.x, skeletonY:Number = skeleton.y;
 		var boneX:Number = positions[0], boneY:Number = positions[1], offsetRotation:Number = data.offsetRotation;
 		var tip:Boolean = rotateMode == RotateMode.chain && offsetRotation == 0;
 		var p:Number;
 		for (i = 0, p = 3; i < boneCount; i++, p += 3) {
 			bone = bones[i];
-			bone._worldX += (boneX - skeletonX - bone.worldX) * translateMix;
+			bone._worldX += (boneX - bone.worldX) * translateMix;
-			bone._worldY += (boneY - skeletonY - bone.worldY) * 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];
@@ -149,6 +147,7 @@ public class PathConstraint implements Updatable {
 				bone._c = sin * a + cos * c;
 				bone._d = sin * b + cos * d;
 			}
+			bone.appliedValid = false;
 		}
 	}
 
@@ -394,7 +393,7 @@ public class PathConstraint implements Updatable {
 
 	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) p = 0.0001;
+		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;
@@ -410,6 +409,10 @@ public class PathConstraint implements Updatable {
 	public function get data () : PathConstraintData {
 		return _data;
 	}
+	
+	public function getOrder () : Number {
+		return _data.order;
+	}
 
 	public function toString () : String {
 		return _data.name;

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

@@ -32,6 +32,7 @@ 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;

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

@@ -38,10 +38,11 @@ public class Skeleton {
 	public var bones:Vector.<Bone>;
 	public var slots:Vector.<Slot>;
 	public var drawOrder:Vector.<Slot>;
-	public var ikConstraints:Vector.<IkConstraint>, ikConstraintsSorted:Vector.<IkConstraint>;
+	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 r:Number = 1, g:Number = 1, b:Number = 1, a:Number = 1;
 	public var time:Number = 0;
@@ -75,8 +76,7 @@ public class Skeleton {
 			drawOrder[drawOrder.length] = slot;
 		}
 		
-		ikConstraints = new Vector.<IkConstraint>();
+		ikConstraints = new Vector.<IkConstraint>();		
-		ikConstraintsSorted = new Vector.<IkConstraint>();
 		for each (var ikConstraintData:IkConstraintData in data.ikConstraints)
 			ikConstraints.push(new IkConstraint(ikConstraintData, this));
 		
@@ -98,103 +98,112 @@ public class Skeleton {
 		updateCache.length = 0;
 
 		var bones:Vector.<Bone> = this.bones;
-		for (var i:int = 0, n:int = bones.length; i < n; i++)
+		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.ikConstraintsSorted;
+		var ikConstraints:Vector.<IkConstraint> = this.ikConstraints;
-		ikConstraints.length = 0;
-		for each (var c:IkConstraint in this.ikConstraints)
-			ikConstraints.push(c);
-		var ikCount:int = ikConstraints.length;
-		var level:int;
-		for (i = 0, n = ikCount; i < n; i++) {
-			var ik:IkConstraint = ikConstraints[i];
-			var bone:Bone = ik.bones[0].parent;
-			for (level = 0; bone != null; level++)
-				bone = bone.parent;
-			ik.level = level;
-		}
-		var ii:int;
-		for (i = 1; i < ikCount; i++) {
-			ik = ikConstraints[i];
-			level = ik.level;
-			for (ii = i - 1; ii >= 0; ii--) {
-				var other:IkConstraint = ikConstraints[ii];
-				if (other.level < level) break;
-				ikConstraints[ii + 1] = other;
-			}
-			ikConstraints[ii + 1] = ik;
-		}
-		for (i = 0, n = ikConstraints.length; i < n; i++) {
-			var ikConstraint:IkConstraint = ikConstraints[i];
-			var target:Bone = ikConstraint.target;
-			sortBone(target);
-
-			var constrained:Vector.<Bone> = ikConstraint.bones;
-			var parent:Bone = constrained[0];
-			sortBone(parent);
-
-			updateCache.push(ikConstraint);
-
-			sortReset(parent.children);
-			constrained[constrained.length - 1]._sorted = true;
-		}
-
-		var pathConstraints:Vector.<PathConstraint> = this.pathConstraints;
-		for (i = 0, n = pathConstraints.length; i < n; i++) {
-			var pathConstraint:PathConstraint = pathConstraints[i];
-
-			var slot:Slot = pathConstraint.target;
-			var slotIndex:int = 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 nn:int;
-			for (ii = 0, nn = _data.skins.length; ii < nn; ii++)
-				sortPathConstraintAttachment(_data.skins[ii], slotIndex, slotBone);
-
-			var attachment:PathAttachment = slot.attachment as PathAttachment;
-			if (attachment != null) sortPathConstraintAttachment2(attachment, slotBone);
-
-			constrained = pathConstraint.bones;
-			var boneCount:int = constrained.length;
-			for (ii = 0; ii < boneCount; ii++)
-				sortBone(constrained[ii]);
-
-			updateCache.push(pathConstraint);
-
-			for (ii = 0; ii < boneCount; ii++)
-				sortReset(constrained[ii].children);
-			for (ii = 0; ii < boneCount; ii++)
-				constrained[ii]._sorted = true;
-		}
-
 		var transformConstraints:Vector.<TransformConstraint> = this.transformConstraints;
-		for (i = 0, n = transformConstraints.length; i < n; i++) {
+		var pathConstraints:Vector.<PathConstraint> = this.pathConstraints;
-			var transformConstraint:TransformConstraint = transformConstraints[i];
+		var ikCount:Number = ikConstraints.length, transformCount:Number = transformConstraints.length, pathCount:Number = pathConstraints.length;
-
+		var constraintCount:Number = ikCount + transformCount + pathCount;
-			sortBone(transformConstraint.target);
+		
-
+		outer:			
-			constrained = transformConstraint.bones;
+		for (i = 0; i < constraintCount; i++) {
-			boneCount = constrained.length;
+			var ii:Number = 0;
-			for (ii = 0; ii < boneCount; ii++)
+			for (ii = 0; ii < ikCount; ii++) {
-				sortBone(constrained[ii]);
+				var ikConstraint:IkConstraint = ikConstraints[ii];
-
+				if (ikConstraint.data.order == i) {
-			updateCache.push(transformConstraint);
+					sortIkConstraint(ikConstraint);
-
+					continue outer;
-			for (ii = 0; ii < boneCount; ii++)
+				}
-				sortReset(constrained[ii].children);
+			}
-			for (ii = 0; ii < boneCount; ii++)
+			for (ii = 0; ii < transformCount; ii++) {
-				constrained[ii]._sorted = true;
+				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]);
 	}
 	
+	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);
+
+		if (constrained.length > 1) {
+			var child:Bone = constrained[constrained.length - 1];
+			if (!(_updateCache.indexOf(child) > -1)) _updateCacheReset.push(child);
+		}
+
+		_updateCache.push(constraint);
+
+		sortReset(parent.children);
+		constrained[constrained.length - 1]._sorted = true;
+	}
+
+	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 ii:Number = 0;
+		var nn:Number = 0;		
+		for (ii = 0, nn = data.skins.length; ii < nn; ii++)
+			sortPathConstraintAttachment(data.skins[ii], 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 (ii = 0; ii < boneCount; ii++)
+			sortBone(constrained[ii]);
+
+		_updateCache.push(constraint);
+
+		for (ii = 0; ii < boneCount; ii++)
+			sortReset(constrained[ii].children);
+		for (ii = 0; ii < boneCount; ii++)
+			constrained[ii]._sorted = true;
+	}
+
+	private function sortTransformConstraint (constraint:TransformConstraint): void {
+		sortBone(constraint.target);
+
+		var constrained:Vector.<Bone> = constraint.bones;
+		var boneCount:Number = constrained.length;
+		var ii:Number = 0;
+		for (ii = 0; ii < boneCount; ii++)
+			sortBone(constrained[ii]);
+
+		_updateCache.push(constraint);
+
+		for (ii = 0; ii < boneCount; ii++)
+			sortReset(constrained[ii].children);
+		for (ii = 0; ii < boneCount; ii++)
+			constrained[ii]._sorted = true;
+	}
+	
 	private function sortPathConstraintAttachment (skin:Skin, slotIndex:int, slotBone:Bone) : void {
 		var dict:Dictionary = skin.attachments[slotIndex];
 		if (!dict) return;
@@ -240,6 +249,17 @@ public class Skeleton {
 
 	/** 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();
 	}

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

@@ -46,6 +46,9 @@ public class SkeletonData {
 	public var width:Number, height:Number;
 	public var version:String, hash:String;
 	
+	public var fps:Number;
+	public var imagesPath:String;
+	
 	public function SkeletonData () {		
 	}
 

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

@@ -89,7 +89,9 @@ public class SkeletonJson {
 			skeletonData.hash = skeletonMap["hash"];
 			skeletonData.version = skeletonMap["spine"];
 			skeletonData.width = skeletonMap["width"] || 0;
-			skeletonData.height = skeletonMap["height"] || 0;			
+			skeletonData.height = skeletonMap["height"] || 0;
+			skeletonData.fps = skeletonMap["fps"] || 0;
+			skeletonData.imagesPath = skeletonMap["images"];		
 		}			
 
 		// Bones.
@@ -110,8 +112,7 @@ public class SkeletonJson {
 			boneData.scaleY = boneMap.hasOwnProperty("scaleY") ? boneMap["scaleY"] : 1;
 			boneData.shearX = Number(boneMap["shearX"] || 0);
 			boneData.shearY = Number(boneMap["shearY"] || 0);
-			boneData.inheritRotation = boneMap.hasOwnProperty("inheritRotation") ? Boolean(boneMap["inheritRotation"]) : true;
+			boneData.transformMode = TransformMode[boneMap["transform"] || "normal"];			
-			boneData.inheritScale = boneMap.hasOwnProperty("inheritScale") ? Boolean(boneMap["inheritScale"]) : true;			
 			skeletonData.bones.push(boneData);
 		}
 		
@@ -139,6 +140,7 @@ public class SkeletonJson {
 		// IK constraints.
 		for each (var constraintMap:Object in root["ik"]) {
 			var ikConstraintData:IkConstraintData = new IkConstraintData(constraintMap["name"]);
+			ikConstraintData.order = constraintMap["order"] || 0;
 
 			for each (boneName in constraintMap["bones"]) {
 				var bone:BoneData = skeletonData.findBone(boneName);
@@ -158,6 +160,7 @@ public class SkeletonJson {
 		// 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);
@@ -186,6 +189,7 @@ public class SkeletonJson {
 		// 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);

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

@@ -30,7 +30,7 @@
 
 package spine {
 
-public class TransformConstraint implements Updatable {
+public class TransformConstraint implements Constraint {
 	internal var _data:TransformConstraintData;
 	internal var _bones:Vector.<Bone>;
 	public var target:Bone;
@@ -65,8 +65,9 @@ public class TransformConstraint implements Updatable {
 		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) {
+			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) + data.offsetRotation * MathUtils.degRad;
 				if (r > Math.PI)
@@ -78,27 +79,30 @@ public class TransformConstraint implements Updatable {
 				bone._b = cos * b - sin * d;
 				bone._c = sin * a + cos * c;
 				bone._d = sin * b + cos * d;
+				modified = true;
 			}
 
-			if (translateMix > 0) {
+			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 bs:Number = Math.sqrt(bone.a * bone.a + bone.c * bone.c);
+				var s:Number = Math.sqrt(bone.a * bone.a + bone.c * bone.c);
 				var ts:Number = Math.sqrt(ta * ta + tc * tc);
-				var s:Number = bs > 0.00001 ? (bs + (ts - bs + data.offsetScaleX) * scaleMix) / bs : 0;
+				if (s > 0.00001) s = (s + (ts - s + data.offsetScaleX) * scaleMix) / s;
 				bone._a *= s;
 				bone._c *= s;
-				bs = Math.sqrt(bone.b * bone.b + bone.d * bone.d);
+				s = Math.sqrt(bone.b * bone.b + bone.d * bone.d);
 				ts = Math.sqrt(tb * tb + td * td);
-				s = bs > 0.00001 ? (bs + (ts - bs + data.offsetScaleY) * scaleMix) / bs : 0;
+				if (s > 0.00001) s = (s + (ts - s + data.offsetScaleY) * scaleMix) / s;
 				bone._b *= s;
 				bone._d *= s;
+				modified = true;
 			}
 
 			if (shearMix > 0) {
@@ -112,9 +116,16 @@ public class TransformConstraint implements Updatable {
 				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;
 		}
 	}
+	
+	public function getOrder () : Number {
+		return _data.order;
+	}
 
 	public function get data () : TransformConstraintData {
 		return _data;

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

@@ -32,6 +32,7 @@ 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;

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

@@ -0,0 +1,41 @@
+/******************************************************************************
+ * 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 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/attachments/VertexAttachment.as

@@ -53,8 +53,7 @@ public dynamic class VertexAttachment extends Attachment {
 	 * @param offset The worldVertices index to begin writing values. */
 	public function computeWorldVertices2 (slot:Slot, start:int, count:int, worldVertices:Vector.<Number>, offset:int): void {
 		count += offset;
-		var skeleton:Skeleton = slot.skeleton;
+		var skeleton:Skeleton = slot.skeleton;		
-		var x:Number = skeleton.x, y:Number = skeleton.y;
 		var deformArray:Vector.<Number> = slot.attachmentVertices;
 		var vertices:Vector.<Number> = this.vertices;
 		var bones:Vector.<int> = this.bones;
@@ -68,8 +67,8 @@ public dynamic class VertexAttachment extends Attachment {
 		if (bones == null) {
 			if (deformArray.length > 0) vertices = deformArray;
 			bone = slot.bone;
-			x += bone.worldX;
+			var x:Number = bone.worldX;
-			y += bone.worldY;
+			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 += 2) {
 				vx = vertices[v], vy = vertices[v + 1];
@@ -87,7 +86,7 @@ public dynamic class VertexAttachment extends Attachment {
 		var skeletonBones:Vector.<Bone> = skeleton.bones;
 		if (deformArray.length == 0) {
 			for (w = offset, b = skip * 3; w < count; w += 2) {
-				wx = x, wy = y;
+				wx = 0, wy = 0;
 				n = bones[v++];
 				n += v;
 				for (; v < n; v++, b += 3) {
@@ -102,7 +101,7 @@ public dynamic class VertexAttachment extends Attachment {
 		} else {
 			deform = deformArray;
 			for (w = offset, b = skip * 3, f = skip << 1; w < count; w += 2) {
-				wx = x; wy = y;
+				wx = 0; wy = 0;
 				n = bones[v++];
 				n += v;
 				for (; v < n; v++, b += 3, f += 2) {

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

@@ -43,8 +43,9 @@ public class Main extends Sprite {
 		// example = SpineboyExample;
 		// example = GoblinsExample;
 		// example = RaptorExample;
-		example = TankExample;
+		// example = TankExample;
 		// example = VineExample;
+		example = StretchymanExample;
 
 		_starling = new Starling(example, stage);
 		_starling.enableErrorChecking = true;

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

@@ -0,0 +1,94 @@
+/******************************************************************************
+ * 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.examples {
+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;
+
+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.png")]
+	static public const StretchymanAtlasTexture:Class;
+
+	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());
+
+		var stateData:AnimationStateData = new AnimationStateData(skeletonData);
+
+		skeleton = new SkeletonAnimation(skeletonData, stateData);
+		skeleton.x = 100;
+		skeleton.y = 560;
+		
+		skeleton.state.timeScale = 0.1;
+		
+		skeleton.state.onStart.add(function (trackIndex:int) : void {
+			trace(trackIndex + " 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.skeleton.setToSetupPose();
+		skeleton.state.setAnimationByName(0, "sneak", true);
+
+		addChild(skeleton);
+		Starling.juggler.add(skeleton);		
+	}
+}
+}

spine-starling/spine-starling-example/src/stretchyman.atlas

@@ -0,0 +1,41 @@
+
+stretchyman.png
+size: 1024,256
+format: RGBA8888
+filter: Linear,Linear
+repeat: none
+back arm
+  rotate: true
+  xy: 679, 173
+  size: 72, 202
+  orig: 72, 202
+  offset: 0, 0
+  index: -1
+back leg
+  rotate: true
+  xy: 2, 2
+  size: 100, 318
+  orig: 100, 318
+  offset: 0, 0
+  index: -1
+body
+  rotate: true
+  xy: 2, 104
+  size: 141, 452
+  orig: 141, 452
+  offset: 0, 0
+  index: -1
+front arm
+  rotate: true
+  xy: 456, 100
+  size: 145, 221
+  orig: 145, 221
+  offset: 0, 0
+  index: -1
+head
+  rotate: true
+  xy: 322, 15
+  size: 87, 102
+  orig: 87, 102
+  offset: 0, 0
+  index: -1