fbcore.h

Go to the documentation of this file.

#ifndef __FBCORE_H__

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,char * pName,void *pData);

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

#define FBBoxImplementation( ThisComponent ) \
    FBClassImplementation( ThisComponent )

#define FBDeviceDeclare( ClassName, Parent ) \
    FBClassDeclare( ClassName,Parent ); \
  public: \
    ClassName(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*/,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*/,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*/,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(char *pName, HIObject pObject=NULL);


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

    virtual bool EvaluateAnimationNodes( HFBEvaluateInfo pEvaluateInfo );

    virtual bool AnimationNodeNotify( HFBAnimationNode pAnimationNode, HFBEvaluateInfo pEvaluateInfo );


    virtual bool FbxStore(  HFBFbxObject pFbxObject, kFbxObjectStore pStoreWhat );
    virtual bool FbxRetrieve(HFBFbxObject pFbxObject, kFbxObjectStore pStoreWhat );

    virtual bool AnimationNodeDestroy( HFBAnimationNode pAnimationNode );

    virtual bool AnimationNodeIsUserData( HFBAnimationNode pAnimationNode );


    virtual HFBAnimationNode AnimationNodeInGet();
    virtual HFBAnimationNode AnimationNodeOutGet();

    char* UniqueName;                   
    virtual char* FbxGetObjectSubType();
    virtual 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( 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    ( HFBModelTemplate 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< HFBAnimationNode > FBPropertyBaseListModelTemplateBinding;

class FBSDK_DLL FBPropertyListModelTemplateBinding : public FBPropertyListComponentBase
{
public:
    virtual int Add( HFBAnimationNode 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(char *pPrefix,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();

    int GetSyncCount();

};

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

    virtual bool FbxStore( HFBFbxObject pFbxObject, kFbxObjectStore pStoreWhat );
    virtual bool FbxRetrieve( HFBFbxObject 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
};

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

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

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

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

    // See FBBox class
    virtual HFBAnimationNode AnimationNodeInCreate (kReference pUserId,char * pName ,char * pDataType,bool pIsPublic=true,double *pMin=NULL,double *pMax=NULL,bool pUserData=false);
    virtual HFBAnimationNode AnimationNodeOutCreate(kReference pUserId,char * pName ,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,HFBEvaluateInfo pEvaluateInfo );

    virtual bool ModelTemplateBindNotify( HFBModel pModel,int pIndex, HFBModelTemplate pModelTemplate );

    virtual bool ModelTemplateUnBindNotify( int pIndex, HFBModelTemplate pModelTemplate );

    virtual bool AnimationNodeNotify( HFBAnimationNode pAnimationNode, HFBEvaluateInfo pEvaluateInfo ) override;

    virtual char* FbxGetObjectType() override;  


    virtual bool FbxStore   ( HFBFbxObject pFbxObject, kFbxObjectStore pStoreWhat ) override;
    virtual bool FbxRetrieve( HFBFbxObject 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;          

    FBPropertyDeviceSamplingMode    SamplingMode;           
    FBPropertyInt                   CommType;               
                                    
    FBPropertyListDeviceInstrument  Instruments;    

    FBPropertyTime                  RecordingStartTime;     
    FBPropertyTime                  RecordingStopTime;      

    void AckOneSampleReceived();

    void AckOneBadSampleReceived();

    void AckOneSampleSent();

    virtual void RecordingInitAnimation(HFBAnimationNode pAnimationNode);

    virtual void RecordingDoneAnimation(HFBAnimationNode 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( HFBAnimationNode pAnimNode );
        
        virtual ~GloveChannel();
    
        FBString        GetName ();

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


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

    virtual void RecordingInitAnimation( HFBAnimationNode pAnimationNode );

    virtual void RecordingDoneAnimation( HFBAnimationNode pAnimationNode );
    
protected:
    void InitializeModelGeometry();

    void VectorToModelPartAngle( kHandModelPart pPartIndex, FBVector3d& pVector );

    HFBAnimationNode GetModelRotationNode( kHandModelPart pPartIndex );

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

#endif

#ifdef FBSDKUseNamespace
    }
#endif
#endif

---

Please send us your comments about this page.