kfcurvenode.h

Go to the documentation of this file.

#ifndef FBXFILESDK_COMPONENTS_KFCURVE_KFCURVENODE_H
#define FBXFILESDK_COMPONENTS_KFCURVE_KFCURVENODE_H

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

 Copyright (C) 2001 - 2009 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/components/kfcurve/kfcurve_h.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/kfcurve/kfcurve.h>

#ifndef KFBX_PLUGIN
    #include <fbxfilesdk/components/kfcurve/i/ifcurveeti.h>
    #include <fbxfilesdk/components/kbaselib/object/i/iobject.h>
    #include <fbxfilesdk/components/kbaselib/object/i/ifbobjectholder.h>
#endif

KFBX_FORWARD (IConnector) 
KFBX_FORWARD (IData) 

#include <fbxfilesdk/components/kbaselib/kbaselib_forward.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

    enum 
    {   
        KFCN_IN = 0, 
        KFCN_OUT = 1, 
        KFCN_INOUT_MASK = 1, 

        KFCN_HIDDEN = 0, 
        KFCN_SHOWN = 2, 

        KFCN_CONTAINER_NODE = 0, 
        KFCN_REFERENCER_NODE = 8, 
        KFCN_REFERENCER_MASK = 8, 

        KFCN_TAKE_NODE = 16, 
        KFCN_FIXED_NODE = 0, 
        KFCN_TAKE_MASK = 16,

        KFCN_EXPENDED_NODE = 32, 
        KFCN_NOTEXPENDED_NODE = 0, 
        KFCN_EXPENDED_MASK = 32,

        KFCN_MULTILAYER = 64,
        KFCN_MONOLAYER  = 0,
        KFCN_MULTILAYER_MASK = 64,

        KFCN_ALWAYS_CANDIDATE = 128,
        KFCN_ALWAYS_CANDIDATE_TESTED = 256
    };

    //
    // Picking Types define
    //
    enum 
    {
        KCP_KEY = 1, 
        KCP_LTANGENT, 
        KCP_RTANGENT
    };

    //
    //  Node/Layer info
    //
    enum
    {
        KFCL_NOLAYER,
        KFCL_ADD,       // For translation and standard others
        KFCL_EULER_XYZ, // For rotation
        KFCL_MULT,      // For scaling, mainly
        KFCL_QUAT       // For quaternion rotation
    };

    #define KFCURVENODE_TRANSFORM               "Transform"
        #define KFCURVENODE_T                       "T"
            #define KFCURVENODE_T_X                     "X"
            #define KFCURVENODE_T_Y                     "Y"
            #define KFCURVENODE_T_Z                     "Z"
        #define KFCURVENODE_R                       "R"
            #define KFCURVENODE_R_X                     "X"
            #define KFCURVENODE_R_Y                     "Y"
            #define KFCURVENODE_R_Z                     "Z"
            #define KFCURVENODE_R_W                     "W"
        #define KFCURVENODE_S                       "S"
            #define KFCURVENODE_S_X                     "X"
            #define KFCURVENODE_S_Y                     "Y"
            #define KFCURVENODE_S_Z                     "Z"
    #define KFCURVENODE_LCL_T                   "Lcl Translation"
    #define KFCURVENODE_LCL_R                   "Lcl Rotation"
    #define KFCURVENODE_LCL_S                   "Lcl Scaling"
    #define KFCURVENODE_VISIBILITY              "Visibility"

    // Addition for the optical marker node attribute.
    #define KFCURVENODE_OCCLUSION               "Occlusion"

    // Addition for the IK effector marker node attribute.
    #define KFCURVENODE_IK_REACH_TRANSLATION    "IK Reach Translation"
    #define KFCURVENODE_IK_REACH_ROTATION       "IK Reach Rotation"

    // Addition for the light node attribute.
    #define KFCURVENODE_LIGHT_CONEANGLE         "Cone angle"
    #define KFCURVENODE_LIGHT_FOG               "Fog"
    #define KFCURVENODE_LIGHT_INTENSITY         "Intensity"
    #define KFCURVENODE_COLOR                   "Color"
    #define KFCURVENODE_COLOR_RED                   "X"
    #define KFCURVENODE_COLOR_GREEN                 "Y"
    #define KFCURVENODE_COLOR_BLUE                  "Z"

    // Addition for the camera node attribute.
    #define KFCURVENODE_CAMERA_FIELDOFVIEW      "FieldOfView"
    #define KFCURVENODE_CAMERA_FIELDOFVIEWX     "FieldOfViewX"
    #define KFCURVENODE_CAMERA_FIELDOFVIEWY     "FieldOfViewY"
    #define KFCURVENODE_CAMERA_FOCALLENGTH      "FocalLength"
    #define KFCURVENODE_CAMERA_OPTICALCENTERX   "OpticalCenterX"
    #define KFCURVENODE_CAMERA_OPTICALCENTERY   "OpticalCenterY"
    #define KFCURVENODE_CAMERA_ROLL             "Roll"
    #define KFCURVENODE_CAMERA_TURNTABLE        "TurnTable"
    #define KFCURVENODE_BACKGROUND_COLOR        "BackgroundColor"
    #define KFCURVENODE_BACKGROUND_COLOR_RED        "X"
    #define KFCURVENODE_BACKGROUND_COLOR_GREEN      "Y"
    #define KFCURVENODE_BACKGROUND_COLOR_BLUE       "Z"

    // Addition for the camera switcher node attribute.
    #define KFCURVENODE_CAMERA_INDEX            "Camera Index"

    // Addition for the texture.
    #define KFCURVENODE_TEXTURE_TRANSLATION     "Translation"
    #define KFCURVENODE_TEXTURE_TRANSLATION_X   "X"
    #define KFCURVENODE_TEXTURE_TRANSLATION_Y   "Y"
    #define KFCURVENODE_TEXTURE_TRANSLATION_Z   "Z"
    #define KFCURVENODE_TEXTURE_ROTATION        "Rotation"
    #define KFCURVENODE_TEXTURE_ROTATION_X      "X"
    #define KFCURVENODE_TEXTURE_ROTATION_Y      "Y"
    #define KFCURVENODE_TEXTURE_ROTATION_Z      "Z"
    #define KFCURVENODE_TEXTURE_SCALING         "Scaling"
    #define KFCURVENODE_TEXTURE_SCALING_X       "X"
    #define KFCURVENODE_TEXTURE_SCALING_Y       "Y"
    #define KFCURVENODE_TEXTURE_SCALING_Z       "Z"
    #define KFCURVENODE_TEXTURE_ALPHA           "Alpha"

    // Addition for the material.
    #define KFCURVENODE_MATERIAL_EMISSIVE       "Emissive"
    #define KFCURVENODE_MATERIAL_EMISSIVE_R     "X"
    #define KFCURVENODE_MATERIAL_EMISSIVE_G     "Y"
    #define KFCURVENODE_MATERIAL_EMISSIVE_B     "Z"
    #define KFCURVENODE_MATERIAL_AMBIENT        "Ambient"
    #define KFCURVENODE_MATERIAL_AMBIENT_R      "X"
    #define KFCURVENODE_MATERIAL_AMBIENT_G      "Y"
    #define KFCURVENODE_MATERIAL_AMBIENT_B      "Z"
    #define KFCURVENODE_MATERIAL_DIFFUSE        "Diffuse"
    #define KFCURVENODE_MATERIAL_DIFFUSE_R      "X"
    #define KFCURVENODE_MATERIAL_DIFFUSE_G      "Y"
    #define KFCURVENODE_MATERIAL_DIFFUSE_B      "Z"
    #define KFCURVENODE_MATERIAL_SPECULAR       "Specular"
    #define KFCURVENODE_MATERIAL_SPECULAR_R     "X"
    #define KFCURVENODE_MATERIAL_SPECULAR_G     "Y"
    #define KFCURVENODE_MATERIAL_SPECULAR_B     "Z"
    #define KFCURVENODE_MATERIAL_OPACITY        "Opacity"
    #define KFCURVENODE_MATERIAL_REFLECTIVITY   "Reflectivity"
    #define KFCURVENODE_MATERIAL_SHININESS      "Shininess"

    // Addition for the generic vector property.
    #define KFCURVENODE_USER_PROPERTY_VECTOR_X  "X"
    #define KFCURVENODE_USER_PROPERTY_VECTOR_Y  "Y"
    #define KFCURVENODE_USER_PROPERTY_VECTOR_Z  "Z"
    #define KFCURVENODE_USER_PROPERTY_VECTOR_W  "W"

    // Addition for the generic color property.
    #define KFCURVENODE_USER_PROPERTY_COLOR_R  "X"
    #define KFCURVENODE_USER_PROPERTY_COLOR_G  "Y"
    #define KFCURVENODE_USER_PROPERTY_COLOR_B  "Z"
    #define KFCURVENODE_USER_PROPERTY_COLOR_A  "W"

    // Addition of generic matrix
    #define KFCURVENODE_USER_PROPERTY_MATRIX "Matrix"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_0 "0"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_1 "1"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_2 "2"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_3 "3"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_4 "4"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_5 "5"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_6 "6"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_7 "7" 
    #define KFCURVENODE_USER_PROPERTY_MATRIX_8 "8"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_9 "9"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_A "A"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_B "B"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_C "C"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_D "D"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_E "E"
    #define KFCURVENODE_USER_PROPERTY_MATRIX_F "F"

    // Default array size for 1 minute of animation (30fps) 
    #define SELECTION_ARRAY_SIZE    30*60+1
    //#define SELECTION_ARRAY_SIZE 1024*1024

    #define KFCURVENODE_CANDIDATE_MAX_COUNT 4


    typedef int  kFCurveNodeType;

    KFBX_FORWARD (KFCurveNode);
    typedef HKFCurveNode HIKFCurveNode;
    typedef KFCurveNode IKFCurveNode;

    #define IKFCurveNodeID 43763634

    enum EKFCurveNodeEventType
    {
        KFCURVENODEEVENT_NONE = 0, 
        KFCURVENODEEVENT_SELECTION = 1, 
        KFCURVENODEEVENT_DESTROY = 2, 
        KFCURVENODEEVENT_FCURVE = 4, 
        KFCURVENODEEVENT_TIMEWARP = 8, 
        KFCURVENODEEVENT_CTRLCURVE = 16, 
        KFCURVENODEEVENT_DATAUPDATED = 32
    };

    struct KExternalTimingInformation
    {
        KTime mLclOffset;
        KTime mDuration;
    };


    class KFBX_DLL KFCurveNodeEvent : public KEventBase
    {
    public:

        int mEventCount;

        void* mData;

        inline void Clear () 
        {
            mType=KFCURVENODEEVENT_NONE; 
            mEventCount = 0; 
            mData = NULL; 
        }

        inline void Add (int pWhat) 
        {
            mType |= pWhat;
            mEventCount++;
        }

        // Set the data contained by the node event.
        inline void SetData (void* pData) {mData = pData;}
    };


    struct KFCurveNodeCallback 
    {
        KFCurveNodeEvent mEvent;
        KArrayUL mCallbackFunctions;   // no delete on object must use array ul
        KArrayUL mCallbackObjects;     // no delete on object must use array ul
        bool mCallbackEnable;
    };

    typedef void (*kFCurveNodeCallback) (KFCurveNode* pFCurve, KFCurveNodeEvent* FCurveNodeEvent, void* pObject) ;

    typedef class KArrayTemplate< HKFCurveNode > KArrayTemplateFCurveNode;  

    // Return codes for function KFCurveNode::IsKey().
    enum 
    { 
        ISKEY_NONE,
        ISKEY_SOME, 
        ISKEY_ALL 
    };


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

        void Dump(int pLevel = 0);

        void SetCandidateTotalTime      ( KTime &pCandidateTime ) { mCandidateTotalTime = pCandidateTime; };
        void SetCandidateSpecificTime   ( KTime &pCandidateTime ) { mCandidateSpecificTime = pCandidateTime; };

    protected:
        friend class KFCurveNode;
        
        int mSpecificCandidateMethod;
        int mTotalCandidateMethod;

        double mCandidateTotalValue[KFCURVENODE_CANDIDATE_MAX_COUNT];
        KTime   mCandidateTotalTime;

        double mCandidateSpecificValue;
        double mFCurveValue;
        KTime mCandidateSpecificTime;

        KFCurveNodeCandidateState *mSubStates[KFCURVENODE_CANDIDATE_MAX_COUNT];
        KFCurveNodeCandidateState *mLayerState;
        int                        mLayerID;

    };


    #ifdef KFBX_PLUGIN
        class KFBX_DLL KFCurveNode
    #else 
        class KFBX_DLL KFCurveNode : public IFBObjectHolder
    #endif
    {

    public:


        KFCurveNode 
        (
            char* pNodeName, 
            char* pTimeWarpName, 
            HKDataType pDataType, 
            int  pLayerType = KFCL_NOLAYER,
            int  pLayerID = 0
        ) ;

        KFCurveNode(HKFCurveNode pTemplateCurveNode);

        virtual ~KFCurveNode () ;

        #ifndef DOXYGEN_SHOULD_SKIP_THIS
        #ifdef KFBX_PLUGIN
            void Destroy (int Local=0) ;
        #else
            KFBX_IObject_Declare (KFBX_Implementation) 
        #endif
        #endif



        void CreateFCurve( );

        bool FCurveCreated( );



        HKFCurveNode Clone(bool pKeepAttached);

        HKFCurveNode CloneTemplate(bool pKeepAttached=false, bool pCloneFCurves=false, bool pCreateCurves=false, int pLayerID = -1);

        void CopyFrom(HKFCurveNode pSource, bool pTransferCurve = false);

        HKFCurveNode Copy(KTime pStart=KTIME_MINUS_INFINITE, KTime pStop=KTIME_INFINITE);



        char* GetName () ;

        char* GetTimeWarpName() ;

        char* GetTypeName() ;



        HKFCurve FCurveGet();

        KFCurve* FCurveSet (KFCurve* pCurve, bool pDestroyOldCurve = false) ;

        void FCurveReplace (KFCurve* pCurve) ;

        bool GetTransformCurves (KFCurve* pT[3], KFCurve* pR[3], KFCurve* pS[3]) ;



        virtual void Clear () ;

        virtual int Add(HKFCurveNode pCurveNode);
        
        virtual void Remove (int pIndex) ;
        
        virtual void Delete (int pIndex) ;
        
        virtual int GetCount () ;
        
        virtual HKFCurveNode Get(int pIndex) ;
        
        virtual bool IsChild(KFCurveNode* pCurveNode, bool pRecursive = false) ;

        virtual int Find (char* pName) ;

        virtual int Find(HKFCurveNode pNode);

        HKFCurveNode FindRecursive(char* pName);

        HKFCurveNode FindOrCreate(char* pName, bool pFindOrCreateCurve = true) ;
        
        virtual void SetParent(HKFCurveNode pParent) {mParent = pParent;}
        
        virtual HKFCurveNode GetParent() {return mParent;}



        int KeyGetCount(bool pRecursiveInLayers = false);

        void KeyGetCount(int& pCurveCount, int& pTotalCount, int& pMinCount, int& pMaxCount);

        void GetCurveWithFirstKey(KFCurve*& lCurveWithFirstKey, bool *pCurveMask /* = NULL */, bool pRecursiveInLayers);

        void GetCurveWithLastKey(KFCurve*& lCurveWithLastKey, bool *pCurveMask /* = NULL */, bool pRecursiveInLayers);

        KTime GetFirstKeyTime(bool *pCurveMask = NULL, bool pRecursiveInLayers = false);

        KTime GetLastKeyTime(bool *pCurveMask = NULL, bool pRecursiveInLayers = false);

        double* KeyAdd (KTime pTime, double* pValue) ;

        double* KeyAppend (KTime pTime, double* pValue, bool pCheckForContinuousRotation = false) ;

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

        void GetTimeSpan          (KTime& pStart, KTime& pStop) ;   

        int IsKey (KTime& pTime, int *pLast, bool* pCurveMask = NULL, double pKeyIndexTolerance = 0.0, double pMin = -K_DOUBLE_MAX,  double pMax = K_DOUBLE_MAX );

        bool DeleteKey (KTime& pTime, bool* pCurveMask = NULL, double pKeyIndexTolerance = 0.0 );

        KTime GetNextKeyTime (KTime pTime, bool* pCurveMask = NULL, bool pRecursiveInLayers = false);

        KTime GetPrevKeyTime (KTime pTime, bool* pCurveMask = NULL );

        double* Evaluate (double* pValue, KTime pTime, kFCurveIndex* pLast=NULL) ;
        
        double* GetValue (double* pValue) ;
        
        double* SetValue (double* pValue) ;

        void Delete(KTime pStart=KTIME_MINUS_INFINITE, KTime pStop=KTIME_INFINITE);

    void Replace(HKFCurveNode pSource, KTime pStart = KTIME_MINUS_INFINITE, KTime pStop = KTIME_INFINITE, bool pUseGivenSpan = false, bool pKeyStartEndOnNoKey = true, KTime pTimeSpanOffset = KTIME_ZERO );


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

    #ifndef DOXYGEN_SHOULD_SKIP_THIS


        float* GetColor();

        void SetColor (float pColor[3]) ;



        inline int IncReferenceCount () {return ++mReferenceCount;}

        inline int DecReferenceCount () {mReferenceCount--; return mReferenceCount;}

        inline int GetReferenceCount () {return mReferenceCount;}



        int GetTakeType () ;

        void SetTakeType (int pType) ;



        bool GetVisibility () ;

        void SetVisibility (bool pVisible, bool pRecursive=false, bool pRecurseLayer = false, int lChildIndex = -1) ;



        void DataNodeSet (HKFCurveNode pDataNode, bool pRecursive=true) ;

        HKFCurveNode DataNodeGet () ;

        bool SetPreExtrapolation(kUInt pNewPreExtrapolation, bool pRespectUserLock=true );
        bool SetPreExtrapolationCount(kUInt pNewPreExtrapolationCount, bool pRespectUserLock=true);
        bool SetPostExtrapolation(kUInt pNewPreExtrapolation, bool pRespectUserLock=true);
        bool SetPostExtrapolationCount(kUInt pNewPreExtrapolationCount, bool pRespectUserLock=true);



        int GetContainerType () ;

        void SetContainerType (int pInOutType) ;



        int GetIOType () ;

        void SetIOType (int pInOutType) ;



        int IsExpended () ;

        void SetExpended (bool pExpended) ;



        int IsMultiLayer() ;

        void SetMultiLayer (bool pMultiLayer) ;

        HKFCurveNode GetLayerNode(int pLayerID);

    #ifndef KFBX_PLUGIN
        void ExtractKeysIndex( KArraykInt &pArray, KTimeSpan pTimeSpan, double pMinValue =  -K_DOUBLE_MAX, double pMaxValue =  K_DOUBLE_MAX);
    #endif



        bool LookLikeSampledData(KTime pThresholdPeriod);



        int GetUpdateId () ;

        int GetValuesUpdateId ();

        int GetNodeUpdateId () ;



        
        bool CallbackEnable (bool pEnable) ;
        
        bool CallbackIsEnable () ;
        
        void CallbackClear () ;
        
        void CallbackAddEvent (int pWhat) ;
        
        void CallbackRegister (kFCurveNodeCallback, void* pObject) ;
        
        void CallbackUnregister (kFCurveNodeCallback, void* pObject) ;


    #ifndef KFBX_PLUGIN


        void SetETI(IKFCurveETI * pFCurveETI);
        IKFCurveETI * GetETI() const;

        KTime ETINodeTime2GlobalTime(KTime const & pTime);
        KTime ETIGlobalTime2NodeTime(KTime const & pTime);
        KTime ETIGetDuration();
        KTime ETIGetTrimOffset();
        KTime ETIGetGlobalOffset();
        double ETIGetScaleFactor();
        bool ETIGetColor(KgeRGBVector & pColor);
        bool ETIIsGlobalTimeInSpan(KTime const & pTime, bool pIncludeStop = true);
        typedef KTime (IKFCurveETI::*TETITimeFetcher)();
        KTime ETIGetSpecifiedTime(TETITimeFetcher pFunc);
        bool ETIIsSelectedDuration();
    #endif


        bool    FbxStore (KFbx* pFbx, bool pOnlyDefaults = false, bool pReplaceLclTRSName = false, bool pSkipTimeWarpName = false, char* pFieldName = "Channel", bool pColor = true, bool pIsVersion5 = false ) ;
        bool    FbxRetrieve (KFbx* pFbx, bool pOnlyDefaults = false, bool pCreateIfNotFound = true,bool pColor = false);
        bool    FbxInternalRetrieve (KFbx* pFbx, bool pOnlyDefaults = false, bool pCreateIfNotFound = true,bool pColor = false) ;
        bool    FbxTimeWarpNameRetrieve(KFbx* pFbx);
        bool    FbxLayerAndTimeWarpRetrieve(KFbx* pFbx, bool pOnlyDefaults = false, bool pCreateIfNotFound = true,bool pColor = false) ;


        bool mUseQuaternion;
        inline bool GetUseQuaternion(){return mUseQuaternion;}; 
        void SetUseQuaternion(bool pVal); 
        private:
            void RotationNodeEvaluate(double* pValue, KTime pTime, kFCurveIndex* pLast,bool pEvaluateCandidate  );


    public:

        void GetCandidateState(KFCurveNodeCandidateState& pState);
        void SetCandidateState(const KFCurveNodeCandidateState& pState, bool pDestroyMissingLayers = false );

        int     GetCandidateSpecificMethod();
        int     GetCandidateTotalMethod();
        KTime   GetCandidateTotalTime();
        double* GetCandidateTotalValue();
        int     GetCandidateTotalValueSize();

        void    SetCandidateSpecificMethod(int pMethod);
        void    SetCandidateTotalMethod(int pMethod);
        void    SetCandidateTotalTime(KTime pTime);
        void    SetCandidateTotalValue(double* pValue);


    void GetQuaternionInterpolationBezierPoints(KTime pCurrentTime, KgeQuaternion &pQ0, KgeQuaternion &lQ1, KgeQuaternion &lQ2, KgeQuaternion &lQ3);

    protected:
        struct NameInfo 
        {
            KString     mName;
            KString     mTimeWarpName;
            HKDataType  mDataType;
            int     mRefCount;
        }*mNameInfo;

        void    SetNameInfo( NameInfo* pNameInfo );

        int mType;

        int mReferenceCount;
        KArrayTemplate<HKFCurveNode> mNodes;

        HIKFCurve    mFCurve;
        HKFCurveNode mTimeWarp;
        HKFCurveNode mLayer;        // Ctrl Curve (Animation layering) 
        HKFCurveNode mObjectLayer;  // Pointer to Layer 0
        HKFCurveNode mTemplate;
        HKFCurveNode mDataNode;
        HKFCurveNode mParent;

        int mLayerType;
        int mLayerID;

        int mUpdateId;

        public:
        int mMBRotationOrder;
        inline int GetRotationOrder(){return mMBRotationOrder;}; 
        void SetRotationOrder(int pRotationOrder);

        int GetLayerType() { return mLayerType; }

        protected:
        //
        //  Candidates in nodes (Max is KFCURVENODE_CANDIDATE_MAX_COUNT)
        //
        
        void FromTotalCandidateToSpecificCandidate(int pLayerID);

        enum {eUseFCurve = 1, eUseTotal = 2};
        int mSpecificCandidateMethod;  // Used as a bit field
        int mTotalCandidateMethod;     // Used as an enum
                                        // To my knowledge the possible state are       
                                        // No validcandidate                            mCandidateTotalTime == INFINITE and no FCurve candidate for the current time
                                        // Total candidate is valid and fcuve invalid   mTotalCandidateMethod ==  eUseTotal and mSpecificCandidateMethod == eUseTotal
                                        // FCurve is valid and Total invalid            mTotalCandidateMethod ==  eUseFCurve and mSpecificCandidateMethod == eUseFCurve
                                        // Total valid and FCurve computed              mTotalCandidateMethod ==  eUseTotal and mSpecificCandidateMethod == eUseTotal | eUseFCurve

                                        // FCurve valid and total computed              mTotalCandidateMethod ==  eUseTotal and mSpecificCandidateMethod == eUseFCurve
                                        // FCurve valid (and computed from total) and total computed    mTotalCandidateMethod ==  eUseTotal and mSpecificCandidateMethod == eUseTotal | eUseFCurve
                        
                    
                                        

        double mCandidateTotalValue[KFCURVENODE_CANDIDATE_MAX_COUNT];   // For all layers at once (only meaningful on ObjectLayer )
        KTime   mCandidateTotalTime;

        //
        //  Callbacks
        //
        
        KFCurveNodeCallback* mCallback;
        int mUserLock;


    #ifndef KFBX_PLUGIN
        //
        //  External Timing Information (for transportation only: optional, not used internally, and not persisted).
        //
        IKFCurveETI * mETI;
    #endif

    private:
        void KeyGetCountRecursive(int& pCurveCount, int& pTotalCount, int& pMinCount, int& pMaxCount);
        bool GetAnimationIntervalRecursive (KTime& pStart, KTime& pStop) ;
        void IsKeyRecursive( KTime& pTime, int &pKeyCount, int &pKeyFound, int *pLast, bool *pCurveMask, double pKeyIndexTolerance = 0.0, double pMin = -K_DOUBLE_MAX,  double pMax = K_DOUBLE_MAX );

        friend KFBX_DLL HKFCurveNode KFCurveNodeCreate (KFbx* pFbx, HKFCurveNode pParent, bool pOnlyDefaults, bool pCreateIfNotFound, bool pColor );

    public:
        //
        // TimeWarp
        //

        void TimeWarpSet (HKFCurveNode pLayer);

        HKFCurveNode TimeWarpGet ();

        //
        // Layers
        //

        void LayerSet(HKFCurveNode pLayer, bool pDeleteCurrentAndSubLayers ); // No default value to make sure you know what you are doing

        HKFCurveNode LayerGet ();

        HKFCurveNode LayerGet( int pLayerID );

        void CreateLayerAt( int pLayerID );
    private:
        HKFCurveNode LayerCreate ( int pLayerID, bool pDeleteCurrentLayer );    // No default value to make sure you know what you are doing
    public:
        virtual HKFCurveNode Find(HKDataType pDataType);
        
        HKFCurveNode FindRecursive(HKDataType pDataType);

        HKDataType GetDataType();
            
        void Delete(HKFCurveNode pNode);

        HKFCurveNode ObjectLayerGet();

        void ObjectLayerSet( HKFCurveNode pNode );

        inline int GetLayerID() { return mLayerID; };

        inline void SetLayerID( int pLayerID ) { mLayerID = pLayerID; };

        void SetLayerType( int pLayerType, HKFCurveNode pObjectLayerNode = NULL );

        HKFCurveNode GetPreviousLayer( int pLayerID );

        HKFCurveNode RemoveLayer( int pLayerID, bool pDestroy = true );

        // Copy a specific anyer or create one if none exist 
        HKFCurveNode InsertOrCopyLayer( int pLayerId, HKFCurveNode pLayerNode );

        void SingleLayerCopyFrom(HKFCurveNode pSource, bool pTransferCurve = false );

        HKFCurveNode SingleLayerCopy(KTime pStart=KTIME_MINUS_INFINITE, KTime pStop=KTIME_INFINITE ); 

        //
        // Templates
        //

        void TemplateSet (HKFCurveNode pTemplate);

        HKFCurveNode TemplateGet ();

        //
        // Copy/paste
        //

        void LayerCopyFromRecursive( HKFCurveNode pSource, bool pTransferCurve = false );

        //
        //  Candidates
        //

        bool    CandidateClear ( int pLayerID = 0, bool pClearAllSubLayersToo = true );

        void    CandidateClearSubLayers ();
        
        double* CandidateSet (KTime pTime, double* pValue, int pLayerID = 0, int pChildIndexInParent = -1 );

        double *CandidateSetSpecificLayer (KTime pTime,double *pValue, int pLayerID = 0 );

        double* CandidateGet (double* pValue, int pLayerID = 0 );
        
        double* CandidateGetSpecificLayer( double* pValue, KTime &pCandidateTime, int pLayerID = 0 );
        
        void CandidateGetTotalCandidate( double* pValue, KTime &pCandidateTime );
        
        bool IsCandidate              ();
        
        bool    CandidateKey 
        (
            kFCurveIndex*   pLast           = NULL, 
            int             pLayerID        = 0, 
            bool*           pCurveMask      = NULL, 
            bool            pZeroKey        = false , 
            int         pInterpolation  = KFCURVE_INTERPOLATION_CUBIC, 
            int         pTangeantMode   = KFCURVE_TANGEANT_USER, 
            int         pContinuity     = KFCURVE_CONTINUITY,
            bool            pTanOverride    = true,
            KTime           pCandidateTime  = KTIME_INFINITE,
            double          pKeyIndexTolerance = 0.0
        );

        bool    CandidateKeySpecificLayer 
        (
            kFCurveIndex*   pLast           = NULL, 
            int             pLayerID        = 0, 
            bool*           pCurveMask      = NULL,
            int         pInterpolation  = KFCURVE_INTERPOLATION_CUBIC, 
            int         pTangeantMode   = KFCURVE_TANGEANT_USER, 
            int         pContinuity     = KFCURVE_CONTINUITY,
            bool            pTanOverride    = true,
            KTime           pCandidateTime  = KTIME_INFINITE,
            double          pKeyIndexTolerance = 0.0
        );

        // !    If CurveNode is MonoLayer it will return 0
        int         GetCorrectLayerID( int pLayerID );
        HKFCurveNode    GetCorrectLayer  ( int pLayerID, bool pCreateLayerIfNesseary = false );

        void    ComputeCandidateForLayer( double *pDestLayerValue, double *pCandidateValue, KTime pTime, int pLayerID, kFCurveIndex *pLast );

        void    EvaluateCurvesExceptLayerRecursiveAdd ( double *pValue, KTime pTime, int pExceptLayerID, kFCurveIndex* pLast=NULL);
        
        void    EvaluateCurvesExceptLayerRecursiveMult ( double *pValue, KTime pTime, int pExceptLayerID, kFCurveIndex* pLast=NULL);

        void    EvaluateCurvesBeforeLayerRecursiveEulerXYZ ( KgeRMatrix &pBefore, KTime lCandidateTime, int pLayerID, kFCurveIndex* pLast );

        void    EvaluateCurvesAfterLayerRecursiveEulerXYZ  ( KgeRMatrix &pAfter, KTime lCandidateTime, int pAfterLayerID, kFCurveIndex* pLast );

        void    EvaluateCurvesBeforeLayerRecursiveQuat( KgeQuaternion &pBefore, KTime pTime, int pBeforeLayerID, kFCurveIndex* pLast );

        void    EvaluateCurvesAfterLayerRecursiveQuat ( KgeQuaternion &pAfter , KTime pTime, int pBeforeLayerID, kFCurveIndex* pLast );

        double* CandidateGetWithTime ( double *pValue, KTime &pCandidateTime );


        //
        // Helpers
        //

        double* EvaluateSpecificLayer( double *pValue, KTime pTime, int pLayerID, kFCurveIndex* pLast=NULL);

        double *CandidateEvaluateSpecificLayer( double *pValue, KTime pTime, int pLayerID, kFCurveIndex *pLast=NULL);

        double* GeneralEvaluate (double* pValue, KTime pTime, kFCurveIndex* pLast=NULL,bool pEvaluateCandidate=true);

        double* CandidateEvaluate (double* pValue, KTime pTime, kFCurveIndex* pLast=NULL);

        bool IsEditable ();

        void GetZeroValues( double *pValues );

        // ! Content replacement for quaternions ( = with scaling of the quaternion )
        void ReplaceForQuaternion( HKFCurveNode pSource, KTime pStart, KTime pStop, double pScaleStart, double pScaleStop, bool pUseExactGivenSpan /*= false*/, bool pKeyStartEndOnNoKey /*= true*/, KTime pTimeSpanOffset /*= KTIME_ZERO*/ );

        // ! Calculates the offset between to euler rotations
        bool GetContinuousOffset( double pOffset[3], double pNew[3], double pOld[3] );

        // ! Unrolls a rotation at a given time, using the previous key.
        void GetContinuousRotation( double pResultKeyValue[3], double pCurrentKeyValue[3], KTime pCurrentKeyTime );

        // ! Sets the user name
        void SetTimeWarpName( char* pName );

        // ! Returns the total key count for all child (pChildIndex) in every layer.
        int KeyGetCountOnChild( int pChildIndex );

        //
        //  User lock
        //

        void    UserLockAdd();

        void    UserLockRemove();

        bool    IsUserLocked();

    #ifndef KFBX_PLUGIN
        //
        // FBObjectHolder for FBSDK reference
        //

        KFBObjectHolder mFBObjectHolder;

        KFBObjectHolder &GetFBHolder () {return mFBObjectHolder;}
    #endif

    public:
        virtual int SortedAdd (HKFCurveNode pNode) ;

    public:

        // For Backward compatibility reasons must be revisited please ...
        HIConnector mConnector; // Do not set this member because if the Connector is set, it means that it is a Connector FCurveNode. So watchout!!!

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

    };


    KFBX_DLL HKFCurveNode KFCurveNodeCreate(char* pNodeName, char* pTimeWarpName, char* pTypeName, int pLayerType = KFCL_NOLAYER, int pLayerID = 0);
    KFBX_DLL HKFCurveNode KFCurveNodeCreate(char* pNodeName, HKDataType pDataType=NULL, int pLayerType = KFCL_NOLAYER, int pLayerID = 0);


    KFBX_DLL HKFCurveNode KFCurveNodeCreate(HKFCurveNode pTemplateCurveNode);

    // Create a curve node, FBX SDK internal use only.
    KFBX_DLL HKFCurveNode KFCurveNodeCreate(KFbx* pFbx, bool pOnlyDefaults = false, bool pColor = false);

    // Create a curve node, FBX SDK internal use only.
    KFBX_DLL HKFCurveNode KFCurveNodeCreate(KFbx* pFbx, HKFCurveNode pParent, bool pOnlyDefaults = false, bool pCreateIfNotFound = true, bool pColor = false);

    // Create a layer node, FBX SDK internal use only.
    KFBX_DLL HKFCurveNode KFCurveNodeLayerCreate (KFbx* pFbx,HKFCurveNode pParent, bool pOnlyDefaults = false );

    // Create a curve node from a datatype, FBX SDK internal use only.
    KFBX_DLL HKFCurveNode FCurveNodeCreateFromDataType( HKDataType pDataType,char* pNodeName);

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_COMPONENTS_KFCURVE_KFCURVENODE_H