mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2025-12-21 01:36:02 +08:00
303 lines
9.9 KiB
C#
303 lines
9.9 KiB
C#
/******************************************************************************
|
|
* Spine Runtimes License Agreement
|
|
* Last updated April 5, 2025. Replaces all prior versions.
|
|
*
|
|
* Copyright (c) 2013-2025, Esoteric Software LLC
|
|
*
|
|
* Integration of the Spine Runtimes into software or otherwise creating
|
|
* derivative works of the Spine Runtimes is permitted under the terms and
|
|
* conditions of Section 2 of the Spine Editor License Agreement:
|
|
* http://esotericsoftware.com/spine-editor-license
|
|
*
|
|
* Otherwise, it is permitted to integrate the Spine Runtimes into software
|
|
* or otherwise create derivative works of the Spine Runtimes (collectively,
|
|
* "Products"), provided that each user of the Products must obtain their own
|
|
* Spine Editor license and redistribution of the Products in any form must
|
|
* include this license and copyright notice.
|
|
*
|
|
* THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
|
|
* BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*****************************************************************************/
|
|
|
|
using System;
|
|
|
|
namespace Spine {
|
|
|
|
/// <summary>
|
|
/// Stores the current pose for a physics constraint. A physics constraint applies physics to bones.
|
|
/// <para>
|
|
/// See <a href="http://esotericsoftware.com/spine-physics-constraints">Physics constraints</a> in the Spine User Guide.</para>
|
|
/// </summary>
|
|
public class PhysicsConstraint : Constraint<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> {
|
|
internal BonePose bone;
|
|
|
|
bool reset = true;
|
|
float ux, uy, cx, cy, tx, ty;
|
|
float xOffset, xLag, xVelocity;
|
|
float yOffset, yLag, yVelocity;
|
|
float rotateOffset, rotateLag, rotateVelocity;
|
|
float scaleOffset, scaleLag, scaleVelocity;
|
|
|
|
float remaining, lastTime;
|
|
|
|
public PhysicsConstraint (PhysicsConstraintData data, Skeleton skeleton)
|
|
: base(data, new PhysicsConstraintPose(), new PhysicsConstraintPose()) {
|
|
if (skeleton == null) throw new ArgumentNullException("skeleton", "skeleton cannot be null.");
|
|
|
|
bone = skeleton.bones.Items[data.bone.index].constrained;
|
|
}
|
|
|
|
override public IConstraint Copy (Skeleton skeleton) {
|
|
var copy = new PhysicsConstraint(data, skeleton);
|
|
copy.pose.Set(pose);
|
|
return copy;
|
|
}
|
|
|
|
public void Reset (Skeleton skeleton) {
|
|
remaining = 0;
|
|
lastTime = skeleton.time;
|
|
reset = true;
|
|
xOffset = 0;
|
|
xLag = 0;
|
|
xVelocity = 0;
|
|
yOffset = 0;
|
|
yLag = 0;
|
|
yVelocity = 0;
|
|
rotateOffset = 0;
|
|
rotateLag = 0;
|
|
rotateVelocity = 0;
|
|
scaleOffset = 0;
|
|
scaleLag = 0;
|
|
scaleVelocity = 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Translates the physics constraint so next <see cref="Update(Skeleton, Physics)"/> forces are applied as if the bone moved an
|
|
/// additional amount in world space.
|
|
/// </summary>
|
|
public void Translate (float x, float y) {
|
|
ux -= x;
|
|
uy -= y;
|
|
cx -= x;
|
|
cy -= y;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Rotates the physics constraint so next <see cref="Update(Skeleton, Physics)"/> forces are applied as if the bone rotated around
|
|
/// the specified point in world space.
|
|
/// </summary>
|
|
public void Rotate (float x, float y, float degrees) {
|
|
float r = degrees * MathUtils.DegRad, cos = (float)Math.Cos(r), sin = (float)Math.Sin(r);
|
|
float dx = cx - x, dy = cy - y;
|
|
Translate(dx * cos - dy * sin - dx, dx * sin + dy * cos - dy);
|
|
}
|
|
|
|
/// <summary>Applies the constraint to the constrained bones.</summary>
|
|
override public void Update (Skeleton skeleton, Physics physics) {
|
|
PhysicsConstraintPose p = applied;
|
|
float mix = p.mix;
|
|
if (mix == 0) return;
|
|
|
|
bool x = data.x > 0, y = data.y > 0, rotateOrShearX = data.rotate > 0 || data.shearX > 0, scaleX = data.scaleX > 0;
|
|
BonePose bone = this.bone;
|
|
float l = bone.bone.data.length, t = data.step, z = 0;
|
|
|
|
switch (physics) {
|
|
case Physics.None:
|
|
return;
|
|
case Physics.Reset:
|
|
Reset(skeleton);
|
|
goto case Physics.Update; // Fall through.
|
|
case Physics.Update:
|
|
float delta = Math.Max(skeleton.time - lastTime, 0), aa = remaining;
|
|
remaining += delta;
|
|
lastTime = skeleton.time;
|
|
|
|
float bx = bone.worldX, by = bone.worldY;
|
|
if (reset) {
|
|
reset = false;
|
|
ux = bx;
|
|
uy = by;
|
|
} else {
|
|
float a = remaining, i = p.inertia, f = skeleton.data.referenceScale, d = -1, m = 0, e = 0, qx = data.limit * delta,
|
|
qy = qx * Math.Abs(skeleton.ScaleY);
|
|
qx *= Math.Abs(skeleton.ScaleX);
|
|
|
|
if (x || y) {
|
|
if (x) {
|
|
float u = (ux - bx) * i;
|
|
xOffset += u > qx ? qx : u < -qx ? -qx : u;
|
|
ux = bx;
|
|
}
|
|
if (y) {
|
|
float u = (uy - by) * i;
|
|
yOffset += u > qy ? qy : u < -qy ? -qy : u;
|
|
uy = by;
|
|
}
|
|
if (a >= t) {
|
|
float xs = xOffset, ys = yOffset;
|
|
d = (float)Math.Pow(p.damping, 60 * t);
|
|
m = t * p.massInverse;
|
|
e = p.strength;
|
|
float w = f * p.wind, g = f * p.gravity;
|
|
float ax = (w * skeleton.windX + g * skeleton.gravityX) * skeleton.scaleX;
|
|
float ay = (w * skeleton.windY + g * skeleton.gravityY) * skeleton.ScaleY;
|
|
do {
|
|
if (x) {
|
|
xVelocity += (ax - xOffset * e) * m;
|
|
xOffset += xVelocity * t;
|
|
xVelocity *= d;
|
|
}
|
|
if (y) {
|
|
yVelocity -= (ay + yOffset * e) * m;
|
|
yOffset += yVelocity * t;
|
|
yVelocity *= d;
|
|
}
|
|
a -= t;
|
|
} while (a >= t);
|
|
xLag = xOffset - xs;
|
|
yLag = yOffset - ys;
|
|
}
|
|
z = Math.Max(0, 1 - a / t);
|
|
if (x) bone.worldX += (xOffset - xLag * z) * mix * data.x;
|
|
if (y) bone.worldY += (yOffset - yLag * z) * mix * data.y;
|
|
}
|
|
if (rotateOrShearX || scaleX) {
|
|
float ca = (float)Math.Atan2(bone.c, bone.a), c, s, mr = 0, dx = cx - bone.worldX, dy = cy - bone.worldY;
|
|
if (dx > qx)
|
|
dx = qx;
|
|
else if (dx < -qx)
|
|
dx = -qx;
|
|
if (dy > qy)
|
|
dy = qy;
|
|
else if (dy < -qy)
|
|
dy = -qy;
|
|
if (rotateOrShearX) {
|
|
mr = (data.rotate + data.shearX) * mix;
|
|
z = rotateLag * Math.Max(0, 1 - aa / t);
|
|
float r = (float)Math.Atan2(dy + ty, dx + tx) - ca - (rotateOffset - z) * mr;
|
|
rotateOffset += (r - (float)Math.Ceiling(r * MathUtils.InvPI2 - 0.5f) * MathUtils.PI2) * i;
|
|
r = (rotateOffset - z) * mr + ca;
|
|
c = (float)Math.Cos(r);
|
|
s = (float)Math.Sin(r);
|
|
if (scaleX) {
|
|
r = l * bone.WorldScaleX;
|
|
if (r > 0) scaleOffset += (dx * c + dy * s) * i / r;
|
|
}
|
|
} else {
|
|
c = (float)Math.Cos(ca);
|
|
s = (float)Math.Sin(ca);
|
|
float r = l * bone.WorldScaleX - scaleLag * Math.Max(0, 1 - aa / t);
|
|
if (r > 0) scaleOffset += (dx * c + dy * s) * i / r;
|
|
}
|
|
a = remaining;
|
|
if (a >= t) {
|
|
if (d == -1) {
|
|
d = (float)Math.Pow(p.damping, 60 * t);
|
|
m = t * p.massInverse;
|
|
e = p.strength;
|
|
}
|
|
float ax = p.wind * skeleton.windX + p.gravity * skeleton.gravityX;
|
|
float ay = p.wind * skeleton.windY + p.gravity * skeleton.gravityY;
|
|
float rs = rotateOffset, ss = scaleOffset, h = l / f;
|
|
if (Spine.Bone.yDown) ay = -ay;
|
|
while (true) {
|
|
a -= t;
|
|
if (scaleX) {
|
|
scaleVelocity += (ax * c - ay * s - scaleOffset * e) * m;
|
|
scaleOffset += scaleVelocity * t;
|
|
scaleVelocity *= d;
|
|
}
|
|
if (rotateOrShearX) {
|
|
rotateVelocity -= ((ax * s + ay * c) * h + rotateOffset * e) * m;
|
|
rotateOffset += rotateVelocity * t;
|
|
rotateVelocity *= d;
|
|
if (a < t) break;
|
|
float r = rotateOffset * mr + ca;
|
|
c = (float)Math.Cos(r);
|
|
s = (float)Math.Sin(r);
|
|
} else if (a < t) //
|
|
break;
|
|
}
|
|
rotateLag = rotateOffset - rs;
|
|
scaleLag = scaleOffset - ss;
|
|
}
|
|
z = Math.Max(0, 1 - a / t);
|
|
}
|
|
remaining = a;
|
|
}
|
|
cx = bone.worldX;
|
|
cy = bone.worldY;
|
|
break;
|
|
case Physics.Pose:
|
|
z = Math.Max(0, 1 - remaining / t);
|
|
if (x) bone.worldX += (xOffset - xLag * z) * mix * data.x;
|
|
if (y) bone.worldY += (yOffset - yLag * z) * mix * data.y;
|
|
break;
|
|
}
|
|
|
|
if (rotateOrShearX) {
|
|
float o = (rotateOffset - rotateLag * z) * mix, s, c, a;
|
|
if (data.shearX > 0) {
|
|
float r = 0;
|
|
if (data.rotate > 0) {
|
|
r = o * data.rotate;
|
|
s = (float)Math.Sin(r);
|
|
c = (float)Math.Cos(r);
|
|
a = bone.b;
|
|
bone.b = c * a - s * bone.d;
|
|
bone.d = s * a + c * bone.d;
|
|
}
|
|
r += o * data.shearX;
|
|
s = (float)Math.Sin(r);
|
|
c = (float)Math.Cos(r);
|
|
a = bone.a;
|
|
bone.a = c * a - s * bone.c;
|
|
bone.c = s * a + c * bone.c;
|
|
} else {
|
|
o *= data.rotate;
|
|
s = (float)Math.Sin(o);
|
|
c = (float)Math.Cos(o);
|
|
a = bone.a;
|
|
bone.a = c * a - s * bone.c;
|
|
bone.c = s * a + c * bone.c;
|
|
a = bone.b;
|
|
bone.b = c * a - s * bone.d;
|
|
bone.d = s * a + c * bone.d;
|
|
}
|
|
}
|
|
if (scaleX) {
|
|
float s = 1 + (scaleOffset - scaleLag * z) * mix * data.scaleX;
|
|
bone.a *= s;
|
|
bone.c *= s;
|
|
}
|
|
if (physics != Physics.Pose) {
|
|
tx = l * bone.a;
|
|
ty = l * bone.c;
|
|
}
|
|
bone.ModifyWorld(skeleton.update);
|
|
}
|
|
|
|
override public void Sort (Skeleton skeleton) {
|
|
Bone bone = this.bone.bone;
|
|
skeleton.SortBone(bone);
|
|
skeleton.updateCache.Add(this);
|
|
skeleton.SortReset(bone.children);
|
|
skeleton.Constrained(bone);
|
|
}
|
|
|
|
override public bool IsSourceActive { get { return bone.bone.active; } }
|
|
|
|
/// <summary>The bone constrained by this physics constraint.</summary>
|
|
public BonePose Bone { get { return bone; } set { bone = value; } }
|
|
}
|
|
}
|