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);
 
        enum ECandidateAction
        {
            eCandidateAccept,                       
            eCandidateIntercept,                    
            eCandidateInterceptAfterEvaluation      
        };
 
 
        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 ResolveCandidate( FBAnimationNode* pAnimationNode, FBEvaluateInfo* pEvaluateInfo );
 
        virtual ECandidateAction SetGlobalCandidate( FBAnimationNode* pAnimationNode, double* pData, FBEvaluateInfo* pEvaluateInfo );
 
        virtual ECandidateAction SetStdCandidate( FBAnimationNode* pAnimationNode, double* pData, 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 void AnimationNodesOutDisableIfNotWritten( FBEvaluateInfo* pEvaluateInfo );
 
 
        virtual FBAnimationNode* AnimationNodeInGet();
        virtual FBAnimationNode* AnimationNodeOutGet();
 
        const char* UniqueName;                 
        virtual const char* FbxGetObjectSubType();
        virtual const char* FbxGetObjectType(); 
 
        IObject_Declare(override);  // Interface to IObject.
 
        virtual int GetOutConnectorCount() const;
 
        virtual int GetInConnectorCount() const;
 
        virtual FBAnimationNode* GetOutConnector( int pIndex ) const;
 
        virtual FBAnimationNode* GetInConnector( int pIndex ) const;
 
        FBPropertyBool Animatable;          
        FBPropertyBool Live;                
        FBPropertyBool RecordMode;          
    };
 
 
#ifndef K_NO_UI
 
    // 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    ( FBDeviceInstrument* 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   () override;
        virtual void FBDestroy  () override;
 
        // 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) override;
        virtual FBAnimationNode* AnimationNodeOutCreate(kReference pUserId,const char * pName ,const char * pDataType,bool pIsPublic=true,double *pMin=NULL,double *pMax=NULL,bool pUserData=false) override;
 
        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( override );                // Interface to IObject
 
        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 ) override;
 
        virtual void RecordingDoneAnimation( FBAnimationNode* pAnimationNode ) override;
 
    protected:
        void InitializeModelGeometry();
 
        void VectorToModelPartAngle( kHandModelPart pPartIndex, FBVector3d& pVector );
 
        FBAnimationNode* GetModelRotationNode( kHandModelPart pPartIndex );
 
    public:
        FBArrayTemplate<GloveChannel*>      Channels;       
 
        FBPropertyBool                      LeftHand;       
    };
 
#endif
 
#ifdef FBSDKUseNamespace
}
#endif
#endif