[csharp] Porting of commits dbd90ca, da1b280, 10d5a91 and e14db0e (includes 4.0 format changes). Fixed errors in color parsing introduced by previous porting 4.0 commit.

* Added separate X and Y for transform constraint translate and scale mix.
* Renamed `xxxMix` to `mixXxx` to avoid names like `scaleXMix`.
* Added separate X and Y sliders for path constraint translate mix.
* Added a proportional spacing mode to path constraints.
* Fixed path constraint when a parent bone of the path is scaled.

spine-csharp/src/Animation.cs

@@ -199,7 +199,7 @@ namespace Spine {
 	}
 
 	internal enum Property {
-		Rotate=0, TranslateX, TranslateY, ScaleX, ScaleY, ShearX, ShearY, //
+		Rotate=0, X, Y, ScaleX, ScaleY, ShearX, ShearY, //
 		RGB, Alpha, RGB2, //
 		Attachment, Deform, //
 		Event, DrawOrder, //
@@ -333,7 +333,7 @@ namespace Spine {
 		/// <param name="bezier">The ordinal of this Bezier curve for this timeline, between 0 and <code>bezierCount - 1</code> (specified
 		///					in the constructor), inclusive.</param>
 		/// <param name="frame">Between 0 and <code>frameCount - 1</code>, inclusive.</param>
-		/// <param name="value">The index of the value for this frame that this curve is used for.</param>
+		/// <param name="value">The index of the value for the frame this curve is used for.</param>
 		/// <param name="time1">The time for the first key.</param>
 		/// <param name="value1">The value for the first key.</param>
 		/// <param name="cx1">The time for the first Bezier handle.</param>
@@ -518,8 +518,8 @@ namespace Spine {
 
 		public TranslateTimeline (int frameCount, int bezierCount, int boneIndex)
 			: base(frameCount, bezierCount, //
-				(int)Property.TranslateX + "|" + boneIndex, //
-				(int) Property.TranslateY + "|" + boneIndex) {
+				(int)Property.X + "|" + boneIndex, //
+				(int) Property.Y + "|" + boneIndex) {
 			this.boneIndex = boneIndex;
 		}
 
@@ -593,7 +593,7 @@ namespace Spine {
 		readonly int boneIndex;
 
 		public TranslateXTimeline (int frameCount, int bezierCount, int boneIndex)
-			: base(frameCount, bezierCount, (int)Property.TranslateX + "|" + boneIndex) {
+			: base(frameCount, bezierCount, (int)Property.X + "|" + boneIndex) {
 			this.boneIndex = boneIndex;
 		}
 
@@ -642,7 +642,7 @@ namespace Spine {
 		readonly int boneIndex;
 
 		public TranslateYTimeline (int frameCount, int bezierCount, int boneIndex)
-			: base(frameCount, bezierCount, (int)Property.TranslateY + "|" + boneIndex) {
+			: base(frameCount, bezierCount, (int)Property.Y + "|" + boneIndex) {
 			this.boneIndex = boneIndex;
 		}
 
@@ -1705,12 +1705,11 @@ namespace Spine {
 				slot.ClampSecondColor();
 			}
 			else {
-				float br, bg, bb, ba, br2, bg2, bb2;
+				float br, bg, bb, br2, bg2, bb2;
 				if (blend == MixBlend.Setup) {
 					br = slot.data.r;
 					bg = slot.data.g;
 					bb = slot.data.b;
-					ba = slot.data.a;
 					br2 = slot.data.r2;
 					bg2 = slot.data.g2;
 					bb2 = slot.data.b2;
@@ -1719,7 +1718,6 @@ namespace Spine {
 					br = slot.r;
 					bg = slot.g;
 					bb = slot.b;
-					ba = slot.a;
 					br2 = slot.r2;
 					bg2 = slot.g2;
 					bb2 = slot.b2;
@@ -2308,8 +2306,8 @@ namespace Spine {
 
 	///	<summary>Changes a transform constraint's mixes.</summary>
 	public class TransformConstraintTimeline : CurveTimeline {
-		public const int ENTRIES = 5;
-		private const int ROTATE = 1, TRANSLATE = 2, SCALE = 3, SHEAR = 4;
+		public const int ENTRIES = 7;
+		private const int ROTATE = 1, X = 2, Y = 3, SCALEX = 4, SCALEY = 5, SHEARY = 6;
 
 		readonly int transformConstraintIndex;
 
@@ -2335,13 +2333,16 @@ namespace Spine {
 		/// <summary>Sets the time, rotate mix, translate mix, scale mix, and shear mix for the specified frame.</summary>
 		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
-		public void SetFrame (int frame, float time, float rotateMix, float translateMix, float scaleMix, float shearMix) {
+		public void SetFrame (int frame, float time, float mixRotate, float mixX, float mixY, float mixScaleX, float mixScaleY,
+			float mixShearY) {
 			frame *= ENTRIES;
 			frames[frame] = time;
-			frames[frame + ROTATE] = rotateMix;
-			frames[frame + TRANSLATE] = translateMix;
-			frames[frame + SCALE] = scaleMix;
-			frames[frame + SHEAR] = shearMix;
+			frames[frame + ROTATE] = mixRotate;
+			frames[frame + X] = mixX;
+			frames[frame + Y] = mixY;
+			frames[frame + SCALEX] = mixScaleX;
+			frames[frame + SCALEY] = mixScaleY;
+			frames[frame + SHEARY] = mixShearY;
 		}
 
 		override public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha, MixBlend blend,
@@ -2354,61 +2355,77 @@ namespace Spine {
 				TransformConstraintData data = constraint.data;
 				switch (blend) {
 				case MixBlend.Setup:
-					constraint.rotateMix = data.rotateMix;
-					constraint.translateMix = data.translateMix;
-					constraint.scaleMix = data.scaleMix;
-					constraint.shearMix = data.shearMix;
+					constraint.mixRotate = data.mixRotate;
+					constraint.mixX = data.mixX;
+					constraint.mixY = data.mixY;
+					constraint.mixScaleX = data.mixScaleX;
+					constraint.mixScaleY = data.mixScaleY;
+					constraint.mixShearY = data.mixShearY;
 					return;
 				case MixBlend.First:
-					constraint.rotateMix += (data.rotateMix - constraint.rotateMix) * alpha;
-					constraint.translateMix += (data.translateMix - constraint.translateMix) * alpha;
-					constraint.scaleMix += (data.scaleMix - constraint.scaleMix) * alpha;
-					constraint.shearMix += (data.shearMix - constraint.shearMix) * alpha;
+					constraint.mixRotate += (data.mixRotate - constraint.mixRotate) * alpha;
+					constraint.mixX += (data.mixX - constraint.mixX) * alpha;
+					constraint.mixY += (data.mixY - constraint.mixY) * alpha;
+					constraint.mixScaleX += (data.mixScaleX - constraint.mixScaleX) * alpha;
+					constraint.mixScaleY += (data.mixScaleY - constraint.mixScaleY) * alpha;
+					constraint.mixShearY += (data.mixShearY - constraint.mixShearY) * alpha;
 					return;
 				}
 				return;
 			}
 
-			float rotate, translate, scale, shear;
+			float rotate, x, y, scaleX, scaleY, shearY;
 			int i = Animation.Search(frames, time, ENTRIES), curveType = (int)curves[i / ENTRIES];
 			switch (curveType) {
 				case LINEAR:
 					float before = frames[i];
 					rotate = frames[i + ROTATE];
-					translate = frames[i + TRANSLATE];
-					scale = frames[i + SCALE];
-					shear = frames[i + SHEAR];
+					x = frames[i + X];
+					y = frames[i + Y];
+					scaleX = frames[i + SCALEX];
+					scaleY = frames[i + SCALEY];
+					shearY = frames[i + SHEARY];
 					float t = (time - before) / (frames[i + ENTRIES] - before);
 					rotate += (frames[i + ENTRIES + ROTATE] - rotate) * t;
-					translate += (frames[i + ENTRIES + TRANSLATE] - translate) * t;
-					scale += (frames[i + ENTRIES + SCALE] - scale) * t;
-					shear += (frames[i + ENTRIES + SHEAR] - shear) * t;
+					x += (frames[i + ENTRIES + X] - x) * t;
+					y += (frames[i + ENTRIES + Y] - y) * t;
+					scaleX += (frames[i + ENTRIES + SCALEX] - scaleX) * t;
+					scaleY += (frames[i + ENTRIES + SCALEY] - scaleY) * t;
+					shearY += (frames[i + ENTRIES + SHEARY] - shearY) * t;
 					break;
 				case STEPPED:
 					rotate = frames[i + ROTATE];
-					translate = frames[i + TRANSLATE];
-					scale = frames[i + SCALE];
-					shear = frames[i + SHEAR];
+					x = frames[i + X];
+					y = frames[i + Y];
+					scaleX = frames[i + SCALEX];
+					scaleY = frames[i + SCALEY];
+					shearY = frames[i + SHEARY];
 					break;
 				default:
 					rotate = GetBezierValue(time, i, ROTATE, curveType - BEZIER);
-					translate = GetBezierValue(time, i, TRANSLATE, curveType + BEZIER_SIZE - BEZIER);
-					scale = GetBezierValue(time, i, TRANSLATE, curveType + BEZIER_SIZE * 2 - BEZIER);
-					shear = GetBezierValue(time, i, TRANSLATE, curveType + BEZIER_SIZE * 3 - BEZIER);
+					x = GetBezierValue(time, i, X, curveType + BEZIER_SIZE - BEZIER);
+					y = GetBezierValue(time, i, Y, curveType + BEZIER_SIZE * 2 - BEZIER);
+					scaleX = GetBezierValue(time, i, SCALEX, curveType + BEZIER_SIZE * 3 - BEZIER);
+					scaleY = GetBezierValue(time, i, SCALEY, curveType + BEZIER_SIZE * 4 - BEZIER);
+					shearY = GetBezierValue(time, i, SHEARY, curveType + BEZIER_SIZE * 5 - BEZIER);
 					break;
 			}
 
 			if (blend == MixBlend.Setup) {
 				TransformConstraintData 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;
+				constraint.mixRotate = data.mixRotate + (rotate - data.mixRotate) * alpha;
+				constraint.mixX = data.mixX + (x - data.mixX) * alpha;
+				constraint.mixY = data.mixY + (y - data.mixY) * alpha;
+				constraint.mixScaleX = data.mixScaleX + (scaleX - data.mixScaleX) * alpha;
+				constraint.mixScaleY = data.mixScaleY + (scaleY - data.mixScaleY) * alpha;
+				constraint.mixShearY = data.mixShearY + (shearY - data.mixShearY) * 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;
+				constraint.mixRotate += (rotate - constraint.mixRotate) * alpha;
+				constraint.mixX += (x - constraint.mixX) * alpha;
+				constraint.mixY += (y - constraint.mixY) * alpha;
+				constraint.mixScaleX += (scaleX - constraint.mixScaleX) * alpha;
+				constraint.mixScaleY += (scaleY - constraint.mixScaleY) * alpha;
+				constraint.mixShearY += (shearY - constraint.mixShearY) * alpha;
 			}
 		}
 	}
@@ -2499,8 +2516,12 @@ namespace Spine {
 		}
 	}
 
-	/// <summary>Changes a path constraint's mixes.</summary>
-	public class PathConstraintMixTimeline : CurveTimeline2 {
+	/// <summary> Changes a transform constraint's <see cref="PathConstraint.MixRotate"/>, <see cref="PathConstraint.MixX"/>, and
+	/// <see cref="PathConstraint.MixY"/>.</summary>
+	public class PathConstraintMixTimeline : CurveTimeline {
+		public const int ENTRIES = 4;
+		private const int ROTATE = 1, X = 2, Y = 3;
+
 		readonly int pathConstraintIndex;
 
 		public PathConstraintMixTimeline (int frameCount, int bezierCount, int pathConstraintIndex)
@@ -2508,6 +2529,10 @@ namespace Spine {
 			this.pathConstraintIndex = pathConstraintIndex;
 		}
 
+		public override int FrameEntries {
+			get { return ENTRIES; }
+		}
+
 		/// <summary>The index of the path constraint slot in <see cref="Skeleton.PathConstraints"/> that will be changed when this timeline
 		/// is applied.</summary>
 		public int PathConstraintIndex {
@@ -2516,6 +2541,17 @@ namespace Spine {
 			}
 		}
 
+		/// <summary>Sets the time and color for the specified frame.</summary>
+		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="time">The frame time in seconds.</param>
+		public void SetFrame (int frame, float time, float mixRotate, float mixX, float mixY) {
+			frame <<= 2;
+			frames[frame] = time;
+			frames[frame + ROTATE] = mixRotate;
+			frames[frame + X] = mixX;
+			frames[frame + Y] = mixY;
+		}
+
 		override public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha, MixBlend blend,
 									MixDirection direction) {
 			PathConstraint constraint = skeleton.pathConstraints.Items[pathConstraintIndex];
@@ -2525,44 +2561,53 @@ namespace Spine {
 			if (time < frames[0]) { // Time is before first frame.
 				switch (blend) {
 				case MixBlend.Setup:
-					constraint.rotateMix = constraint.data.rotateMix;
-					constraint.translateMix = constraint.data.translateMix;
+					constraint.mixRotate = constraint.data.mixRotate;
+					constraint.mixX = constraint.data.mixX;
+					constraint.mixY = constraint.data.mixY;
 					return;
 				case MixBlend.First:
-					constraint.rotateMix += (constraint.data.rotateMix - constraint.rotateMix) * alpha;
-					constraint.translateMix += (constraint.data.translateMix - constraint.translateMix) * alpha;
+					constraint.mixRotate += (constraint.data.mixRotate - constraint.mixRotate) * alpha;
+					constraint.mixX += (constraint.data.mixX - constraint.mixX) * alpha;
+					constraint.mixY += (constraint.data.mixY - constraint.mixY) * alpha;
 					return;
 				}
 				return;
 			}
 
-			float rotate, translate;
-			int i = Animation.Search(frames, time, ENTRIES), curveType = (int)curves[i / ENTRIES];
+			float rotate, x, y;
+			int i = Animation.Search(frames, time, ENTRIES), curveType = (int)curves[i >> 2];
 			switch (curveType) {
 				case LINEAR:
 					float before = frames[i];
-					rotate = frames[i + VALUE1];
-					translate = frames[i + VALUE2];
+					rotate = frames[i + ROTATE];
+					x = frames[i + X];
+					y = frames[i + Y];
 					float t = (time - before) / (frames[i + ENTRIES] - before);
-					rotate += (frames[i + ENTRIES + VALUE1] - rotate) * t;
-					translate += (frames[i + ENTRIES + VALUE2] - translate) * t;
+					rotate += (frames[i + ENTRIES + ROTATE] - rotate) * t;
+					x += (frames[i + ENTRIES + X] - x) * t;
+					y += (frames[i + ENTRIES + Y] - y) * t;
 					break;
 				case STEPPED:
-					rotate = frames[i + VALUE1];
-					translate = frames[i + VALUE2];
+					rotate = frames[i + ROTATE];
+					x = frames[i + X];
+					y = frames[i + Y];
 					break;
 				default:
-					rotate = GetBezierValue(time, i, VALUE1, curveType - BEZIER);
-					translate = GetBezierValue(time, i, VALUE2, curveType + BEZIER_SIZE - BEZIER);
+					rotate = GetBezierValue(time, i, ROTATE, curveType - BEZIER);
+					x = GetBezierValue(time, i, X, curveType + BEZIER_SIZE - BEZIER);
+					y = GetBezierValue(time, i, Y, curveType + BEZIER_SIZE * 2 - BEZIER);
 					break;
 			}
 
 			if (blend == MixBlend.Setup) {
-				constraint.rotateMix = constraint.data.rotateMix + (rotate - constraint.data.rotateMix) * alpha;
-				constraint.translateMix = constraint.data.translateMix + (translate - constraint.data.translateMix) * alpha;
+				PathConstraintData data = constraint.data;
+				constraint.mixRotate = data.mixRotate + (rotate - data.mixRotate) * alpha;
+				constraint.mixX = data.mixX + (x - data.mixX) * alpha;
+				constraint.mixY = data.mixY + (y - data.mixY) * alpha;
 			} else {
-				constraint.rotateMix += (rotate - constraint.rotateMix) * alpha;
-				constraint.translateMix += (translate - constraint.translateMix) * alpha;
+				constraint.mixRotate += (rotate - constraint.mixRotate) * alpha;
+				constraint.mixX += (x - constraint.mixX) * alpha;
+				constraint.mixY += (y - constraint.mixY) * alpha;
 			}
 		}
 	}

spine-csharp/src/Attachments/PathAttachment.cs

@@ -37,7 +37,10 @@ namespace Spine {
 
 		/// <summary>The length in the setup pose from the start of the path to the end of each curve.</summary>
 		public float[] Lengths { get { return lengths; } set { lengths = value; } }
+		/// <summary>If true, the start and end knots are connected.</summary>
 		public bool Closed { get { return closed; } set { closed = value; } }
+		/// <summary>If true, additional calculations are performed to make computing positions along the path more accurate and movement along
+		/// the path have a constant speed.</summary>
 		public bool ConstantSpeed { get { return constantSpeed; } set { constantSpeed = value; } }
 
 		public PathAttachment (String name)

spine-csharp/src/IkConstraint.cs

@@ -104,7 +104,7 @@ namespace Spine {
 			set { target = value; }
 		}
 
-		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained rotations.</summary>
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained rotation.</summary>
 		public float Mix {
 			get { return mix; }
 			set { mix = value; }

spine-csharp/src/IkConstraintData.cs

@@ -54,7 +54,7 @@ namespace Spine {
 		}
 
 		/// <summary>
-		/// A percentage (0-1) that controls the mix between the constraint and unconstrained rotations.</summary>
+		/// A percentage (0-1) that controls the mix between the constraint and unconstrained rotation.</summary>
 		public float Mix {
 			get { return mix; }
 			set { mix = value; }

spine-csharp/src/PathConstraint.cs

@@ -45,7 +45,7 @@ namespace Spine {
 		internal PathConstraintData data;
 		internal ExposedList<Bone> bones;
 		internal Slot target;
-		internal float position, spacing, rotateMix, translateMix;
+		internal float position, spacing, mixRotate, mixX, mixY;
 
 		internal bool active;
 
@@ -63,8 +63,9 @@ namespace Spine {
 			target = skeleton.FindSlot(data.target.name);
 			position = data.position;
 			spacing = data.spacing;
-			rotateMix = data.rotateMix;
-			translateMix = data.translateMix;
+			mixRotate = data.mixRotate;
+			mixX = data.mixX;
+			mixY = data.mixY;
 		}
 
 		/// <summary>Copy constructor.</summary>
@@ -78,60 +79,88 @@ namespace Spine {
 			target = skeleton.slots.Items[constraint.target.data.index];
 			position = constraint.position;
 			spacing = constraint.spacing;
-			rotateMix = constraint.rotateMix;
-			translateMix = constraint.translateMix;
+			mixRotate = constraint.mixRotate;
+			mixX = constraint.mixX;
+			mixY = constraint.mixY;
 		}
 
 		public void Update () {
 			PathAttachment attachment = target.Attachment as PathAttachment;
 			if (attachment == null) return;
 
-			float rotateMix = this.rotateMix, translateMix = this.translateMix;
-			bool translate = translateMix > 0, rotate = rotateMix > 0;
-			if (!translate && !rotate) return;
+			float mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY;
+			if (mixRotate == 0 && mixX == 0 && mixY == 0) return;
 
 			PathConstraintData data = this.data;
-			bool percentSpacing = data.spacingMode == SpacingMode.Percent;
-			RotateMode rotateMode = data.rotateMode;
-			bool tangents = rotateMode == RotateMode.Tangent, scale = rotateMode == RotateMode.ChainScale;
+			bool tangents = data.rotateMode == RotateMode.Tangent, scale = data.rotateMode == RotateMode.ChainScale;
 			int boneCount = this.bones.Count, spacesCount = tangents ? boneCount : boneCount + 1;
 			Bone[] bonesItems = this.bones.Items;
-			ExposedList<float> spaces = this.spaces.Resize(spacesCount), lengths = null;
+			float[] spaces = this.spaces.Resize(spacesCount).Items, lengths = scale ? this.lengths.Resize(boneCount).Items : null;
 			float spacing = this.spacing;
-			if (scale || !percentSpacing) {
-				if (scale) lengths = this.lengths.Resize(boneCount);
-				bool lengthSpacing = data.spacingMode == SpacingMode.Length;
-				for (int i = 0, n = spacesCount - 1; i < n;) {
-					Bone bone = bonesItems[i];
-					float setupLength = bone.data.length;
-					if (setupLength < PathConstraint.Epsilon) {
-						if (scale) lengths.Items[i] = 0;
-						spaces.Items[++i] = 0;
-					} else if (percentSpacing) {
-						if (scale) {
+			switch (data.spacingMode) {
+				case SpacingMode.Percent:
+					for (int i = 0, n = spacesCount - 1; i < n;) {
+						Bone bone = bonesItems[i];
+						float setupLength = bone.data.length;
+						if (setupLength < PathConstraint.Epsilon) {
+							if (scale) lengths[i] = 0;
+							spaces[++i] = 0;
+						} else {
+							if (scale) {
+								float x = setupLength * bone.a, y = setupLength * bone.c;
+								lengths[i] = (float)Math.Sqrt(x * x + y * y);
+							}
+							spaces[++i] = spacing;
+						}
+					}
+					break;
+				case SpacingMode.Proportional: {
+					float sum = 0;
+					for (int i = 0; i < boneCount;) {
+						Bone bone = bonesItems[i];
+						float setupLength = bone.data.length;
+						if (setupLength < PathConstraint.Epsilon) {
+							if (scale) lengths[i] = 0;
+							spaces[++i] = 0;
+						} else {
 							float x = setupLength * bone.a, y = setupLength * bone.c;
 							float length = (float)Math.Sqrt(x * x + y * y);
-							lengths.Items[i] = length;
+							if (scale) lengths[i] = length;
+							spaces[++i] = length;
+							sum += length;
 						}
-						spaces.Items[++i] = spacing;
-					} else {
-						float x = setupLength * bone.a, y = setupLength * bone.c;
-						float length = (float)Math.Sqrt(x * x + y * y);
-						if (scale) lengths.Items[i] = length;
-						spaces.Items[++i] = (lengthSpacing ? setupLength + spacing : spacing) * length / setupLength;
 					}
+					sum = spacesCount / sum * spacing;
+					for (int i = 1; i < spacesCount; i++)
+						spaces[i] *= sum;
+					break;
+				}
+				default: {
+					bool lengthSpacing = data.spacingMode == SpacingMode.Length;
+
+					for (int i = 0, n = spacesCount - 1; i < n;) {
+						Bone bone = bonesItems[i];
+						float setupLength = bone.data.length;
+						if (setupLength < PathConstraint.Epsilon) {
+							if (scale) lengths[i] = 0;
+							spaces[++i] = 0;
+						}
+						else {
+							float x = setupLength * bone.a, y = setupLength * bone.c;
+							float length = (float)Math.Sqrt(x * x + y * y);
+							if (scale) lengths[i] = length;
+							spaces[++i] = (lengthSpacing ? setupLength + spacing : spacing) * length / setupLength;
+						}
+					}
+					break;
 				}
-			} else {
-				for (int i = 1; i < spacesCount; i++)
-					spaces.Items[i] = spacing;
 			}
 
-			float[] positions = ComputeWorldPositions(attachment, spacesCount, tangents,
-				data.positionMode == PositionMode.Percent, percentSpacing);
+			float[] positions = ComputeWorldPositions(attachment, spacesCount, tangents);
 			float boneX = positions[0], boneY = positions[1], offsetRotation = data.offsetRotation;
 			bool tip;
 			if (offsetRotation == 0) {
-				tip = rotateMode == RotateMode.Chain;
+				tip = data.rotateMode == RotateMode.Chain;
 			} else {
 				tip = false;
 				Bone p = target.bone;
@@ -139,24 +168,24 @@ namespace Spine {
 			}
 			for (int i = 0, p = 3; i < boneCount; i++, p += 3) {
 				Bone bone = bonesItems[i];
-				bone.worldX += (boneX - bone.worldX) * translateMix;
-				bone.worldY += (boneY - bone.worldY) * translateMix;
+				bone.worldX += (boneX - bone.worldX) * mixX;
+				bone.worldY += (boneY - bone.worldY) * mixY;
 				float x = positions[p], y = positions[p + 1], dx = x - boneX, dy = y - boneY;
 				if (scale) {
-					float length = lengths.Items[i];
+					float length = lengths[i];
 					if (length >= PathConstraint.Epsilon) {
-						float s = ((float)Math.Sqrt(dx * dx + dy * dy) / length - 1) * rotateMix + 1;
+						float s = ((float)Math.Sqrt(dx * dx + dy * dy) / length - 1) * mixRotate + 1;
 						bone.a *= s;
 						bone.c *= s;
 					}
 				}
 				boneX = x;
 				boneY = y;
-				if (rotate) {
+				if (mixRotate > 0) {
 					float a = bone.a, b = bone.b, c = bone.c, d = bone.d, r, cos, sin;
 					if (tangents)
 						r = positions[p - 1];
-					else if (spaces.Items[i + 1] < PathConstraint.Epsilon)
+					else if (spaces[i + 1] < PathConstraint.Epsilon)
 						r = positions[p + 2];
 					else
 						r = MathUtils.Atan2(dy, dx);
@@ -165,15 +194,15 @@ namespace Spine {
 						cos = MathUtils.Cos(r);
 						sin = MathUtils.Sin(r);
 						float length = bone.data.length;
-						boneX += (length * (cos * a - sin * c) - dx) * rotateMix;
-						boneY += (length * (sin * a + cos * c) - dy) * rotateMix;
+						boneX += (length * (cos * a - sin * c) - dx) * mixRotate;
+						boneY += (length * (sin * a + cos * c) - dy) * mixRotate;
 					} else
 						r += offsetRotation;
 					if (r > MathUtils.PI)
 						r -= MathUtils.PI2;
 					else if (r < -MathUtils.PI) //
 						r += MathUtils.PI2;
-					r *= rotateMix;
+					r *= mixRotate;
 					cos = MathUtils.Cos(r);
 					sin = MathUtils.Sin(r);
 					bone.a = cos * a - sin * c;
@@ -185,28 +214,38 @@ namespace Spine {
 			}
 		}
 
-		float[] ComputeWorldPositions (PathAttachment path, int spacesCount, bool tangents, bool percentPosition,
-			bool percentSpacing) {
+		float[] ComputeWorldPositions (PathAttachment path, int spacesCount, bool tangents) {
 
 			Slot target = this.target;
 			float position = this.position;
-			float[] spacesItems = this.spaces.Items, output = this.positions.Resize(spacesCount * 3 + 2).Items, world;
+			float[] spaces = this.spaces.Items, output = this.positions.Resize(spacesCount * 3 + 2).Items, world;
 			bool closed = path.Closed;
 			int verticesLength = path.WorldVerticesLength, curveCount = verticesLength / 6, prevCurve = NONE;
-			float pathLength = 0;
-
+			float pathLength;
+			float multiplier;
 			if (!path.ConstantSpeed) {
 				float[] lengths = path.Lengths;
 				curveCount -= closed ? 1 : 2;
 				pathLength = lengths[curveCount];
-				if (percentPosition) position *= pathLength;
-				if (percentSpacing) {
-					for (int i = 1; i < spacesCount; i++)
-						spacesItems[i] *= pathLength;
+
+				if (data.positionMode == PositionMode.Percent) position *= pathLength;
+
+				//float multiplier;
+				switch (data.spacingMode) {
+					case SpacingMode.Percent:
+						multiplier = pathLength;
+						break;
+					case SpacingMode.Proportional:
+						multiplier = pathLength / spacesCount;
+						break;
+					default:
+						multiplier = 1;
+						break;
 				}
+
 				world = this.world.Resize(8).Items;
 				for (int i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) {
-					float space = spacesItems[i];
+					float space = spaces[i] * multiplier;
 					position += space;
 					float p = position;
 
@@ -307,20 +346,26 @@ namespace Spine {
 				x1 = x2;
 				y1 = y2;
 			}
-			if (percentPosition)
-				position *= pathLength;
-			else
-				position *= pathLength / path.lengths[curveCount - 1];
-
-			if (percentSpacing) {
-				for (int i = 1; i < spacesCount; i++)
-					spacesItems[i] *= pathLength;
+
+			if (data.positionMode == PositionMode.Percent) position *= pathLength;
+
+			//float multiplier;
+			switch (data.spacingMode) {
+				case SpacingMode.Percent:
+					multiplier = pathLength;
+					break;
+				case SpacingMode.Proportional:
+					multiplier = pathLength / spacesCount;
+					break;
+				default:
+					multiplier = 1;
+					break;
 			}
 
 			float[] segments = this.segments;
 			float curveLength = 0;
 			for (int i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) {
-				float space = spacesItems[i];
+				float space = spaces[i] * multiplier;
 				position += space;
 				float p = position;
 
@@ -448,9 +493,11 @@ namespace Spine {
 		/// <summary>The spacing between bones.</summary>
 		public float Spacing { get { return spacing; } set { spacing = value; } }
 		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained rotations.</summary>
-		public float RotateMix { get { return rotateMix; } set { rotateMix = value; } }
-		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained translations.</summary>
-		public float TranslateMix { get { return translateMix; } set { translateMix = value; } }
+		public float MixRotate { get { return mixRotate; } set { mixRotate = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained translation X.</summary>
+		public float MixX { get { return mixX; } set { mixX = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained translation Y.</summary>
+		public float MixY { get { return mixY; } set { mixY = value; } }
 		/// <summary>The bones that will be modified by this path constraint.</summary>
 		public ExposedList<Bone> Bones { get { return bones; } }
 		/// <summary>The slot whose path attachment will be used to constrained the bones.</summary>

spine-csharp/src/PathConstraintData.cs

@@ -37,7 +37,7 @@ namespace Spine {
 		internal SpacingMode spacingMode;
 		internal RotateMode rotateMode;
 		internal float offsetRotation;
-		internal float position, spacing, rotateMix, translateMix;
+		internal float position, spacing, mixRotate, mixX, mixY;
 
 		public PathConstraintData (string name) : base(name) {
 		}
@@ -50,8 +50,12 @@ namespace Spine {
 		public float OffsetRotation { get { return offsetRotation; } set { offsetRotation = value; } }
 		public float Position { get { return position; } set { position = value; } }
 		public float Spacing { get { return spacing; } set { spacing = value; } }
-		public float RotateMix { get { return rotateMix; } set { rotateMix = value; } }
-		public float TranslateMix { get { return translateMix; } set { translateMix = value; } }
+		/// <summary> A percentage (0-1) that controls the mix between the constrained and unconstrained rotation.</summary>
+		public float RotateMix { get { return mixRotate; } set { mixRotate = value; } }
+		/// <summary> A percentage (0-1) that controls the mix between the constrained and unconstrained translation X.</summary>
+		public float MixX { get { return mixX; } set { mixX = value; } }
+		/// <summary> A percentage (0-1) that controls the mix between the constrained and unconstrained translation Y.</summary>
+		public float MixY { get { return mixY; } set { mixY = value; } }
 	}
 
 	public enum PositionMode {
@@ -59,7 +63,7 @@ namespace Spine {
 	}
 
 	public enum SpacingMode {
-		Length, Fixed, Percent
+		Length, Fixed, Percent, Proportional
 	}
 
 	public enum RotateMode {

spine-csharp/src/Skeleton.cs

@@ -379,10 +379,12 @@ namespace Spine {
 			for (int i = 0, n = this.transformConstraints.Count; i < n; i++) {
 				TransformConstraint constraint = transformConstraints[i];
 				TransformConstraintData constraintData = constraint.data;
-				constraint.rotateMix = constraintData.rotateMix;
-				constraint.translateMix = constraintData.translateMix;
-				constraint.scaleMix = constraintData.scaleMix;
-				constraint.shearMix = constraintData.shearMix;
+				constraint.mixRotate = constraintData.mixRotate;
+				constraint.mixX = constraintData.mixX;
+				constraint.mixY = constraintData.mixY;
+				constraint.mixScaleX = constraintData.mixScaleX;
+				constraint.mixScaleY = constraintData.mixScaleY;
+				constraint.mixShearY = constraintData.mixShearY;
 			}
 
 			var pathConstraints = this.pathConstraints.Items;
@@ -391,8 +393,9 @@ namespace Spine {
 				PathConstraintData constraintData = constraint.data;
 				constraint.position = constraintData.position;
 				constraint.spacing = constraintData.spacing;
-				constraint.rotateMix = constraintData.rotateMix;
-				constraint.translateMix = constraintData.translateMix;
+				constraint.mixRotate = constraintData.mixRotate;
+				constraint.mixX = constraintData.mixX;
+				constraint.mixY = constraintData.mixY;
 			}
 		}
 

spine-csharp/src/SkeletonBinary.cs

@@ -57,9 +57,9 @@ namespace Spine {
 		public const int SLOT_ATTACHMENT = 0;
 		public const int SLOT_RGBA = 1;
 		public const int SLOT_RGB = 2;
-		public const int SLOT_ALPHA = 3;
-		public const int SLOT_RGBA2 = 4;
-		public const int SLOT_RGB2 = 5;
+		public const int SLOT_RGBA2 = 3;
+		public const int SLOT_RGB2 = 4;
+		public const int SLOT_ALPHA = 5;
 
 		public const int PATH_POSITION = 0;
 		public const int PATH_SPACING = 1;
@@ -240,10 +240,12 @@ namespace Spine {
 				data.offsetScaleX = input.ReadFloat();
 				data.offsetScaleY = input.ReadFloat();
 				data.offsetShearY = input.ReadFloat();
-				data.rotateMix = input.ReadFloat();
-				data.translateMix = input.ReadFloat();
-				data.scaleMix = input.ReadFloat();
-				data.shearMix = input.ReadFloat();
+				data.mixRotate = input.ReadFloat();
+				data.mixX = input.ReadFloat();
+				data.mixY = input.ReadFloat();
+				data.mixScaleX = input.ReadFloat();
+				data.mixScaleY = input.ReadFloat();
+				data.mixShearY = input.ReadFloat();
 				o[i] = data;
 			}
 
@@ -265,8 +267,9 @@ namespace Spine {
 				if (data.positionMode == PositionMode.Fixed) data.position *= scale;
 				data.spacing = input.ReadFloat();
 				if (data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed) data.spacing *= scale;
-				data.rotateMix = input.ReadFloat();
-				data.translateMix = input.ReadFloat();
+				data.mixRotate = input.ReadFloat();
+				data.mixX = input.ReadFloat();
+				data.mixY = input.ReadFloat();
 				o[i] = data;
 			}
 
@@ -637,8 +640,7 @@ namespace Spine {
 									timeline.SetFrame(frame, time, r, g, b);
 									if (frame == frameLast) break;
 									float time2 = input.ReadFloat();
-									float r2 = input.Read() / 255f, g2 = input.Read() / 255f;
-									float b2 = input.Read() / 255f, a2 = input.Read() / 255f;
+									float r2 = input.Read() / 255f, g2 = input.Read() / 255f, b2 = input.Read() / 255f;
 									switch (input.ReadByte()) {
 										case CURVE_STEPPED:
 											timeline.SetStepped(frame);
@@ -826,29 +828,33 @@ namespace Spine {
 			for (int i = 0, n = input.ReadInt(true); i < n; i++) {
 				int index = input.ReadInt(true), frameCount = input.ReadInt(true), frameLast = frameCount - 1;
 				TransformConstraintTimeline timeline = new TransformConstraintTimeline(frameCount, input.ReadInt(true), index);
-				float time = input.ReadFloat(), rotateMix = input.ReadFloat(), translateMix = input.ReadFloat(),
-					scaleMix = input.ReadFloat(), shearMix = input.ReadFloat();
+				float time = input.ReadFloat(), mixRotate = input.ReadFloat(), mixX = input.ReadFloat(), mixY = input.ReadFloat(),
+				mixScaleX = input.ReadFloat(), mixScaleY = input.ReadFloat(), mixShearY = input.ReadFloat();
 				for (int frame = 0, bezier = 0; ; frame++) {
-					timeline.SetFrame(frame, time, rotateMix, translateMix, scaleMix, shearMix);
+					timeline.SetFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY);
 					if (frame == frameLast) break;
-					float time2 = input.ReadFloat(), rotateMix2 = input.ReadFloat(), translateMix2 = input.ReadFloat(),
-						scaleMix2 = input.ReadFloat(), shearMix2 = input.ReadFloat();
+					float time2 = input.ReadFloat(), mixRotate2 = input.ReadFloat(), mixX2 = input.ReadFloat(), mixY2 = input.ReadFloat(),
+					mixScaleX2 = input.ReadFloat(), mixScaleY2 = input.ReadFloat(), mixShearY2 = input.ReadFloat();
 					switch (input.ReadByte()) {
 						case CURVE_STEPPED:
 							timeline.SetStepped(frame);
 							break;
 						case CURVE_BEZIER:
-							SetBezier(input, timeline, bezier++, frame, 0, time, time2, rotateMix, rotateMix2, 1);
-							SetBezier(input, timeline, bezier++, frame, 1, time, time2, translateMix, translateMix2, 1);
-							SetBezier(input, timeline, bezier++, frame, 2, time, time2, scaleMix, scaleMix2, 1);
-							SetBezier(input, timeline, bezier++, frame, 3, time, time2, shearMix, shearMix2, 1);
+							SetBezier(input, timeline, bezier++, frame, 0, time, time2, mixRotate, mixRotate2, 1);
+							SetBezier(input, timeline, bezier++, frame, 1, time, time2, mixX, mixX2, 1);
+							SetBezier(input, timeline, bezier++, frame, 2, time, time2, mixY, mixY2, 1);
+							SetBezier(input, timeline, bezier++, frame, 3, time, time2, mixScaleX, mixScaleX2, 1);
+							SetBezier(input, timeline, bezier++, frame, 4, time, time2, mixScaleY, mixScaleY2, 1);
+							SetBezier(input, timeline, bezier++, frame, 5, time, time2, mixShearY, mixShearY2, 1);
 							break;
 					}
 					time = time2;
-					rotateMix = rotateMix2;
-					translateMix = translateMix2;
-					scaleMix = scaleMix2;
-					shearMix = shearMix2;
+					mixRotate = mixRotate2;
+					mixX = mixX2;
+					mixY = mixY2;
+					mixScaleX = mixScaleX2;
+					mixScaleY = mixScaleY2;
+					mixShearY = mixShearY2;
 				}
 				timelines.Add(timeline);
 			}
@@ -870,8 +876,30 @@ namespace Spine {
 									data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed ? scale : 1));
 							break;
 						case PATH_MIX:
-							timelines
-								.Add(ReadTimeline(input, new PathConstraintMixTimeline(input.ReadInt(true), input.ReadInt(true), index), 1));
+							PathConstraintMixTimeline timeline = new PathConstraintMixTimeline(input.ReadInt(true), input.ReadInt(true),
+								index);
+							float time = input.ReadFloat(), mixRotate = input.ReadFloat(), mixX = input.ReadFloat(), mixY = input.ReadFloat();
+							for (int frame = 0, bezier = 0, frameLast = nn - 1; ; frame++) {
+								timeline.SetFrame(frame, time, mixRotate, mixX, mixY);
+								if (frame == frameLast) break;
+								float time2 = input.ReadFloat(), mixRotate2 = input.ReadFloat(), mixX2 = input.ReadFloat(),
+									mixY2 = input.ReadFloat();
+								switch (input.ReadByte()) {
+									case CURVE_STEPPED:
+										timeline.SetStepped(frame);
+										break;
+									case CURVE_BEZIER:
+										SetBezier(input, timeline, bezier++, frame, 0, time, time2, mixRotate, mixRotate2, 1);
+										SetBezier(input, timeline, bezier++, frame, 1, time, time2, mixX, mixX2, 1);
+										SetBezier(input, timeline, bezier++, frame, 2, time, time2, mixY, mixY2, 1);
+										break;
+								}
+								time = time2;
+								mixRotate = mixRotate2;
+								mixX = mixX2;
+								mixY = mixY2;
+							}
+							timelines.Add(timeline);
 							break;
 					}
 				}

spine-csharp/src/SkeletonJson.cs

@@ -231,10 +231,12 @@ namespace Spine {
 					data.offsetScaleY = GetFloat(constraintMap, "scaleY", 0);
 					data.offsetShearY = GetFloat(constraintMap, "shearY", 0);
 
-					data.rotateMix = GetFloat(constraintMap, "rotateMix", 1);
-					data.translateMix = GetFloat(constraintMap, "translateMix", 1);
-					data.scaleMix = GetFloat(constraintMap, "scaleMix", 1);
-					data.shearMix = GetFloat(constraintMap, "shearMix", 1);
+					data.mixRotate = GetFloat(constraintMap, "mixRotate", 1);
+					data.mixX = GetFloat(constraintMap, "mixX", 1);
+					data.mixY = GetFloat(constraintMap, "mixY", data.mixX);
+					data.mixScaleX = GetFloat(constraintMap, "mixScaleX", 1);
+					data.mixScaleY = GetFloat(constraintMap, "mixScaleY", data.mixScaleX);
+					data.mixShearY = GetFloat(constraintMap, "mixShearY", 1);
 
 					skeletonData.transformConstraints.Add(data);
 				}
@@ -267,8 +269,10 @@ namespace Spine {
 					if (data.positionMode == PositionMode.Fixed) data.position *= scale;
 					data.spacing = GetFloat(constraintMap, "spacing", 0);
 					if (data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed) data.spacing *= scale;
-					data.rotateMix = GetFloat(constraintMap, "rotateMix", 1);
-					data.translateMix = GetFloat(constraintMap, "translateMix", 1);
+					data.mixRotate = GetFloat(constraintMap, "mixRotate", 1);
+					data.mixX = GetFloat(constraintMap, "mixX", 1);
+					data.mixY = GetFloat(constraintMap, "mixY", 1);
+
 
 					skeletonData.pathConstraints.Add(data);
 				}
@@ -595,9 +599,9 @@ namespace Spine {
 							var keyMap = (Dictionary<string, Object>)keyMapEnumerator.Current;
 							float time = GetFloat(keyMap, "time", 0);
 							string color = (string)keyMap["color"];
-							float r = ToColor(color, 0);
-							float g = ToColor(color, 1);
-							float b = ToColor(color, 2);
+							float r = ToColor(color, 0, 6);
+							float g = ToColor(color, 1, 6);
+							float b = ToColor(color, 2, 6);
 							for (int frame = 0, bezier = 0; ; frame++) {
 								timeline.SetFrame(frame, time, r, g, b);
 								bool hasNext = keyMapEnumerator.MoveNext();
@@ -609,9 +613,9 @@ namespace Spine {
 
 								float time2 = GetFloat(nextMap, "time", 0);
 								color = (string)nextMap["color"];
-								float nr = ToColor(color, 0);
-								float ng = ToColor(color, 1);
-								float nb = ToColor(color, 2);
+								float nr = ToColor(color, 0, 6);
+								float ng = ToColor(color, 1, 6);
+								float nb = ToColor(color, 2, 6);
 
 								if (keyMap.ContainsKey("curve")) {
 									object curve = keyMap["curve"];
@@ -645,9 +649,9 @@ namespace Spine {
 							float b = ToColor(color, 2);
 							float a = ToColor(color, 3);
 							color = (string)keyMap["dark"];
-							float r2 = ToColor(color, 0);
-							float g2 = ToColor(color, 1);
-							float b2 = ToColor(color, 2);
+							float r2 = ToColor(color, 0, 6);
+							float g2 = ToColor(color, 1, 6);
+							float b2 = ToColor(color, 2, 6);
 							for (int frame = 0, bezier = 0; ; frame++) {
 								timeline.SetFrame(frame, time, r, g, b, a, r2, g2, b2);
 								bool hasNext = keyMapEnumerator.MoveNext();
@@ -664,9 +668,9 @@ namespace Spine {
 								float nb = ToColor(color, 2);
 								float na = ToColor(color, 3);
 								color = (string)nextMap["dark"];
-								float nr2 = ToColor(color, 0);
-								float ng2 = ToColor(color, 1);
-								float nb2 = ToColor(color, 2);
+								float nr2 = ToColor(color, 0, 6);
+								float ng2 = ToColor(color, 1, 6);
+								float nb2 = ToColor(color, 2, 6);
 
 								if (keyMap.ContainsKey("curve")) {
 									object curve = keyMap["curve"];
@@ -698,13 +702,13 @@ namespace Spine {
 							var keyMap = (Dictionary<string, Object>)keyMapEnumerator.Current;
 							float time = GetFloat(keyMap, "time", 0);
 							string color = (string)keyMap["light"];
-							float r = ToColor(color, 0);
-							float g = ToColor(color, 1);
-							float b = ToColor(color, 2);
+							float r = ToColor(color, 0, 6);
+							float g = ToColor(color, 1, 6);
+							float b = ToColor(color, 2, 6);
 							color = (string)keyMap["dark"];
-							float r2 = ToColor(color, 0);
-							float g2 = ToColor(color, 1);
-							float b2 = ToColor(color, 2);
+							float r2 = ToColor(color, 0, 6);
+							float g2 = ToColor(color, 1, 6);
+							float b2 = ToColor(color, 2, 6);
 							for (int frame = 0, bezier = 0; ; frame++) {
 								timeline.SetFrame(frame, time, r, g, b, r2, g2, b2);
 								bool hasNext = keyMapEnumerator.MoveNext();
@@ -716,13 +720,13 @@ namespace Spine {
 
 								float time2 = GetFloat(nextMap, "time", 0);
 								color = (string)nextMap["light"];
-								float nr = ToColor(color, 0);
-								float ng = ToColor(color, 1);
-								float nb = ToColor(color, 2);
+								float nr = ToColor(color, 0, 6);
+								float ng = ToColor(color, 1, 6);
+								float nb = ToColor(color, 2, 6);
 								color = (string)nextMap["dark"];
-								float nr2 = ToColor(color, 0);
-								float ng2 = ToColor(color, 1);
-								float nb2 = ToColor(color, 2);
+								float nr2 = ToColor(color, 0, 6);
+								float ng2 = ToColor(color, 1, 6);
+								float nb2 = ToColor(color, 2, 6);
 
 								if (keyMap.ContainsKey("curve")) {
 									object curve = keyMap["curve"];
@@ -849,10 +853,11 @@ namespace Spine {
 					TransformConstraintTimeline timeline = new TransformConstraintTimeline(timelineMapValues.Count, timelineMapValues.Count << 2,
 						skeletonData.TransformConstraints.IndexOf(constraint));
 					float time = GetFloat(keyMap, "time", 0);
-					float rotateMix = GetFloat(keyMap, "rotateMix", 1), translateMix = GetFloat(keyMap, "translateMix", 1);
-					float scaleMix = GetFloat(keyMap, "scaleMix", 1), shearMix = GetFloat(keyMap, "shearMix", 1);
+					float mixRotate = GetFloat(keyMap, "mixRotate", 1), mixShearY = GetFloat(keyMap, "mixShearY", 1);
+					float mixX = GetFloat(keyMap, "mixX", 1), mixY = GetFloat(keyMap, "mixY", mixX);
+					float mixScaleX = GetFloat(keyMap, "mixScaleX", 1), mixScaleY = GetFloat(keyMap, "mixScaleY", mixScaleX);
 					for (int frame = 0, bezier = 0; ; frame++) {
-						timeline.SetFrame(frame, time, rotateMix, translateMix, scaleMix, shearMix);
+						timeline.SetFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY);
 						hasNext = keyMapEnumerator.MoveNext();
 						if (!hasNext) {
 							timeline.Shrink(bezier);
@@ -860,20 +865,25 @@ namespace Spine {
 						}
 						var nextMap = (Dictionary<string, Object>)keyMapEnumerator.Current;
 						float time2 = GetFloat(nextMap, "time", 0);
-						float rotateMix2 = GetFloat(nextMap, "rotateMix", 1), translateMix2 = GetFloat(nextMap, "translateMix", 1);
-						float scaleMix2 = GetFloat(nextMap, "scaleMix", 1), shearMix2 = GetFloat(nextMap, "shearMix", 1);
+						float mixRotate2 = GetFloat(nextMap, "mixRotate", 1), mixShearY2 = GetFloat(nextMap, "mixShearY", 1);
+						float mixX2 = GetFloat(nextMap, "mixX", 1), mixY2 = GetFloat(nextMap, "mixY", mixX2);
+						float mixScaleX2 = GetFloat(nextMap, "mixScaleX", 1), mixScaleY2 = GetFloat(nextMap, "mixScaleY", mixScaleX2);
 						if (keyMap.ContainsKey("curve")) {
 							object curve = keyMap["curve"];
-							bezier = ReadCurve(curve, timeline, bezier, frame, 0, time, time2, rotateMix, rotateMix2, 1);
-							bezier = ReadCurve(curve, timeline, bezier, frame, 1, time, time2, translateMix, translateMix2, 1);
-							bezier = ReadCurve(curve, timeline, bezier, frame, 2, time, time2, scaleMix, scaleMix2, 1);
-							bezier = ReadCurve(curve, timeline, bezier, frame, 3, time, time2, shearMix, shearMix2, 1);
+							bezier = ReadCurve(curve, timeline, bezier, frame, 0, time, time2, mixRotate, mixRotate2, 1);
+							bezier = ReadCurve(curve, timeline, bezier, frame, 1, time, time2, mixX, mixX2, 1);
+							bezier = ReadCurve(curve, timeline, bezier, frame, 2, time, time2, mixY, mixY2, 1);
+							bezier = ReadCurve(curve, timeline, bezier, frame, 3, time, time2, mixScaleX, mixScaleX2, 1);
+							bezier = ReadCurve(curve, timeline, bezier, frame, 4, time, time2, mixScaleY, mixScaleY2, 1);
+							bezier = ReadCurve(curve, timeline, bezier, frame, 5, time, time2, mixShearY, mixShearY2, 1);
 						}
 						time = time2;
-						rotateMix = rotateMix2;
-						translateMix = translateMix2;
-						scaleMix = scaleMix2;
-						shearMix = shearMix2;
+						mixRotate = mixRotate2;
+						mixX = mixX2;
+						mixY = mixY2;
+						mixScaleX = mixScaleX2;
+						mixScaleY = mixScaleY2;
+						mixScaleX = mixScaleX2;
 						keyMap = nextMap;
 					}
 					timelines.Add(timeline);
@@ -903,8 +913,35 @@ namespace Spine {
 								data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed ? scale : 1));
 						}
 						else if (timelineName == "mix") {
-							CurveTimeline2 timeline = new PathConstraintMixTimeline(values.Count, values.Count << 1, index);
-							timelines.Add(ReadTimeline(ref keyMapEnumerator, timeline, "rotateMix", "translateMix", 1, 1));
+							PathConstraintMixTimeline timeline = new PathConstraintMixTimeline(values.Count, values.Count * 3, index);
+							var keyMap = (Dictionary<string, Object>)keyMapEnumerator.Current;
+							float time = GetFloat(keyMap, "time", 0);
+							float mixRotate = GetFloat(keyMap, "mixRotate", 1);
+							float mixX = GetFloat(keyMap, "mixX", 1), mixY = GetFloat(keyMap, "mixY", mixX);
+							for (int frame = 0, bezier = 0; ; frame++) {
+								timeline.SetFrame(frame, time, mixRotate, mixX, mixY);
+								hasNext = keyMapEnumerator.MoveNext();
+								if (!hasNext) {
+									timeline.Shrink(bezier);
+									break;
+								}
+								var nextMap = (Dictionary<string, Object>)keyMapEnumerator.Current;
+								float time2 = GetFloat(nextMap, "time", 0);
+								float mixRotate2 = GetFloat(nextMap, "mixRotate", 1);
+								float mixX2 = GetFloat(nextMap, "mixX", 1), mixY2 = GetFloat(nextMap, "mixY", mixX2);
+								if (keyMap.ContainsKey("curve")) {
+									object curve = keyMap["curve"];
+									bezier = ReadCurve(curve, timeline, bezier, frame, 0, time, time2, mixRotate, mixRotate2, 1);
+									bezier = ReadCurve(curve, timeline, bezier, frame, 1, time, time2, mixX, mixX2, 1);
+									bezier = ReadCurve(curve, timeline, bezier, frame, 2, time, time2, mixY, mixY2, 1);
+								}
+								time = time2;
+								mixRotate = mixRotate2;
+								mixX = mixX2;
+								mixY = mixY2;
+								keyMap = nextMap;
+							}
+							timelines.Add(timeline);
 						}
 					}
 				}

spine-csharp/src/TransformConstraint.cs

@@ -41,7 +41,7 @@ namespace Spine {
 		internal TransformConstraintData data;
 		internal ExposedList<Bone> bones;
 		internal Bone target;
-		internal float rotateMix, translateMix, scaleMix, shearMix;
+		internal float mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY;
 
 		internal bool active;
 
@@ -49,11 +49,12 @@ namespace Spine {
 			if (data == null) throw new ArgumentNullException("data", "data cannot be null.");
 			if (skeleton == null) throw new ArgumentNullException("skeleton", "skeleton cannot be null.");
 			this.data = data;
-			rotateMix = data.rotateMix;
-			translateMix = data.translateMix;
-			scaleMix = data.scaleMix;
-			shearMix = data.shearMix;
-
+			mixRotate = data.mixRotate;
+			mixX = data.mixX;
+			mixY = data.mixY;
+			mixScaleX = data.mixScaleX;
+			mixScaleY = data.mixScaleY;
+			mixShearY = data.mixShearY;
 			bones = new ExposedList<Bone>();
 			foreach (BoneData boneData in data.bones)
 				bones.Add (skeleton.FindBone(boneData.name));
@@ -70,14 +71,16 @@ namespace Spine {
 			foreach (Bone bone in constraint.Bones)
 				bones.Add(skeleton.Bones.Items[bone.data.index]);
 			target = skeleton.Bones.Items[constraint.target.data.index];
-			rotateMix = constraint.rotateMix;
-			translateMix = constraint.translateMix;
-			scaleMix = constraint.scaleMix;
-			shearMix = constraint.shearMix;
+			mixRotate = constraint.mixRotate;
+			mixX = constraint.mixX;
+			mixY = constraint.mixY;
+			mixScaleX = constraint.mixScaleX;
+			mixScaleY = constraint.mixScaleY;
+			mixShearY = constraint.mixShearY;
 		}
 
 		public void Update () {
-			if (rotateMix == 0 && translateMix == 0 && scaleMix == 0 && shearMix == 0) return;
+			if (mixRotate == 0 && mixX == 0 && mixY == 0 && mixScaleX == 0 && mixScaleX == 0 && mixShearY == 0) return;
 			if (data.local) {
 				if (data.relative)
 					ApplyRelativeLocal();
@@ -92,22 +95,27 @@ namespace Spine {
 		}
 
 		void ApplyAbsoluteWorld () {
-			float rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
+			float mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
+			mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;
+			bool translate = mixX != 0 || mixY != 0;
+
 			Bone target = this.target;
 			float ta = target.a, tb = target.b, tc = target.c, td = target.d;
 			float degRadReflect = ta * td - tb * tc > 0 ? MathUtils.DegRad : -MathUtils.DegRad;
 			float offsetRotation = data.offsetRotation * degRadReflect, offsetShearY = data.offsetShearY * degRadReflect;
+
 			var bones = this.bones.Items;
 			for (int i = 0, n = this.bones.Count; i < n; i++) {
 				Bone bone = bones[i];
 
-				if (rotateMix != 0) {
+				if (mixRotate != 0) {
 					float a = bone.a, b = bone.b, c = bone.c, d = bone.d;
 					float r = MathUtils.Atan2(tc, ta) - MathUtils.Atan2(c, a) + offsetRotation;
 					if (r > MathUtils.PI)
 						r -= MathUtils.PI2;
-					else if (r < -MathUtils.PI) r += MathUtils.PI2;
-					r *= rotateMix;
+					else if (r < -MathUtils.PI) //
+						r += MathUtils.PI2;
+					r *= mixRotate;
 					float cos = MathUtils.Cos(r), sin = MathUtils.Sin(r);
 					bone.a = cos * a - sin * c;
 					bone.b = cos * b - sin * d;
@@ -115,32 +123,35 @@ namespace Spine {
 					bone.d = sin * b + cos * d;
 				}
 
-				if (translateMix != 0) {
+				if (translate) {
 					float tx, ty; //Vector2 temp = this.temp;
 					target.LocalToWorld(data.offsetX, data.offsetY, out tx, out ty); //target.localToWorld(temp.set(data.offsetX, data.offsetY));
-					bone.worldX += (tx - bone.worldX) * translateMix;
-					bone.worldY += (ty - bone.worldY) * translateMix;
+					bone.worldX += (tx - bone.worldX) * mixX;
+					bone.worldY += (ty - bone.worldY) * mixY;
 				}
 
-				if (scaleMix > 0) {
+				if (mixScaleX != 0) {
 					float s = (float)Math.Sqrt(bone.a * bone.a + bone.c * bone.c);
-					if (s != 0) s = (s + ((float)Math.Sqrt(ta * ta + tc * tc) - s + data.offsetScaleX) * scaleMix) / s;
+					if (s != 0) s = (s + ((float)Math.Sqrt(ta * ta + tc * tc) - s + data.offsetScaleX) * mixScaleX) / s;
 					bone.a *= s;
 					bone.c *= s;
-					s = (float)Math.Sqrt(bone.b * bone.b + bone.d * bone.d);
-					if (s != 0) s = (s + ((float)Math.Sqrt(tb * tb + td * td) - s + data.offsetScaleY) * scaleMix) / s;
+				}
+				if (mixScaleY != 0) {
+					float s = (float)Math.Sqrt(bone.b * bone.b + bone.d * bone.d);
+					if (s != 0) s = (s + ((float)Math.Sqrt(tb * tb + td * td) - s + data.offsetScaleY) * mixScaleY) / s;
 					bone.b *= s;
 					bone.d *= s;
 				}
 
-				if (shearMix > 0) {
+				if (mixShearY > 0) {
 					float b = bone.b, d = bone.d;
 					float by = MathUtils.Atan2(d, b);
 					float r = MathUtils.Atan2(td, tb) - MathUtils.Atan2(tc, ta) - (by - MathUtils.Atan2(bone.c, bone.a));
 					if (r > MathUtils.PI)
 						r -= MathUtils.PI2;
-					else if (r < -MathUtils.PI) r += MathUtils.PI2;
-					r = by + (r + offsetShearY) * shearMix;
+					else if (r < -MathUtils.PI) //
+						r += MathUtils.PI2;
+					r = by + (r + offsetShearY) * mixShearY;
 					float s = (float)Math.Sqrt(b * b + d * d);
 					bone.b = MathUtils.Cos(r) * s;
 					bone.d = MathUtils.Sin(r) * s;
@@ -151,22 +162,27 @@ namespace Spine {
 		}
 
 		void ApplyRelativeWorld () {
-			float rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
+			float mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
+			mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;
+			bool translate = mixX != 0 || mixY != 0;
+
 			Bone target = this.target;
 			float ta = target.a, tb = target.b, tc = target.c, td = target.d;
 			float degRadReflect = ta * td - tb * tc > 0 ? MathUtils.DegRad : -MathUtils.DegRad;
 			float offsetRotation = data.offsetRotation * degRadReflect, offsetShearY = data.offsetShearY * degRadReflect;
+
 			var bones = this.bones.Items;
 			for (int i = 0, n = this.bones.Count; i < n; i++) {
 				Bone bone = bones[i];
 
-				if (rotateMix != 0) {
+				if (mixRotate != 0) {
 					float a = bone.a, b = bone.b, c = bone.c, d = bone.d;
 					float r = MathUtils.Atan2(tc, ta) + offsetRotation;
 					if (r > MathUtils.PI)
 						r -= MathUtils.PI2;
-					else if (r < -MathUtils.PI) r += MathUtils.PI2;
-					r *= rotateMix;
+					else if (r < -MathUtils.PI) //
+						r += MathUtils.PI2;
+					r *= mixRotate;
 					float cos = MathUtils.Cos(r), sin = MathUtils.Sin(r);
 					bone.a = cos * a - sin * c;
 					bone.b = cos * b - sin * d;
@@ -174,29 +190,32 @@ namespace Spine {
 					bone.d = sin * b + cos * d;
 				}
 
-				if (translateMix != 0) {
+				if (translate) {
 					float tx, ty; //Vector2 temp = this.temp;
 					target.LocalToWorld(data.offsetX, data.offsetY, out tx, out ty); //target.localToWorld(temp.set(data.offsetX, data.offsetY));
-					bone.worldX += tx * translateMix;
-					bone.worldY += ty * translateMix;
+					bone.worldX += tx * mixX;
+					bone.worldY += ty * mixY;
 				}
 
-				if (scaleMix > 0) {
-					float s = ((float)Math.Sqrt(ta * ta + tc * tc) - 1 + data.offsetScaleX) * scaleMix + 1;
+				if (mixScaleX != 0) {
+					float s = ((float)Math.Sqrt(ta * ta + tc * tc) - 1 + data.offsetScaleX) * mixScaleX + 1;
 					bone.a *= s;
 					bone.c *= s;
-					s = ((float)Math.Sqrt(tb * tb + td * td) - 1 + data.offsetScaleY) * scaleMix + 1;
+				}
+				if (mixScaleY != 0) {
+					float s = ((float)Math.Sqrt(tb * tb + td * td) - 1 + data.offsetScaleY) * mixScaleY + 1;
 					bone.b *= s;
 					bone.d *= s;
 				}
 
-				if (shearMix > 0) {
+				if (mixShearY > 0) {
 					float r = MathUtils.Atan2(td, tb) - MathUtils.Atan2(tc, ta);
 					if (r > MathUtils.PI)
 						r -= MathUtils.PI2;
-					else if (r < -MathUtils.PI) r += MathUtils.PI2;
+					else if (r < -MathUtils.PI) //
+						r += MathUtils.PI2;
 					float b = bone.b, d = bone.d;
-					r = MathUtils.Atan2(d, b) + (r - MathUtils.PI / 2 + offsetShearY) * shearMix;
+					r = MathUtils.Atan2(d, b) + (r - MathUtils.PI / 2 + offsetShearY) * mixShearY;
 					float s = (float)Math.Sqrt(b * b + d * d);
 					bone.b = MathUtils.Cos(r) * s;
 					bone.d = MathUtils.Sin(r) * s;
@@ -207,38 +226,39 @@ namespace Spine {
 		}
 
 		void ApplyAbsoluteLocal () {
-			float rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
+			float mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
+			mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;
+
 			Bone target = this.target;
 			if (!target.appliedValid) target.UpdateAppliedTransform();
+
 			var bones = this.bones.Items;
 			for (int i = 0, n = this.bones.Count; i < n; i++) {
 				Bone bone = bones[i];
 				if (!bone.appliedValid) bone.UpdateAppliedTransform();
 
 				float rotation = bone.arotation;
-				if (rotateMix != 0) {
+				if (mixRotate != 0) {
 					float r = target.arotation - rotation + data.offsetRotation;
 					r -= (16384 - (int)(16384.499999999996 - r / 360)) * 360;
-					rotation += r * rotateMix;
+					rotation += r * mixRotate;
 				}
 
 				float x = bone.ax, y = bone.ay;
-				if (translateMix != 0) {
-					x += (target.ax - x + data.offsetX) * translateMix;
-					y += (target.ay - y + data.offsetY) * translateMix;
-				}
+				x += (target.ax - x + data.offsetX) * mixX;
+				y += (target.ay - y + data.offsetY) * mixY;
 
 				float scaleX = bone.ascaleX, scaleY = bone.ascaleY;
-				if (scaleMix != 0) {
-					if (scaleX != 0) scaleX = (scaleX + (target.ascaleX - scaleX + data.offsetScaleX) * scaleMix) / scaleX;
-					if (scaleY != 0) scaleY = (scaleY + (target.ascaleY - scaleY + data.offsetScaleY) * scaleMix) / scaleY;
-				}
+				if (mixScaleX != 0 && scaleX != 0)
+					scaleX = (scaleX + (target.ascaleX - scaleX + data.offsetScaleX) * mixScaleX) / scaleX;
+				if (mixScaleY != 0 && scaleY != 0)
+					scaleY = (scaleY + (target.ascaleY - scaleY + data.offsetScaleY) * mixScaleY) / scaleY;
 
 				float shearY = bone.ashearY;
-				if (shearMix != 0) {
+				if (mixShearY != 0) {
 					float r = target.ashearY - shearY + data.offsetShearY;
 					r -= (16384 - (int)(16384.499999999996 - r / 360)) * 360;
-					shearY += r * shearMix;
+					shearY += r * mixShearY;
 				}
 
 				bone.UpdateWorldTransform(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
@@ -246,31 +266,23 @@ namespace Spine {
 		}
 
 		void ApplyRelativeLocal () {
-			float rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
+			float mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
+			mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;
+
 			Bone target = this.target;
 			if (!target.appliedValid) target.UpdateAppliedTransform();
+
 			var bones = this.bones.Items;
 			for (int i = 0, n = this.bones.Count; i < n; i++) {
 				Bone bone = bones[i];
 				if (!bone.appliedValid) bone.UpdateAppliedTransform();
 
-				float rotation = bone.arotation;
-				if (rotateMix != 0) rotation += (target.arotation + data.offsetRotation) * rotateMix;
-
-				float x = bone.ax, y = bone.ay;
-				if (translateMix != 0) {
-					x += (target.ax + data.offsetX) * translateMix;
-					y += (target.ay + data.offsetY) * translateMix;
-				}
-
-				float scaleX = bone.ascaleX, scaleY = bone.ascaleY;
-				if (scaleMix != 0) {
-					scaleX *= ((target.ascaleX - 1 + data.offsetScaleX) * scaleMix) + 1;
-					scaleY *= ((target.ascaleY - 1 + data.offsetScaleY) * scaleMix) + 1;
-				}
-
-				float shearY = bone.ashearY;
-				if (shearMix != 0) shearY += (target.ashearY + data.offsetShearY) * shearMix;
+				float rotation = bone.arotation + (target.arotation + data.offsetRotation) * mixRotate;
+				float x = bone.ax + (target.ax + data.offsetX) * mixX;
+				float y = bone.ay + (target.ay + data.offsetY) * mixY;
+				float scaleX = (bone.ascaleX * ((target.ascaleX - 1 + data.offsetScaleX) * mixScaleX) + 1);
+				float scaleY = (bone.ascaleY * ((target.ascaleY - 1 + data.offsetScaleY) * mixScaleY) + 1);
+				float shearY = bone.ashearY + (target.ashearY + data.offsetShearY) * mixShearY;
 
 				bone.UpdateWorldTransform(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
 			}
@@ -280,14 +292,18 @@ namespace Spine {
 		public ExposedList<Bone> Bones { get { return bones; } }
 		/// <summary>The target bone whose world transform will be copied to the constrained bones.</summary>
 		public Bone Target { get { return target; } set { target = value; } }
-		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained rotations.</summary>
-		public float RotateMix { get { return rotateMix; } set { rotateMix = value; } }
-		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained translations.</summary>
-		public float TranslateMix { get { return translateMix; } set { translateMix = value; } }
-		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained scales.</summary>
-		public float ScaleMix { get { return scaleMix; } set { scaleMix = value; } }
-		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained scales.</summary>
-		public float ShearMix { get { return shearMix; } set { shearMix = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained rotation.</summary>
+		public float MixRotate { get { return mixRotate; } set { mixRotate = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained translation X.</summary>
+		public float MixX { get { return mixX; } set { mixX = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained translation Y.</summary>
+		public float MixY { get { return mixY; } set { mixY = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained scale X.</summary>
+		public float MixScaleX { get { return mixScaleX; } set { mixScaleX = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained scale Y.</summary>
+		public float MixScaleY { get { return mixScaleY; } set { mixScaleY = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained shear Y.</summary>
+		public float MixShearY { get { return mixShearY; } set { mixShearY = value; } }
 		public bool Active { get { return active; } }
 		/// <summary>The transform constraint's setup pose data.</summary>
 		public TransformConstraintData Data { get { return data; } }

spine-csharp/src/TransformConstraintData.cs

@@ -33,16 +33,24 @@ namespace Spine {
 	public class TransformConstraintData : ConstraintData {
 		internal ExposedList<BoneData> bones = new ExposedList<BoneData>();
 		internal BoneData target;
-		internal float rotateMix, translateMix, scaleMix, shearMix;
+		internal float mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY;
 		internal float offsetRotation, offsetX, offsetY, offsetScaleX, offsetScaleY, offsetShearY;
 		internal bool relative, local;
 
 		public ExposedList<BoneData> Bones { get { return bones; } }
 		public BoneData Target { get { return target; } set { target = value; } }
-		public float RotateMix { get { return rotateMix; } set { rotateMix = value; } }
-		public float TranslateMix { get { return translateMix; } set { translateMix = value; } }
-		public float ScaleMix { get { return scaleMix; } set { scaleMix = value; } }
-		public float ShearMix { get { return shearMix; } set { shearMix = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained rotation.</summary>
+		public float MixRotate { get { return mixRotate; } set { mixRotate = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained translation X.</summary>
+		public float MixX { get { return mixX; } set { mixX = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained translation Y.</summary>
+		public float MixY { get { return mixY; } set { mixY = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained scale X.</summary>
+		public float MixScaleX { get { return mixScaleX; } set { mixScaleX = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained scale Y.</summary>
+		public float MixScaleY { get { return mixScaleY; } set { mixScaleY = value; } }
+		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained shear Y.</summary>
+		public float MixShearY { get { return mixShearY; } set { mixShearY = value; } }
 
 		public float OffsetRotation { get { return offsetRotation; } set { offsetRotation = value; } }
 		public float OffsetX { get { return offsetX; } set { offsetX = value; } }

spine-unity/Assets/Spine Examples/Scripts/MecanimAnimationMatchModifier/AnimationMatchModifierAsset.cs

@@ -206,7 +206,7 @@ namespace Spine.Unity.Examples {
 			static TransformConstraintTimeline GetFillerTimeline (TransformConstraintTimeline timeline, SkeletonData skeletonData) {
 				var t = new TransformConstraintTimeline(1, 0, timeline.TransformConstraintIndex);
 				var data = skeletonData.TransformConstraints.Items[timeline.TransformConstraintIndex];
-				t.SetFrame(0, 0, data.RotateMix, data.TranslateMix, data.ScaleMix, data.ShearMix);
+				t.SetFrame(0, 0, data.MixRotate, data.MixX, data.MixY, data.MixScaleX, data.MixScaleY, data.MixShearY);
 				return t;
 			}
 
@@ -227,7 +227,7 @@ namespace Spine.Unity.Examples {
 			static PathConstraintMixTimeline GetFillerTimeline (PathConstraintMixTimeline timeline, SkeletonData skeletonData) {
 				var t = new PathConstraintMixTimeline(1, 0, timeline.PathConstraintIndex);
 				var data = skeletonData.PathConstraints.Items[timeline.PathConstraintIndex];
-				t.SetFrame(0, 0, data.RotateMix, data.TranslateMix);
+				t.SetFrame(0, 0, data.RotateMix, data.MixX, data.MixY);
 				return t;
 			}
 			#endregion

spine-unity/Assets/Spine Examples/Scripts/Sample Components/SkeletonUtility Modules/SkeletonRagdoll.cs

@@ -212,16 +212,19 @@ namespace Spine.Unity.Examples {
 			if (disableOtherConstraints) {
 				var transformConstraints = skeleton.TransformConstraints;
 				for (int i = 0, n = transformConstraints.Count; i < n; i++) {
-					transformConstraints.Items[i].RotateMix = 0;
-					transformConstraints.Items[i].ScaleMix = 0;
-					transformConstraints.Items[i].ShearMix = 0;
-					transformConstraints.Items[i].TranslateMix = 0;
+					transformConstraints.Items[i].MixRotate = 0;
+					transformConstraints.Items[i].MixScaleX = 0;
+					transformConstraints.Items[i].MixScaleY = 0;
+					transformConstraints.Items[i].MixShearY = 0;
+					transformConstraints.Items[i].MixX = 0;
+					transformConstraints.Items[i].MixY = 0;
 				}
 
 				var pathConstraints = skeleton.PathConstraints;
 				for (int i = 0, n = pathConstraints.Count; i < n; i++) {
-					pathConstraints.Items[i].RotateMix = 0;
-					pathConstraints.Items[i].TranslateMix = 0;
+					pathConstraints.Items[i].MixRotate = 0;
+					pathConstraints.Items[i].MixX = 0;
+					pathConstraints.Items[i].MixY = 0;
 				}
 			}
 

spine-unity/Assets/Spine Examples/Scripts/Sample Components/SkeletonUtility Modules/SkeletonRagdoll2D.cs

@@ -224,16 +224,19 @@ namespace Spine.Unity.Examples {
 			if (disableOtherConstraints) {
 				var transformConstraints = skeleton.TransformConstraints;
 				for (int i = 0, n = transformConstraints.Count; i < n; i++) {
-					transformConstraints.Items[i].RotateMix = 0;
-					transformConstraints.Items[i].ScaleMix = 0;
-					transformConstraints.Items[i].ShearMix = 0;
-					transformConstraints.Items[i].TranslateMix = 0;
+					transformConstraints.Items[i].MixRotate = 0;
+					transformConstraints.Items[i].MixScaleX = 0;
+					transformConstraints.Items[i].MixScaleY = 0;
+					transformConstraints.Items[i].MixShearY = 0;
+					transformConstraints.Items[i].MixX = 0;
+					transformConstraints.Items[i].MixY = 0;
 				}
 
 				var pathConstraints = skeleton.PathConstraints;
 				for (int i = 0, n = pathConstraints.Count; i < n; i++) {
-					pathConstraints.Items[i].RotateMix = 0;
-					pathConstraints.Items[i].TranslateMix = 0;
+					pathConstraints.Items[i].MixRotate = 0;
+					pathConstraints.Items[i].MixX = 0;
+					pathConstraints.Items[i].MixY = 0;
 				}
 			}
 

spine-unity/Assets/Spine/Editor/spine-unity/Editor/Utility/SpineHandles.cs

@@ -359,8 +359,9 @@ namespace Spine.Unity.Editor {
 				var targetBone = tc.Target;
 				targetPos = targetBone.GetWorldPosition(transform, skeletonRenderScale);
 
-				if (tc.TranslateMix > 0) {
-					if (tc.TranslateMix != 1f) {
+				if (tc.MixX > 0 || tc.MixY > 0) {
+					if ((tc.MixX > 0 && tc.MixX != 1f) ||
+						(tc.MixY > 0 && tc.MixY != 1f)) {
 						Handles.color = handleColor;
 						foreach (var b in tc.Bones) {
 							pos = b.GetWorldPosition(transform, skeletonRenderScale);
@@ -416,7 +417,7 @@ namespace Spine.Unity.Editor {
 			// Path Constraints
 			handleColor = SpineHandles.PathColor;
 			foreach (var pc in skeleton.PathConstraints) {
-				active = pc.TranslateMix > 0;
+				active = pc.MixX > 0 || pc.MixY > 0 || pc.MixRotate > 0;
 				if (active)
 					foreach (var b in pc.Bones)
 						SpineHandles.DrawBoneCircle(b.GetWorldPosition(transform, skeletonRenderScale), handleColor, normal, 1f * skeletonRenderScale);

spine-unity/Assets/Spine/Editor/spine-unity/Editor/Windows/SkeletonDebugWindow.cs

@@ -419,10 +419,12 @@ namespace Spine.Unity.Editor {
 										EditorGUI.EndDisabledGroup();
 
 										EditorGUI.BeginChangeCheck();
-										c.TranslateMix = EditorGUILayout.Slider("TranslateMix", c.TranslateMix, MixMin, MixMax);
-										c.RotateMix = EditorGUILayout.Slider("RotateMix", c.RotateMix, MixMin, MixMax);
-										c.ScaleMix = EditorGUILayout.Slider("ScaleMix", c.ScaleMix, MixMin, MixMax);
-										c.ShearMix = EditorGUILayout.Slider("ShearMix", c.ShearMix, MixMin, MixMax);
+										c.MixX = EditorGUILayout.Slider("Mix Translate X", c.MixX, MixMin, MixMax);
+										c.MixY = EditorGUILayout.Slider("Mix Translate Y", c.MixY, MixMin, MixMax);
+										c.MixRotate = EditorGUILayout.Slider("Mix Rotate", c.MixRotate, MixMin, MixMax);
+										c.MixScaleX = EditorGUILayout.Slider("Mix Scale X", c.MixScaleX, MixMin, MixMax);
+										c.MixScaleY = EditorGUILayout.Slider("Mix Scale Y", c.MixScaleY, MixMin, MixMax);
+										c.MixShearY = EditorGUILayout.Slider("Mix Shear Y", c.MixShearY, MixMin, MixMax);
 										if (EditorGUI.EndChangeCheck()) requireRepaint = true;
 
 										EditorGUILayout.Space();
@@ -452,8 +454,9 @@ namespace Spine.Unity.Editor {
 										EditorGUI.EndDisabledGroup();
 
 										EditorGUI.BeginChangeCheck();
-										c.RotateMix = EditorGUILayout.Slider("RotateMix", c.RotateMix, MixMin, MixMax);
-										c.TranslateMix = EditorGUILayout.Slider("TranslateMix", c.TranslateMix, MixMin, MixMax);
+										c.MixRotate = EditorGUILayout.Slider("Mix Rotate", c.MixRotate, MixMin, MixMax);
+										c.MixX = EditorGUILayout.Slider("Mix Translate X", c.MixX, MixMin, MixMax);
+										c.MixY = EditorGUILayout.Slider("Mix Translate Y", c.MixY, MixMin, MixMax);
 										c.Position = EditorGUILayout.FloatField("Position", c.Position);
 										c.Spacing = EditorGUILayout.FloatField("Spacing", c.Spacing);
 										if (EditorGUI.EndChangeCheck()) requireRepaint = true;