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

Revert "[cpp] Add core pose classes for 4.3-beta architecture"

Browse Source 
This reverts commit c83a0ba84915799bc905c4f86cf436c24f4c8aec.

# Conflicts:
#	spine-cpp/spine-cpp/include/spine/spine.h
#	spine-cpp/spine-cpp/src/spine/BoneLocal.cpp
#	spine-cpp/spine-cpp/src/spine/BonePose.cpp
#	spine-cpp/spine-cpp/src/spine/SlotPose.cpp
This commit is contained in:
Mario Zechner 2025-06-05 20:01:32 +02:00
parent a9874c887c
commit 2692f4c684
6 changed files with 0 additions and 932 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
spine-cpp/spine-cpp/include/spine/BoneLocal.h
View File

@ -1,90 +0,0 @@
/******************************************************************************
* 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.
*****************************************************************************/
#ifndef Spine_BoneLocal_h
#define Spine_BoneLocal_h
#include <spine/Pose.h>
#include <spine/Inherit.h>
#include <spine/SpineObject.h>
namespace spine {
/// Stores a bone's local pose.
class SP_API BoneLocal : public SpineObject, public Pose<BoneLocal> {
public:
BoneLocal();
virtual ~BoneLocal();
virtual void set(const BoneLocal& pose) override;
/// The local x translation.
float getX() const;
void setX(float x);
/// The local y translation.
float getY() const;
void setY(float y);
void setPosition(float x, float y);
/// The local rotation in degrees, counter clockwise.
float getRotation() const;
void setRotation(float rotation);
/// The local scaleX.
float getScaleX() const;
void setScaleX(float scaleX);
/// The local scaleY.
float getScaleY() const;
void setScaleY(float scaleY);
void setScale(float scaleX, float scaleY);
void setScale(float scale);
/// The local shearX.
float getShearX() const;
void setShearX(float shearX);
/// The local shearY.
float getShearY() const;
void setShearY(float shearY);
/// Determines how parent world transforms affect this bone.
Inherit getInherit() const;
void setInherit(Inherit inherit);
protected:
float _x, _y, _rotation, _scaleX, _scaleY, _shearX, _shearY;
Inherit _inherit;
};
}
#endif /* Spine_BoneLocal_h */

143
spine-cpp/spine-cpp/include/spine/BonePose.h
View File

@ -1,143 +0,0 @@
/******************************************************************************
* 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.
*****************************************************************************/
#ifndef Spine_BonePose_h
#define Spine_BonePose_h
#include <spine/BoneLocal.h>
#include <spine/Update.h>
namespace spine {
class Bone;
class Skeleton;
/// The applied pose for a bone. This is the Bone pose with constraints applied and the world transform computed by
/// Skeleton::updateWorldTransform(Physics).
class SP_API BonePose : public BoneLocal, public Update {
public:
BonePose();
virtual ~BonePose();
/// Called by Skeleton::updateCache() to compute the world transform, if needed.
virtual void update(Skeleton& skeleton, Physics physics) override;
/// Computes the world transform using the parent bone's applied pose and this pose. Child bones are not updated.
///
/// See World transforms in the Spine Runtimes Guide.
void updateWorldTransform(Skeleton& skeleton);
/// Computes the local transform values from the world transform.
///
/// If the world transform is modified (by a constraint, rotateWorld(), etc) then this method should be called so
/// the local transform matches the world transform. The local transform may be needed by other code (eg to apply another
/// constraint).
///
/// Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. The local transform after
/// calling this method is equivalent to the local transform used to compute the world transform, but may not be identical.
void updateLocalTransform(Skeleton& skeleton);
/// If the world transform has been modified and the local transform no longer matches, updateLocalTransform(Skeleton)
/// is called.
void validateLocalTransform(Skeleton& skeleton);
/// Transforms a point from world coordinates to the bone's local coordinates.
void worldToLocal(float worldX, float worldY, float& outLocalX, float& outLocalY);
/// Transforms a point from the bone's local coordinates to world coordinates.
void localToWorld(float localX, float localY, float& outWorldX, float& outWorldY);
/// Transforms a point from world coordinates to the parent bone's local coordinates.
void worldToParent(float worldX, float worldY, float& outParentX, float& outParentY);
/// Transforms a point from the parent bone's coordinates to world coordinates.
void parentToWorld(float parentX, float parentY, float& outWorldX, float& outWorldY);
/// Transforms a world rotation to a local rotation.
float worldToLocalRotation(float worldRotation);
/// Transforms a local rotation to a world rotation.
float localToWorldRotation(float localRotation);
/// Rotates the world transform the specified amount.
///
/// After changes are made to the world transform, updateLocalTransform(Skeleton) should be called on this bone and any
/// child bones, recursively.
void rotateWorld(float degrees);
/// Part of the world transform matrix for the X axis. If changed, updateLocalTransform(Skeleton) should be called.
float getA() const;
void setA(float a);
/// Part of the world transform matrix for the Y axis. If changed, updateLocalTransform(Skeleton) should be called.
float getB() const;
void setB(float b);
/// Part of the world transform matrix for the X axis. If changed, updateLocalTransform(Skeleton) should be called.
float getC() const;
void setC(float c);
/// Part of the world transform matrix for the Y axis. If changed, updateLocalTransform(Skeleton) should be called.
float getD() const;
void setD(float d);
/// The world X position. If changed, updateLocalTransform(Skeleton) should be called.
float getWorldX() const;
void setWorldX(float worldX);
/// The world Y position. If changed, updateLocalTransform(Skeleton) should be called.
float getWorldY() const;
void setWorldY(float worldY);
/// The world rotation for the X axis, calculated using a and c.
float getWorldRotationX() const;
/// The world rotation for the Y axis, calculated using b and d.
float getWorldRotationY() const;
/// The magnitude (always positive) of the world scale X, calculated using a and c.
float getWorldScaleX() const;
/// The magnitude (always positive) of the world scale Y, calculated using b and d.
float getWorldScaleY() const;
private:
void modifyLocal(Skeleton& skeleton);
void modifyWorld(int update);
void resetWorld(int update);
public:
Bone* _bone;
float _a, _b, _worldX;
float _c, _d, _worldY;
int _world, _local;
};
}
#endif /* Spine_BonePose_h */

