Show in Contents

Add to Favorites

Home: FBX SDK Programmers Guide

 

 

 

FBX SDK Reference Guide: kfcurve.h Source File

Go to the documentation of this file.

#ifndef _FBXSDK_KFCURVE_H_
#define _FBXSDK_KFCURVE_H_

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

 Copyright © 2001 - 2008 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/ktime.h>
#include <object/e/keventbase.h>


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

#ifndef K_PLUGIN
    #include <klib/kdebug.h>
#endif

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

#ifdef K_PLUGIN
    #define KFCURVE_INLINE
#else
    #define KFCURVE_INLINE inline
#endif

#include <kfcurve/kfcurve_nsbegin.h>

    #define KFCURVE_FLOAT
    #ifdef KFCURVE_FLOAT
        typedef float kFCurveDouble;
    #else
        typedef double kFCurveDouble;
    #endif


    K_FORWARD(KFCurve);

    #define IKFCurveID 43763635

    typedef HKFCurve HIKFCurve;
    typedef class KFCURVE_DLL KArrayTemplate< KFCurve * > KArrayKFCurve;

    // Recording memory functions declaration
    KFCURVE_DLL kULong GetRecordingMemory();
    KFCURVE_DLL void WatchFree(void* pPtr, kULong pSize);
    KFCURVE_DLL void* WatchMalloc(kULong pSize);

    enum
    {
        KFCURVE_INTERPOLATION_CONSTANT    = 0x00000002,     
        KFCURVE_INTERPOLATION_LINEAR      = 0x00000004,     
        KFCURVE_INTERPOLATION_CUBIC       = 0x00000008,     
        KFCURVE_INTERPOLATION_ALL         = KFCURVE_INTERPOLATION_CONSTANT|KFCURVE_INTERPOLATION_LINEAR|KFCURVE_INTERPOLATION_CUBIC,
        KFCURVE_INTERPOLATION_COUNT       = 3
    };                                                

    enum
    {
        KFCURVE_CONSTANT_STANDARD         = 0x00000000,
        KFCURVE_CONSTANT_NEXT             = 0x00000100,
        KFCURVE_CONSTANT_ALL              = KFCURVE_CONSTANT_STANDARD | KFCURVE_CONSTANT_NEXT,
        KFCURVE_CONSTANT_COUNT            = 2
    };

    enum
    {
        KFCURVE_TANGEANT_AUTO             = 0x00000100,     
        KFCURVE_TANGEANT_TCB              = 0x00000200,     
        KFCURVE_TANGEANT_USER             = 0x00000400,     
        KFCURVE_GENERIC_BREAK             = 0x00000800,     
    KFCURVE_GENERIC_CLAMP             = 0x00001000,     
        KFCURVE_TANGEANT_BREAK            = KFCURVE_TANGEANT_USER|KFCURVE_GENERIC_BREAK,
        KFCURVE_TANGEANT_AUTO_BREAK   = KFCURVE_TANGEANT_AUTO|KFCURVE_GENERIC_BREAK,
    KFCURVE_TANGEANT_ALL              = KFCURVE_TANGEANT_AUTO|KFCURVE_TANGEANT_TCB|KFCURVE_TANGEANT_USER|KFCURVE_GENERIC_BREAK|KFCURVE_GENERIC_CLAMP,
    KFCURVE_TANGEANT_TYPE_MASK        = KFCURVE_TANGEANT_AUTO|KFCURVE_TANGEANT_TCB|KFCURVE_TANGEANT_USER|KFCURVE_TANGEANT_BREAK, // Break is part of the modes for historic reasons, should be part of overrides
    KFCURVE_TANGEANT_OVERRIDES_MASK   = KFCURVE_GENERIC_CLAMP
    // KFCURVE_TANGEANT_COUNT             = 4
    };

    enum 
    {
        KFCURVE_SELECT_POINT              = 0x00010000, 
        KFCURVE_SELECT_LEFT               = 0x00020000, 
        KFCURVE_SELECT_RIGHT              = 0x00040000, 
        KFCURVE_SELECT_ALL                = KFCURVE_SELECT_POINT|KFCURVE_SELECT_LEFT|KFCURVE_SELECT_RIGHT
    };

    enum
    {
        KFCURVE_MARKED_FOR_MANIP          = 0x00080000,
        KFCURVE_MARKED_ALL                = KFCURVE_MARKED_FOR_MANIP
    };

    enum 
    {
        KFCURVE_TANGEANT_SHOW_NONE        = 0x00000000, 
        KFCURVE_TANGEANT_SHOW_LEFT        = 0x00100000, 
        KFCURVE_TANGEANT_SHOW_RIGHT       = 0x00200000, 
        KFCURVE_TANGEANT_SHOW_BOTH        = KFCURVE_TANGEANT_SHOW_LEFT|KFCURVE_TANGEANT_SHOW_RIGHT
    };

