kfcurve.h

Go to the documentation of this file.

#ifndef FBXFILESDK_COMPONENTS_KFCURVE_KFCURVE_H
#define FBXFILESDK_COMPONENTS_KFCURVE_KFCURVE_H

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

 Copyright (C) 2001 - 2010 Autodesk, Inc. and/or its licensors.
 All Rights Reserved.

 The coded instructions, statements, computer programs, and/or related material 
 (collectively the "Data") in these files contain unpublished information 
 proprietary to Autodesk, Inc. and/or its licensors, which is protected by 
 Canada and United States of America federal copyright law and by international 
 treaties. 
 
 The Data may not be disclosed or distributed to third parties, in whole or in
 part, without the prior written consent of Autodesk, Inc. ("Autodesk").

 THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY.
 ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO
 WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR ARISING
 BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES OF TITLE, 
 NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE OR USE. 
 WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT WARRANT THAT THE OPERATION
 OF THE DATA WILL BE UNINTERRUPTED OR ERROR FREE. 
 
 IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS
 OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR EXPENSES
 OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE DAMAGES OR OTHER
 SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS OF PROFITS, REVENUE
 OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR DAMAGES OF ANY KIND),
 HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF LIABILITY, WHETHER DERIVED
 FROM CONTRACT, TORT (INCLUDING, BUT NOT LIMITED TO, NEGLIGENCE), OR OTHERWISE,
 ARISING OUT OF OR RELATING TO THE DATA OR ITS USE OR ANY OTHER PERFORMANCE,
 WHETHER OR NOT AUTODESK HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS
 OR DAMAGE. 

**************************************************************************************/
#include <fbxfilesdk/fbxfilesdk_def.h>

#include <fbxfilesdk/components/kbaselib/klib/karrayul.h>
#include <fbxfilesdk/components/kbaselib/klib/ktime.h>
#include <fbxfilesdk/components/kbaselib/klib/kdebug.h>
#include <fbxfilesdk/components/kbaselib/object/e/keventbase.h>

#undef  KFBX_FCURVE_INLINE
#define KFBX_FCURVE_INLINE inline

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

KFBX_FORWARD(KFbx);
KFBX_FORWARD(KDataType);
KFBX_FORWARD(KgeQuaternion);
KFBX_FORWARD(KgeRMatrix);

#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_GENERIC_TIME_INDEPENDENT  = 0x00002000,
    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_GENERIC_TIME_INDEPENDENT,
    KFCURVE_TANGEANT_TYPE_MASK        = KFCURVE_TANGEANT_AUTO|KFCURVE_TANGEANT_TCB|KFCURVE_TANGEANT_USER|KFCURVE_TANGEANT_BREAK,
    KFCURVE_TANGEANT_OVERRIDES_MASK   = KFCURVE_GENERIC_CLAMP|KFCURVE_GENERIC_TIME_INDEPENDENT
};

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 tokens from weight 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;
    kFCurveDouble mVelocity;
    kFCurveDouble mAuto;  // The auto parameter!
    bool         mWeighted;
    bool          mHasVelocity;
};

class KFCurveKey;

class KFCurveKeyAttrManager;


class KFBX_DLL KMemoryBlockQueue;

struct KPriFCurveKeyAttr
{
    KPriFCurveKeyAttr() : mFlags(0) {}

    KFBX_FCURVE_INLINE void Set 
        (
        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 (float pData0 = 0.0f, float pData1 = 0.0f, float pData2 = 0.0f);
    KFBX_FCURVE_INLINE void Set(KFCurveKey& pSource);
    KFBX_FCURVE_INLINE kFCurveInterpolation GetInterpolation() const;
    KFBX_FCURVE_INLINE void SetInterpolation(kFCurveInterpolation pInterpolation);
    KFBX_FCURVE_INLINE kFCurveConstantMode GetConstantMode() const;
    KFBX_FCURVE_INLINE kFCurveTangeantMode GetTangeantMode( bool pIncludeOverrides = false ) const;
    KFBX_FCURVE_INLINE kFCurveTangeantWeightMode GetTangeantWeightMode() const;
    KFBX_FCURVE_INLINE kFCurveTangeantVelocityMode GetTangeantVelocityMode() const;
    KFBX_FCURVE_INLINE void SetConstantMode(kFCurveConstantMode pMode);
    KFBX_FCURVE_INLINE void SetTangeantMode(kFCurveTangeantMode pTangent, bool pIgnoreAutoTimeIndepedentConversion = false);
    KFBX_FCURVE_INLINE void SetTangeantWeightMode(kFCurveTangeantWeightMode pTangentWeightMode, kFCurveTangeantWeightMode pMask = KFCURVE_WEIGHTED_ALL );
    KFBX_FCURVE_INLINE void SetTangentWeightAndAdjustTangent( EKFCurveDataIndex pIndex, kFCurveDouble pWeight );
    KFBX_FCURVE_INLINE void SetTangeantVelocityMode(kFCurveTangeantVelocityMode pTangentVelocityMode, kFCurveTangeantVelocityMode pMask = KFCURVE_VELOCITY_ALL );
    KFBX_FCURVE_INLINE kFCurveDouble GetDataDouble(EKFCurveDataIndex pIndex) const;
    KFBX_FCURVE_INLINE void SetDataDouble(EKFCurveDataIndex pIndex, kFCurveDouble pValue);
    KFBX_FCURVE_INLINE float GetDataFloat(EKFCurveDataIndex pIndex) const;
    KFBX_FCURVE_INLINE void SetDataFloat(EKFCurveDataIndex pIndex, float pValue);
    KFBX_FCURVE_INLINE float* GetDataPtr() const;
    KFBX_FCURVE_INLINE void SetSelected(bool pSelected);    
    KFBX_FCURVE_INLINE bool GetSelected() const;
    KFBX_FCURVE_INLINE void SetMarkedForManipulation(bool pMark);   
    KFBX_FCURVE_INLINE bool GetMarkedForManipulation() const;
    KFBX_FCURVE_INLINE void SetTangeantVisibility (kFCurveTangeantVisibility pVisibility);  
    KFBX_FCURVE_INLINE kFCurveTangeantVisibility GetTangeantVisibility () const;
    KFBX_FCURVE_INLINE void SetBreak(bool pVal); 
    KFBX_FCURVE_INLINE bool GetBreak() const; 
    KFBX_FCURVE_INLINE bool IsEqual(const KPriFCurveKeyAttr& pRsh) const;
    KFBX_FCURVE_INLINE void IncRefCount();
    KFBX_FCURVE_INLINE void DecRefCount();
    KFBX_FCURVE_INLINE kUInt32 GetRefCount() const;

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

};

struct KPriFCurveKey
{
    KPriFCurveKey()
    {
        Init();
    }