93
spine-cpp/spine-cpp/include/spine/SlotPose.h
View File

@ -1,93 +0,0 @@
/******************************************************************************
* 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.
*****************************************************************************/
#ifndef Spine_SlotPose_h
#define Spine_SlotPose_h
#include <spine/Pose.h>
#include <spine/SpineObject.h>
#include <spine/Color.h>
#include <spine/Vector.h>
namespace spine {
class Attachment;
class VertexAttachment;
/// Stores a slot's pose. Slots organize attachments for Skeleton drawOrder purposes and provide a place to store state
/// for an attachment. State cannot be stored in an attachment itself because attachments are stateless and may be shared across
/// multiple skeletons.
class SP_API SlotPose : public SpineObject, public Pose<SlotPose> {
public:
SlotPose();
virtual ~SlotPose();
virtual void set(const SlotPose& pose) override;
/// The color used to tint the slot's attachment. If hasDarkColor() is true, this is used as the light color for two
/// color tinting.
Color& getColor();
/// The dark color used to tint the slot's attachment for two color tinting. Only use if hasDarkColor() is true.
/// The dark color's alpha is not used.
Color& getDarkColor();
bool hasDarkColor();
void setHasDarkColor(bool hasDarkColor);
/// The current attachment for the slot, or null if the slot has no attachment.
Attachment* getAttachment();
/// Sets the slot's attachment and, if the attachment changed, resets sequenceIndex and clears the deform.
/// The deform is not cleared if the old attachment has the same VertexAttachment::getTimelineAttachment() as the
/// specified attachment.
void setAttachment(Attachment* attachment);
/// The index of the texture region to display when the slot's attachment has a Sequence. -1 represents the
/// Sequence::getSetupIndex().
int getSequenceIndex();
void setSequenceIndex(int sequenceIndex);
/// Values to deform the slot's attachment. For an unweighted mesh, the entries are local positions for each vertex. For a
/// weighted mesh, the entries are an offset for each vertex which will be added to the mesh's local vertex positions.
///
/// See VertexAttachment::computeWorldVertices and DeformTimeline.
Vector<float>& getDeform();
private:
Color _color;
Color _darkColor;
bool _hasDarkColor;
Attachment* _attachment;
int _sequenceIndex;
Vector<float> _deform;
};
}
#endif /* Spine_SlotPose_h */

128
spine-cpp/spine-cpp/src/spine/BoneLocal.cpp
View File

