fbsystem.h

Go to the documentation of this file.

#ifndef __FBSYSTEM_H__
#define __FBSYSTEM_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

// Essential includes
#include <fbsdk/fbcomponent.h>
#include <fbsdk/fbdata.h>   // FBPropertyListTake

#include <fbsdk/fbio.h>     // FBPropertyListCommPort
#include <fbsdk/fbshader.h>
#include <fbsdk/fbmodel.h>
#include <fbsdk/fbevaluateinfo.h>

// For 'lean version' we don't need the plugin headers.
#if !defined(K_NO_AUDIO)
    #include <fbsdk/fbaudio.h>
#endif

#if !defined(K_NO_VIDEO)
    #include <fbsdk/fbvideo.h>
#endif

#if !defined(K_NO_DECK)
    #include <fbsdk/fbdeck.h>           // FBPropertyListDeck
#endif

#if !defined(K_NO_ASSETMNG)
    #include <fbsdk/fbassetmng.h>   // FBPropertyAssetMng
#endif

#if !defined(K_NO_MANIPULATOR)
    #include <fbsdk/fbmanipulator.h>    // FBPropertyListManipulator
#endif

#ifdef FBSDKUseNamespace
    namespace FBSDKNamespace {
#endif

#if !defined(K_NO_CHARACTER)
FB_FORWARD( FBCharacter );
#endif

struct FBVideoGrabOptions;
typedef FBVideoGrabOptions* HFBVideoGrabOptions;

struct FBPickInfos;
typedef class FBSDK_DLL FBArrayTemplate<FBPickInfos> FBPickInfosList;

FB_DEFINE_COMPONENT( FBSDK_DLL, Take );
FB_DEFINE_COMPONENT( FBSDK_DLL, Renderer );

// Utility function
// For internal use only.

FBSDK_DLL HIObject      FBGetFBObject( HIObject pObject, bool pAutoCreate=false );

template<class T> inline T* FBCast(HIObject pObject, bool pAutoCreate = false)
{
    HIObject lObject = FBGetFBObject(pObject, pAutoCreate);
    // Should also validate type but not available for now
    return (T*)lObject;
}

// FBSystem
__FB_FORWARD( FBSystem );

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

    FBPropertyString                        ConfigPath;                 // < <b>Read Only Property:</b> Location where the config folder is.
    FBPropertyString                        UserConfigPath;             // < <b>Read Only Property:</b> Location where the user config folder is.
    FBPropertyString                        ApplicationPath;            
    FBPropertyString                        TempPath;                   
    FBPropertyEventUIIdle                   OnUIIdle;                   
    FBPropertyEventConnectionNotify         OnConnectionNotify;         
    FBPropertyEventConnectionDataNotify     OnConnectionDataNotify;     
    FBPropertyEventConnectionStateNotify    OnConnectionStateNotify;    
    FBPropertyEventConnectionKeyingNotify   OnConnectionKeyingNotify;   

    FBPropertyString                        ComputerName;               
    FBPropertyDouble                        Version;                    
    FBPropertyString                        BuildId;                    

                                                                        
    FBPropertyTime                          SystemTime;                 
    FBPropertyTime                          LocalTime;                  
    FBPropertyTake                          CurrentTake;                
                                                                        
    FBPropertyScene                         Scene;                      
                                                                        
    FBPropertyModel                         SceneRootModel;             
    FBPropertyModel                         RootModel;                  
    FBPropertyString                        PathImages;                 
    FBPropertyString                        PathMeshs;                  
                                                                        
#if !defined(K_NO_AUDIO)
    FBPropertyListAudioIn                   AudioInputs;                
    FBPropertyListAudioOut                  AudioOutputs;               
#endif

#if !defined(K_NO_VIDEO)
    FBPropertyListVideoIn                   VideoInputs;                
    FBPropertyListVideoOut                  VideoOutputs;               
#endif                                                                  
                                                                        
    FBPropertyListCommPort                  CommPorts;                  
    FBPropertyRenderer                      Renderer;                   
                                                                        
    FBPropertyDouble                        FrameRate;                  
    FBPropertyDouble                        ProcessMemory;              
    FBPropertyDouble                        ProcessMemoryPeak;          
    FBPropertyVector2d                      DesktopSize;                
    FBPropertyBool                          FullScreenViewer;           

#if !defined(K_NO_ASSETMNG)
    FBPropertyAssetMng                      AssetManager;               
#endif

#if !defined(K_NO_MANIPULATOR)
    FBPropertyListManipulator               Manipulators;   
#endif

    static bool  LibraryLoad(const char *pPath);
    static void* LibraryGetProcAddress(const char *pPath, const char *pFunctionName);
    static bool  LibraryFree(const char *pPath);

    static FBString CurrentDirectory();

    static FBString MakeFullPath(const char* pRelativeFilePath);

    static FBSystem& TheOne();
};

