UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2025-12-22 18:26:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Harald Csaszar 2024-09-13 11:14:56 +02:00
parent c3feed0535
commit 22cc555b0d
7 changed files with 105 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
spine-csharp/src/Animation.cs
View File

@ -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;

91
spine-csharp/src/AnimationState.cs
View File

@ -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>

2
spine-csharp/src/Attachments/RegionAttachment.cs
View File

@ -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; } }

4
spine-csharp/src/Skeleton.cs
View File

@ -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");

2
spine-csharp/src/Skin.cs
View File

@ -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.");

5
spine-csharp/src/Slot.cs
View File

@ -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; }

2
spine-csharp/src/package.json
View File

@ -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",