fbxtransforms.h

Go to the documentation of this file.

/****************************************************************************************
 
   Copyright (C) 2013 Autodesk, Inc.
   All rights reserved.
 
   Use of this software is subject to the terms of the Autodesk license agreement
   provided at the time of installation or download, or which otherwise accompanies
   this software in either electronic or hard copy form.
 
****************************************************************************************/

#ifndef _FBXSDK_CORE_MATH_TRANSFORMS_H_
#define _FBXSDK_CORE_MATH_TRANSFORMS_H_

#include <fbxsdk/fbxsdk_def.h>

#include <fbxsdk/core/math/fbxmath.h>
#include <fbxsdk/core/math/fbxquaternion.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

class FBXSDK_DLL FbxLimits
{
public:
    FbxLimits();

    FbxLimits& operator=(const FbxLimits& pLimits);

    bool GetActive() const;

    void SetActive(const bool pActive);

    bool GetMinXActive() const;

    bool GetMinYActive() const;

    bool GetMinZActive() const;

    void GetMinActive(bool& pXActive, bool& pYActive, bool& pZActive) const;

    FbxDouble3 GetMin() const;

    void SetMinXActive(const bool pActive);

    void SetMinYActive(const bool pActive);

    void SetMinZActive(const bool pActive);

    void SetMinActive(const bool pXActive, const bool pYActive, const bool pZActive);

    void SetMin(const FbxDouble3& pMin);

    bool GetMaxXActive() const;

    bool GetMaxYActive() const;

    bool GetMaxZActive() const;

    void GetMaxActive(bool& pXActive, bool& pYActive, bool& pZActive) const;

    FbxDouble3 GetMax() const;

    void SetMaxXActive(const bool pActive);

    void SetMaxYActive(const bool pActive);

    void SetMaxZActive(const bool pActive);

    void SetMaxActive(const bool pXActive, const bool pYActive, const bool pZActive);

    void SetMax(const FbxDouble3& pMax);

    bool GetAnyMinMaxActive() const;
    
    FbxDouble3 Apply(const FbxDouble3& pVector);

/*****************************************************************************************************************************
** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
*****************************************************************************************************************************/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
private:
    enum EMask {eActive=1<<0, eMinX=1<<1, eMinY=1<<2, eMinZ=1<<3, eMaxX=1<<4, eMaxY=1<<5, eMaxZ=1<<6, eAll=eMinX|eMinY|eMinZ|eMaxX|eMaxY|eMaxZ};

    FbxUInt8    mMask;
    FbxDouble3  mMin;
    FbxDouble3  mMax;
#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
};

class FBXSDK_DLL FbxRotationOrder
{
public: 
    FbxRotationOrder(int pOrder=FbxEuler::eOrderXYZ);

    int     GetOrder();
    void    SetOrder(int pOrder);
    void    V2M(FbxAMatrix& pRM, const FbxVector4& pV);
    void    M2V(FbxVector4& pV, FbxAMatrix& pRM);
    bool    V2VRef(FbxVector4& pVOut, FbxVector4& pVIn, FbxVector4& pVRef);

private:
    int     mOrder;
};

class FBXSDK_DLL FbxTransform
{
public:
    enum EInheritType {eInheritRrSs, eInheritRSrs, eInheritRrs};

    FbxTransform();

    EInheritType        GetInheritType();
    void                SetInheritType(EInheritType pType);
    FbxLimits&          GetTranslationLimits();
    FbxLimits&          GetRotationLimits();
    FbxLimits&          GetScalingLimits();
    FbxRotationOrder&   GetRotationOrder();
    bool                HasROffset();
    bool                HasRPivot();
    bool                HasSOffset();
    bool                HasSPivot();
    bool                HasPreRM();
    bool                HasPostRM();
    void                SetROffset(FbxVector4& pROffset);
    void                SetRPivot(FbxVector4& pRPivot);
    void                SetSOffset(FbxVector4& pSOffset);
    void                SetSPivot(FbxVector4& pSPivot);
    void                SetPreRM(FbxVector4& pPreR);
    void                SetPostRM(FbxVector4& pPostR);
    bool                GetRotationSpaceForLimitOnly();
    void                SetRotationSpaceForLimitOnly(bool pRotationSpaceForLimitOnly);

    void                DoF2LT(FbxVector4& pLT, FbxVector4& pDoF, FbxAMatrix& pLRM, FbxAMatrix& pLSM);
    void                LT2DoF(FbxVector4& pDoF, FbxVector4 pLT, FbxAMatrix& pLRM, FbxAMatrix& pLSM);
    void                DoF2LRM(FbxAMatrix& pLRM, FbxVector4& pRDoF, bool pForLimit=false);
    void                LRM2DoF(FbxVector4& pRDoF, FbxAMatrix& pLRM, bool pForLimit=false);
    void                LSM2GSM(FbxAMatrix& pGSM, FbxAMatrix& pPGSM, FbxAMatrix& pLSM, FbxAMatrix& pLRM, FbxVector4& pPLS);
    void                GTRSM2GX(FbxAMatrix& pGX, FbxVector4& pGT, FbxAMatrix& pGRM, FbxAMatrix& pGSM);

private:
    void                SumPivots(FbxVector4& pSum, FbxAMatrix& pLRM, FbxAMatrix& pLSM);

    class RotationSpace
    {
    public:
        enum EMask {eHasNothing=0, eHasPreRotM=1<<0, eHasPostRotM=1<<1};

        RotationSpace();

        bool                HasPreRM();
        bool                HasPostRM();
        void                GetPreRM(FbxAMatrix& pPreRM);
        void                GetPostRM(FbxAMatrix& pPostRM);
        void                SetPreRM(FbxVector4& pPreR);
        void                SetPostRM(FbxVector4& pPostR);
        void                DoF2LRM(FbxAMatrix& pLRM, FbxVector4& pRDoF);
        void                LRM2DoF(FbxVector4& pRDoF, FbxAMatrix& pLRM);

        FbxUInt8            mMask;
        FbxAMatrix          mPreRM;
        FbxAMatrix          mPostRM;
        FbxRotationOrder    mRotationOrder;
    };

    enum EMask {eHasNothing=0, eHasRotOffset=1<<0, eHasRotPivot=1<<1, eHasScaleOffset=1<<2, eHasScalePivot=1<<3};

    FbxUInt8        mMask;
    EInheritType    mInheritType;   
    FbxVector4      mROffset;
    FbxVector4      mRPivot;
    FbxVector4      mSOffset;
    FbxVector4      mSPivot;
    FbxLimits       mTranslationLimits;
    FbxLimits       mRotationLimits;
    FbxLimits       mScalingLimits;
    bool            mRotationSpaceForLimitOnly;
    RotationSpace   mRotationSpace;
};

FBXSDK_DLL bool FbxGetContinuousRotation(FbxVector4& pRes, FbxVector4 pRot, FbxVector4 pRef, const int* pOrder);
FBXSDK_DLL void FbxGetContinuousRotation(FbxVector4& pRes, FbxVector4 pRot, FbxVector4 pRef);

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_CORE_MATH_TRANSFORMS_H_ */