fbxnode.h

Go to the documentation of this file.

/****************************************************************************************
 
   Copyright (C) 2012 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_SCENE_GEOMETRY_NODE_H_
#define _FBXSDK_SCENE_GEOMETRY_NODE_H_

#include <fbxsdk/fbxsdk_def.h>

#include <fbxsdk/core/fbxobject.h>
#include <fbxsdk/core/base/fbxarray.h>
#include <fbxsdk/core/base/fbxerror.h>
#include <fbxsdk/core/base/fbxstring.h>
#include <fbxsdk/core/base/fbxtime.h>
#include <fbxsdk/core/math/fbxvector4.h>
#include <fbxsdk/core/math/fbxmatrix.h>
#include <fbxsdk/core/math/fbxaffinematrix.h>
#include <fbxsdk/core/math/fbxtransforms.h>
#include <fbxsdk/scene/fbxgroupname.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

class FbxNodeAttribute;
class FbxScene;
class FbxAnimStack;
class FbxAnimLayer;
class FbxManager;
class FbxCachedEffect;
class FbxLODGroup;
class FbxNull;
class FbxMarker;
class FbxSkeleton;
class FbxGeometry;
class FbxMesh;
class FbxNurbs;
class FbxNurbsCurve;
class FbxLine;
class FbxNurbsSurface;
class FbxTrimNurbsSurface;
class FbxPatch;
class FbxCamera;
class FbxCameraStereo;
class FbxCameraSwitcher;
class FbxLight;
class FbxOpticalReference;
class FbxCharacter;
class FbxNode_internal;
class FbxSurfaceMaterial;
class FbxSubDiv;
class FbxNodeEvalState;

class FBXSDK_DLL FbxNode : public FbxObject
{
    FBXSDK_OBJECT_DECLARE(FbxNode, FbxObject);

public:
        FbxNode* GetParent();
        FbxNode const* GetParent() const;

        bool AddChild(FbxNode* pNode);

        FbxNode* RemoveChild(FbxNode* pNode);

        int GetChildCount(bool pRecursive = false) const;

        FbxNode* GetChild(int pIndex);

        FbxNode const* GetChild(int pIndex) const;

        FbxNode* FindChild(char const* pName, bool pRecursive = true, bool pInitial = false);


        void SetTarget(FbxNode* pNode);

        FbxNode* GetTarget() const;

        void SetPostTargetRotation(FbxVector4 pVector);

        FbxVector4 GetPostTargetRotation() const;

        void SetTargetUp(FbxNode* pNode);

        FbxNode* GetTargetUp() const;

        void SetTargetUpVector(FbxVector4 pVector);

        FbxVector4 GetTargetUpVector() const;

        void SetVisibility(bool pIsVisible);

        bool GetVisibility() const;

        enum EShadingMode
        {
            eHardShading,               
            eWireFrame,             
            eFlatShading,               
            eLightShading,              
            eTextureShading,            
            eFullShading        
        };

        void SetShadingMode(EShadingMode pShadingMode);

        EShadingMode GetShadingMode() const;

        FbxNodeAttribute* SetNodeAttribute(FbxNodeAttribute* pNodeAttribute);

        FbxNodeAttribute* GetNodeAttribute();

        FbxNodeAttribute const* GetNodeAttribute() const;

        int GetNodeAttributeCount() const;

        int GetDefaultNodeAttributeIndex() const;

        bool SetDefaultNodeAttributeIndex(int pIndex);

        FbxNodeAttribute* GetNodeAttributeByIndex(int pIndex);

        FbxNodeAttribute const* GetNodeAttributeByIndex(int pIndex) const;

        int GetNodeAttributeIndex(FbxNodeAttribute* pNodeAttribute) const;

        bool AddNodeAttribute(FbxNodeAttribute* pNodeAttribute);

        FbxNodeAttribute* RemoveNodeAttribute(FbxNodeAttribute* pNodeAttribute);

        FbxNodeAttribute* RemoveNodeAttributeByIndex(int pIndex);

        FbxCachedEffect* GetCachedEffect();

        FbxLODGroup* GetLodGroup();

        FbxNull* GetNull();

        FbxMarker* GetMarker();

        FbxSkeleton* GetSkeleton();

        FbxGeometry* GetGeometry();

        FbxMesh* GetMesh();

        FbxNurbs* GetNurbs();

        FbxNurbsSurface* GetNurbsSurface();

        FbxNurbsCurve* GetNurbsCurve();

        FbxLine* GetLine();

        FbxTrimNurbsSurface* GetTrimNurbsSurface();

        FbxSubDiv* GetSubdiv();

        FbxPatch* GetPatch();

        FbxCamera* GetCamera();
        const FbxCamera* GetCamera() const;

        FbxCameraStereo* GetCameraStereo();

        FbxCameraSwitcher* GetCameraSwitcher();

        FbxLight* GetLight();
        const FbxLight * GetLight() const;

        FbxOpticalReference* GetOpticalReference();

        void SetTransformationInheritType(FbxTransform::EInheritType pInheritType);

        void GetTransformationInheritType(FbxTransform::EInheritType& pInheritType) const;

        enum EPivotSet
        {
            eSourcePivot,       
            eDestinationPivot   
        };

        enum EPivotState
        {
            ePivotActive,   
            ePivotReference 
        };

        void SetPivotState(EPivotSet pPivotSet, EPivotState pPivotState);

        void GetPivotState(EPivotSet pPivotSet, EPivotState& pPivotState) const;

        void SetRotationOrder(EPivotSet pPivotSet, EFbxRotationOrder pRotationOrder);

        void GetRotationOrder(EPivotSet pPivotSet, EFbxRotationOrder& pRotationOrder) const;

        void SetUseRotationSpaceForLimitOnly(EPivotSet pPivotSet, bool pUseForLimitOnly);

        bool GetUseRotationSpaceForLimitOnly(EPivotSet pPivotSet) const;

        void SetRotationActive(bool pVal);

        bool GetRotationActive() const;

        void SetQuaternionInterpolation(EPivotSet pPivotSet, EFbxQuatInterpMode pQuatIterp);

        EFbxQuatInterpMode GetQuaternionInterpolation(EPivotSet pPivotSet) const;

        void SetRotationStiffness(FbxVector4 pRotationStiffness);

        FbxVector4 GetRotationStiffness() const;

        void SetMinDampRange(FbxVector4 pMinDampRange);

        FbxVector4 GetMinDampRange() const;


        void SetMaxDampRange(FbxVector4 pMaxDampRange);

        FbxVector4 GetMaxDampRange() const;


        void SetMinDampStrength(FbxVector4 pMinDampStrength);

        FbxVector4 GetMinDampStrength() const;


        void SetMaxDampStrength(FbxVector4 pMaxDampStrength);

        FbxVector4 GetMaxDampStrength() const;

        void SetPreferedAngle(FbxVector4 pPreferedAngle);

        FbxVector4 GetPreferedAngle() const;

        void SetRotationOffset(EPivotSet pPivotSet, FbxVector4 pVector);

        const FbxVector4& GetRotationOffset(EPivotSet pPivotSet) const;

        void SetRotationPivot(EPivotSet pPivotSet, FbxVector4 pVector);

        const FbxVector4& GetRotationPivot(EPivotSet pPivotSet) const;

        void SetPreRotation(EPivotSet pPivotSet, FbxVector4 pVector);

        const FbxVector4& GetPreRotation(EPivotSet pPivotSet) const;

        void SetPostRotation(EPivotSet pPivotSet, FbxVector4 pVector);

        const FbxVector4& GetPostRotation(EPivotSet pPivotSet) const;

        void SetScalingOffset(EPivotSet pPivotSet, FbxVector4 pVector);

        const FbxVector4& GetScalingOffset(EPivotSet pPivotSet) const;

        void SetScalingPivot(EPivotSet pPivotSet, FbxVector4 pVector);

        const FbxVector4& GetScalingPivot(EPivotSet pPivotSet) const;

        void SetGeometricTranslation(EPivotSet pPivotSet, FbxVector4 pVector);

        FbxVector4 GetGeometricTranslation(EPivotSet pPivotSet) const;

        void SetGeometricRotation(EPivotSet pPivotSet, FbxVector4 pVector);

        FbxVector4 GetGeometricRotation(EPivotSet pPivotSet) const;

        void SetGeometricScaling(EPivotSet pPivotSet, FbxVector4 pVector);

        FbxVector4 GetGeometricScaling(EPivotSet pPivotSet) const;

        void ResetPivotSet( FbxNode::EPivotSet pPivotSet );

        void ConvertPivotAnimation(EPivotSet pConversionTarget, double pFrameRate, bool pKeyReduce=true);
        
        void ConvertPivotAnimationRecursive(const char * pAnimStackName,
            EPivotSet pConversionTarget, double pFrameRate, bool pKeyReduce=true);

        void ResetPivotSetAndConvertAnimation( double pFrameRate=30., bool pKeyReduce=false, bool pToNodeCenter=true, bool pForceResetLimits = false );

        void SetRotationPivotAsCenterRecursive(FbxVector4 pParentGeometricOffset = FbxVector4());

        FbxAMatrix& EvaluateGlobalTransform(FbxTime pTime=FBXSDK_TIME_INFINITE, FbxNode::EPivotSet pPivotSet=FbxNode::eSourcePivot, bool pApplyTarget=false, bool pForceEval=false);

        FbxAMatrix& EvaluateLocalTransform(FbxTime pTime=FBXSDK_TIME_INFINITE, FbxNode::EPivotSet pPivotSet=FbxNode::eSourcePivot, bool pApplyTarget=false, bool pForceEval=false);

        FbxVector4& EvaluateLocalTranslation(FbxTime pTime=FBXSDK_TIME_INFINITE, FbxNode::EPivotSet pPivotSet=FbxNode::eSourcePivot, bool pApplyTarget=false, bool pForceEval=false);

        FbxVector4& EvaluateLocalRotation(FbxTime pTime=FBXSDK_TIME_INFINITE, FbxNode::EPivotSet pPivotSet=FbxNode::eSourcePivot, bool pApplyTarget=false, bool pForceEval=false);

        FbxVector4& EvaluateLocalScaling(FbxTime pTime=FBXSDK_TIME_INFINITE, FbxNode::EPivotSet pPivotSet=FbxNode::eSourcePivot, bool pApplyTarget=false, bool pForceEval=false);


        int GetCharacterLinkCount() const;

        bool GetCharacterLink(int pIndex, FbxCharacter** pCharacter, int* pCharacterLinkType, int* pNodeId, int *pNodeSubId);

        int FindCharacterLink(FbxCharacter* pCharacter, int pCharacterLinkType, int pNodeId, int pNodeSubId) const;

    virtual bool GetAnimationInterval(FbxTimeSpan& pSpan, FbxAnimStack* pAnimStack = NULL, int pAnimLayerId = 0);



        int AddMaterial( FbxSurfaceMaterial* pMaterial );

        bool RemoveMaterial( FbxSurfaceMaterial* pMaterial );

        int GetMaterialCount() const;

        FbxSurfaceMaterial* GetMaterial( int pIndex ) const;

        void RemoveAllMaterials();

        int GetMaterialIndex( char const* pName ) const;

        FbxError& GetError();

        enum EErrorCode
        {
            eIndexOutOfRange,       
            eAttributeNotConnected, 
            eErrorCount
        };

        EErrorCode GetLastErrorID() const;

        const char* GetLastErrorString() const;


        FbxPropertyT<FbxDouble3>               LclTranslation;

        FbxPropertyT<FbxDouble3>               LclRotation;

        FbxPropertyT<FbxDouble3>               LclScaling;

        FbxPropertyT<FbxDouble>               Visibility;

        FbxPropertyT<FbxBool>                   VisibilityInheritance;


        FbxPropertyT<EFbxQuatInterpMode>  QuaternionInterpolate;

        FbxPropertyT<FbxDouble3>               RotationOffset;

        FbxPropertyT<FbxDouble3>               RotationPivot;

        FbxPropertyT<FbxDouble3>               ScalingOffset;

        FbxPropertyT<FbxDouble3>               ScalingPivot;

        FbxPropertyT<FbxBool>                 TranslationActive;

        FbxPropertyT<FbxDouble3>               Translation;

        FbxPropertyT<FbxDouble3>               TranslationMin;

        FbxPropertyT<FbxDouble3>               TranslationMax;

        FbxPropertyT<FbxBool>                 TranslationMinX;

        FbxPropertyT<FbxBool>                 TranslationMinY;

        FbxPropertyT<FbxBool>                 TranslationMinZ;

        FbxPropertyT<FbxBool>                 TranslationMaxX;

        FbxPropertyT<FbxBool>                 TranslationMaxY;

        FbxPropertyT<FbxBool>                 TranslationMaxZ;

        FbxPropertyT<EFbxRotationOrder>           RotationOrder;

        FbxPropertyT<FbxBool>                 RotationSpaceForLimitOnly;

        FbxPropertyT<FbxDouble>               RotationStiffnessX;

        FbxPropertyT<FbxDouble>               RotationStiffnessY;

        FbxPropertyT<FbxDouble>               RotationStiffnessZ;

        FbxPropertyT<FbxDouble>               AxisLen;
     
        FbxPropertyT<FbxDouble3>               PreRotation;

        FbxPropertyT<FbxDouble3>               PostRotation;

        FbxPropertyT<FbxBool>                 RotationActive;

        FbxPropertyT<FbxDouble3>               RotationMin;

        FbxPropertyT<FbxDouble3>               RotationMax;

        FbxPropertyT<FbxBool>                 RotationMinX;

        FbxPropertyT<FbxBool>                 RotationMinY;

        FbxPropertyT<FbxBool>                 RotationMinZ;

        FbxPropertyT<FbxBool>                 RotationMaxX;

        FbxPropertyT<FbxBool>                 RotationMaxY;

        FbxPropertyT<FbxBool>                 RotationMaxZ;

        FbxPropertyT<FbxTransform::EInheritType>    InheritType;

        FbxPropertyT<FbxBool>                 ScalingActive;

        FbxPropertyT<FbxDouble3>               Scaling;

        FbxPropertyT<FbxDouble3>               ScalingMin;

        FbxPropertyT<FbxDouble3>               ScalingMax;

        FbxPropertyT<FbxBool>                 ScalingMinX;

        FbxPropertyT<FbxBool>                 ScalingMinY;

        FbxPropertyT<FbxBool>                 ScalingMinZ;

        FbxPropertyT<FbxBool>                 ScalingMaxX;

        FbxPropertyT<FbxBool>                 ScalingMaxY;

        FbxPropertyT<FbxBool>                 ScalingMaxZ;

        FbxPropertyT<FbxDouble3>               GeometricTranslation;

        FbxPropertyT<FbxDouble3>               GeometricRotation;
     
        FbxPropertyT<FbxDouble3>               GeometricScaling;

        // IK Settings

        FbxPropertyT<FbxDouble>               MinDampRangeX;

        FbxPropertyT<FbxDouble>               MinDampRangeY;

        FbxPropertyT<FbxDouble>               MinDampRangeZ;

        FbxPropertyT<FbxDouble>               MaxDampRangeX;

        FbxPropertyT<FbxDouble>               MaxDampRangeY;

        FbxPropertyT<FbxDouble>               MaxDampRangeZ;

        FbxPropertyT<FbxDouble>               MinDampStrengthX;

        FbxPropertyT<FbxDouble>               MinDampStrengthY;

        FbxPropertyT<FbxDouble>               MinDampStrengthZ;

        FbxPropertyT<FbxDouble>               MaxDampStrengthX;

        FbxPropertyT<FbxDouble>               MaxDampStrengthY;

        FbxPropertyT<FbxDouble>               MaxDampStrengthZ;

        FbxPropertyT<FbxDouble>               PreferedAngleX;

        FbxPropertyT<FbxDouble>               PreferedAngleY;

        FbxPropertyT<FbxDouble>               PreferedAngleZ;

        FbxPropertyT<FbxReference>            LookAtProperty;

        FbxPropertyT<FbxReference>            UpVectorProperty;

        FbxPropertyT<FbxBool>                 Show;

        FbxPropertyT<FbxBool>                 NegativePercentShapeSupport;

        FbxPropertyT<FbxInt>              DefaultAttributeIndex;

        FbxPropertyT<FbxBool>              Freeze;

        FbxPropertyT<FbxBool>              LODBox;

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is 
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void                    AddChildName(char* pChildName);
    char*                   GetChildName(FbxUInt pIndex) const;
    FbxUInt                 GetChildNameCount() const;

    FbxTransform&           GetTransform();
    FbxLimits&              GetTranslationLimits();
    FbxLimits&              GetRotationLimits();
    FbxLimits&              GetScalingLimits();

    void                    UpdatePivotsAndLimitsFromProperties();
    void                    UpdatePropertiesFromPivotsAndLimits();

    void                    SetRotationActiveProperty(bool pVal);
    void                    PivotSetToMBTransform(EPivotSet pPivotSet);

    int                     AddCharacterLink(FbxCharacter* pCharacter, int pCharacterLinkType, int pNodeId, int pNodeSubId);
    int                     RemoveCharacterLink(FbxCharacter* pCharacter, int pCharacterLinkType, int pNodeId, int pNodeSubId);

    virtual FbxObject&      Copy(const FbxObject& pObject);
    virtual const char*     GetTypeName() const;
    virtual FbxStringList   GetTypeFlags() const;
    virtual bool            PropertyNotify(EPropertyNotifyType pType, FbxProperty* pProperty);

    enum ECullingType
    {
        eCullingOff,
        eCullingOnCCW,
        eCullingOnCW
    };

    ECullingType            mCullingType;
    bool                    mCorrectInheritType;

protected:
    FbxNode(FbxManager& pManager, char const* pName);

    virtual void        Construct(const FbxNode* pFrom);
    virtual bool        ConstructProperties(bool pForceSet);
    virtual void        Destruct(bool pRecursive, bool pDependents);
    void                Reset();
    bool                GetAnimationIntervalRecursive(FbxTimeSpan& pTimeInterval, FbxAnimLayer* pAnimLayer);

private:
    void                ResetLimitsRecursive(FbxNode* pNode);
    void                ConvertPivotAnimationRecursiveWrapper(const char * pAnimStackName, EPivotSet pConversionTarget, double pFrameRate, bool pKeyReduce);
    FbxNode&            DeepCopy(const FbxNode& pNode, bool pCopyNodeAttribute);

    FbxTransform        mTransform;
    FbxNode_internal*   mPH;
    mutable FbxError    mError;

    friend class FbxScene;
    friend class FbxGeometry;
    friend class FbxLight;
    friend class FbxNodeFinderDuplicateName;
    friend class FbxCharacter;
    friend class FbxControlSet;
    friend class FbxNode_internal;
    friend class FbxNodeEvalState;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
};

inline EFbxType FbxTypeOf(const EFbxRotationOrder&){ return eFbxEnum; }
inline EFbxType FbxTypeOf(const FbxTransform::EInheritType&){ return eFbxEnum; }
inline EFbxType FbxTypeOf(const EFbxQuatInterpMode&){ return eFbxEnum; }

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_SCENE_GEOMETRY_NODE_H_ */