    KFBX_FCURVE_INLINE void Init();
    KFBX_FCURVE_INLINE void Set (KTime pTime, kFCurveDouble pValue);
    KFBX_FCURVE_INLINE kFCurveDouble GetValue() const;
    KFBX_FCURVE_INLINE void SetValue(kFCurveDouble pValue);
    KFBX_FCURVE_INLINE void IncValue(kFCurveDouble pValue);
    KFBX_FCURVE_INLINE void MultValue(kFCurveDouble pValue);
    KFBX_FCURVE_INLINE KTime GetTime() const;
    KFBX_FCURVE_INLINE void SetTime(KTime pTime);
    KFBX_FCURVE_INLINE void IncTime(KTime pTime);

    KTime mTime;  //8 Bytes
#ifdef KFCURVE_FLOAT
    KPriFCurveKeyAttr* mAttr; // 4 Bytes on 32-bit OS, 8 Bytes on 64-bit OS
    kFCurveDouble mValue; // 4 Bytes (float) for KFCRVE_FLOAT, 8 Bytes (double) otherwise.
#else
    kFCurveDouble mValue;
    KPriFCurveKeyAttr* mAttr;
#endif
};


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() const;
    
    KFBX_FCURVE_INLINE void SetInterpolation(kFCurveInterpolation pInterpolation);

    KFBX_FCURVE_INLINE kFCurveConstantMode GetConstantMode() const;

    KFBX_FCURVE_INLINE kFCurveTangeantMode GetTangeantMode( bool pIncludeOverrides = false ) const;

    KFBX_FCURVE_INLINE kFCurveTangeantWeightMode GetTangeantWeightMode() const;

    KFBX_FCURVE_INLINE kFCurveTangeantVelocityMode GetTangeantVelocityMode() const;

    KFBX_FCURVE_INLINE void SetConstantMode(kFCurveConstantMode pMode);

    KFBX_FCURVE_INLINE void SetTangeantMode(kFCurveTangeantMode pTangent, bool pIgnoreAutoTimeIndepedentConversion = false);
        
    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) const;
    
    KFBX_FCURVE_INLINE void SetDataDouble(EKFCurveDataIndex pIndex, kFCurveDouble pValue);
    
    KFBX_FCURVE_INLINE float GetDataFloat(EKFCurveDataIndex pIndex) const;

    KFBX_FCURVE_INLINE void SetDataFloat(EKFCurveDataIndex pIndex, float pValue);

    KFBX_FCURVE_INLINE float* GetDataPtr() const;

    KFBX_FCURVE_INLINE kFCurveDouble GetValue() const;

    KFBX_FCURVE_INLINE void SetValue(kFCurveDouble pValue);

    KFBX_FCURVE_INLINE void IncValue(kFCurveDouble pValue);

    KFBX_FCURVE_INLINE void MultValue(kFCurveDouble pValue);

    KFBX_FCURVE_INLINE KTime GetTime() const;

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

    KFBX_FCURVE_INLINE void SetMarkedForManipulation(bool pMark);   

    KFBX_FCURVE_INLINE bool GetMarkedForManipulation() const;

    KFBX_FCURVE_INLINE void SetTangeantVisibility (kFCurveTangeantVisibility pVisibility);  

    KFBX_FCURVE_INLINE kFCurveTangeantVisibility GetTangeantVisibility () const;

    KFBX_FCURVE_INLINE void SetBreak(bool pVal); 

    KFBX_FCURVE_INLINE bool GetBreak() const; 

    KFBX_FCURVE_INLINE void Init();


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


    #ifndef DOXYGEN_SHOULD_SKIP_THIS
