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>
 
#include <fbxsdk/fbxsdk_nsbegin.h>
    class FbxAnimCurveNode;
    class FbxScene;
    class FbxAnimStack;
    class FbxProperty;
    class FbxObject;
#include <fbxsdk/fbxsdk_nsend.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;
 
#include <fbxsdk/fbxsdk_nsbegin.h>
    class FbxAnimCurve;
#include <fbxsdk/fbxsdk_nsend.h>
 
#ifdef FBSDKUseNamespace
namespace FBSDKNamespace {
#endif
 
    FB_FORWARD( FBEvaluateInfo );
    FB_FORWARD( FBPlotOptions );
 
    enum FBInterpolation    {   
        kFBInterpolationInvalid  = -1,  
        kFBInterpolationConstant = 0,   
        kFBInterpolationLinear,         
        kFBInterpolationCubic,          
        kFBInterpolationCustom,         
        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 );
 
    enum FBTangentCustomIndex {
        kFBTangentCustomIndex0,     
        kFBTangentCustomIndex1,     
        kFBTangentCustomIndex2,     
    };
    FB_DEFINE_ENUM( FBSDK_DLL, TangentCustomIndex );
 
    enum FBTangentWeightMode {
        kFBTangentWeightModeNone,       
        kFBTangentWeightModeRight,      
        kFBTangentWeightModeNextLeft,   
        kFBTangentWeightModeBoth        
    };
    FB_DEFINE_ENUM( FBSDK_DLL, TangentWeightMode );
 
    // 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;    
        FBPropertyTangentWeightMode     TangentWeightMode;      
        FBPropertyExtrapolationMode     ExtrapolationMode;      
        FBPropertyTangentCustomIndex    TangentCustomIndex;     
 
        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 KeysAdd( const FBArrayTemplate<FBTime>&            pTimes,
                      const FBArrayDouble&                      pValues,
                      const FBArrayTemplate<FBInterpolation>&   pInterpolations = FBArrayTemplate<FBInterpolation>(),
                      const FBArrayTemplate<FBTangentMode>&     pTangentModes = FBArrayTemplate<FBTangentMode>() );
 
