spine-runtimes/spine-cpp/spine-cpp/include/spine/Bone.h

/******************************************************************************
 * Spine Runtimes Software License v2.5
 *
 * Copyright (c) 2013-2016, Esoteric Software
 * All rights reserved.
 *
 * You are granted a perpetual, non-exclusive, non-sublicensable, and
 * non-transferable license to use, install, execute, and perform the Spine
 * Runtimes software and derivative works solely for personal or internal
 * use. Without the written permission of Esoteric Software (see Section 2 of
 * the Spine Software License Agreement), you may not (a) modify, translate,
 * adapt, or develop new applications using the Spine Runtimes or otherwise
 * create derivative works or improvements of the Spine Runtimes or (b) remove,
 * delete, alter, or obscure any trademarks or any copyright, trademark, patent,
 * or other intellectual property or proprietary rights notices on or in the
 * Software, including any copy thereof. Redistributions in binary or source
 * form must include this license and terms.
 *
 * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 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 THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

#ifndef Spine_Bone_h
#define Spine_Bone_h

#include <spine/Updatable.h>

#include <spine/Vector.h>

namespace Spine
{
    class BoneData;
    class Skeleton;
    
    /// Stores a bone's current pose.
    ///
    /// A bone has a local transform which is used to compute its world transform. A bone also has an applied transform, which is a
    /// local transform that can be applied to compute the world transform. The local transform and applied transform may differ if a
    /// constraint or application code modifies the world transform after it was computed from the local transform.
    class Bone : public Updatable
    {
        RTTI_DECL;
        
        friend class RotateTimeline;
        friend class IkConstraint;
        friend class TransformConstraint;
        friend class VertexAttachment;
        friend class PathConstraint;
        friend class Skeleton;
        friend class RegionAttachment;
        friend class PointAttachment;
        friend class ScaleTimeline;
        friend class ShearTimeline;
        friend class TranslateTimeline;
        
    public:
        static void setYDown(bool inValue);
        
        static bool isYDown();
        
        /// @param parent May be NULL.
        Bone(BoneData& data, Skeleton& skeleton, Bone* parent = NULL);
        
        /// Same as updateWorldTransform. This method exists for Bone to implement Spine::Updatable.
        virtual void update();
        
        /// Computes the world transform using the parent bone and this bone's local transform.
        void updateWorldTransform();
        
        /// Computes the world transform using the parent bone and the specified local transform.
        void updateWorldTransform(float x, float y, float rotation, float scaleX, float scaleY, float shearX, float shearY);
        
        void setToSetupPose();
        
        void worldToLocal(float worldX, float worldY, float& outLocalX, float& outLocalY);
        
        void localToWorld(float localX, float localY, float& outWorldX, float& outWorldY);
        
        float worldToLocalRotation(float worldRotation);
        
        float localToWorldRotation(float localRotation);
        
        ///
        /// Rotates the world transform the specified amount and sets isAppliedValid to false.
        ///
        /// @param degrees Degrees.
        void rotateWorld(float degrees);
        
        float getWorldToLocalRotationX();
        
        float getWorldToLocalRotationY();
        
        BoneData& getData();
        Skeleton& getSkeleton();
        Bone* getParent();
        Vector<Bone*>& getChildren();
        
        /// The local X translation.
        float getX();
        void setX(float inValue);
        
        /// The local Y translation.
        float getY();
        void setY(float inValue);
        
        /// The local rotation.
        float getRotation();
        void setRotation(float inValue);
        
        /// The local scaleX.
        float getScaleX();
        void setScaleX(float inValue);
        
        /// The local scaleY.
        float getScaleY();
        void setScaleY(float inValue);
        
        /// The local shearX.
        float getShearX();
        void setShearX(float inValue);
        
        /// The local shearY.
        float getShearY();
        void setShearY(float inValue);
        
        /// The rotation, as calculated by any constraints.
        float getAppliedRotation();
        void setAppliedRotation(float inValue);
        
        /// The applied local x translation.
        float getAX();
        void setAX(float inValue);
        
        /// The applied local y translation.
        float getAY();
        void setAY(float inValue);
        
        /// The applied local scaleX.
        float getAScaleX();
        void setAScaleX(float inValue);
        
        /// The applied local scaleY.
        float getAScaleY();
        void setAScaleY(float inValue);
        
        /// The applied local shearX.
        float getAShearX();
        void setAShearX(float inValue);
        
        /// The applied local shearY.
        float getAShearY();
        void setAShearY(float inValue);
        
        float getA();
        float getB();
        float getC();
        float getD();
        
        float getWorldX();
        float getWorldY();
        float getWorldRotationX();
        float getWorldRotationY();
        
        /// Returns the magnitide (always positive) of the world scale X.
        float getWorldScaleX();
        
        /// Returns the magnitide (always positive) of the world scale Y.
        float getWorldScaleY();
        
    private:
        static bool yDown;
        
        BoneData& _data;
        Skeleton& _skeleton;
        Bone* _parent;
        Vector<Bone*> _children;
        float _x, _y, _rotation, _scaleX, _scaleY, _shearX, _shearY;
        float _ax, _ay, _arotation, _ascaleX, _ascaleY, _ashearX, _ashearY;
        bool _appliedValid;
        float _a, _b, _worldX;
        float _c, _d, _worldY;
        bool _sorted;
        
        /// Computes the individual applied transform values from the world transform. This can be useful to perform processing using
        /// the applied transform after the world transform has been modified directly (eg, by a constraint)..
        ///
        /// Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation.
        void updateAppliedTransform();
    };
}

#endif /* Spine_Bone_h */