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"


K_FORWARD( IConnector );
K_FORWARD( KFCurve );

#ifdef FBSDKUseNamespace
    namespace FBSDKNamespace {
#endif

FB_FORWARD( FBEvaluateInfo );
        
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     
};
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 );
 
// FBFCurveKey
FB_FORWARD( FBFCurve );
__FB_FORWARD( FBFCurveKey );
FB_FORWARD( FBPropertyListFCurveKey );

class FBSDK_DLL FBFCurveKey
{
private:
    HDataFBFCurveKey mLocalPtr;
    void FBFCurveKeyInitProperties();
    void PropertyAdd( FBProperty* ) {};
public:
    FBFCurveKey( HKFCurve 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;        
    
    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 );

    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 Replace( FBFCurve& pSource, FBTime pStart = FBTime::MinusInfinity, FBTime pStop = FBTime::Infinity, bool pUseExactGivenSpan = false, bool pKeyStartEndOnNoKey = true );

    static FBFCurve* CreateInterpolatorCurve( FBInterpolatorCurveType pCurveType );

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

FB_DEFINE_COMPONENT( FBSDK_DLL, AnimationNode   );
// 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( FBTime &pTime, double *pData );

    void KeyAdd( double *pData );

    bool SetCandidate( double* Data );

    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 ReadData( double *Data, FBTime pTime );

    bool ReadData( double* Data );

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

    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;   

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

private:
    void FBAnimationLayerInitProperties();
};


__FB_FORWARD( FBTake);
// FBPropertyListTake

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

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

enum FBMergeLayerMode   {   
    kFBMergeLayerModeAutomatic, 
    kFBMergeLayerModeAdditive,  
    kFBMergeLayerModeOverride,  
};

// FBTake

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

    virtual void FBDelete();

    HFBTake CopyTake( const char *pNewTakeName );

    void PlotAllTakesOnSelected(FBTime pPlotPeriod);
    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);

    void PlotTakeOnSelected(FBTime pPlotPeriod);

    void PlotAllTakesOnSelectedProperties(FBTime pPlotPeriod);

    void PlotTakeOnSelectedProperties(FBTime pPlotPeriod);

    void ClearAllProperties(bool pOnSelectedObjectsOnly);

    FBPropertyTimeSpan  ReferenceTimeSpan;      
    FBPropertyTimeSpan  LocalTimeSpan;          
    FBPropertyString    Comments;               
};

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(HFBTake pTake);

    void TimeWarpInitTake(HFBTake pTake);

    void TimeWarpCopyTake(HFBTake pDstTake, HFBTake pSrcTake );


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

    void DestroyTimeWarpFromTake(HFBTake pTake, FBAnimationNode* pTimeWarp);
    
    void RemoveTimeWarpFromScene(FBAnimationNode* pTimeWarp);


    kLong GetTimeWarpCount(HFBTake pTake);
    
    FBAnimationNode* GetTimeWarpAtIndex(HFBTake pTake, kLong pIndex);


    int GetTimeWarpNickNumber(HFBTake pTake, FBAnimationNode* pTimeWarp);

    bool SetTimeWarpNickNumber(HFBTake pTake, FBAnimationNode* pTimeWarp, int pNumber);
    
    int GetTimeWarpNickNumberAtIndex(HFBTake pTake, kLong pIndex);

    FBAnimationNode* GetTimeWarpFromNickNumber(HFBTake pTake, int pNumber);
    
    int FindTimeWarpNickNumberGlobal(FBAnimationNode* pTimeWarp);


    bool ApplyTimeWarp(HFBTake pTake, FBProperty* pEvalProp, FBAnimationNode* pTimeWarp);
    
    void RemoveTimeWarp(HFBTake pTake, FBProperty* pEvalProp );


    void TimeWarpRegisterChangeEvent(TimeWarpChangeCallback pCallback, void* pObject);
    
    void TimeWarpUnregisterChangeEvent(TimeWarpChangeCallback pCallback, void* pObject);


    FBAnimationNode* TimeWarpCreateNew( const char* pName );


    void TimeWarpRename( HFBTake pTake, FBAnimationNode* pTimeWarp, const char* pNewName );
    
    void TimeWarpMergeCurveNode( HFBTake pTake,FBProperty* pEvalProp, FBAnimationNode*  pNode, FBAnimationNode*  pTimeWarpNode );
    
    static FBTimeWarpManager& TheOne();
};

#ifdef FBSDKUseNamespace
    }
#endif

#endif