#ifndef K_NO_TRIGGER

// FBTriggerManager
__FB_FORWARD( FBTriggerManager );
class FBSDK_DLL FBTriggerManager :public FBComponent 
{
    __FBClassDeclare( FBTriggerManager, FBComponent );
  public:
    FBTriggerManager();

    int GetGroupCount();

    char* GetGroupName( int pIndex );

    bool GetGroupActive( int pIndex );

    void SetGroupActive( int pIndex, bool pState );

    FBPropertyBool      Active;     
};
#endif

// FBBatchOptions
FB_FORWARD( FBBatchOptions );

enum FBBatchProcessType
{
    kFBBatchProcessTypeLoad,    
    kFBBatchProcessTypeSave,    
    kFBBatchProcessTypeConvert  
};
FB_DEFINE_ENUM( FBSDK_DLL, BatchProcessType );

enum FBBatchFileFormat
{
    kFBBatchFileFormatTRC,      
    kFBBatchFileFormatC3D,      
    kFBBatchFileFormatAMC,      
    kFBBatchFileFormatBVH,      
    kFBBatchFileFormatHTR,      
    kFBBatchFileFormatFBX       
};
FB_DEFINE_ENUM( FBSDK_DLL, BatchFileFormat );

enum FBBatchOnTakeExist
{
    kFBBatchOnTakeExistOverwrite,   
    kFBBatchOnTakeExistSkip         
};
FB_DEFINE_ENUM( FBSDK_DLL, BatchOnTakeExist );

enum FBBatchOnContainsBatchTakes
{
    kFBBatchOnContainsBatchTakesSaveBatchTakesOnly, 
    kFBBatchOnContainsBatchTakesSaveAllTakes        
};
FB_DEFINE_ENUM( FBSDK_DLL, BatchOnContainsBatchTakes );

enum FBBatchStatus
{
    kFBBatchStatusSuccess,
    kFBBatchStatusError,
    kFBBatchStatusCharacterNotSpecified,
    kFBBatchStatusCharacterNotCharacterized,
    kFBBatchStatusCharacterHasNoReference,
    kFBBatchStatusInputActorNotSpecified,
    kFBBatchStatusActorInputMarkersetNotSpecified,
    kFBBatchStatusActorInputMarkersetHasNoReferenceModel,
    kFBBatchStatusActorInputMarkersetNotCorrectlyAssociated,
    kFBBatchStatusInputCharacterNotCharacterized,
    kFBBatchStatusInputCharacterHasNoReference,
    kFBBatchStatusInputDirectoryNotValid,
    kFBBatchStatusAsfSkeletonFileNotSpecified,
    kFBBatchStatusCantOpenAsfSkeletonFile,
    kFBBatchStatusOutputDirectoryNotValid
};

class FBSDK_DLL FBBatchOptions
{
  public:

    FBBatchOptions();

    FBBatchFileFormat       mInputFileFormat;           
    FBBatchFileFormat       mOutputFileFormat;          
                                                        
    FBBatchProcessType      mProcessType;               
                                                        
    FBString                mInputDirectory;            
    FBString                mOutputDirectory;           
    FBString                mSkeletonFile;              

#if !defined(K_NO_CHARACTER)
    FBCharacter*            mCharacter;                 
#endif
                                                        
    bool                    mStartAnimationAtZero;      
    bool                    mFrameAnimation;            
    bool                    mOverwriteScaling;          
    bool                    mKeepDummyBones;            
    bool                    mWriteRate;                 
    bool                    mWriteTranslation;          
    bool                    mPlotToCharacter;           
    bool                    mPlotToControlSet;          
    bool                    mUseSingleTake;             
    bool                    mUseBatchSuffix;            
    bool                    mKeepCharacterConstraint;   

    FBBatchOnTakeExist          mOnTakeExistAction;             
    FBBatchOnContainsBatchTakes mOnContainsBatchTakesAction;    
};


// FBPlotOptions
FB_FORWARD( FBPlotOptions );

