kfcurve.h

Go to the documentation of this file.

#ifndef FBXFILESDK_COMPONENTS_KFCURVE_KFCURVE_H
#define FBXFILESDK_COMPONENTS_KFCURVE_KFCURVE_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/ktime.h>
#include <fbxfilesdk/components/kbaselib/object/e/keventbase.h>
#include <fbxfilesdk/components/kbaselib/klib/kdebug.h>


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

#ifndef KFBX_PLUGIN
    #include <fbxfilesdk/components/kbaselib/klib/kdebug.h>
#endif

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

#undef  KFBX_FCURVE_INLINE
#define KFBX_FCURVE_INLINE inline

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

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


    KFBX_FORWARD(KFCurve);

    #define IKFCurveID 43763635

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

    // Recording memory functions declaration
    KFBX_DLL kULong GetRecordingMemory();
    KFBX_DLL void WatchFree(void* pPtr, kULong pSize);
    KFBX_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  
    };

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

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


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

        int mKeyIndexStop;  

        int mEventCount;    

        KFBX_FCURVE_INLINE void Clear (); 
        
        KFBX_FCURVE_INLINE void Add (int pWhat, int pIndex);
    };

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

    class KFBX_DLL KFCurveTangeantInfo 
    {
    public:
        KFBX_FCURVE_INLINE KFCurveTangeantInfo();

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

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

    public:
        
        KFBX_FCURVE_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
        );
        
        KFBX_FCURVE_INLINE void SetTCB 
        (
            KTime pTime, 
            kFCurveDouble pValue, 
            float pData0 = 0.0f, 
            float pData1 = 0.0f, 
            float pData2 = 0.0f
        );
        
        KFBX_FCURVE_INLINE void Set(KFCurveKey& pSource);
        
        KFBX_FCURVE_INLINE kFCurveInterpolation GetInterpolation();
        
        KFBX_FCURVE_INLINE void SetInterpolation(kFCurveInterpolation pInterpolation);

        KFBX_FCURVE_INLINE kFCurveConstantMode GetConstantMode();

        KFBX_FCURVE_INLINE kFCurveTangeantMode GetTangeantMode( bool pIncludeOverrides = false );

        KFBX_FCURVE_INLINE kFCurveTangeantWeightMode GetTangeantWeightMode();

        KFBX_FCURVE_INLINE kFCurveTangeantVelocityMode GetTangeantVelocityMode();

        KFBX_FCURVE_INLINE void SetConstantMode(kFCurveConstantMode pMode);

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

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

        KFBX_FCURVE_INLINE void SetTangentWeightAndAdjustTangent( EKFCurveDataIndex pIndex, kFCurveDouble pWeight );


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

        KFBX_FCURVE_INLINE void SetDataFloat(EKFCurveDataIndex pIndex, float pValue);

        KFBX_FCURVE_INLINE float* GetDataPtr();

        KFBX_FCURVE_INLINE kFCurveDouble GetValue();

        KFBX_FCURVE_INLINE void SetValue(kFCurveDouble pValue);

        KFBX_FCURVE_INLINE void IncValue(kFCurveDouble pValue);

        KFBX_FCURVE_INLINE void MultValue(kFCurveDouble pValue);

        KFBX_FCURVE_INLINE void MultTangeant(kFCurveDouble pValue);

        KFBX_FCURVE_INLINE KTime GetTime();

        KFBX_FCURVE_INLINE void SetTime(KTime pTime);

        KFBX_FCURVE_INLINE void IncTime(KTime pTime);

        KFBX_FCURVE_INLINE void SetSelected(bool pSelected);    

        KFBX_FCURVE_INLINE bool GetSelected();

        KFBX_FCURVE_INLINE void SetMarkedForManipulation(bool pMark);   

        KFBX_FCURVE_INLINE bool GetMarkedForManipulation();

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

        KFBX_FCURVE_INLINE void SetBreak(bool pVal); 

        KFBX_FCURVE_INLINE bool GetBreak(); 




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

        KFBX_FCURVE_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 KFBX_PLUGIN
    class KFBX_DLL KFCurve
    #else 
    class KFBX_DLL KFCurve : public IFBObjectHolder
    #endif
    {

    public:


        KFCurve();

        virtual ~KFCurve();

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


        float* GetColor();

        void SetColor(float *pColor);

        void SetValue(kFCurveDouble pValue);

        KFBX_FCURVE_INLINE kFCurveDouble GetValue() const;


        void ResizeKeyBuffer(int pKeyCount);

        void KeyModifyBegin ();

        void KeyModifyEnd ();

        int KeyGetCount ();

        int KeyGetSelectionCount ();

        void KeySelectAll ();

        void KeyUnselectAll ();

        KFCurveKey KeyGet(kFCurveIndex pIndex);

        void KeyClear ();

        void KeyShrink();

        bool    KeySet(kFCurveIndex pIndex, KFCurveKey& pKey);

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


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



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

        KFBX_FCURVE_INLINE void KeySetTCB 
            (
            kFCurveIndex pKeyIndex,
            KTime pTime, 
            kFCurveDouble pValue, 
            float pData0 = 0.0f, 
            float pData1 = 0.0f, 
            float pData2 = 0.0f
            );

        KFBX_FCURVE_INLINE kFCurveInterpolation KeyGetInterpolation(kFCurveIndex pKeyIndex);

        KFBX_FCURVE_INLINE void KeySetInterpolation(kFCurveIndex pKeyIndex, kFCurveInterpolation pInterpolation);

        KFBX_FCURVE_INLINE kFCurveConstantMode KeyGetConstantMode(kFCurveIndex pKeyIndex);

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

        KFBX_FCURVE_INLINE kFCurveTangeantWeightMode KeyGetTangeantWeightMode(kFCurveIndex pKeyIndex);

        KFBX_FCURVE_INLINE kFCurveTangeantVelocityMode KeyGetTangeantVelocityMode(kFCurveIndex pKeyIndex);

        KFBX_FCURVE_INLINE void KeySetConstantMode(kFCurveIndex pKeyIndex, kFCurveConstantMode pMode);

        KFBX_FCURVE_INLINE void KeySetTangeantMode(kFCurveIndex pKeyIndex, kFCurveTangeantMode pTangent);

        KFBX_FCURVE_INLINE void KeySetTangeantWeightMode(kFCurveIndex pKeyIndex, kFCurveTangeantWeightMode pTangentWeightMode, kFCurveTangeantWeightMode pMask = KFCURVE_WEIGHTED_ALL );

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


        KFBX_FCURVE_INLINE kFCurveDouble KeyGetDataDouble(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex);

        KFBX_FCURVE_INLINE void KeySetDataDouble(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex, kFCurveDouble pValue);

        KFBX_FCURVE_INLINE float KeyGetDataFloat(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex);

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

        KFBX_FCURVE_INLINE const float* KeyGetDataPtr(kFCurveIndex pKeyIndex);

        KFBX_FCURVE_INLINE kFCurveDouble KeyGetValue(kFCurveIndex pKeyIndex);

        KFBX_FCURVE_INLINE void KeySetValue(kFCurveIndex pKeyIndex, kFCurveDouble pValue);

        KFBX_FCURVE_INLINE void KeyIncValue(kFCurveIndex pKeyIndex, kFCurveDouble pValue);

        KFBX_FCURVE_INLINE void KeyMultValue(kFCurveIndex pKeyIndex, kFCurveDouble pValue);

        KFBX_FCURVE_INLINE void KeyMultTangeant(kFCurveIndex pKeyIndex, kFCurveDouble pValue);

        KFBX_FCURVE_INLINE KTime KeyGetTime(kFCurveIndex pKeyIndex);

        KFBX_FCURVE_INLINE void KeySetTime(kFCurveIndex pKeyIndex, KTime pTime);

        KFBX_FCURVE_INLINE void KeyIncTime(kFCurveIndex pKeyIndex, KTime pTime);

        KFBX_FCURVE_INLINE void KeySetSelected(kFCurveIndex pKeyIndex, bool pSelected); 

        KFBX_FCURVE_INLINE bool KeyGetSelected(kFCurveIndex pKeyIndex);

        KFBX_FCURVE_INLINE void KeySetMarkedForManipulation(kFCurveIndex pKeyIndex, bool pMark);    

        KFBX_FCURVE_INLINE bool KeyGetMarkedForManipulation(kFCurveIndex pKeyIndex);

        KFBX_FCURVE_INLINE void KeySetTangeantVisibility (kFCurveIndex pKeyIndex, kFCurveTangeantVisibility pVisibility);   

        KFBX_FCURVE_INLINE kFCurveTangeantVisibility KeyGetTangeantVisibility (kFCurveIndex pKeyIndex);

        KFBX_FCURVE_INLINE void KeySetBreak(kFCurveIndex pKeyIndex, bool pVal); 

        KFBX_FCURVE_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, bool pAdjustTan = false );

        void   KeySetRightTangeantWeight( kFCurveIndex pIndex, kFCurveDouble pWeight, bool pAdjustTan = false  );

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



        KFBX_FCURVE_INLINE void SetPreExtrapolation(kFCurveExtrapolationMode pExtrapolation);

        KFBX_FCURVE_INLINE kFCurveExtrapolationMode GetPreExtrapolation();

        KFBX_FCURVE_INLINE void SetPreExtrapolationCount(kULong pCount);

        KFBX_FCURVE_INLINE kULong GetPreExtrapolationCount();

        KFBX_FCURVE_INLINE void SetPostExtrapolation(kFCurveExtrapolationMode pExtrapolation);

        KFBX_FCURVE_INLINE kFCurveExtrapolationMode GetPostExtrapolation();

        KFBX_FCURVE_INLINE void SetPostExtrapolationCount(kULong pCount);

        KFBX_FCURVE_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 KFBX_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 KFBX_PLUGIN
            KFBObjectHolder mFBObjectHolder;
            KFBX_FCURVE_INLINE KFBObjectHolder& GetFBHolder ();
        #endif

        KFBX_FCURVE_INLINE KFCurveKey* InternalKeyGetPtr(kFCurveIndex pIndex);

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

    };


    KFBX_FCURVE_INLINE void KFCurveEvent::Clear () 
    {
        mType = KFCURVEEVENT_NONE;
        mKeyIndexStart = mKeyIndexStop=-1; 
        mEventCount = 0; 
    }


    KFBX_FCURVE_INLINE void KFCurveEvent::Add (int pWhat, int pIndex) 
    {       
        mType |= pWhat;
        mEventCount++;
        if ( (pIndex<mKeyIndexStart) || (mKeyIndexStart==-1)) 
        {
            mKeyIndexStart = pIndex;
        }
        if (pIndex>mKeyIndexStop) 
        {
            mKeyIndexStop = pIndex;
        }
    }

    //
    //  class KFCurveKey
    //
    KFBX_FCURVE_INLINE KFCurveTangeantInfo::KFCurveTangeantInfo()
    {
        mDerivative = 0.0;
        mWeight     = KFCURVE_DEFAULT_WEIGHT;
        mWeighted   = false;
        mVelocity   = KFCURVE_DEFAULT_VELOCITY;
        mHasVelocity= false;
        mAuto       = 0.0;
    }

    //
    //  class KFCurveKey
    //

    KFBX_FCURVE_INLINE void KFCurveKey::Set 
        (
        KTime pTime, 
        kFCurveDouble pValue, 
        kFCurveInterpolation pInterpolation /* = KFCURVE_INTERPOLATION_CUBIC*/, 
        kFCurveTangeantMode pTangeantMode /*= KFCURVE_TANGEANT_AUTO*/, 
        kFCurveDouble pData0 /*= 0*/, 
        kFCurveDouble pData1 /*= 0*/,
        kFCurveTangeantWeightMode pTangeantWeightMode /*= KFCURVE_WEIGHT_NONE*/, 
        kFCurveDouble pWeight0 /* = KFCURVE_DEFAULT_WEIGHT */,
        kFCurveDouble pWeight1 /* = KFCURVE_DEFAULT_WEIGHT */,
        kFCurveDouble pVelocity0 /* = KFCURVE_DEFAULT_VELOCITY */,
        kFCurveDouble pVelocity1 /* = KFCURVE_DEFAULT_VELOCITY */
        )
    {
        K_ASSERT (pInterpolation != KFCURVE_INTERPOLATION_CUBIC || pTangeantMode != KFCURVE_TANGEANT_TCB);

        SetTime (pTime);
        SetValue (pValue);
        SetInterpolation (pInterpolation);
        SetTangeantMode (pTangeantMode);
        SetDataDouble (KFCURVEKEY_RIGHT_SLOPE, pData0);
        SetDataDouble (KFCURVEKEY_NEXT_LEFT_SLOPE, pData1);

        SetTangeantWeightMode (pTangeantWeightMode);
        SetDataDouble (KFCURVEKEY_RIGHT_WEIGHT, pWeight0);
        SetDataDouble (KFCURVEKEY_NEXT_LEFT_WEIGHT, pWeight1);

        SetDataDouble (KFCURVEKEY_RIGHT_VELOCITY, pVelocity0);
        SetDataDouble (KFCURVEKEY_NEXT_LEFT_VELOCITY, pVelocity1);

        SetTangeantVisibility (KFCURVE_TANGEANT_SHOW_NONE);
    }


    KFBX_FCURVE_INLINE void KFCurveKey::SetTCB (KTime pTime, kFCurveDouble pValue, float pData1/*=0.0f*/, float pData2/*=0.0f*/, float pData3/*=0.0f*/)
    {
        SetTime (pTime);
        SetValue (pValue);
        SetInterpolation (KFCURVE_INTERPOLATION_CUBIC);
        SetTangeantMode (KFCURVE_TANGEANT_TCB);
        SetDataFloat (KFCURVEKEY_TCB_TENSION, pData1);
        SetDataFloat (KFCURVEKEY_TCB_CONTINUITY, pData2);
        SetDataFloat (KFCURVEKEY_TCB_BIAS, pData3);
        SetTangeantVisibility (KFCURVE_TANGEANT_SHOW_NONE);
    }


    KFBX_FCURVE_INLINE void KFCurveKey::Set (KFCurveKey& iSource)
    {
        mValue = iSource.mValue;
        mTime = iSource.mTime;
        mFlags = iSource.mFlags;
        mData[0] = iSource.mData[0];
        mData[1] = iSource.mData[1];
        #ifdef KFCURVE_FLOAT
            mData[2] = iSource.mData[2];
            mData[3] = iSource.mData[3];
        #else 
            mWeight[0] = iSource.mWeight[0];
            mWeight[1] = iSource.mWeight[1];
            mVelocity[0] = iSource.mVelocity[0];
            mVelocity[1] = iSource.mVelocity[1];
        #endif
    }


    KFBX_FCURVE_INLINE kFCurveInterpolation KFCurveKey::GetInterpolation () 
    {
        return mFlags & KFCURVE_INTERPOLATION_ALL;
    }


    KFBX_FCURVE_INLINE void KFCurveKey::SetInterpolation (kFCurveInterpolation pInterpolation)  
    {
        K_ASSERT_MSG(   (pInterpolation == KFCURVE_INTERPOLATION_CUBIC) || 
            (pInterpolation == KFCURVE_INTERPOLATION_LINEAR) ||
            (pInterpolation == KFCURVE_INTERPOLATION_CONSTANT) ,"Wrong interpolation type." );

        if( (((mFlags & KFCURVE_INTERPOLATION_ALL)!=KFCURVE_INTERPOLATION_CUBIC)) && pInterpolation == KFCURVE_INTERPOLATION_CUBIC )
        {
            // Clear weighting information
            SetTangeantWeightMode( KFCURVE_WEIGHTED_NONE);
            SetDataDouble (KFCURVEKEY_RIGHT_WEIGHT, KFCURVE_DEFAULT_WEIGHT);
            SetDataDouble (KFCURVEKEY_NEXT_LEFT_WEIGHT, KFCURVE_DEFAULT_WEIGHT);

            SetTangeantVelocityMode(KFCURVE_VELOCITY_NONE);
            SetDataDouble( KFCURVEKEY_RIGHT_VELOCITY, KFCURVE_DEFAULT_VELOCITY);
            SetDataDouble( KFCURVEKEY_NEXT_LEFT_VELOCITY, KFCURVE_DEFAULT_VELOCITY);
        }

        mFlags = (mFlags & ~KFCURVE_INTERPOLATION_ALL) | (pInterpolation & KFCURVE_INTERPOLATION_ALL); 
    }


    KFBX_FCURVE_INLINE kFCurveConstantMode KFCurveKey::GetConstantMode() 
    {
        return mFlags & KFCURVE_CONSTANT_ALL;
    }

    KFBX_FCURVE_INLINE kFCurveTangeantMode KFCurveKey::GetTangeantMode( bool pIncludeOverrides ) 
    {
        if( pIncludeOverrides )
        {
            return mFlags & KFCURVE_TANGEANT_ALL;
        }
        else
        {
            return mFlags & KFCURVE_TANGEANT_TYPE_MASK;
        }
    }

    KFBX_FCURVE_INLINE void KFCurveKey::SetConstantMode (kFCurveConstantMode pMode)         
    {
        K_ASSERT_MSG(   (GetInterpolation() != KFCURVE_INTERPOLATION_CONSTANT) ||
            (pMode == KFCURVE_CONSTANT_STANDARD) ||
            (pMode == KFCURVE_CONSTANT_NEXT),"Wrong constant mode.");

        mFlags = (mFlags & ~KFCURVE_CONSTANT_ALL) | (pMode & KFCURVE_CONSTANT_ALL); 
    }

    KFBX_FCURVE_INLINE void KFCurveKey::SetTangeantMode (kFCurveTangeantMode pTangeant)         
    {

        K_ASSERT_MSG( (GetInterpolation() != KFCURVE_INTERPOLATION_CUBIC) || !(pTangeant & ~KFCURVE_TANGEANT_ALL), "Wrong tangent mode." );
        K_ASSERT_MSG( (GetInterpolation() != KFCURVE_INTERPOLATION_CONSTANT) || !(pTangeant & ~KFCURVE_CONSTANT_ALL), "Wrong tangent mode." );

        mFlags = (mFlags & ~(KFCURVE_TANGEANT_ALL|KFCURVE_CONSTANT_ALL)) | (pTangeant & (KFCURVE_TANGEANT_ALL|KFCURVE_CONSTANT_ALL) ); 
    }

    KFBX_FCURVE_INLINE kFCurveTangeantWeightMode KFCurveKey::GetTangeantWeightMode()
    {
        return mFlags & KFCURVE_WEIGHTED_ALL;
    }

    KFBX_FCURVE_INLINE void KFCurveKey::SetTangeantWeightMode(kFCurveTangeantWeightMode pTangent, kFCurveTangeantWeightMode pMask /* KFCURVE_WEIGHTED_ALL */ )
    {

        pMask &= KFCURVE_WEIGHTED_ALL;
        mFlags = (mFlags & ~pMask) | (pTangent & pMask); 
    }

    KFBX_FCURVE_INLINE kFCurveTangeantVelocityMode KFCurveKey::GetTangeantVelocityMode()
    {
        return mFlags & KFCURVE_VELOCITY_ALL;
    }

    KFBX_FCURVE_INLINE void KFCurveKey::SetTangeantVelocityMode(kFCurveTangeantVelocityMode pTangent, kFCurveTangeantVelocityMode pMask /* KFCURVE_VELOCITY_ALL */ )
    {
        pMask &= KFCURVE_VELOCITY_ALL;
        mFlags = (mFlags & ~pMask) | (pTangent & pMask); 
    }

    KFBX_FCURVE_INLINE void KFCurveKey::SetTangentWeightAndAdjustTangent( EKFCurveDataIndex pIndex, kFCurveDouble pWeight ) 
    {
        K_ASSERT( pIndex == KFCURVEKEY_RIGHT_WEIGHT || pIndex == KFCURVEKEY_NEXT_LEFT_WEIGHT);
        if (pIndex != KFCURVEKEY_RIGHT_WEIGHT && pIndex != KFCURVEKEY_NEXT_LEFT_WEIGHT)
            return;

        if( pWeight > KFCURVE_MAX_WEIGHT )
        {
            pWeight = KFCURVE_MAX_WEIGHT;
        }

        int lWeightToStore = (int)(pWeight*KFCURVE_WEIGHT_DIVIDER);
        if( lWeightToStore < 1 )
        {
            lWeightToStore = 1;
        }

        // Apply the adjustment to the tangent value
        // ..only if Weight is small values..for weights below 0.01 here which will correct all errors over 1%
        // 
        if( pWeight < ((kFCurveDouble)(100.0/KFCURVE_WEIGHT_DIVIDER)) )
        {
            int index = (pIndex == KFCURVEKEY_RIGHT_WEIGHT) ? KFCURVEKEY_RIGHT_SLOPE : KFCURVEKEY_NEXT_LEFT_SLOPE;
            double lTangent = mData[index];
            lTangent = lTangent*pWeight*KFCURVE_WEIGHT_DIVIDER/(double)lWeightToStore;
            mData[index] = lTangent;
        }
       
        #ifdef KFCURVE_FLOAT
            (((kInt16*)(&mData[KFCURVEKEY_WEIGHTS]))[pIndex-KFCURVEKEY_WEIGHTS]) = (kInt16)lWeightToStore;
        #else       
            mWeight[pIndex-KFCURVEKEY_WEIGHTS] = lWeightToStore;
        #endif
    }

    KFBX_FCURVE_INLINE void KFCurveKey::SetTangeantVisibility (kFCurveTangeantVisibility pVisibility)               
    {
        K_ASSERT_MSG(   (pVisibility == KFCURVE_TANGEANT_SHOW_NONE) || 
            (pVisibility == KFCURVE_TANGEANT_SHOW_LEFT) ||
            (pVisibility == KFCURVE_TANGEANT_SHOW_RIGHT) ||
            (pVisibility == KFCURVE_TANGEANT_SHOW_BOTH) ,"Wrong visibility type." );

        mFlags = (mFlags & ~KFCURVE_TANGEANT_SHOW_BOTH) | (pVisibility & KFCURVE_TANGEANT_SHOW_BOTH); 
    }


    KFBX_FCURVE_INLINE kFCurveTangeantVisibility KFCurveKey::GetTangeantVisibility () 
    {
        return mFlags & KFCURVE_TANGEANT_SHOW_BOTH;
    }


    KFBX_FCURVE_INLINE kFCurveDouble KFCurveKey::GetDataDouble (EKFCurveDataIndex pIndex) 
    {
        if( pIndex < KFCURVEKEY_WEIGHTS )
        {
            return mData[pIndex];
        }
        else
        {
            #ifdef KFCURVE_FLOAT
                return (kFCurveDouble)(((kInt16*)(&mData[KFCURVEKEY_WEIGHTS]))[pIndex-KFCURVEKEY_WEIGHTS])/(kFCurveDouble)KFCURVE_WEIGHT_DIVIDER;
            #else       
                return (kFCurveDouble)mWeight[pIndex-KFCURVEKEY_WEIGHTS]/(kFCurveDouble)KFCURVE_WEIGHT_DIVIDER;
            #endif
        }
    }


    KFBX_FCURVE_INLINE void KFCurveKey::SetDataDouble (EKFCurveDataIndex pIndex, kFCurveDouble pValue) 
    {
        if( pIndex < KFCURVEKEY_RIGHT_WEIGHT )
        {
            mData[pIndex] = pValue;
        }
        else
        {
            if( (pIndex == KFCURVEKEY_RIGHT_WEIGHT || pIndex == KFCURVEKEY_NEXT_LEFT_WEIGHT ) && pValue > KFCURVE_MAX_WEIGHT )
            {
                pValue = KFCURVE_MAX_WEIGHT;
            }
            else if( (pIndex == KFCURVEKEY_RIGHT_WEIGHT || pIndex == KFCURVEKEY_NEXT_LEFT_WEIGHT ) && pValue < KFCURVE_MIN_WEIGHT )
            {
                pValue = KFCURVE_MIN_WEIGHT;
            }

            #ifdef KFCURVE_FLOAT
                (((kInt16*)(&mData[KFCURVEKEY_WEIGHTS]))[pIndex-KFCURVEKEY_WEIGHTS]) = (kInt16)(pValue*KFCURVE_WEIGHT_DIVIDER);
            #else       
                mWeight[pIndex-KFCURVEKEY_WEIGHTS] = pValue*KFCURVE_WEIGHT_DIVIDER;
            #endif
        }
    }


    KFBX_FCURVE_INLINE float KFCurveKey::GetDataFloat (EKFCurveDataIndex pIndex) 
    {
        return ( (float *)&mData[0])[pIndex];
    }


    KFBX_FCURVE_INLINE void KFCurveKey::SetDataFloat (EKFCurveDataIndex pIndex, float pValue) 
    {
        ((float *)&mData[0])[pIndex] = pValue;
    }

    KFBX_FCURVE_INLINE float* KFCurveKey::GetDataPtr()
    {
        return (float*)mData;
    }


    KFBX_FCURVE_INLINE kFCurveDouble KFCurveKey::GetValue () 
    {
        return mValue;
    }


    KFBX_FCURVE_INLINE void KFCurveKey::SetValue (kFCurveDouble pValue) 
    {
        mValue=pValue;
    }


    KFBX_FCURVE_INLINE void KFCurveKey::IncValue (kFCurveDouble pValue) 
    {
        mValue+=pValue;
    }

    KFBX_FCURVE_INLINE void KFCurveKey::MultValue (kFCurveDouble pValue) 
    {
        mValue*=pValue;
    }

    KFBX_FCURVE_INLINE void KFCurveKey::MultTangeant (kFCurveDouble pValue) 
    {
        if (GetInterpolation() == KFCURVE_INTERPOLATION_CUBIC)
        {
            switch (GetTangeantMode())
            {                   
            case KFCURVE_TANGEANT_USER:
            case KFCURVE_TANGEANT_BREAK:
                SetDataDouble(KFCURVEKEY_RIGHT_SLOPE, GetDataDouble(KFCURVEKEY_RIGHT_SLOPE) * pValue);
                SetDataDouble(KFCURVEKEY_NEXT_LEFT_SLOPE, GetDataDouble(KFCURVEKEY_NEXT_LEFT_SLOPE) * pValue);
                break;
            case KFCURVE_TANGEANT_TCB:
                // dunno how to handle this
            case KFCURVE_TANGEANT_AUTO:
            case KFCURVE_TANGEANT_AUTO_BREAK:
            default:
                // nothing to do
                break;
            }
        }
    }

    KFBX_FCURVE_INLINE KTime KFCurveKey::GetTime () 
    {
        return mTime;
    }


    KFBX_FCURVE_INLINE void KFCurveKey::SetTime (KTime pTime) 
    {
        K_ASSERT_MSG( pTime != KTIME_MINUS_INFINITE && 
            pTime != KTIME_INFINITE, "Key at infinite!" );

        mTime=pTime;
    }

    KFBX_FCURVE_INLINE void KFCurveKey::IncTime (KTime pTime) 
    {
        mTime+=pTime;
    }


    KFBX_FCURVE_INLINE void KFCurveKey::SetSelected (bool pSelected) 
    {
        mFlags = pSelected ? (mFlags & ~KFCURVE_SELECT_ALL) | KFCURVE_SELECT_POINT : (mFlags & ~KFCURVE_SELECT_ALL);
    }


    KFBX_FCURVE_INLINE bool KFCurveKey::GetSelected () 
    {
        return (mFlags & KFCURVE_SELECT_POINT) ? true : false;
    }


    KFBX_FCURVE_INLINE void KFCurveKey::SetMarkedForManipulation (bool pSelected) 
    {
        mFlags = pSelected ? (mFlags & ~KFCURVE_MARKED_ALL) | KFCURVE_MARKED_FOR_MANIP : (mFlags & ~KFCURVE_MARKED_ALL);
    }


    KFBX_FCURVE_INLINE bool KFCurveKey::GetMarkedForManipulation () 
    {
        return (mFlags & KFCURVE_MARKED_FOR_MANIP) ? true : false;
    }


    KFBX_FCURVE_INLINE void KFCurveKey::Init()
    {
        mValue = 0.0;
        mTime = KTIME_ZERO;
        mFlags = 0;
    }


    KFBX_FCURVE_INLINE void KFCurveKey::SetBreak(bool pVal)
    {
        K_ASSERT_MSG(   (GetInterpolation() != KFCURVE_INTERPOLATION_CUBIC) ||                  
            (GetTangeantMode() == KFCURVE_TANGEANT_BREAK) ||
            (GetTangeantMode() == KFCURVE_TANGEANT_AUTO)  ||
            (GetTangeantMode() == KFCURVE_TANGEANT_AUTO_BREAK)  ||
            (GetTangeantMode() == KFCURVE_TANGEANT_USER) ,"Wrong tangent mode." );

        if(pVal)
            mFlags = mFlags |  KFCURVE_GENERIC_BREAK ;
        else
            mFlags = mFlags & ~KFCURVE_GENERIC_BREAK ;  

    } 

    KFBX_FCURVE_INLINE bool KFCurveKey::GetBreak()
    {
        K_ASSERT_MSG(   (GetInterpolation() != KFCURVE_INTERPOLATION_CUBIC) ||                  
            (GetTangeantMode() == KFCURVE_TANGEANT_BREAK) ||
            (GetTangeantMode() == KFCURVE_TANGEANT_AUTO)  ||
            (GetTangeantMode() == KFCURVE_TANGEANT_AUTO_BREAK)  ||
            (GetTangeantMode() == KFCURVE_TANGEANT_USER)  ,"Wrong tangent mode." );

        if( ((mFlags & KFCURVE_GENERIC_BREAK ) == KFCURVE_GENERIC_BREAK))
            return true;
        else
            return false; 

    }


    //****************************************************************************************
    // class KFCurve
    //****************************************************************************************

    KFBX_FCURVE_INLINE kFCurveDouble KFCurve::GetValue () const 
    {
        return mValue;
    }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    KFBX_FCURVE_INLINE void KFCurve::SetPreExtrapolation (kUInt pExtrapolation) 
    {
        K_ASSERT_MSG(   (pExtrapolation == KFCURVE_EXTRAPOLATION_CONST) || 
            (pExtrapolation == KFCURVE_EXTRAPOLATION_REPETITION) ||
            (pExtrapolation == KFCURVE_EXTRAPOLATION_MIRROR_REPETITION) ||
            (pExtrapolation == KFCURVE_EXTRAPOLATION_KEEP_SLOPE) ,"Wrong extrapolation type." );

        mPreExtrapolation = pExtrapolation; 
        CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, -1);
    }
