Merge branch '3.7' into 3.8-beta

spine-csharp/src/AnimationState.cs

@@ -264,7 +264,7 @@ namespace Spine {
 			} else {
 				mix = to.mixTime / to.mixDuration;
 				if (mix > 1) mix = 1;
-				if (blend != MixBlend.First) blend = from.mixBlend; // Track 0 ignores frack mix blend.
+				if (blend != MixBlend.First) blend = from.mixBlend; // Track 0 ignores track mix blend.
 			}
 
 			var eventBuffer = mix < from.eventThreshold ? this.events : null;

spine-csharp/src/IkConstraint.cs

@@ -31,55 +31,20 @@
 using System;
 
 namespace Spine {
+	/// <summary>
+	/// <para>
+	/// Stores the current pose for an IK constraint. An IK constraint adjusts the rotation of 1 or 2 constrained bones so the tip of
+	/// the last bone is as close to the target bone as possible.</para>
+	/// <para>
+	/// See <a href="http://esotericsoftware.com/spine-ik-constraints">IK constraints</a> in the Spine User Guide.</para>
+	/// </summary>
 	public class IkConstraint : IConstraint {
 		internal IkConstraintData data;
 		internal ExposedList<Bone> bones = new ExposedList<Bone>();
 		internal Bone target;
 		internal int bendDirection;
 		internal bool compress, stretch;
-		internal float mix;
-
-		public IkConstraintData Data { get { return data; } }
-		public int Order { get { return data.order; } }
-
-		/// <summary>The bones that will be modified by this IK constraint.</summary>
-		public ExposedList<Bone> Bones {
-			get { return bones; }
-		}
-
-		/// <summary>The bone that is the IK target.</summary>
-		public Bone Target {
-			get { return target; }
-			set { target = value; }
-		}
-
-		/// <summary>Controls the bend direction of the IK bones, either 1 or -1.</summary>
-		public int BendDirection {
-			get { return bendDirection; }
-			set { bendDirection = value; }
-		}
-
-		/// <summary>
-		/// When true and only a single bone is being constrained, 
-		/// if the target is too close, the bone is scaled to reach it.</summary>
-		public bool Compress {
-			get { return compress; }
-			set { compress = value; }
-		}
-
-		/// <summary>
-		/// When true, if the target is out of range, the parent bone is scaled on the X axis to reach it.
-		/// If the parent bone has nonuniform scale, stretching is not applied.</summary>
-		public bool Stretch {
-			get { return stretch; }
-			set { stretch = value; }
-		}
-
-		/// <summary>A percentage (0-1) that controls the mix between the constrained and unconstrained rotations.</summary>
-		public float Mix {
-			get { return mix; }
-			set { mix = value; }
-		}
+		internal float mix = 1;
 
 		public IkConstraint (IkConstraintData data, Skeleton skeleton) {
 			if (data == null) throw new ArgumentNullException("data", "data cannot be null.");
@@ -96,6 +61,21 @@ namespace Spine {
 			target = skeleton.FindBone(data.target.name);
 		}
 
+		/// <summary>Copy constructor.</summary>
+		public IkConstraint (IkConstraint constraint, Skeleton skeleton) {
+			if (constraint == null) throw new ArgumentNullException("constraint cannot be null.");
+			if (skeleton == null) throw new ArgumentNullException("skeleton cannot be null.");
+			data = constraint.data;
+			bones = new ExposedList<Bone>(constraint.Bones.Count);
+			foreach (Bone bone in constraint.Bones)
+				bones.Add(skeleton.Bones.Items[bone.data.index]);
+			target = skeleton.Bones.Items[constraint.target.data.index];
+			mix = constraint.mix;
+			bendDirection = constraint.bendDirection;
+			compress = constraint.compress;
+			stretch = constraint.stretch;
+		}
+
 		/// <summary>Applies the constraint to the constrained bones.</summary>
 		public void Apply () {
 			Update();
@@ -114,12 +94,61 @@ namespace Spine {
 			}
 		}
 
+
+		public int Order {
+			get { return data.order; }
+		}
+
+		/// <summary>The bones that will be modified by this IK constraint.</summary>
+		public ExposedList<Bone> Bones {
+			get { return bones; }
+		}
+
+		/// <summary>The bone that is the IK target.</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 Mix {
+			get { return mix; }
+			set { mix = value; }
+		}
+
+		/// <summary>Controls the bend direction of the IK bones, either 1 or -1.</summary>
+		public int BendDirection {
+			get { return bendDirection; }
+			set { bendDirection = value; }
+		}
+
+		/// <summary>
+		/// When true and only a single bone is being constrained, if the target is too close, the bone is scaled to reach it.</summary>
+		public bool Compress {
+			get { return compress; }
+			set { compress = value; }
+		}
+
+		/// <summary>
+		///  When true, if the target is out of range, the parent bone is scaled to reach it. If more than one bone is being constrained
+		///  and the parent bone has local nonuniform scale, stretch is not applied.</summary>
+		public bool Stretch {
+			get { return stretch; }
+			set { stretch = value; }
+		}
+
+		/// <summary>The IK constraint's setup pose data.</summary>
+		public IkConstraintData Data {
+			get { return data; }
+		}
+
 		override public string ToString () {
 			return data.name;
 		}
 
 		/// <summary>Applies 1 bone IK. The target is specified in the world coordinate system.</summary>
-		static public void Apply (Bone bone, float targetX, float targetY, bool compress, bool stretch, bool uniform, float alpha) {
+		static public void Apply (Bone bone, float targetX, float targetY, bool compress, bool stretch, bool uniform,
+								float alpha) {
 			if (!bone.appliedValid) bone.UpdateAppliedTransform();
 			Bone p = bone.parent;
 			float id = 1 / (p.a * p.d - p.b * p.c);
@@ -140,16 +169,14 @@ namespace Spine {
 					if (uniform) sy *= s;
 				}
 			}
-			bone.UpdateWorldTransform(bone.ax, bone.ay, bone.arotation + rotationIK * alpha, sx, sy, bone.ashearX,
-				bone.ashearY);
+			bone.UpdateWorldTransform(bone.ax, bone.ay, bone.arotation + rotationIK * alpha, sx, sy, bone.ashearX, bone.ashearY);
 		}
 
-		/// <summary>Adjusts the parent and child bone rotations so the tip of the child is as close to the target position as
-		/// possible. The target is specified in the world coordinate system.</summary>
+		/// <summary>Applies 2 bone IK. The target is specified in the world coordinate system.</summary>
 		/// <param name="child">A direct descendant of the parent bone.</param>
 		static public void Apply (Bone parent, Bone child, float targetX, float targetY, int bendDir, bool stretch, float alpha) {
 			if (alpha == 0) {
-				child.UpdateWorldTransform ();
+				child.UpdateWorldTransform();
 				return;
 			}
 			if (!parent.appliedValid) parent.UpdateAppliedTransform();

spine-csharp/src/PathConstraint.cs

@@ -31,6 +31,14 @@
 using System;
 
 namespace Spine {
+
+	/// <summary>
+	/// <para>
+	/// Stores the current pose for a path constraint. A path constraint adjusts the rotation, translation, and scale of the
+	/// constrained bones so they follow a {@link PathAttachment}.</para>
+	/// <para>
+	/// See <a href="http://esotericsoftware.com/spine-path-constraints">Path constraints</a> in the Spine User Guide.</para>
+	/// </summary>
 	public class PathConstraint : IConstraint {
 		const int NONE = -1, BEFORE = -2, AFTER = -3;
 		const float Epsilon = 0.00001f;
@@ -44,15 +52,6 @@ namespace Spine {
 		internal ExposedList<float> world = new ExposedList<float>(), curves = new ExposedList<float>(), lengths = new ExposedList<float>();
 		internal float[] segments = new float[10];
 
-		public int Order { get { return data.order; } }
-		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; } }
-		public ExposedList<Bone> Bones { get { return bones; } }
-		public Slot Target { get { return target; } set { target = value; } }
-		public PathConstraintData Data { get { return data; } }
-
 		public PathConstraint (PathConstraintData data, Skeleton skeleton) {
 			if (data == null) throw new ArgumentNullException("data", "data cannot be null.");
 			if (skeleton == null) throw new ArgumentNullException("skeleton", "skeleton cannot be null.");
@@ -67,11 +66,26 @@ namespace Spine {
 			translateMix = data.translateMix;
 		}
 
+		/// <summary>Copy constructor.</summary>
+		public PathConstraint (PathConstraint constraint, Skeleton skeleton) {
+			if (constraint == null) throw new ArgumentNullException("constraint cannot be null.");
+			if (skeleton == null) throw new ArgumentNullException("skeleton cannot be null.");
+			data = constraint.data;
+			bones = new ExposedList<Bone>(constraint.Bones.Count);
+			foreach (Bone bone in constraint.Bones)
+				bones.Add(skeleton.Bones.Items[bone.data.index]);
+			target = skeleton.slots.Items[constraint.target.data.index];
+			position = constraint.position;
+			spacing = constraint.spacing;
+			rotateMix = constraint.rotateMix;
+			translateMix = constraint.translateMix;
+		}
+
 		/// <summary>Applies the constraint to the constrained bones.</summary>
 		public void Apply () {
 			Update();
 		}
-			
+		
 		public void Update () {
 			PathAttachment attachment = target.Attachment as PathAttachment;
 			if (attachment == null) return;
@@ -183,7 +197,7 @@ namespace Spine {
 			float[] spacesItems = 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 = 0;
 
 			if (!path.ConstantSpeed) {
 				float[] lengths = path.Lengths;
@@ -207,14 +221,14 @@ namespace Spine {
 					} else if (p < 0) {
 						if (prevCurve != BEFORE) {
 							prevCurve = BEFORE;
-							path.ComputeWorldVertices(target, 2, 4, world, 0);
+							path.ComputeWorldVertices(target, 2, 4, world, 0, 2);
 						}
 						AddBeforePosition(p, world, 0, output, o);
 						continue;
 					} else if (p > pathLength) {
 						if (prevCurve != AFTER) {
 							prevCurve = AFTER;
-							path.ComputeWorldVertices(target, verticesLength - 6, 4, world, 0);
+							path.ComputeWorldVertices(target, verticesLength - 6, 4, world, 0, 2);
 						}
 						AddAfterPosition(p - pathLength, world, 0, output, o);
 						continue;
@@ -235,10 +249,10 @@ namespace Spine {
 					if (curve != prevCurve) {
 						prevCurve = curve;
 						if (closed && curve == curveCount) {
-							path.ComputeWorldVertices(target, verticesLength - 4, 4, world, 0);
-							path.ComputeWorldVertices(target, 0, 4, world, 4);
+							path.ComputeWorldVertices(target, verticesLength - 4, 4, world, 0, 2);
+							path.ComputeWorldVertices(target, 0, 4, world, 4, 2);
 						} else
-							path.ComputeWorldVertices(target, curve * 6 + 2, 8, world, 0);
+							path.ComputeWorldVertices(target, curve * 6 + 2, 8, world, 0, 2);
 					}
 					AddCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], output, o,
 						tangents || (i > 0 && space < PathConstraint.Epsilon));
@@ -250,15 +264,15 @@ namespace Spine {
 			if (closed) {
 				verticesLength += 2;
 				world = this.world.Resize(verticesLength).Items;
-				path.ComputeWorldVertices(target, 2, verticesLength - 4, world, 0);
-				path.ComputeWorldVertices(target, 0, 2, world, verticesLength - 4);
+				path.ComputeWorldVertices(target, 2, verticesLength - 4, world, 0, 2);
+				path.ComputeWorldVertices(target, 0, 2, world, verticesLength - 4, 2);
 				world[verticesLength - 2] = world[0];
 				world[verticesLength - 1] = world[1];
 			} else {
 				curveCount--;
 				verticesLength -= 4;
 				world = this.world.Resize(verticesLength).Items;
-				path.ComputeWorldVertices(target, 2, verticesLength, world, 0);
+				path.ComputeWorldVertices(target, 2, verticesLength, world, 0, 2);
 			}
 
 			// Curve lengths.
@@ -432,5 +446,25 @@ namespace Spine {
 					output[o + 2] = (float)Math.Atan2(y - (y1 * uu + cy1 * ut * 2 + cy2 * tt), x - (x1 * uu + cx1 * ut * 2 + cx2 * tt));
 			}
 		}
+		
+		public int Order { get { return data.order; } }
+		/// <summary>The position along the path.</summary>
+		public float Position { get { return position; } set { position = value; } }
+		/// <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; } }
+		/// <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>
+		public Slot Target { get { return target; } set { target = value; } }
+		/// <summary>The path constraint's setup pose data.</summary>
+		public PathConstraintData Data { get { return data; } }
+
+		override public string ToString () {
+			return data.name;
+		}
 	}
 }

spine-csharp/src/TransformConstraint.cs

@@ -31,21 +31,19 @@
 using System;
 
 namespace Spine {
+	/// <summary>
+	/// <para>
+	/// Stores the current pose for a transform constraint. A transform constraint adjusts the world transform of the constrained
+	/// bones to match that of the target bone.</para>
+	/// <para>
+	/// See <a href="http://esotericsoftware.com/spine-transform-constraints">Transform constraints</a> in the Spine User Guide.</para>
+	/// </summary>
 	public class TransformConstraint : IConstraint {
 		internal TransformConstraintData data;
 		internal ExposedList<Bone> bones;
 		internal Bone target;
 		internal float rotateMix, translateMix, scaleMix, shearMix;
 
-		public TransformConstraintData Data { get { return data; } }
-		public int Order { get { return data.order; } }
-		public ExposedList<Bone> Bones { get { return bones; } }
-		public Bone 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; } }
-
 		public TransformConstraint (TransformConstraintData data, Skeleton skeleton) {
 			if (data == null) throw new ArgumentNullException("data", "data cannot be null.");
 			if (skeleton == null) throw new ArgumentNullException("skeleton", "skeleton cannot be null.");
@@ -57,11 +55,27 @@ namespace Spine {
 
 			bones = new ExposedList<Bone>();
 			foreach (BoneData boneData in data.bones)
-				bones.Add (skeleton.FindBone (boneData.name));
+				bones.Add (skeleton.FindBone(boneData.name));
 
 			target = skeleton.FindBone(data.target.name);
 		}
 
+		/// <summary>Copy constructor.</summary>
+		public TransformConstraint (TransformConstraint constraint, Skeleton skeleton) {
+			if (constraint == null) throw new ArgumentNullException("constraint cannot be null.");
+			if (skeleton == null) throw new ArgumentNullException("skeleton cannot be null.");
+			data = constraint.data;
+			bones = new ExposedList<Bone>(constraint.Bones.Count);
+			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;
+		}
+
+		/// <summary>Applies the constraint to the constrained bones.</summary>
 		public void Apply () {
 			Update();
 		}
@@ -116,13 +130,11 @@ namespace Spine {
 
 				if (scaleMix > 0) {
 					float s = (float)Math.Sqrt(bone.a * bone.a + bone.c * bone.c);
-					//float ts = (float)Math.sqrt(ta * ta + tc * tc);
-					if (s > 0.00001f) 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) * scaleMix) / s;
 					bone.a *= s;
 					bone.c *= s;
 					s = (float)Math.Sqrt(bone.b * bone.b + bone.d * bone.d);
-					//ts = (float)Math.Sqrt(tb * tb + td * td);
-					if (s > 0.00001f) s = (s + ((float)Math.Sqrt(tb * tb + td * td) - s + data.offsetScaleY) * scaleMix) / s;
+					if (s != 0) s = (s + ((float)Math.Sqrt(tb * tb + td * td) - s + data.offsetScaleY) * scaleMix) / s;
 					bone.b *= s;
 					bone.d *= s;
 					modified = true;
@@ -231,15 +243,15 @@ namespace Spine {
 
 				float scaleX = bone.ascaleX, scaleY = bone.ascaleY;
 				if (scaleMix != 0) {
-					if (scaleX > 0.00001f) scaleX = (scaleX + (target.ascaleX - scaleX + data.offsetScaleX) * scaleMix) / scaleX;
-					if (scaleY > 0.00001f) scaleY = (scaleY + (target.ascaleY - scaleY + data.offsetScaleY) * scaleMix) / scaleY;
+					if (scaleX != 0) scaleX = (scaleX + (target.ascaleX - scaleX + data.offsetScaleX) * scaleMix) / scaleX;
+					if (scaleY != 0) scaleY = (scaleY + (target.ascaleY - scaleY + data.offsetScaleY) * scaleMix) / scaleY;
 				}
 
 				float shearY = bone.ashearY;
 				if (shearMix != 0) {
 					float r = target.ashearY - shearY + data.offsetShearY;
 					r -= (16384 - (int)(16384.499999999996 - r / 360)) * 360;
-					bone.shearY += r * shearMix;
+					shearY += r * shearMix;
 				}
 
 				bone.UpdateWorldTransform(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
@@ -266,8 +278,8 @@ namespace Spine {
 
 				float scaleX = bone.ascaleX, scaleY = bone.ascaleY;
 				if (scaleMix != 0) {
-					if (scaleX > 0.00001f) scaleX *= ((target.ascaleX - 1 + data.offsetScaleX) * scaleMix) + 1;
-					if (scaleY > 0.00001f) scaleY *= ((target.ascaleY - 1 + data.offsetScaleY) * scaleMix) + 1;
+					scaleX *= ((target.ascaleX - 1 + data.offsetScaleX) * scaleMix) + 1;
+					scaleY *= ((target.ascaleY - 1 + data.offsetScaleY) * scaleMix) + 1;
 				}
 
 				float shearY = bone.ashearY;
@@ -277,6 +289,22 @@ namespace Spine {
 			}
 		}
 
+		public int Order { get { return data.order; } }
+		/// <summary>The bones that will be modified by this transform constraint.</summary>
+		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>The transform constraint's setup pose data.</summary>
+		public TransformConstraintData Data { get { return data; } }
+
 		override public string ToString () {
 			return data.name;
 		}