kfbxnode.h

Go to the documentation of this file.

#ifndef _FBXSDK_NODE_H_
#define _FBXSDK_NODE_H_

/**************************************************************************************

 Copyright © 1999 - 2007 Autodesk, Inc. and/or its licensors.
 All Rights Reserved.

 The coded instructions, statements, computer programs, and/or related material
 (collectively the "Data") in these files contain unpublished information
 proprietary to Autodesk, Inc. and/or its licensors, which is protected by
 Canada and United States of America federal copyright law and by international
 treaties.

 The Data may not be disclosed or distributed to third parties, in whole or in
 part, without the prior written consent of Autodesk, Inc. ("Autodesk").

 THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY.
 ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO
 WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR ARISING
 BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES OF TITLE,
 NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE OR USE.
 WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT WARRANT THAT THE OPERATION
 OF THE DATA WILL BE UNINTERRUPTED OR ERROR FREE.

 IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS
 OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR EXPENSES
 OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE DAMAGES OR OTHER
 SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS OF PROFITS, REVENUE
 OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR DAMAGES OF ANY KIND),
 HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF LIABILITY, WHETHER DERIVED
 FROM CONTRACT, TORT (INCLUDING, BUT NOT LIMITED TO, NEGLIGENCE), OR OTHERWISE,
 ARISING OUT OF OR RELATING TO THE DATA OR ITS USE OR ANY OTHER PERFORMANCE,
 WHETHER OR NOT AUTODESK HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS
 OR DAMAGE.

**************************************************************************************/

#include <kaydaradef.h>
#ifndef KFBX_DLL 
    #define KFBX_DLL K_DLLIMPORT
#endif

#include <kaydara.h>

#include <kfbxplugins/kfbxtakenodecontainer.h>
#include <kfbxplugins/kfbxnodelimits.h>
#include <kfbxplugins/kfbxgroupname.h>

#include <kfbxmath/kfbxtransformation.h>
#include <kfbxmath/kfbxvector4.h>
#include <kfbxmath/kfbxmatrix.h>
#include <kfbxmath/kfbxxmatrix.h>

#include <klib/karrayul.h>
#include <klib/kerror.h>
#include <klib/kstring.h>
#include <klib/ktime.h>

#ifndef MB_FBXSDK
#include <kbaselib_nsuse.h>
#endif
#include <kbaselib_forward.h>

#include <fbxfilesdk_nsbegin.h>

class KFbxNodeAttribute;
class KFbxScene;
class KFbxSdkManager;
class KFbxNull;
class KFbxMarker;
class KFbxSkeleton;
class KFbxGeometry;
class KFbxMesh;
class KFbxNurb;
class KFbxNurbsCurve;
class KFbxNurbsSurface;
class KFbxTrimNurbsSurface;
class KFbxPatch;
class KFbxCamera;
class KFbxCameraSwitcher;
class KFbxLight;
class KFbxOpticalReference;
class KFbxCharacter;
class KFbxNode_internal;
class KFbxSurfaceMaterial_internal;
class KFbxNodeAttribute_internal;



class KFBX_DLL KFbxNode : public KFbxTakeNodeContainer
{
    KFBXOBJECT_DECLARE(KFbxNode);
public:

    KFbxNode* GetParent();

    bool AddChild(KFbxNode* pNode);
    
    KFbxNode* RemoveChild(KFbxNode* pNode);

    int GetChildCount(bool pRecursive = false) const;

    KFbxNode* GetChild(int pIndex);
    
    KFbxNode const* GetChild(int pIndex) const;
    
    KFbxNode* FindChild(char const* pName, bool pRecursive = true, bool pInitial = false);
    


    void SetTarget(KFbxNode* pNode);

    KFbxNode* GetTarget() const;

    void SetPostTargetRotation(KFbxVector4 pVector);

    KFbxVector4 GetPostTargetRotation() const;

    void SetTargetUp(KFbxNode* pNode);

    KFbxNode* GetTargetUp() const;

    void SetTargetUpVector(KFbxVector4 pVector);

