mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2026-03-26 22:49:01 +08:00
[libgdx] Javadocs: prefer linking to property for brevity.
This commit is contained in:
Nathan Sweet
parent
ca5ff77a8f
commit
bf6ba6f858
@ -93,7 +93,7 @@ public class Animation {
|
||||
|
||||
/** Returns true if this animation contains a timeline with any of the specified property IDs.
|
||||
* <p>
|
||||
* See {@link Timeline#getPropertyIds()}. */
|
||||
* See {@link Timeline#propertyIds}. */
|
||||
public boolean hasTimeline (String[] propertyIds) {
|
||||
for (String id : propertyIds)
|
||||
if (timelineIds.contains(id)) return true;
|
||||
@ -110,7 +110,7 @@ public class Animation {
|
||||
this.duration = duration;
|
||||
}
|
||||
|
||||
/** {@link Skeleton#getBones()} indices that this animation's timelines modify.
|
||||
/** {@link Skeleton#bones} indices that this animation's timelines modify.
|
||||
* <p>
|
||||
* See {@link BoneTimeline#getBoneIndex()}. */
|
||||
public IntArray getBones () {
|
||||
@ -129,7 +129,7 @@ public class Animation {
|
||||
* the first time an animation is applied to ensure frame 0 is triggered.
|
||||
* @param time The time in seconds the skeleton is being posed for. Timelines find the frame before and after this time and
|
||||
* interpolate between the frame values.
|
||||
* @param loop True if <code>time</code> beyond the {@link #getDuration()} repeats the animation, else the last frame is used.
|
||||
* @param loop True if <code>time</code> beyond the {@link #duration} repeats the animation, else the last frame is used.
|
||||
* @param events If any events are fired, they are added to this list. Pass null to ignore fired events or if no timelines fire
|
||||
* events.
|
||||
* @param alpha 0 applies setup or current values (depending on <code>fromSetup</code>), 1 uses timeline values, and
|
||||
@ -141,7 +141,7 @@ public class Animation {
|
||||
* @param add If true, for timelines that support it, their values are added to the setup or current values (depending on
|
||||
* <code>fromSetup</code>).
|
||||
* @param out True when the animation is mixing out, else it is mixing in. Used by timelines that perform instant transitions.
|
||||
* @param appliedPose True to modify {@link Posed#getAppliedPose()}, else {@link Posed#getPose()} is modified. */
|
||||
* @param appliedPose True to modify {@link Posed#getAppliedPose()}, else {@link Posed#pose} is modified. */
|
||||
public void apply (Skeleton skeleton, float lastTime, float time, boolean loop, @Null Array<Event> events, float alpha,
|
||||
boolean fromSetup, boolean add, boolean out, boolean appliedPose) {
|
||||
if (skeleton == null) throw new IllegalArgumentException("skeleton cannot be null.");
|
||||
@ -254,7 +254,7 @@ public class Animation {
|
||||
* <code>fromSetup</code>).
|
||||
* @param out True when the animation is mixing out, else it is mixing in. Used by timelines that perform instant
|
||||
* transitions.
|
||||
* @param appliedPose True to modify {@link Posed#getAppliedPose()}, else {@link Posed#getPose()} is modified. */
|
||||
* @param appliedPose True to modify {@link Posed#getAppliedPose()}, else {@link Posed#pose} is modified. */
|
||||
abstract public void apply (Skeleton skeleton, float lastTime, float time, @Null Array<Event> events, float alpha,
|
||||
boolean fromSetup, boolean add, boolean out, boolean appliedPose);
|
||||
|
||||
@ -281,7 +281,7 @@ public class Animation {
|
||||
|
||||
/** An interface for timelines that change a slot's properties. */
|
||||
static public interface SlotTimeline {
|
||||
/** The index of the slot in {@link Skeleton#getSlots()} that will be changed when this timeline is applied. */
|
||||
/** The index of the slot in {@link Skeleton#slots} that will be changed when this timeline is applied. */
|
||||
public int getSlotIndex ();
|
||||
}
|
||||
|
||||
@ -368,7 +368,7 @@ public class Animation {
|
||||
}
|
||||
|
||||
/** Returns the Bezier interpolated value for the specified time.
|
||||
* @param frameIndex The index into {@link #getFrames()} for the values of the frame before <code>time</code>.
|
||||
* @param frameIndex The index into {@link #frames} for the values of the frame before <code>time</code>.
|
||||
* @param valueOffset The offset from <code>frameIndex</code> to the value this curve is used for.
|
||||
* @param i The index of the Bezier segments. See {@link #getCurveType(int)}. */
|
||||
public float getBezierValue (float time, int frameIndex, int valueOffset, int i) {
|
||||
@ -493,7 +493,7 @@ public class Animation {
|
||||
|
||||
/** An interface for timelines that change a bone's properties. */
|
||||
static public interface BoneTimeline {
|
||||
/** The index of the bone in {@link Skeleton#getBones()} that is changed by this timeline. */
|
||||
/** The index of the bone in {@link Skeleton#bones} that is changed by this timeline. */
|
||||
public int getBoneIndex ();
|
||||
}
|
||||
|
||||
@ -563,7 +563,7 @@ public class Animation {
|
||||
boolean out);
|
||||
}
|
||||
|
||||
/** Changes {@link BonePose#getRotation()}. */
|
||||
/** Changes {@link BonePose#rotation}. */
|
||||
static public class RotateTimeline extends BoneTimeline1 {
|
||||
public RotateTimeline (int frameCount, int bezierCount, int boneIndex) {
|
||||
super(frameCount, bezierCount, boneIndex, Property.rotate);
|
||||
@ -574,7 +574,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link BonePose#getX()} and {@link BonePose#getY()}. */
|
||||
/** Changes {@link BonePose#x} and {@link BonePose#y}. */
|
||||
static public class TranslateTimeline extends BoneTimeline2 {
|
||||
public TranslateTimeline (int frameCount, int bezierCount, int boneIndex) {
|
||||
super(frameCount, bezierCount, boneIndex, Property.x, Property.y);
|
||||
@ -624,7 +624,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link BonePose#getX()}. */
|
||||
/** Changes {@link BonePose#x}. */
|
||||
static public class TranslateXTimeline extends BoneTimeline1 {
|
||||
public TranslateXTimeline (int frameCount, int bezierCount, int boneIndex) {
|
||||
super(frameCount, bezierCount, boneIndex, Property.x);
|
||||
@ -635,7 +635,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link BonePose#getY()}. */
|
||||
/** Changes {@link BonePose#y}. */
|
||||
static public class TranslateYTimeline extends BoneTimeline1 {
|
||||
public TranslateYTimeline (int frameCount, int bezierCount, int boneIndex) {
|
||||
super(frameCount, bezierCount, boneIndex, Property.y);
|
||||
@ -646,7 +646,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link BonePose#getScaleX()} and {@link BonePose#getScaleY()}. */
|
||||
/** Changes {@link BonePose#scaleX} and {@link BonePose#scaleY}. */
|
||||
static public class ScaleTimeline extends BoneTimeline2 {
|
||||
public ScaleTimeline (int frameCount, int bezierCount, int boneIndex) {
|
||||
super(frameCount, bezierCount, boneIndex, Property.scaleX, Property.scaleY);
|
||||
@ -713,7 +713,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link BonePose#getScaleX()}. */
|
||||
/** Changes {@link BonePose#scaleX}. */
|
||||
static public class ScaleXTimeline extends BoneTimeline1 {
|
||||
public ScaleXTimeline (int frameCount, int bezierCount, int boneIndex) {
|
||||
super(frameCount, bezierCount, boneIndex, Property.scaleX);
|
||||
@ -724,7 +724,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link BonePose#getScaleY()}. */
|
||||
/** Changes {@link BonePose#scaleY}. */
|
||||
static public class ScaleYTimeline extends BoneTimeline1 {
|
||||
public ScaleYTimeline (int frameCount, int bezierCount, int boneIndex) {
|
||||
super(frameCount, bezierCount, boneIndex, Property.scaleY);
|
||||
@ -735,7 +735,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link BonePose#getShearX()} and {@link BonePose#getShearY()}. */
|
||||
/** Changes {@link BonePose#shearX} and {@link BonePose#shearY}. */
|
||||
static public class ShearTimeline extends BoneTimeline2 {
|
||||
public ShearTimeline (int frameCount, int bezierCount, int boneIndex) {
|
||||
super(frameCount, bezierCount, boneIndex, Property.shearX, Property.shearY);
|
||||
@ -785,7 +785,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link BonePose#getShearX()}. */
|
||||
/** Changes {@link BonePose#shearX}. */
|
||||
static public class ShearXTimeline extends BoneTimeline1 {
|
||||
public ShearXTimeline (int frameCount, int bezierCount, int boneIndex) {
|
||||
super(frameCount, bezierCount, boneIndex, Property.shearX);
|
||||
@ -796,7 +796,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link BonePose#getShearY()}. */
|
||||
/** Changes {@link BonePose#shearY}. */
|
||||
static public class ShearYTimeline extends BoneTimeline1 {
|
||||
public ShearYTimeline (int frameCount, int bezierCount, int boneIndex) {
|
||||
super(frameCount, bezierCount, boneIndex, Property.shearY);
|
||||
@ -807,7 +807,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link BonePose#getInherit()}. */
|
||||
/** Changes {@link BonePose#inherit}. */
|
||||
static public class InheritTimeline extends Timeline implements BoneTimeline {
|
||||
static public final int ENTRIES = 2;
|
||||
static private final int INHERIT = 1;
|
||||
@ -877,7 +877,7 @@ public class Animation {
|
||||
abstract protected void apply (Slot slot, SlotPose pose, float time, float alpha, boolean fromSetup, boolean add);
|
||||
}
|
||||
|
||||
/** Changes {@link SlotPose#getColor()}. */
|
||||
/** Changes {@link SlotPose#color}. */
|
||||
static public class RGBATimeline extends SlotCurveTimeline {
|
||||
static public final int ENTRIES = 5;
|
||||
static private final int R = 1, G = 2, B = 3, A = 4;
|
||||
@ -954,7 +954,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes RGB for a slot's {@link SlotPose#getColor()}. */
|
||||
/** Changes RGB for a slot's {@link SlotPose#color}. */
|
||||
static public class RGBTimeline extends SlotCurveTimeline {
|
||||
static public final int ENTRIES = 4;
|
||||
static private final int R = 1, G = 2, B = 3;
|
||||
@ -1034,7 +1034,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes alpha for a slot's {@link SlotPose#getColor()}. */
|
||||
/** Changes alpha for a slot's {@link SlotPose#color}. */
|
||||
static public class AlphaTimeline extends CurveTimeline1 implements SlotTimeline {
|
||||
final int slotIndex;
|
||||
|
||||
@ -1072,7 +1072,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link SlotPose#getColor()} and {@link SlotPose#getDarkColor()} for two color tinting. */
|
||||
/** Changes {@link SlotPose#color} and {@link SlotPose#darkColor} for two color tinting. */
|
||||
static public class RGBA2Timeline extends SlotCurveTimeline {
|
||||
static public final int ENTRIES = 8;
|
||||
static private final int R = 1, G = 2, B = 3, A = 4, R2 = 5, G2 = 6, B2 = 7;
|
||||
@ -1183,7 +1183,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes RGB for a slot's {@link SlotPose#getColor()} and {@link SlotPose#getDarkColor()} for two color tinting. */
|
||||
/** Changes RGB for a slot's {@link SlotPose#color} and {@link SlotPose#darkColor} for two color tinting. */
|
||||
static public class RGB2Timeline extends SlotCurveTimeline {
|
||||
static public final int ENTRIES = 7;
|
||||
static private final int R = 1, G = 2, B = 3, R2 = 4, G2 = 5, B2 = 6;
|
||||
@ -1295,7 +1295,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link SlotPose#getAttachment()}. */
|
||||
/** Changes {@link SlotPose#attachment}. */
|
||||
static public class AttachmentTimeline extends Timeline implements SlotTimeline {
|
||||
final int slotIndex;
|
||||
final String[] attachmentNames;
|
||||
@ -1345,7 +1345,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link SlotPose#getDeform()} to deform a {@link VertexAttachment}. */
|
||||
/** Changes {@link SlotPose#deform} to deform a {@link VertexAttachment}. */
|
||||
static public class DeformTimeline extends SlotCurveTimeline {
|
||||
final VertexAttachment attachment;
|
||||
private final float[][] vertices;
|
||||
@ -1555,7 +1555,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link SlotPose#getSequenceIndex()} for an attachment's {@link Sequence}. */
|
||||
/** Changes {@link SlotPose#sequenceIndex} for an attachment's {@link Sequence}. */
|
||||
static public class SequenceTimeline extends Timeline implements SlotTimeline {
|
||||
static public final int ENTRIES = 3;
|
||||
static private final int MODE = 1, DELAY = 2;
|
||||
@ -1578,7 +1578,7 @@ public class Animation {
|
||||
return slotIndex;
|
||||
}
|
||||
|
||||
/** The attachment for which {@link SlotPose#getSequenceIndex()} will be set.
|
||||
/** The attachment for which {@link SlotPose#sequenceIndex} will be set.
|
||||
* <p>
|
||||
* See {@link VertexAttachment#getTimelineAttachment()}. */
|
||||
public Attachment getAttachment () {
|
||||
@ -1704,7 +1704,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link Skeleton#getDrawOrder()}. */
|
||||
/** Changes {@link Skeleton#drawOrder}. */
|
||||
static public class DrawOrderTimeline extends Timeline {
|
||||
static final String propertyID = Integer.toString(Property.drawOrder.ordinal());
|
||||
static private final String[] propertyIds = {propertyID};
|
||||
@ -1754,13 +1754,13 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes a subset of {@link Skeleton#getDrawOrder()}. */
|
||||
/** Changes a subset of {@link Skeleton#drawOrder}. */
|
||||
static public class DrawOrderFolderTimeline extends Timeline {
|
||||
private final int[] slots;
|
||||
private final boolean[] inFolder;
|
||||
private final int[][] drawOrders;
|
||||
|
||||
/** @param slots {@link Skeleton#getSlots()} indices controlled by this timeline, in setup order.
|
||||
/** @param slots {@link Skeleton#slots} indices controlled by this timeline, in setup order.
|
||||
* @param slotCount The maximum number of slots in the skeleton. */
|
||||
public DrawOrderFolderTimeline (int frameCount, int[] slots, int slotCount) {
|
||||
super(frameCount, propertyIds(slots));
|
||||
@ -1784,7 +1784,7 @@ public class Animation {
|
||||
return frames.length;
|
||||
}
|
||||
|
||||
/** The {@link Skeleton#getSlots()} indices that this timeline affects, in setup order. */
|
||||
/** The {@link Skeleton#slots} indices that this timeline affects, in setup order. */
|
||||
public int[] getSlots () {
|
||||
return slots;
|
||||
}
|
||||
@ -1797,7 +1797,7 @@ public class Animation {
|
||||
/** Sets the time and draw order for the specified frame.
|
||||
* @param frame Between 0 and <code>frameCount</code>, inclusive.
|
||||
* @param time The frame time in seconds.
|
||||
* @param drawOrder Ordered {@link #getSlots()} indices, or null to use setup pose order. */
|
||||
* @param drawOrder Ordered {@link #slots} indices, or null to use setup pose order. */
|
||||
public void setFrame (int frame, float time, @Null int[] drawOrder) {
|
||||
frames[frame] = time;
|
||||
drawOrders[frame] = drawOrder;
|
||||
@ -1842,14 +1842,13 @@ public class Animation {
|
||||
}
|
||||
|
||||
static public interface ConstraintTimeline {
|
||||
/** The index of the constraint in {@link Skeleton#getConstraints()} that will be changed when this timeline is applied, or
|
||||
* -1 if a specific constraint will not be changed. */
|
||||
/** The index of the constraint in {@link Skeleton#constraints} that will be changed when this timeline is applied, or -1 if
|
||||
* a specific constraint will not be changed. */
|
||||
public int getConstraintIndex ();
|
||||
}
|
||||
|
||||
/** Changes {@link IkConstraintPose#getMix()}, {@link IkConstraintPose#getSoftness()},
|
||||
* {@link IkConstraintPose#getBendDirection()}, {@link IkConstraintPose#getStretch()}, and
|
||||
* {@link IkConstraintPose#getCompress()}. */
|
||||
/** Changes {@link IkConstraintPose#mix}, {@link IkConstraintPose#softness}, {@link IkConstraintPose#bendDirection},
|
||||
* {@link IkConstraintPose#stretch}, and {@link IkConstraintPose#compress}. */
|
||||
static public class IkConstraintTimeline extends CurveTimeline implements ConstraintTimeline {
|
||||
static public final int ENTRIES = 6;
|
||||
static private final int MIX = 1, SOFTNESS = 2, BEND_DIRECTION = 3, COMPRESS = 4, STRETCH = 5;
|
||||
@ -1941,9 +1940,9 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link TransformConstraintPose#getMixRotate()}, {@link TransformConstraintPose#getMixX()},
|
||||
* {@link TransformConstraintPose#getMixY()}, {@link TransformConstraintPose#getMixScaleX()},
|
||||
* {@link TransformConstraintPose#getMixScaleY()}, and {@link TransformConstraintPose#getMixShearY()}. */
|
||||
/** Changes {@link TransformConstraintPose#mixRotate}, {@link TransformConstraintPose#mixX},
|
||||
* {@link TransformConstraintPose#mixY}, {@link TransformConstraintPose#mixScaleX}, {@link TransformConstraintPose#mixScaleY},
|
||||
* and {@link TransformConstraintPose#mixShearY}. */
|
||||
static public class TransformConstraintTimeline extends CurveTimeline implements ConstraintTimeline {
|
||||
static public final int ENTRIES = 7;
|
||||
static private final int ROTATE = 1, X = 2, Y = 3, SCALEX = 4, SCALEY = 5, SHEARY = 6;
|
||||
@ -2069,7 +2068,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link PathConstraintPose#getPosition()}. */
|
||||
/** Changes {@link PathConstraintPose#position}. */
|
||||
static public class PathConstraintPositionTimeline extends ConstraintTimeline1 {
|
||||
public PathConstraintPositionTimeline (int frameCount, int bezierCount, int constraintIndex) {
|
||||
super(frameCount, bezierCount, constraintIndex, Property.pathConstraintPosition);
|
||||
@ -2086,7 +2085,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link PathConstraintPose#getSpacing()}. */
|
||||
/** Changes {@link PathConstraintPose#spacing}. */
|
||||
static public class PathConstraintSpacingTimeline extends ConstraintTimeline1 {
|
||||
public PathConstraintSpacingTimeline (int frameCount, int bezierCount, int constraintIndex) {
|
||||
super(frameCount, bezierCount, constraintIndex, Property.pathConstraintSpacing);
|
||||
@ -2102,8 +2101,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link PathConstraintPose#getMixRotate()}, {@link PathConstraintPose#getMixX()}, and
|
||||
* {@link PathConstraintPose#getMixY()}. */
|
||||
/** Changes {@link PathConstraintPose#mixRotate}, {@link PathConstraintPose#mixX}, and {@link PathConstraintPose#mixY}. */
|
||||
static public class PathConstraintMixTimeline extends CurveTimeline implements ConstraintTimeline {
|
||||
static public final int ENTRIES = 4;
|
||||
static private final int ROTATE = 1, X = 2, Y = 3;
|
||||
@ -2226,7 +2224,7 @@ public class Animation {
|
||||
abstract protected boolean global (PhysicsConstraintData constraint);
|
||||
}
|
||||
|
||||
/** Changes {@link PhysicsConstraintPose#getInertia()}. */
|
||||
/** Changes {@link PhysicsConstraintPose#inertia}. */
|
||||
static public class PhysicsConstraintInertiaTimeline extends PhysicsConstraintTimeline {
|
||||
public PhysicsConstraintInertiaTimeline (int frameCount, int bezierCount, int constraintIndex) {
|
||||
super(frameCount, bezierCount, constraintIndex, Property.physicsConstraintInertia);
|
||||
@ -2245,7 +2243,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link PhysicsConstraintPose#getStrength()}. */
|
||||
/** Changes {@link PhysicsConstraintPose#strength}. */
|
||||
static public class PhysicsConstraintStrengthTimeline extends PhysicsConstraintTimeline {
|
||||
public PhysicsConstraintStrengthTimeline (int frameCount, int bezierCount, int constraintIndex) {
|
||||
super(frameCount, bezierCount, constraintIndex, Property.physicsConstraintStrength);
|
||||
@ -2264,7 +2262,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link PhysicsConstraintPose#getDamping()}. */
|
||||
/** Changes {@link PhysicsConstraintPose#damping}. */
|
||||
static public class PhysicsConstraintDampingTimeline extends PhysicsConstraintTimeline {
|
||||
public PhysicsConstraintDampingTimeline (int frameCount, int bezierCount, int constraintIndex) {
|
||||
super(frameCount, bezierCount, constraintIndex, Property.physicsConstraintDamping);
|
||||
@ -2283,7 +2281,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link PhysicsConstraintPose#getMassInverse()}. The timeline values are not inverted. */
|
||||
/** Changes {@link PhysicsConstraintPose#massInverse}. The timeline values are not inverted. */
|
||||
static public class PhysicsConstraintMassTimeline extends PhysicsConstraintTimeline {
|
||||
public PhysicsConstraintMassTimeline (int frameCount, int bezierCount, int constraintIndex) {
|
||||
super(frameCount, bezierCount, constraintIndex, Property.physicsConstraintMass);
|
||||
@ -2302,7 +2300,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link PhysicsConstraintPose#getWind()}. */
|
||||
/** Changes {@link PhysicsConstraintPose#wind}. */
|
||||
static public class PhysicsConstraintWindTimeline extends PhysicsConstraintTimeline {
|
||||
public PhysicsConstraintWindTimeline (int frameCount, int bezierCount, int constraintIndex) {
|
||||
super(frameCount, bezierCount, constraintIndex, Property.physicsConstraintWind);
|
||||
@ -2322,7 +2320,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link PhysicsConstraintPose#getGravity()}. */
|
||||
/** Changes {@link PhysicsConstraintPose#gravity}. */
|
||||
static public class PhysicsConstraintGravityTimeline extends PhysicsConstraintTimeline {
|
||||
public PhysicsConstraintGravityTimeline (int frameCount, int bezierCount, int constraintIndex) {
|
||||
super(frameCount, bezierCount, constraintIndex, Property.physicsConstraintGravity);
|
||||
@ -2342,7 +2340,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link PhysicsConstraintPose#getMix()}. */
|
||||
/** Changes {@link PhysicsConstraintPose#mix}. */
|
||||
static public class PhysicsConstraintMixTimeline extends PhysicsConstraintTimeline {
|
||||
public PhysicsConstraintMixTimeline (int frameCount, int bezierCount, int constraintIndex) {
|
||||
super(frameCount, bezierCount, constraintIndex, Property.physicsConstraintMix);
|
||||
@ -2374,8 +2372,8 @@ public class Animation {
|
||||
instant = true;
|
||||
}
|
||||
|
||||
/** The index of the physics constraint in {@link Skeleton#getConstraints()} that will be reset when this timeline is
|
||||
* applied, or -1 if all physics constraints in the skeleton will be reset. */
|
||||
/** The index of the physics constraint in {@link Skeleton#constraints} that will be reset when this timeline is applied, or
|
||||
* -1 if all physics constraints in the skeleton will be reset. */
|
||||
public int getConstraintIndex () {
|
||||
return constraintIndex;
|
||||
}
|
||||
@ -2422,7 +2420,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link SliderPose#getTime()}. */
|
||||
/** Changes {@link SliderPose#time}. */
|
||||
static public class SliderTimeline extends ConstraintTimeline1 {
|
||||
public SliderTimeline (int frameCount, int bezierCount, int constraintIndex) {
|
||||
super(frameCount, bezierCount, constraintIndex, Property.sliderTime);
|
||||
@ -2439,7 +2437,7 @@ public class Animation {
|
||||
}
|
||||
}
|
||||
|
||||
/** Changes {@link SliderPose#getMix()}. */
|
||||
/** Changes {@link SliderPose#mix}. */
|
||||
static public class SliderMixTimeline extends ConstraintTimeline1 {
|
||||
public SliderMixTimeline (int frameCount, int bezierCount, int constraintIndex) {
|
||||
super(frameCount, bezierCount, constraintIndex, Property.sliderMix);
|
||||
|
||||
@ -78,7 +78,7 @@ public class AnimationState {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
/** Increments each track entry {@link TrackEntry#getTrackTime()}, setting queued animations as current if needed. */
|
||||
/** Increments each track entry {@link TrackEntry#trackTime}, setting queued animations as current if needed. */
|
||||
public void update (float delta) {
|
||||
delta *= timeScale;
|
||||
TrackEntry[] tracks = this.tracks.items;
|
||||
@ -496,7 +496,7 @@ public class AnimationState {
|
||||
* If the formerly current track entry is for the same animation and was never applied to a skeleton, it is replaced (not mixed
|
||||
* from).
|
||||
* @param loop If true, the animation will repeat. If false it will not, instead its last frame is applied if played beyond its
|
||||
* duration. In either case {@link TrackEntry#getTrackEnd()} determines when the track is cleared.
|
||||
* duration. In either case {@link TrackEntry#trackEnd} determines when the track is cleared.
|
||||
* @return A track entry to allow further customization of animation playback. References to the track entry must not be kept
|
||||
* after the {@link AnimationStateListener#dispose(TrackEntry)} event occurs. */
|
||||
public TrackEntry setAnimation (int trackIndex, Animation animation, boolean loop) {
|
||||
@ -533,8 +533,8 @@ public class AnimationState {
|
||||
|
||||
/** Adds an animation to be played after the current or last queued animation for a track. If the track has no entries, this is
|
||||
* equivalent to calling {@link #setAnimation(int, Animation, boolean)}.
|
||||
* @param delay If > 0, sets {@link TrackEntry#getDelay()}. If <= 0, the delay set is the duration of the previous track entry
|
||||
* minus any mix duration (from {@link #data}) plus the specified <code>delay</code> (ie the mix ends at (when
|
||||
* @param delay If > 0, sets {@link TrackEntry#delay}. If <= 0, the delay set is the duration of the previous track entry minus
|
||||
* any mix duration (from {@link #data}) plus the specified <code>delay</code> (ie the mix ends at (when
|
||||
* <code>delay</code> = 0) or before (when <code>delay</code> < 0) the previous track entry duration). If the
|
||||
* previous entry is looping, its next loop completion is used instead of its duration.
|
||||
* @return A track entry to allow further customization of animation playback. References to the track entry must not be kept
|
||||
@ -566,7 +566,7 @@ public class AnimationState {
|
||||
}
|
||||
|
||||
/** Sets an empty animation for a track, discarding any queued animations, and sets the track entry's
|
||||
* {@link TrackEntry#getMixDuration()}. An empty animation has no timelines and serves as a placeholder for mixing in or out.
|
||||
* {@link TrackEntry#mixDuration}. An empty animation has no timelines and serves as a placeholder for mixing in or out.
|
||||
* <p>
|
||||
* Mixing out is done by setting an empty animation with a mix duration using either {@link #setEmptyAnimation(int, float)},
|
||||
* {@link #setEmptyAnimations(float)}, or {@link #addEmptyAnimation(int, float, float)}. Mixing to an empty animation causes
|
||||
@ -590,16 +590,16 @@ public class AnimationState {
|
||||
}
|
||||
|
||||
/** Adds an empty animation to be played after the current or last queued animation for a track, and sets the track entry's
|
||||
* {@link TrackEntry#getMixDuration()}. If the track has no entries, it is equivalent to calling
|
||||
* {@link TrackEntry#mixDuration}. If the track has no entries, it is equivalent to calling
|
||||
* {@link #setEmptyAnimation(int, float)}.
|
||||
* <p>
|
||||
* See {@link #setEmptyAnimation(int, float)} and
|
||||
* <a href='https://esotericsoftware.com/spine-applying-animations#Empty-animations'>Empty animations</a> in the Spine Runtimes
|
||||
* Guide.
|
||||
* @param delay If > 0, sets {@link TrackEntry#getDelay()}. If <= 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 (when <code>delay</code> = 0) or
|
||||
* before (when <code>delay</code> < 0) the previous track entry duration). If the previous entry is looping, its
|
||||
* next loop completion is used instead of its duration.
|
||||
* @param delay If > 0, sets {@link TrackEntry#delay}. If <= 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 (when <code>delay</code> = 0) or before
|
||||
* (when <code>delay</code> < 0) the previous track entry duration). If the previous entry is looping, its next loop
|
||||
* completion is used instead of its duration.
|
||||
* @return A track entry to allow further customization of animation playback. References to the track entry must not be kept
|
||||
* after the {@link AnimationStateListener#dispose(TrackEntry)} event occurs. */
|
||||
public TrackEntry addEmptyAnimation (int trackIndex, float mixDuration, float delay) {
|
||||
@ -668,7 +668,7 @@ public class AnimationState {
|
||||
return entry;
|
||||
}
|
||||
|
||||
/** Removes {@link TrackEntry#getNext()} and all entries after it for the specified entry. */
|
||||
/** Removes {@link TrackEntry#next} and all entries after it for the specified entry. */
|
||||
public void clearNext (TrackEntry entry) {
|
||||
TrackEntry next = entry.next;
|
||||
while (next != null) {
|
||||
@ -779,7 +779,7 @@ public class AnimationState {
|
||||
/** Multiplier for the delta time when the animation state is updated, causing time for all animations and mixes to play slower
|
||||
* or faster. Defaults to 1.
|
||||
* <p>
|
||||
* See {@link TrackEntry#getTimeScale()} to affect a single animation. */
|
||||
* See {@link TrackEntry#timeScale} to affect a single animation. */
|
||||
public float getTimeScale () {
|
||||
return timeScale;
|
||||
}
|
||||
@ -879,14 +879,14 @@ public class AnimationState {
|
||||
}
|
||||
|
||||
/** Seconds to postpone playing the animation. Must be >= 0. When this track entry is the current track entry,
|
||||
* <code>delay</code> postpones incrementing the {@link #getTrackTime()}. When this track entry is queued,
|
||||
* <code>delay</code> 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 {@link #getTrackTime()} >= this track entry's <code>delay</code>).
|
||||
* <code>delay</code> postpones incrementing the {@link #trackTime}. When this track entry is queued, <code>delay</code> 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 {@link #trackTime} >= this track entry's <code>delay</code>).
|
||||
* <p>
|
||||
* {@link #getTimeScale()} affects the delay.
|
||||
* {@link #timeScale} affects the delay.
|
||||
* <p>
|
||||
* When passing <code>delay</code> <= 0 to {@link AnimationState#addAnimation(int, Animation, boolean, float)} this
|
||||
* <code>delay</code> is set using a mix duration from {@link AnimationStateData}. To change the {@link #getMixDuration()}
|
||||
* <code>delay</code> is set using a mix duration from {@link AnimationStateData}. To change the {@link #mixDuration}
|
||||
* afterward, use {@link #setMixDuration(float, float)} so this <code>delay</code> is adjusted. */
|
||||
public float getDelay () {
|
||||
return delay;
|
||||
@ -923,11 +923,11 @@ public class AnimationState {
|
||||
this.trackEnd = trackEnd;
|
||||
}
|
||||
|
||||
/** If this track entry is non-looping, this is the track time in seconds when {@link #getAnimationEnd()} is reached, or the
|
||||
* current {@link #getTrackTime()} if it has already been reached.
|
||||
/** If this track entry is non-looping, this is the track time in seconds when {@link #animationEnd} is reached, or the
|
||||
* current {@link #trackTime} if it has already been reached.
|
||||
* <p>
|
||||
* If this track entry is looping, this is the track time when this animation will reach its next {@link #getAnimationEnd()}
|
||||
* (the next loop completion). */
|
||||
* If this track entry is looping, this is the track time when this animation will reach its next {@link #animationEnd} (the
|
||||
* next loop completion). */
|
||||
public float getTrackComplete () {
|
||||
float duration = animationEnd - animationStart;
|
||||
if (duration != 0) {
|
||||
@ -939,8 +939,8 @@ public class AnimationState {
|
||||
|
||||
/** Seconds when this animation starts, both initially and after looping. Defaults to 0.
|
||||
* <p>
|
||||
* When changing the <code>animationStart</code> time, it often makes sense to set {@link #getAnimationLast()} to the same
|
||||
* value to prevent timeline keys before the start time from triggering. */
|
||||
* When changing the <code>animationStart</code> time, it often makes sense to set {@link #animationLast} to the same value
|
||||
* to prevent timeline keys before the start time from triggering. */
|
||||
public float getAnimationStart () {
|
||||
return animationStart;
|
||||
}
|
||||
@ -950,7 +950,7 @@ public class AnimationState {
|
||||
}
|
||||
|
||||
/** Seconds for the last frame of this animation. Non-looping animations won't play past this time. Looping animations will
|
||||
* loop back to {@link #getAnimationStart()} at this time. Defaults to the animation {@link Animation#duration}. */
|
||||
* loop back to {@link #animationStart} at this time. Defaults to the animation {@link Animation#duration}. */
|
||||
public float getAnimationEnd () {
|
||||
return animationEnd;
|
||||
}
|
||||
@ -972,12 +972,12 @@ public class AnimationState {
|
||||
nextAnimationLast = animationLast;
|
||||
}
|
||||
|
||||
/** Uses {@link #getTrackTime()} to compute the <code>animationTime</code>. When the <code>trackTime</code> is 0, the
|
||||
/** Uses {@link #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.
|
||||
* <p>
|
||||
* The <code>animationTime</code> is between {@link #getAnimationStart()} and {@link #getAnimationEnd()}, except if this
|
||||
* track entry is non-looping and {@link #getAnimationEnd()} is >= to the {@link Animation#duration}, then
|
||||
* <code>animationTime</code> continues to increase past {@link #getAnimationEnd()}. */
|
||||
* The <code>animationTime</code> is between {@link #animationStart} and {@link #animationEnd}, except if this track entry
|
||||
* is non-looping and {@link #animationEnd} is >= to the {@link Animation#duration}, then <code>animationTime</code>
|
||||
* continues to increase past {@link #animationEnd}. */
|
||||
public float getAnimationTime () {
|
||||
if (loop) {
|
||||
float duration = animationEnd - animationStart;
|
||||
@ -991,16 +991,16 @@ public class AnimationState {
|
||||
/** Multiplier for the delta time when this track entry is updated, causing time for this animation to pass slower or
|
||||
* faster. Defaults to 1.
|
||||
* <p>
|
||||
* Values < 0 are not supported. To play an animation in reverse, use {@link #getReverse()}.
|
||||
* Values < 0 are not supported. To play an animation in reverse, use {@link #reverse}.
|
||||
* <p>
|
||||
* {@link #getMixTime()} is not affected by track entry time scale, so {@link #getMixDuration()} may need to be adjusted to
|
||||
* match the animation speed.
|
||||
* {@link #mixTime} is not affected by track entry time scale, so {@link #mixDuration} may need to be adjusted to match the
|
||||
* animation speed.
|
||||
* <p>
|
||||
* When using {@link AnimationState#addAnimation(int, Animation, boolean, float)} with a <code>delay</code> <= 0, the
|
||||
* {@link #getDelay()} is set using the mix duration from {@link AnimationState#data}, assuming time scale to be 1. If the
|
||||
* time scale is not 1, the delay may need to be adjusted.
|
||||
* {@link #delay} is set using the mix duration from {@link AnimationState#data}, assuming time scale to be 1. If the time
|
||||
* scale is not 1, the delay may need to be adjusted.
|
||||
* <p>
|
||||
* See {@link AnimationState#getTimeScale()} to affect all animations. */
|
||||
* See {@link AnimationState#timeScale} to affect all animations. */
|
||||
public float getTimeScale () {
|
||||
return timeScale;
|
||||
}
|
||||
@ -1026,7 +1026,7 @@ public class AnimationState {
|
||||
* <p>
|
||||
* Alpha should be 1 on track 0.
|
||||
* <p>
|
||||
* See {@link #getAlphaAttachmentThreshold()}. */
|
||||
* See {@link #alphaAttachmentThreshold}. */
|
||||
public float getAlpha () {
|
||||
return alpha;
|
||||
}
|
||||
@ -1035,9 +1035,9 @@ public class AnimationState {
|
||||
this.alpha = alpha;
|
||||
}
|
||||
|
||||
/** When the mix percentage ({@link #getMixTime()} / {@link #getMixDuration()}) is less than the
|
||||
* <code>eventThreshold</code>, 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. */
|
||||
/** When the mix percentage ({@link #mixTime} / {@link #mixDuration}) is less than the <code>eventThreshold</code>, 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. */
|
||||
public float getEventThreshold () {
|
||||
return eventThreshold;
|
||||
}
|
||||
@ -1047,7 +1047,7 @@ public class AnimationState {
|
||||
}
|
||||
|
||||
/** When the computed alpha is greater than <code>alphaAttachmentThreshold</code>, attachment timelines are applied. The
|
||||
* computed alpha includes {@link #getAlpha()} and the mix percentage. Defaults to 0, so attachment timelines are always
|
||||
* computed alpha includes {@link #alpha} and the mix percentage. Defaults to 0, so attachment timelines are always
|
||||
* applied. */
|
||||
public float getAlphaAttachmentThreshold () {
|
||||
return alphaAttachmentThreshold;
|
||||
@ -1057,9 +1057,9 @@ public class AnimationState {
|
||||
this.alphaAttachmentThreshold = alphaAttachmentThreshold;
|
||||
}
|
||||
|
||||
/** When the mix percentage ({@link #getMixTime()} / {@link #getMixDuration()}) is less than the
|
||||
* <code>mixAttachmentThreshold</code>, 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. */
|
||||
/** When the mix percentage ({@link #mixTime} / {@link #mixDuration}) is less than the <code>mixAttachmentThreshold</code>,
|
||||
* 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. */
|
||||
public float getMixAttachmentThreshold () {
|
||||
return mixAttachmentThreshold;
|
||||
}
|
||||
@ -1068,9 +1068,9 @@ public class AnimationState {
|
||||
this.mixAttachmentThreshold = mixAttachmentThreshold;
|
||||
}
|
||||
|
||||
/** When the mix percentage ({@link #getMixTime()} / {@link #getMixDuration()}) is less than the
|
||||
* <code>mixDrawOrderThreshold</code>, 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. */
|
||||
/** When the mix percentage ({@link #mixTime} / {@link #mixDuration}) is less than the <code>mixDrawOrderThreshold</code>,
|
||||
* 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. */
|
||||
public float getMixDrawOrderThreshold () {
|
||||
return mixDrawOrderThreshold;
|
||||
}
|
||||
@ -1099,7 +1099,7 @@ public class AnimationState {
|
||||
return nextTrackLast != -1;
|
||||
}
|
||||
|
||||
/** Returns true if there is a {@link #getNext()} track entry and it will become the current track entry during the next
|
||||
/** Returns true if there is a {@link #next} track entry and it will become the current track entry during the next
|
||||
* {@link AnimationState#update(float)}. */
|
||||
public boolean isNextReady () {
|
||||
return next != null && nextTrackLast - next.delay >= 0;
|
||||
@ -1112,8 +1112,8 @@ public class AnimationState {
|
||||
return trackTime >= animationEnd - animationStart;
|
||||
}
|
||||
|
||||
/** Seconds elapsed from 0 to the {@link #getMixDuration()} when mixing from the previous animation to this animation. May
|
||||
* be slightly more than <code>mixDuration</code> when the mix is complete. */
|
||||
/** Seconds elapsed from 0 to the {@link #mixDuration} when mixing from the previous animation to this animation. May be
|
||||
* slightly more than <code>mixDuration</code> when the mix is complete. */
|
||||
public float getMixTime () {
|
||||
return mixTime;
|
||||
}
|
||||
@ -1133,7 +1133,7 @@ public class AnimationState {
|
||||
* track entry only before {@link AnimationState#update(float)} is next called.
|
||||
* <p>
|
||||
* When using {@link AnimationState#addAnimation(int, Animation, boolean, float)} with a <code>delay</code> <= 0, the
|
||||
* {@link #getDelay()} is set using the mix duration from {@link AnimationState#data}. If <code>mixDuration</code> is set
|
||||
* {@link #delay} is set using the mix duration from {@link AnimationState#data}. If <code>mixDuration</code> is set
|
||||
* afterward, the delay needs to be adjusted:
|
||||
*
|
||||
* <pre>
|
||||
@ -1155,11 +1155,11 @@ public class AnimationState {
|
||||
this.mixDuration = mixDuration;
|
||||
}
|
||||
|
||||
/** Sets both {@link #getMixDuration()} and {@link #getDelay()}.
|
||||
* @param delay If > 0, sets {@link #getDelay()}. 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 (when <code>delay</code> =
|
||||
* 0) or before (when <code>delay</code> < 0) the previous track entry duration). If the previous entry is
|
||||
* looping, its next loop completion is used instead of its duration. */
|
||||
/** Sets both {@link #mixDuration} and {@link #delay}.
|
||||
* @param delay If > 0, sets {@link #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 (when <code>delay</code> = 0)
|
||||
* or before (when <code>delay</code> < 0) the previous track entry duration). If the previous entry is looping,
|
||||
* its next loop completion is used instead of its duration. */
|
||||
public void setMixDuration (float mixDuration, float delay) {
|
||||
this.mixDuration = mixDuration;
|
||||
if (delay <= 0) delay = previous == null ? 0 : Math.max(delay + previous.getTrackComplete() - mixDuration, 0);
|
||||
@ -1205,7 +1205,7 @@ public class AnimationState {
|
||||
}
|
||||
|
||||
/** When {@link #shortestRotation} is false, this clears the directions for mixing this entry's rotation. This can be useful
|
||||
* to avoid bones rotating the long way around when using {@link #getAlpha()} and starting animations on other tracks.
|
||||
* to avoid bones rotating the long way around when using {@link #alpha} and starting animations on other tracks.
|
||||
* <p>
|
||||
* Mixing involves finding a rotation between two others. There are two possible solutions: the short or the long way
|
||||
* around. When the two rotations change over time, which direction is the short or long way can also change. If the short
|
||||
@ -1366,7 +1366,7 @@ public class AnimationState {
|
||||
/** Invoked every time this entry's animation completes a loop. This may occur during mixing (after
|
||||
* {@link #interrupt(TrackEntry)}).
|
||||
* <p>
|
||||
* If this entry's {@link TrackEntry#getMixingTo()} is not null, this entry is mixing out (it is not the current entry).
|
||||
* If this entry's {@link TrackEntry#mixingTo} is not null, this entry is mixing out (it is not the current entry).
|
||||
* <p>
|
||||
* Because this event is triggered at the end of {@link AnimationState#apply(Skeleton)}, any animations set in response to
|
||||
* the event won't be applied until the next time the AnimationState is applied. */
|
||||
|
||||
@ -74,7 +74,7 @@ public class AnimationStateData {
|
||||
}
|
||||
|
||||
/** Returns the mix duration to use when changing from the specified animation to the other on the same track, or the
|
||||
* {@link #getDefaultMix()} if no mix duration has been set. */
|
||||
* {@link #defaultMix} if no mix duration has been set. */
|
||||
public float getMix (Animation from, Animation to) {
|
||||
if (from == null) throw new IllegalArgumentException("from cannot be null.");
|
||||
if (to == null) throw new IllegalArgumentException("to cannot be null.");
|
||||
|
||||
@ -35,9 +35,9 @@ import com.badlogic.gdx.utils.Null;
|
||||
/** A node in a skeleton's hierarchy with a transform that affects its children and their attachments. A bone has a number of
|
||||
* poses:
|
||||
* <ul>
|
||||
* <li>{@link #getData()}: The setup pose.
|
||||
* <li>{@link #getPose()}: The unconstrained local pose. Set by animations and application code.
|
||||
* <li>{@link #getAppliedPose()}: The constrained local pose. The {@link #getPose()} with modifications by constraints.
|
||||
* <li>{@link #data}: The setup pose.
|
||||
* <li>{@link #pose}: The unconstrained local pose. Set by animations and application code.
|
||||
* <li>{@link #getAppliedPose()}: The constrained local pose. The {@link #pose} with modifications by constraints.
|
||||
* <li>World transform (on the applied pose): the {@link #getAppliedPose()} combined with the parent world transform. Computed by
|
||||
* {@link Skeleton#updateWorldTransform(Physics)} and {@link BonePose#updateWorldTransform(Skeleton)}.
|
||||
* </ul>
|
||||
@ -54,7 +54,7 @@ public class Bone extends PosedActive<BoneData, BonePose> {
|
||||
constrained.bone = this;
|
||||
}
|
||||
|
||||
/** Copy constructor. Does not copy the {@link #getChildren()} bones. */
|
||||
/** Copy constructor. Does not copy the {@link #children} bones. */
|
||||
public Bone (Bone bone, @Null Bone parent) {
|
||||
this(bone.data, parent);
|
||||
pose.set(bone.pose);
|
||||
|
||||
@ -65,7 +65,7 @@ public class BoneData extends PosedData<BonePose> {
|
||||
return super.getName();
|
||||
}
|
||||
|
||||
/** The {@link Skeleton#getBones()} index. */
|
||||
/** The {@link Skeleton#bones} index. */
|
||||
public int getIndex () {
|
||||
return index;
|
||||
}
|
||||
|
||||
@ -9,8 +9,8 @@ import com.badlogic.gdx.math.Vector2;
|
||||
|
||||
import com.esotericsoftware.spine.BoneData.Inherit;
|
||||
|
||||
/** The applied local pose and world transform for a bone. This is the {@link Bone#getPose()} with constraints applied and the
|
||||
* world transform computed by {@link Skeleton#updateWorldTransform(Physics)} and {@link #updateWorldTransform(Skeleton)}.
|
||||
/** The applied local pose and world transform for a bone. This is the {@link Bone#pose} with constraints applied and the world
|
||||
* transform computed by {@link Skeleton#updateWorldTransform(Physics)} and {@link #updateWorldTransform(Skeleton)}.
|
||||
* <p>
|
||||
* If the world transform is changed, call {@link #updateLocalTransform(Skeleton)} before using the local transform. The local
|
||||
* transform may be needed by other code (eg to apply another constraint).
|
||||
|
||||
@ -62,8 +62,8 @@ public class IkConstraintData extends ConstraintData<IkConstraint, IkConstraintP
|
||||
this.target = target;
|
||||
}
|
||||
|
||||
/** When true and {@link IkConstraintPose#getCompress()} or {@link IkConstraintPose#getStretch()} is used, the bone is scaled
|
||||
* on both the X and Y axes. */
|
||||
/** When true and {@link IkConstraintPose#compress} or {@link IkConstraintPose#stretch} is used, the bone is scaled on both the
|
||||
* X and Y axes. */
|
||||
public boolean getUniform () {
|
||||
return uniform;
|
||||
}
|
||||
|
||||
@ -84,8 +84,8 @@ public class IkConstraintPose implements Pose<IkConstraintPose> {
|
||||
|
||||
/** When true and the target is out of range, the parent bone is scaled to reach it.
|
||||
* <p>
|
||||
* For two bone IK: 1) the child bone's local Y translation is set to 0, 2) stretch is not applied if {@link #getSoftness()} is
|
||||
* > 0, and 3) if the parent bone has local nonuniform scale, stretch is not applied. */
|
||||
* For two bone IK: 1) the child bone's local Y translation is set to 0, 2) stretch is not applied if {@link #softness} is > 0,
|
||||
* and 3) if the parent bone has local nonuniform scale, stretch is not applied. */
|
||||
public boolean getStretch () {
|
||||
return stretch;
|
||||
}
|
||||
|
||||
@ -79,7 +79,7 @@ public class PhysicsConstraintPose implements Pose<PhysicsConstraintPose> {
|
||||
this.massInverse = massInverse;
|
||||
}
|
||||
|
||||
/** Applies a constant force along the world X axis. */
|
||||
/** Applies a constant force along the {@link Skeleton#windX}, {@link Skeleton#windY} vector. */
|
||||
public float getWind () {
|
||||
return wind;
|
||||
}
|
||||
@ -88,7 +88,7 @@ public class PhysicsConstraintPose implements Pose<PhysicsConstraintPose> {
|
||||
this.wind = wind;
|
||||
}
|
||||
|
||||
/** Applies a constant force along the world Y axis. */
|
||||
/** Applies a constant force along the {@link Skeleton#gravityX}, {@link Skeleton#gravityY} vector. */
|
||||
public float getGravity () {
|
||||
return gravity;
|
||||
}
|
||||
|
||||
@ -3,9 +3,9 @@ package com.esotericsoftware.spine;
|
||||
|
||||
/** The base class for an object with a number of poses:
|
||||
* <ul>
|
||||
* <li>{@link #getData()}: The setup pose.
|
||||
* <li>{@link #getPose()}: The unconstrained pose. Set by animations and application code.
|
||||
* <li>{@link #getAppliedPose()}: The constrained pose. The {@link #getPose()} with modifications by constraints.
|
||||
* <li>{@link #data}: The setup pose.
|
||||
* <li>{@link #pose}: The unconstrained pose. Set by animations and application code.
|
||||
* <li>{@link #getAppliedPose()}: The constrained pose. The {@link #pose} with modifications by constraints.
|
||||
* </ul>
|
||||
*/
|
||||
abstract public class Posed< //
|
||||
|
||||
@ -16,8 +16,8 @@ abstract public class PosedActive< //
|
||||
|
||||
/** Returns false when this constraint won't be updated by
|
||||
* {@link Skeleton#updateWorldTransform(com.esotericsoftware.spine.Physics)} because a skin is required and the
|
||||
* {@link Skeleton#getSkin() active skin} does not contain this item. See {@link Skin#getBones()},
|
||||
* {@link Skin#getConstraints()}, {@link PosedData#getSkinRequired()}, and {@link Skeleton#updateCache()}. */
|
||||
* {@link Skeleton#skin active skin} does not contain this item. See {@link Skin#bones}, {@link Skin#constraints},
|
||||
* {@link PosedData#skinRequired}, and {@link Skeleton#updateCache()}. */
|
||||
public boolean isActive () {
|
||||
return active;
|
||||
}
|
||||
|
||||
@ -50,10 +50,10 @@ abstract public class PosedData<P extends Pose> {
|
||||
return setup;
|
||||
}
|
||||
|
||||
/** When true, {@link Skeleton#updateWorldTransform(Physics)} only updates this constraint if the {@link Skeleton#getSkin()}
|
||||
/** When true, {@link Skeleton#updateWorldTransform(Physics)} only updates this constraint if the {@link Skeleton#skin}
|
||||
* contains this constraint.
|
||||
* <p>
|
||||
* See {@link Skin#getConstraints()}. */
|
||||
* See {@link Skin#constraints}. */
|
||||
public boolean getSkinRequired () {
|
||||
return skinRequired;
|
||||
}
|
||||
|
||||
@ -148,8 +148,8 @@ public class Skeleton {
|
||||
updateCache();
|
||||
}
|
||||
|
||||
/** Caches information about bones and constraints. Must be called if the {@link #getSkin()} is modified or if bones,
|
||||
* constraints, or weighted path attachments are added or removed. */
|
||||
/** Caches information about bones and constraints. Must be called if the {@link #skin} is modified or if bones, constraints,
|
||||
* or weighted path attachments are added or removed. */
|
||||
public void updateCache () {
|
||||
updateCache.clear();
|
||||
resetCache.clear();
|
||||
@ -374,7 +374,7 @@ public class Skeleton {
|
||||
setSkin(skin);
|
||||
}
|
||||
|
||||
/** Sets the skin used to look up attachments before looking in {@link SkeletonData#getDefaultSkin()}. If the skin is changed,
|
||||
/** Sets the skin used to look up attachments before looking in {@link SkeletonData#defaultSkin}. If the skin is changed,
|
||||
* {@link #updateCache()} is called.
|
||||
* <p>
|
||||
* Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was no
|
||||
@ -536,13 +536,13 @@ public class Skeleton {
|
||||
return color;
|
||||
}
|
||||
|
||||
/** A convenience method for setting the skeleton color. The color can also be set by modifying {@link #getColor()}. */
|
||||
/** A convenience method for setting the skeleton color. The color can also be set by modifying {@link #color}. */
|
||||
public void setColor (Color color) {
|
||||
if (color == null) throw new IllegalArgumentException("color cannot be null.");
|
||||
this.color.set(color);
|
||||
}
|
||||
|
||||
/** A convenience method for setting the skeleton color. The color can also be set by modifying {@link #getColor()}. */
|
||||
/** A convenience method for setting the skeleton color. The color can also be set by modifying {@link #color}. */
|
||||
public void setColor (float r, float g, float b, float a) {
|
||||
color.set(r, g, b, a);
|
||||
}
|
||||
@ -607,7 +607,7 @@ public class Skeleton {
|
||||
this.y = y;
|
||||
}
|
||||
|
||||
/** The x component of a vector that defines the direction {@link PhysicsConstraintPose#getWind()} is applied. */
|
||||
/** The x component of a vector that defines the direction {@link PhysicsConstraintPose#wind} is applied. */
|
||||
public float getWindX () {
|
||||
return windX;
|
||||
}
|
||||
@ -616,7 +616,7 @@ public class Skeleton {
|
||||
this.windX = windX;
|
||||
}
|
||||
|
||||
/** The y component of a vector that defines the direction {@link PhysicsConstraintPose#getWind()} is applied. */
|
||||
/** The y component of a vector that defines the direction {@link PhysicsConstraintPose#wind} is applied. */
|
||||
public float getWindY () {
|
||||
return windY;
|
||||
}
|
||||
@ -625,7 +625,7 @@ public class Skeleton {
|
||||
this.windY = windY;
|
||||
}
|
||||
|
||||
/** The x component of a vector that defines the direction {@link PhysicsConstraintPose#getGravity()} is applied. */
|
||||
/** The x component of a vector that defines the direction {@link PhysicsConstraintPose#gravity} is applied. */
|
||||
public float getGravityX () {
|
||||
return gravityX;
|
||||
}
|
||||
@ -634,7 +634,7 @@ public class Skeleton {
|
||||
this.gravityX = gravityX;
|
||||
}
|
||||
|
||||
/** The y component of a vector that defines the direction {@link PhysicsConstraintPose#getGravity()} is applied. */
|
||||
/** The y component of a vector that defines the direction {@link PhysicsConstraintPose#gravity} is applied. */
|
||||
public float getGravityY () {
|
||||
return gravityY;
|
||||
}
|
||||
|
||||
@ -186,7 +186,7 @@ public class Skin {
|
||||
hashCode = placeholderName.hashCode() + slotIndex * 37;
|
||||
}
|
||||
|
||||
/** The {@link Skeleton#getSlots()} index. */
|
||||
/** The {@link Skeleton#slots} index. */
|
||||
public int getSlotIndex () {
|
||||
return slotIndex;
|
||||
}
|
||||
|
||||
@ -56,7 +56,7 @@ public class SlotData extends PosedData<SlotPose> {
|
||||
return super.getName();
|
||||
}
|
||||
|
||||
/** The {@link Skeleton#getSlots()} index. */
|
||||
/** The {@link Skeleton#slots} index. */
|
||||
public int getIndex () {
|
||||
return index;
|
||||
}
|
||||
|
||||
@ -59,8 +59,8 @@ public class SlotPose implements Pose<SlotPose> {
|
||||
deform.addAll(pose.deform);
|
||||
}
|
||||
|
||||
/** The color used to tint the slot's attachment. If {@link #getDarkColor()} is set, this is used as the light color for two
|
||||
* color tinting. */
|
||||
/** The color used to tint the slot's attachment. If {@link #darkColor} is set, this is used as the light color for two color
|
||||
* tinting. */
|
||||
public Color getColor () {
|
||||
return color;
|
||||
}
|
||||
|
||||
@ -58,7 +58,7 @@ public class AtlasAttachmentLoader implements AttachmentLoader {
|
||||
this.allowMissingRegions = allowMissingRegions;
|
||||
}
|
||||
|
||||
/** Sets each {@link Sequence#getRegions()} by calling {@link #findRegion(String, String)} for each texture region using
|
||||
/** Sets each {@link Sequence#regions} by calling {@link #findRegion(String, String)} for each texture region using
|
||||
* {@link Sequence#getPath(String, int)}. */
|
||||
protected void findRegions (String name, String basePath, Sequence sequence) {
|
||||
TextureRegion[] regions = sequence.getRegions();
|
||||
|
||||
@ -35,8 +35,8 @@ import com.badlogic.gdx.graphics.g2d.TextureRegion;
|
||||
|
||||
import com.esotericsoftware.spine.SlotPose;
|
||||
|
||||
/** Holds texture regions, UVs, and vertex offsets for rendering a region or mesh attachment. {@link #getRegions() Regions} must
|
||||
* be populated and {@link #update(HasSequence)} called before use. */
|
||||
/** Holds texture regions, UVs, and vertex offsets for rendering a region or mesh attachment. {@link #regions Regions} must be
|
||||
* populated and {@link #update(HasSequence)} called before use. */
|
||||
public class Sequence {
|
||||
static private int nextID;
|
||||
|
||||
@ -103,7 +103,7 @@ public class Sequence {
|
||||
return regions;
|
||||
}
|
||||
|
||||
/** Returns the {@link #getRegions()} index for the {@link SlotPose#getSequenceIndex()}. */
|
||||
/** Returns the {@link #regions} index for the {@link SlotPose#getSequenceIndex()}. */
|
||||
public int resolveIndex (SlotPose pose) {
|
||||
int index = pose.getSequenceIndex();
|
||||
if (index == -1) index = setupIndex;
|
||||
@ -111,13 +111,13 @@ public class Sequence {
|
||||
return index;
|
||||
}
|
||||
|
||||
/** Returns the texture region from {@link #getRegions()} for the specified index. */
|
||||
/** Returns the texture region from {@link #regions} for the specified index. */
|
||||
public TextureRegion getRegion (int index) {
|
||||
return regions[index];
|
||||
}
|
||||
|
||||
/** Returns the UVs for the specified index. {@link #getRegions() Regions} must be populated and {@link #update(HasSequence)}
|
||||
* called before calling this method. */
|
||||
/** Returns the UVs for the specified index. {@link #regions Regions} must be populated and {@link #update(HasSequence)} called
|
||||
* before calling this method. */
|
||||
public float[] getUVs (int index) {
|
||||
return uvs[index];
|
||||
}
|
||||
@ -181,7 +181,7 @@ public class Sequence {
|
||||
return nextID++;
|
||||
}
|
||||
|
||||
/** Controls how {@link Sequence#getRegions()} are displayed over time. */
|
||||
/** Controls how {@link Sequence#regions} are displayed over time. */
|
||||
static public enum SequenceMode {
|
||||
hold, once, loop, pingpong, onceReverse, loopReverse, pingpongReverse;
|
||||
|
||||
|
||||
@ -73,13 +73,13 @@ abstract public class VertexAttachment extends Attachment {
|
||||
worldVerticesLength = other.worldVerticesLength;
|
||||
}
|
||||
|
||||
/** Transforms the attachment's local {@link #getVertices()} to world coordinates. If {@link SlotPose#getDeform()} is not
|
||||
* empty, it is used to deform the vertices.
|
||||
/** Transforms the attachment's local {@link #vertices} to world coordinates. If {@link SlotPose#getDeform()} is not empty, it
|
||||
* is used to deform the vertices.
|
||||
* <p>
|
||||
* See <a href="https://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
|
||||
* Runtimes Guide.
|
||||
* @param start The index of the first {@link #getVertices()} value to transform. Each vertex has 2 values, x and y.
|
||||
* @param count The number of world vertex values to output. Must be <= {@link #getWorldVerticesLength()} - <code>start</code>.
|
||||
* @param start The index of the first {@link #vertices} value to transform. Each vertex has 2 values, x and y.
|
||||
* @param count The number of world vertex values to output. Must be <= {@link #worldVerticesLength} - <code>start</code>.
|
||||
* @param worldVertices The output world vertices. Must have a length >= <code>offset</code> + <code>count</code> *
|
||||
* <code>stride</code> / 2.
|
||||
* @param offset The <code>worldVertices</code> index to begin writing values.
|
||||
@ -142,9 +142,8 @@ abstract public class VertexAttachment extends Attachment {
|
||||
}
|
||||
}
|
||||
|
||||
/** The bones that affect the {@link #getVertices()}. The entries are, for each vertex, the number of bones affecting the
|
||||
* vertex followed by that many bone indices, which is {@link Skeleton#getBones()} index. Null if this attachment has no
|
||||
* weights. */
|
||||
/** The bones that affect the {@link #vertices}. The entries are, for each vertex, the number of bones affecting the vertex
|
||||
* followed by that many bone indices, which is {@link Skeleton#getBones()} index. Null if this attachment has no weights. */
|
||||
public @Null int[] getBones () {
|
||||
return bones;
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user