enum FBRotationFilter
{
    kFBRotationFilterNone,
    kFBRotationFilterGimbleKiller,
    kFBRotationFilterUnroll
};
FB_DEFINE_ENUM( FBSDK_DLL, RotationFilter );

class FBSDK_DLL FBPlotOptions
{
  public:

    FBPlotOptions();

    bool                mPlotAllTakes;                  
    bool                mPlotOnFrame;                   
    FBTime              mPlotPeriod;                    
    FBRotationFilter    mRotationFilterToApply;         
    bool                mUseConstantKeyReducer;         
    bool                mConstantKeyReducerKeepOneKey;  
    bool                mPlotTranslationOnRootOnly;     
    bool                mPreciseTimeDiscontinuities;    
};

#if !defined(K_NO_AUDIO)

// FBAudioRenderOptions
FB_FORWARD( FBAudioRenderOptions );

class FBSDK_DLL FBAudioRenderOptions
{
public:
    
    FBAudioRenderOptions();

    FBTimeSpan              TimeSpan;       
    FBAudioChannelMode      ChannelMode;    
    FBAudioBitDepthMode     BitDepthMode;   
    FBAudioRateMode         RateMode;       
    FBString                OutputFileName; 
};
typedef FBAudioRenderOptions* HFBAudioRenderOptions;
#endif

// FBApplication
__FB_FORWARD( FBApplication );
#if !defined(K_NO_CHARACTER)
__FB_FORWARD( FBCharacter );
#endif
#if !defined(K_NO_ACTOR)
__FB_FORWARD( FBActor );
#endif
#if !defined(K_NO_CHARACTER)
FB_DEFINE_COMPONENT( FBSDK_DLL, Character );
#endif
#if !defined(K_NO_ACTOR)
FB_DEFINE_COMPONENT( FBSDK_DLL, Actor );
#endif

enum FBViewerMode { 
    kFBViewerModeOneWindow,     
    kFBViewerModeTwoWindow,     
    kFBViewerModeThreeWindow,   
    kFBViewerModeFourWindow,    
    kFBViewerModeSchematic      
};

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

    FBPropertyEvent OnFileNewCompleted;     
    FBPropertyEvent OnFileNew;              
    FBPropertyEvent OnFileOpenCompleted;    
    FBPropertyEvent OnFileOpen;             
    FBPropertyEvent OnFileMerge;            
    FBPropertyEvent OnFileSaveCompleted;    
    FBPropertyEvent OnFileSave;             
    FBPropertyEvent OnFileExit;             

    bool Minimize(bool pBlocking=true);

    bool Maximize();

    bool FileNew();

    bool FileOpen( const char* pFilename, bool pShowUIMsg = false, FBFbxOptions* pOptions = NULL );
    bool FileOpen( void* pBuffer, kULong pBufferLength );       
    bool GetMaxFrameCount(void* pMemAddr, kULong pSize, kLong* pFrameCount, int pTimeScale);    

    bool FileMerge( const char* pFilename, bool pShowUIMsg = false, FBFbxOptions* pOptions = NULL );

    bool FileMerge( FBStringList& pPathlist, bool pShowUIMsg = false, FBFbxOptions* pOptions = NULL );

    bool FileAppend( const char* pFilename, bool pShowUIMsg = false, FBFbxOptions* pOptions = NULL );

    bool FileSave( const char* pFilename = NULL, FBFbxOptions* pOptions = NULL );

    void FileExit( bool pSave = false );

    bool FileImport( FBString pFilename, bool pMatchModels = false, bool pCreateUnmatchedModels = true );

    bool FileExport( FBString pFilename );

    FBBatchStatus FileBatch( HFBBatchOptions pBatchOptions, HFBPlotOptions pPlotOptions = NULL );

    bool FileImportBatch( const char* pName, HFBBatchOptions pBatchOptions, FBModel* pReference );

    bool FileExportBatch( const char* pName, HFBTake pTake, HFBBatchOptions pBatchOptions, FBModelList &pExportModels );

#if !defined(K_NO_CHARACTER)

   bool SaveCharacterRigAndAnimation( const char* pFileName, FBCharacter* pCharacter, HFBFbxOptions pFbxOptions);

    bool LoadAnimationOnCharacter( const char* pFileName, FBCharacter* pCharacter,  HFBFbxOptions pFbxOptions, HFBPlotOptions pPlotOptions);
