fbxtransforms.h

Go to the documentation of this file.

/****************************************************************************************
 
   Copyright (C) 2015 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(bool pActive);

    void SetMinYActive(bool pActive);

    void SetMinZActive(bool pActive);

    void SetMinActive(bool pXActive, bool pYActive, 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(bool pActive);

    void SetMaxYActive(bool pActive);

    void SetMaxZActive(bool pActive);

    void SetMaxActive(bool pXActive, bool pYActive, 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(FbxEuler::EOrder pOrder=FbxEuler::eOrderXYZ);

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

private:
    FbxEuler::EOrder mOrder;
};

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

    FbxTransform();

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

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

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

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

        RotationSpace();

        bool                HasPreRM() const;
        bool                HasPostRM() const;
        void                GetPreRM(FbxAMatrix& pPreRM) const;
        void                GetPostRM(FbxAMatrix& pPostRM) const;
        void                SetPreRM(const FbxVector4& pPreR);
        void                SetPostRM(const FbxVector4& pPostR);
        void                DoF2LRM(FbxAMatrix& pLRM, const FbxVector4& pRDoF);
        void                LRM2DoF(FbxVector4& pRDoF, const 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, const FbxVector4& pRot, const FbxVector4& pRef, const int* pOrder);
FBXSDK_DLL void FbxGetContinuousRotation(FbxVector4& pRes, const FbxVector4& pRot, const FbxVector4& pRef);

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_CORE_MATH_TRANSFORMS_H_ */