@ -1,128 +0,0 @@
/******************************************************************************
* 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.
*****************************************************************************/
#include <spine/BoneLocal.h>
using namespace spine;
BoneLocal::BoneLocal() : _x(0), _y(0), _rotation(0), _scaleX(1), _scaleY(1), _shearX(0), _shearY(0), _inherit(Inherit_Normal) {
}
BoneLocal::~BoneLocal() {
}
void BoneLocal::set(const BoneLocal &pose) {
_x = pose._x;
_y = pose._y;
_rotation = pose._rotation;
_scaleX = pose._scaleX;
_scaleY = pose._scaleY;
_shearX = pose._shearX;
_shearY = pose._shearY;
_inherit = pose._inherit;
}
float BoneLocal::getX() const {
return _x;
}
void BoneLocal::setX(float x) {
_x = x;
}
float BoneLocal::getY() const {
return _y;
}
void BoneLocal::setY(float y) {
_y = y;
}
void BoneLocal::setPosition(float x, float y) {
_x = x;
_y = y;
}
float BoneLocal::getRotation() const {
return _rotation;
}
void BoneLocal::setRotation(float rotation) {
_rotation = rotation;
}
float BoneLocal::getScaleX() const {
return _scaleX;
}
void BoneLocal::setScaleX(float scaleX) {
_scaleX = scaleX;
}
float BoneLocal::getScaleY() const {
return _scaleY;
}
void BoneLocal::setScaleY(float scaleY) {
_scaleY = scaleY;
}
void BoneLocal::setScale(float scaleX, float scaleY) {
_scaleX = scaleX;
_scaleY = scaleY;
}
void BoneLocal::setScale(float scale) {
_scaleX = scale;
_scaleY = scale;
}
float BoneLocal::getShearX() const {
return _shearX;
}
void BoneLocal::setShearX(float shearX) {
_shearX = shearX;
}
float BoneLocal::getShearY() const {
return _shearY;
}
void BoneLocal::setShearY(float shearY) {
_shearY = shearY;
}
Inherit BoneLocal::getInherit() const {
return _inherit;
}
void BoneLocal::setInherit(Inherit inherit) {
_inherit = inherit;
}

382
spine-cpp/spine-cpp/src/spine/BonePose.cpp
View File

