[csharp] Minor: Fixed xml documentation tags (missing closing tags and multi-line code tags).

spine-csharp/src/Animation.cs

@@ -94,16 +94,16 @@ namespace Spine {
 		/// <param name="lastTime">The last time in seconds this animation was applied. Some timelines trigger only at specific times rather
 		///					than every frame. Pass -1 the first time an animation is applied to ensure frame 0 is triggered.</param>
 		/// <param name="time"> The time in seconds the skeleton is being posed for. Most timelines find the frame before and the frame after
-		///					this time and interpolate between the frame values. If beyond the <see cref="Duration"/> and <code>loop</code> is
+		///					this time and interpolate between the frame values. If beyond the <see cref="Duration"/> and <c>loop</c> is
 		///					true then the animation will repeat, else the last frame will be applied.</param>
 		/// <param name="loop">If true, the animation repeats after the <see cref="Duration"/>.</param>
 		/// <param name="events">If any events are fired, they are added to this list. Can be null to ignore fired events or if no timelines
 		///					fire events.</param>
-		/// <param name="alpha"> 0 applies the current or setup values (depending on <code>blend</code>). 1 applies the timeline values. Between
+		/// <param name="alpha"> 0 applies the current or setup values (depending on <c>blend</c>). 1 applies the timeline values. Between
 		///					0 and 1 applies values between the current or setup values and the timeline values. By adjusting
-		///					<code>alpha</code> over time, an animation can be mixed in or out. <code>alpha</code> can also be useful to apply
+		///					<c>alpha</c> over time, an animation can be mixed in or out. <c>alpha</c> can also be useful to apply
 		///					animations on top of each other (layering).</param>
-		/// <param name="blend">Controls how mixing is applied when <code>alpha</code> < 1.</param>
+		/// <param name="blend">Controls how mixing is applied when <c>alpha</c> &lt; 1.</param>
 		/// <param name="direction">Indicates whether the timelines are mixing in or out. Used by timelines which perform instant transitions,
 		///					such as <see cref="DrawOrderTimeline"/> or <see cref="AttachmentTimeline"/>.</param>
 		public void Apply (Skeleton skeleton, float lastTime, float time, bool loop, ExposedList<Event> events, float alpha,
@@ -127,7 +127,7 @@ namespace Spine {
 
 	/// <summary>
 	/// Controls how timeline values are mixed with setup pose values or current pose values when a timeline is applied with
-	/// <code>alpha</code> < 1.</summary>
+	/// <c>alpha</c> &lt; 1.</summary>
 	/// <seealso cref="Timeline.Apply(Skeleton, float, float, ExposedList, float, MixBlend, MixDirection)"/>
 	public enum MixBlend {
 		/// <summary> Transitions from the setup value to the timeline value (the current value is not used). Before the first frame, the
@@ -140,7 +140,7 @@ namespace Spine {
 		/// the setup value. Timelines which perform instant transitions, such as <see cref="DrawOrderTimeline"/> or
 		/// <see cref="AttachmentTimeline"/>, use the setup value before the first frame.</para>
 		/// <para>
-		/// <code>First</code> is intended for the first animations applied, not for animations layered on top of those.</para>
+		/// <c>First</c> is intended for the first animations applied, not for animations layered on top of those.</para>
 		/// </summary>
 		First,
 
@@ -149,7 +149,7 @@ namespace Spine {
 		/// Transitions from the current value to the timeline value. No change is made before the first frame (the current value is
 		/// kept until the first frame).</para>
 		/// <para>
-		/// <code>Replace</code> is intended for animations layered on top of others, not for the first animations applied.</para>
+		/// <c>Replace</c> is intended for animations layered on top of others, not for the first animations applied.</para>
 		/// </summary>
 		Replace,
 
@@ -158,7 +158,7 @@ namespace Spine {
 		/// Transitions from the current value to the current value plus the timeline value. No change is made before the first frame
 		/// (the current value is kept until the first frame).</para>
 		/// <para>
-		/// <code>Add</code> is intended for animations layered on top of others, not for the first animations applied. Properties
+		/// <c>Add</c> is intended for animations layered on top of others, not for the first animations applied. Properties
 		/// set by additive animations must be set manually or by another animation before applying the additive animations, else the
 		/// property values will increase each time the additive animations are applied.
 		/// </para>
@@ -167,7 +167,7 @@ namespace Spine {
 	}
 
 	/// <summary>
-	/// Indicates whether a timeline's <code>alpha</code> is mixing out over time toward 0 (the setup or current pose value) or
+	/// Indicates whether a timeline's <c>alpha</c> is mixing out over time toward 0 (the setup or current pose value) or
 	/// mixing in toward 1 (the timeline's value). Some timelines use this to decide how values are applied.</summary>
 	/// <seealso cref="Timeline.Apply(Skeleton, float, float, ExposedList, float, MixBlend, MixDirection)"/>
 	public enum MixDirection {
@@ -231,26 +231,26 @@ namespace Spine {
 		///					skeleton components the timeline may change.</param>
 		/// <param name="lastTime">The time this timeline was last applied. Timelines such as <see cref="EventTimeline"/> trigger only
 		///					at specific times rather than every frame. In that case, the timeline triggers everything between
-		///					<code>lastTime</code> (exclusive) and <code>time</code> (inclusive). Pass -1 the first time an animation is
+		///					<c>lastTime</c> (exclusive) and <c>time</c> (inclusive). Pass -1 the first time an animation is
 		///					 applied to ensure frame 0 is triggered.</param>
 		/// <param name="time">The time in seconds that the skeleton is being posed for. Most timelines find the frame before and the frame
 		///					after this time and interpolate between the frame values.If beyond the last frame, the last frame will be
 		///					applied.</param>
 		/// <param name="events">If any events are fired, they are added to this list. Can be null to ignore fired events or if the timeline
 		///					does not fire events.</param>
-		/// <param name="alpha">0 applies the current or setup value (depending on <code>blend</code>). 1 applies the timeline value.
+		/// <param name="alpha">0 applies the current or setup value (depending on <c>blend</c>). 1 applies the timeline value.
 		///					Between 0 and 1 applies a value between the current or setup value and the timeline value.By adjusting
-		///					<code>alpha</code> over time, an animation can be mixed in or out. <code>alpha</code> can also be useful to
+		///					<c>alpha</c> over time, an animation can be mixed in or out. <c>alpha</c> can also be useful to
 		///					apply animations on top of each other (layering).</param>
-		/// <param name="blend">Controls how mixing is applied when <code>alpha</code> < 1.</param>
+		/// <param name="blend">Controls how mixing is applied when <c>alpha</c> &lt; 1.</param>
 		/// <param name="direction">Indicates whether the timeline is mixing in or out. Used by timelines which perform instant transitions,
 		///                   such as <see cref="DrawOrderTimeline"/> or <see cref="AttachmentTimeline"/>, and other such as <see cref="ScaleTimeline"/>.</param>
 		public abstract void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> events, float alpha,
 			MixBlend blend, MixDirection direction);
 
 		/// <summary>Search using a stride of 1.</summary>
-		/// <param name="time">Must be >= the first value in <code>frames</code>.</param>
-		/// <returns>The index of the first value <= <code>time</code>.</returns>
+		/// <param name="time">Must be >= the first value in <c>frames</c>.</param>
+		/// <returns>The index of the first value <= <c>time</c>.</returns>
 		internal static int Search (float[] frames, float time) {
 			int n = frames.Length;
 			for (int i = 1; i < n; i++)
@@ -259,8 +259,8 @@ namespace Spine {
 		}
 
 		/// <summary>Search using the specified stride.</summary>
-		/// <param name="time">Must be >= the first value in <code>frames</code>.</param>
-		/// <returns>The index of the first value <= <code>time</code>.</returns>
+		/// <param name="time">Must be >= the first value in <c>frames</c>.</param>
+		/// <returns>The index of the first value <= <c>time</c>.</returns>
 		internal static int Search (float[] frames, float time, int step) {
 			int n = frames.Length;
 			for (int i = step; i < n; i += step)
@@ -297,25 +297,25 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the specified frame to linear interpolation.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount - 1</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount - 1</c>, inclusive.</param>
 		public void SetLinear (int frame) {
 			curves[frame] = LINEAR;
 		}
 
 		/// <summary>Sets the specified frame to stepped interpolation.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount - 1</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount - 1</c>, inclusive.</param>
 		public void SetStepped (int frame) {
 			curves[frame] = STEPPED;
 		}
 
 		/// <summary>Returns the interpolation type for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount - 1</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount - 1</c>, inclusive.</param>
 		/// <returns><see cref="LINEAR"/>, <see cref="STEPPED"/> or <see cref="BEZIER"/> + the index of the Bezier segments.</returns>
 		public float GetCurveType (int frame) {
 			return (int)curves[frame];
 		}
 
-		/// <summary>Shrinks the storage for Bezier curves, for use when <code>bezierCount</code> (specified in the constructor) was larger
+		/// <summary>Shrinks the storage for Bezier curves, for use when <c>bezierCount</c> (specified in the constructor) was larger
 		/// than the actual number of Bezier curves.</summary>
 		public void Shrink (int bezierCount) {
 			int size = FrameCount + bezierCount * BEZIER_SIZE;
@@ -329,9 +329,9 @@ namespace Spine {
 		/// <summary>
 		/// Stores the segments for the specified Bezier curve. For timelines that modify multiple values, there may be more than
 		/// one curve per frame.</summary>
-		/// <param name="bezier">The ordinal of this Bezier curve for this timeline, between 0 and <code>bezierCount - 1</code> (specified
+		/// <param name="bezier">The ordinal of this Bezier curve for this timeline, between 0 and <c>bezierCount - 1</c> (specified
 		///					in the constructor), inclusive.</param>
-		/// <param name="frame">Between 0 and <code>frameCount - 1</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount - 1</c>, inclusive.</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>
@@ -366,8 +366,8 @@ namespace Spine {
 
 		/// <summary>
 		/// Returns the Bezier interpolated value for the specified time.</summary>
-		/// <param name="frameIndex">The index into <see cref="Frames"/> for the values of the frame before <code>time</code>.</param>
-		/// <param name="valueOffset">The offset from <code>frameIndex</code> to the value this curve is used for.</param>
+		/// <param name="frameIndex">The index into <see cref="Frames"/> for the values of the frame before <c>time</c>.</param>
+		/// <param name="valueOffset">The offset from <c>frameIndex</c> to the value this curve is used for.</param>
 		/// <param name="i">The index of the Bezier segments. See <see cref="GetCurveType(int)"/>.</param>
 		public float GetBezierValue (float time, int frameIndex, int valueOffset, int i) {
 			float[] curves = this.curves;
@@ -406,7 +406,7 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the time and value for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds</param>
 		public void SetFrame (int frame, float time, float value) {
 			frame <<= 1;
@@ -544,7 +544,7 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the time and values for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
 		public void SetFrame (int frame, float time, float value1, float value2) {
 			frame *= ENTRIES;
@@ -700,7 +700,7 @@ namespace Spine {
 		}
 	}
 
-	/// <summary>Changes a bone's local <see cref="Bone.ScaleX"> and <see cref="Bone.ScaleY">.</summary>
+	/// <summary>Changes a bone's local <see cref="Bone.ScaleX"/> and <see cref="Bone.ScaleY"/>.</summary>
 	public class ScaleTimeline : CurveTimeline2, IBoneTimeline {
 		readonly int boneIndex;
 
@@ -816,7 +816,7 @@ namespace Spine {
 		}
 	}
 
-	/// <summary>Changes a bone's local <see cref="Bone.ScaleX">.</summary>
+	/// <summary>Changes a bone's local <see cref="Bone.ScaleX"/>.</summary>
 	public class ScaleXTimeline : CurveTimeline1, IBoneTimeline {
 		readonly int boneIndex;
 
@@ -838,7 +838,7 @@ namespace Spine {
 		}
 	}
 
-	/// <summary>Changes a bone's local <see cref="Bone.ScaleY">.</summary>
+	/// <summary>Changes a bone's local <see cref="Bone.ScaleY"/>.</summary>
 	public class ScaleYTimeline : CurveTimeline1, IBoneTimeline {
 		readonly int boneIndex;
 
@@ -1004,7 +1004,7 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the transform mode for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
 		public void SetFrame (int frame, float time, Inherit inherit) {
 			frame *= ENTRIES;
@@ -1056,7 +1056,7 @@ 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="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
 		public void SetFrame (int frame, float time, float r, float g, float b, float a) {
 			frame *= ENTRIES;
@@ -1173,7 +1173,7 @@ 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="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
 		public void SetFrame (int frame, float time, float r, float g, float b) {
 			frame <<= 2;
@@ -1333,7 +1333,7 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the time, light color, and dark color for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
 		public void SetFrame (int frame, float time, float r, float g, float b, float a, float r2, float g2, float b2) {
 			frame <<= 3;
@@ -1493,7 +1493,7 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the time, light color, and dark color for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
 		public void SetFrame (int frame, float time, float r, float g, float b, float r2, float g2, float b2) {
 			frame *= ENTRIES;
@@ -1638,7 +1638,7 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the time and attachment name for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
 		public void SetFrame (int frame, float time, String attachmentName) {
 			frames[frame] = time;
@@ -1703,7 +1703,7 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the time and vertices for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
 		/// <param name="vertices">Vertex positions for an unweighted VertexAttachment, or deform offsets if it has weights.</param>
 		public void SetFrame (int frame, float time, float[] vertices) {
@@ -1736,7 +1736,7 @@ namespace Spine {
 		}
 
 		/// <summary>Returns the interpolated percentage for the specified time.</summary>
-		/// <param name="frame">The frame before <code>time</code>.</param>
+		/// <param name="frame">The frame before <c>time</c>.</param>
 		private float GetCurvePercent (float time, int frame) {
 			float[] curves = this.curves;
 			int i = (int)curves[frame];
@@ -1972,13 +1972,13 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the time and event for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		public void SetFrame (int frame, Event e) {
 			frames[frame] = e.time;
 			events[frame] = e;
 		}
 
-		/// <summary>Fires events for frames &gt; <code>lastTime</code> and &lt;= <code>time</code>.</summary>
+		/// <summary>Fires events for frames &gt; <c>lastTime</c> and &lt;= <c>time</c>.</summary>
 		public override void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha,
 			MixBlend blend, MixDirection direction) {
 
@@ -2030,7 +2030,7 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the time and draw order for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
 		/// <param name="drawOrder">For each slot in <see cref="Skeleton.Slots"/>, the index of the slot in the new draw order. May be null to use
 		///					 setup pose draw order.</param>
@@ -2093,7 +2093,7 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the time, mix, softness, bend direction, compress, and stretch for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
 		/// <param name="bendDirection">1 or -1.</param>
 		public void SetFrame (int frame, float time, float mix, float softness, int bendDirection, bool compress,
@@ -2205,7 +2205,7 @@ 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="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">The frame time in seconds.</param>
 		public void SetFrame (int frame, float time, float mixRotate, float mixX, float mixY, float mixScaleX, float mixScaleY,
 			float mixShearY) {
@@ -2388,7 +2388,7 @@ 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="frame">Between 0 and <c>frameCount</c>, 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;
@@ -2689,13 +2689,13 @@ namespace Spine {
 			get { return frames.Length; }
 		}
 
-		/// <summary>Sets the time for the specified frame.<summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <summary>Sets the time for the specified frame.</summary>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		public void SetFrame (int frame, float time) {
 			frames[frame] = time;
 		}
 
-		/// <summary>Resets the physics constraint when frames > <code>lastTime</code> and <= <code>time</code>.</summary>
+		/// <summary>Resets the physics constraint when frames > <c>lastTime</c> and <= <c>time</c>.</summary>
 		override public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha, MixBlend blend,
 									MixDirection direction) {
 
@@ -2759,7 +2759,7 @@ namespace Spine {
 		}
 
 		/// <summary>Sets the time, mode, index, and frame time for the specified frame.</summary>
-		/// <param name="frame">Between 0 and <code>frameCount</code>, inclusive.</param>
+		/// <param name="frame">Between 0 and <c>frameCount</c>, inclusive.</param>
 		/// <param name="time">Seconds between frames.</param>
 		public void SetFrame (int frame, float time, SequenceMode mode, int index, float delay) {
 			frame *= ENTRIES;

spine-csharp/src/AnimationState.cs

@@ -49,9 +49,9 @@ namespace Spine {
 		/// 2) The next track entry applied after this one does not have a timeline to set this property.<para />
 		/// Result: Mix from the setup pose to the timeline pose.
 		internal const int First = 1;
-		/// 1) A previously applied timeline has set this property.<br>
-		/// 2) The next track entry to be applied does have a timeline to set this property.<br>
-		/// 3) The next track entry after that one does not have a timeline to set this property.<br>
+		/// 1) A previously applied timeline has set this property.<para />
+		/// 2) The next track entry to be applied does have a timeline to set this property.<para />
+		/// 3) The next track entry after that one does not have a timeline to set this property.<para />
 		/// Result: Mix from the current pose to the timeline pose, but do not mix out. This avoids "dipping" when crossfading
 		/// animations that key the same property. A subsequent timeline will set this property using a mix.
 		internal const int HoldSubsequent = 2;
@@ -485,7 +485,7 @@ namespace Spine {
 		}
 
 		/// <summary> Applies the attachment timeline and sets <see cref="Slot.attachmentState"/>.</summary>
-		/// <param name="attachments">False when: 1) the attachment timeline is mixing out, 2) mix < attachmentThreshold, and 3) the timeline
+		/// <param name="attachments">False when: 1) the attachment timeline is mixing out, 2) mix &lt; attachmentThreshold, and 3) the timeline
 		/// is not the last timeline to set the slot's attachment. In that case the timeline is applied only so subsequent
 		/// timelines see any deform.</param>
 		private void ApplyAttachmentTimeline (AttachmentTimeline timeline, Skeleton skeleton, float time, MixBlend blend,
@@ -730,8 +730,8 @@ namespace Spine {
 		/// equivalent to calling <see cref="SetAnimation(int, Animation, bool)"/>.</summary>
 		/// <param name="delay">
 		/// If &gt; 0, sets <see cref="TrackEntry.Delay"/>. If &lt;= 0, the delay set is the duration of the previous track entry
-		/// minus any mix duration (from the <see cref="AnimationStateData"/> plus the specified <code>Delay</code> (ie the mix
-		/// ends at (<code>Delay</code> = 0) or before (<code>Delay</code> &lt; 0) the previous track entry duration). If the
+		/// minus any mix duration (from the <see cref="AnimationStateData"/> plus the specified <c>Delay</c> (ie the mix
+		/// ends at (<c>Delay</c> = 0) or before (<c>Delay</c> &lt; 0) the previous track entry duration). If the
 		/// previous entry is looping, its next loop completion is used instead of its duration.
 		/// </param>
 		/// <returns>A track entry to allow further customization of animation playback. References to the track entry must not be kept
@@ -791,8 +791,8 @@ namespace Spine {
 		/// <param name="trackIndex">Track number.</param>
 		/// <param name="mixDuration">Mix duration.</param>
 		/// <param name="delay">If &gt; 0, sets <see cref="TrackEntry.Delay"/>. If &lt;= 0, the delay set is the duration of the previous track entry
-		/// minus any mix duration plus the specified <code>Delay</code> (ie the mix ends at (<code>Delay</code> = 0) or
-		/// before (<code>Delay</code> &lt; 0) the previous track entry duration). If the previous entry is looping, its next
+		/// minus any mix duration plus the specified <c>Delay</c> (ie the mix ends at (<c>Delay</c> = 0) or
+		/// before (<c>Delay</c> &lt; 0) the previous track entry duration). If the previous entry is looping, its next
 		/// loop completion is used instead of its duration.</param>
 		/// <returns> A track entry to allow further customization of animation playback. References to the track entry must not be kept
 		/// after the <see cref="AnimationState.Dispose"/> event occurs.
@@ -939,6 +939,7 @@ namespace Spine {
 		/// <summary> Discards all listener notifications that have not yet been delivered. This can be useful to call from an
 		/// AnimationState event subscriber when it is known that further notifications that may have been already queued for delivery
 		/// are not wanted because new animations are being set.
+		/// </summary>
 		public void ClearListenerNotifications () {
 			queue.Clear();
 		}
@@ -1048,16 +1049,16 @@ namespace Spine {
 
 		/// <summary>
 		/// <para>
-		/// Seconds to postpone playing the animation. When this track entry is the current track entry, <code>Delay</code>
-		/// postpones incrementing the <see cref="TrackEntry.TrackTime"/>. When this track entry is queued, <code>Delay</code> is the time from
+		/// Seconds to postpone playing the animation. When this track entry is the current track entry, <c>Delay</c>
+		/// postpones incrementing the <see cref="TrackEntry.TrackTime"/>. When this track entry is queued, <c>Delay</c> is the time from
 		/// the start of the previous animation to when this track entry will become the current track entry (ie when the previous
-		/// track entry <see cref="TrackEntry.TrackTime"/> &gt;= this track entry's <code>Delay</code>).</para>
+		/// track entry <see cref="TrackEntry.TrackTime"/> &gt;= this track entry's <c>Delay</c>).</para>
 		/// <para>
 		/// <see cref="TrackEntry.TimeScale"/> affects the delay.</para>
 		/// <para>
-		/// When using <see cref="AnimationState.AddAnimation(int, Animation, bool, float)"/> with a <code>delay</code> <= 0, the delay
+		/// When using <see cref="AnimationState.AddAnimation(int, Animation, bool, float)"/> with a <c>delay</c> &lt;= 0, the delay
 		/// is set using the mix duration from the <see cref="AnimationStateData"/>. If <see cref="mixDuration"/> is set afterward, the delay
-		/// may need to be adjusted.</summary>
+		/// may need to be adjusted.</para></summary>
 		public float Delay { get { return delay; } set { delay = value; } }
 
 		/// <summary>
@@ -1097,7 +1098,7 @@ namespace Spine {
 		/// <para>
 		/// Seconds when this animation starts, both initially and after looping. Defaults to 0.</para>
 		/// <para>
-		/// When changing the <code>AnimationStart</code> time, it often makes sense to set <see cref="TrackEntry.AnimationLast"> to the same
+		/// When changing the <c>AnimationStart</c> time, it often makes sense to set <see cref="TrackEntry.AnimationLast"/> to the same
 		/// value to prevent timeline keys before the start time from triggering.</para>
 		/// </summary>
 		public float AnimationStart { get { return animationStart; } set { animationStart = value; } }
@@ -1110,8 +1111,8 @@ namespace Spine {
 
 		/// <summary>
 		/// The time in seconds this animation was last applied. Some timelines use this for one-time triggers. Eg, when this
-		/// animation is applied, event timelines will fire all events between the <code>AnimationLast</code> time (exclusive) and
-		/// <code>AnimationTime</code> (inclusive). Defaults to -1 to ensure triggers on frame 0 happen the first time this animation
+		/// animation is applied, event timelines will fire all events between the <c>AnimationLast</c> time (exclusive) and
+		/// <c>AnimationTime</c> (inclusive). Defaults to -1 to ensure triggers on frame 0 happen the first time this animation
 		/// is applied.</summary>
 		public float AnimationLast {
 			get { return animationLast; }
@@ -1122,12 +1123,12 @@ namespace Spine {
 		}
 
 		/// <summary>
-		/// Uses <see cref="TrackEntry.TrackTime"/> to compute the <code>AnimationTime</code>. When the <code>TrackTime</code> is 0, the
-		/// <code>AnimationTime</code> is equal to the <code>AnimationStart</code> time.
+		/// Uses <see cref="TrackEntry.TrackTime"/> to compute the <c>AnimationTime</c>. When the <c>TrackTime</c> is 0, the
+		/// <c>AnimationTime</c> is equal to the <c>AnimationStart</c> time.
 		/// <para>
-		/// The <code>animationTime</code> is between <see cref="AnimationStart"/> and <see cref="AnimationEnd"/>, except if this
+		/// The <c>animationTime</c> is between <see cref="AnimationStart"/> and <see cref="AnimationEnd"/>, except if this
 		/// track entry is non-looping and <see cref="AnimationEnd"/> is >= to the animation <see cref="Animation.Duration"/>, then
-		/// <code>animationTime</code> continues to increase past <see cref="AnimationEnd"/>.</para>
+		/// <c>animationTime</c> continues to increase past <see cref="AnimationEnd"/>.</para>
 		/// </summary>
 		public float AnimationTime {
 			get {
@@ -1146,12 +1147,12 @@ namespace Spine {
 		/// Multiplier for the delta time when this track entry is updated, causing time for this animation to pass slower or
 		/// faster. Defaults to 1.</para>
 		/// <para>
-		/// Values < 0 are not supported. To play an animation in reverse, use <see cref="Reverse"/>.
+		/// Values &lt; 0 are not supported. To play an animation in reverse, use <see cref="Reverse"/>.</para>
 		/// <para>
 		/// <see cref="TrackEntry.MixTime"/> is not affected by track entry time scale, so <see cref="TrackEntry.MixDuration"/> may need to be adjusted to
 		/// match the animation speed.</para>
 		/// <para>
-		/// When using <see cref="AnimationState.AddAnimation(int, Animation, bool, float)"> with a <code>Delay</code> <= 0, the
+		/// When using <see cref="AnimationState.AddAnimation(int, Animation, bool, float)"/> with a <c>Delay</c> &lt;= 0, the
 		/// <see cref="TrackEntry.Delay"/> is set using the mix duration from the <see cref="AnimationStateData"/>, assuming time scale to be 1. If
 		/// the time scale is not 1, the delay may need to be adjusted.</para>
 		/// <para>
@@ -1161,7 +1162,7 @@ namespace Spine {
 
 		/// <summary>
 		/// <para>
-		/// Values < 1 mix this animation with the skeleton's current pose (usually the pose resulting from lower tracks). Defaults
+		/// Values &lt; 1 mix this animation with the skeleton's current pose (usually the pose resulting from lower tracks). Defaults
 		/// to 1, which overwrites the skeleton's current pose with this animation.</para>
 		/// <para>
 		/// Typically track 0 is used to completely pose the skeleton, then alpha is used on higher tracks. It doesn't make sense to
@@ -1173,39 +1174,40 @@ namespace Spine {
 
 		/// <summary>
 		/// When the mix percentage (<see cref="TrackEntry.MixTime"/> / <see cref="TrackEntry.MixDuration"/>) is less than the
-		/// <code>EventThreshold</code>, event timelines are applied while this animation is being mixed out. Defaults to 0, so event
+		/// <c>EventThreshold</c>, event timelines are applied while this animation is being mixed out. Defaults to 0, so event
 		/// timelines are not applied while this animation is being mixed out.
 		/// </summary>
 		public float EventThreshold { get { return eventThreshold; } set { eventThreshold = value; } }
 
-		/// When <see cref="Alpha"/> is greater than <code>AlphaAttachmentThreshold</code>, attachment timelines are applied.
+		/// <summary>
+		/// When <see cref="Alpha"/> is greater than <c>AlphaAttachmentThreshold</c>, attachment timelines are applied.
 		/// Defaults to 0, so attachment timelines are always applied.
 		/// </summary>
 		public float AlphaAttachmentThreshold { get { return alphaAttachmentThreshold; } set { alphaAttachmentThreshold = value; } }
 
 		/// <summary>
 		/// When the mix percentage (<see cref="TrackEntry.MixTime"/> / <see cref="TrackEntry.MixDuration"/>) is less than the
-		/// <code>MixAttachmentThreshold</code>, attachment timelines are applied while this animation is being mixed out. Defaults
+		/// <c>MixAttachmentThreshold</c>, attachment timelines are applied while this animation is being mixed out. Defaults
 		/// to 0, so attachment timelines are not applied while this animation is being mixed out.
 		/// </summary>
 		public float MixAttachmentThreshold { get { return mixAttachmentThreshold; } set { mixAttachmentThreshold = value; } }
 
 		/// <summary>
 		/// When the mix percentage (<see cref="TrackEntry.MixTime"/> / <see cref="TrackEntry.MixDuration"/>) is less than the
-		/// <code>MixDrawOrderThreshold</code>, draw order timelines are applied while this animation is being mixed out. Defaults to
+		/// <c>MixDrawOrderThreshold</c>, draw order timelines are applied while this animation is being mixed out. Defaults to
 		/// 0, so draw order timelines are not applied while this animation is being mixed out.
 		/// </summary>
 		public float MixDrawOrderThreshold { get { return mixDrawOrderThreshold; } set { mixDrawOrderThreshold = value; } }
 
 		/// <summary>
-		/// The animation queued to start after this animation, or null if there is none. <code>next</code> makes up a doubly linked
+		/// The animation queued to start after this animation, or null if there is none. <c>next</c> makes up a doubly linked
 		/// list.
 		/// <para>
 		/// See <see cref="AnimationState.ClearNext(TrackEntry)"/> to truncate the list.</para></summary>
 		public TrackEntry Next { get { return next; } }
 
 		/// <summary>
-		/// The animation queued to play before this animation, or null. <code>previous</code> makes up a doubly linked list.</summary>
+		/// The animation queued to play before this animation, or null. <c>previous</c> makes up a doubly linked list.</summary>
 		public TrackEntry Previous { get { return previous; } }
 
 		/// <summary>Returns true if this track entry has been applied at least once.</summary>
@@ -1231,7 +1233,7 @@ namespace Spine {
 
 		/// <summary>
 		/// Seconds from 0 to the <see cref="TrackEntry.MixDuration"/> when mixing from the previous animation to this animation. May be
-		/// slightly more than <code>MixDuration</code> when the mix is complete.</summary>
+		/// slightly more than <c>MixDuration</c> when the mix is complete.</summary>
 		public float MixTime { get { return mixTime; } set { mixTime = value; } }
 
 		/// <summary>
@@ -1239,23 +1241,23 @@ namespace Spine {
 		/// Seconds for mixing from the previous animation to this animation. Defaults to the value provided by AnimationStateData
 		/// <see cref="AnimationStateData.GetMix(Animation, Animation)"/> based on the animation before this animation (if any).</para>
 		/// <para>
-		/// The <code>MixDuration</code> can be set manually rather than use the value from
-		/// <see cref="AnimationStateData.GetMix(Animation, Animation)"/>. In that case, the <code>MixDuration</code> can be set for a new
+		/// The <c>MixDuration</c> can be set manually rather than use the value from
+		/// <see cref="AnimationStateData.GetMix(Animation, Animation)"/>. In that case, the <c>MixDuration</c> can be set for a new
 		/// track entry only before <see cref="AnimationState.Update(float)"/> is first called.</para>
 		/// <para>
-		/// When using <seealso cref="AnimationState.AddAnimation(int, Animation, bool, float)"/> with a <code>Delay</code> &lt;= 0, the
-		/// <see cref="TrackEntry.Delay"/> is set using the mix duration from the <see cref=" AnimationStateData"/>. If <code>mixDuration</code> is set
+		/// When using <seealso cref="AnimationState.AddAnimation(int, Animation, bool, float)"/> with a <c>Delay</c> &lt;= 0, the
+		/// <see cref="TrackEntry.Delay"/> is set using the mix duration from the <see cref=" AnimationStateData"/>. If <c>mixDuration</c> is set
 		/// afterward, the delay may need to be adjusted. For example:</para>
-		/// <para><code>entry.Delay = entry.previous.TrackComplete - entry.MixDuration;</code></para>
+		/// <para><c>entry.Delay = entry.previous.TrackComplete - entry.MixDuration;</c></para>
 		/// <para>Alternatively, <see cref="SetMixDuration(float, float)"/> can be used to recompute the delay:</para>
-		/// <para><code>entry.SetMixDuration(0.25f, 0);</code></para>
+		/// <para><c>entry.SetMixDuration(0.25f, 0);</c></para>
 		/// </summary>
 		public float MixDuration { get { return mixDuration; } set { mixDuration = value; } }
 
 		/// <summary>Sets both <see cref="MixDuration"/> and <see cref="Delay"/>.</summary>
-		/// <param name="delay">If > 0, sets <see cref="TrackEntry.Delay"/>. If <= 0, the delay set is the duration of the previous track
-		///		entry minus the specified mix duration plus the specified<code> delay</code> (ie the mix ends at
-		///		(<code>delay</code> = 0) or before (<code>delay</code> < 0) the previous track entry duration). If the previous
+		/// <param name="delay">If > 0, sets <see cref="TrackEntry.Delay"/>. If &lt;= 0, the delay set is the duration of the previous track
+		///		entry minus the specified mix duration plus the specified<c> delay</c> (ie the mix ends at
+		///		(<c>delay</c> = 0) or before (<c>delay</c> &lt; 0) the previous track entry duration). If the previous
 		///		entry is looping, its next loop completion is used instead of its duration.</param>
 		public void SetMixDuration (float mixDuration, float delay) {
 			this.mixDuration = mixDuration;
@@ -1269,19 +1271,19 @@ namespace Spine {
 		/// </para><para>
 		/// Track entries on track 0 ignore this setting and always use <see cref="MixBlend.First"/>.
 		/// </para><para>
-		///  The <code>MixBlend</code> can be set for a new track entry only before <see cref="AnimationState.Apply(Skeleton)"/> is first
+		///  The <c>MixBlend</c> can be set for a new track entry only before <see cref="AnimationState.Apply(Skeleton)"/> is first
 		///  called.</para>
 		/// </summary>
 		public MixBlend MixBlend { get { return mixBlend; } set { mixBlend = value; } }
 
 		/// <summary>
 		/// The track entry for the previous animation when mixing from the previous animation to this animation, or null if no
-		/// mixing is currently occurring. When mixing from multiple animations, <code>MixingFrom</code> makes up a linked list.</summary>
+		/// mixing is currently occurring. When mixing from multiple animations, <c>MixingFrom</c> makes up a linked list.</summary>
 		public TrackEntry MixingFrom { get { return mixingFrom; } }
 
 		/// <summary>
 		/// The track entry for the next animation when mixing from this animation to the next animation, or null if no mixing is
-		/// currently occurring. When mixing to multiple animations, <code>MixingTo</code> makes up a linked list.</summary>
+		/// currently occurring. When mixing to multiple animations, <c>MixingTo</c> makes up a linked list.</summary>
 		public TrackEntry MixingTo { get { return mixingTo; } }
 
 		/// <summary>
@@ -1291,11 +1293,11 @@ namespace Spine {
 		/// <para>
 		/// When mixing between animations that key the same property, if a lower track also keys that property then the value will
 		/// briefly dip toward the lower track value during the mix. This happens because the first animation mixes from 100% to 0%
-		/// while the second animation mixes from 0% to 100%. Setting <code>HoldPrevious</code> to true applies the first animation
+		/// while the second animation mixes from 0% to 100%. Setting <c>HoldPrevious</c> to true applies the first animation
 		/// at 100% during the mix so the lower track value is overwritten. Such dipping does not occur on the lowest track which
 		/// keys the property, only when a higher track also keys the property.</para>
 		/// <para>
-		/// Snapping will occur if <code>HoldPrevious</code> is true and this animation does not key all the same properties as the
+		/// Snapping will occur if <c>HoldPrevious</c> is true and this animation does not key all the same properties as the
 		/// previous animation.</para>
 		/// </summary>
 		public bool HoldPrevious { get { return holdPrevious; } set { holdPrevious = value; } }
@@ -1314,6 +1316,7 @@ namespace Spine {
 
 		/// <summary>Returns true if this entry is for the empty animation. See <see cref="AnimationState.SetEmptyAnimation(int, float)"/>,
 		/// <see cref="AnimationState.AddEmptyAnimation(int, float, float)"/>, and <see cref="AnimationState.SetEmptyAnimations(float)"/>.
+		/// </summary>
 		public bool IsEmptyAnimation { get { return animation == AnimationState.EmptyAnimation; } }
 
 		/// <summary>

spine-csharp/src/Attachments/RegionAttachment.cs

@@ -59,7 +59,7 @@ namespace Spine {
 		public string Path { get; set; }
 		public TextureRegion Region { get { return region; } set { region = value; } }
 
-		/// <summary>For each of the 4 vertices, a pair of <code>x,y</code> values that is the local position of the vertex.</summary>
+		/// <summary>For each of the 4 vertices, a pair of <c>x,y</c> values that is the local position of the vertex.</summary>
 		/// <seealso cref="UpdateRegion"/>
 		public float[] Offset { get { return offset; } }
 		public float[] UVs { get { return uvs; } }

spine-csharp/src/Skeleton.cs

@@ -68,7 +68,7 @@ namespace Spine {
 		/// <summary>The skeleton's transform constraints.</summary>
 		public ExposedList<TransformConstraint> TransformConstraints { get { return transformConstraints; } }
 
-		/// <summary>The skeleton's current skin.</summary>
+		/// <summary>The skeleton's current skin. May be null. See <see cref="SetSkin(Spine.Skin)"/></summary>
 		public Skin Skin {
 			/// <summary>The skeleton's current skin. May be null.</summary>
 			get { return skin; }
@@ -561,7 +561,7 @@ namespace Spine {
 			return null;
 		}
 
-		/// <summary>Sets a skin by name (see <see cref="SetSkin(Skin)"/>).</summary>
+		/// <summary>Sets a skin by name (see <see cref="SetSkin(Spine.Skin)"/>).</summary>
 		public void SetSkin (string skinName) {
 			Skin foundSkin = data.FindSkin(skinName);
 			if (foundSkin == null) throw new ArgumentException("Skin not found: " + skinName, "skinName");

spine-csharp/src/Skin.cs

@@ -108,7 +108,7 @@ namespace Spine {
 		}
 
 		/// <summary>Returns all attachments in this skin for the specified slot index.</summary>
-		/// <param name="slotIndex">The target slotIndex. To find the slot index, use <see cref="Spine.SkeletonData.FindSlot"/> and <see cref="Spine.SlotData.Index"/>.
+		/// <param name="slotIndex">The target slotIndex. To find the slot index, use <see cref="Spine.SkeletonData.FindSlot"/> and <see cref="Spine.SlotData.Index"/></param>.
 		public void GetAttachments (int slotIndex, List<SkinEntry> attachments) {
 			if (slotIndex < 0) throw new ArgumentException("slotIndex must be >= 0.");
 			if (attachments == null) throw new ArgumentNullException("attachments", "attachments cannot be null.");

spine-csharp/src/Slot.cs

@@ -131,6 +131,11 @@ namespace Spine {
 			b2 = MathUtils.Clamp(b2, 0, 1);
 		}
 
+		/// <summary>
+		/// The current attachment for the slot, or null if the slot has no attachment.
+		/// If the attachment is changed, resets <see cref="SequenceIndex"/> and clears the <see cref="Deform"/>.
+		/// The deform is not cleared if the old attachment has the same <see cref="VertexAttachment.TimelineAttachment"/> as the
+		/// specified attachment.</summary>
 		public Attachment Attachment {
 			/// <summary>The current attachment for the slot, or null if the slot has no attachment.</summary>
 			get { return attachment; }

spine-csharp/src/package.json

@@ -2,7 +2,7 @@
 	"name": "com.esotericsoftware.spine.spine-csharp",
 	"displayName": "spine-csharp Runtime",
 	"description": "This plugin provides the spine-csharp core runtime.",
-	"version": "4.2.30",
+	"version": "4.2.31",
 	"unity": "2018.3",
 	"author": {
 		"name": "Esoteric Software",