#endif

    bool IsValidBatchFile( const char* pFilename );

    bool FileRender( FBVideoGrabOptions* pRenderOptions = NULL );

#if !defined(K_NO_AUDIO)

    bool AudioRender( HFBAudioRenderOptions pAudioRenderOptions  = NULL);
#endif

    bool ExecuteScript(FBString pFilename);

    void SwitchViewerCamera( FBCamera &pCamera );

// Temporary export for QA tests

    K_DEPRECATED bool FBXFileOpen( const char* pFilename, FBFbxOptions* pOptions = NULL );
    
    K_DEPRECATED bool FBXFileMerge( const char* pFilename, FBFbxOptions* pOptions = NULL );
    
    K_DEPRECATED bool FBXFileAppend( const char* pFilename, FBFbxOptions* pOptions = NULL );

    K_DEPRECATED bool FBXFileSave( const char* pFilename = NULL, FBFbxOptions* pOptions = NULL );

public:
    FBPropertyString        FBXFileName;            
#if !defined(K_NO_ACTOR)
    FBPropertyActor         CurrentActor;           
#endif
#if !defined(K_NO_CHARACTER)
    FBPropertyCharacter     CurrentCharacter;       
#endif

    static FBApplication& TheOne();
};


// FBPlayerControl

__FB_FORWARD( FBPlayerControl );




enum FBTransportMode {  
    kFBTransportPlay,               kFBTransportPlayPrepare,        kFBTransportPlayReady,
    kFBTransportStop,               kFBTransportStopPost,           kFBTransportStopReady,
    kFBTransportShuttle,            kFBTransportShuttlePrepare,     kFBTransportShuttleReady,
    kFBTransportPlayReverse,        kFBTransportPlayReversePrepare, kFBTransportPlayReverseReady,
    kFBTransportJog,                kFBTransportJogPrepare,         kFBTransportJogReady,
    kFBTransportGoto,               kFBTransportGotoPrepare,        kFBTransportGotoReady,
    kFBTransportStepForward,        kFBTransportStepForwardPrepare, kFBTransportStepForwardReady,
    kFBTransportStepBackward,       kFBTransportStepBackwardPrepare,kFBTransportStepBackwardReady
};
FB_DEFINE_ENUM( FBSDK_DLL, TransportMode );

enum FBTransportTimeFormat
{
    kFBTimeFormatTimecode, 
    kFBTimeFormatFrame, 
};

FB_DEFINE_ENUM(FBSDK_DLL, TransportTimeFormat);


enum FBTransportPlaySpeed
{
    kFBSpeed_1_10x, 
    kFBSpeed_1_5x,  
    kFBSpeed_1_4x,  
    kFBSpeed_1_3x,  
    kFBSpeed_1_2x,  
    kFBSpeed_1x,    
    kFBSpeed_ALL_FR, 
    kFBSpeed_2x,    
    kFBSpeed_3x,    
    kFBSpeed_4x,    
    kFBSpeed_5x,    
    kFBSpeed_10x    
};
FB_DEFINE_ENUM( FBSDK_DLL, TransportPlaySpeed);

enum FBTransportSnapMode
{
    kFBTransportSnapModeNoSnap,              
    kFBTransportSnapModeSnapOnFrames,        
    kFBTransportSnapModePlayOnFrames,        
    kFBTransportSnapModeSnapAndPlayOnFrames, 
};
FB_DEFINE_ENUM( FBSDK_DLL, TransportSnapMode );


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

    FBPlayerControl(HIObject pObject=NULL);

    bool Play(bool pUseMarkers = false);

    bool PlayReverse(bool pUseMarkers = false);

    void SetPlaySpeed (FBTransportPlaySpeed pPlaySpeed );

    FBTransportPlaySpeed GetPlaySpeed();

    bool Stop();

    bool GotoStart();

    bool GotoEnd();

    bool Goto( FBTime pTime );

    bool StepForward();

    bool StepBackward();

    bool Record( bool pOverrideTake=false,bool pCopyData=true );
    
    void LockTransport( bool );

    bool IsLocked(); 
    
    FBTransportMode GetTransportMode();
    
    void       SetTransportFps ( FBTimeMode pTimeMode, double pCustom=0.0);

    FBTimeMode GetTransportFps ();

    double     GetTransportFpsValue ();
    
    void Key();

    void GotoNextKey();

    void GotoPreviousKey();

    void EvaluationPause();

    void EvaluationResume();

    FBPropertyBool  LoopActive;     
    FBPropertyTime  LoopStart;      
    FBPropertyTime  LoopStop;       

    FBPropertyTime  ZoomWindowStart;    
    FBPropertyTime  ZoomWindowStop;     

    FBPropertyTime  NextMarker;     
    FBPropertyTime  PreviousMarker; 

    FBPropertyBool  IsRecording;    
    FBPropertyBool  IsPlaying;      
    FBPropertyBool  IsPlotting;     

    FBPropertyTransportSnapMode SnapMode;   

    FBPropertyTransportTimeFormat TransportTimeFormat; 

    FBPropertyTime  RecordingSamplingPeriod;    
    FBPropertyTime  PlotSamplingPeriod;         

    static FBPlayerControl& TheOne();
};