#endif

    KFBX_FCURVE_INLINE kUInt KFCurve::GetPreExtrapolation () 
    {
        return mPreExtrapolation;
    }


    KFBX_FCURVE_INLINE void KFCurve::SetPreExtrapolationCount (kULong pCount) 
    {
        mPreExtrapolationCount = pCount; 
        CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, -1);
    }


    KFBX_FCURVE_INLINE kULong KFCurve::GetPreExtrapolationCount () 
    {
        return mPreExtrapolationCount;
    }

#ifndef DOXYGEN_SHOULD_SKIP_THIS

    KFBX_FCURVE_INLINE void KFCurve::SetPostExtrapolation (kUInt pExtrapolation) 
    {
        K_ASSERT_MSG(   (pExtrapolation == KFCURVE_EXTRAPOLATION_CONST) || 
            (pExtrapolation == KFCURVE_EXTRAPOLATION_REPETITION) ||
            (pExtrapolation == KFCURVE_EXTRAPOLATION_MIRROR_REPETITION) ||
            (pExtrapolation == KFCURVE_EXTRAPOLATION_KEEP_SLOPE) ,"Wrong extrapolation type." );

        mPostExtrapolation = pExtrapolation; 
        CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, -1);
    }

#endif

    KFBX_FCURVE_INLINE kUInt KFCurve::GetPostExtrapolation () 
    {
        return mPostExtrapolation;
    }


    KFBX_FCURVE_INLINE void KFCurve::SetPostExtrapolationCount (kULong pCount) 
    {
        mPostExtrapolationCount = pCount; 
        CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, -1);
    }


    KFBX_FCURVE_INLINE kULong KFCurve::GetPostExtrapolationCount () 
    {
        return mPostExtrapolationCount;
    }

    #ifndef DOXYGEN_SHOULD_SKIP_THIS
    KFBX_FCURVE_INLINE KFCurveKey* KFCurve::InternalKeyGetPtr (int pIndex) 
    {
        K_ASSERT_MSG( pIndex >= 0, "Negative indexes are not recommended." );
        K_ASSERT_MSG( mFCurveKeysList && mFCurveKeysList[pIndex / KEY_BLOCK_COUNT], "Accessing unallocated buffer." );

        return mFCurveKeysList[pIndex / KEY_BLOCK_COUNT] + (pIndex % KEY_BLOCK_COUNT);
    }
    
    #ifndef KFBX_PLUGIN
        KFBX_FCURVE_INLINE KFBObjectHolder& KFCurve::GetFBHolder () 
        {
            return mFBObjectHolder;
        }
    #endif
    #endif
 
    /*********************************************************************************************/
    /*********************************************************************************************/
    /*********************************************************************************************/
    /*********************************************************************************************/
    KFBX_FCURVE_INLINE bool KFCurve::KeySet(kFCurveIndex pIndex, KFCurve* pSourceCurve, int pSourceIndex)
    {
        KFCurveKey* lKey = pSourceCurve->InternalKeyGetPtr(pSourceIndex);
        return KeySet(pIndex, *lKey);
    }


    KFBX_FCURVE_INLINE int KFCurve::KeyAdd(KTime pTime, KFCurve* pSourceCurve, int pSourceIndex, kFCurveIndex* pLast)
    {
        K_ASSERT(pSourceIndex >= 0);
        K_ASSERT(pSourceIndex < pSourceCurve->KeyGetCount());

        KFCurveKey* lKey = pSourceCurve->InternalKeyGetPtr(pSourceIndex);
        return KeyAdd(pTime, *lKey, pLast);
    }


    KFBX_FCURVE_INLINE void KFCurve::KeySet 
        (
        kFCurveIndex pKeyIndex,
        KTime pTime, 
        kFCurveDouble pValue, 
        kFCurveInterpolation pInterpolation, 
        kFCurveTangeantMode pTangentMode, 
        kFCurveDouble pData0, 
        kFCurveDouble pData1, 
        kFCurveTangeantWeightMode pTangentWeightMode, 
        kFCurveDouble pWeight0, 
        kFCurveDouble pWeight1, 
        kFCurveDouble pVelocity0, 
        kFCurveDouble pVelocity1
        )
    {
        InternalKeyGetPtr(pKeyIndex)->Set(pTime, pValue, pInterpolation, pTangentMode, pData0, pData1, pTangentWeightMode, pWeight0, pWeight1, pVelocity0, pVelocity1);

        if (pKeyIndex >= mFCurveKeyCount)
        {
            int lOldCount = mFCurveKeyCount;
            mFCurveKeyCount = pKeyIndex + 1;

            CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_KEYADD, lOldCount);
            CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_KEYADD, pKeyIndex);
        }
        else
        {
            CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITVALUE | KFCURVEEVENT_EDITTIME | KFCURVEEVENT_EDITOTHER, pKeyIndex);
        }
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetTCB 
        (
        kFCurveIndex pKeyIndex,
        KTime pTime, 
        kFCurveDouble pValue, 
        float pData0, 
        float pData1, 
        float pData2
        )
    {
        InternalKeyGetPtr(pKeyIndex)->SetTCB(pTime, pValue, pData0, pData1, pData2);

        if (pKeyIndex >= mFCurveKeyCount)
        {
            int lOldCount = mFCurveKeyCount;
            mFCurveKeyCount = pKeyIndex + 1;

            CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_KEYADD, lOldCount);
            CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_KEYADD, pKeyIndex);
        }
        else
        {
            CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITVALUE | KFCURVEEVENT_EDITTIME | KFCURVEEVENT_EDITOTHER, pKeyIndex);
        }
    }

    KFBX_FCURVE_INLINE kFCurveInterpolation KFCurve::KeyGetInterpolation(kFCurveIndex pKeyIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetInterpolation();
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetInterpolation(kFCurveIndex pKeyIndex, kFCurveInterpolation pInterpolation)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetInterpolation(pInterpolation);
        CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
    }

    KFBX_FCURVE_INLINE kFCurveConstantMode KFCurve::KeyGetConstantMode(kFCurveIndex pKeyIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetConstantMode();
    }

    KFBX_FCURVE_INLINE kFCurveTangeantMode KFCurve::KeyGetTangeantMode(kFCurveIndex pKeyIndex, bool pIncludeOverrides )
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetTangeantMode( pIncludeOverrides );
    }

    KFBX_FCURVE_INLINE kFCurveTangeantWeightMode KFCurve::KeyGetTangeantWeightMode(kFCurveIndex pKeyIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetTangeantWeightMode();
    }

    KFBX_FCURVE_INLINE kFCurveTangeantVelocityMode KFCurve::KeyGetTangeantVelocityMode(kFCurveIndex pKeyIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetTangeantVelocityMode();
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetConstantMode(kFCurveIndex pKeyIndex, kFCurveConstantMode pMode)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetConstantMode(pMode);
        CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetTangeantMode(kFCurveIndex pKeyIndex, kFCurveTangeantMode pTangent)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetTangeantMode(pTangent);
        CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetTangeantWeightMode(kFCurveIndex pKeyIndex, kFCurveTangeantWeightMode pTangentWeightMode, kFCurveTangeantWeightMode pMask)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetTangeantWeightMode(pTangentWeightMode, pMask);
        CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetTangeantVelocityMode(kFCurveIndex pKeyIndex, kFCurveTangeantVelocityMode pTangentVelocityMode, kFCurveTangeantVelocityMode pMask)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetTangeantVelocityMode(pTangentVelocityMode, pMask);
        CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
    }

    KFBX_FCURVE_INLINE kFCurveDouble KFCurve::KeyGetDataDouble(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetDataDouble(pIndex);
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetDataDouble(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex, kFCurveDouble pValue)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetDataDouble(pIndex, pValue);
        CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
    }

    KFBX_FCURVE_INLINE float KFCurve::KeyGetDataFloat(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetDataFloat(pIndex);
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetDataFloat(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex, float pValue)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetDataFloat(pIndex, pValue);
        CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
    }

    KFBX_FCURVE_INLINE const float* KFCurve::KeyGetDataPtr(kFCurveIndex pKeyIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetDataPtr();
    }

    KFBX_FCURVE_INLINE kFCurveDouble KFCurve::KeyGetValue(kFCurveIndex pKeyIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetValue();
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetValue(kFCurveIndex pKeyIndex, kFCurveDouble pValue)
    {
        InternalKeyGetPtr(pKeyIndex)->SetValue(pValue);
        CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITVALUE, pKeyIndex);
    }

    KFBX_FCURVE_INLINE void KFCurve::KeyIncValue(kFCurveIndex pKeyIndex, kFCurveDouble pValue)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->IncValue(pValue);
        CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITVALUE, pKeyIndex);
    }

    KFBX_FCURVE_INLINE void KFCurve::KeyMultValue(kFCurveIndex pKeyIndex, kFCurveDouble pValue)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->MultValue(pValue);
        CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITVALUE, pKeyIndex);
    }

    KFBX_FCURVE_INLINE void KFCurve::KeyMultTangeant(kFCurveIndex pKeyIndex, kFCurveDouble pValue)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->MultTangeant(pValue);
        CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
    }

    KFBX_FCURVE_INLINE KTime KFCurve::KeyGetTime(kFCurveIndex pKeyIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetTime();
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetTime(kFCurveIndex pKeyIndex, KTime pTime)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetTime(pTime);
        CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITTIME, pKeyIndex);
    }

    KFBX_FCURVE_INLINE void KFCurve::KeyIncTime(kFCurveIndex pKeyIndex, KTime pTime)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->IncTime(pTime);
        CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITTIME, pKeyIndex);
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetSelected(kFCurveIndex pKeyIndex, bool pSelected)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetSelected(pSelected);
        CallbackAddEvent(KFCURVEEVENT_SELECTION, pKeyIndex);
    }

    KFBX_FCURVE_INLINE bool KFCurve::KeyGetSelected(kFCurveIndex pKeyIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetSelected();
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetMarkedForManipulation(kFCurveIndex pKeyIndex, bool pMarked)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetMarkedForManipulation(pMarked);
    }

    KFBX_FCURVE_INLINE bool KFCurve::KeyGetMarkedForManipulation(kFCurveIndex pKeyIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetMarkedForManipulation();
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetTangeantVisibility (kFCurveIndex pKeyIndex, kFCurveTangeantVisibility pVisibility)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetTangeantVisibility(pVisibility);
        CallbackAddEvent(KFCURVEEVENT_SELECTION, pKeyIndex);
    }

    KFBX_FCURVE_INLINE kFCurveTangeantVisibility KFCurve::KeyGetTangeantVisibility (kFCurveIndex pKeyIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetTangeantVisibility();
    }

    KFBX_FCURVE_INLINE void KFCurve::KeySetBreak(kFCurveIndex pKeyIndex, bool pVal)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        InternalKeyGetPtr(pKeyIndex)->SetBreak(pVal);
        CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
    }

    KFBX_FCURVE_INLINE bool KFCurve::KeyGetBreak(kFCurveIndex pKeyIndex)
    {
        K_ASSERT(pKeyIndex >= 0);
        K_ASSERT(pKeyIndex < KeyGetCount());

        return InternalKeyGetPtr(pKeyIndex)->GetBreak();
    }



    KFBX_DLL HKFCurve KFCurveCreate();

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

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

#include <fbxfilesdk/fbxfilesdk_nsend.h>


#endif // FBXFILESDK_COMPONENTS_KFCURVE_KFCURVE_H