kfbxnode.h

Go to the documentation of this file.

#ifndef FBXFILESDK_KFBXPLUGINS_KFBXNODE_H
#define FBXFILESDK_KFBXPLUGINS_KFBXNODE_H

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

 Copyright (C) 2001 - 2010 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 <fbxfilesdk/fbxfilesdk_def.h>

#include <fbxfilesdk/kfbxplugins/kfbxobject.h>
#include <fbxfilesdk/kfbxplugins/kfbxnodelimits.h>
#include <fbxfilesdk/kfbxplugins/kfbxgroupname.h>

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

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

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

    class KFbxNodeAttribute;
    class KFbxScene;
    class KFbxAnimStack;
    class KFbxAnimLayer;
    class KFbxSdkManager;
    class KFbxLodGroup;
    class KFbxNull;
    class KFbxMarker;
    class KFbxSkeleton;
    class KFbxGeometry;
    class KFbxMesh;
    class KFbxNurb;
    class KFbxNurbsCurve;
    class KFbxNurbsSurface;
    class KFbxTrimNurbsSurface;
    class KFbxPatch;
    class KFbxCamera;
    class KFbxCameraStereo;
    class KFbxCameraSwitcher;
    class KFbxLight;
    class KFbxOpticalReference;
    class KFbxCharacter;
    class KFbxNode_internal;
    class KFbxSurfaceMaterial;
    class KFbxSubdiv;
    class KFbxNodeEvalState;

    class KFBX_DLL KFbxNode : public KFbxObject
    {
        KFBXOBJECT_DECLARE(KFbxNode,KFbxObject);
        public:

            KFbxNode* GetParent();
            KFbxNode const* GetParent() const;

            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;



        public:
            virtual kFbxUpdateId GetUpdateId(eFbxUpdateIdType pUpdateId=eUpdateId_Object) 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;



            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);

            KFbxLodGroup* GetLodGroup();

            KFbxNull* GetNull();

            KFbxMarker* GetMarker();

            KFbxSkeleton* GetSkeleton();

            KFbxGeometry* GetGeometry();

            KFbxMesh* GetMesh();

            KFbxNurb* GetNurb();

            KFbxNurbsSurface* GetNurbsSurface();

            KFbxNurbsCurve* GetNurbsCurve();

            KFbxTrimNurbsSurface* GetTrimNurbsSurface();

            KFbxSubdiv* GetSubdiv();

            KFbxPatch* GetPatch();

            KFbxCamera* GetCamera();

            KFbxCameraSwitcher* GetCameraSwitcher();

            KFbxLight* GetLight();

            KFbxOpticalReference* GetOpticalReference();


            K_DEPRECATED void SetDefaultT(const KFbxVector4& pT);

            K_DEPRECATED KFbxVector4& GetDefaultT(KFbxVector4& pT);

            K_DEPRECATED void SetDefaultR(const KFbxVector4& pR);

            K_DEPRECATED KFbxVector4& GetDefaultR(KFbxVector4& pR);

            K_DEPRECATED void SetDefaultS(const KFbxVector4& pS);

            K_DEPRECATED KFbxVector4& GetDefaultS(KFbxVector4& pS);

            void SetDefaultVisibility(double pVisibility);

            double GetDefaultVisibility() const;


            void SetTransformationInheritType(ETransformInheritType pInheritType);

            void GetTransformationInheritType(ETransformInheritType& pInheritType) const;


            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) const;

            void SetRotationOrder(EPivotSet pPivotSet, ERotationOrder pRotationOrder);

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

            void SetUseRotationSpaceForLimitOnly(EPivotSet pPivotSet, bool pUseForLimitOnly);

            bool GetUseRotationSpaceForLimitOnly(EPivotSet pPivotSet) const;

            void SetRotationActive(bool pVal);

            bool GetRotationActive() const;

            void SetUseQuaternionForInterpolation(EPivotSet pPivotSet, bool pUseQuaternion);

            bool GetUseQuaternionForInterpolation(EPivotSet pPivotSet) const;

            void SetRotationStiffness(KFbxVector4 pRotationStiffness);

            KFbxVector4 GetRotationStiffness() const;

            void SetMinDampRange(KFbxVector4 pMinDampRange);

            KFbxVector4 GetMinDampRange() const;


            void SetMaxDampRange(KFbxVector4 pMaxDampRange);

            KFbxVector4 GetMaxDampRange() const;


            void SetMinDampStrength(KFbxVector4 pMinDampStrength);

            KFbxVector4 GetMinDampStrength() const;


            void SetMaxDampStrength(KFbxVector4 pMaxDampStrength);

            KFbxVector4 GetMaxDampStrength() const;

            void SetPreferedAngle(KFbxVector4 pPreferedAngle);

            KFbxVector4 GetPreferedAngle() const;

            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) const;

            void SetGeometricScaling(EPivotSet pPivotSet, KFbxVector4 pVector);

            KFbxVector4 GetGeometricScaling(EPivotSet pPivotSet) const;

            void ResetPivotSet( KFbxNode::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(KFbxVector4 pParentGeometricOffset = KFbxVector4());


            K_DEPRECATED KFbxVector4& GetLocalTFromDefault(bool pApplyLimits = false);
            K_DEPRECATED KFbxVector4& GetLocalTFromDefaultTake(bool pApplyLimits = false);

            K_DEPRECATED KFbxVector4& GetLocalRFromDefault(bool pApplyLimits = false);
            K_DEPRECATED KFbxVector4& GetLocalRFromDefaultTake(bool pApplyLimits = false);

            K_DEPRECATED KFbxVector4& GetLocalSFromDefault(bool pApplyLimits = false);
            K_DEPRECATED KFbxVector4& GetLocalSFromDefaultTake(bool pApplyLimits = false);

            K_DEPRECATED KFbxXMatrix& GetGlobalFromDefault(EPivotSet pPivotSet = eSOURCE_SET, bool pApplyTarget = false);
            K_DEPRECATED KFbxXMatrix& GetGlobalFromDefaultTake(EPivotSet pPivotSet = eSOURCE_SET, bool pApplyTarget = false);

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

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

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

            K_DEPRECATED KFbxXMatrix& GetGlobalFromCurrentTake(KTime pTime, EPivotSet pPivotSet = eSOURCE_SET, bool pApplyTarget = false);


            int GetCharacterLinkCount() const;

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

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

        virtual bool GetAnimationInterval(KTime& pStart, KTime& pStop, KFbxAnimStack* pAnimStack = NULL, int pAnimLayerId = 0);



            int AddMaterial( KFbxSurfaceMaterial* pMaterial );

            bool RemoveMaterial( KFbxSurfaceMaterial* pMaterial );

            int GetMaterialCount() const;

            KFbxSurfaceMaterial* GetMaterial( int pIndex ) const;

            void RemoveAllMaterials();

            int GetMaterialIndex( char const* pName ) const;



            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() const;

            const char* GetLastErrorString() const;




            KFbxTypedProperty<fbxDouble3>               LclTranslation;

            KFbxTypedProperty<fbxDouble3>               LclRotation;

            KFbxTypedProperty<fbxDouble3>               LclScaling;

            KFbxTypedProperty<KFbxXMatrix>              GlobalTransform;

            KFbxTypedProperty<fbxDouble1>               Visibility;
            
            KFbxTypedProperty<fbxDouble1>               Weight;

            KFbxTypedProperty<fbxDouble3>               PoleVector;

            KFbxTypedProperty<fbxDouble1>               Twist;

            KFbxTypedProperty<fbxDouble3>               WorldUpVector;

            KFbxTypedProperty<fbxDouble3>               UpVector;

            KFbxTypedProperty<fbxDouble3>               AimVector;

            KFbxTypedProperty<fbxBool1>                 QuaternionInterpolate;

            KFbxTypedProperty<fbxDouble3>               RotationOffset;

            KFbxTypedProperty<fbxDouble3>               RotationPivot;
 
            KFbxTypedProperty<fbxDouble3>               ScalingOffset;

            KFbxTypedProperty<fbxDouble3>               ScalingPivot;

            KFbxTypedProperty<fbxBool1>                 TranslationActive;

            KFbxTypedProperty<fbxDouble3>               Translation;

            KFbxTypedProperty<fbxDouble3>               TranslationMin;

            KFbxTypedProperty<fbxDouble3>               TranslationMax;

            KFbxTypedProperty<fbxBool1>                 TranslationMinX;

            KFbxTypedProperty<fbxBool1>                 TranslationMinY;

            KFbxTypedProperty<fbxBool1>                 TranslationMinZ;

            KFbxTypedProperty<fbxBool1>                 TranslationMaxX;

            KFbxTypedProperty<fbxBool1>                 TranslationMaxY;

            KFbxTypedProperty<fbxBool1>                 TranslationMaxZ;

            KFbxTypedProperty<ERotationOrder>           RotationOrder;

            KFbxTypedProperty<fbxBool1>                 RotationSpaceForLimitOnly;

            KFbxTypedProperty<fbxDouble1>               RotationStiffnessX;

            KFbxTypedProperty<fbxDouble1>               RotationStiffnessY;

            KFbxTypedProperty<fbxDouble1>               RotationStiffnessZ;

            KFbxTypedProperty<fbxDouble1>               AxisLen;
         
            KFbxTypedProperty<fbxDouble3>               PreRotation;

            KFbxTypedProperty<fbxDouble3>               PostRotation;

            KFbxTypedProperty<fbxBool1>                 RotationActive;

            KFbxTypedProperty<fbxDouble3>               RotationMin;

            KFbxTypedProperty<fbxDouble3>               RotationMax;

            KFbxTypedProperty<fbxBool1>                 RotationMinX;

            KFbxTypedProperty<fbxBool1>                 RotationMinY;

            KFbxTypedProperty<fbxBool1>                 RotationMinZ;

            KFbxTypedProperty<fbxBool1>                 RotationMaxX;

            KFbxTypedProperty<fbxBool1>                 RotationMaxY;

            KFbxTypedProperty<fbxBool1>                 RotationMaxZ;

            KFbxTypedProperty<ETransformInheritType>    InheritType;

            KFbxTypedProperty<fbxBool1>                 ScalingActive;

            KFbxTypedProperty<fbxDouble3>               Scaling;

            KFbxTypedProperty<fbxDouble3>               ScalingMin;

            KFbxTypedProperty<fbxDouble3>               ScalingMax;

            KFbxTypedProperty<fbxBool1>                 ScalingMinX;

            KFbxTypedProperty<fbxBool1>                 ScalingMinY;

            KFbxTypedProperty<fbxBool1>                 ScalingMinZ;

            KFbxTypedProperty<fbxBool1>                 ScalingMaxX;

            KFbxTypedProperty<fbxBool1>                 ScalingMaxY;

            KFbxTypedProperty<fbxBool1>                 ScalingMaxZ;

            KFbxTypedProperty<fbxDouble3>               GeometricTranslation;

            KFbxTypedProperty<fbxDouble3>               GeometricRotation;
         
            KFbxTypedProperty<fbxDouble3>               GeometricScaling;

            // IK Settings

            KFbxTypedProperty<fbxDouble1>               MinDampRangeX;

            KFbxTypedProperty<fbxDouble1>               MinDampRangeY;

            KFbxTypedProperty<fbxDouble1>               MinDampRangeZ;

            KFbxTypedProperty<fbxDouble1>               MaxDampRangeX;

            KFbxTypedProperty<fbxDouble1>               MaxDampRangeY;

            KFbxTypedProperty<fbxDouble1>               MaxDampRangeZ;

            KFbxTypedProperty<fbxDouble1>               MinDampStrengthX;

            KFbxTypedProperty<fbxDouble1>               MinDampStrengthY;

            KFbxTypedProperty<fbxDouble1>               MinDampStrengthZ;

            KFbxTypedProperty<fbxDouble1>               MaxDampStrengthX;

            KFbxTypedProperty<fbxDouble1>               MaxDampStrengthY;

            KFbxTypedProperty<fbxDouble1>               MaxDampStrengthZ;

            KFbxTypedProperty<fbxDouble1>               PreferedAngleX;

            KFbxTypedProperty<fbxDouble1>               PreferedAngleY;

            KFbxTypedProperty<fbxDouble1>               PreferedAngleZ;

            KFbxTypedProperty<fbxReference*>            LookAtProperty;

            KFbxTypedProperty<fbxReference*>            UpVectorProperty;

            KFbxTypedProperty<fbxBool1>                 Show;

            KFbxTypedProperty<fbxBool1>                 NegativePercentShapeSupport;

            KFbxTypedProperty<fbxInteger1>              DefaultAttributeIndex;

            KFbxTypedProperty<fbxBool1>              Freeze;

            KFbxTypedProperty<fbxBool1>              LODBox;


        #ifndef DOXYGEN_SHOULD_SKIP_THIS
        //  WARNING!
        //  Anything beyond these lines may not be documented accurately and is
        //  subject to change without notice.
        public:
            void SetMultiLayer(bool pMultiLayer);

            bool GetMultiLayer() const;

            typedef enum
            {
                eOLD_MULTI_TAKE,
                eMULTI_TAKE,
                eMONO_TAKE
            } EMultiTakeMode;

            void SetMultiTakeMode(EMultiTakeMode pMultiTakeMode);

            EMultiTakeMode GetMultiTakeMode() const;

                void ForceEvalOfState(bool pGlobal=false);

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

                void SetDefaultFromLocalState(bool pRecursive);
                K_DEPRECATED void SetDefaultTakeFromLocalState(bool pRecursive);

                void SetLocalStateFromAnim(KTime pTime, bool pRecursive, KFbxAnimStack* pAnimStack, bool pApplyLimits = false);
                K_DEPRECATED void SetLocalStateFromCurrentTake(KTime pTime, bool pRecursive,bool pApplyLimits = false);

                void SetAnimFromLocalState(KTime pTime, bool pRecursive, KFbxAnimStack* pAnimStack);
                K_DEPRECATED void SetCurrentTakeFromLocalState(KTime pTime, bool pRecursive);

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

                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() const;

                void SetLocalStateId(kUInt pUpdateId, bool pRecursive);

                kUInt GetLocalStateId() const;

            KFbxNodeLimits& GetLimits();

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

            virtual bool PropertyNotify(eFbxPropertyNotify pType, KFbxProperty* pProperty);

        protected:
            KFbxNode(KFbxSdkManager& pManager, char const* pName);
            
            virtual void Construct(const KFbxNode* pFrom);
            virtual bool ConstructProperties(bool pForceSet);
            virtual void Destruct(bool pRecursive, bool pDependents);

            void    Reset();
            bool    GetAnimationIntervalRecursive(KTime& pStart, KTime& pStop, KFbxAnimLayer* pAnimLayer);

        private:
            void    ResetLimitsRecursive(KFbxNode* pNode);

            // a wrapper function for ConvertPivotAnimationRecursive 
            // to avoid stack over flow when exporting scene with deep hierarchy
            void ConvertPivotAnimationRecursiveWrapper(const char * pAnimStackName,
                EPivotSet pConversionTarget, double pFrameRate, bool pKeyReduce );

        public:
            virtual KFbxObject& Copy(const KFbxObject& pObject);

            void    AddChildName(char* pChildName);

            char*   GetChildName(kUInt pIndex) const;

            kUInt   GetChildNameCount() const;

            void UpdatePivotsAndLimitsFromProperties();
            
            void UpdatePropertiesFromPivotsAndLimits();

            void SetRotationActiveProperty(bool pVal);

            void PivotSetToMBTransform(EPivotSet pPivotSet);

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

            virtual KString     GetTypeName() const;

            virtual KStringList GetTypeFlags() const;

        protected:
            KMBTransform*       GetMBTransform();

            // begin character related members
            int AddCharacterLink(KFbxCharacter* pCharacter, int pCharacterLinkType, int pNodeId, int pNodeSubId);
            int RemoveCharacterLink(KFbxCharacter* pCharacter, int pCharacterLinkType, int pNodeId, int pNodeSubId);
            // This class must be declared public, otherwise gcc complains on typedef below.

        private:
            KFbxNode& DeepCopy( KFbxNode const& pNode, bool pCopyNodeAttribute );

        public:
            // 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;

            bool                        mCorrectInheritType;

        protected:
            KFbxNode_internal*          mPH;
            mutable KError              mError;

            friend class KFbxScene;
            friend class KFbxGeometry;
            friend class KFbxLight;
            friend class KFbxNodeFinderDuplicateName;
            friend class KFbxCharacter;
            friend class KFbxControlSet;
            friend class KFbxNode_internal;
            friend class KFbxSurfaceMaterial_internal;
            friend class KFbxTexture_internal;
            friend class KFbxVideo_internal;

            friend class KFbxNodeLimits;
            friend class KFbxLimits;
            friend class KFbxNodeEvalState;
        #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
    };

    typedef KFbxNode* HKFbxNode;
    typedef class KFBX_DLL KArrayTemplate<KFbxNode*> KArrayKFbxNode;

    inline EFbxType FbxTypeOf( ERotationOrder const &pItem )            { return eENUM; }
    inline EFbxType FbxTypeOf( ETransformInheritType const &pItem )     { return eENUM; }

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXNODE_H