kfcurvenode.h

Go to the documentation of this file.

#ifndef _FBXSDK_KFCURVE_NODE_H_
#define _FBXSDK_KFCURVE_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 <kfcurve/kfcurve_h.h>

#include <klib/karrayul.h>
#include <klib/kerror.h>
#include <klib/kstring.h>
#include <object/e/keventbase.h>

#include <kfcurve/kfcurve.h>

#ifndef K_PLUGIN
    #include <kfcurve/i/ifcurveeti.h>
    #include <object/i/iobject.h>
    #include <object/i/ifbobjectholder.h>
#endif

K_FORWARD (IConnector) 
K_FORWARD (IData) 

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

#include <kfcurve/kfcurve_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"

    // 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"


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

    K_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;
    };


    // Curve node event class.
    class KFCURVE_DLL KFCurveNodeEvent : public KEventBase
    {
    public:
        /* Nature (s) of this node event.
        *   It is a bit field.  Value defined in the enum stated before 
        *   the class can composited. 
        * stored in mType
        */
        // Event count.
        int mEventCount;

        // Data.
        void* mData;

        // Clear the curve node event object.
        inline void Clear () 
        {
            mType=KFCURVENODEEVENT_NONE; 
            mEventCount = 0; 
            mData = NULL; 
        }

        /* Add an event of type pWhat.
        *   \param pWhat    Use EKFCurveNodeEventType to identify what pWhat means.
        */
        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 KFCURVE_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 K_PLUGIN
        class KFCURVE_DLL KFCurveNode
    #else 
        class KFCURVE_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 () ;

        #ifdef K_PLUGIN
            void Destroy (int Local=0) ;
        #else
            IObject_Declare (Implementation) 
        #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);
        
        // Get the first key in the children specified by the curve mask (NULL = all children)
        // DEPRECATED: use GetFirstKeyTime or GetCurveWithFirstKey instead.
        // K_DEPRECATED void KeyGetFirst(KFCurveKey*& lKey, bool *pCurveMask = NULL, bool pRecursiveInLayers = false);
        // Get the last key in the children specified by the curve mask (NULL = all children)
        // DEPRECATED: use GetLastKeyTime or GetCurveWithLastKey instead.
        // K_DEPRECATED void KeyGetLast(KFCurveKey*& lKey, bool *pCurveMask = NULL, bool pRecursiveInLayers = false);

        // Get the fcurve that has the earliest key. If many fcurves
        // has a key at the earliest time, returns one of the fcurves.
        void GetCurveWithFirstKey(KFCurve*& lCurveWithFirstKey, bool *pCurveMask /* = NULL */, bool pRecursiveInLayers);
        // Get the fcurve that has the latest key. If many fcurves has
        // a key at the latest time, returns one of the fcurves.
        void GetCurveWithLastKey(KFCurve*& lCurveWithLastKey, bool *pCurveMask /* = NULL */, bool pRecursiveInLayers);

        // Get the first key time in the children specified by the curve mask (NULL = all children)
        // If there is no key, return KTIME_MINUS_INFINITE.
        KTime GetFirstKeyTime(bool *pCurveMask = NULL, bool pRecursiveInLayers = false);
        // Get the last key time in the children specified by the curve mask (NULL = all children)
        // If there is no key, return KTIME_INFINITE.
        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 K_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 K_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


        #ifndef K_FBXSDK_INTERFACE
            #include <kfcurve/kfcurvenodeinhouse.h>
        #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 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 );


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

    protected:
        struct NameInfo 
        {
            KString     mName;
            KString     mTimeWarpName;
            HKDataType  mDataType;
            KProperty*  mProperty;  // Helper to display enum values in fcurve editor
            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); 
        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 K_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 KFCURVE_DLL HKFCurveNode KFCurveNodeCreate (KFbx* pFbx, HKFCurveNode pParent, bool pOnlyDefaults, bool pCreateIfNotFound, bool pColor ); 

    #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

    };


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


    KFCURVE_DLL HKFCurveNode KFCurveNodeCreate(HKFCurveNode pTemplateCurveNode);

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

    // Create a curve node, FBX SDK internal use only.
    KFCURVE_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.
    KFCURVE_DLL HKFCurveNode KFCurveNodeLayerCreate (KFbx* pFbx,HKFCurveNode pParent, bool pOnlyDefaults = false );

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

#include <kfcurve/kfcurve_nsend.h>

#endif // #ifndef _FBXSDK_KFCURVE_NODE_H_