    KFbxVector4 GetTargetUpVector() const;



    void SetVisibility(bool pIsVisible);
    
    bool GetVisibility() const;

    typedef enum 
    {
        eHARD_SHADING,          
        eWIRE_FRAME,            
        eFLAT_SHADING,
        eLIGHT_SHADING,
        eTEXTURE_SHADING,
        eLIGHT_TEXTURE_SHADING
    } EShadingMode;

    void SetShadingMode(EShadingMode pShadingMode);
    
    EShadingMode GetShadingMode() const;

    void SetMultiLayer(bool pMultiLayer);

    bool GetMultiLayer() const;

    typedef enum 
    {
        eOLD_MULTI_TAKE,
        eMULTI_TAKE,
        eMONO_TAKE
    } EMultiTakeMode;
    
    void SetMultiTakeMode(EMultiTakeMode pMultiTakeMode);
    
    EMultiTakeMode GetMultiTakeMode() const;



    KFbxNodeAttribute* SetNodeAttribute(KFbxNodeAttribute* pNodeAttribute);
    
    KFbxNodeAttribute* GetNodeAttribute();

    KFbxNodeAttribute const* GetNodeAttribute() const;

    int GetNodeAttributeCount() const;

    int GetDefaultNodeAttributeIndex() const;

    bool SetDefaultNodeAttributeIndex(int pIndex);

    KFbxNodeAttribute* GetNodeAttributeByIndex(int pIndex);

    KFbxNodeAttribute const* GetNodeAttributeByIndex(int pIndex) const;

    int GetNodeAttributeIndex(KFbxNodeAttribute* pNodeAttribute) const;

    bool AddNodeAttribute(KFbxNodeAttribute* pNodeAttribute);

    KFbxNodeAttribute* RemoveNodeAttribute(KFbxNodeAttribute* pNodeAttribute);

    KFbxNodeAttribute* RemoveNodeAttributeByIndex(int pIndex);

    KFbxNull* GetNull();

    KFbxMarker* GetMarker();

    KFbxSkeleton* GetSkeleton();

    KFbxGeometry* GetGeometry();
    
    KFbxMesh* GetMesh();

    KFbxNurb* GetNurb();

    KFbxNurbsSurface* GetNurbsSurface();

    KFbxNurbsCurve* GetNurbsCurve();

    KFbxTrimNurbsSurface* GetTrimNurbsSurface();

    KFbxPatch* GetPatch();
    
    KFbxCamera* GetCamera();

    KFbxCameraSwitcher* GetCameraSwitcher();

    KFbxLight* GetLight();

    KFbxOpticalReference* GetOpticalReference();



    void SetDefaultT(const KFbxVector4& pT);

    KFbxVector4& GetDefaultT(KFbxVector4& pT);

    void SetDefaultR(const KFbxVector4& pR);

    KFbxVector4& GetDefaultR(KFbxVector4& pR);

    void SetDefaultS(const KFbxVector4& pS);

    KFbxVector4& GetDefaultS(KFbxVector4& pS);

    void SetDefaultVisibility(double pVisibility);

    double GetDefaultVisibility();



    void SetTransformationInheritType(ETransformInheritType pInheritType);

    void GetTransformationInheritType(ETransformInheritType& pInheritType);




    typedef enum  
    { 
        eSOURCE_SET,          
        eDESTINATION_SET
    } EPivotSet;

    typedef enum 
    {
        ePIVOT_STATE_ACTIVE,
        ePIVOT_STATE_REFERENCE
    } EPivotState;

    void SetPivotState(EPivotSet pPivotSet, EPivotState pPivotState);

    void GetPivotState(EPivotSet pPivotSet, EPivotState& pPivotState);

    void SetRotationOrder(EPivotSet pPivotSet, ERotationOrder pRotationOrder);

    void GetRotationOrder(EPivotSet pPivotSet, ERotationOrder& pRotationOrder);

    void SetUseRotationSpaceForLimitOnly(EPivotSet pPivotSet, bool pUseForLimitOnly);

