diff --git a/spine-cpp/spine-cpp/include/spine/BoneData.h b/spine-cpp/spine-cpp/include/spine/BoneData.h index bedcbacd6..2fa58a24e 100644 --- a/spine-cpp/spine-cpp/include/spine/BoneData.h +++ b/spine-cpp/spine-cpp/include/spine/BoneData.h @@ -84,7 +84,7 @@ namespace spine { void setIcon(const String &icon); - bool isVisible(); + bool getVisible(); void setVisible(bool inValue); diff --git a/spine-cpp/spine-cpp/include/spine/IkConstraintData.h b/spine-cpp/spine-cpp/include/spine/IkConstraintData.h index 2d953d4c4..f64561d9e 100644 --- a/spine-cpp/spine-cpp/include/spine/IkConstraintData.h +++ b/spine-cpp/spine-cpp/include/spine/IkConstraintData.h @@ -34,11 +34,13 @@ #include #include #include +#include namespace spine { class BoneData; + class IkConstraint; - class SP_API IkConstraintData : public ConstraintData { + class SP_API IkConstraintData : public ConstraintData { friend class SkeletonBinary; friend class SkeletonJson; @@ -62,40 +64,15 @@ namespace spine { void setTarget(BoneData *inValue); - /// Controls the bend direction of the IK bones, either 1 or -1. - int getBendDirection(); - - void setBendDirection(int inValue); - - bool getCompress(); - - void setCompress(bool inValue); - - bool getStretch(); - - void setStretch(bool inValue); - + /// When true and IkConstraintPose compress or stretch is used, the bone is scaled on both the X and Y axes. bool getUniform(); - void setUniform(bool inValue); - - float getMix(); - - void setMix(float inValue); - - float getSoftness(); - - void setSoftness(float inValue); + void setUniform(bool uniform); private: Vector _bones; BoneData *_target; - int _bendDirection; - bool _compress; - bool _stretch; bool _uniform; - float _mix; - float _softness; }; } diff --git a/spine-cpp/spine-cpp/include/spine/PathConstraintData.h b/spine-cpp/spine-cpp/include/spine/PathConstraintData.h index d6a1771bf..ae91cd52a 100644 --- a/spine-cpp/spine-cpp/include/spine/PathConstraintData.h +++ b/spine-cpp/spine-cpp/include/spine/PathConstraintData.h @@ -32,12 +32,13 @@ #include #include +#include +#include namespace spine { class BoneData; class SlotData; class PathConstraint; - class PathConstraintPose; class Skeleton; /// Controls how the first bone is positioned along the path. diff --git a/spine-cpp/spine-cpp/include/spine/PhysicsConstraintData.h b/spine-cpp/spine-cpp/include/spine/PhysicsConstraintData.h index 32aa3cc8f..350c89840 100644 --- a/spine-cpp/spine-cpp/include/spine/PhysicsConstraintData.h +++ b/spine-cpp/spine-cpp/include/spine/PhysicsConstraintData.h @@ -30,122 +30,78 @@ #ifndef Spine_PhysicsConstraintData_h #define Spine_PhysicsConstraintData_h -#include -#include -#include #include +#include namespace spine { class BoneData; + class PhysicsConstraint; - class SP_API PhysicsConstraintData : public ConstraintData { + /// Stores the setup pose for a PhysicsConstraint. + /// + /// See https://esotericsoftware.com/spine-physics-constraints Physics constraints in the Spine User Guide. + class SP_API PhysicsConstraintData : public ConstraintData { friend class SkeletonBinary; - friend class SkeletonJson; - + friend class PhysicsConstraint; friend class Skeleton; - friend class PhysicsConstraint; - public: RTTI_DECL explicit PhysicsConstraintData(const String &name); - void setBone(BoneData* bone); + /// The bone constrained by this physics constraint. + BoneData* getBone(); + void setBone(BoneData* bone); - BoneData* getBone() const; + float getStep(); + void setStep(float step); - void setX(float x); + float getX(); + void setX(float x); - float getX() const; + float getY(); + void setY(float y); - void setY(float y); + float getRotate(); + void setRotate(float rotate); - float getY() const; + float getScaleX(); + void setScaleX(float scaleX); - void setRotate(float rotate); + float getShearX(); + void setShearX(float shearX); - float getRotate() const; + float getLimit(); + void setLimit(float limit); - void setScaleX(float scaleX); + bool getInertiaGlobal(); + void setInertiaGlobal(bool inertiaGlobal); - float getScaleX() const; + bool getStrengthGlobal(); + void setStrengthGlobal(bool strengthGlobal); - void setShearX(float shearX); + bool getDampingGlobal(); + void setDampingGlobal(bool dampingGlobal); - float getShearX() const; + bool getMassGlobal(); + void setMassGlobal(bool massGlobal); - void setLimit(float limit); + bool getWindGlobal(); + void setWindGlobal(bool windGlobal); - float getLimit() const; + bool getGravityGlobal(); + void setGravityGlobal(bool gravityGlobal); - void setStep(float step); - - float getStep() const; - - void setInertia(float inertia); - - float getInertia() const; - - void setStrength(float strength); - - float getStrength() const; - - void setDamping(float damping); - - float getDamping() const; - - void setMassInverse(float massInverse); - - float getMassInverse() const; - - void setWind(float wind); - - float getWind() const; - - void setGravity(float gravity); - - float getGravity() const; - - void setMix(float mix); - - float getMix() const; - - void setInertiaGlobal(bool inertiaGlobal); - - bool isInertiaGlobal() const; - - void setStrengthGlobal(bool strengthGlobal); - - bool isStrengthGlobal() const; - - void setDampingGlobal(bool dampingGlobal); - - bool isDampingGlobal() const; - - void setMassGlobal(bool massGlobal); - - bool isMassGlobal() const; - - void setWindGlobal(bool windGlobal); - - bool isWindGlobal() const; - - void setGravityGlobal(bool gravityGlobal); - - bool isGravityGlobal() const; - - void setMixGlobal(bool mixGlobal); - - bool isMixGlobal() const; + bool getMixGlobal(); + void setMixGlobal(bool mixGlobal); private: - BoneData *_bone; - float _x, _y, _rotate, _scaleX, _shearX, _limit; - float _step, _inertia, _strength, _damping, _massInverse, _wind, _gravity, _mix; - bool _inertiaGlobal, _strengthGlobal, _dampingGlobal, _massGlobal, _windGlobal, _gravityGlobal, _mixGlobal; + BoneData* _bone; + float _x, _y, _rotate, _scaleX, _shearX, _limit, _step; + bool _inertiaGlobal, _strengthGlobal, _dampingGlobal, _massGlobal, _windGlobal, _gravityGlobal, _mixGlobal; }; } -#endif /* Spine_PhysicsConstraintData_h */ +#endif /* Spine_PhysicsConstraintData_h */ \ No newline at end of file diff --git a/spine-cpp/spine-cpp/include/spine/SlotData.h b/spine-cpp/spine-cpp/include/spine/SlotData.h index 9a1fd4d39..0bd918c06 100644 --- a/spine-cpp/spine-cpp/include/spine/SlotData.h +++ b/spine-cpp/spine-cpp/include/spine/SlotData.h @@ -34,10 +34,10 @@ #include #include #include +#include namespace spine { class BoneData; - class SlotPose; /// Stores the setup pose for a Slot. class SP_API SlotData : public PosedData { @@ -83,7 +83,7 @@ namespace spine { void setBlendMode(BlendMode blendMode); /// False if the slot was hidden in Spine and nonessential data was exported. Does not affect runtime rendering. - bool isVisible(); + bool getVisible(); void setVisible(bool visible); private: diff --git a/spine-cpp/spine-cpp/include/spine/TransformConstraintData.h b/spine-cpp/spine-cpp/include/spine/TransformConstraintData.h index 9446bf8a3..86071498b 100644 --- a/spine-cpp/spine-cpp/include/spine/TransformConstraintData.h +++ b/spine-cpp/spine-cpp/include/spine/TransformConstraintData.h @@ -30,99 +30,209 @@ #ifndef Spine_TransformConstraintData_h #define Spine_TransformConstraintData_h -#include -#include -#include #include +#include +#include namespace spine { class BoneData; + class TransformConstraint; + class BonePose; + class TransformConstraintPose; - class SP_API TransformConstraintData : public ConstraintData { + /// Source property for a TransformConstraint. + class SP_API FromProperty : public SpineObject { + public: + RTTI_DECL + + /// The value of this property that corresponds to ToProperty offset. + float offset; + + /// Constrained properties. + Vector to; + + FromProperty(); + virtual ~FromProperty(); + + /// Reads this property from the specified bone. + virtual float value(BonePose& source, bool local, float* offsets) = 0; + }; + + /// Constrained property for a TransformConstraint. + class SP_API ToProperty : public SpineObject { + public: + RTTI_DECL + + /// The value of this property that corresponds to FromProperty offset. + float offset; + + /// The maximum value of this property when clamped. + float max; + + /// The scale of the FromProperty value in relation to this property. + float scale; + + ToProperty(); + virtual ~ToProperty(); + + /// Reads the mix for this property from the specified pose. + virtual float mix(TransformConstraintPose& pose) = 0; + + /// Applies the value to this property. + virtual void apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) = 0; + }; + + class SP_API FromRotate : public FromProperty { + public: + RTTI_DECL + float value(BonePose& source, bool local, float* offsets) override; + }; + + class SP_API ToRotate : public ToProperty { + public: + RTTI_DECL + float mix(TransformConstraintPose& pose) override; + void apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) override; + }; + + class SP_API FromX : public FromProperty { + public: + RTTI_DECL + float value(BonePose& source, bool local, float* offsets) override; + }; + + class SP_API ToX : public ToProperty { + public: + RTTI_DECL + float mix(TransformConstraintPose& pose) override; + void apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) override; + }; + + class SP_API FromY : public FromProperty { + public: + RTTI_DECL + float value(BonePose& source, bool local, float* offsets) override; + }; + + class SP_API ToY : public ToProperty { + public: + RTTI_DECL + float mix(TransformConstraintPose& pose) override; + void apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) override; + }; + + class SP_API FromScaleX : public FromProperty { + public: + RTTI_DECL + float value(BonePose& source, bool local, float* offsets) override; + }; + + class SP_API ToScaleX : public ToProperty { + public: + RTTI_DECL + float mix(TransformConstraintPose& pose) override; + void apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) override; + }; + + class SP_API FromScaleY : public FromProperty { + public: + RTTI_DECL + float value(BonePose& source, bool local, float* offsets) override; + }; + + class SP_API ToScaleY : public ToProperty { + public: + RTTI_DECL + float mix(TransformConstraintPose& pose) override; + void apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) override; + }; + + class SP_API FromShearY : public FromProperty { + public: + RTTI_DECL + float value(BonePose& source, bool local, float* offsets) override; + }; + + class SP_API ToShearY : public ToProperty { + public: + RTTI_DECL + float mix(TransformConstraintPose& pose) override; + void apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) override; + }; + + /// Stores the setup pose for a TransformConstraint. + /// + /// See https://esotericsoftware.com/spine-transform-constraints Transform constraints in the Spine User Guide. + class SP_API TransformConstraintData : public ConstraintData { friend class SkeletonBinary; - friend class SkeletonJson; - friend class TransformConstraint; - friend class Skeleton; - friend class TransformConstraintTimeline; public: RTTI_DECL explicit TransformConstraintData(const String &name); + ~TransformConstraintData(); - Vector &getBones(); + /// The bones that will be modified by this transform constraint. + Vector& getBones(); - BoneData *getTarget(); - - void setTarget(BoneData *target); - - float getMixRotate(); - - void setMixRotate(float mixRotate); - - float getMixX(); - - void setMixX(float mixX); - - float getMixY(); - - void setMixY(float mixY); - - float getMixScaleX(); - - void setMixScaleX(float mixScaleX); - - float getMixScaleY(); - - void setMixScaleY(float mixScaleY); - - float getMixShearY(); - - void setMixShearY(float mixShearY); + /// The bone whose world transform will be copied to the constrained bones. + BoneData* getSource(); + void setSource(BoneData* source); + /// An offset added to the constrained bone rotation. float getOffsetRotation(); + void setOffsetRotation(float offsetRotation); - void setOffsetRotation(float offsetRotation); - + /// An offset added to the constrained bone X translation. float getOffsetX(); + void setOffsetX(float offsetX); - void setOffsetX(float offsetX); - + /// An offset added to the constrained bone Y translation. float getOffsetY(); + void setOffsetY(float offsetY); - void setOffsetY(float offsetY); - + /// An offset added to the constrained bone scaleX. float getOffsetScaleX(); + void setOffsetScaleX(float offsetScaleX); - void setOffsetScaleX(float offsetScaleX); - + /// An offset added to the constrained bone scaleY. float getOffsetScaleY(); + void setOffsetScaleY(float offsetScaleY); - void setOffsetScaleY(float offsetScaleY); - + /// An offset added to the constrained bone shearY. float getOffsetShearY(); + void setOffsetShearY(float offsetShearY); - void setOffsetShearY(float offsetShearY); + /// Reads the source bone's local transform instead of its world transform. + bool getLocalSource(); + void setLocalSource(bool localSource); - bool isRelative(); + /// Sets the constrained bones' local transforms instead of their world transforms. + bool getLocalTarget(); + void setLocalTarget(bool localTarget); - void setRelative(bool isRelative); + /// Adds the source bone transform to the constrained bones instead of setting it absolutely. + bool getAdditive(); + void setAdditive(bool additive); - bool isLocal(); + /// Prevents constrained bones from exceeding the ranged defined by offset and max. + bool getClamp(); + void setClamp(bool clamp); - void setLocal(bool isLocal); + /// The mapping of transform properties to other transform properties. + Vector& getProperties(); private: - Vector _bones; - BoneData *_target; - float _mixRotate, _mixX, _mixY, _mixScaleX, _mixScaleY, _mixShearY; - float _offsetRotation, _offsetX, _offsetY, _offsetScaleX, _offsetScaleY, _offsetShearY; - bool _relative, _local; + Vector _bones; + BoneData* _source; + float _offsets[6]; // [rotation, x, y, scaleX, scaleY, shearY] + bool _localSource, _localTarget, _additive, _clamp; + Vector _properties; }; } -#endif /* Spine_TransformConstraintData_h */ +#endif /* Spine_TransformConstraintData_h */ \ No newline at end of file diff --git a/spine-cpp/spine-cpp/include/spine/TransformConstraintPose.h b/spine-cpp/spine-cpp/include/spine/TransformConstraintPose.h index 5870e7827..2b4181e4c 100644 --- a/spine-cpp/spine-cpp/include/spine/TransformConstraintPose.h +++ b/spine-cpp/spine-cpp/include/spine/TransformConstraintPose.h @@ -37,6 +37,22 @@ namespace spine { /// Stores a pose for a transform constraint. class SP_API TransformConstraintPose : public Pose { RTTI_DECL + + friend class FromProperty; + friend class ToProperty; + friend class FromRotate; + friend class ToRotate; + friend class FromX; + friend class ToX; + friend class FromY; + friend class ToY; + friend class FromScaleX; + friend class ToScaleX; + friend class FromScaleY; + friend class ToScaleY; + friend class FromShearY; + friend class ToShearY; + private: float _mixRotate, _mixX, _mixY, _mixScaleX, _mixScaleY, _mixShearY; diff --git a/spine-cpp/spine-cpp/src/spine/BoneData.cpp b/spine-cpp/spine-cpp/src/spine/BoneData.cpp index e9b5fa479..919862005 100644 --- a/spine-cpp/spine-cpp/src/spine/BoneData.cpp +++ b/spine-cpp/spine-cpp/src/spine/BoneData.cpp @@ -35,7 +35,7 @@ using namespace spine; RTTI_IMPL_NOPARENT(BoneData) -BoneData::BoneData(int index, const String &name, BoneData *parent) : PosedData(name, new (__FILE__, __LINE__) BoneLocal()), +BoneData::BoneData(int index, const String &name, BoneData *parent) : PosedData(name), _index(index), _parent(parent), _length(0), @@ -73,7 +73,7 @@ void BoneData::setIcon(const String &icon) { this->_icon = icon; } -bool BoneData::isVisible() { +bool BoneData::getVisible() { return _visible; } diff --git a/spine-cpp/spine-cpp/src/spine/IkConstraintData.cpp b/spine-cpp/spine-cpp/src/spine/IkConstraintData.cpp index 5f232ac69..84df371f9 100644 --- a/spine-cpp/spine-cpp/src/spine/IkConstraintData.cpp +++ b/spine-cpp/spine-cpp/src/spine/IkConstraintData.cpp @@ -33,16 +33,11 @@ using namespace spine; -RTTI_IMPL(IkConstraintData, ConstraintData) +RTTI_IMPL_NOPARENT(IkConstraintData) -IkConstraintData::IkConstraintData(const String &name) : ConstraintData(name), +IkConstraintData::IkConstraintData(const String &name) : ConstraintData(name), _target(NULL), - _bendDirection(0), - _compress(false), - _stretch(false), - _uniform(false), - _mix(0), - _softness(0) { + _uniform(false) { } Vector &IkConstraintData::getBones() { @@ -57,51 +52,10 @@ void IkConstraintData::setTarget(BoneData *inValue) { _target = inValue; } -int IkConstraintData::getBendDirection() { - return _bendDirection; -} - -void IkConstraintData::setBendDirection(int inValue) { - _bendDirection = inValue; -} - -float IkConstraintData::getMix() { - return _mix; -} - -void IkConstraintData::setMix(float inValue) { - _mix = inValue; -} - -bool IkConstraintData::getStretch() { - return _stretch; -} - -void IkConstraintData::setStretch(bool inValue) { - _stretch = inValue; -} - -bool IkConstraintData::getCompress() { - return _compress; -} - -void IkConstraintData::setCompress(bool inValue) { - _compress = inValue; -} - - bool IkConstraintData::getUniform() { return _uniform; } -void IkConstraintData::setUniform(bool inValue) { - _uniform = inValue; -} - -float IkConstraintData::getSoftness() { - return _softness; -} - -void IkConstraintData::setSoftness(float inValue) { - _softness = inValue; -} +void IkConstraintData::setUniform(bool uniform) { + _uniform = uniform; +} \ No newline at end of file diff --git a/spine-cpp/spine-cpp/src/spine/PathConstraintData.cpp b/spine-cpp/spine-cpp/src/spine/PathConstraintData.cpp index 8d08f9891..14ab9014f 100644 --- a/spine-cpp/spine-cpp/src/spine/PathConstraintData.cpp +++ b/spine-cpp/spine-cpp/src/spine/PathConstraintData.cpp @@ -28,8 +28,6 @@ *****************************************************************************/ #include -#include -#include #include #include #include diff --git a/spine-cpp/spine-cpp/src/spine/PhysicsConstraintData.cpp b/spine-cpp/spine-cpp/src/spine/PhysicsConstraintData.cpp index 2c88a8d6a..128f04e78 100644 --- a/spine-cpp/spine-cpp/src/spine/PhysicsConstraintData.cpp +++ b/spine-cpp/spine-cpp/src/spine/PhysicsConstraintData.cpp @@ -28,196 +28,135 @@ *****************************************************************************/ #include - #include -#include - using namespace spine; -RTTI_IMPL(PhysicsConstraintData, ConstraintData) +RTTI_IMPL_NOPARENT(PhysicsConstraintData) -PhysicsConstraintData::PhysicsConstraintData(const String &name) : ConstraintData(name), - _bone(nullptr), - _x(0), _y(0), _rotate(0), _scaleX(0), _shearX(0), _limit(0), - _step(0), _inertia(0), _strength(0), _damping(0), _massInverse(0), _wind(0), _gravity(0), _mix(0), +PhysicsConstraintData::PhysicsConstraintData(const String &name) : ConstraintData(name), + _bone(NULL), + _x(0), _y(0), _rotate(0), _scaleX(0), _shearX(0), _limit(0), _step(0), _inertiaGlobal(false), _strengthGlobal(false), _dampingGlobal(false), _massGlobal(false), _windGlobal(false), _gravityGlobal(false), _mixGlobal(false) { } - -void PhysicsConstraintData::setBone(BoneData *bone) { - _bone = bone; -} - -BoneData *PhysicsConstraintData::getBone() const { +BoneData* PhysicsConstraintData::getBone() { return _bone; } -void PhysicsConstraintData::setX(float x) { - _x = x; +void PhysicsConstraintData::setBone(BoneData* bone) { + _bone = bone; } -float PhysicsConstraintData::getX() const { - return _x; -} - -void PhysicsConstraintData::setY(float y) { - _y = y; -} - -float PhysicsConstraintData::getY() const { - return _y; -} - -void PhysicsConstraintData::setRotate(float rotate) { - _rotate = rotate; -} - -float PhysicsConstraintData::getRotate() const { - return _rotate; -} - -void PhysicsConstraintData::setScaleX(float scaleX) { - _scaleX = scaleX; -} - -float PhysicsConstraintData::getScaleX() const { - return _scaleX; -} - -void PhysicsConstraintData::setShearX(float shearX) { - _shearX = shearX; -} - -float PhysicsConstraintData::getShearX() const { - return _shearX; -} - -void PhysicsConstraintData::setLimit(float limit) { - _limit = limit; -} - -float PhysicsConstraintData::getLimit() const { - return _limit; +float PhysicsConstraintData::getStep() { + return _step; } void PhysicsConstraintData::setStep(float step) { _step = step; } -float PhysicsConstraintData::getStep() const { - return _step; +float PhysicsConstraintData::getX() { + return _x; } -void PhysicsConstraintData::setInertia(float inertia) { - _inertia = inertia; +void PhysicsConstraintData::setX(float x) { + _x = x; } -float PhysicsConstraintData::getInertia() const { - return _inertia; +float PhysicsConstraintData::getY() { + return _y; } -void PhysicsConstraintData::setStrength(float strength) { - _strength = strength; +void PhysicsConstraintData::setY(float y) { + _y = y; } -float PhysicsConstraintData::getStrength() const { - return _strength; +float PhysicsConstraintData::getRotate() { + return _rotate; } -void PhysicsConstraintData::setDamping(float damping) { - _damping = damping; +void PhysicsConstraintData::setRotate(float rotate) { + _rotate = rotate; } -float PhysicsConstraintData::getDamping() const { - return _damping; +float PhysicsConstraintData::getScaleX() { + return _scaleX; } -void PhysicsConstraintData::setMassInverse(float massInverse) { - _massInverse = massInverse; +void PhysicsConstraintData::setScaleX(float scaleX) { + _scaleX = scaleX; } -float PhysicsConstraintData::getMassInverse() const { - return _massInverse; +float PhysicsConstraintData::getShearX() { + return _shearX; } -void PhysicsConstraintData::setWind(float wind) { - _wind = wind; +void PhysicsConstraintData::setShearX(float shearX) { + _shearX = shearX; } -float PhysicsConstraintData::getWind() const { - return _wind; +float PhysicsConstraintData::getLimit() { + return _limit; } -void PhysicsConstraintData::setGravity(float gravity) { - _gravity = gravity; +void PhysicsConstraintData::setLimit(float limit) { + _limit = limit; } -float PhysicsConstraintData::getGravity() const { - return _gravity; -} - -void PhysicsConstraintData::setMix(float mix) { - _mix = mix; -} - -float PhysicsConstraintData::getMix() const { - return _mix; +bool PhysicsConstraintData::getInertiaGlobal() { + return _inertiaGlobal; } void PhysicsConstraintData::setInertiaGlobal(bool inertiaGlobal) { _inertiaGlobal = inertiaGlobal; } -bool PhysicsConstraintData::isInertiaGlobal() const { - return _inertiaGlobal; +bool PhysicsConstraintData::getStrengthGlobal() { + return _strengthGlobal; } void PhysicsConstraintData::setStrengthGlobal(bool strengthGlobal) { _strengthGlobal = strengthGlobal; } -bool PhysicsConstraintData::isStrengthGlobal() const { - return _strengthGlobal; +bool PhysicsConstraintData::getDampingGlobal() { + return _dampingGlobal; } void PhysicsConstraintData::setDampingGlobal(bool dampingGlobal) { _dampingGlobal = dampingGlobal; } -bool PhysicsConstraintData::isDampingGlobal() const { - return _dampingGlobal; +bool PhysicsConstraintData::getMassGlobal() { + return _massGlobal; } void PhysicsConstraintData::setMassGlobal(bool massGlobal) { _massGlobal = massGlobal; } -bool PhysicsConstraintData::isMassGlobal() const { - return _massGlobal; +bool PhysicsConstraintData::getWindGlobal() { + return _windGlobal; } void PhysicsConstraintData::setWindGlobal(bool windGlobal) { _windGlobal = windGlobal; } -bool PhysicsConstraintData::isWindGlobal() const { - return _windGlobal; +bool PhysicsConstraintData::getGravityGlobal() { + return _gravityGlobal; } void PhysicsConstraintData::setGravityGlobal(bool gravityGlobal) { _gravityGlobal = gravityGlobal; } -bool PhysicsConstraintData::isGravityGlobal() const { - return _gravityGlobal; +bool PhysicsConstraintData::getMixGlobal() { + return _mixGlobal; } void PhysicsConstraintData::setMixGlobal(bool mixGlobal) { _mixGlobal = mixGlobal; -} - -bool PhysicsConstraintData::isMixGlobal() const { - return _mixGlobal; -} +} \ No newline at end of file diff --git a/spine-cpp/spine-cpp/src/spine/SlotData.cpp b/spine-cpp/spine-cpp/src/spine/SlotData.cpp index 01468bcf7..f4e5d8e0c 100644 --- a/spine-cpp/spine-cpp/src/spine/SlotData.cpp +++ b/spine-cpp/spine-cpp/src/spine/SlotData.cpp @@ -38,7 +38,7 @@ using namespace spine; RTTI_IMPL_NOPARENT(SlotData) SlotData::SlotData(int index, const String& name, BoneData& boneData) : - PosedData(name, new (__FILE__, __LINE__) SlotPose()), + PosedData(name), _index(index), _boneData(boneData), _attachmentName(), @@ -71,7 +71,7 @@ void SlotData::setBlendMode(BlendMode blendMode) { _blendMode = blendMode; } -bool SlotData::isVisible() { +bool SlotData::getVisible() { return _visible; } diff --git a/spine-cpp/spine-cpp/src/spine/TransformConstraintData.cpp b/spine-cpp/spine-cpp/src/spine/TransformConstraintData.cpp index 38a674e48..cc5fe9bad 100644 --- a/spine-cpp/spine-cpp/src/spine/TransformConstraintData.cpp +++ b/spine-cpp/spine-cpp/src/spine/TransformConstraintData.cpp @@ -28,153 +28,330 @@ *****************************************************************************/ #include - #include - -#include +#include +#include +#include +#include using namespace spine; -RTTI_IMPL(TransformConstraintData, ConstraintData) +RTTI_IMPL_NOPARENT(TransformConstraintData) -TransformConstraintData::TransformConstraintData(const String &name) : ConstraintData(name), - _target(NULL), - _mixRotate(0), - _mixX(0), - _mixY(0), - _mixScaleX(0), - _mixScaleY(0), - _mixShearY(0), - _offsetRotation(0), - _offsetX(0), - _offsetY(0), - _offsetScaleX(0), - _offsetScaleY(0), - _offsetShearY(0), - _relative(false), - _local(false) { +TransformConstraintData::TransformConstraintData(const String &name) : ConstraintData(name), + _source(NULL), + _localSource(false), + _localTarget(false), + _additive(false), + _clamp(false) { + for (int i = 0; i < 6; i++) { + _offsets[i] = 0; + } } -Vector &TransformConstraintData::getBones() { +Vector& TransformConstraintData::getBones() { return _bones; } -BoneData *TransformConstraintData::getTarget() { - return _target; +BoneData* TransformConstraintData::getSource() { + return _source; } -float TransformConstraintData::getMixRotate() { - return _mixRotate; -} - -float TransformConstraintData::getMixX() { - return _mixX; -} - -float TransformConstraintData::getMixY() { - return _mixY; -} - -float TransformConstraintData::getMixScaleX() { - return _mixScaleX; -} - -float TransformConstraintData::getMixScaleY() { - return _mixScaleY; -} - -float TransformConstraintData::getMixShearY() { - return _mixShearY; +void TransformConstraintData::setSource(BoneData* source) { + _source = source; } float TransformConstraintData::getOffsetRotation() { - return _offsetRotation; -} - -float TransformConstraintData::getOffsetX() { - return _offsetX; -} - -float TransformConstraintData::getOffsetY() { - return _offsetY; -} - -float TransformConstraintData::getOffsetScaleX() { - return _offsetScaleX; -} - -float TransformConstraintData::getOffsetScaleY() { - return _offsetScaleY; -} - -float TransformConstraintData::getOffsetShearY() { - return _offsetShearY; -} - -bool TransformConstraintData::isRelative() { - return _relative; -} - -bool TransformConstraintData::isLocal() { - return _local; -} - -void TransformConstraintData::setTarget(BoneData *target) { - _target = target; -} - -void TransformConstraintData::setMixRotate(float mixRotate) { - _mixRotate = mixRotate; -} - -void TransformConstraintData::setMixX(float mixX) { - _mixX = mixX; -} - -void TransformConstraintData::setMixY(float mixY) { - _mixY = mixY; -} - -void TransformConstraintData::setMixScaleX(float mixScaleX) { - _mixScaleX = mixScaleX; -} - -void TransformConstraintData::setMixScaleY(float mixScaleY) { - _mixScaleY = mixScaleY; -} - -void TransformConstraintData::setMixShearY(float mixShearY) { - _mixShearY = mixShearY; + return _offsets[0]; } void TransformConstraintData::setOffsetRotation(float offsetRotation) { - _offsetRotation = offsetRotation; + _offsets[0] = offsetRotation; +} + +float TransformConstraintData::getOffsetX() { + return _offsets[1]; } void TransformConstraintData::setOffsetX(float offsetX) { - _offsetX = offsetX; + _offsets[1] = offsetX; +} + +float TransformConstraintData::getOffsetY() { + return _offsets[2]; } void TransformConstraintData::setOffsetY(float offsetY) { - _offsetY = offsetY; + _offsets[2] = offsetY; +} + +float TransformConstraintData::getOffsetScaleX() { + return _offsets[3]; } void TransformConstraintData::setOffsetScaleX(float offsetScaleX) { - _offsetScaleX = offsetScaleX; + _offsets[3] = offsetScaleX; +} + +float TransformConstraintData::getOffsetScaleY() { + return _offsets[4]; } void TransformConstraintData::setOffsetScaleY(float offsetScaleY) { - _offsetScaleY = offsetScaleY; + _offsets[4] = offsetScaleY; +} + +float TransformConstraintData::getOffsetShearY() { + return _offsets[5]; } void TransformConstraintData::setOffsetShearY(float offsetShearY) { - _offsetShearY = offsetShearY; + _offsets[5] = offsetShearY; } -void TransformConstraintData::setRelative(bool isRelative) { - _relative = isRelative; +bool TransformConstraintData::getLocalSource() { + return _localSource; } -void TransformConstraintData::setLocal(bool isLocal) { - _local = isLocal; +void TransformConstraintData::setLocalSource(bool localSource) { + _localSource = localSource; } + +bool TransformConstraintData::getLocalTarget() { + return _localTarget; +} + +void TransformConstraintData::setLocalTarget(bool localTarget) { + _localTarget = localTarget; +} + +bool TransformConstraintData::getAdditive() { + return _additive; +} + +void TransformConstraintData::setAdditive(bool additive) { + _additive = additive; +} + +bool TransformConstraintData::getClamp() { + return _clamp; +} + +void TransformConstraintData::setClamp(bool clamp) { + _clamp = clamp; +} + +Vector& TransformConstraintData::getProperties() { + return _properties; +} + +// ============================================================================ +// Property Classes +// ============================================================================ + +RTTI_IMPL_NOPARENT(FromProperty) + +FromProperty::FromProperty() : SpineObject(), offset(0) { +} + +FromProperty::~FromProperty() { +} + +RTTI_IMPL_NOPARENT(ToProperty) + +ToProperty::ToProperty() : offset(0), max(0), scale(1) { +} + +ToProperty::~ToProperty() { +} + +RTTI_IMPL(FromRotate, FromProperty) + +float FromRotate::value(BonePose& source, bool local, float* offsets) { + if (local) return source.getRotation() + offsets[0]; + float value = MathUtil::atan2(source._c, source._a) * MathUtil::Rad_Deg + + (source._a * source._d - source._b * source._c > 0 ? offsets[0] : -offsets[0]); + if (value < 0) value += 360; + return value; +} + +RTTI_IMPL(ToRotate, ToProperty) + +float ToRotate::mix(TransformConstraintPose& pose) { + return pose._mixRotate; +} + +void ToRotate::apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) { + if (local) { + if (!additive) value -= bone.getRotation(); + bone.setRotation(bone.getRotation() + value * pose._mixRotate); + } else { + float a = bone._a, b = bone._b, c = bone._c, d = bone._d; + value *= MathUtil::Deg_Rad; + if (!additive) value -= MathUtil::atan2(c, a); + if (value > MathUtil::Pi) + value -= MathUtil::Pi * 2; + else if (value < -MathUtil::Pi) + value += MathUtil::Pi * 2; + value *= pose._mixRotate; + float cosVal = MathUtil::cos(value), sinVal = MathUtil::sin(value); + bone._a = cosVal * a - sinVal * c; + bone._b = cosVal * b - sinVal * d; + bone._c = sinVal * a + cosVal * c; + bone._d = sinVal * b + cosVal * d; + } +} + +RTTI_IMPL(FromX, FromProperty) + +float FromX::value(BonePose& source, bool local, float* offsets) { + return local ? source.getX() + offsets[1] : offsets[1] * source._a + offsets[2] * source._b + source.getWorldX(); +} + +RTTI_IMPL(ToX, ToProperty) + +float ToX::mix(TransformConstraintPose& pose) { + return pose._mixX; +} + +void ToX::apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) { + if (local) { + if (!additive) value -= bone.getX(); + bone.setX(bone.getX() + value * pose._mixX); + } else { + if (!additive) value -= bone.getWorldX(); + bone.setWorldX(bone.getWorldX() + value * pose._mixX); + } +} + +RTTI_IMPL(FromY, FromProperty) + +float FromY::value(BonePose& source, bool local, float* offsets) { + return local ? source.getY() + offsets[2] : offsets[1] * source._c + offsets[2] * source._d + source.getWorldY(); +} + +RTTI_IMPL(ToY, ToProperty) + +float ToY::mix(TransformConstraintPose& pose) { + return pose._mixY; +} + +void ToY::apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) { + if (local) { + if (!additive) value -= bone.getY(); + bone.setY(bone.getY() + value * pose._mixY); + } else { + if (!additive) value -= bone.getWorldY(); + bone.setWorldY(bone.getWorldY() + value * pose._mixY); + } +} + +RTTI_IMPL(FromScaleX, FromProperty) + +float FromScaleX::value(BonePose& source, bool local, float* offsets) { + return (local ? source.getScaleX() : MathUtil::sqrt(source._a * source._a + source._c * source._c)) + offsets[3]; +} + +RTTI_IMPL(ToScaleX, ToProperty) + +float ToScaleX::mix(TransformConstraintPose& pose) { + return pose._mixScaleX; +} + +void ToScaleX::apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) { + if (local) { + if (additive) + bone.setScaleX(bone.getScaleX() * (1 + ((value - 1) * pose._mixScaleX))); + else if (bone.getScaleX() != 0) + bone.setScaleX(bone.getScaleX() * (1 + (value / bone.getScaleX() - 1) * pose._mixScaleX)); + } else { + float s; + if (additive) + s = 1 + (value - 1) * pose._mixScaleX; + else { + s = MathUtil::sqrt(bone._a * bone._a + bone._c * bone._c); + if (s != 0) s = 1 + (value / s - 1) * pose._mixScaleX; + } + bone._a *= s; + bone._c *= s; + } +} + +RTTI_IMPL(FromScaleY, FromProperty) + +float FromScaleY::value(BonePose& source, bool local, float* offsets) { + return (local ? source.getScaleY() : MathUtil::sqrt(source._b * source._b + source._d * source._d)) + offsets[4]; +} + +RTTI_IMPL(ToScaleY, ToProperty) + +float ToScaleY::mix(TransformConstraintPose& pose) { + return pose._mixScaleY; +} + +void ToScaleY::apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) { + if (local) { + if (additive) + bone.setScaleY(bone.getScaleY() * (1 + ((value - 1) * pose._mixScaleY))); + else if (bone.getScaleY() != 0) + bone.setScaleY(bone.getScaleY() * (1 + (value / bone.getScaleY() - 1) * pose._mixScaleY)); + } else { + float s; + if (additive) + s = 1 + (value - 1) * pose._mixScaleY; + else { + s = MathUtil::sqrt(bone._b * bone._b + bone._d * bone._d); + if (s != 0) s = 1 + (value / s - 1) * pose._mixScaleY; + } + bone._b *= s; + bone._d *= s; + } +} + +RTTI_IMPL(FromShearY, FromProperty) + +float FromShearY::value(BonePose& source, bool local, float* offsets) { + return (local ? source.getShearY() : (MathUtil::atan2(source._d, source._b) - MathUtil::atan2(source._c, source._a)) * MathUtil::Rad_Deg - 90) + offsets[5]; +} + +RTTI_IMPL(ToShearY, ToProperty) + +float ToShearY::mix(TransformConstraintPose& pose) { + return pose._mixShearY; +} + +void ToShearY::apply(TransformConstraintPose& pose, BonePose& bone, float value, bool local, bool additive) { + if (local) { + if (!additive) value -= bone.getShearY(); + bone.setShearY(bone.getShearY() + value * pose._mixShearY); + } else { + float b = bone._b, d = bone._d, by = MathUtil::atan2(d, b); + value = (value + 90) * MathUtil::Deg_Rad; + if (additive) + value -= MathUtil::Pi / 2; + else { + value -= by - MathUtil::atan2(bone._c, bone._a); + if (value > MathUtil::Pi) + value -= MathUtil::Pi * 2; + else if (value < -MathUtil::Pi) + value += MathUtil::Pi * 2; + } + value = by + value * pose._mixShearY; + float s = MathUtil::sqrt(b * b + d * d); + bone._b = MathUtil::cos(value) * s; + bone._d = MathUtil::sin(value) * s; + } +} + +TransformConstraintData::~TransformConstraintData() { + // Clean up all FromProperty objects, which will in turn clean up their ToProperty objects + for (size_t i = 0; i < _properties.size(); i++) { + FromProperty* fromProp = _properties[i]; + if (fromProp) { + // Clean up the ToProperty objects in the FromProperty + ContainerUtil::cleanUpVectorOfPointers(fromProp->to); + delete fromProp; + } + } + _properties.clear(); +} \ No newline at end of file