UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-02-04 14:24:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

* Added separate X and Y for transform constraint translate and scale mix.

Browse Source 
* Renamed `xxxMix` to `mixXxx` to avoid names like `scaleXMix`.
This commit is contained in:
Nathan Sweet 2020-11-14 18:59:42 -08:00
parent 391917d37b
commit dbd90caa53
13 changed files with 331 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/Animation.java
View File

@ -188,7 +188,7 @@ public class Animation {
}
static private enum Property {
rotate, translateX, translateY, scaleX, scaleY, shearX, shearY, //
rotate, x, y, scaleX, scaleY, shearX, shearY, //
rgb, alpha, rgb2, //
attachment, deform, //
event, drawOrder, //
@ -316,7 +316,7 @@ public class Animation {
* @param bezier The ordinal of this Bezier curve for this timeline, between 0 and <code>bezierCount - 1</code> (specified
* in the constructor), inclusive.
* @param frame Between 0 and <code>frameCount - 1</code>, inclusive.
* @param value The index of the value for this frame that this curve is used for.
* @param value The index of the value for the frame this curve is used for.
* @param time1 The time for the first key.
* @param value1 The value for the first key.
* @param cx1 The time for the first Bezier handle.
@ -494,8 +494,8 @@ public class Animation {
public TranslateTimeline (int frameCount, int bezierCount, int boneIndex) {
super(frameCount, bezierCount, //
Property.translateX.ordinal() + "|" + boneIndex, //
Property.translateY.ordinal() + "|" + boneIndex);
Property.x.ordinal() + "|" + boneIndex, //
Property.y.ordinal() + "|" + boneIndex);
this.boneIndex = boneIndex;
}
@ -565,7 +565,7 @@ public class Animation {
final int boneIndex;
public TranslateXTimeline (int frameCount, int bezierCount, int boneIndex) {
super(frameCount, bezierCount, Property.translateX.ordinal() + "|" + boneIndex);
super(frameCount, bezierCount, Property.x.ordinal() + "|" + boneIndex);
this.boneIndex = boneIndex;
}
@ -611,7 +611,7 @@ public class Animation {
final int boneIndex;
public TranslateYTimeline (int frameCount, int bezierCount, int boneIndex) {
super(frameCount, bezierCount, Property.translateY.ordinal() + "|" + boneIndex);
super(frameCount, bezierCount, Property.y.ordinal() + "|" + boneIndex);
this.boneIndex = boneIndex;
}
@ -2109,11 +2109,12 @@ public class Animation {
}
}
/** Changes a transform constraint's {@link TransformConstraint#getRotateMix()}, {@link TransformConstraint#getTranslateMix()},
* {@link TransformConstraint#getScaleMix()}, and {@link TransformConstraint#getShearMix()}. */
/** Changes a transform constraint's {@link TransformConstraint#getMixRotate()}, {@link TransformConstraint#getMixX()},
* {@link TransformConstraint#getMixY()}, {@link TransformConstraint#getMixScaleX()},
* {@link TransformConstraint#getMixScaleY()}, and {@link TransformConstraint#getMixShearY()}. */
static public class TransformConstraintTimeline extends CurveTimeline {
static public final int ENTRIES = 5;
static private final int ROTATE = 1, TRANSLATE = 2, SCALE = 3, SHEAR = 4;
static public final int ENTRIES = 7;
static private final int ROTATE = 1, X = 2, Y = 3, SCALEX = 4, SCALEY = 5, SHEARY = 6;
final int transformConstraintIndex;
@ -2135,13 +2136,16 @@ public class Animation {
/** Sets the time, rotate mix, translate mix, scale mix, and shear mix for the specified frame.
* @param frame Between 0 and <code>frameCount</code>, inclusive.
* @param time The frame time in seconds. */
public void setFrame (int frame, float time, float rotateMix, float translateMix, float scaleMix, float shearMix) {
public void setFrame (int frame, float time, float mixRotate, float mixX, float mixY, float mixScaleX, float mixScaleY,
float mixShearY) {
frame *= ENTRIES;
frames[frame] = time;
frames[frame + ROTATE] = rotateMix;
frames[frame + TRANSLATE] = translateMix;
frames[frame + SCALE] = scaleMix;
frames[frame + SHEAR] = shearMix;
frames[frame + ROTATE] = mixRotate;
frames[frame + X] = mixX;
frames[frame + Y] = mixY;
frames[frame + SCALEX] = mixScaleX;
frames[frame + SCALEY] = mixScaleY;
frames[frame + SHEARY] = mixShearY;
}
public void apply (Skeleton skeleton, float lastTime, float time, @Null Array<Event> events, float alpha, MixBlend blend,
@ -2155,59 +2159,75 @@ public class Animation {
TransformConstraintData data = constraint.data;
switch (blend) {
case setup:
constraint.rotateMix = data.rotateMix;
constraint.translateMix = data.translateMix;
constraint.scaleMix = data.scaleMix;
constraint.shearMix = data.shearMix;
constraint.mixRotate = data.mixRotate;
constraint.mixX = data.mixX;
constraint.mixY = data.mixY;
constraint.mixScaleX = data.mixScaleX;
constraint.mixScaleY = data.mixScaleY;
constraint.mixShearY = data.mixShearY;
return;
case first:
constraint.rotateMix += (data.rotateMix - constraint.rotateMix) * alpha;
constraint.translateMix += (data.translateMix - constraint.translateMix) * alpha;
constraint.scaleMix += (data.scaleMix - constraint.scaleMix) * alpha;
constraint.shearMix += (data.shearMix - constraint.shearMix) * alpha;
constraint.mixRotate += (data.mixRotate - constraint.mixRotate) * alpha;
constraint.mixX += (data.mixX - constraint.mixX) * alpha;
constraint.mixY += (data.mixY - constraint.mixY) * alpha;
constraint.mixScaleX += (data.mixScaleX - constraint.mixScaleX) * alpha;
constraint.mixScaleY += (data.mixScaleY - constraint.mixScaleY) * alpha;
constraint.mixShearY += (data.mixShearY - constraint.mixShearY) * alpha;
}
return;
}
float rotate, translate, scale, shear;
float rotate, x, y, scaleX, scaleY, shearY;
int i = search(frames, time, ENTRIES), curveType = (int)curves[i / ENTRIES];
switch (curveType) {
case LINEAR:
float before = frames[i];
rotate = frames[i + ROTATE];
translate = frames[i + TRANSLATE];
scale = frames[i + SCALE];
shear = frames[i + SHEAR];
x = frames[i + X];
y = frames[i + Y];
scaleX = frames[i + SCALEX];
scaleY = frames[i + SCALEY];
shearY = frames[i + SHEARY];
float t = (time - before) / (frames[i + ENTRIES] - before);
rotate += (frames[i + ENTRIES + ROTATE] - rotate) * t;
translate += (frames[i + ENTRIES + TRANSLATE] - translate) * t;
scale += (frames[i + ENTRIES + SCALE] - scale) * t;
shear += (frames[i + ENTRIES + SHEAR] - shear) * t;
x += (frames[i + ENTRIES + X] - x) * t;
y += (frames[i + ENTRIES + Y] - y) * t;
scaleX += (frames[i + ENTRIES + SCALEX] - scaleX) * t;
scaleY += (frames[i + ENTRIES + SCALEY] - scaleY) * t;
shearY += (frames[i + ENTRIES + SHEARY] - shearY) * t;
break;
case STEPPED:
rotate = frames[i + ROTATE];
translate = frames[i + TRANSLATE];
scale = frames[i + SCALE];
shear = frames[i + SHEAR];
x = frames[i + X];
y = frames[i + Y];
scaleX = frames[i + SCALEX];
scaleY = frames[i + SCALEY];
shearY = frames[i + SHEARY];
break;
default:
rotate = getBezierValue(time, i, ROTATE, curveType - BEZIER);
translate = getBezierValue(time, i, TRANSLATE, curveType + BEZIER_SIZE - BEZIER);
scale = getBezierValue(time, i, TRANSLATE, curveType + BEZIER_SIZE * 2 - BEZIER);
shear = getBezierValue(time, i, TRANSLATE, curveType + BEZIER_SIZE * 3 - BEZIER);
x = getBezierValue(time, i, X, curveType + BEZIER_SIZE - BEZIER);
y = getBezierValue(time, i, Y, curveType + BEZIER_SIZE * 2 - BEZIER);
scaleX = getBezierValue(time, i, SCALEX, curveType + BEZIER_SIZE * 3 - BEZIER);
scaleY = getBezierValue(time, i, SCALEY, curveType + BEZIER_SIZE * 4 - BEZIER);
shearY = getBezierValue(time, i, SHEARY, curveType + BEZIER_SIZE * 5 - BEZIER);
}
if (blend == setup) {
TransformConstraintData data = constraint.data;
constraint.rotateMix = data.rotateMix + (rotate - data.rotateMix) * alpha;
constraint.translateMix = data.translateMix + (translate - data.translateMix) * alpha;
constraint.scaleMix = data.scaleMix + (scale - data.scaleMix) * alpha;
constraint.shearMix = data.shearMix + (shear - data.shearMix) * alpha;
constraint.mixRotate = data.mixRotate + (rotate - data.mixRotate) * alpha;
constraint.mixX = data.mixX + (x - data.mixX) * alpha;
constraint.mixY = data.mixY + (y - data.mixY) * alpha;
constraint.mixScaleX = data.mixScaleX + (scaleX - data.mixScaleX) * alpha;
constraint.mixScaleY = data.mixScaleY + (scaleY - data.mixScaleY) * alpha;
constraint.mixShearY = data.mixShearY + (shearY - data.mixShearY) * alpha;
} else {
constraint.rotateMix += (rotate - constraint.rotateMix) * alpha;
constraint.translateMix += (translate - constraint.translateMix) * alpha;
constraint.scaleMix += (scale - constraint.scaleMix) * alpha;
constraint.shearMix += (shear - constraint.shearMix) * alpha;
constraint.mixRotate += (rotate - constraint.mixRotate) * alpha;
constraint.mixX += (x - constraint.mixX) * alpha;
constraint.mixY += (y - constraint.mixY) * alpha;
constraint.mixScaleX += (scaleX - constraint.mixScaleX) * alpha;
constraint.mixScaleY += (scaleY - constraint.mixScaleY) * alpha;
constraint.mixShearY += (shearY - constraint.mixShearY) * alpha;
}
}
}
@ -2292,8 +2312,7 @@ public class Animation {
}
}
/** Changes a transform constraint's {@link PathConstraint#getRotateMix()} and
* {@link TransformConstraint#getTranslateMix()}. */
/** Changes a transform constraint's {@link PathConstraint#getMixRotate()} and {@link PathConstraint#getMixTranslate()}. */
static public class PathConstraintMixTimeline extends CurveTimeline2 {
final int pathConstraintIndex;
@ -2318,12 +2337,12 @@ public class Animation {
if (time < frames[0]) { // Time is before first frame.
switch (blend) {
case setup:
constraint.rotateMix = constraint.data.rotateMix;
constraint.translateMix = constraint.data.translateMix;
constraint.mixRotate = constraint.data.mixRotate;
constraint.mixTranslate = constraint.data.mixTranslate;
return;
case first:
constraint.rotateMix += (constraint.data.rotateMix - constraint.rotateMix) * alpha;
constraint.translateMix += (constraint.data.translateMix - constraint.translateMix) * alpha;
constraint.mixRotate += (constraint.data.mixRotate - constraint.mixRotate) * alpha;
constraint.mixTranslate += (constraint.data.mixTranslate - constraint.mixTranslate) * alpha;
}
return;
}
@ -2349,11 +2368,11 @@ public class Animation {
}
if (blend == setup) {
constraint.rotateMix = constraint.data.rotateMix + (rotate - constraint.data.rotateMix) * alpha;
constraint.translateMix = constraint.data.translateMix + (translate - constraint.data.translateMix) * alpha;
constraint.mixRotate = constraint.data.mixRotate + (rotate - constraint.data.mixRotate) * alpha;
constraint.mixTranslate = constraint.data.mixTranslate + (translate - constraint.data.mixTranslate) * alpha;
} else {
constraint.rotateMix += (rotate - constraint.rotateMix) * alpha;
constraint.translateMix += (translate - constraint.translateMix) * alpha;
constraint.mixRotate += (rotate - constraint.mixRotate) * alpha;
constraint.mixTranslate += (translate - constraint.mixTranslate) * alpha;
}
}
}

2
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/IkConstraint.java
View File

@ -109,7 +109,7 @@ public class IkConstraint implements Updatable {
this.target = target;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotation. */
public float getMix () {
return mix;
}

2
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/IkConstraintData.java
View File

@ -60,7 +60,7 @@ public class IkConstraintData extends ConstraintData {
this.target = target;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotation. */
public float getMix () {
return mix;
}

46
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/PathConstraint.java
View File

@ -50,7 +50,7 @@ public class PathConstraint implements Updatable {
final PathConstraintData data;
final Array<Bone> bones;
Slot target;
float position, spacing, rotateMix, translateMix;
float position, spacing, mixRotate, mixTranslate;
boolean active;
@ -68,8 +68,8 @@ public class PathConstraint implements Updatable {
target = skeleton.findSlot(data.target.name);
position = data.position;
spacing = data.spacing;
rotateMix = data.rotateMix;
translateMix = data.translateMix;
mixRotate = data.mixRotate;
mixTranslate = data.mixTranslate;
}
/** Copy constructor. */
@ -83,8 +83,8 @@ public class PathConstraint implements Updatable {
target = skeleton.slots.get(constraint.target.data.index);
position = constraint.position;
spacing = constraint.spacing;
rotateMix = constraint.rotateMix;
translateMix = constraint.translateMix;
mixRotate = constraint.mixRotate;
mixTranslate = constraint.mixTranslate;
}
/** Applies the constraint to the constrained bones. */
@ -92,8 +92,8 @@ public class PathConstraint implements Updatable {
Attachment attachment = target.attachment;
if (!(attachment instanceof PathAttachment)) return;
float rotateMix = this.rotateMix, translateMix = this.translateMix;
boolean translate = translateMix > 0, rotate = rotateMix > 0;
float mixRotate = this.mixRotate, mixTranslate = this.mixTranslate;
boolean translate = mixTranslate > 0, rotate = mixRotate > 0;
if (!translate && !rotate) return;
PathConstraintData data = this.data;
@ -145,13 +145,13 @@ public class PathConstraint implements Updatable {
}
for (int i = 0, p = 3; i < boneCount; i++, p += 3) {
Bone bone = (Bone)bones[i];
bone.worldX += (boneX - bone.worldX) * translateMix;
bone.worldY += (boneY - bone.worldY) * translateMix;
bone.worldX += (boneX - bone.worldX) * mixTranslate;
bone.worldY += (boneY - bone.worldY) * mixTranslate;
float x = positions[p], y = positions[p + 1], dx = x - boneX, dy = y - boneY;
if (scale) {
float length = lengths[i];
if (length >= epsilon) {
float s = ((float)Math.sqrt(dx * dx + dy * dy) / length - 1) * rotateMix + 1;
float s = ((float)Math.sqrt(dx * dx + dy * dy) / length - 1) * mixRotate + 1;
bone.a *= s;
bone.c *= s;
}
@ -171,15 +171,15 @@ public class PathConstraint implements Updatable {
cos = (float)Math.cos(r);
sin = (float)Math.sin(r);
float length = bone.data.length;
boneX += (length * (cos * a - sin * c) - dx) * rotateMix;
boneY += (length * (sin * a + cos * c) - dy) * rotateMix;
boneX += (length * (cos * a - sin * c) - dx) * mixRotate;
boneY += (length * (sin * a + cos * c) - dy) * mixRotate;
} else
r += offsetRotation;
if (r > SpineUtils.PI)
r -= SpineUtils.PI2;
else if (r < -SpineUtils.PI) //
r += SpineUtils.PI2;
r *= rotateMix;
r *= mixRotate;
cos = (float)Math.cos(r);
sin = (float)Math.sin(r);
bone.a = cos * a - sin * c;
@ -464,22 +464,22 @@ public class PathConstraint implements Updatable {
this.spacing = spacing;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
public float getRotateMix () {
return rotateMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotation. */
public float getMixRotate () {
return mixRotate;
}
public void setRotateMix (float rotateMix) {
this.rotateMix = rotateMix;
public void setMixRotate (float mixRotate) {
this.mixRotate = mixRotate;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained translations. */
public float getTranslateMix () {
return translateMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained translation. */
public float getMixTranslate () {
return mixTranslate;
}
public void setTranslateMix (float translateMix) {
this.translateMix = translateMix;
public void setMixTranslate (float mixTranslate) {
this.mixTranslate = mixTranslate;
}
/** The bones that will be modified by this path constraint. */

22
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/PathConstraintData.java
View File

@ -41,7 +41,7 @@ public class PathConstraintData extends ConstraintData {
SpacingMode spacingMode;
RotateMode rotateMode;
float offsetRotation;
float position, spacing, rotateMix, translateMix;
float position, spacing, mixRotate, mixTranslate;
public PathConstraintData (String name) {
super(name);
@ -119,22 +119,22 @@ public class PathConstraintData extends ConstraintData {
this.spacing = spacing;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
public float getRotateMix () {
return rotateMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotation. */
public float getMixRotate () {
return mixRotate;
}
public void setRotateMix (float rotateMix) {
this.rotateMix = rotateMix;
public void setMixRotate (float mixRotate) {
this.mixRotate = mixRotate;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained translations. */
public float getTranslateMix () {
return translateMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained translation. */
public float getMixTranslate () {
return mixTranslate;
}
public void setTranslateMix (float translateMix) {
this.translateMix = translateMix;
public void setMixTranslate (float mixTranslate) {
this.mixTranslate = mixTranslate;
}
/** Controls how the first bone is positioned along the path.

14
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/Skeleton.java
View File

@ -405,10 +405,12 @@ public class Skeleton {
for (int i = 0, n = this.transformConstraints.size; i < n; i++) {
TransformConstraint constraint = (TransformConstraint)transformConstraints[i];
TransformConstraintData data = constraint.data;
constraint.rotateMix = data.rotateMix;
constraint.translateMix = data.translateMix;
constraint.scaleMix = data.scaleMix;
constraint.shearMix = data.shearMix;
constraint.mixRotate = data.mixRotate;
constraint.mixX = data.mixX;
constraint.mixY = data.mixY;
constraint.mixScaleX = data.mixScaleX;
constraint.mixScaleY = data.mixScaleY;
constraint.mixShearY = data.mixShearY;
}
Object[] pathConstraints = this.pathConstraints.items;
@ -417,8 +419,8 @@ public class Skeleton {
PathConstraintData data = constraint.data;
constraint.position = data.position;
constraint.spacing = data.spacing;
constraint.rotateMix = data.rotateMix;
constraint.translateMix = data.translateMix;
constraint.mixRotate = data.mixRotate;
constraint.mixTranslate = data.mixTranslate;
}
}

44
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/SkeletonBinary.java
View File

@ -239,10 +239,12 @@ public class SkeletonBinary extends SkeletonLoader {
data.offsetScaleX = input.readFloat();
data.offsetScaleY = input.readFloat();
data.offsetShearY = input.readFloat();
data.rotateMix = input.readFloat();
data.translateMix = input.readFloat();
data.scaleMix = input.readFloat();
data.shearMix = input.readFloat();
data.mixRotate = input.readFloat();
data.mixX = input.readFloat();
data.mixY = input.readFloat();
data.mixScaleX = input.readFloat();
data.mixScaleY = input.readFloat();
data.mixShearY = input.readFloat();
o[i] = data;
}
@ -264,8 +266,8 @@ public class SkeletonBinary extends SkeletonLoader {
if (data.positionMode == PositionMode.fixed) data.position *= scale;
data.spacing = input.readFloat();
if (data.spacingMode == SpacingMode.length || data.spacingMode == SpacingMode.fixed) data.spacing *= scale;
data.rotateMix = input.readFloat();
data.translateMix = input.readFloat();
data.mixRotate = input.readFloat();
data.mixTranslate = input.readFloat();
o[i] = data;
}
@ -810,28 +812,32 @@ public class SkeletonBinary extends SkeletonLoader {
for (int i = 0, n = input.readInt(true); i < n; i++) {
int index = input.readInt(true), frameCount = input.readInt(true), frameLast = frameCount - 1;
TransformConstraintTimeline timeline = new TransformConstraintTimeline(frameCount, input.readInt(true), index);
float time = input.readFloat(), rotateMix = input.readFloat(), translateMix = input.readFloat(),
scaleMix = input.readFloat(), shearMix = input.readFloat();
float time = input.readFloat(), mixRotate = input.readFloat(), mixX = input.readFloat(), mixY = input.readFloat(),
mixScaleX = input.readFloat(), mixScaleY = input.readFloat(), mixShearY = input.readFloat();
for (int frame = 0, bezier = 0;; frame++) {
timeline.setFrame(frame, time, rotateMix, translateMix, scaleMix, shearMix);
timeline.setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY);
if (frame == frameLast) break;
float time2 = input.readFloat(), rotateMix2 = input.readFloat(), translateMix2 = input.readFloat(),
scaleMix2 = input.readFloat(), shearMix2 = input.readFloat();
float time2 = input.readFloat(), mixRotate2 = input.readFloat(), mixX2 = input.readFloat(), mixY2 = input.readFloat(),
mixScaleX2 = input.readFloat(), mixScaleY2 = input.readFloat(), mixShearY2 = input.readFloat();
switch (input.readByte()) {
case CURVE_STEPPED:
timeline.setStepped(frame);
break;
case CURVE_BEZIER:
setBezier(input, timeline, bezier++, frame, 0, time, time2, rotateMix, rotateMix2, 1);
setBezier(input, timeline, bezier++, frame, 1, time, time2, translateMix, translateMix2, 1);
setBezier(input, timeline, bezier++, frame, 2, time, time2, scaleMix, scaleMix2, 1);
setBezier(input, timeline, bezier++, frame, 3, time, time2, shearMix, shearMix2, 1);
setBezier(input, timeline, bezier++, frame, 0, time, time2, mixRotate, mixRotate2, 1);
setBezier(input, timeline, bezier++, frame, 1, time, time2, mixX, mixX2, 1);
setBezier(input, timeline, bezier++, frame, 2, time, time2, mixY, mixY2, 1);
setBezier(input, timeline, bezier++, frame, 3, time, time2, mixScaleX, mixScaleX2, 1);
setBezier(input, timeline, bezier++, frame, 4, time, time2, mixScaleY, mixScaleY2, 1);
setBezier(input, timeline, bezier++, frame, 5, time, time2, mixShearY, mixShearY2, 1);
}
time = time2;
rotateMix = rotateMix2;
translateMix = translateMix2;
scaleMix = scaleMix2;
shearMix = shearMix2;
mixRotate = mixRotate2;
mixX = mixX2;
mixY = mixY2;
mixScaleX = mixScaleX2;
mixScaleY = mixScaleY2;
mixShearY = mixShearY2;
}
timelines.add(timeline);
}

2
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/SkeletonBounds.java
View File

@ -57,7 +57,7 @@ public class SkeletonBounds {
if (skeleton == null) throw new IllegalArgumentException("skeleton cannot be null.");
Array<BoundingBoxAttachment> boundingBoxes = this.boundingBoxes;
Array<FloatArray> polygons = this.polygons;
Object[] slots = skeleton.slots.items;
Object[] slots = skeleton.slots.items;
int slotCount = skeleton.slots.size;
boundingBoxes.clear();

48
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/SkeletonJson.java
View File

@ -226,10 +226,12 @@ public class SkeletonJson extends SkeletonLoader {
data.offsetScaleY = constraintMap.getFloat("scaleY", 0);
data.offsetShearY = constraintMap.getFloat("shearY", 0);
data.rotateMix = constraintMap.getFloat("rotateMix", 1);
data.translateMix = constraintMap.getFloat("translateMix", 1);
data.scaleMix = constraintMap.getFloat("scaleMix", 1);
data.shearMix = constraintMap.getFloat("shearMix", 1);
data.mixRotate = constraintMap.getFloat("mixRotate", 1);
data.mixX = constraintMap.getFloat("mixX", 1);
data.mixY = constraintMap.getFloat("mixY", data.mixX);
data.mixScaleX = constraintMap.getFloat("mixScaleX", 1);
data.mixScaleY = constraintMap.getFloat("mixScaleY", data.mixScaleX);
data.mixShearY = constraintMap.getFloat("mixShearY", 1);
skeletonData.transformConstraints.add(data);
}
@ -258,8 +260,8 @@ public class SkeletonJson extends SkeletonLoader {
if (data.positionMode == PositionMode.fixed) data.position *= scale;
data.spacing = constraintMap.getFloat("spacing", 0);
if (data.spacingMode == SpacingMode.length || data.spacingMode == SpacingMode.fixed) data.spacing *= scale;
data.rotateMix = constraintMap.getFloat("rotateMix", 1);
data.translateMix = constraintMap.getFloat("translateMix", 1);
data.mixRotate = constraintMap.getFloat("mixRotate", 1);
data.mixTranslate = constraintMap.getFloat("mixTranslate", 1);
skeletonData.pathConstraints.add(data);
}
@ -765,30 +767,36 @@ public class SkeletonJson extends SkeletonLoader {
TransformConstraintTimeline timeline = new TransformConstraintTimeline(timelineMap.size, timelineMap.size << 2,
skeletonData.getTransformConstraints().indexOf(constraint, true));
float time = keyMap.getFloat("time", 0);
float rotateMix = keyMap.getFloat("rotateMix", 1), translateMix = keyMap.getFloat("translateMix", 1);
float scaleMix = keyMap.getFloat("scaleMix", 1), shearMix = keyMap.getFloat("shearMix", 1);
float mixRotate = keyMap.getFloat("mixRotate", 1), mixShearY = keyMap.getFloat("mixShearY", 1);
float mixX = keyMap.getFloat("mixX", 1), mixY = keyMap.getFloat("mixY", mixX);
float mixScaleX = keyMap.getFloat("mixScaleX", 1), mixScaleY = keyMap.getFloat("mixScaleY", mixScaleX);
for (int frame = 0, bezier = 0;; frame++) {
timeline.setFrame(frame, time, rotateMix, translateMix, scaleMix, shearMix);
timeline.setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY);
JsonValue nextMap = keyMap.next;
if (nextMap == null) {
timeline.shrink(bezier);
break;
}
float time2 = nextMap.getFloat("time", 0);
float rotateMix2 = nextMap.getFloat("rotateMix", 1), translateMix2 = nextMap.getFloat("translateMix", 1);
float scaleMix2 = nextMap.getFloat("scaleMix", 1), shearMix2 = nextMap.getFloat("shearMix", 1);
float mixRotate2 = nextMap.getFloat("mixRotate", 1), mixShearY2 = nextMap.getFloat("mixShearY", 1);
float mixX2 = nextMap.getFloat("mixX", 1), mixY2 = nextMap.getFloat("mixY", mixX2);
float mixScaleX2 = nextMap.getFloat("mixScaleX", 1), mixScaleY2 = nextMap.getFloat("mixScaleY", mixScaleX2);
JsonValue curve = keyMap.get("curve");
if (curve != null) {
bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, rotateMix, rotateMix2, 1);
bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, translateMix, translateMix2, 1);
bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, scaleMix, scaleMix2, 1);
bezier = readCurve(curve, timeline, bezier, frame, 3, time, time2, shearMix, shearMix2, 1);
bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, mixRotate, mixRotate2, 1);
bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, mixX, mixX2, 1);
bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, mixY, mixY2, 1);
bezier = readCurve(curve, timeline, bezier, frame, 3, time, time2, mixScaleX, mixScaleX2, 1);
bezier = readCurve(curve, timeline, bezier, frame, 4, time, time2, mixScaleY, mixScaleY2, 1);
bezier = readCurve(curve, timeline, bezier, frame, 5, time, time2, mixShearY, mixShearY2, 1);
}
time = time2;
rotateMix = rotateMix2;
translateMix = translateMix2;
scaleMix = scaleMix2;
shearMix = shearMix2;
mixRotate = mixRotate2;
mixX = mixX2;
mixY = mixY2;
mixScaleX = mixScaleX2;
mixScaleY = mixScaleY2;
mixScaleX = mixScaleX2;
keyMap = nextMap;
}
timelines.add(timeline);
@ -812,7 +820,7 @@ public class SkeletonJson extends SkeletonLoader {
data.spacingMode == SpacingMode.length || data.spacingMode == SpacingMode.fixed ? scale : 1));
} else if (timelineName.equals("mix")) {
CurveTimeline2 timeline = new PathConstraintMixTimeline(timelineMap.size, timelineMap.size << 1, index);
timelines.add(readTimeline(keyMap, timeline, "rotateMix", "translateMix", 1, 1));
timelines.add(readTimeline(keyMap, timeline, "mixRotate", "mixTranslate", 1, 1));
}
}
}

207
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/TransformConstraint.java
View File

@ -42,7 +42,7 @@ public class TransformConstraint implements Updatable {
final TransformConstraintData data;
final Array<Bone> bones;
Bone target;
float rotateMix, translateMix, scaleMix, shearMix;
float mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY;
boolean active;
final Vector2 temp = new Vector2();
@ -51,10 +51,12 @@ public class TransformConstraint implements Updatable {
if (data == null) throw new IllegalArgumentException("data cannot be null.");
if (skeleton == null) throw new IllegalArgumentException("skeleton cannot be null.");
this.data = data;
rotateMix = data.rotateMix;
translateMix = data.translateMix;
scaleMix = data.scaleMix;
shearMix = data.shearMix;
mixRotate = data.mixRotate;
mixX = data.mixX;
mixY = data.mixY;
mixScaleX = data.mixScaleX;
mixScaleY = data.mixScaleY;
mixShearY = data.mixShearY;
bones = new Array(data.bones.size);
for (BoneData boneData : data.bones)
bones.add(skeleton.findBone(boneData.name));
@ -70,15 +72,17 @@ public class TransformConstraint implements Updatable {
for (Bone bone : constraint.bones)
bones.add(skeleton.bones.get(bone.data.index));
target = skeleton.bones.get(constraint.target.data.index);
rotateMix = constraint.rotateMix;
translateMix = constraint.translateMix;
scaleMix = constraint.scaleMix;
shearMix = constraint.shearMix;
mixRotate = constraint.mixRotate;
mixX = constraint.mixX;
mixY = constraint.mixY;
mixScaleX = constraint.mixScaleX;
mixScaleY = constraint.mixScaleY;
mixShearY = constraint.mixShearY;
}
/** Applies the constraint to the constrained bones. */
public void update () {
if (rotateMix == 0 && translateMix == 0 && scaleMix == 0 && shearMix == 0) return;
if (mixRotate == 0 && mixX == 0 && mixY == 0 && mixScaleX == 0 && mixScaleX == 0 && mixShearY == 0) return;
if (data.local) {
if (data.relative)
applyRelativeLocal();
@ -93,22 +97,27 @@ public class TransformConstraint implements Updatable {
}
private void applyAbsoluteWorld () {
float rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
float mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;
boolean translate = mixX != 0 || mixY != 0;
Bone target = this.target;
float ta = target.a, tb = target.b, tc = target.c, td = target.d;
float degRadReflect = ta * td - tb * tc > 0 ? degRad : -degRad;
float offsetRotation = data.offsetRotation * degRadReflect, offsetShearY = data.offsetShearY * degRadReflect;
Object[] bones = this.bones.items;
for (int i = 0, n = this.bones.size; i < n; i++) {
Bone bone = (Bone)bones[i];
if (rotateMix != 0) {
if (mixRotate != 0) {
float a = bone.a, b = bone.b, c = bone.c, d = bone.d;
float r = atan2(tc, ta) - atan2(c, a) + offsetRotation;
if (r > PI)
r -= PI2;
else if (r < -PI) r += PI2;
r *= rotateMix;
else if (r < -PI) //
r += PI2;
r *= mixRotate;
float cos = cos(r), sin = sin(r);
bone.a = cos * a - sin * c;
bone.b = cos * b - sin * d;
@ -116,32 +125,35 @@ public class TransformConstraint implements Updatable {
bone.d = sin * b + cos * d;
}
if (translateMix != 0) {
if (translate) {
Vector2 temp = this.temp;
target.localToWorld(temp.set(data.offsetX, data.offsetY));
bone.worldX += (temp.x - bone.worldX) * translateMix;
bone.worldY += (temp.y - bone.worldY) * translateMix;
bone.worldX += (temp.x - bone.worldX) * mixX;
bone.worldY += (temp.y - bone.worldY) * mixY;
}
if (scaleMix > 0) {
if (mixScaleX != 0) {
float s = (float)Math.sqrt(bone.a * bone.a + bone.c * bone.c);
if (s != 0) s = (s + ((float)Math.sqrt(ta * ta + tc * tc) - s + data.offsetScaleX) * scaleMix) / s;
if (s != 0) s = (s + ((float)Math.sqrt(ta * ta + tc * tc) - s + data.offsetScaleX) * mixScaleX) / s;
bone.a *= s;
bone.c *= s;
s = (float)Math.sqrt(bone.b * bone.b + bone.d * bone.d);
if (s != 0) s = (s + ((float)Math.sqrt(tb * tb + td * td) - s + data.offsetScaleY) * scaleMix) / s;
}
if (mixScaleY != 0) {
float s = (float)Math.sqrt(bone.b * bone.b + bone.d * bone.d);
if (s != 0) s = (s + ((float)Math.sqrt(tb * tb + td * td) - s + data.offsetScaleY) * mixScaleY) / s;
bone.b *= s;
bone.d *= s;
}
if (shearMix > 0) {
if (mixShearY > 0) {
float b = bone.b, d = bone.d;
float by = atan2(d, b);
float r = atan2(td, tb) - atan2(tc, ta) - (by - atan2(bone.c, bone.a));
if (r > PI)
r -= PI2;
else if (r < -PI) r += PI2;
r = by + (r + offsetShearY) * shearMix;
else if (r < -PI) //
r += PI2;
r = by + (r + offsetShearY) * mixShearY;
float s = (float)Math.sqrt(b * b + d * d);
bone.b = cos(r) * s;
bone.d = sin(r) * s;
@ -152,22 +164,27 @@ public class TransformConstraint implements Updatable {
}
private void applyRelativeWorld () {
float rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
float mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;
boolean translate = mixX != 0 || mixY != 0;
Bone target = this.target;
float ta = target.a, tb = target.b, tc = target.c, td = target.d;
float degRadReflect = ta * td - tb * tc > 0 ? degRad : -degRad;
float offsetRotation = data.offsetRotation * degRadReflect, offsetShearY = data.offsetShearY * degRadReflect;
Object[] bones = this.bones.items;
for (int i = 0, n = this.bones.size; i < n; i++) {
Bone bone = (Bone)bones[i];
if (rotateMix != 0) {
if (mixRotate != 0) {
float a = bone.a, b = bone.b, c = bone.c, d = bone.d;
float r = atan2(tc, ta) + offsetRotation;
if (r > PI)
r -= PI2;
else if (r < -PI) r += PI2;
r *= rotateMix;
else if (r < -PI) //
r += PI2;
r *= mixRotate;
float cos = cos(r), sin = sin(r);
bone.a = cos * a - sin * c;
bone.b = cos * b - sin * d;
@ -175,29 +192,32 @@ public class TransformConstraint implements Updatable {
bone.d = sin * b + cos * d;
}
if (translateMix != 0) {
if (translate) {
Vector2 temp = this.temp;
target.localToWorld(temp.set(data.offsetX, data.offsetY));
bone.worldX += temp.x * translateMix;
bone.worldY += temp.y * translateMix;
bone.worldX += temp.x * mixX;
bone.worldY += temp.y * mixY;
}
if (scaleMix > 0) {
float s = ((float)Math.sqrt(ta * ta + tc * tc) - 1 + data.offsetScaleX) * scaleMix + 1;
if (mixScaleX != 0) {
float s = ((float)Math.sqrt(ta * ta + tc * tc) - 1 + data.offsetScaleX) * mixScaleX + 1;
bone.a *= s;
bone.c *= s;
s = ((float)Math.sqrt(tb * tb + td * td) - 1 + data.offsetScaleY) * scaleMix + 1;
}
if (mixScaleY != 0) {
float s = ((float)Math.sqrt(tb * tb + td * td) - 1 + data.offsetScaleY) * mixScaleY + 1;
bone.b *= s;
bone.d *= s;
}
if (shearMix > 0) {
if (mixShearY > 0) {
float r = atan2(td, tb) - atan2(tc, ta);
if (r > PI)
r -= PI2;
else if (r < -PI) r += PI2;
else if (r < -PI) //
r += PI2;
float b = bone.b, d = bone.d;
r = atan2(d, b) + (r - PI / 2 + offsetShearY) * shearMix;
r = atan2(d, b) + (r - PI / 2 + offsetShearY) * mixShearY;
float s = (float)Math.sqrt(b * b + d * d);
bone.b = cos(r) * s;
bone.d = sin(r) * s;
@ -208,38 +228,39 @@ public class TransformConstraint implements Updatable {
}
private void applyAbsoluteLocal () {
float rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
float mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;
Bone target = this.target;
if (!target.appliedValid) target.updateAppliedTransform();
Object[] bones = this.bones.items;
for (int i = 0, n = this.bones.size; i < n; i++) {
Bone bone = (Bone)bones[i];
if (!bone.appliedValid) bone.updateAppliedTransform();
float rotation = bone.arotation;
if (rotateMix != 0) {
if (mixRotate != 0) {
float r = target.arotation - rotation + data.offsetRotation;
r -= (16384 - (int)(16384.499999999996 - r / 360)) * 360;
rotation += r * rotateMix;
rotation += r * mixRotate;
}
float x = bone.ax, y = bone.ay;
if (translateMix != 0) {
x += (target.ax - x + data.offsetX) * translateMix;
y += (target.ay - y + data.offsetY) * translateMix;
}
x += (target.ax - x + data.offsetX) * mixX;
y += (target.ay - y + data.offsetY) * mixY;
float scaleX = bone.ascaleX, scaleY = bone.ascaleY;
if (scaleMix != 0) {
if (scaleX != 0) scaleX = (scaleX + (target.ascaleX - scaleX + data.offsetScaleX) * scaleMix) / scaleX;
if (scaleY != 0) scaleY = (scaleY + (target.ascaleY - scaleY + data.offsetScaleY) * scaleMix) / scaleY;
}
if (mixScaleX != 0 && scaleX != 0)
scaleX = (scaleX + (target.ascaleX - scaleX + data.offsetScaleX) * mixScaleX) / scaleX;
if (mixScaleY != 0 && scaleY != 0)
scaleY = (scaleY + (target.ascaleY - scaleY + data.offsetScaleY) * mixScaleY) / scaleY;
float shearY = bone.ashearY;
if (shearMix != 0) {
if (mixShearY != 0) {
float r = target.ashearY - shearY + data.offsetShearY;
r -= (16384 - (int)(16384.499999999996 - r / 360)) * 360;
shearY += r * shearMix;
shearY += r * mixShearY;
}
bone.updateWorldTransform(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
@ -247,31 +268,23 @@ public class TransformConstraint implements Updatable {
}
private void applyRelativeLocal () {
float rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
float mixRotate = this.mixRotate, mixX = this.mixX, mixY = this.mixY, mixScaleX = this.mixScaleX,
mixScaleY = this.mixScaleY, mixShearY = this.mixShearY;
Bone target = this.target;
if (!target.appliedValid) target.updateAppliedTransform();
Object[] bones = this.bones.items;
for (int i = 0, n = this.bones.size; i < n; i++) {
Bone bone = (Bone)bones[i];
if (!bone.appliedValid) bone.updateAppliedTransform();
float rotation = bone.arotation;
if (rotateMix != 0) rotation += (target.arotation + data.offsetRotation) * rotateMix;
float x = bone.ax, y = bone.ay;
if (translateMix != 0) {
x += (target.ax + data.offsetX) * translateMix;
y += (target.ay + data.offsetY) * translateMix;
}
float scaleX = bone.ascaleX, scaleY = bone.ascaleY;
if (scaleMix != 0) {
scaleX *= ((target.ascaleX - 1 + data.offsetScaleX) * scaleMix) + 1;
scaleY *= ((target.ascaleY - 1 + data.offsetScaleY) * scaleMix) + 1;
}
float shearY = bone.ashearY;
if (shearMix != 0) shearY += (target.ashearY + data.offsetShearY) * shearMix;
float rotation = bone.arotation + (target.arotation + data.offsetRotation) * mixRotate;
float x = bone.ax + (target.ax + data.offsetX) * mixX;
float y = bone.ay + (target.ay + data.offsetY) * mixY;
float scaleX = (bone.ascaleX * ((target.ascaleX - 1 + data.offsetScaleX) * mixScaleX) + 1);
float scaleY = (bone.ascaleY * ((target.ascaleY - 1 + data.offsetScaleY) * mixScaleY) + 1);
float shearY = bone.ashearY + (target.ashearY + data.offsetShearY) * mixShearY;
bone.updateWorldTransform(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
}
@ -292,40 +305,58 @@ public class TransformConstraint implements Updatable {
this.target = target;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
public float getRotateMix () {
return rotateMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotation. */
public float getMixRotate () {
return mixRotate;
}
public void setRotateMix (float rotateMix) {
this.rotateMix = rotateMix;
public void setMixRotate (float mixRotate) {
this.mixRotate = mixRotate;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained translations. */
public float getTranslateMix () {
return translateMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained translation X. */
public float getMixX () {
return mixX;
}
public void setTranslateMix (float translateMix) {
this.translateMix = translateMix;
public void setMixX (float mixX) {
this.mixX = mixX;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained scales. */
public float getScaleMix () {
return scaleMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained translation Y. */
public float getMixY () {
return mixY;
}
public void setScaleMix (float scaleMix) {
this.scaleMix = scaleMix;
public void setMixY (float mixY) {
this.mixY = mixY;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained scales. */
public float getShearMix () {
return shearMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained scale X. */
public float getMixScaleX () {
return mixScaleX;
}
public void setShearMix (float shearMix) {
this.shearMix = shearMix;
public void setMixScaleX (float mixScaleX) {
this.mixScaleX = mixScaleX;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained scale X. */
public float getMixScaleY () {
return mixScaleY;
}
public void setMixScaleY (float mixScaleY) {
this.mixScaleY = mixScaleY;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained shear Y. */
public float getMixShearY () {
return mixShearY;
}
public void setMixShearY (float mixShearY) {
this.mixShearY = mixShearY;
}
public boolean isActive () {

60
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/TransformConstraintData.java
View File

@ -37,7 +37,7 @@ import com.badlogic.gdx.utils.Array;
public class TransformConstraintData extends ConstraintData {
final Array<BoneData> bones = new Array();
BoneData target;
float rotateMix, translateMix, scaleMix, shearMix;
float mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY;
float offsetRotation, offsetX, offsetY, offsetScaleX, offsetScaleY, offsetShearY;
boolean relative, local;
@ -60,40 +60,58 @@ public class TransformConstraintData extends ConstraintData {
this.target = target;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
public float getRotateMix () {
return rotateMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained rotation. */
public float getMixRotate () {
return mixRotate;
}
public void setRotateMix (float rotateMix) {
this.rotateMix = rotateMix;
public void setMixRotate (float mixRotate) {
this.mixRotate = mixRotate;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained translations. */
public float getTranslateMix () {
return translateMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained translation X. */
public float getMixX () {
return mixX;
}
public void setTranslateMix (float translateMix) {
this.translateMix = translateMix;
public void setMixX (float mixX) {
this.mixX = mixX;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained scales. */
public float getScaleMix () {
return scaleMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained translation Y. */
public float getMixY () {
return mixY;
}
public void setScaleMix (float scaleMix) {
this.scaleMix = scaleMix;
public void setMixY (float mixY) {
this.mixY = mixY;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained shears. */
public float getShearMix () {
return shearMix;
/** A percentage (0-1) that controls the mix between the constrained and unconstrained scale X. */
public float getMixScaleX () {
return mixScaleX;
}
public void setShearMix (float shearMix) {
this.shearMix = shearMix;
public void setMixScaleX (float mixScaleX) {
this.mixScaleX = mixScaleX;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained scale Y. */
public float getMixScaleY () {
return mixScaleY;
}
public void setMixScaleY (float mixScaleY) {
this.mixScaleY = mixScaleY;
}
/** A percentage (0-1) that controls the mix between the constrained and unconstrained shear Y. */
public float getMixShearY () {
return mixShearY;
}
public void setMixShearY (float mixShearY) {
this.mixShearY = mixShearY;
}
/** An offset added to the constrained bone rotation. */

1
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/vertexeffects/JitterEffect.java
View File

@ -32,6 +32,7 @@ package com.esotericsoftware.spine.vertexeffects;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Vector2;
import com.esotericsoftware.spine.Skeleton;
import com.esotericsoftware.spine.SkeletonRenderer.VertexEffect;

1
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/vertexeffects/SwirlEffect.java
View File

@ -33,6 +33,7 @@ import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.math.Interpolation;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Vector2;
import com.esotericsoftware.spine.Skeleton;
import com.esotericsoftware.spine.SkeletonRenderer.VertexEffect;
import com.esotericsoftware.spine.utils.SpineUtils;