    bool GetUseRotationSpaceForLimitOnly(EPivotSet pPivotSet);

    void SetRotationActive(bool pVal);

    bool GetRotationActive();

    void SetUseQuaternionForInterpolation(EPivotSet pPivotSet, bool pUseQuaternion);

    bool GetUseQuaternionForInterpolation(EPivotSet pPivotSet) const;

    void SetRotationStiffness(KFbxVector4 pRotationStiffness);

    KFbxVector4 GetRotationStiffness();


    void SetMinDampRange(KFbxVector4 pMinDampRange);

    KFbxVector4 GetMinDampRange();

    
    void SetMaxDampRange(KFbxVector4 pMaxDampRange);
    
    KFbxVector4 GetMaxDampRange();


    void SetMinDampStrength(KFbxVector4 pMinDampStrength);
    
    KFbxVector4 GetMinDampStrength();


    void SetMaxDampStrength(KFbxVector4 pMaxDampStrength);
    
    KFbxVector4 GetMaxDampStrength();

    
    void SetPreferedAngle(KFbxVector4 pPreferedAngle);
    
    KFbxVector4 GetPreferedAngle();


    void SetRotationOffset(EPivotSet pPivotSet, KFbxVector4 pVector);

    KFbxVector4& GetRotationOffset(EPivotSet pPivotSet) const;

    void SetRotationPivot(EPivotSet pPivotSet, KFbxVector4 pVector);

    KFbxVector4& GetRotationPivot(EPivotSet pPivotSet) const;

    void SetPreRotation(EPivotSet pPivotSet, KFbxVector4 pVector);
    
    KFbxVector4& GetPreRotation(EPivotSet pPivotSet) const;
    
    void SetPostRotation(EPivotSet pPivotSet, KFbxVector4 pVector);

    KFbxVector4& GetPostRotation(EPivotSet pPivotSet) const;

    void SetScalingOffset(EPivotSet pPivotSet, KFbxVector4 pVector);

    KFbxVector4& GetScalingOffset(EPivotSet pPivotSet) const;

    void SetScalingPivot(EPivotSet pPivotSet, KFbxVector4 pVector);

    KFbxVector4& GetScalingPivot(EPivotSet pPivotSet) const;

    void SetGeometricTranslation(EPivotSet pPivotSet, KFbxVector4 pVector);

    KFbxVector4 GetGeometricTranslation(EPivotSet pPivotSet) const;

    void SetGeometricRotation(EPivotSet pPivotSet, KFbxVector4 pVector);

    KFbxVector4 GetGeometricRotation(EPivotSet pPivotSet);

    void SetGeometricScaling(EPivotSet pPivotSet, KFbxVector4 pVector);

    KFbxVector4 GetGeometricScaling(EPivotSet pPivotSet);

    void ConvertPivotAnimation(EPivotSet pConversionTarget, double pFrameRate, bool pKeyReduce=true);

    void ConvertPivotAnimationRecursive(EPivotSet pConversionTarget, double pFrameRate, bool pKeyReduce=true);

    void ResetPivotSet( KFbxNode::EPivotSet pPivotSet );

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


    KFbxVector4& GetLocalTFromDefaultTake(bool pApplyLimits = false);

    KFbxVector4& GetLocalRFromDefaultTake(bool pApplyLimits = false);

    KFbxVector4& GetLocalSFromDefaultTake(bool pApplyLimits = false);

    KFbxXMatrix& GetGlobalFromDefaultTake(EPivotSet pPivotSet = eSOURCE_SET);

    KFbxVector4& GetLocalTFromCurrentTake(KTime pTime, bool pApplyLimits = false);

    KFbxVector4& GetLocalRFromCurrentTake(KTime pTime, bool pApplyLimits = false);

    KFbxVector4& GetLocalSFromCurrentTake(KTime pTime, bool pApplyLimits = false);

    KFbxXMatrix& GetGlobalFromCurrentTake(KTime pTime, EPivotSet pPivotSet = eSOURCE_SET);




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