private:
    friend class KFCurve;
    KFBX_FCURVE_INLINE KFCurveKey(const KPriFCurveKey& pKey, const KPriFCurveKeyAttr& pAttr);
    KFBX_FCURVE_INLINE KPriFCurveKeyAttr GetKeyAttr() const;

private:
    KTime mTime;
    kFCurveDouble mValue;           
    kUInt32 mFlags;

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

    #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

};

#ifdef KFCURVE_FLOAT
extern void TangentWeightAndAdjustTangent(EKFCurveDataIndex pIndex, kFCurveDouble pWeight, float mData[4]);
#else
extern void TangentWeightAndAdjustTangent(EKFCurveDataIndex pIndex, kFCurveDouble pWeight, double mData[2], kInt16 mWeight[2]);
#endif

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

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


class KFBX_DLL KFCurve
{

public:


    KFCurve();

    virtual ~KFCurve();

    void Destroy(int Local=0);


    float* GetColor();

    void SetColor(const float *pColor);

    void SetValue(kFCurveDouble pValue);

    KFBX_FCURVE_INLINE kFCurveDouble GetValue() const;


    void ResizeKeyBuffer(int pKeyCount, bool pResetKeyCount = false);

    void KeyModifyBegin ();

    void KeyModifyEnd ();

    int KeyGetCount () const;

    int KeyGetSelectionCount () const;

    void KeySelectAll ();

    void KeyUnselectAll ();

    KFCurveKey KeyGet(kFCurveIndex pIndex) const;

    void KeyClear ();

    void KeyShrink();

    bool    KeySet(kFCurveIndex pIndex, KFCurveKey& pKey);

    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 pRightSlope = 0.0,
        kFCurveDouble pNextLeftSlope = 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) const;

    KFBX_FCURVE_INLINE void KeySetInterpolation(kFCurveIndex pKeyIndex, kFCurveInterpolation pInterpolation);

    KFBX_FCURVE_INLINE kFCurveConstantMode KeyGetConstantMode(kFCurveIndex pKeyIndex) const;

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

    KFBX_FCURVE_INLINE kFCurveTangeantWeightMode KeyGetTangeantWeightMode(kFCurveIndex pKeyIndex) const;

    KFBX_FCURVE_INLINE kFCurveTangeantVelocityMode KeyGetTangeantVelocityMode(kFCurveIndex pKeyIndex) const;

    KFBX_FCURVE_INLINE void KeySetConstantMode(kFCurveIndex pKeyIndex, kFCurveConstantMode pMode);

    KFBX_FCURVE_INLINE void KeySetTangeantMode(kFCurveIndex pKeyIndex, kFCurveTangeantMode pTangent, bool pIgnoreAutoTimeIndepedentConversion = false);

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

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

    KFBX_FCURVE_INLINE float KeyGetDataFloat(kFCurveIndex pKeyIndex, EKFCurveDataIndex pIndex) const;

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

    KFBX_FCURVE_INLINE const float* KeyGetDataPtr(kFCurveIndex pKeyIndex) const;

    KFBX_FCURVE_INLINE kFCurveDouble KeyGetValue(kFCurveIndex pKeyIndex) const;

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

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

    KFBX_FCURVE_INLINE void KeySetMarkedForManipulation(kFCurveIndex pKeyIndex, bool pMark);    

    KFBX_FCURVE_INLINE bool KeyGetMarkedForManipulation(kFCurveIndex pKeyIndex) const;

    KFBX_FCURVE_INLINE void KeySetTangeantVisibility (kFCurveIndex pKeyIndex, kFCurveTangeantVisibility pVisibility);   

    KFBX_FCURVE_INLINE kFCurveTangeantVisibility KeyGetTangeantVisibility (kFCurveIndex pKeyIndex) const;

    KFBX_FCURVE_INLINE void KeySetBreak(kFCurveIndex pKeyIndex, bool pVal); 

    KFBX_FCURVE_INLINE bool KeyGetBreak(kFCurveIndex pKeyIndex) const; 


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


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

    bool KeyIsRightTangeantWeighted(kFCurveIndex pIndex) const;

    void   KeySetLeftTangeantWeightedMode( kFCurveIndex pIndex, bool pWeighted);

    void   KeySetRightTangeantWeightedMode( kFCurveIndex pIndex, bool pWeighted);

    kFCurveDouble KeyGetLeftTangeantWeight(kFCurveIndex pIndex) const;

    kFCurveDouble KeyGetRightTangeantWeight(kFCurveIndex pIndex) const;

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

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

    bool KeyIsLeftTangeantVelocity(kFCurveIndex pIndex) const;

    bool KeyIsRightTangeantVelocity(kFCurveIndex pIndex) const;

    void   KeySetLeftTangeantVelocityMode( kFCurveIndex pIndex, bool pVelocity );

    void   KeySetRightTangeantVelocityMode( kFCurveIndex pIndex, bool pVelocity);

    kFCurveDouble KeyGetLeftTangeantVelocity(kFCurveIndex pIndex) const;

    kFCurveDouble KeyGetRightTangeantVelocity(kFCurveIndex pIndex) const;

    void   KeySetLeftTangeantVelocity( kFCurveIndex pIndex, kFCurveDouble pVelocity );

    void   KeySetRightTangeantVelocity( kFCurveIndex pIndex, kFCurveDouble pVelocity );



    KFBX_FCURVE_INLINE void SetPreExtrapolation(kFCurveExtrapolationMode pExtrapolation);

    KFBX_FCURVE_INLINE kFCurveExtrapolationMode GetPreExtrapolation() const;

    KFBX_FCURVE_INLINE void SetPreExtrapolationCount(kULong pCount);

    KFBX_FCURVE_INLINE kULong GetPreExtrapolationCount() const;

    KFBX_FCURVE_INLINE void SetPostExtrapolation(kFCurveExtrapolationMode pExtrapolation);

    KFBX_FCURVE_INLINE kFCurveExtrapolationMode GetPostExtrapolation() const;

    KFBX_FCURVE_INLINE void SetPostExtrapolationCount(kULong pCount);

    KFBX_FCURVE_INLINE kULong GetPostExtrapolationCount() const;

    int KeyGetCountAll() const;

    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 pInclusive = false);

    bool IsKeyInterpolationPureCubicAuto(kFCurveIndex pKeyIndex);

    void ExtractKeysIndex( KArrayTemplate<int> &pArray, int pMinIndex, int pMaxIndex, double pMinValue =  -K_DOUBLE_MAX, double pMaxValue =  K_DOUBLE_MAX);


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

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    typedef enum {
        V7 = 4007,
        V6 = 4005,
        V5 = 4004
    } FbxStoreVersionID;

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

    void    FbxStorePriKeyAndAttrArrays(KFbx* pFbx);
    void    FbxRetrievePriKeyAndAttrArrays(KFbx* pFbx);
    void    FbxRetrievePrePostExtrapolation(KFbx* pFbx);

    double CandidateEvaluate (KTime pTime, kFCurveIndex* pLast = NULL);
    bool CandidateClear ();
    bool CandidateSet (KTime pTime, double pValue);
    bool IsCandidate ();
    double CandidateGet ();
    KTime CandidateGetTime ();

    bool IsLocked() const;
    bool IsLockedByLayer() const;
    bool IsLockedByProperty() const;
    void SetLockedByLayer(bool pLocked);
    void SetLockedByProperty(bool pLocked);

    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 () const;
    int GuessWasData (KTime* pStart = NULL, KTime* pStep = NULL);

    void KeyTangeantHide ();

    int GetUpdateId () const;
    int GetValuesUpdateId () const;

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