@ -1,382 +0,0 @@
/******************************************************************************
* 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.
*****************************************************************************/
#include <spine/BonePose.h>
#include <spine/Bone.h>
#include <spine/Skeleton.h>
#include <spine/MathUtil.h>
using namespace spine;
BonePose::BonePose() : _bone(nullptr), _a(1), _b(0), _worldX(0), _c(0), _d(1), _worldY(0), _world(0), _local(0) {
}
BonePose::~BonePose() {
}
void BonePose::update(Skeleton &skeleton, Physics physics) {
if (_world != skeleton.getUpdate()) updateWorldTransform(skeleton);
}
void BonePose::updateWorldTransform(Skeleton &skeleton) {
if (_local == skeleton.getUpdate()) {
updateLocalTransform(skeleton);
} else {
_world = skeleton.getUpdate();
}
if (_bone->getParent() == nullptr) {
float sx = skeleton.getScaleX(), sy = skeleton.getScaleY();
float rx = (_rotation + _shearX) * MathUtil::Deg_Rad;
float ry = (_rotation + 90 + _shearY) * MathUtil::Deg_Rad;
_a = MathUtil::cos(rx) * _scaleX * sx;
_b = MathUtil::cos(ry) * _scaleY * sx;
_c = MathUtil::sin(rx) * _scaleX * sy;
_d = MathUtil::sin(ry) * _scaleY * sy;
_worldX = _x * sx + skeleton.getX();
_worldY = _y * sy + skeleton.getY();
return;
}
BonePose *parent = _bone->getParent()->getApplied();
float pa = parent->_a, pb = parent->_b, pc = parent->_c, pd = parent->_d;
_worldX = pa * _x + pb * _y + parent->_worldX;
_worldY = pc * _x + pd * _y + parent->_worldY;
switch (_inherit) {
case Inherit_Normal: {
float rx = (_rotation + _shearX) * MathUtil::Deg_Rad;
float ry = (_rotation + 90 + _shearY) * MathUtil::Deg_Rad;
float la = MathUtil::cos(rx) * _scaleX;
float lb = MathUtil::cos(ry) * _scaleY;
float lc = MathUtil::sin(rx) * _scaleX;
float ld = MathUtil::sin(ry) * _scaleY;
_a = pa * la + pb * lc;
_b = pa * lb + pb * ld;
_c = pc * la + pd * lc;
_d = pc * lb + pd * ld;
break;
}
case Inherit_OnlyTranslation: {
float rx = (_rotation + _shearX) * MathUtil::Deg_Rad;
float ry = (_rotation + 90 + _shearY) * MathUtil::Deg_Rad;
_a = MathUtil::cos(rx) * _scaleX;
_b = MathUtil::cos(ry) * _scaleY;
_c = MathUtil::sin(rx) * _scaleX;
_d = MathUtil::sin(ry) * _scaleY;
break;
}
case Inherit_NoRotationOrReflection: {
float sx = 1 / skeleton.getScaleX(), sy = 1 / skeleton.getScaleY();
pa *= sx;
pc *= sy;
float s = pa * pa + pc * pc, prx;
if (s > 0.0001f) {
s = MathUtil::abs(pa * pd * sy - pb * sx * pc) / s;
pb = pc * s;
pd = pa * s;
prx = MathUtil::atan2Deg(pc, pa);
} else {
pa = 0;
pc = 0;
prx = 90 - MathUtil::atan2Deg(pd, pb);
}
float rx = (_rotation + _shearX - prx) * MathUtil::Deg_Rad;
float ry = (_rotation + _shearY - prx + 90) * MathUtil::Deg_Rad;
float la = MathUtil::cos(rx) * _scaleX;
float lb = MathUtil::cos(ry) * _scaleY;
float lc = MathUtil::sin(rx) * _scaleX;
float ld = MathUtil::sin(ry) * _scaleY;
_a = pa * la - pb * lc;
_b = pa * lb - pb * ld;
_c = pc * la + pd * lc;
_d = pc * lb + pd * ld;
break;
}
case Inherit_NoScale:
case Inherit_NoScaleOrReflection: {
float rotation = _rotation * MathUtil::Deg_Rad;
float cosVal = MathUtil::cos(rotation), sinVal = MathUtil::sin(rotation);
float za = (pa * cosVal + pb * sinVal) / skeleton.getScaleX();
float zc = (pc * cosVal + pd * sinVal) / skeleton.getScaleY();
float s = MathUtil::sqrt(za * za + zc * zc);
if (s > 0.00001f) s = 1 / s;
za *= s;
zc *= s;
s = MathUtil::sqrt(za * za + zc * zc);
if (_inherit == Inherit_NoScale && (pa * pd - pb * pc < 0) != (skeleton.getScaleX() < 0 != skeleton.getScaleY() < 0)) s = -s;
rotation = MathUtil::Pi / 2 + MathUtil::atan2(zc, za);
float zb = MathUtil::cos(rotation) * s;
float zd = MathUtil::sin(rotation) * s;
float shearX = _shearX * MathUtil::Deg_Rad;
float shearY = (90 + _shearY) * MathUtil::Deg_Rad;
float la = MathUtil::cos(shearX) * _scaleX;
float lb = MathUtil::cos(shearY) * _scaleY;
float lc = MathUtil::sin(shearX) * _scaleX;
float ld = MathUtil::sin(shearY) * _scaleY;
_a = za * la + zb * lc;
_b = za * lb + zb * ld;
_c = zc * la + zd * lc;
_d = zc * lb + zd * ld;
break;
}
}
_a *= skeleton.getScaleX();
_b *= skeleton.getScaleX();
_c *= skeleton.getScaleY();
_d *= skeleton.getScaleY();
}
void BonePose::updateLocalTransform(Skeleton &skeleton) {
_local = 0;
_world = skeleton.getUpdate();
if (_bone->getParent() == nullptr) {
_x = _worldX - skeleton.getX();
_y = _worldY - skeleton.getY();
float a = _a, b = _b, c = _c, d = _d;
_rotation = MathUtil::atan2Deg(c, a);
_scaleX = MathUtil::sqrt(a * a + c * c);
_scaleY = MathUtil::sqrt(b * b + d * d);
_shearX = 0;
_shearY = MathUtil::atan2Deg(a * b + c * d, a * d - b * c);
return;
}
BonePose *parent = _bone->getParent()->getApplied();
float pa = parent->_a, pb = parent->_b, pc = parent->_c, pd = parent->_d;
float pid = 1 / (pa * pd - pb * pc);
float ia = pd * pid, ib = pb * pid, ic = pc * pid, id = pa * pid;
float dx = _worldX - parent->_worldX, dy = _worldY - parent->_worldY;
_x = (dx * ia - dy * ib);
_y = (dy * id - dx * ic);
float ra, rb, rc, rd;
if (_inherit == Inherit_OnlyTranslation) {
ra = _a;
rb = _b;
rc = _c;
rd = _d;
} else {
switch (_inherit) {
case Inherit_NoRotationOrReflection: {
float s = MathUtil::abs(pa * pd - pb * pc) / (pa * pa + pc * pc);
pb = -pc * skeleton.getScaleX() * s / skeleton.getScaleY();
pd = pa * skeleton.getScaleY() * s / skeleton.getScaleX();
pid = 1 / (pa * pd - pb * pc);
ia = pd * pid;
ib = pb * pid;
break;
}
case Inherit_NoScale:
case Inherit_NoScaleOrReflection: {
float r = _rotation * MathUtil::Deg_Rad, cosVal = MathUtil::cos(r), sinVal = MathUtil::sin(r);
pa = (pa * cosVal + pb * sinVal) / skeleton.getScaleX();
pc = (pc * cosVal + pd * sinVal) / skeleton.getScaleY();
float s = MathUtil::sqrt(pa * pa + pc * pc);
if (s > 0.00001f) s = 1 / s;
pa *= s;
pc *= s;
s = MathUtil::sqrt(pa * pa + pc * pc);
if (_inherit == Inherit_NoScale && pid < 0 != (skeleton.getScaleX() < 0 != skeleton.getScaleY() < 0)) s = -s;
r = MathUtil::Pi / 2 + MathUtil::atan2(pc, pa);
pb = MathUtil::cos(r) * s;
pd = MathUtil::sin(r) * s;
pid = 1 / (pa * pd - pb * pc);
ia = pd * pid;
ib = pb * pid;
ic = pc * pid;
id = pa * pid;
break;
}
}
ra = ia * _a - ib * _c;
rb = ia * _b - ib * _d;
rc = id * _c - ic * _a;
rd = id * _d - ic * _b;
}
_shearX = 0;
_scaleX = MathUtil::sqrt(ra * ra + rc * rc);
if (_scaleX > 0.0001f) {
float det = ra * rd - rb * rc;
_scaleY = det / _scaleX;
_shearY = -MathUtil::atan2Deg(ra * rb + rc * rd, det);
_rotation = MathUtil::atan2Deg(rc, ra);
} else {
_scaleX = 0;
_scaleY = MathUtil::sqrt(rb * rb + rd * rd);
_shearY = 0;
_rotation = 90 - MathUtil::atan2Deg(rd, rb);
}
}
void BonePose::validateLocalTransform(Skeleton &skeleton) {
if (_local == skeleton.getUpdate()) updateLocalTransform(skeleton);
}
void BonePose::modifyLocal(Skeleton &skeleton) {
if (_local == skeleton.getUpdate()) updateLocalTransform(skeleton);
_world = 0;
resetWorld(skeleton.getUpdate());
}
void BonePose::modifyWorld(int update) {
_local = update;
_world = update;
resetWorld(update);
}
void BonePose::resetWorld(int update) {
Vector<Bone *> &children = _bone->getChildren();
for (int i = 0, n = children.size(); i < n; i++) {
BonePose *child = children[i]->getApplied();
if (child->_world == update) {
child->_world = 0;
child->_local = 0;
child->resetWorld(update);
}
}
}
void BonePose::worldToLocal(float worldX, float worldY, float &outLocalX, float &outLocalY) {
float det = _a * _d - _b * _c;
float x = worldX - _worldX, y = worldY - _worldY;
outLocalX = (x * _d - y * _b) / det;
outLocalY = (y * _a - x * _c) / det;
}
void BonePose::localToWorld(float localX, float localY, float &outWorldX, float &outWorldY) {
outWorldX = localX * _a + localY * _b + _worldX;
outWorldY = localX * _c + localY * _d + _worldY;
}
void BonePose::worldToParent(float worldX, float worldY, float &outParentX, float &outParentY) {
if (_bone == nullptr || _bone->getParent() == nullptr) {
outParentX = worldX;
outParentY = worldY;
return;
}
_bone->getParent()->getApplied()->worldToLocal(worldX, worldY, outParentX, outParentY);
}
void BonePose::parentToWorld(float parentX, float parentY, float &outWorldX, float &outWorldY) {
if (_bone == nullptr || _bone->getParent() == nullptr) {
outWorldX = parentX;
outWorldY = parentY;
return;
}
_bone->getParent()->getApplied()->localToWorld(parentX, parentY, outWorldX, outWorldY);
}
float BonePose::worldToLocalRotation(float worldRotation) {
worldRotation *= MathUtil::Deg_Rad;
float sinVal = MathUtil::sin(worldRotation), cosVal = MathUtil::cos(worldRotation);
return MathUtil::atan2Deg(_a * sinVal - _c * cosVal, _d * cosVal - _b * sinVal) + _rotation - _shearX;
}
float BonePose::localToWorldRotation(float localRotation) {
localRotation = (localRotation - _rotation - _shearX) * MathUtil::Deg_Rad;
float sinVal = MathUtil::sin(localRotation), cosVal = MathUtil::cos(localRotation);
return MathUtil::atan2Deg(cosVal * _c + sinVal * _d, cosVal * _a + sinVal * _b);
}
void BonePose::rotateWorld(float degrees) {
degrees *= MathUtil::Deg_Rad;
float sinVal = MathUtil::sin(degrees), cosVal = MathUtil::cos(degrees);
float ra = _a, rb = _b;
_a = cosVal * ra - sinVal * _c;
_b = cosVal * rb - sinVal * _d;
_c = sinVal * ra + cosVal * _c;
_d = sinVal * rb + cosVal * _d;
}
float BonePose::getA() const {
return _a;
}
void BonePose::setA(float a) {
_a = a;
}
float BonePose::getB() const {
return _b;
}
void BonePose::setB(float b) {
_b = b;
}
float BonePose::getC() const {
return _c;
}
void BonePose::setC(float c) {
_c = c;
}
float BonePose::getD() const {
return _d;
}
void BonePose::setD(float d) {
_d = d;
}
float BonePose::getWorldX() const {
return _worldX;
}
void BonePose::setWorldX(float worldX) {
_worldX = worldX;
}
float BonePose::getWorldY() const {
return _worldY;
}
void BonePose::setWorldY(float worldY) {
_worldY = worldY;
}
float BonePose::getWorldRotationX() const {
return MathUtil::atan2Deg(_c, _a);
}
float BonePose::getWorldRotationY() const {
return MathUtil::atan2Deg(_d, _b);
}
float BonePose::getWorldScaleX() const {
return MathUtil::sqrt(_a * _a + _c * _c);
}
float BonePose::getWorldScaleY() const {
return MathUtil::sqrt(_b * _b + _d * _d);
}