        bool KeysSetValues( const FBArrayUInt&                      pIndices,
                            const FBArrayDouble&                    pValues,
                            const FBArrayTemplate<FBInterpolation>& pInterpolations = FBArrayTemplate<FBInterpolation>(),
                            const FBArrayTemplate<FBTangentMode>&   pTangentModes = FBArrayTemplate<FBTangentMode>() );
 
        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 );
 
        bool KeyOffset(
            FBTime& pOffsetTime,
            int     pStartIndex,
            int     pStopIndex );
 
        bool KeyOffset(
            FBTime& pOffsetTime,
            FBTime  pStartTime = FBTime::MinusInfinity,
            FBTime  pStopTime = FBTime::Infinity,
            bool    pInclusive = true );
 
        static FBFCurve* CreateInterpolatorCurve( FBInterpolatorCurveType pCurveType );
 
        FBExtrapolationMode GetPostExtrapolationMode();
 
        void SetPostExtrapolationMode(FBExtrapolationMode pExtrapolationMode);
 
        int GetPostExtrapolationCount();
 
        void SetPostExtrapolationCount(int pCount);
 
        FBExtrapolationMode GetPreExtrapolationMode();
 
        void SetPreExtrapolationMode(FBExtrapolationMode pExtrapolationMode);
 
        int GetPreExtrapolationCount();
 
        void SetPreExtrapolationCount(int pCount);
 
        FBPropertyListFCurveKey GetKeys(){ return Keys; };
        void SetKeys(FBPropertyListFCurveKey pKeys){ Keys = pKeys; };
        FBPropertyListFCurveKey Keys;       
        
        float KeyGetValue(int pIndex);
 
        void KeySetValue(int pIndex, float pValue);
 
        float KeyGetLeftDerivative(int pIndex);
 
        void KeySetLeftDerivative(int pIndex, float pValue);
 
        float KeyGetRightDerivative(int pIndex);
 
        void KeySetRightDerivative(int pIndex, float pValue);
 
        float KeyGetLeftTangentWeight(int pIndex);
 
        void KeySetLeftTangentWeight(int pIndex, float pValue);
 
        float KeyGetRightTangentWeight(int pIndex);
 
        void KeySetRightTangentWeight(int pIndex, float pValue);
 
        float KeyGetLeftBezierTangent(int pIndex);
 
        void KeySetLeftBezierTangent(int pIndex, float pValue);
 
        float KeyGetRightBezierTangent(int pIndex);
 
        void KeySetRightBezierTangent(int pIndex, float pValue);
 
        float KeyGetTCBTension(int pIndex);
 
        void KeySetTCBTension(int pIndex, float pValue);
 
        float KeyGetTCBContinuity(int pIndex);
 
        void KeySetTCBContinuity(int pIndex, float pValue);
 
        float KeyGetTCBBias(int pIndex);
 
        void KeySetTCBBias(int pIndex, float pValue);
 
        FBTime KeyGetTime(int pIndex);
    
        void KeySetTime(int pIndex, FBTime pValue);
 
        FBInterpolation KeyGetInterpolation(int pIndex);
 
        void KeySetInterpolation(int pIndex, FBInterpolation pValue);
 
        FBTangentMode KeyGetTangentMode(int pIndex);
 
        void KeySetTangentMode(int pIndex, FBTangentMode pValue);
 
        FBTangentClampMode KeyGetTangentClampMode(int pIndex);
 
        void KeySetTangentClampMode(int pIndex, FBTangentClampMode pValue);
 
        bool KeyGetTangentBreak(int pIndex);
 
        void KeySetTangentBreak(int pIndex, bool pValue);
 
        FBTangentConstantMode KeyGetTangentConstantMode(int pIndex);
 
        void KeySetTangentConstantMode(int pIndex, FBTangentConstantMode pValue);
 
        FBTangentCustomIndex KeyGetTangentCustomIndex(int pIndex);
 
        void KeySetTangentCustomIndex(int pIndex, FBTangentCustomIndex pValue);
 
        FBTangentWeightMode KeyGetTangentWeightMode(int pIndex);
 
        void KeySetTangentWeightMode(int pIndex, FBTangentWeightMode pValue);
 
        bool KeyGetSelected(int pIndex);
 
        bool KeySetSelected(int pIndex, bool pValue);
 
        bool KeyGetMarkedForManipulation(int pIndex);
 
        bool KeySetMarkedForManipulation(int pIndex, bool pValue);
    };
 
    FB_DEFINE_COMPONENT( FBSDK_DLL, FCurve );
 
    // FBFCurveCustomTangent
    __FB_FORWARD( FBFCurveCustomTangent);
 
    class FBSDK_DLL FBFCurveCustomTangent : public FBComponent {
        __FBClassDeclare( FBFCurveCustomTangent,FBComponent );
    public:
        FBFCurveCustomTangent(HIObject pObject=NULL);
 
        virtual void FBDelete() override;
 
        FBPropertyString            CustomTangentName;          
        FBPropertyString            CustomTangentFBXName;       
        FBPropertyInt               CustomTangentIndex;         
    };
 
    FB_DEFINE_COMPONENT( FBSDK_DLL, FBFCurveCustomTangent );
 
    class FBSDK_DLL FBPropertyListCustomTangent : public FBPropertyListComponent
    {
    public:
        FBPropertyListCustomTangent();
 
        FBFCurveCustomTangent* operator[](int pIndex);
    };
 
    // 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;   
    };
 
    // FBCurveEvaluationEvent
    __FB_FORWARD( FBCurveEvaluationEvent );
 
    class FBSDK_DLL FBCurveEvaluationEvent : public FBEvent 
    {
    public:
        FBCurveEvaluationEvent( HKEventBase pEvent );
 
        FBXSDK_NAMESPACE::FbxAnimCurve* GetFBXCurve();
 
        FBPropertyDouble KeyIndex;              
        FBPropertyTime   Time;                  
        FBPropertyFCurve Curve;                 
        FBPropertyDouble Result;                
 
        FBPropertyInt LeftCustomTangentTypeIndex;       
        FBPropertyInt RightCustomTangentTypeIndex;      
    };
 
    // FBCurveCustomKeyAddEvent
    __FB_FORWARD( FBCurveCustomKeyAddEvent );
 
    class FBSDK_DLL FBCurveCustomKeyAddEvent : public FBEvent 
    {
    public:
        FBCurveCustomKeyAddEvent( HKEventBase pEvent );
    
        FBAnimationNode*        GetParentAnimationNode();
 
        FBComponent*            GetParentComponent();
 
        FBPropertyInt           KeyIndex;       
        FBPropertyTime          Time;           
        FBPropertyFCurve        Curve;          
    };
 
    // FBCurveCustomKeyChangeEvent
    __FB_FORWARD( FBCurveCustomKeyChangeEvent );
 
    enum FBCustomKeyChangeType
    {
        kFBNoChange,                
        kFBInterpolationChange,     
        kFBCustomTangentChange      
    };
    FB_DEFINE_ENUM( FBSDK_DLL, CustomKeyChangeType );
 
    class FBSDK_DLL FBCurveCustomKeyChangeEvent : public FBEvent 
    {
    public:
        FBCurveCustomKeyChangeEvent( HKEventBase pEvent );
 
        FBAnimationNode*                GetParentAnimationNode();
 
        FBComponent*                    GetParentComponent();
 
        FBPropertyBool                  IsPreCall;  
        FBPropertyCustomKeyChangeType   ChangeType; 
 
        FBPropertyInt                   KeyIndex;   
        FBPropertyTime                  Time;       
        FBPropertyFCurve                Curve;      
    };
 
    // 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);
 
    // FBPropertyEventAnimationNodeEvaluate
    class FBSDK_DLL FBPropertyEventAnimationNodeEvaluate : public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };
 
    // FBPropertyEventAnimationNodeKeyAdd
    class FBSDK_DLL FBPropertyEventAnimationNodeKeyAdd : public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };
 
    // FBPropertyEventAnimationNodeCustomKeyAdd
    class FBSDK_DLL FBPropertyEventAnimationNodeCustomKeyAdd : public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };
 
    // FBPropertyEventAnimationNodeCustomKeyChange
    class FBSDK_DLL FBPropertyEventAnimationNodeCustomKeyChange : public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };
 
    // 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;
    };
    
    // FBAnimationStack
 
    __FB_FORWARD( FBAnimationStack );
 
    class FBSDK_DLL FBAnimationStack : public FBComponent
    {
        //--- Open Reality declaration.
        __FBClassDeclare(FBAnimationStack, FBComponent);
    public:
 
        FBAnimationStack(const char *pName, HIObject pObject=NULL);
 
        virtual void FBDelete() override;
 
    };
 
    // FBFCurveCustomTangentManager
    __FB_FORWARD( FBFCurveCustomTangentManager );
 
    class FBSDK_DLL FBFCurveCustomTangentManager : public FBComponent
    {
        __FBClassDeclare(FBFCurveCustomTangentManager, FBComponent);
 
        FBFCurveCustomTangentManager();
 
    public:
 
        int AddCustomTangentType(const char* pTangentName, const char* pTangentFBXName);
 
        bool RemoveCustomTangentType(const char* pTangentName);
    
        int GetCustomTangentTypeCount();
 
        const char* GetCustomTangentTypeName(int pIndex);
 
        FBPropertyEventAnimationNodeEvaluate                OnEvaluate;     
 
        FBPropertyEventAnimationNodeKeyAdd                  OnKeyAdd;           
        FBPropertyEventAnimationNodeCustomKeyAdd            OnCustomKeyAdd;     
 
        FBPropertyEventAnimationNodeCustomKeyChange         OnCustomKeyChange;  
 
        static FBFCurveCustomTangentManager& TheOne();
    };
 
    // FBPropertyStateEvent
 
    enum FBPropertyStateEventType   {
        kFBPropertyStateEventTypeUnknownOperation = 0,  
        kFBPropertyStateEventTypeAttached = 1 << 0,     
        kFBPropertyStateEventTypeDetached = 1 << 1,     
        kFBPropertyStateEventTypeDestroyed = 1 << 2,    
        kFBPropertyStateEventTypeMassOperation = 1 << 3,
    };
    FB_DEFINE_ENUM( FBSDK_DLL, PropertyStateEventType );
 
    __FB_FORWARD( FBPropertyStateEvent );
 
    class FBSDK_DLL FBPropertyStateEvent : public FBEvent 
    {
    public:
        FBPropertyStateEvent( HKEventBase pEvent );
    
        FBProperty*             GetProperty();
 
        FBComponent*            GetParentComponent();
 
        FBPropertyPropertyStateEventType    EventType;    
    };
 
    // FBFCurveEvent
 
    enum FBFCurveEventType  {
        kFBFCurveEventTypeUnknownOperation = 0,                     
        kFBFCurveEventTypeKeyAdded = 1 << 0,                        
        kFBFCurveEventTypeKeyRemoved = 1 << 1,                      
        kFBFCurveEventTypeKeyTimeChanged = 1 << 2,                  
        kFBFCurveEventTypeKeyValueChanged = 1 << 3,                 
        kFBFCurveEventTypeDerivativedChanged = 1 << 4,              
        kFBFCurveEventTypeKeyInterpolationChanged = 1 << 5,         
        kFBFCurveEventTypeKeyTangentChanged = 1 << 6,               
        kFBFCurveEventTypeKeyTangentBreakChanged = 1 << 7,          
        kFBFCurveEventTypeKeyTangentClampModeChanged = 1 << 8,      
        kFBFCurveEventTypeKeyTangentConstantChanged = 1 << 9,       
        kFBFCurveEventTypeKeyVelocityChanged = 1 << 10,             
        kFBFCurveEventTypeKeyWeightChanged = 1 << 11,               
        kFBFCurveEventTypeKeyTensionChanged = 1 << 12,              
        kFBFCurveEventTypeKeyContinuityChanged = 1 << 13,           
        kFBFCurveEventTypeKeyBiasChanged = 1 << 14,                 
        kFBFCurveEventTypeKeyPreExtrapolationChanged = 1 << 15,     
        kFBFCurveEventTypeKeyPostExtrapolationChanged = 1 << 16,    
        kFBFCurveEventTypeKeyMassOperation = 1 << 17,               
    };
    FB_DEFINE_ENUM( FBSDK_DLL, FCurveEventType );
 
    __FB_FORWARD( FBFCurveEvent );
 
    class FBSDK_DLL FBFCurveEvent : public FBEvent 
    {
    public:
        FBFCurveEvent( HKEventBase pEvent );
    
        FBProperty*             GetParentProperty();
 
        FBAnimationNode*        GetParentAnimationNode();
 
        FBComponent*            GetParentComponent();
 
        FBPropertyFCurveEventType   EventType;          
        FBPropertyInt               KeyIndexStart;      
        FBPropertyInt               KeyIndexStop;       
        FBPropertyFCurve            Curve;              
        FBPropertyString            CurveName;          
        FBPropertyInt               CurveIndex;         
    };
 
    // FBPropertyChanged
    class FBSDK_DLL FBPropertyChanged: public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };
 
    // FBFCurveChanged
    class FBSDK_DLL FBFCurveChanged: public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };
 
    // FBFCurveEventManager
    __FB_FORWARD( FBFCurveEventManager );
 
    class FBSDK_DLL FBFCurveEventManager : public FBComponent
    {
        __FBClassDeclare(FBFCurveEventManager, FBComponent);
 
        FBFCurveEventManager();
 
    public:
 
        bool RegisterProperty(FBPropertyAnimatable* pProperty);
 
        bool UnregisterProperty(FBPropertyAnimatable* pProperty);
 
        FBFCurveChanged         OnFCurveEvent;  
        FBPropertyChanged       OnPropertyEvent;
 
        static FBFCurveEventManager& TheOne();
    };
 
    // 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() override;
 
        FBPropertyColor             Color;              
        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,          
    };
 
    enum FBMergeLayerMode   {   
        kFBMergeLayerModeAutomatic, 
        kFBMergeLayerModeAdditive,  
        kFBMergeLayerModeOverride,  
    };
 