public:
    static bool sConvertAutoTimeIndepedent;

    void CopyExternalPriKeyAndAttr(void** pSourceFCurveKeysList, int pSourceFCurveKeyCount); 

    KPriFCurveKey** GetPriFCurveKeysList() const { return mFCurveKeysList; }

private:
    void KeyAttrSet(kFCurveIndex pKeyIndex, const KPriFCurveKeyAttr& pKeyAttr);

    void KeyAttrSeparate(kFCurveIndex pKeyIndex);
    
    KFBX_FCURVE_INLINE void KeyAttrSeparateCheck(kFCurveIndex pKeyIndex);

    /* Control optimization flag, when enable, we will perform KeyAttrShrink() operation
     * when call KeyModifyEnd().
     */ 
    void KeySetOptimizeEnable(bool pEnable); 
    void KeySetOptimizeThreshold(int pThreshold);

    void KeyAttrShrink(kFCurveIndex pStartIndex, kFCurveIndex pStopIndex);

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

    int MapIndexAll (int pIndex, int &pWhere);
    void InitBuffers (int pKeyCount, bool pResetKeyCount = false );

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

public:
    static void AllocateGlobals();

    static void FreeGlobals();

public:
    static  KFCurveKeyAttrManager*  mGlobalKeyAttrMemoryPool;
    // Recording Memory global var
    static  kULong                  mGlobalRecordingMemory;
    static  KMemoryBlockQueue*      mGlobalKeyBufferQueue;

private:

    float mColor[3];

    kFCurveDouble mValue;

    int mUpdateId;
    int mFlags;
    int mOptimizationThreshold;
    int mKeyModifyGuard;

    KPriFCurveKey** 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

    KFBX_FCURVE_INLINE KPriFCurveKey* InternalPriKeyGetPtr (kFCurveIndex pIndex) const;
    KFBX_FCURVE_INLINE KPriFCurveKeyAttr* InternalPriKeyAttrGetPtr(kFCurveIndex pIndex) const;

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

};

// Allocate memory blocks for fcurve to give room for recording.
KFBX_DLL void KFCURVE_SetFCurveRecordMemoryBlockCount ( int pBlockCount );
KFBX_DLL int KFCURVE_GetFCurveMemoryBlockSize ( );
KFBX_DLL void KFCURVE_ClearMemoryBlockQueue ();

//
// class KFCurveEvent
//
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;
}

