fbdata.h

Go to the documentation of this file.

#ifndef __FBDATA_H__
#define __FBDATA_H__
/**************************************************************************
Copyright (c) 1994 - 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 <kaydaradef.h>
#ifndef FBSDK_DLL

    #define FBSDK_DLL K_DLLIMPORT
#endif

#include <fbsdk/fbcomponent.h>

// Basic types
#define ANIMATIONNODE_TYPE_NUMBER               "Number"
#define ANIMATIONNODE_TYPE_TIME                 "Time"
#define ANIMATIONNODE_TYPE_TIMECODE             "TimeCode"
#define ANIMATIONNODE_TYPE_VECTOR               "Vector"
#define ANIMATIONNODE_TYPE_VECTOR_4             "Vector4"
#define ANIMATIONNODE_TYPE_OBJECT               "Object"
#define ANIMATIONNODE_TYPE_REFERENCE            "Reference"
#define ANIMATIONNODE_TYPE_EVENT                "Event"
#define ANIMATIONNODE_TYPE_STRING               "String"

// Types which are numbers
#define ANIMATIONNODE_TYPE_ACTION               "Action"
#define ANIMATIONNODE_TYPE_BOOL                 "Bool"
#define ANIMATIONNODE_TYPE_ENUM                 "Enum"
#define ANIMATIONNODE_TYPE_INTEGER              "Integer"
#define ANIMATIONNODE_TYPE_OCCLUSION            "Occlusion"
#define ANIMATIONNODE_TYPE_FIELDOFVIEWX         "FieldOfViewX"
#define ANIMATIONNODE_TYPE_FIELDOFVIEWY         "FieldOfViewY"
#define ANIMATIONNODE_TYPE_OPTICALCENTERX       "OpticalCenterX"
#define ANIMATIONNODE_TYPE_OPTICALCENTERY       "OpticalCenterY"
#define ANIMATIONNODE_TYPE_IKREACHTRANSLATION   "IK Reach Translation"
#define ANIMATIONNODE_TYPE_IKREACHROTATION      "IK Reach Rotation"

// Types which are vectors (3 members)
#define ANIMATIONNODE_TYPE_COLOR                "Color"
#define ANIMATIONNODE_TYPE_LOCAL_TRANSLATION    "Lcl Translation"
#define ANIMATIONNODE_TYPE_LOCAL_ROTATION       "Lcl Rotation"
#define ANIMATIONNODE_TYPE_LOCAL_SCALING        "Lcl Scaling"
#define ANIMATIONNODE_TYPE_TRANSLATION          "Translation"
#define ANIMATIONNODE_TYPE_ROTATION             "Rotation"
#define ANIMATIONNODE_TYPE_SCALING              "Scaling"

// Types which are vectors (4 members)
#define ANIMATIONNODE_TYPE_COLOR_RGBA           "ColorAndAlpha"


class KFCurve;

#ifdef FBSDKUseNamespace
namespace FBSDKNamespace {
#endif

    FB_FORWARD( FBEvaluateInfo );
    FB_FORWARD( FBPlotOptions );

    enum FBInterpolation    {   
        kFBInterpolationInvalid  = -1,  
        kFBInterpolationConstant = 0,   
        kFBInterpolationLinear,         
        kFBInterpolationCubic,          
        kFBInterpolationCount           
    };
    FB_DEFINE_ENUM( FBSDK_DLL, Interpolation ); 

    enum FBInterpolatorCurveType {
        kFBInterpolatorCurveLinearIn, 
        kFBInterpolatorCurveLinearOut, 
        kFBInterpolatorCurveSmoothIn, 
        kFBInterpolatorCurveSmoothOut, 
        kFBInterpolatorCurveSlowIn, 
        kFBInterpolatorCurveSlowOut, 
        kFBInterpolatorCurveFastIn, 
        kFBInterpolatorCurveFastOut, 
        kFBInterpolatorCurveLast 
    };

    enum FBTangentMode  {
        kFBTangentModeAuto,             
        kFBTangentModeTCB,              
        kFBTangentModeUser,             
        kFBTangentModeBreak,            
        kFBTangentModeTimeIndependent,  
        kFBTangentModeClampProgressive  
    };
    FB_DEFINE_ENUM( FBSDK_DLL, TangentMode );

    enum FBTangentClampMode {
        kFBTangentClampModeNone,    
        kFBTangentClampModeClamped  
        //Add other clamping methods here...
    };
    FB_DEFINE_ENUM( FBSDK_DLL, TangentClampMode );

    enum FBTangentConstantMode {
        kFBTangentConstantModeNormal,   
        kFBTangentConstantModeNext      
    };
    FB_DEFINE_ENUM( FBSDK_DLL, TangentConstantMode );

    enum FBExtrapolationMode {
        kFCurveExtrapolationConst = 1,
        kFCurveExtrapolationRepetition = 2,
        kFCurveExtrapolationMirrorRepetition = 3,
        kFCurveExtrapolationKeepSlope = 4,
        kFCurveExtrapolationRelativeRepetition = 5
    };
    FB_DEFINE_ENUM( FBSDK_DLL, ExtrapolationMode );

    enum FBAnimationNodeConnectorType {
        kFBAnimationNodeConnectorTypeNone,          
        kFBAnimationNodeConnectorTypeConnectedIn,   
        kFBAnimationNodeConnectorTypeConnectedOut,  
        kFBAnimationNodeConnectorTypeConstantIn,    
    };
    FB_DEFINE_ENUM( FBSDK_DLL, AnimationNodeConnectorType );

    // FBFCurveKey
    FB_FORWARD( FBFCurve );
    __FB_FORWARD( FBFCurveKey );
    FB_FORWARD( FBPropertyListFCurveKey );

    class FBSDK_DLL FBFCurveKey
    {
    private:
        DataFBFCurveKey* mLocalPtr;
        void FBFCurveKeyInitProperties();
        void PropertyAdd( FBProperty* ) {};
    public:
        FBFCurveKey( ::KFCurve* pFCurve=NULL, int pKeyIndex=1 );

        FBFCurveKey( const FBFCurveKey &pFCurveKey );

        ~FBFCurveKey();

        bool operator==(const FBFCurveKey &pValue) const;

        // To convert the derivative values to degrees (as shown in Exact mode):
        //    degrees( atan( RightDerivative ))
        //    -1 * degrees( atan( LeftDerivative )) 
        //
        // To convert from the exact degree in Exact mode in the GUI to the corresponding
        // derivative:
        //    tan( radians( RightDerivative ))
        //    tan( radians( -1 * LeftDerivative ))
        FBPropertyFloat Value;              
        FBPropertyFloat LeftDerivative;     
        FBPropertyFloat RightDerivative;    
        FBPropertyFloat LeftTangentWeight;  
        FBPropertyFloat RightTangentWeight; 
        FBPropertyFloat LeftBezierTangent;  
        FBPropertyFloat RightBezierTangent; 

        // TCB
        FBPropertyFloat Tension;            
        FBPropertyFloat Continuity;         
        FBPropertyFloat Bias;               

        FBPropertyTime  Time;                   
        FBPropertyInterpolation Interpolation;  
        FBPropertyTangentMode   TangentMode;    
        FBPropertyTangentClampMode      TangentClampMode;   
        FBPropertyBool  TangentBreak;           
        FBPropertyTangentConstantMode   TangentConstantMode;    
        FBPropertyExtrapolationMode ExtrapolationMode;  

        FBPropertyBool  Selected;               
        FBPropertyBool  MarkedForManipulation;  

        friend class FBFCurve;
        friend class FBPropertyListFCurveKey;
    };

    // FBPropertyListFCurveKey
    FB_FORWARD( FBFCurveKey );

    class FBSDK_DLL FBPropertyListFCurveKey : public FBPropertyBaseList< FBFCurveKey >
    {
    private:
        virtual int  Add    ( FBFCurveKey pItem );

        virtual int  Remove ( FBFCurveKey pItem );

    public:

        virtual void RemoveAt( int pIndex );

        virtual FBFCurveKey operator[](int pIndex);

        virtual int  GetCount();
    };

    // FBFCurve
    __FB_FORWARD( FBFCurve);

    class FBSDK_DLL FBFCurve : public FBComponent {
        __FBClassDeclare( FBFCurve,FBComponent );
    public:
        FBFCurve(HIObject pObject=NULL);

        virtual void FBDelete() override;

        float   Evaluate(FBTime &pTime);

        void    EditBegin(int pKeyCount=-1);

        void    EditEnd(int pKeyCount=-1);

        void    EditClear();

        int KeyAdd( FBTime &pTime, double pValue, FBInterpolation pInterpolation=kFBInterpolationCubic, FBTangentMode pTangentMode=kFBTangentModeAuto );

        bool KeyRemove( int pIndex );

        bool KeyDelete(int pStartIndex , int pStopIndex);   

        bool KeyDelete(FBTime pStart = FBTime::MinusInfinity, FBTime pStop = FBTime::Infinity, bool pInclusive = false);

        void KeyInsert( FBTime &pTime, FBInterpolation pInterpolation = kFBInterpolationCubic, FBTangentMode pTangentMode = kFBTangentModeAuto );

        void KeyReplaceBy( FBFCurve& pSource, FBTime pStart = FBTime::MinusInfinity, FBTime pStop = FBTime::Infinity, bool pUseExactGivenSpan = false, bool pKeyStartEndOnNoKey = true );

        K_DEPRECATED_2014 void Replace( FBFCurve& pSource, FBTime pStart = FBTime::MinusInfinity, FBTime pStop = FBTime::Infinity, bool pUseExactGivenSpan = false, bool pKeyStartEndOnNoKey = true );

        static FBFCurve* CreateInterpolatorCurve( FBInterpolatorCurveType pCurveType );

        FBExtrapolationMode GetPostExtrapolationMode();

        void SetPostExtrapolationMode(FBExtrapolationMode pExtrapolationMode);

        long GetPostExtrapolationCount();

        void SetPostExtrapolationCount(int pCount);

        FBExtrapolationMode GetPreExtrapolationMode();

        void SetPreExtrapolationMode(FBExtrapolationMode pExtrapolationMode);

        long GetPreExtrapolationCount();

        void SetPreExtrapolationCount(int pCount);

        FBPropertyListFCurveKey GetKeys(){ return Keys; };
        void SetKeys(FBPropertyListFCurveKey pKeys){ Keys = pKeys; };
        FBPropertyListFCurveKey Keys;       
    };

    FB_DEFINE_COMPONENT( FBSDK_DLL, FCurve );

    // FBPropertyListAnimationNode
    __FB_FORWARD( FBAnimationNode);
    __FB_FORWARD( FBPropertyListAnimationNode);
    FB_DEFINE_LIST( FBSDK_DLL, AnimationNode );

    class FBSDK_DLL FBPropertyListAnimationNode : public FBPropertyBaseList< FBAnimationNode* >
    {
    public:
        virtual int  Add    ( FBAnimationNode* pItem );
        virtual int  Remove ( FBAnimationNode* pItem );
        virtual void RemoveAt( int pIndex );
        virtual FBAnimationNode* operator[](int pIndex);
        virtual int  GetCount();
        FBAnimationNode* Find( FBBox *pOriginalOwner, const char* pDataType );
        FBAnimationNode* Find( const char* pNodeName );
        FBAnimationNode* FindByLabel( const char* pNodeLabel );
    };

    // FBEventAnimationNode

    enum FBEventAnimationNodeType {
        kFBEventAnimationNodeDataChange,
        kFBEventAnimationNodeConstraintChange,
        kFBEventAnimationNodeNone
    };

    FB_DEFINE_ENUM( FBSDK_DLL, EventAnimationNodeType );

    __FB_FORWARD( FBEventAnimationNode );

    class FBSDK_DLL FBEventAnimationNode: public FBEvent
    {
    public:
        FBEventAnimationNode( HKEventBase pEvent );     

        FBPropertyEventAnimationNodeType        Type;   
    };

    // FBPropertyEventAnimationNode
    class FBSDK_DLL FBPropertyEventAnimationNode : public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };
    typedef bool (* kFBDataHandler )(void* pBuffer,FBEvaluateInfo* pEvaluateInfo,FBAnimationNode* pAnimationNode,void* p1,void* p2);

    // FBAnimationNode
    FB_DEFINE_COMPONENT( FBSDK_DLL, AnimationNode );

    class FBSDK_DLL FBAnimationNode : public FBComponent
    {
        __FBClassDeclare( FBAnimationNode,FBComponent );
    public:
        FBAnimationNode(const char *pName = NULL, HIObject pObject=NULL);

        void KeyAdd( const FBTime &pTime, double *pData, FBInterpolation pInterpolation=kFBInterpolationCubic, FBTangentMode pTangentMode=kFBTangentModeAuto );

        void KeyAdd( double *pData, FBInterpolation pInterpolation=kFBInterpolationCubic, FBTangentMode pTangentMode=kFBTangentModeAuto );

        bool SetCandidate( double* Data, bool pCheckLocked = false );

        void SetBufferType( bool pGlobal );

        void KeyCandidate( FBTime pTime = FBTime::Infinity );

        int GetSizeOfData();

        int GetDataDoubleArrayCount();

        bool WriteData( double* Data,FBEvaluateInfo* pEvaluateInfo );

        bool WriteGlobalData( double* Data,FBEvaluateInfo* pEvaluateInfo );

        bool ReadData( double* Data,FBEvaluateInfo* pEvaluateInfo, bool pConvertGlobalToLocal = false );

        bool ReadData( double *Data, FBTime pTime, bool pConvertGlobalToLocal = false );

        bool ReadData( double* Data );

        bool Evaluate( double* Data, FBTime pTime, bool pEvaluateCandidate = true );

        bool IsEvaluationRecursive( FBEvaluateInfo* pEvaluateInfo );

        void DisableIfNotWritten( FBEvaluateInfo* pEvaluateInfo );

        bool IsKey();

        void KeyRemove();

        void KeyRemoveAt( FBTime pTime );

        FBAnimationNode* GetAnimationToRecord();

        FBAnimationNode* GetAnimationToPlay();

        FBTime ConvertGlobalToNodeTime(FBTime& pKeyTime);

        FBTime ConvertNodeToGlobalTime(FBTime& pKeyTime);

        FBPropertyString            Label;          
        FBPropertyString            UserName;       
        FBPropertykReference        Reference;      
        FBPropertyInt               KeyCount;       
        FBPropertyFCurve            FCurve;         
        FBPropertyBool              Live;           
        FBPropertyBool              RecordMode;     
        FBPropertyAnimationNode     Parent;         
        FBPropertyInterpolation     DefaultInterpolation;   
        FBPropertyAnimationNodeConnectorType        ConnectorType;  

        FBPropertyListAnimationNode Nodes;          

        FBPropertyEventAnimationNode    OnChange;       

        friend class FBBox;
    };

    // FBAnimationLayer

    enum FBLayerMode    {
        kFBLayerModeInvalidIndex = -1,  
        kFBLayerModeAdditive = 0,       
        kFBLayerModeOverride,           
        kFBLayerModeOverridePassthrough 
    };
    FB_DEFINE_ENUM( FBSDK_DLL, LayerMode );

    enum FBLayerRotationMode    {
        kFBLayerRotationModeInvalidIndex = -1,      
        kFBLayerRotationModeEulerRotation = 0,  
        kFBLayerRotationModeQuaternionRotation  
    };
    FB_DEFINE_ENUM( FBSDK_DLL, LayerRotationMode );


    __FB_FORWARD( FBAnimationLayer );

    class FBSDK_DLL FBAnimationLayer : public FBComponent
    {
        //--- Open Reality declaration.
        __FBClassDeclare(FBAnimationLayer, FBComponent);
    public:

        FBAnimationLayer(const char *pName, int pLayerID, HIObject pObject=NULL);

        virtual void FBDelete();

        FBPropertyBool              Solo;               
        FBPropertyBool              Mute;               
        FBPropertyBool              Lock;               
        FBPropertyAnimatableDouble  Weight;             
        FBPropertyLayerMode         LayerMode;          
        FBPropertyLayerRotationMode LayerRotationMode;  

        void    AddChildLayer( FBAnimationLayer* pAnimationLayer );

        FBAnimationLayer*   GetChildLayer( int pIndex );

        int     GetChildCount();

        void    GetCompleteChildHierarchy(FBArrayTemplate<FBAnimationLayer*>* pChildArray);

        void SetParentLayer(FBAnimationLayer* pParentLayer);

        FBAnimationLayer*   GetParentLayer();

        int GetLayerIndex();

        void SelectLayer(bool pValue, bool pExclusiveSelect);

        bool IsSelected();
    };


    __FB_FORWARD( FBTake);
    // FBPropertyListTake

    class FBSDK_DLL FBPropertyListTake : public FBPropertyListComponent
    {
    public:
        FBPropertyListTake();
        FBTake* operator[](int pIndex);

        virtual int Add( FBComponent* pItem ) override;

        virtual void RemoveAt( int pIndex ) override;
    };

    enum FBAnimationLayerMergeOptions   {   
        kFBAnimLayerMerge_SelectedLayers_SelectedProperties,
        kFBAnimLayerMerge_AllLayers_SelectedProperties,     
        kFBAnimLayerMerge_SelectedLayers_AllProperties,     
        kFBAnimLayerMerge_AllLayers_AllProperties,          
        kFBAnimLayerMerge_SelectedLayers_CompleteScene,     
        kFBAnimLayerMerge_AllLayers_CompleteScene,          
    };

    K_DEPRECATED_2014 static const FBAnimationLayerMergeOptions kFBAnimLayerMerge_SelectedLayer_CompleteScene = kFBAnimLayerMerge_SelectedLayers_CompleteScene; 

    enum FBMergeLayerMode   {   
        kFBMergeLayerModeAutomatic, 
        kFBMergeLayerModeAdditive,  
        kFBMergeLayerModeOverride,  
    };

enum FBTimeMarkAction
{
    kFBTimeMarkAction_None,         
    kFBTimeMarkAction_Stop,         
    kFBTimeMarkAction_Loop,         
};

    // FBTake

    class FBSDK_DLL FBTake : public FBComponent {
        __FBClassDeclare( FBTake,FBComponent );
    public:
        FBTake(const char* pName, HIObject pObject=NULL);

        virtual void FBDelete();

        FBTake* CopyTake( const char *pNewTakeName );

        void CreateNewLayer();    

        void RemoveLayer(int pLayerIndex);  

        FBAnimationLayer* GetLayer(int pLayerIndex);  

        FBAnimationLayer* GetLayerByName(const char* pName);  

        void SetCurrentLayer(int pLayerIndex);

        int GetCurrentLayer();

        int GetLayerCount();

        bool MoveCurrentLayerUp();

        bool MoveCurrentLayerDown();

        void DuplicateSelectedLayers();

        void MergeLayers(FBAnimationLayerMergeOptions pMergeOptions, bool pDeleteMergedLayers, FBMergeLayerMode pMergeMode, bool pMergeLockedProperties = false);

// COMMENT MERGE PREIVEW
#ifdef MERGE_PREVIEW

        bool CanDoMergePreview();

        bool IsInMergePreviewMode();

        bool DoMergePreview();

        void QuitMergePreview();
#endif

        void PlotTakeOnSelected(FBPlotOptions* pPlotOptions);

        void PlotTakeOnSelectedProperties(FBPlotOptions* pPlotOptions);

        void PlotTakeOnSelected(FBTime pPlotPeriod);

        void PlotAllTakesOnSelected(FBTime pPlotPeriod);

        void PlotTakeOnSelectedProperties(FBTime pPlotPeriod);

        void PlotAllTakesOnSelectedProperties(FBTime pPlotPeriod);

        void ClearAllProperties(bool pOnSelectedObjectsOnly, bool pOnLockedProperties = false);

        void ClearAllPropertiesOnCurrentLayer();

        FBPropertyTimeSpan  ReferenceTimeSpan;      
        FBPropertyTimeSpan  LocalTimeSpan;          
        FBPropertyString    Comments;               

        void PlotTakeOnObjects( FBPlotOptions* pPlotOptions, FBArrayTemplate<FBBox *> *pObjectsToPlot );

        void PlotTakeOnObjects( FBTime pPlotPeriod, FBArrayTemplate<FBBox *> *pObjectsToPlot );

        void PlotAllTakesOnObjects( FBTime pPlotPeriod, FBArrayTemplate<FBBox *> *pObjectsToPlot );

        void PlotTakeOnProperties( FBTime pPlotPeriod, FBArrayTemplate<FBProperty *> *pPropertiesToPlot );

        void PlotAllTakesOnProperties( FBTime pPlotPeriod, FBArrayTemplate<FBProperty *> *pPropertiesToPlot );


        int AddTimeMark( FBTime pTime, const char* pName = NULL );

        bool DeleteTimeMark( int pIndex );

        void DeleteAllTimeMarks();

        int GetTimeMarkCount();

        FBTime GetTimeMarkTime( int pIndex );

        int SetTimeMarkTime( int pIndex, FBTime pTime );

        const char* GetTimeMarkName( int pIndex );

        bool SetTimeMarkName( int pIndex, const char* pName );

        FBTimeMarkAction GetTimeMarkAction( int pIndex );

        bool SetTimeMarkAction( int pIndex, FBTimeMarkAction pAction );

        FBColor GetTimeMarkColor( int pIndex );

        bool SetTimeMarkColor( int pIndex, FBColor pColor );

        void SetLayerRealSelection(bool pValue);

        bool GetLayerRealSelection();

        int GetNextTimeMarkIndex();

        int GetPreviousTimeMarkIndex();
    };

    FB_DEFINE_COMPONENT( FBSDK_DLL, Take );

    // FBTimeWarpManager
    __FB_FORWARD( FBTimeWarpManager );

    class FBSDK_DLL FBTimeWarpManager : public FBComponent
    {
        __FBClassDeclare(FBTimeWarpManager, FBComponent);

    public:
        typedef void (*TimeWarpChangeCallback)(void* pObject);

        FBTimeWarpManager();


        void TimeWarpTakeChange();

        void TimeWarpClearTake(FBTake* pTake);

        void TimeWarpInitTake(FBTake* pTake);

        void TimeWarpCopyTake(FBTake* pDstTake, FBTake* pSrcTake );


        void TimeWarpAddToTake(FBTake* pTake, FBAnimationNode* pTimeWarp, int pNickNumber=0);

        void DestroyTimeWarpFromTake(FBTake* pTake, FBAnimationNode* pTimeWarp);

        void RemoveTimeWarpFromScene(FBAnimationNode* pTimeWarp);


        kLong GetTimeWarpCount(FBTake* pTake);

        FBAnimationNode* GetTimeWarpAtIndex(FBTake* pTake, kLong pIndex);


        int GetTimeWarpNickNumber(FBTake* pTake, FBAnimationNode* pTimeWarp);

        bool SetTimeWarpNickNumber(FBTake* pTake, FBAnimationNode* pTimeWarp, int pNumber);

        int GetTimeWarpNickNumberAtIndex(FBTake* pTake, kLong pIndex);

        FBAnimationNode* GetTimeWarpFromNickNumber(FBTake* pTake, int pNumber);

        int FindTimeWarpNickNumberGlobal(FBAnimationNode* pTimeWarp);


        bool ApplyTimeWarp(FBTake* pTake, FBProperty* pEvalProp, FBAnimationNode* pTimeWarp);

        void RemoveTimeWarp(FBTake* pTake, FBProperty* pEvalProp );


        void TimeWarpRegisterChangeEvent(TimeWarpChangeCallback pCallback, void* pObject);

        void TimeWarpUnregisterChangeEvent(TimeWarpChangeCallback pCallback, void* pObject);


        FBAnimationNode* TimeWarpCreateNew( const char* pName );


        void TimeWarpRename( FBTake* pTake, FBAnimationNode* pTimeWarp, const char* pNewName );

        void TimeWarpMergeCurveNode( FBTake* pTake,FBProperty* pEvalProp, FBAnimationNode*  pNode, FBAnimationNode*  pTimeWarpNode );

        static FBTimeWarpManager& TheOne();
    };

#ifdef FBSDKUseNamespace
}
#endif

#endif