// FBEvaluateManager

enum FBParallelScheduleType
{
    kFBParallelScheduleSerial,      
    kFBParallelScheduleSimple,      
    kFBParallelScheduleAdvanced,    
};

enum FBGlobalEvalCallbackTiming
{
    kFBGlobalEvalCallbackBeforeDAG,     
    kFBGlobalEvalCallbackAfterDAG,      
    kFBGlobalEvalCallbackAfterDeform,   
};

typedef void (*kFBEvaluationGlobalFunctionCallback)(FBEvaluateInfo* pEvaluteInfo);

FB_DEFINE_ENUM(FBSDK_DLL, ParallelScheduleType);

__FB_FORWARD( FBEvaluateManager );
class FBSDK_DLL FBEvaluateManager : public FBComponent 
{
    __FBClassDeclare( FBEvaluateManager,FBComponent );

public:

    FBEvaluateManager(HIObject pObject=NULL);

    FBPropertyBool                  ParallelPipeline;            
    FBPropertyBool                  ParallelDeformation;         
    FBPropertyBool                  UseGPUDeformation;           
    FBPropertyBool                  FrameSkipOptimization;       
    FBPropertyParallelScheduleType  ParallelScheduleType;        
    FBPropertyBool                  ParallelEvaluation;          

    FBPropertyInt                   NodeCount;                   
    FBPropertyInt                   DeviceCount;                 

    void InvalidateDAG();

    void RegisterEvaluationGlobalFunction  (kFBEvaluationGlobalFunctionCallback pCallback, FBGlobalEvalCallbackTiming pTiming);

    void UnregisterEvaluationGlobalFunction(kFBEvaluationGlobalFunctionCallback pCallback, FBGlobalEvalCallbackTiming pTiming);

    static FBEvaluateManager& TheOne();
};

// FBKeyControl
__FB_FORWARD( FBKeyControl );

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

public:
    FBKeyControl(HIObject pObject=NULL);

    FBPropertyBool  AutoKey;    
};

// FBPointCacheManager
__FB_FORWARD( FBPointCacheManager );

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

    FBPointCacheManager(HIObject pObject=NULL);

public:
    FBPropertyListObject   Models;                  

    FBPropertyBool         ApplyGlobalTransform;    
    FBPropertyAction       SetTransformReference;   

    FBPropertyBool         ApplyCacheOnNewModel;    
    FBPropertyModel        NewModelRoot;            

    FBPropertyBool         AllowCacheResampling;    
    FBPropertyBool         AlwaysAskForPath;        
    FBPropertyString       DefaultPath;             
    FBPropertyBool         CacheNormal;             
    FBPropertyBool         CacheAABBox;             
    FBPropertyBool         CreateMultiChannelCache; 
    FBPropertyBool         CreateFilePerFrameCache; 
    FBPropertyInt          SaveEveryFrame;          

    static FBPointCacheManager& TheOne();
};

// FBFileMonitoringManager
__FB_FORWARD( FBFileMonitoringManager );
enum FBFileMonitoringType   {
    kFBFileMonitoring_InvalidIndex, 
    kFBFileMonitoring_MAINSCENE,    
    kFBFileMonitoring_ANIMATIONCLIP,
};

FB_DEFINE_ENUM( FBSDK_DLL, FileMonitoringType );

__FB_FORWARD( FBEventFileChange );

class FBSDK_DLL FBEventFileChange: public FBEvent 
{
  public:

    FBEventFileChange( HKEventBase pEvent );        

    FBPropertyFileMonitoringType    Type;        
    FBPropertyString                Path;        
};

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

    FBFileMonitoringManager(HIObject pObject=NULL);