KFBX_FCURVE_INLINE KFCurveKey::KFCurveKey(const KPriFCurveKey& pKey, const KPriFCurveKeyAttr& pAttr)
{
    mTime = pKey.mTime;
    mValue = pKey.mValue;
    mFlags = pAttr.mFlags;
    mData[0] = pAttr.mData[0];
    mData[1] = pAttr.mData[1];
#ifdef KFCURVE_FLOAT
    mData[2] = pAttr.mData[2];
    mData[3] = pAttr.mData[3];
#else
    mWeight[0] = pAttr.mWeight[0];
    mWeight[1] = pAttr.mWeight[1];
    mVelocity[0] = pAttr.mVelocity[0];
    mVelocity[1] = pAttr.mVelocity[1];
#endif
}

KFBX_FCURVE_INLINE KPriFCurveKeyAttr KFCurveKey::GetKeyAttr() const
{
    KPriFCurveKeyAttr lKeyAttr;
    lKeyAttr.mFlags = mFlags;
    lKeyAttr.mData[0] = mData[0];
    lKeyAttr.mData[1] = mData[1];
#ifdef KFCURVE_FLOAT
    lKeyAttr.mData[2] = mData[2];
    lKeyAttr.mData[3] = mData[3];
#else
    lKeyAttr.mWeight[0] = mWeight[0];
    lKeyAttr.mWeight[1] = mWeight[1];
    lKeyAttr.mVelocity[0] = mVelocity[0];
    lKeyAttr.mVelocity[1] = mVelocity[1];
#endif
    return lKeyAttr;
}

KFBX_FCURVE_INLINE void KPriFCurveKeyAttr::Set 
(
    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);

    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 KPriFCurveKey::Set 
(
    KTime pTime, 
    kFCurveDouble pValue
)
{
    SetTime (pTime);
    SetValue (pValue);
}

//
//  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 KPriFCurveKeyAttr::SetTCB (float pData1/*=0.0f*/, float pData2/*=0.0f*/, float pData3/*=0.0f*/)
{
    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::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)
{
    memcpy(this, &iSource, sizeof(KFCurveKey));
}

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

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


KFBX_FCURVE_INLINE void KPriFCurveKeyAttr::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 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 KPriFCurveKeyAttr::GetConstantMode() const
{
    return mFlags & KFCURVE_CONSTANT_ALL;
}

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

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

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