enum FBTimeMarkAction
{
    kFBTimeMarkAction_None,         
    kFBTimeMarkAction_Stop,         
    kFBTimeMarkAction_Loop,         
};
 
enum FBPropertyComponents { 
    kFBPropertyComponent0   = 1 << 0,   
    kFBPropertyComponent1   = 1 << 1,   
    kFBPropertyComponent2   = 1 << 2,   
    kFBPropertyComponent3   = 1 << 3,   
    kFBPropertyComponentAll =   kFBPropertyComponent0 |
                                kFBPropertyComponent1 |
                                kFBPropertyComponent2 |
                                kFBPropertyComponent3   
};  
 
    // FBTake
 
    class FBSDK_DLL FBTake : public FBComponent {
        __FBClassDeclare( FBTake,FBComponent );
    public:
        FBTake(const char* pName, HIObject pObject=NULL);
 
        virtual void FBDelete() override;
 
        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();
 
        bool OffsetAnimation(
            FBTime&                         pOffsetTime,
            FBTime                          pStartTime = FBTime::MinusInfinity,
            FBTime                          pStopTime = FBTime::Infinity,
            bool                            pInclusive = true,
            int                             pLayerID = -1,
            bool                            pOnLockedProperties = false );
 
        bool OffsetAnimationOnObjects(
            FBArrayTemplate<FBBox*>*        pObjects,
            FBTime&                         pOffsetTime,
            FBTime                          pStartTime = FBTime::MinusInfinity,
            FBTime                          pStopTime = FBTime::Infinity,
            bool                            pInclusive = true,
            int                             pLayerID = -1,
            bool                            pOnLockedProperties = false );
    
        bool OffsetAnimationOnProperties(
            FBArrayTemplate<FBProperty*>*   pProperties,
            FBTime&                         pOffsetTime,
            FBTime                          pStartTime = FBTime::MinusInfinity,
            FBTime                          pStopTime = FBTime::Infinity,
            bool                            pInclusive = true,
            int                             pLayerID = -1,
            bool                            pOnLockedProperties = false,
            FBPropertyComponents            pPropertyComponents = kFBPropertyComponentAll );
 
        bool DeleteAnimation(
            FBTime                          pStartTime = FBTime::MinusInfinity,
            FBTime                          pStopTime = FBTime::Infinity,
            bool                            pInclusive = true,
            int                             pLayerID = -1,
            bool                            pOnLockedProperties = false );
 
        bool DeleteAnimationOnObjects(
            FBArrayTemplate<FBBox*>*        pObjects,
            FBTime                          pStartTime = FBTime::MinusInfinity,
            FBTime                          pStopTime = FBTime::Infinity,
            bool                            pInclusive = true,
            int                             pLayerID = -1,
            bool                            pOnLockedProperties = false );
 
        bool DeleteAnimationOnProperties(
            FBArrayTemplate<FBProperty*>*   pProperties,
            FBTime                          pStartTime = FBTime::MinusInfinity,
            FBTime                          pStopTime = FBTime::Infinity,
            bool                            pInclusive = true,
            int                             pLayerID = -1,
            bool                            pOnLockedProperties = false,
            FBPropertyComponents            pPropertyComponents = kFBPropertyComponentAll );
    };
 
    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);
 
        K_DEPRECATED_2023 void DestroyTimeWarpFromTake(FBTake* pTake, FBAnimationNode* pTimeWarp);
 
        K_DEPRECATED_2023 void RemoveTimeWarpFromScene(FBAnimationNode* pTimeWarp);
 
        void RemoveTimeWarpFromScene( FBTake* pTake, 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();
    };
 
FBSDK_DLL FBXSDK_NAMESPACE::FbxProperty FBtoFBXProperty(FBProperty* pSourceProperty, FBTake* pSourceTake, FBXSDK_NAMESPACE::FbxObject* pDestinationObject, FBXSDK_NAMESPACE::FbxScene* pDestinationScene, FBXSDK_NAMESPACE::FbxAnimStack* pDestinationStack, bool pCopyAnimation=true);
 
FBSDK_DLL FBProperty* FBXtoFBProperty(FBXSDK_NAMESPACE::FbxProperty* pSourceProperty, FBXSDK_NAMESPACE::FbxAnimStack* pSourceStack, FBComponent* pDestinationObject, FBTake* pDestinationTake, bool pCopyAnimation=true, FBTime pLimitStart=FBTime::MinusInfinity, FBTime pLimitEnd=FBTime::Infinity);
 
#ifdef FBSDKUseNamespace
}
#endif
 
#endif