public:
    void AddFileToMonitor(FBString pFilePath, FBFileMonitoringType pFileMonitoringType );

    void RemoveFileFromMonitor(FBString pFilePath);

    void PauseFileMonitoring(bool pPause = true);

    void CleanFileMonitoring();

public:
    FBPropertyEvent    OnFileChangeMainScene;           
    FBPropertyEvent    OnFileChangeAnimationClip;       

    static FBFileMonitoringManager& TheOne();
};

// FBCriticalSection
FB_FORWARD( FBCriticalSection );

class FBSDK_DLL FBCriticalSection
{
    void *mPtr;     
public:
    FBCriticalSection();

    ~FBCriticalSection();

    bool Init();

    void Enter();

    void Leave();
};

// FBFastLock
FB_FORWARD( FBFastLock );

class FBSDK_DLL FBFastLock 
{
    void *mPtr;     
public:
    FBFastLock();

    ~FBFastLock();

    void Lock();

    void Unlock();
};

// FBReferenceTime
__FB_FORWARD( FBReferenceTime );

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

    int    Add( const char *pName );

    void   Remove( int pIndex );

    void   SetTime( int pIndex, FBTime pReferenceTime, FBTime pSystem );
    FBTime GetTime( int pIndex, FBTime pSystem );

    const char *operator[](int pIndex);

    FBPropertyInt               Count;          
    FBPropertyInt               ItemIndex;      
};

// Global utility functions


FBSDK_DLL FBModelList* FBCreateModelList();

FBSDK_DLL void FBDestroyModelList( FBModelList* pModelList );

FBSDK_DLL FBPickInfosList* FBCreatePickInfosList();

FBSDK_DLL void FBDestroyPickInfosList( FBPickInfosList* pPickInfosList );

FBSDK_DLL FBPlugList* FBCreatePlugList();

FBSDK_DLL void FBDestroyPlugList( FBPlugList* pPlugList );

FBSDK_DLL FBComponentList* FBCreateComponentList();

FBSDK_DLL void FBDestroyComponentList( FBComponentList* pObjectList );


FBSDK_DLL void FBSleep( kULong MilliSeconds );

FBSDK_DLL void FBSchedulingDependencyOutput( bool pEnable );

K_DEPRECATED FBSDK_DLL FBModel* FBFindModelByName( const char* pModelName, FBModel* pParent=NULL  );

FBSDK_DLL FBModel* FBFindModelByLabelName( const char* pModelLabelName );

FBSDK_DLL FBModel* FBFindModelByUniqueColorId( const FBColor& pColor );

FBSDK_DLL FBModel* FBLoadFbxPrimitivesModel( const char* pModelName );

FBSDK_DLL void FBFindModelsOfType( FBModelList& pList, int pTypeInfo, FBModel* pParent=NULL );

FBSDK_DLL void FBGetSelectedModels( FBModelList& pList, FBModel* pParent=NULL, bool pSelected=true, bool pSortBySelectOrder = false );

FBSDK_DLL void FBFindObjectsByName( const char* pNamePattern, FBComponentList& pList, bool pIncludeNamespace = true, bool pModelsOnly = false );

FBSDK_DLL FBComponent* FBFindObjectByFullName( const char* pObjectFullName );

FBSDK_DLL int FBDeleteObjectsByName( const char* pNamePattern, const char* pNameSpace = NULL, const char* pGroupName = NULL);

FBSDK_DLL void FBBeginChangeAllModels();

FBSDK_DLL void FBEndChangeAllModels();

FBSDK_DLL void FBMergeTransactionBegin();

FBSDK_DLL void FBMergeTransactionEnd();


FBSDK_DLL void FBTrace( const char* pFormatString, ... );


FBSDK_DLL void FBMakeFullPath( FBString &pFullPath, const char *pRootPath, const char *pFilePath );

class FBSDK_DLL FBVisitDirectoryCallback
{
public:
    virtual ~FBVisitDirectoryCallback();
    virtual void FileVisited(const char*  pSrc) const;
    virtual void DirectoryVisited(const char*  pSrc) const;
    bool DoIt( const char* pSrcPath, bool pRecursive ) const;
};

#if !defined(K_NO_UI)

FBSDK_DLL bool FBPopNormalTool( const char* pToolName, bool pSetFocus = true );

#endif

#ifdef FBSDKUseNamespace
    }
#endif
#endif