    int FindCharacterLink(KFbxCharacter* pCharacter, int pCharacterLinkType, int pNodeId, int pNodeSubId);


    virtual bool GetAnimationInterval(KTime& pStart, KTime& pStop);


    KError& GetError();

    typedef enum 
    {
        eTAKE_NODE_ERROR,
        eNODE_NAME_CLASH,
        eMATERIAL_NAME_CLASH,
        eTEXTURE_NAME_CLASH,
        eVIDEO_NAME_CLASH,
        eNOT_A_CHILD,
        eCYCLIC_GRAPH,
        eINDEX_OUT_OF_RANGE,
        eATTRIBUTE_NOT_CONNECTED,
        eERROR_COUNT
    } EError;   

    EError GetLastErrorID();

    char* GetLastErrorString();



    virtual bool SetCurrentTakeNode(int pIndex);

    virtual bool SetCurrentTakeNode(char* pName);


//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is 
//  subject to change without notice.
//

#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:


    void SetLocalStateFromDefaultTake(bool pRecursive, bool pApplyLimits = false); 

    void SetDefaultTakeFromLocalState(bool pRecursive);

    void SetLocalStateFromCurrentTake(KTime pTime, bool pRecursive,bool pApplyLimits = false); 

    void SetCurrentTakeFromLocalState(KTime pTime, bool pRecursive);

    void ComputeGlobalState(kUInt pUpdateId, bool pRecursive, EPivotSet pPivotSet = eSOURCE_SET); 

    void ComputeLocalState(kUInt pUpdateId, bool pRecursive);

    void SetGlobalState(const KFbxXMatrix& pGX);

    KFbxXMatrix& GetGlobalState();

    void SetLocalState(const KFbxVector4& pLT,const KFbxVector4& pLR, const KFbxVector4& pLS); 

    void GetLocalState(KFbxVector4& pLT, KFbxVector4& pLR, KFbxVector4& pLS);

    void SetGlobalStateId(kUInt pUpdateId, bool pRecursive); 

    kUInt GetGlobalStateId();

    void SetLocalStateId(kUInt pUpdateId, bool pRecursive); 

    kUInt GetLocalStateId();


    KFbxNodeLimits& GetLimits() { return *mLimits; }

    bool GetSelected(bool pRecursive = false);
    void SetSelected(bool pSelected, bool pRecursive = false);

    // This class must be declared public, otherwise gcc complains on typedef below.
    class KFBX_DLL KFbxLinkToCharacter
    {
    
    public:

        bool operator==(KFbxLinkToCharacter& pLinkToCharacter);
    
        KFbxCharacter* mCharacter;
        int mType;
        int mIndex;
        int mSubIndex;  
    };

    // Clone
    virtual KFbxObject* Clone(KFbxObject::ECloneType pCloneType = eDEEP_CLONE) const;

protected:
    static char const* GetNamePrefix() { return MODEL_PREFIX; }

    KFbxNode(KFbxSdkManager& pManager, char const* pName);
    virtual ~KFbxNode();

    virtual void Destruct(bool pRecursive, bool pDependents);

    KFbxNode& operator=(KFbxNode const& pNode); 

    void    Reset();
    virtual KFbxObject::ENameSpace GetNameSpace() const;
    bool GetAnimationIntervalRecursive(KTime& pStart, KTime& pStop);    

    virtual void AddChannels(KFbxTakeNode *pTakeNode);

    void AddChildName(char* pChildName);
    char* GetChildName(kUInt pIndex);
    kUInt GetChildNameCount();
        
public:
    void UpdatePivotsAndLimitsFromProperties();
    void UpdatePropertiesFromPivotsAndLimits();
    void SetRotationActiveProperty(bool pVal);

    void PivotSetToMBTransform(EPivotSet pPivotSet);

    bool mCorrectInheritType;

    virtual KObject* GetFbxObject_internal();
    virtual KObject const*  GetFbxObject_internal() const;
protected:
    KFbxNode_internal* mPH;

    virtual KString     GetTypeName() const;
    virtual KStringList GetTypeFlags() const;