enum
{
    KFCURVE_CONTINUITY                = 0x00000000,
    KFCURVE_CONTINUITY_FLAT           = 0x00100000,
    KFCURVE_CONTINUITY_BREAK          = 0x00200000,
    KFCURVE_CONTINUITY_INSERT         = 0x00400000   // Used to prevent the curve shape from changing when inserting a key
};

    enum 
    {
        KFCURVE_WEIGHTED_NONE             = 0x00000000, 
        KFCURVE_WEIGHTED_RIGHT            = 0x01000000, 
        KFCURVE_WEIGHTED_NEXT_LEFT        = 0x02000000, 
        KFCURVE_WEIGHTED_ALL              = KFCURVE_WEIGHTED_RIGHT|KFCURVE_WEIGHTED_NEXT_LEFT
    };

    // !Velocity mode
    enum
    {
        KFCURVE_VELOCITY_NONE             = 0x00000000,
        KFCURVE_VELOCITY_RIGHT            = 0x10000000,
        KFCURVE_VELOCITY_NEXT_LEFT        = 0x20000000,
        KFCURVE_VELOCITY_ALL              = KFCURVE_VELOCITY_RIGHT | KFCURVE_VELOCITY_NEXT_LEFT
    };


    #ifndef DOXYGEN_SHOULD_SKIP_THIS

    #define KFCURVE_WEIGHT_DIVIDER       9999       // precise enough and can be divided by 3 without error
    #define KFCURVE_DEFAULT_WEIGHT       ((kFCurveDouble)(1.0/3.0))
    #define KFCURVE_MIN_WEIGHT           ((kFCurveDouble)(1.0/KFCURVE_WEIGHT_DIVIDER))
    #define KFCURVE_MAX_WEIGHT           ((kFCurveDouble)0.99)
    #define KFCURVE_DEFAULT_VELOCITY     0.0 

    #endif // DOXYGEN_SHOULD_SKIP_THIS


    enum EKFCurveDataIndex
    {
        // User and Break tangent mode (data are doubles).
        KFCURVEKEY_RIGHT_SLOPE          = 0, 
        KFCURVEKEY_NEXT_LEFT_SLOPE      = 1, 

        // User and Break tangent break mode (data are kInt16 thken from mwight and converted to doubles).
        KFCURVEKEY_WEIGHTS              = 2, 
        KFCURVEKEY_RIGHT_WEIGHT         = 2, 
        KFCURVEKEY_NEXT_LEFT_WEIGHT     = 3, 

        // Velocity mode
        KFCURVEKEY_VELOCITY             = 4,
        KFCURVEKEY_RIGHT_VELOCITY       = 4,
        KFCURVEKEY_NEXT_LEFT_VELOCITY   = 5, 

        // TCB tangent mode (data are floats).
        KFCURVEKEY_TCB_TENSION          = 0, 
        KFCURVEKEY_TCB_CONTINUITY       = 1, 
        KFCURVEKEY_TCB_BIAS             = 2,

        KFCURVEKEY_RIGHT_AUTO           = 0,
        KFCURVEKEY_NEXT_LEFT_AUTO       = 1
    };

    enum 
    {
        KFCURVE_EXTRAPOLATION_CONST             = 1, 
        KFCURVE_EXTRAPOLATION_REPETITION        = 2, 
        KFCURVE_EXTRAPOLATION_MIRROR_REPETITION = 3, 
        KFCURVE_EXTRAPOLATION_KEEP_SLOPE        = 4
    };

    enum 
    {
        KFCURVE_BEZIER  = 0, 
        KFCURVE_SAMPLE  = 1, 
        KFCURVE_ISO     = 2
    };

    typedef kUInt kFCurveInterpolation;
    typedef kUInt kFCurveConstantMode;
    typedef kUInt kFCurveTangeantMode;
    typedef kUInt kFCurveTangeantWeightMode;
    typedef kUInt kFCurveTangeantVelocityMode;
    typedef kUInt kFCurveExtrapolationMode;
    typedef kUInt kFCurveTangeantVisibility;
    typedef int kFCurveIndex;

    enum 
    {
        KFCURVEEVENT_NONE       =0, // default event value
        KFCURVEEVENT_CANDIDATE  =1 << 0, // curve value (not candidate) changed
        KFCURVEEVENT_UNUSED1    =1 << 1,
        KFCURVEEVENT_UNUSED2    =1 << 2,
        KFCURVEEVENT_UNUSED3    =1 << 3,
        KFCURVEEVENT_KEY        =1 << 4, // key changed (add, removed, edited); see bits 11-15 for precisions
        KFCURVEEVENT_DEPRECATED5 =1 << 5,
        KFCURVEEVENT_UNUSED6    =1 << 6,
        KFCURVEEVENT_UNUSED7    =1 << 7,
        KFCURVEEVENT_SELECTION  =1 << 8, // key selection changed
        KFCURVEEVENT_DESTROY    =1 << 9, // fcurve destruction
        KFCURVEEVENT_DEPRECATED10 =1 << 10,
        KFCURVEEVENT_KEYADD     =1 << 11,
        KFCURVEEVENT_KEYREMOVE  =1 << 12,
        KFCURVEEVENT_EDITVALUE  =1 << 13,
        KFCURVEEVENT_EDITTIME   =1 << 14,
        KFCURVEEVENT_EDITOTHER  =1 << 15,
    };


    // Curve event class.
    class KFCURVE_DLL KFCurveEvent : public KEventBase
    {
    public:
        // Curve event type, the enum stated above allow composition of type (bitfield). 
        // Stored in mType

        // Start key index.
        int mKeyIndexStart; 

        //  Stop key index.
        int mKeyIndexStop; 

        // Count of events.
        int mEventCount;

        // Clear curve event.
        KFCURVE_INLINE void Clear (); 
        
        // Add a curve event of type pWhat to a curve event object.
        KFCURVE_INLINE void Add (int pWhat, int pIndex);
    };

    typedef void (*kFCurveCallback) (KFCurve *pFCurve, KFCurveEvent *FCurveEvent, void* pObject);

    class KFCURVE_DLL KFCurveTangeantInfo 
    {
    public:
        KFCURVE_INLINE KFCurveTangeantInfo();

        kFCurveDouble mDerivative;
        kFCurveDouble mWeight;
        bool         mWeighted;
        kFCurveDouble mVelocity;
        bool          mHasVelocity;
        kFCurveDouble mAuto;  // The auto parameter!
    };

    class KFCURVE_DLL KFCurveKey 
    {
    public:
        KFCurveKey()
        {
            Init();
        }

    public:
        
        KFCURVE_INLINE void Set 
        (
            KTime pTime, 
            kFCurveDouble pValue, 
            kFCurveInterpolation pInterpolation = KFCURVE_INTERPOLATION_CUBIC, 
            kFCurveTangeantMode pTangentMode = KFCURVE_TANGEANT_AUTO, 
            kFCurveDouble pData0 = 0.0,
            kFCurveDouble pData1 = 0.0,
            kFCurveTangeantWeightMode pTangentWeightMode = KFCURVE_WEIGHTED_NONE, 
            kFCurveDouble pWeight0                             = KFCURVE_DEFAULT_WEIGHT,
            kFCurveDouble pWeight1                             = KFCURVE_DEFAULT_WEIGHT,
            kFCurveDouble pVelocity0 = KFCURVE_DEFAULT_VELOCITY,
            kFCurveDouble pVelocity1 = KFCURVE_DEFAULT_VELOCITY
        );
        
        KFCURVE_INLINE void SetTCB 
        (
            KTime pTime, 
            kFCurveDouble pValue, 
            float pData0 = 0.0f, 
            float pData1 = 0.0f, 
            float pData2 = 0.0f
        );
        
        KFCURVE_INLINE void Set(KFCurveKey& pSource);
        
        KFCURVE_INLINE kFCurveInterpolation GetInterpolation();
        
        KFCURVE_INLINE void SetInterpolation(kFCurveInterpolation pInterpolation);

        KFCURVE_INLINE kFCurveConstantMode GetConstantMode();

    KFCURVE_INLINE kFCurveTangeantMode GetTangeantMode( bool pIncludeOverrides = false );

        KFCURVE_INLINE kFCurveTangeantWeightMode GetTangeantWeightMode();

        KFCURVE_INLINE kFCurveTangeantVelocityMode GetTangeantVelocityMode();

        KFCURVE_INLINE void SetConstantMode(kFCurveConstantMode pMode);

        KFCURVE_INLINE void SetTangeantMode(kFCurveTangeantMode pTangent);
            
        KFCURVE_INLINE void SetTangeantWeightMode(kFCurveTangeantWeightMode pTangentWeightMode, kFCurveTangeantWeightMode pMask = KFCURVE_WEIGHTED_ALL );

        KFCURVE_INLINE void SetTangeantVelocityMode(kFCurveTangeantVelocityMode pTangentVelocityMode, kFCurveTangeantVelocityMode pMask = KFCURVE_VELOCITY_ALL );

            
        KFCURVE_INLINE kFCurveDouble GetDataDouble(EKFCurveDataIndex pIndex);
        
        KFCURVE_INLINE void SetDataDouble(EKFCurveDataIndex pIndex, kFCurveDouble pValue);
        
        KFCURVE_INLINE float GetDataFloat(EKFCurveDataIndex pIndex);

        KFCURVE_INLINE void SetDataFloat(EKFCurveDataIndex pIndex, float pValue);

        KFCURVE_INLINE float* GetDataPtr();

        KFCURVE_INLINE kFCurveDouble GetValue();

        KFCURVE_INLINE void SetValue(kFCurveDouble pValue);

        KFCURVE_INLINE void IncValue(kFCurveDouble pValue);

        KFCURVE_INLINE void MultValue(kFCurveDouble pValue);

        KFCURVE_INLINE void MultTangeant(kFCurveDouble pValue);

        KFCURVE_INLINE KTime GetTime();

        KFCURVE_INLINE void SetTime(KTime pTime);

        KFCURVE_INLINE void IncTime(KTime pTime);

        KFCURVE_INLINE void SetSelected(bool pSelected);    

        KFCURVE_INLINE bool GetSelected();

        KFCURVE_INLINE void SetMarkedForManipulation(bool pMark);   

        KFCURVE_INLINE bool GetMarkedForManipulation();

        KFCURVE_INLINE void SetTangeantVisibility (kFCurveTangeantVisibility pVisibility);  
        
        KFCURVE_INLINE kFCurveTangeantVisibility GetTangeantVisibility ();

        KFCURVE_INLINE void SetBreak(bool pVal); 

        KFCURVE_INLINE bool GetBreak(); 




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

        KFCURVE_INLINE void Init();

    #ifndef DOXYGEN_SHOULD_SKIP_THIS

    private:

        kFCurveDouble mValue;       
        KTime mTime;    
        kUInt mFlags;

    #ifdef KFCURVE_FLOAT
        float  mData[4];
    #else 
        double  mData[2];
        kInt16  mWeight[2];
        kInt16  mVelocity[2];
    #endif  

    #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

    };


    const int KEY_BLOCK_SIZE    = 1024;
    const int KEY_BLOCK_COUNT   = KEY_BLOCK_SIZE/sizeof (KFCurveKey);

    const int KEY_LIST_BLOCK_SIZE   = 256;
    const int KEY_LIST_BLOCK_COUNT  = KEY_LIST_BLOCK_SIZE/sizeof (KFCurveKey *);


    #ifdef K_PLUGIN
    class KFCURVE_DLL KFCurve
    #else 
    class KFCURVE_DLL KFCurve : public IFBObjectHolder
    #endif
    {

    public:


        KFCurve();

        virtual ~KFCurve();

        #ifdef K_PLUGIN
            void Destroy(int Local=0);
        #else
            IObject_Declare(Implementation)
        #endif


        float* GetColor();
        
        void SetColor(float *pColor);

        void SetValue(kFCurveDouble pValue);

        KFCURVE_INLINE kFCurveDouble GetValue() const;


        void ResizeKeyBuffer(int pKeyCount);

        void KeyModifyBegin ();
        
        void KeyModifyEnd ();

        int KeyGetCount ();

        int KeyGetSelectionCount ();

        // Select all keys.
        void KeySelectAll ();
        
        // Unselect all keys.
        void KeyUnselectAll ();

        KFCurveKey KeyGet(kFCurveIndex pIndex);
        
        void KeyClear ();
        
        void KeyShrink();

        bool    KeySet(kFCurveIndex pIndex, KFCurveKey& pKey);
        KFCURVE_INLINE bool KeySet(kFCurveIndex pIndex, KFCurve* pSourceCurve, int pSourceIndex);
        
        int KeyMove(kFCurveIndex pIndex, KTime pTime);
        
        bool KeyMoveOf (bool pSelectedOnly, KTime pDeltaTime, kFCurveDouble pDeltaValue);
        
        bool KeyMoveValueTo (bool pSelectedOnly, kFCurveDouble pValue);
        
        bool KeyScaleValue (bool pSelectedOnly, kFCurveDouble pMultValue);

        bool KeyScaleTangeant (bool pSelectedOnly, kFCurveDouble pMultValue);

        bool KeyScaleValueAndTangeant (bool pSelectedOnly, kFCurveDouble pMultValue);

        bool KeyRemove(kFCurveIndex pIndex);

        int KeyInsert ( KTime pTime, kFCurveIndex* pLast = NULL );

        int KeyAdd (KTime pTime, KFCurveKey& pKey, kFCurveIndex* pLast = NULL);
        int KeyAdd(KTime pTime, KFCurve* pSourceCurve, int pSourceIndex, kFCurveIndex* pLast = NULL);
        
        int KeyAdd (KTime pTime, kFCurveIndex* pLast = NULL);

        int KeyAppend(KTime pAtTime, KFCurve* pSourceCurve, int pSourceIndex);

        int KeyAppendFast( KTime pTime, kFCurveDouble pValue );
        
        double KeyFind (KTime pTime, kFCurveIndex* pLast = NULL);   


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



        KFCURVE_INLINE void KeySet 
        (
            kFCurveIndex pKeyIndex,
            KTime pTime, 
            kFCurveDouble pValue, 
            kFCurveInterpolation pInterpolation = KFCURVE_INTERPOLATION_CUBIC, 
            kFCurveTangeantMode pTangentMode = KFCURVE_TANGEANT_AUTO, 
            kFCurveDouble pData0 = 0.0,
            kFCurveDouble pData1 = 0.0,
            kFCurveTangeantWeightMode pTangentWeightMode = KFCURVE_WEIGHTED_NONE, 
            kFCurveDouble pWeight0                             = KFCURVE_DEFAULT_WEIGHT,
            kFCurveDouble pWeight1                             = KFCURVE_DEFAULT_WEIGHT,
            kFCurveDouble pVelocity0 = KFCURVE_DEFAULT_VELOCITY,
            kFCurveDouble pVelocity1 = KFCURVE_DEFAULT_VELOCITY
        );
        
        KFCURVE_INLINE void KeySetTCB 
        (
            kFCurveIndex pKeyIndex,
            KTime pTime, 
            kFCurveDouble pValue, 
            float pData0 = 0.0f, 
            float pData1 = 0.0f, 
            float pData2 = 0.0f
        );
            
        KFCURVE_INLINE kFCurveInterpolation KeyGetInterpolation(kFCurveIndex pKeyIndex);
        
        KFCURVE_INLINE void KeySetInterpolation(kFCurveIndex pKeyIndex, kFCurveInterpolation pInterpolation);

        KFCURVE_INLINE kFCurveConstantMode KeyGetConstantMode(kFCurveIndex pKeyIndex);

    KFCURVE_INLINE kFCurveTangeantMode KeyGetTangeantMode(kFCurveIndex pKeyIndex, bool pIncludeOverrides = false );

        KFCURVE_INLINE kFCurveTangeantWeightMode KeyGetTangeantWeightMode(kFCurveIndex pKeyIndex);

        KFCURVE_INLINE kFCurveTangeantVelocityMode KeyGetTangeantVelocityMode(kFCurveIndex pKeyIndex);

        KFCURVE_INLINE void KeySetConstantMode(kFCurveIndex pKeyIndex, kFCurveConstantMode pMode);

        KFCURVE_INLINE void KeySetTangeantMode(kFCurveIndex pKeyIndex, kFCurveTangeantMode pTangent);
            
        KFCURVE_INLINE void KeySetTangeantWeightMode(kFCurveIndex pKeyIndex, kFCurveTangeantWeightMode pTangentWeightMode, kFCurveTangeantWeightMode pMask = KFCURVE_WEIGHTED_ALL );

        KFCURVE_INLINE void KeySetTangeantVelocityMode(kFCurveIndex pKeyIndex, kFCurveTangeantVelocityMode pTangentVelocityMode, kFCurveTangeantVelocityMode pMask = KFCURVE_VELOCITY_ALL );

            
        KFCURVE_INLINE kFCurveDouble KeyGetDataDouble(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex);
        
        KFCURVE_INLINE void KeySetDataDouble(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex, kFCurveDouble pValue);
        
        KFCURVE_INLINE float KeyGetDataFloat(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex);

        KFCURVE_INLINE void KeySetDataFloat(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex, float pValue);

        KFCURVE_INLINE const float* KeyGetDataPtr(kFCurveIndex pKeyIndex);

        KFCURVE_INLINE kFCurveDouble KeyGetValue(kFCurveIndex pKeyIndex);

        KFCURVE_INLINE void KeySetValue(kFCurveIndex pKeyIndex, kFCurveDouble pValue);

        KFCURVE_INLINE void KeyIncValue(kFCurveIndex pKeyIndex, kFCurveDouble pValue);

        KFCURVE_INLINE void KeyMultValue(kFCurveIndex pKeyIndex, kFCurveDouble pValue);

        KFCURVE_INLINE void KeyMultTangeant(kFCurveIndex pKeyIndex, kFCurveDouble pValue);

        KFCURVE_INLINE KTime KeyGetTime(kFCurveIndex pKeyIndex);

        KFCURVE_INLINE void KeySetTime(kFCurveIndex pKeyIndex, KTime pTime);

        KFCURVE_INLINE void KeyIncTime(kFCurveIndex pKeyIndex, KTime pTime);

        KFCURVE_INLINE void KeySetSelected(kFCurveIndex pKeyIndex, bool pSelected); 

        KFCURVE_INLINE bool KeyGetSelected(kFCurveIndex pKeyIndex);

        KFCURVE_INLINE void KeySetMarkedForManipulation(kFCurveIndex pKeyIndex, bool pMark);    

        KFCURVE_INLINE bool KeyGetMarkedForManipulation(kFCurveIndex pKeyIndex);

        KFCURVE_INLINE void KeySetTangeantVisibility (kFCurveIndex pKeyIndex, kFCurveTangeantVisibility pVisibility);   
        
        KFCURVE_INLINE kFCurveTangeantVisibility KeyGetTangeantVisibility (kFCurveIndex pKeyIndex);

        KFCURVE_INLINE void KeySetBreak(kFCurveIndex pKeyIndex, bool pVal); 

        KFCURVE_INLINE bool KeyGetBreak(kFCurveIndex pKeyIndex); 


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


        void KeyTangeantSetInterpolation(bool pSelectedOnly, kFCurveInterpolation pInterpolation);
        
        void KeyTangeantSetMode(bool pSelectedOnly, kFCurveTangeantMode pTangentMode);
        
        kFCurveDouble KeyGetLeftDerivative(kFCurveIndex pIndex);
        
        void KeySetLeftDerivative(kFCurveIndex pIndex, kFCurveDouble pValue);

    kFCurveDouble KeyGetLeftAuto(kFCurveIndex pIndex, bool pApplyOvershootProtection = false);

        void KeySetLeftAuto(kFCurveIndex pIndex, kFCurveDouble pValue); 
        
        KFCurveTangeantInfo KeyGetLeftDerivativeInfo(kFCurveIndex pIndex);
        
    void KeySetLeftDerivativeInfo(kFCurveIndex pIndex, KFCurveTangeantInfo pValue, bool pForceDerivative = false);


        void KeyIncLeftDerivative(kFCurveIndex pIndex, kFCurveDouble pInc);
        
        kFCurveDouble KeyGetRightDerivative(kFCurveIndex pIndex);
        
        void KeySetRightDerivative(kFCurveIndex pIndex, kFCurveDouble pValue);

    kFCurveDouble KeyGetRightAuto(kFCurveIndex pIndex, bool pApplyOvershootProtection = false);
        
        void KeySetRightAuto(kFCurveIndex pIndex, kFCurveDouble pValue);
        
        
        KFCurveTangeantInfo KeyGetRightDerivativeInfo(kFCurveIndex pIndex);
        
    void KeySetRightDerivativeInfo(kFCurveIndex pIndex, KFCurveTangeantInfo pValue, bool pForceDerivative = false);


        void KeyIncRightDerivative(kFCurveIndex pIndex, kFCurveDouble pInc);
        
        kFCurveDouble KeyGetRightBezierTangeant(kFCurveIndex pIndex);
        
        void KeySetLeftBezierTangeant(kFCurveIndex pIndex, kFCurveDouble pValue);

        kFCurveDouble KeyGetLeftBezierTangeant(kFCurveIndex pIndex);
        
        void KeySetRightBezierTangeant(kFCurveIndex pIndex, kFCurveDouble pValue);


        void KeyMultDerivative(kFCurveIndex pIndex, kFCurveDouble pMultValue);

        bool KeyIsLeftTangeantWeighted(kFCurveIndex pIndex);

        bool KeyIsRightTangeantWeighted(kFCurveIndex pIndex);
        
        void   KeySetLeftTangeantWeightedMode( kFCurveIndex pIndex, bool pWeighted );

        void   KeySetRightTangeantWeightedMode( kFCurveIndex pIndex, bool pWeighted );

        kFCurveDouble KeyGetLeftTangeantWeight(kFCurveIndex pIndex);

        kFCurveDouble KeyGetRightTangeantWeight(kFCurveIndex pIndex);

        void   KeySetLeftTangeantWeight( kFCurveIndex pIndex, kFCurveDouble pWeight );

        void   KeySetRightTangeantWeight( kFCurveIndex pIndex, kFCurveDouble pWeight );

        bool KeyIsLeftTangeantVelocity(kFCurveIndex pIndex);

        bool KeyIsRightTangeantVelocity(kFCurveIndex pIndex);
        
        void   KeySetLeftTangeantVelocityMode( kFCurveIndex pIndex, bool pVelocity );

        void   KeySetRightTangeantVelocityMode( kFCurveIndex pIndex, bool pVelocity);

        kFCurveDouble KeyGetLeftTangeantVelocity(kFCurveIndex pIndex);

        kFCurveDouble KeyGetRightTangeantVelocity(kFCurveIndex pIndex);

        void   KeySetLeftTangeantVelocity( kFCurveIndex pIndex, kFCurveDouble pVelocity );

        void   KeySetRightTangeantVelocity( kFCurveIndex pIndex, kFCurveDouble pVelocity );
        


        KFCURVE_INLINE void SetPreExtrapolation(kFCurveExtrapolationMode pExtrapolation);
            
        KFCURVE_INLINE kFCurveExtrapolationMode GetPreExtrapolation();
        
        KFCURVE_INLINE void SetPreExtrapolationCount(kULong pCount);
        
        KFCURVE_INLINE kULong GetPreExtrapolationCount();
        
        KFCURVE_INLINE void SetPostExtrapolation(kFCurveExtrapolationMode pExtrapolation);
        
        KFCURVE_INLINE kFCurveExtrapolationMode GetPostExtrapolation();
        
        KFCURVE_INLINE void SetPostExtrapolationCount(kULong pCount);
            
        KFCURVE_INLINE kULong GetPostExtrapolationCount();

        int KeyGetCountAll();
        
        double KeyFindAll(KTime pTime, kFCurveIndex* pLast = NULL);


        
        kFCurveDouble Evaluate (KTime pTime, kFCurveIndex* pLast = NULL);

        kFCurveDouble EvaluateIndex( double pIndex);
        
        kFCurveDouble EvaluateLeftDerivative (KTime pTime, kFCurveIndex* pLast = NULL);
        
        kFCurveDouble EvaluateRightDerivative (KTime pTime, kFCurveIndex* pLast = NULL);

        int FindPeaks(kFCurveIndex pLeftKeyIndex, KTime& pPeakTime1, KTime& pPeakTime2);

        int FindPeaks(kFCurveIndex pLeftKeyIndex, kFCurveDouble& pPeak1, kFCurveDouble& pPeak2);

        int FindPeaks(kFCurveIndex pLeftKeyIndex, KTime& pPeakTime1, kFCurveDouble& pPeak1, KTime& pPeakTime2, kFCurveDouble& pPeak2);

        void KeyGetPeriods(KTime& pAveragePeriod, KTime& pMinPeriod, KTime& pMaxPeriod);
        


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

        void CopyFrom(KFCurve& pSource, bool pWithKeys = true);

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

    void ReplaceForQuaternion(HKFCurve pSource, KTime pStart, KTime pStop, kFCurveDouble pScaleStart, kFCurveDouble pScaleStop, bool pUseExactGivenSpan = false, bool pKeyStartEndOnNoKey = true, KTime pTimeSpanOffset = KTIME_ZERO );

    void ReplaceForEulerXYZ(HKFCurve pSource, KTime pStart, KTime pStop, kFCurveDouble pAddFromStart, kFCurveDouble pAddAfterStop, bool pValueSubOffsetAfterStart, bool pValueSubOffsetAfterStop, bool pUseExactGivenSpan = false, bool pKeyStartEndOnNoKey = true, KTime pTimeSpanOffset = KTIME_ZERO );   

        void Insert(HKFCurve pSource, KTime pInsertTime, kFCurveDouble pFirstKeyLeftDerivative, bool pFirstKeyIsWeighted = false, kFCurveDouble pFirstKeyWeight = KFCURVE_DEFAULT_WEIGHT);

        void Insert(HKFCurve pSource, KTime pInsertTime, KFCurveTangeantInfo pFirstKeyLeftDerivative );

        bool Delete(kFCurveIndex pStartIndex , kFCurveIndex pStopIndex);                                    
        
        bool Delete (KTime pStart = KTIME_MINUS_INFINITE, KTime pStop = KTIME_INFINITE);

        bool IsKeyInterpolationPureCubicAuto(kFCurveIndex pKeyIndex);

    #ifndef K_PLUGIN

        void ExtractKeysIndex( KArraykInt &pArray, int pMinIndex, int pMaxIndex, double pMinValue =  -K_DOUBLE_MAX, double pMaxValue =  K_DOUBLE_MAX);
    #endif


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

    #ifndef DOXYGEN_SHOULD_SKIP_THIS

        bool    FbxStore (KFbx* pFbx, bool pOnlyDefaults = false, bool pColor = true, bool pIsVersion5 = false );
        bool    FbxRetrieve (KFbx* pFbx, bool pOnlyDefaults = false, bool pColor = false );
        bool    FbxInternalRetrieve (KFbx* pFbx, bool pOnlyDefaults = false, bool pColor = false );

        double CandidateEvaluate (KTime pTime, kFCurveIndex* pLast = NULL);
        bool CandidateClear ();
        bool CandidateSet (KTime pTime, double pValue);
        bool IsCandidate ();
        double CandidateGet ();
        KTime CandidateGetTime ();
        
        bool CandidateKey
        (
            kFCurveIndex    *pLast              = NULL, 
            int pInterpolation = KFCURVE_INTERPOLATION_CUBIC, 
            int pTanMode = KFCURVE_TANGEANT_USER, 
        int pContinuity = KFCURVE_CONTINUITY,
            bool            pTangeantOverride   = true,
            KTime           pCandidateTime      = KTIME_INFINITE,
            double          pKeyIndexTolerance  = 0.0
        );

        bool NormalsSeemsToComeFromAPlot();

        void SetWasData (int pType);
        int GetWasData ();
        int GuessWasData (KTime* pStart = NULL, KTime* pStep = NULL);

        void KeyTangeantHide ();

        int GetUpdateId ();
        int GetValuesUpdateId ();

        void CallbackRegister (kFCurveCallback pCallback, void* pObject);
        void CallbackUnregister (kFCurveCallback pCallback, void* pObject);
        void CallbackEnable (bool pEnable);
        void CallbackClear ();

    private:
        void IncrementUpdateId(int pInc);
        void CallbackAddEvent (int pWhat, int pIndexStart);

        int MapIndexAll (int pIndex, int &pWhere);
        void InitBuffers (int pKeyCount);

        bool CheckCurve();
    void IsClamped( int pIndex, bool &pLeftClamped, bool &pRightClamped ); // Return true if the specified key is an auto clamp that is currently clamped

        float mColor[3];

        kFCurveDouble mValue;

        int mUpdateId;
        bool mCallbackEnable;
        bool mInternalCallbackEnable; // Internal use, to replace many callback by one
        int mKeyModifyGuard;

        KFCurveKey** mFCurveKeysList;

        int mFCurveKeyCount;    
        int mFCurveKeySize; 
        int mFCurveLastBlockIndex;  


        kUInt mPreExtrapolation;
        kULong mPreExtrapolationCount;
        kUInt mPostExtrapolation;
        kULong mPostExtrapolationCount;

        int mWasType;

        kFCurveIndex mLastSearchIndex;

        KTime mCandidateTime;
        kFCurveDouble mCandidateValue;

        KFCurveEvent mEvent;
        KArrayUL mCallbackFunctions;   // no delete on object must use array ul
        KArrayUL mCallbackObjects;     // no delete on object must use array ul

        // FBObjectHolder for FBSDK reference
        #ifndef K_PLUGIN
            KFBObjectHolder mFBObjectHolder;
            KFCURVE_INLINE KFBObjectHolder& GetFBHolder ();
        #endif

        KFCURVE_INLINE KFCurveKey* InternalKeyGetPtr(kFCurveIndex pIndex);

    #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

    };


    #ifndef K_PLUGIN
        #include <kfcurve/kfcurveinline.h>
    #endif


    KFCURVE_DLL HKFCurve KFCurveCreate();

    // Create a function curve, FBX SDK internal use only.
    KFCURVE_DLL HKFCurve KFCurveCreate(KFbx* pFbx, bool pOnlyDefaults = false, bool pColor = false);

    // Create a function curve, FBX SDK internal use only.
    KFCURVE_DLL HKFCurve KFCurveCreate(KFbx* pFbx, HKFCurve pCurve, bool pOnlyDefaults = false, bool pColor = false);

#include <kfcurve/kfcurve_nsend.h>


#endif // #ifndef _FBXSDK_KFCURVE_H_