fbcore.h

Go to the documentation of this file.

#ifndef __FBCORE_H__
#define __FBCORE_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 <fbsdk/fbfbx.h>
#include <fbsdk/fbtime.h>
#include <fbsdk/fbdata.h>
#include <fbsdk/fbevaluateinfo.h>


// somebody at SGI defined this in their include files
// until we find which one, we remove it
#undef Status

#ifdef FBSDKUseNamespace
    namespace FBSDKNamespace {
#endif

FB_DEFINE_COMPONENT( FBSDK_DLL, ModelTemplate   );
FB_DEFINE_COMPONENT( FBSDK_DLL, Device          );
FB_DEFINE_COMPONENT( FBSDK_DLL, Path3D          );
FB_DEFINE_COMPONENT( FBSDK_DLL, Scene           );
FB_DEFINE_COMPONENT( FBSDK_DLL, Model           );
FB_DEFINE_COMPONENT( FBSDK_DLL, Device          );

// ========================================================================================== 
// Global definition
// ==========================================================================================
typedef HIObject (* kFBObjectCreatorFnc)(HIObject pOwner,const char* pName,void *pData);

// ==========================================================================================
// Declaration definition
// ==========================================================================================
#define FBBoxDeclare( ClassName, Parent ) \
    FBClassDeclare( ClassName,Parent ); \
  public: \
  ClassName(const char* pName):Parent(pName) { FBClassInit; } \
  private:

#define FBBoxImplementation( ThisComponent ) \
    FBClassImplementation( ThisComponent )

#define FBDeviceDeclare( ClassName, Parent ) \
    FBClassDeclare( ClassName,Parent ); \
  public: \
    ClassName(const char* pName):Parent(pName) { FBClassInit; } \
  private:

#define FBDeviceImplementation( ThisComponent ) \
    FBClassImplementation( ThisComponent )

// ==========================================================================================
// Register definition
// ==========================================================================================
#define FBRegisterBox( UniqueNameStr, ClassName, FolderName, Label, Description, IconFilename ) \
    HIObject RegisterBox##ClassName##Create( HIObject /*pOwner*/,const char* pName,void * /*pData*/) \
    { \
      ClassName *Class = new ClassName(pName); \
        Class->mAllocated = true; \
        Class->UniqueName = UniqueNameStr; \
        if (Class->FBCreate()) { \
            return Class->GetHIObject(); \
        } else { \
            delete Class; \
            return NULL; \
        } \
    } \
\
    FBLibraryModule( ClassName )    \
    {\
        FBRegisterObject(ClassName##R1,"Boxes",UniqueNameStr,Description,RegisterBox##ClassName##Create,true, IconFilename );\
        FBRegisterObject(ClassName##R2,"Boxes/Functions/"FolderName,Label,Description,RegisterBox##ClassName##Create,true, IconFilename );\
        FBRegisterObject(ClassName##R3,"FbxStorable/Box",UniqueNameStr,Description,RegisterBox##ClassName##Create,true, IconFilename ); \
    }

#define FBRegisterDevice( UniqueNameStr, ClassName, Label, Description, IconFilename ) \
    HIObject RegisterDevice##ClassName##Create( HIObject /*pOwner*/,const char* pName,void * /*pData*/) \
    { \
      ClassName *Class = new ClassName(pName); \
        Class->mAllocated = true; \
        Class->UniqueName = UniqueNameStr; \
        if (Class->FBCreate()) { \
            return Class->GetHIObject(); \
        } else { \
            delete Class; \
            return NULL; \
        } \
    } \
\
    FBLibraryModule( ClassName )    \
    {   \
        FBRegisterObject(ClassName##R1,"Boxes/Devices",Label,Description,RegisterDevice##ClassName##Create,true, IconFilename );\
        FBRegisterObject(ClassName##R2,"FbxStorable/Device",UniqueNameStr,Description,RegisterDevice##ClassName##Create,true, IconFilename ); \
    }

#define FBRegisterOnlineDevice( UniqueNameStr, ClassName, Label, Description, IconFilename ) \
    HIObject RegisterDevice##ClassName##Create( HIObject /*pOwner*/,const char* pName,void * /*pData*/) \
    { \
      ClassName *Class = new ClassName(pName); \
        Class->mAllocated = true; \
        Class->UniqueName = UniqueNameStr; \
        if (Class->FBCreate()) { \
            return Class->GetHIObject(); \
        } else { \
            delete Class; \
            return NULL; \
        } \
    } \
\
    FBLibraryModule( ClassName )    \
    {   \
        if( FBGetLicense() >= kFBLicenseOnline )    \
        {   \
            FBRegisterObject(ClassName##R1,"Boxes/Devices",Label,Description,RegisterDevice##ClassName##Create, true, IconFilename );\
            FBRegisterObject(ClassName##R2,"FbxStorable/Device",UniqueNameStr,Description,RegisterDevice##ClassName##Create, true, IconFilename ); \
        }   \
    }


// FBBox
__FB_FORWARD( FBBox );
FB_FORWARD( FBFbxObject );

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


    virtual FBAnimationNode* AnimationNodeInCreate  (kReference pUserId,const char * pName ,const char * pDataType,bool pIsPublic=false,double *pMin=NULL,double *pMax=NULL,bool pUserData=false);
    virtual FBAnimationNode* AnimationNodeOutCreate (kReference pUserId,const char * pName ,const char * pDataType,bool pIsPublic=false,double *pMin=NULL,double *pMax=NULL,bool pUserData=false);

    virtual bool EvaluateAnimationNodes( FBEvaluateInfo* pEvaluateInfo );

    virtual bool AnimationNodeNotify( FBAnimationNode* pAnimationNode, FBEvaluateInfo* pEvaluateInfo );


    virtual bool FbxStore(  FBFbxObject* pFbxObject, kFbxObjectStore pStoreWhat );
    virtual bool FbxRetrieve(FBFbxObject* pFbxObject, kFbxObjectStore pStoreWhat );

    virtual bool AnimationNodeDestroy( FBAnimationNode* pAnimationNode );

    virtual bool AnimationNodeIsUserData( FBAnimationNode* pAnimationNode );


    virtual FBAnimationNode* AnimationNodeInGet();
    virtual FBAnimationNode* AnimationNodeOutGet();

    const char* UniqueName;                 
    virtual const char* FbxGetObjectSubType();
    virtual const char* FbxGetObjectType(); 

    IObject_Declare(Implementation);    // Interface to IObject.

    FBPropertyBool Animatable;          
    FBPropertyBool Live;                
    FBPropertyBool RecordMode;          
};


#ifndef FB_KERNEL 

// FBHandle
__FB_FORWARD( FBHandle );

class FBSDK_DLL FBHandle : public FBBox {
    __FBClassDeclare( FBHandle, FBBox );

public:
    FBHandle( const char* pName, HIObject pObject=NULL );

    void Select();

    FBPropertyListObject Follow;                
    FBPropertyListObject Manipulate;            
    FBPropertyListObject ManipulateTranslation; 
    FBPropertyListObject ManipulateRotation;    
    FBPropertyListObject ManipulateScaling;     
    FBPropertyListObject Image;                 

private:

    FBHandle( const FBHandle& );
    FBHandle& operator=( const FBHandle& );
};


// FBPropertyListHandle
FB_DEFINE_LIST( FBSDK_DLL, Handle );
FB_FORWARD( FBPropertyListHandle );

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

#endif

// FBPropertyListModelTemplate
__FB_FORWARD    ( FBModelTemplate   );
__FB_FORWARD    ( FBPropertyListModelTemplate   );
FB_DEFINE_LIST  ( FBSDK_DLL, ModelTemplate      );

class FBSDK_DLL FBPropertyListModelTemplate : public FBPropertyListComponentBase
{
public:
    int  Add    ( FBModelTemplate* pItem );
    virtual void RemoveAt( int pIndex );
    FBModelTemplate* operator[](int pIndex);
    virtual int GetCount();
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    inline virtual FBComponent* GetAt(int pIndex) { return (FBComponent*)operator[](pIndex); }
private:
    inline virtual int Add  ( FBComponent* pItem ) { return Add((FBModelTemplate*)pItem); }
#endif
};

// FBPropertyListModelTemplateBinding
__FB_FORWARD( FBModelTemplateBinding );
__FB_FORWARD( FBPropertyListModelTemplateBinding );
typedef class FBSDK_DLL FBPropertyBaseList< FBAnimationNode* > FBPropertyBaseListModelTemplateBinding;

class FBSDK_DLL FBPropertyListModelTemplateBinding : public FBPropertyListComponentBase
{
public:
    virtual int Add( FBAnimationNode* pItem );
    
    virtual void RemoveAt( int pIndex );
    FBAnimationNode* operator[](int pIndex);

    virtual int  GetCount();
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    inline virtual FBComponent* GetAt(int pIndex) { return (FBComponent*)operator[](pIndex); }
private:
    inline virtual int Add  ( FBComponent* pItem ) { return Add((FBAnimationNode*)pItem); }
#endif
};

// FBModelTemplate
__FB_FORWARD( FBModelTemplate);

enum FBModelTemplateStyle { 
    kFBModelTemplateNone,               
    kFBModelTemplateNull,               
    kFBModelTemplateMarker,             
    kFBModelTemplateRoot,               
    kFBModelTemplateSensor,             
    kFBModelTemplateSkeleton,           
    kFBModelTemplateCamera,             
    kFBModelTemplateGeometry,           
    kFBModelTemplateCameraInterest,     
    kFBModelTemplateLight,              
    kFBModelTemplateOptical             
 };

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

    void Init();
public:
    FBModelTemplate(HIObject pObject=NULL);

    FBModelTemplate(const char *pPrefix,const char *pName, FBModelTemplateStyle pStyle);

    FBPropertyListModelTemplate         Children;               
    FBPropertyListModelTemplateBinding  Bindings;               

    FBPropertyString                    Prefix;                 
    FBPropertyModel                     Model;                  
    FBPropertyVector3d                  DefaultTranslation;     
    FBPropertyVector3d                  DefaultRotation;        
    FBPropertyVector3d                  DefaultScaling;         

    friend class FBDevice;
};

// FBPropertyListDevice
__FB_FORWARD    ( FBDevice );
__FB_FORWARD    ( FBPropertyListDevice );

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

// FBDeviceNotifyInfo
FB_FORWARD( FBDeviceNotifyInfo );

class FBSDK_DLL FBDeviceNotifyInfo 
{
public:
    FBTime &GetSystemTime();

    FBTime &GetLocalTime();

    void SetLocalTime( const FBTime & ); 
    
    int GetSyncCount();

    FBEvaluateInfo& GetEvaluateInfo();
};

// FBDeviceInstrument
__FB_FORWARD( FBDeviceInstrument );
class FBSDK_DLL FBDeviceInstrument : public FBComponent
{
    __FBClassDeclare( FBDeviceInstrument, FBComponent );
  public:
    FBDeviceInstrument(FBDevice* pDevice);
    virtual bool InstrumentWriteData( FBEvaluateInfo* pEvaluateInfo );
    virtual void InstrumentRecordFrame( FBTime pRecordTime, FBDeviceNotifyInfo& pNotifyInfo );

    virtual bool FbxStore( FBFbxObject* pFbxObject, kFbxObjectStore pStoreWhat );
    virtual bool FbxRetrieve( FBFbxObject* pFbxObject, kFbxObjectStore pStoreWhat );

    FBPropertyDevice            Device;         
    FBPropertyBool              Active;         
    FBPropertyModelTemplate     ModelTemplate;  
};
FB_DEFINE_COMPONENT( FBSDK_DLL, DeviceInstrument );

// FBPropertyListDeviceInstrument
__FB_FORWARD( FBPropertyListDeviceInstrument );
FB_DEFINE_LIST( FBSDK_DLL, DeviceInstrument );
class FBSDK_DLL FBPropertyListDeviceInstrument : public FBPropertyListComponentBase
{
  public:
    virtual int  Add    ( HFBDeviceInstrument pItem );
    virtual void RemoveAt( int pIndex );
    FBDeviceInstrument* operator[](int pIndex);
    virtual int GetCount();
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    inline virtual FBComponent* GetAt(int pIndex) { return (FBComponent*)operator[](pIndex); }
private:
    inline virtual int Add  ( FBComponent* pItem ) { return Add((FBDeviceInstrument*)pItem); }
#endif
};

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

    void    Sync(int pSyncId);

    int GetSyncCount();
    
    FBTime  GetTimeOfLastSync();
    
    FBTime  GetTimeOfNextSync();

    FBPropertyBool              Active;                 
    FBPropertyTime              SamplingPeriod;         
};
FB_DEFINE_COMPONENT( FBSDK_DLL, SyncReference );


// FBDevice

enum FBDeviceSamplingMode   { 
    kFBHardwareTimestamp,       
    kFBHardwareFrequency,       
    kFBAutoFrequency,           
    kFBSoftwareTimestamp        
};
FB_DEFINE_ENUM( FBSDK_DLL, DeviceSamplingMode );

enum FBCommType {
    kFBCommTypeNone         = 0,        
    kFBCommTypeSerial       = 1<<0,     
    kFBCommTypeNetworkTCP   = 1<<1,     
    kFBCommTypeNetworkUDP   = 1<<2,     
    kFBCommTypeSharedMemory = 1<<3,     
    kFBCommTypeSimulator    = 1<<4,     
    kFBCommTypeOther        = 1<<5      
};

typedef class FBSDK_DLL FBArrayTemplate<FBModel*> FBModelList;
__FB_FORWARD( FBDevice );

class FBSDK_DLL FBDevice : public FBBox {
    __FBClassDeclare( FBDevice,FBBox );
public:
    enum kDeviceOperations { 
        kOpInit,            
        kOpStart,           
        kOpAutoDetect,      
        kOpStop,            
        kOpReset,           
        kOpDone             
    };

    enum kDeviceIOs { 
        kIOStopModeRead,    
        kIOPlayModeRead,    
        kIOStopModeWrite,   
        kIOPlayModeWrite    
    };

    enum kTransportMode    {        
        kPreparePlay,       
        kPlayReady,         
        kPlayStop,          
        kStop,              
        kPlay,              
        kJog,               
        kPlayReverse        
    };

    FBDevice(const char * pName,HIObject pObject=NULL);

    // See FBBox class
    virtual bool FBCreate   ();
    virtual void FBDestroy  ();

    // See FBBox class
    virtual FBAnimationNode* AnimationNodeInCreate (kReference pUserId,const char * pName ,const char * pDataType,bool pIsPublic=true,double *pMin=NULL,double *pMax=NULL,bool pUserData=false);
    virtual FBAnimationNode* AnimationNodeOutCreate(kReference pUserId,const char * pName ,const char * pDataType,bool pIsPublic=true,double *pMin=NULL,double *pMax=NULL,bool pUserData=false);

    virtual bool DeviceOperation( kDeviceOperations pOperation );

    virtual void DeviceTransportNotify( kTransportMode pMode, FBTime pTime, FBTime pSystem );

    virtual void DeviceIONotify( kDeviceIOs  pAction, FBDeviceNotifyInfo& pDeviceNotifyInfo );

    virtual bool DeviceEvaluationNotify( kTransportMode pMode,FBEvaluateInfo* pEvaluateInfo );

    virtual bool ModelTemplateBindNotify( FBModel* pModel,int pIndex, FBModelTemplate* pModelTemplate );

    virtual bool ModelTemplateUnBindNotify( int pIndex, FBModelTemplate* pModelTemplate );

    FBModel* ModelBindingCreate();

    void ModelBindingRootsList(FBModelList& pList);

    virtual bool AnimationNodeNotify( FBAnimationNode* pAnimationNode, FBEvaluateInfo* pEvaluateInfo ) override;

    virtual const char* FbxGetObjectType() override;    


    virtual bool FbxStore   ( FBFbxObject* pFbxObject, kFbxObjectStore pStoreWhat ) override;
    virtual bool FbxRetrieve( FBFbxObject* pFbxObject, kFbxObjectStore pStoreWhat ) override;

    virtual void DeviceSendCommand( kDeviceOperations pOperation );

    IObject_Declare( Implementation );              // Interface to IObject

    FBPropertyString                IconFilename;           
    FBPropertyString                Status;                 
    FBPropertyString                Information;            
    FBPropertyString                HardwareVersionInfo;    
    FBPropertyTime                  SamplingPeriod;         
    FBPropertyBool                  Online;                 
                                    
    FBPropertyEvent                 OnStatusChange;         
                                    
    FBModelTemplate                 ModelTemplate;          
    FBPropertyModel                 ModelBindingRoot;       

    FBPropertyDeviceSamplingMode    SamplingMode;           
    FBPropertyInt                   CommType;               
                                    
    FBPropertyListDeviceInstrument  Instruments;    

    FBPropertyTime                  RecordingStartTime;     
    FBPropertyTime                  RecordingStopTime;      

    void AckOneSampleReceived();

    void AckOneBadSampleReceived();

    void AckOneSampleSent();

    virtual void RecordingInitAnimation(FBAnimationNode* pAnimationNode);

    virtual void RecordingDoneAnimation(FBAnimationNode* pAnimationNode);

    friend class __FBDevice;
    friend class DataFBDeviceOptical;
};

#ifndef FBSDK_LEAN_AND_MEAN

__FB_FORWARD( FBDeviceGlove );

class FBSDK_DLL FBDeviceGlove : public FBDevice {
    __FBClassDeclare( FBDeviceGlove, FBDevice );
public:
    enum kHandModelPart {   // Parents :
        
        kPartRoot,          // No parent
        kPartPalm,          // kPartRoot

        // Thumb
        kPartThumbA,        // kPartPalm
        kPartThumbB,        // kPartThumbA
        kPartThumbC,        // kPartThumbB
        kPartThumbD,        // kPartThumbC

        // Index
        kPartIndexA,        // kPartPalm
        kPartIndexB,        // kPartIndexA
        kPartIndexC,        // kPartIndexB
        kPartIndexD,        // kPartIndexC

        // Middle
        kPartMiddleA,       // kPartPalm
        kPartMiddleB,       // kPartMiddleA
        kPartMiddleC,       // kPartMiddleB
        kPartMiddleD,       // kPartMiddleC

        // Ring
        kPartRingA,         // kPartPalm
        kPartRingB,         // kPartRingA
        kPartRingC,         // kPartRingB
        kPartRingD,         // kPartRingC

        // Little
        kPartLittleA,       // kPartPalm
        kPartLittleB,       // kPartLittleA
        kPartLittleC,       // kPartLittleB
        kPartLittleD,       // kPartLittleC

        kPartMax
    };

    class FBSDK_DLL GloveChannel
    {   
    public:
        GloveChannel( FBAnimationNode* pAnimNode );
        
        virtual ~GloveChannel();
    
        FBString        GetName ();

        void            SetName ( FBString pName );
    
    protected:
        FBString                Name;              
    
    public:
        bool                    Enabled;           
        FBAnimationNode*        AnimNode;          
    };


    FBDeviceGlove( const char* pName, HIObject pObject=NULL );

    virtual void RecordingInitAnimation( FBAnimationNode* pAnimationNode );

    virtual void RecordingDoneAnimation( FBAnimationNode* pAnimationNode );
    
protected:
    void InitializeModelGeometry();

    void VectorToModelPartAngle( kHandModelPart pPartIndex, FBVector3d& pVector );

    FBAnimationNode* GetModelRotationNode( kHandModelPart pPartIndex );

public:
    FBArrayTemplate<GloveChannel*>      Channels;       
    
    FBPropertyBool                      LeftHand;       
};

#endif

#ifdef FBSDKUseNamespace
    }
#endif
#endif