    KArrayTemplate<KString*> mChildrenNameList;

    KFbxNode* mTarget;
    KFbxNode* mUp;
    KFbxVector4 mPostTargetRotation;
    KFbxVector4 mTargetUpVector;

    EShadingMode mShadingMode;
    bool mMultiLayer;
    EMultiTakeMode mMultiTakeMode;

    KMBTransform* GetMBTransform();

    // begin cache related members and functions

    class KFBX_DLL KFbxTRSCache
    {
  
    public:
    
        KFbxTRSCache();
        ~KFbxTRSCache();

        void Reset();

        int mTIndex;
        int mRIndex;
        int mSIndex;

        // Local
        KTime mLocalTTime;
        KTime mLocalRTime;
        KTime mLocalSTime;
        
        bool mLocalTValid;
        bool mLocalRValid;
        bool mLocalSValid;

        KFbxVector4 mLocalT;
        KFbxVector4 mLocalR;
        KFbxVector4 mLocalS;

        // Global
        bool mGlobalValid;
        
        KTime mGlobalTime;
        KFbxXMatrix mGlobalMatrix;

        KFbxVector4 mGlobalT;
        KFbxXMatrix mGlobalR;
        KFbxXMatrix mGlobalS;
        
    };

    void ComputeTRSLocalFromDefaultTake(bool pApplyLimits = false);
    void ComputeTRSLocalFromCurrentTake(KTime pTime, bool pApplyLimits = false);


    KFbxTRSCache mTRSCache;
    KFbxTRSCache mDefaultTRSCache;

    // end cache related members and functions

    // begin state related members and functions

    class KFBX_DLL KFbxState
    {

    public:

        KFbxState();
        ~KFbxState();

        void Reset();

        kUInt mId;
        
        KFbxXMatrix mMatrix;

        KFbxVector4 mT;
        KFbxXMatrix mR;
        KFbxXMatrix mS;
    };

    KFbxState mLocalState;
    KFbxState mGlobalState;

    // end state related members and functions

    KFbxNodeLimits* mLimits;

    bool mSelected;

    // begin character related members
    
    int AddCharacterLink(KFbxCharacter* pCharacter, int pCharacterLinkType, int pNodeId, int pNodeSubId);
    int RemoveCharacterLink(KFbxCharacter* pCharacter, int pCharacterLinkType, int pNodeId, int pNodeSubId);

    KArrayTemplate<KFbxLinkToCharacter> mLinkToCharacter;

    // end character related members

    mutable KError mError;

    friend class KFbxReaderFbx;
    friend class KFbxReaderFbx6;
    friend class KFbxWriterFbx;
    friend class KFbxWriterFbx6;
    friend class KFbxScene;
    friend class KFbxGeometry;
    friend class KFbxLight;
    friend class KFbxNodeFinderDuplicateName;
    friend class KFbxCharacter;
    friend class KFbxControlSet;
    friend class KFbxNode_internal;
    friend class KFbxNodeAttribute_internal;
    friend class KFbxSurfaceMaterial_internal; 
    friend class KFbxTexture_internal; 
    friend class KFbxVideo_internal;

    friend class KFbxNodeLimits;
    friend class KFbxLimits; 

    // Unsupported parameters in the FBX SDK
    // These are declared but not accessible
    // They are used to keep imported and exported data identical

    typedef enum { eCULLING_OFF, eCULLING_ON_CCW, eCULLING_ON_CW } ECullingType;

    ECullingType mCullingType;

public:
    KFbxXMatrix GetLXFromLocalState( bool pT, bool pR, bool pS, bool pSoff );

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

};

typedef class KFBX_DLL KArrayTemplate<KFbxNode::KFbxLinkToCharacter> KArrayKFbxNodeKFbxLinkToCharacter;
typedef KFbxNode* HKFbxNode;
typedef class KFBX_DLL KArrayTemplate<KFbxNode*> KArrayKFbxNode;

#include <fbxfilesdk_nsend.h>

#endif // #ifndef _FBXSDK_NODE_H_