KFBX_FCURVE_INLINE void KPriFCurveKeyAttr::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::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 KPriFCurveKeyAttr::SetTangeantMode (kFCurveTangeantMode pTangeant, bool pIgnoreAutoTimeIndepedentConversion/* = false*/)            
{
    K_ASSERT_MSG( (GetInterpolation() != KFCURVE_INTERPOLATION_CUBIC) || !(pTangeant & ~KFCURVE_TANGEANT_ALL), "Wrong tangeant mode." );
    K_ASSERT_MSG( (GetInterpolation() != KFCURVE_INTERPOLATION_CONSTANT) || !(pTangeant & ~KFCURVE_CONSTANT_ALL), "Wrong tangeant mode." );

    // Convert Auto to Time-Independent.
    if (! pIgnoreAutoTimeIndepedentConversion && KFCurve::sConvertAutoTimeIndepedent && (mFlags & KFCURVE_INTERPOLATION_CUBIC) && (pTangeant & KFCURVE_TANGEANT_AUTO))
    {
        pTangeant = pTangeant | KFCURVE_GENERIC_TIME_INDEPENDENT;
    }

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

KFBX_FCURVE_INLINE void KFCurveKey::SetTangeantMode (kFCurveTangeantMode pTangeant, bool pIgnoreAutoTimeIndepedentConversion/* = false*/)           
{
    K_ASSERT_MSG( (GetInterpolation() != KFCURVE_INTERPOLATION_CUBIC) || !(pTangeant & ~KFCURVE_TANGEANT_ALL), "Wrong tangeant mode." );
    K_ASSERT_MSG( (GetInterpolation() != KFCURVE_INTERPOLATION_CONSTANT) || !(pTangeant & ~KFCURVE_CONSTANT_ALL), "Wrong tangeant mode." );

    // Convert Auto to Time-Independent.
    if (! pIgnoreAutoTimeIndepedentConversion && KFCurve::sConvertAutoTimeIndepedent && (mFlags & KFCURVE_INTERPOLATION_CUBIC) && (pTangeant & KFCURVE_TANGEANT_AUTO))
    {
        pTangeant = pTangeant | KFCURVE_GENERIC_TIME_INDEPENDENT;
    }

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

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

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

KFBX_FCURVE_INLINE void KPriFCurveKeyAttr::SetTangeantWeightMode(kFCurveTangeantWeightMode pTangent, kFCurveTangeantWeightMode pMask /* KFCURVE_WEIGHTED_ALL */ )
{
    pMask &= KFCURVE_WEIGHTED_ALL;
    mFlags = (mFlags & ~pMask) | (pTangent & pMask); 
}

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 KPriFCurveKeyAttr::GetTangeantVelocityMode() const
{
    return mFlags & KFCURVE_VELOCITY_ALL;
}

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

KFBX_FCURVE_INLINE void KPriFCurveKeyAttr::SetTangentWeightAndAdjustTangent( EKFCurveDataIndex pIndex, kFCurveDouble pWeight ) 
{
#ifdef KFCURVE_FLOAT
    TangentWeightAndAdjustTangent(pIndex, pWeight, mData);
#else
    TangentWeightAndAdjustTangent(pIndex, pWeight, mData, mWeight);
#endif
}

KFBX_FCURVE_INLINE void KFCurveKey::SetTangentWeightAndAdjustTangent( EKFCurveDataIndex pIndex, kFCurveDouble pWeight ) 
{
#ifdef KFCURVE_FLOAT
    TangentWeightAndAdjustTangent(pIndex, pWeight, mData);
#else
    TangentWeightAndAdjustTangent(pIndex, pWeight, mData, mWeight);
#endif
}

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

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 KPriFCurveKeyAttr::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 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 KPriFCurveKeyAttr::GetTangeantVisibility ()  const
{
    return mFlags & KFCURVE_TANGEANT_SHOW_BOTH;
}

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

KFBX_FCURVE_INLINE kFCurveDouble KPriFCurveKeyAttr::GetDataDouble (EKFCurveDataIndex pIndex)  const
{
    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 kFCurveDouble KFCurveKey::GetDataDouble (EKFCurveDataIndex pIndex) const
{
    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 KPriFCurveKeyAttr::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 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 KPriFCurveKeyAttr::GetDataFloat (EKFCurveDataIndex pIndex)  const
{
    return ( (float *)&mData[0])[pIndex];
}

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

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

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

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

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

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

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


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

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

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

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

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

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

KFBX_FCURVE_INLINE KTime KPriFCurveKey::GetTime ()  const
{
    return mTime;
}

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

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

    mTime=pTime;
}

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 KPriFCurveKey::IncTime (KTime pTime) 
{
    mTime+=pTime;
}

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


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

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 KPriFCurveKeyAttr::GetSelected () const
{
    return (mFlags & KFCURVE_SELECT_POINT) ? true : false;
}

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

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

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 KPriFCurveKeyAttr::GetMarkedForManipulation () const
{
    return (mFlags & KFCURVE_MARKED_FOR_MANIP) ? true : false;
}

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

KFBX_FCURVE_INLINE void KPriFCurveKey::Init()
{
    mValue = 0.0;
    mTime = KTIME_ZERO;
    mAttr = NULL;
}

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

KFBX_FCURVE_INLINE void KPriFCurveKeyAttr::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 tangeant mode." );

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

} 

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 KPriFCurveKeyAttr::GetBreak() const
{
    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; 

}

KFBX_FCURVE_INLINE bool KFCurveKey::GetBreak() const
{
    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; 

}

KFBX_FCURVE_INLINE bool KPriFCurveKeyAttr::IsEqual(const KPriFCurveKeyAttr& pRsh) const
{
    // To Modify, don't need to check the data for some Flags. 
    return (this == &pRsh) ||
        mFlags == pRsh.mFlags &&
        mData[0] == pRsh.mData[0] &&
        mData[1] == pRsh.mData[1] &&
    #ifdef KFCURVE_FLOAT
        mData[2] == pRsh.mData[2] &&
        mData[3] == pRsh.mData[3];
    #else
        mWeight[0] == pRsh.mWeight[0] &&
        mWeight[1] == pRsh.mWeight[1] &&
        mVelocity[0] == pRsh.mVelocity[0] &&
        mVelocity[1] == pRsh.mVelocity[1];
    #endif
}

KFBX_FCURVE_INLINE void KPriFCurveKeyAttr::IncRefCount()
{
    ++mRefCount;
}

KFBX_FCURVE_INLINE void KPriFCurveKeyAttr::DecRefCount()
{
    --mRefCount;
}

KFBX_FCURVE_INLINE kUInt32 KPriFCurveKeyAttr::GetRefCount() const
{
    return mRefCount;
}
//****************************************************************************************
// 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 () const 
{
    return mPreExtrapolation;
}


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


KFBX_FCURVE_INLINE kULong KFCurve::GetPreExtrapolationCount ()  const
{
    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 () const 
{
    return mPostExtrapolation;
}


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


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

#ifndef DOXYGEN_SHOULD_SKIP_THIS
KFBX_FCURVE_INLINE KPriFCurveKey* KFCurve::InternalPriKeyGetPtr (int pIndex) const
{
    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);
}


KFBX_FCURVE_INLINE KPriFCurveKeyAttr* KFCurve::InternalPriKeyAttrGetPtr(kFCurveIndex pIndex) const
{
    #ifdef _DEBUG
        KPriFCurveKey* lKey = InternalPriKeyGetPtr(pIndex);
        K_ASSERT_MSG(lKey->mAttr != NULL, "Accessing uninitialized keyattr.");
        return lKey->mAttr;
    #else
        return InternalPriKeyGetPtr(pIndex)->mAttr;
    #endif
}
#endif // DOXYGEN_SHOULD_SKIP_THIS

/*********************************************************************************************/
/*********************************************************************************************/
/*********************************************************************************************/
/*********************************************************************************************/
KFBX_FCURVE_INLINE void KFCurve::KeySet 
    (
    kFCurveIndex pKeyIndex,
    KTime pTime, 
    kFCurveDouble pValue, 
    kFCurveInterpolation pInterpolation, 
    kFCurveTangeantMode pTangentMode, 
    kFCurveDouble pRightSlope, 
    kFCurveDouble pNextLeftSlope, 
    kFCurveTangeantWeightMode pTangentWeightMode, 
    kFCurveDouble pWeight0, 
    kFCurveDouble pWeight1, 
    kFCurveDouble pVelocity0, 
    kFCurveDouble pVelocity1
    )
{
    KPriFCurveKey *lPriKey = InternalPriKeyGetPtr(pKeyIndex);
    lPriKey->Set(pTime, pValue);
    KPriFCurveKeyAttr lKeyAttr;
    lKeyAttr.mFlags = 0;
    if (lPriKey->mAttr)
        lKeyAttr.mFlags = lPriKey->mAttr->mFlags;
    lKeyAttr.Set( pInterpolation, pTangentMode, pRightSlope, pNextLeftSlope, pTangentWeightMode, pWeight0, pWeight1, pVelocity0, pVelocity1);

    KeyAttrSet(pKeyIndex, lKeyAttr);
}

KFBX_FCURVE_INLINE void KFCurve::KeySetTCB 
    (
    kFCurveIndex pKeyIndex,
    KTime pTime, 
    kFCurveDouble pValue, 
    float pData0, 
    float pData1, 
    float pData2
    )
{
    InternalPriKeyGetPtr(pKeyIndex)->Set(pTime, pValue);
    KPriFCurveKeyAttr lKeyAttr;
    lKeyAttr.SetTCB(pData0, pData1, pData2);

    KeyAttrSet(pKeyIndex, lKeyAttr);
}

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

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

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

    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex);
    K_ASSERT(lKey->mAttr != NULL);
    if (lKey->mAttr)
    {
        if ( lKey->mAttr->GetInterpolation() != pInterpolation)
        {
            KeyAttrSeparateCheck(pKeyIndex);
            lKey->mAttr->SetInterpolation(pInterpolation);
            CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
        }
    }
}

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

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

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

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

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

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

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

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

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

    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex);
    K_ASSERT(lKey->mAttr != NULL);
    if (lKey->mAttr)
    {
        if (lKey->mAttr->GetConstantMode() != pMode)
        {
            KeyAttrSeparateCheck(pKeyIndex);
            lKey->mAttr->SetConstantMode(pMode);
            CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
        }
    }
}

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

    // Avoid call expensive CallbackAddEvent() and KeyAttrSeparate(). 
    // We need to test if the flag value will be really changed.
    // but there is not easy way to tell that change for this operation,
    // so we need to performance special "try and swap" technique.
    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex);
    K_ASSERT(lKey->mAttr != NULL);
    if (lKey->mAttr)
    {
        kUInt32 lFlags = lKey->mAttr->mFlags;
        lKey->mAttr->SetTangeantMode(pTangent, pIgnoreAutoTimeIndepedentConversion); //only affect mFlags

        if (lKey->mAttr->mFlags != lFlags)
        {
            if (lKey->mAttr->GetRefCount() > 1)
            {
                kUInt32 lSwapFlags = lKey->mAttr->mFlags;
                lKey->mAttr->mFlags = lFlags; //Restore previous attr flag for other keys.
                KeyAttrSeparate(pKeyIndex);
                lKey->mAttr->mFlags = lSwapFlags;
            }
            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());

    // Avoid call expensive CallbackAddEvent() and KeyAttrSeparate(). 
    // We need to test if the flag value will be really changed.
    // but there is not easy way to tell that change for this operation,
    // so we need to performance special "try and swap" technique.
    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex);
    K_ASSERT(lKey->mAttr != NULL);
    if (lKey->mAttr)
    {
        kUInt32 lFlags = lKey->mAttr->mFlags;
        lKey->mAttr->SetTangeantWeightMode(pTangentWeightMode, pMask); //only affect mFlags
        if (lKey->mAttr->mFlags != lFlags)
        {
           if (lKey->mAttr->GetRefCount() > 1)
           {
              kUInt32 lSwapFlags = lKey->mAttr->mFlags;
              lKey->mAttr->mFlags = lFlags; //Restore previous attr flag for other keys.
              KeyAttrSeparate(pKeyIndex);
              lKey->mAttr->mFlags = lSwapFlags;
           }
            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());

    // Avoid call expensive CallbackAddEvent() and KeyAttrSeparate(). 
    // We need to test if the flag value will be really changed.
    // but there is not easy way to tell that change for this operation,
    // so we need to performance special "try and swap" technique.
    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex);
    K_ASSERT(lKey->mAttr != NULL);
    if (lKey->mAttr)
    {
        kUInt32 lFlags = lKey->mAttr->mFlags;
        lKey->mAttr->SetTangeantVelocityMode(pTangentVelocityMode, pMask); //only affect mFlags
        if (lKey->mAttr->mFlags != lFlags)
        {
           if (lKey->mAttr->GetRefCount() > 1)
           {
              kUInt32 lSwapFlags = lKey->mAttr->mFlags;
              lKey->mAttr->mFlags = lFlags; //Restore previous attr flag for other keys.
              KeyAttrSeparate(pKeyIndex);
              lKey->mAttr->mFlags = lSwapFlags;
           }
            CallbackAddEvent (KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
        }
    }
}

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

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

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

    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex);
    K_ASSERT(lKey->mAttr != NULL);
    if (lKey->mAttr)
    {
        if (lKey->mAttr->GetDataDouble(pIndex) != pValue)
        {
            KeyAttrSeparateCheck(pKeyIndex);
            lKey->mAttr->SetDataDouble(pIndex, pValue);
            CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
        }
    }
}

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

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

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

    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex);
    K_ASSERT(lKey->mAttr != NULL);
    if (lKey->mAttr)
    {
        if (lKey->mAttr->GetDataFloat(pIndex) != pValue)
        {
            KeyAttrSeparateCheck(pKeyIndex);
            lKey->mAttr->SetDataFloat(pIndex, pValue);
            CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
        }
    }
}

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

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

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

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