96
spine-cpp/spine-cpp/src/spine/SlotPose.cpp
View File

@ -1,96 +0,0 @@
/******************************************************************************
* 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.
*****************************************************************************/
#include <spine/SlotPose.h>
#include <spine/Attachment.h>
#include <spine/VertexAttachment.h>
using namespace spine;
SlotPose::SlotPose() : _color(1, 1, 1, 1), _darkColor(0, 0, 0, 1), _hasDarkColor(false), _attachment(nullptr), _sequenceIndex(-1) {
}
SlotPose::~SlotPose() {
}
void SlotPose::set(const SlotPose &pose) {
_color.set(pose._color);
if (_hasDarkColor) _darkColor.set(pose._darkColor);
_hasDarkColor = pose._hasDarkColor;
_attachment = pose._attachment;
_sequenceIndex = pose._sequenceIndex;
_deform.clear();
_deform.addAll(pose._deform);
}
Color &SlotPose::getColor() {
return _color;
}
Color &SlotPose::getDarkColor() {
return _darkColor;
}
bool SlotPose::hasDarkColor() {
return _hasDarkColor;
}
void SlotPose::setHasDarkColor(bool hasDarkColor) {
_hasDarkColor = hasDarkColor;
}
Attachment *SlotPose::getAttachment() {
return _attachment;
}
void SlotPose::setAttachment(Attachment *attachment) {
if (_attachment == attachment) return;
if (attachment == nullptr || _attachment == nullptr ||
!attachment->getRTTI().instanceOf(VertexAttachment::rtti) ||
!_attachment->getRTTI().instanceOf(VertexAttachment::rtti) ||
((VertexAttachment *) attachment)->getTimelineAttachment() != ((VertexAttachment *) _attachment)->getTimelineAttachment()) {
_deform.clear();
}
_attachment = attachment;
_sequenceIndex = -1;
}
int SlotPose::getSequenceIndex() {
return _sequenceIndex;
}
void SlotPose::setSequenceIndex(int sequenceIndex) {
_sequenceIndex = sequenceIndex;
}
Vector<float> &SlotPose::getDeform() {
return _deform;
}