KFBX_FCURVE_INLINE void KFCurve::KeySetValue(kFCurveIndex pKeyIndex, kFCurveDouble pValue)
{
    InternalPriKeyGetPtr(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());

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

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

    if (pValue == 1.0)
    {
       return;
    }
    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex); K_ASSERT(lKey->mAttr != NULL);
    KPriFCurveKey* lKeyNext = NULL;
    if (pKeyIndex < KeyGetCount()-1)
    {
        lKeyNext = InternalPriKeyGetPtr(pKeyIndex+1); 
        K_ASSERT(lKeyNext->mAttr != NULL);
    }

    if (lKey->mAttr)
    {
        if (lKey->mAttr->GetInterpolation() == KFCURVE_INTERPOLATION_CUBIC)
        {
            bool lScaleNextLeft = false;
            switch (lKey->mAttr->GetTangeantMode())
            {                   
            case KFCURVE_TANGEANT_USER:
            case KFCURVE_TANGEANT_BREAK:
                lScaleNextLeft = true;
                KeyAttrSeparateCheck(pKeyIndex);                        
                lKey->mAttr->SetDataDouble(KFCURVEKEY_RIGHT_SLOPE, lKey->mAttr->GetDataDouble(KFCURVEKEY_RIGHT_SLOPE) * pValue);

            case KFCURVE_TANGEANT_AUTO:
            case KFCURVE_TANGEANT_AUTO_BREAK:
                if (lKeyNext)
                {
                    switch (lKeyNext->mAttr->GetTangeantMode())
                    {
                    case KFCURVE_TANGEANT_USER:
                    case KFCURVE_TANGEANT_BREAK:                    
                        lScaleNextLeft = true;
                    }
                }

                if (lScaleNextLeft)
                {
                    lKey->mAttr->SetDataDouble(KFCURVEKEY_NEXT_LEFT_SLOPE, lKey->mAttr->GetDataDouble(KFCURVEKEY_NEXT_LEFT_SLOPE) * pValue);
                    CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
                }
                break;

            case KFCURVE_TANGEANT_TCB:
                // dunno how to handle this
            default:
                // nothing to do
                break;
            }
        }
    }
}

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

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

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

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

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

    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex);
    K_ASSERT(lKey->mAttr != NULL);
    if (lKey->mAttr)
    {
        if (lKey->mAttr->GetSelected() != pSelected)
        {
            KeyAttrSeparateCheck(pKeyIndex);
            lKey->mAttr->SetSelected(pSelected);
            CallbackAddEvent(KFCURVEEVENT_SELECTION, pKeyIndex);
        }
    }
}

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

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

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

    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex);
    K_ASSERT(lKey->mAttr != NULL);
    if (lKey->mAttr)
    {
        if (lKey->mAttr->GetMarkedForManipulation() != pMarked)
        {
            KeyAttrSeparateCheck(pKeyIndex);
            lKey->mAttr->SetMarkedForManipulation(pMarked);
        }
    }
}

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

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

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

    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex);  
    K_ASSERT(lKey->mAttr != NULL);
    if (lKey->mAttr)
    {
        if (lKey->mAttr->GetTangeantVisibility() != pVisibility)
        {
            KeyAttrSeparateCheck(pKeyIndex);
            lKey->mAttr->SetTangeantVisibility(pVisibility);
            CallbackAddEvent(KFCURVEEVENT_SELECTION, pKeyIndex);
        }
    }
}

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

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

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

    KPriFCurveKey* lKey = InternalPriKeyGetPtr(pKeyIndex);
    K_ASSERT(lKey->mAttr != NULL);
    if (lKey->mAttr)
    {   
        if (lKey->mAttr->GetBreak() != pVal)
        {
            KeyAttrSeparateCheck(pKeyIndex);
            lKey->mAttr->SetBreak(pVal);
            CallbackAddEvent(KFCURVEEVENT_KEY | KFCURVEEVENT_EDITOTHER, pKeyIndex);
        }
    }
}

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

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

KFBX_FCURVE_INLINE void KFCurve::KeyAttrSeparateCheck(kFCurveIndex pKeyIndex)
{
    KPriFCurveKeyAttr* lCurKeyAttr = InternalPriKeyAttrGetPtr(pKeyIndex);
    if (! lCurKeyAttr || lCurKeyAttr->GetRefCount() > 1 )
        KeyAttrSeparate(pKeyIndex);
}


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