fbcharacter.h

Go to the documentation of this file.

#ifndef __FBCHARACTER_H__
#define __FBCHARACTER_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/fbconstraint.h>
#include <fbsdk/fbcycleanalysisnode.h>
#include <fbsdk/fbcharacterextension.h>

#ifdef FBSDKUseNamespace
    namespace FBSDKNamespace {
#endif

class FBCharacterSolver;

enum FBSkeletonNodeId
{   
    kFBSkeletonInvalidIndex = -1, 
    kFBSkeletonHipsIndex = 0, 
    kFBSkeletonLeftHipIndex,
    kFBSkeletonLeftKneeIndex,
    kFBSkeletonLeftAnkleIndex,
    kFBSkeletonLeftFootIndex,
    kFBSkeletonRightHipIndex,
    kFBSkeletonRightKneeIndex,
    kFBSkeletonRightAnkleIndex,
    kFBSkeletonRightFootIndex,
    kFBSkeletonWaistIndex,
    kFBSkeletonChestIndex,
    kFBSkeletonLeftCollarIndex,
    kFBSkeletonLeftShoulderIndex,
    kFBSkeletonLeftElbowIndex,
    kFBSkeletonLeftWristIndex,
    kFBSkeletonRightCollarIndex,
    kFBSkeletonRightShoulderIndex,
    kFBSkeletonRightElbowIndex,
    kFBSkeletonRightWristIndex,
    kFBSkeletonNeckIndex,
    kFBSkeletonHeadIndex,
    kFBSkeletonLeftThumbAIndex,
    kFBSkeletonLeftThumbBIndex,
    kFBSkeletonLeftThumbCIndex,
    kFBSkeletonLeftIndexAIndex,
    kFBSkeletonLeftIndexBIndex,
    kFBSkeletonLeftIndexCIndex,
    kFBSkeletonLeftMiddleAIndex,
    kFBSkeletonLeftMiddleBIndex,
    kFBSkeletonLeftMiddleCIndex,
    kFBSkeletonLeftRingAIndex,
    kFBSkeletonLeftRingBIndex,
    kFBSkeletonLeftRingCIndex,
    kFBSkeletonLeftPinkyAIndex,
    kFBSkeletonLeftPinkyBIndex,
    kFBSkeletonLeftPinkyCIndex,
    kFBSkeletonRightThumbAIndex,
    kFBSkeletonRightThumbBIndex,
    kFBSkeletonRightThumbCIndex,
    kFBSkeletonRightIndexAIndex,
    kFBSkeletonRightIndexBIndex,
    kFBSkeletonRightIndexCIndex,
    kFBSkeletonRightMiddleAIndex,
    kFBSkeletonRightMiddleBIndex,
    kFBSkeletonRightMiddleCIndex,
    kFBSkeletonRightRingAIndex,
    kFBSkeletonRightRingBIndex,
    kFBSkeletonRightRingCIndex,
    kFBSkeletonRightPinkyAIndex,
    kFBSkeletonRightPinkyBIndex,
    kFBSkeletonRightPinkyCIndex,
    kFBSkeletonReferenceIndex,
    kFBSkeletonLastIndex
};

enum FBBodyNodeId 
{
    kFBInvalidNodeId = -1,
    kFBHipsNodeId = 0,             
    kFBLeftHipNodeId,              
    kFBLeftKneeNodeId,             
    kFBLeftAnkleNodeId,            
    kFBLeftFootNodeId,             
    kFBRightHipNodeId,             
    kFBRightKneeNodeId,            
    kFBRightAnkleNodeId,           
    kFBRightFootNodeId,            
    kFBWaistNodeId,             
    kFBChestNodeId,             
    kFBLeftCollarNodeId,           
    kFBLeftShoulderNodeId,         
    kFBLeftElbowNodeId,            
    kFBLeftWristNodeId,            
    kFBRightCollarNodeId,          
    kFBRightShoulderNodeId,        
    kFBRightElbowNodeId,           
    kFBRightWristNodeId,           
    kFBNeckNodeId,                 
    kFBHeadNodeId,                 
    kFBLeftHipRollNodeId,          
    kFBLeftKneeRollNodeId,         
    kFBRightHipRollNodeId,         
    kFBRightKneeRollNodeId,        
    kFBLeftShoulderRollNodeId,     
    kFBLeftElbowRollNodeId,        
    kFBRightShoulderRollNodeId,    
    kFBRightElbowRollNodeId,       
    kFBSpine2NodeId,               
    kFBSpine3NodeId,               
    kFBSpine4NodeId,               
    kFBSpine5NodeId,               
    kFBSpine6NodeId,               
    kFBSpine7NodeId,               
    kFBSpine8NodeId,               
    kFBSpine9NodeId,               
    kFBLeftThumbANodeId,           
    kFBLeftThumbBNodeId,           
    kFBLeftThumbCNodeId,           
    kFBLeftIndexANodeId,           
    kFBLeftIndexBNodeId,           
    kFBLeftIndexCNodeId,           
    kFBLeftMiddleANodeId,          
    kFBLeftMiddleBNodeId,          
    kFBLeftMiddleCNodeId,          
    kFBLeftRingANodeId,            
    kFBLeftRingBNodeId,            
    kFBLeftRingCNodeId,            
    kFBLeftPinkyANodeId,           
    kFBLeftPinkyBNodeId,           
    kFBLeftPinkyCNodeId,           
    kFBRightThumbANodeId,          
    kFBRightThumbBNodeId,          
    kFBRightThumbCNodeId,          
    kFBRightIndexANodeId,          
    kFBRightIndexBNodeId,          
    kFBRightIndexCNodeId,          
    kFBRightMiddleANodeId,         
    kFBRightMiddleBNodeId,         
    kFBRightMiddleCNodeId,         
    kFBRightRingANodeId,           
    kFBRightRingBNodeId,           
    kFBRightRingCNodeId,           
    kFBRightPinkyANodeId,          
    kFBRightPinkyBNodeId,          
    kFBRightPinkyCNodeId,          
    kFBReferenceNodeId,            
    // -- New bones for 2.0 --
    kFBLeftThumbInNodeId,          
    kFBLeftThumbDNodeId,           
    kFBLeftIndexInNodeId,          
    kFBLeftIndexDNodeId,           
    kFBLeftMiddleInNodeId,         
    kFBLeftMiddleDNodeId,          
    kFBLeftRingInNodeId,           
    kFBLeftRingDNodeId,            
    kFBLeftPinkyInNodeId,          
    kFBLeftPinkyDNodeId,           
    kFBRightThumbInNodeId,         
    kFBRightThumbDNodeId,          
    kFBRightIndexInNodeId,         
    kFBRightIndexDNodeId,          
    kFBRightMiddleInNodeId,        
    kFBRightMiddleDNodeId,         
    kFBRightRingInNodeId,          
    kFBRightRingDNodeId,           
    kFBRightPinkyInNodeId,         
    kFBRightPinkyDNodeId,          

    kFBLeftExtraFingerInNodeId,    
    kFBLeftExtraFingerANodeId,     
    kFBLeftExtraFingerBNodeId,     
    kFBLeftExtraFingerCNodeId,     
    kFBLeftExtraFingerDNodeId,     
    kFBRightExtraFingerInNodeId,   
    kFBRightExtraFingerANodeId,    
    kFBRightExtraFingerBNodeId,    
    kFBRightExtraFingerCNodeId,    
    kFBRightExtraFingerDNodeId,    

    kFBLeftFootThumbInNodeId,      
    kFBLeftFootThumbANodeId,       
    kFBLeftFootThumbBNodeId,       
    kFBLeftFootThumbCNodeId,       
    kFBLeftFootThumbDNodeId,       
    kFBLeftFootIndexInNodeId,      
    kFBLeftFootIndexANodeId,       
    kFBLeftFootIndexBNodeId,       
    kFBLeftFootIndexCNodeId,       
    kFBLeftFootIndexDNodeId,       
    kFBLeftFootMiddleInNodeId,     
    kFBLeftFootMiddleANodeId,      
    kFBLeftFootMiddleBNodeId,      
    kFBLeftFootMiddleCNodeId,      
    kFBLeftFootMiddleDNodeId,      
    kFBLeftFootRingInNodeId,       
    kFBLeftFootRingANodeId,        
    kFBLeftFootRingBNodeId,        
    kFBLeftFootRingCNodeId,        
    kFBLeftFootRingDNodeId,        
    kFBLeftFootPinkyInNodeId,      
    kFBLeftFootPinkyANodeId,       
    kFBLeftFootPinkyBNodeId,       
    kFBLeftFootPinkyCNodeId,       
    kFBLeftFootPinkyDNodeId,       
    kFBRightFootThumbInNodeId,     
    kFBRightFootThumbANodeId,      
    kFBRightFootThumbBNodeId,      
    kFBRightFootThumbCNodeId,      
    kFBRightFootThumbDNodeId,      
    kFBRightFootIndexInNodeId,     
    kFBRightFootIndexANodeId,      
    kFBRightFootIndexBNodeId,      
    kFBRightFootIndexCNodeId,      
    kFBRightFootIndexDNodeId,      
    kFBRightFootMiddleInNodeId,    
    kFBRightFootMiddleANodeId,     
    kFBRightFootMiddleBNodeId,     
    kFBRightFootMiddleCNodeId,     
    kFBRightFootMiddleDNodeId,     
    kFBRightFootRingInNodeId,      
    kFBRightFootRingANodeId,       
    kFBRightFootRingBNodeId,       
    kFBRightFootRingCNodeId,       
    kFBRightFootRingDNodeId,       
    kFBRightFootPinkyInNodeId,     
    kFBRightFootPinkyANodeId,      
    kFBRightFootPinkyBNodeId,      
    kFBRightFootPinkyCNodeId,      
    kFBRightFootPinkyDNodeId,      

    kFBLeftExtraFootFingerInNodeId,        
    kFBLeftExtraFootFingerANodeId,         
    kFBLeftExtraFootFingerBNodeId,         
    kFBLeftExtraFootFingerCNodeId,         
    kFBLeftExtraFootFingerDNodeId,         
    kFBRightExtraFootFingerInNodeId,       
    kFBRightExtraFootFingerANodeId,        
    kFBRightExtraFootFingerBNodeId,        
    kFBRightExtraFootFingerCNodeId,        
    kFBRightExtraFootFingerDNodeId,        

    kFBLeftHandNodeId,             
    kFBRightHandNodeId,            
    kFBNeck1NodeId,                
    kFBNeck2NodeId,                
    kFBNeck3NodeId,                
    kFBNeck4NodeId,                
    kFBNeck5NodeId,                
    kFBNeck6NodeId,                
    kFBNeck7NodeId,                
    kFBNeck8NodeId,                
    kFBNeck9NodeId,                

    kFBHipsTranslationNodeId,       
    
    // -- HIK 2016.5 new leaf roll nodes --
    // this should be consistent with HipsNodeId defined in kernel\humanik.h
    // so HIKNodeTypeFromNodeId & HIKNodeIndexFromNodeId could map to correct
    // data.
    // kFBLastNodeId_Old represent last id before introduction of new roll bone for
    // previous solvers. First new roll bone id equals to ensure continuity
    kFBLastNodeId_Old, 
    kFBLeftHipRollNode1Id = kFBLastNodeId_Old,              
    kFBLeftKneeRollNode1Id,                                 
    kFBRightHipRollNode1Id,                                 
    kFBRightKneeRollNode1Id,                                
    kFBLeftShoulderRollNode1Id,                             
    kFBLeftElbowRollNode1Id,                                
    kFBRightShoulderRollNode1Id,                            
    kFBRightElbowRollNode1Id,                               

    kFBLeftHipRollNode2Id,                                  
    kFBLeftKneeRollNode2Id,                                 
    kFBRightHipRollNode2Id,                                 
    kFBRightKneeRollNode2Id,                                
    kFBLeftShoulderRollNode2Id,                             
    kFBLeftElbowRollNode2Id,                                
    kFBRightShoulderRollNode2Id,                            
    kFBRightElbowRollNode2Id,                               

    kFBLeftHipRollNode3Id,                                  
    kFBLeftKneeRollNode3Id,                                 
    kFBRightHipRollNode3Id,                                 
    kFBRightKneeRollNode3Id,                                
    kFBLeftShoulderRollNode3Id,                             
    kFBLeftElbowRollNode3Id,                                
    kFBRightShoulderRollNode3Id,                            
    kFBRightElbowRollNode3Id,                               

    kFBLeftHipRollNode4Id,                                  
    kFBLeftKneeRollNode4Id,                                 
    kFBRightHipRollNode4Id,                                 
    kFBRightKneeRollNode4Id,                                
    kFBLeftShoulderRollNode4Id,                             
    kFBLeftElbowRollNode4Id,                                
    kFBRightShoulderRollNode4Id,                            
    kFBRightElbowRollNode4Id,                               

    kFBLeftHipRollNode5Id,                                  
    kFBLeftKneeRollNode5Id,                                 
    kFBRightHipRollNode5Id,                                 
    kFBRightKneeRollNode5Id,                                
    kFBLeftShoulderRollNode5Id,                             
    kFBLeftElbowRollNode5Id,                                
    kFBRightShoulderRollNode5Id,                            
    kFBRightElbowRollNode5Id,                               

    kFBLastNodeId                   
};

const int kFBLastActorNodeId = ( kFBHeadNodeId + 1 );

enum FBEffectorId
{
    kFBInvalidEffectorId = -1,         
    kFBHipsEffectorId = 0,             
    kFBLeftAnkleEffectorId,            
    kFBRightAnkleEffectorId,           
    kFBLeftWristEffectorId,            
    kFBRightWristEffectorId,           
    kFBLeftKneeEffectorId,             
    kFBRightKneeEffectorId,            
    kFBLeftElbowEffectorId,            
    kFBRightElbowEffectorId,           
    kFBChestOriginEffectorId,          
    kFBChestEndEffectorId,             
    kFBLeftFootEffectorId,             
    kFBRightFootEffectorId,            
    kFBLeftShoulderEffectorId,         
    kFBRightShoulderEffectorId,        
    kFBHeadEffectorId,                 
    kFBLeftHipEffectorId,              
    kFBRightHipEffectorId,             
    // -- New effector for 2.0 --
    kFBLeftHandEffectorId,             
    kFBRightHandEffectorId,            
    kFBLeftHandThumbEffectorId,        
    kFBLeftHandIndexEffectorId,        
    kFBLeftHandMiddleEffectorId,       
    kFBLeftHandRingEffectorId,         
    kFBLeftHandPinkyEffectorId,        
    kFBLeftHandExtraFingerEffectorId,  
    kFBRightHandThumbEffectorId,       
    kFBRightHandIndexEffectorId,       
    kFBRightHandMiddleEffectorId,      
    kFBRightHandRingEffectorId,        
    kFBRightHandPinkyEffectorId,       
    kFBRightHandExtraFingerEffectorId, 
    kFBLeftFootThumbEffectorId,        
    kFBLeftFootIndexEffectorId,        
    kFBLeftFootMiddleEffectorId,       
    kFBLeftFootRingEffectorId,         
    kFBLeftFootPinkyEffectorId,        
    kFBLeftFootExtraFingerEffectorId,  
    kFBRightFootThumbEffectorId,       
    kFBRightFootIndexEffectorId,       
    kFBRightFootMiddleEffectorId,      
    kFBRightFootRingEffectorId,        
    kFBRightFootPinkyEffectorId,       
    kFBRightFootExtraFingerEffectorId, 
    kFBLastEffectorId                  
};

enum FBEffectorSetID
{   
    FBEffectorSetDefault = 0, 
    FBEffectorSetAux1, 
    FBEffectorSetAux2, 
    FBEffectorSetAux3, 
    FBEffectorSetAux4, 
    FBEffectorSetAux5, 
    FBEffectorSetAux6, 
    EFBffectorSetAux7, 
    FBEffectorSetAux8, 
    FBEffectorSetAux9, 
    FBEffectorSetAux10, 
    FBEffectorSetAux11, 
    FBEffectorSetAux12, 
    FBEffectorSetAux13, 
    FBEffectorSetAux14, 
    FBLastEffectorSetIndex 
};

enum FBFloorContactID
{
    FBLeftHandMemberIndex,
    FBRightHandMemberIndex,
    FBLeftFootMemberIndex,
    FBRightFootMemberIndex, 
    FBLastCharacterMember
};

enum FBBodyPartId
{ 
    kFBCtrlSetPartNone = 0,     
    kFBCtrlSetPartHips,         
    kFBCtrlSetPartChest,        
    kFBCtrlSetPartLeftArm,      
    kFBCtrlSetPartRightArm,     
    kFBCtrlSetPartLeftLeg,      
    kFBCtrlSetPartRightLeg,     
    kFBCtrlSetPartHead,         
    kFBCtrlSetPartLeftHand,     
    kFBCtrlSetPartRightHand,    
    kFBCtrlSetPartLeftFoot,     
    kFBCtrlSetPartRightFoot,    
    kFBLastCtrlSetPartIndex     
};



enum FBCharacterInputType
{ 
    kFBCharacterInputActor, 
    kFBCharacterInputCharacter,
    kFBCharacterInputMarkerSet, 
    kFBCharacterOutputMarkerSet, 
    kFBCharacterInputStance,
    kFBCharacterInputMoCap
};
FB_DEFINE_ENUM( FBSDK_DLL, CharacterInputType );

enum FBCharacterKeyingMode
{ 
    kFBCharacterKeyingFullBody, 
    kFBCharacterKeyingBodyPart,
    kFBCharacterKeyingSelection, 
    kFBCharacterKeyingFullBodyNoPull, 
};
FB_DEFINE_ENUM( FBSDK_DLL, CharacterKeyingMode );

enum FBCharacterResetProperties
{
    kFBCharacterResetPropertiesAll,
    kFBCharacterResetPropertiesSolving,
    kFBCharacterResetPropertiesDefinition
};

enum FBCharacterPlotWhere
{
    kFBCharacterPlotOnControlRig,
    kFBCharacterPlotOnSkeleton
};
FB_DEFINE_ENUM( FBSDK_DLL, CharacterPlotWhere );

enum FBCharacterHipsTranslationMode 
{ 
    kFBParamHipsTranslationWorldRigid = 0, 
    kFBParamHipsTranslationBodyRigid, 
    kFBLastHipsTranslationMode 
};
FB_DEFINE_ENUM( FBSDK_DLL, CharacterHipsTranslationMode );

enum FBCharacterRollSolver 
{ 
    kFBParamRollSolver70 = 0, 
    kFBParamRollSolver75, 
    kFBLastRollSolver
};
FB_DEFINE_ENUM( FBSDK_DLL, CharacterRollSolver );

enum FBCharacterContactBehaviour
{
    kFBParamContactNeverSync = 0, 
    kFBParamContactSyncOnKey, 
    kFBParamContactAlwaysSync, 
    kFBLastContactBehaviour
};
FB_DEFINE_ENUM( FBSDK_DLL, CharacterContactBehaviour );

enum FBControlSetType
{
    kFBControlSetTypeNone = 0, 
    kFBControlSetTypeFKIK, 
    kFBControlSetTypeIKOnly
};
FB_DEFINE_ENUM( FBSDK_DLL, ControlSetType );

enum FBSkeletonTrackingState
{
    kFBSkeletonNotTracked = 0,
    kFBSkeletonPositionOnly,
    kFBSkeletonTracked
};
FB_DEFINE_ENUM( FBSDK_DLL, SkeletonTrackingState );

enum FBSkeletonJointTrackingState
{
    kFBSkeletonJointNotTracked = 0,
    kFBSkeletonJointInferred,
    kFBSkeletonJointTracked
};
FB_DEFINE_ENUM( FBSDK_DLL, SkeletonJointTrackingState );

enum FBCalibrationState
{
    FBCalibrationNoRequest = 0,
    FBCalibrationInProcessing,
    FBCalibrationSuccessfully
};
FB_DEFINE_ENUM( FBSDK_DLL, CalibrationState );

enum FBVisibilityState
{
    kFBVisibilityAny,       
    kFBVisibilityAll,       
    kFBVisibilitySome,      
    kFBVisibilityInvalid    
};
FB_DEFINE_ENUM( FBSDK_DLL, VisibilityState );

FBSDK_DLL const char* FBCharacterBodyNodeNameFromId( FBBodyNodeId pBodyNodeId );

FBSDK_DLL const char* FBCharacterEffectorNameFromId( FBEffectorId pEffectorId );

// FBMarkerSet - Marker set for an actor
__FB_FORWARD( FBMarkerSet );
FB_DEFINE_COMPONENT( FBSDK_DLL, MarkerSet );
FB_FORWARD( FBModel );

typedef class FBSDK_DLL FBArrayTemplate<FBModel*> FBModelList;

class FBSDK_DLL FBMarkerSet : public FBComponent
{
    //--- Open Reality declaration.
    __FBClassDeclare( FBMarkerSet, FBComponent );
public:
    FBMarkerSet(const char* pName, HIObject pObject=NULL);

    FBModel* GetReferenceModel( );

    void SetReferenceModel( FBModel* pReferenceModel );

    FBModel* GetMarkerModel( FBSkeletonNodeId pNodeId, int pMarkerIndex );

    void SetMarkerModel( FBSkeletonNodeId pNodeId, int pMarkerIndex, FBModel* pModel );

    bool SetMultipleMarkerModels( FBModelList* pModelList );

    const char* GetMarkerName( FBSkeletonNodeId pNodeId, int pMarkerIndex );

    void SetMarkerName( FBSkeletonNodeId pNodeId, int pMarkerIndex, const char* pMarkerName );


    void GetMarkerTOffset( FBSkeletonNodeId pNodeId, int pMarkerIndex, FBTVector* pTOffset );
    void SetMarkerTOffset( FBSkeletonNodeId pNodeId, int pMarkerIndex, FBTVector* pTOffset );


    void GetMarkerROffset( FBSkeletonNodeId pNodeId, int pMarkerIndex, FBRVector* pROffset );
    void SetMarkerROffset( FBSkeletonNodeId pNodeId, int pMarkerIndex, FBRVector* pROffset );

    bool GetMarkerOriented( FBSkeletonNodeId pNodeId, int pMarkerIndex );

    void SetMarkerOriented( FBSkeletonNodeId pNodeId, int pMarkerIndex, bool pIsOriented );

    bool GetMarkerUsed( FBSkeletonNodeId pNodeId, int pMarkerIndex );

    void SetMarkerUsed( FBSkeletonNodeId pNodeId, int pMarkerIndex, bool pUsed );
    
    int GetMarkerCount( FBSkeletonNodeId pNodeId = kFBSkeletonInvalidIndex );

    int GetUsedMarkerCount( FBSkeletonNodeId pNodeId = kFBSkeletonInvalidIndex );

    int AddMarker( FBSkeletonNodeId pNodeId, FBModel* pModel = NULL, bool pIsOriented = false );

    void SetMarkerSetVisibility(bool pVisibility);

    int GetMarkerSetVisibility();

    bool GetLinkToModelOk();

    void BeginTransaction( );

    void EndTransaction( );

};

// FBControlSet - Control set for an actor
__FB_FORWARD( FBControlSet );
FB_DEFINE_COMPONENT( FBSDK_DLL, ControlSet );

class FBSDK_DLL FBControlSet : public FBComponent
{
    //--- Open Reality declaration.
    __FBClassDeclare( FBControlSet, FBComponent );
public:
    FBControlSet(const char* pName, HIObject pObject=NULL);

    FBModel* GetReferenceModel( );

    const char* GetReferenceName( );

    int         GetIKEffectorIndex(FBModel* pModel);
    FBModel*    GetIKEffectorModel(FBEffectorId pEffectorIndex, int pPivotIndex = 0);
    int         GetIKEffectorPivotCount(FBEffectorId pEffectorIndex);
    const char* GetIKEffectorName(FBEffectorId pEffectorIndex);



    int         GetFKIndex(FBModel* pModel);
    FBModel*    GetFKModel(int pIndex);
    const char* GetFKName(int pIndex);

    int         GetFKCount();



    FBPropertyControlSetType ControlSetType; 
    FBPropertyBool  UseAxis; 
    FBPropertyDouble  FKOpacity; 
};

__FB_FORWARD( FBControlSetState );
class FBSDK_DLL FBControlSetState
{
public:
    void GetNodeMatrix(FBBodyNodeId pNodeId, FBMatrix &pNodeGlobalMatrix);
};

__FB_FORWARD( FBEffectorSetState );
class FBSDK_DLL FBEffectorSetState
{
public:
    void GetEffectorMatrix(FBEffectorId pEffectorId, FBMatrix &pEffectorGlobalMatrix);

    void GetReach(FBEffectorId pEffectorId, double &pReachT, double &pReachR);
};

// FBCharacterMarkerSet - Marker set for an character
__FB_FORWARD( FBCharacterMarkerSet );
FB_DEFINE_COMPONENT( FBSDK_DLL, CharacterMarkerSet );

class FBSDK_DLL FBCharacterMarkerSet : public FBComponent
{
    //--- Open Reality declaration.
    __FBClassDeclare( FBCharacterMarkerSet, FBComponent );
public:
    FBCharacterMarkerSet(const char* pName, HIObject pObject=NULL);

    void        ReadCtrlSetAndEffectorState(FBControlSetState* pFKState, FBEffectorSetState* pIKState, FBEvaluateInfo* pEvaluateInfo);

    FBProperty* GetMarkersProperty(FBBodyNodeId pNodeId);

    FBProperty* GetExtractionProperty(FBBodyNodeId pNodeId);

    FBProperty* GetSnapProperty(FBBodyNodeId pNodeId, FBModelTransformationType pWhat);
};

__FB_FORWARD( FBSkeletonState );
class FBSDK_DLL FBSkeletonState
{
public:
    void GetNodeMatrix(FBSkeletonNodeId pSkeletonId, FBMatrix &pSkeletonGlobalMatrix);
};

// FBActor - Representation of an actor
__FB_FORWARD( FBActor );
FB_DEFINE_COMPONENT( FBSDK_DLL, Actor );

enum FBRecalcMarkerSetOffset
{
    kFBRecalcMarkerSetOffsetTR,         
    kFBRecalcMarkerSetOffsetROnly       
};

class FBSDK_DLL FBActor : public FBConstraint
{
    //--- Open Reality declaration.
    __FBClassDeclare( FBActor, FBConstraint );
public:
    FBActor(const char* pName, HIObject pObject=NULL);

    virtual void FBDelete();

    FBPropertyMarkerSet     MarkerSet;      
    FBPropertyMarkerSet     OutputMarkerSet;

    FBPropertyColor         BodyColor;      
    FBPropertyColor         SkeletonColor;  
    FBPropertyColor         PivotColor;     
    FBPropertyDouble        MarkerSetSize;  
    FBPropertyDouble        PivotSize;      

    FBPropertyVector3d      HipsPosition;           
    FBPropertyVector3d      LeftHipPosition;        
    FBPropertyVector3d      LeftKneePosition;       
    FBPropertyVector3d      LeftAnklePosition;      
    FBPropertyVector3d      LeftFootPosition;       
    FBPropertyVector3d      RightHipPosition;       
    FBPropertyVector3d      RightKneePosition;      
    FBPropertyVector3d      RightAnklePosition;     
    FBPropertyVector3d      RightFootPosition;      
    FBPropertyVector3d      WaistPosition;          
    FBPropertyVector3d      ChestPosition;          
    FBPropertyVector3d      LeftCollarPosition;     
    FBPropertyVector3d      LeftShoulderPosition;   
    FBPropertyVector3d      LeftElbowPosition;      
    FBPropertyVector3d      LeftWristPosition;      
    FBPropertyVector3d      RightCollarPosition;    
    FBPropertyVector3d      RightShoulderPosition;  
    FBPropertyVector3d      RightElbowPosition;     
    FBPropertyVector3d      RightWristPosition;     
    FBPropertyVector3d      NeckPosition;           
    FBPropertyVector3d      HeadPosition;           
    FBPropertyBool          Visibility;             
    FBPropertyBool          SkeletonVisibility;     
    FBPropertyBool          PivotPointsVisibility;  

    FBPropertyAnimatableDouble  LeftHandIndexIndex;     
    FBPropertyAnimatableDouble  LeftHandIndexMiddle;    
    FBPropertyAnimatableDouble  LeftHandIndexRing;      
    FBPropertyAnimatableDouble  LeftHandIndexPinky;     

    FBPropertyAnimatableDouble  LeftHandMiddleIndex;    
    FBPropertyAnimatableDouble  LeftHandMiddleMiddle;   
    FBPropertyAnimatableDouble  LeftHandMiddleRing;     
    FBPropertyAnimatableDouble  LeftHandMiddlePinky;    

    FBPropertyAnimatableDouble  LeftHandRingIndex;      
    FBPropertyAnimatableDouble  LeftHandRingMiddle;     
    FBPropertyAnimatableDouble  LeftHandRingRing;       
    FBPropertyAnimatableDouble  LeftHandRingPinky;      

    FBPropertyAnimatableDouble  LeftHandPinkyIndex;     
    FBPropertyAnimatableDouble  LeftHandPinkyMiddle;    
    FBPropertyAnimatableDouble  LeftHandPinkyRing;      
    FBPropertyAnimatableDouble  LeftHandPinkyPinky;     

    FBPropertyAnimatableDouble  RightHandIndexIndex;    
    FBPropertyAnimatableDouble  RightHandIndexMiddle;   
    FBPropertyAnimatableDouble  RightHandIndexRing;     
    FBPropertyAnimatableDouble  RightHandIndexPinky;    

    FBPropertyAnimatableDouble  RightHandMiddleIndex;   
    FBPropertyAnimatableDouble  RightHandMiddleMiddle;  
    FBPropertyAnimatableDouble  RightHandMiddleRing;    
    FBPropertyAnimatableDouble  RightHandMiddlePinky;   

    FBPropertyAnimatableDouble  RightHandRingIndex;     
    FBPropertyAnimatableDouble  RightHandRingMiddle;    
    FBPropertyAnimatableDouble  RightHandRingRing;      
    FBPropertyAnimatableDouble  RightHandRingPinky;     

    FBPropertyAnimatableDouble  RightHandPinkyIndex;    
    FBPropertyAnimatableDouble  RightHandPinkyMiddle;   
    FBPropertyAnimatableDouble  RightHandPinkyRing;     
    FBPropertyAnimatableDouble  RightHandPinkyPinky;    

    FBPropertyAnimatableDouble  FKFingerMultiplier;    
    FBPropertyAnimatableDouble  FKFingerTipMultiplier;    
    FBPropertyAnimatableDouble  FKThumbTipMultiplier;    
    FBPropertyAnimatableBool  HumanFingerLimits;    
    
    FBPropertyBool              IKManip;                

    virtual bool Snap( FBRecalcMarkerSetOffset pRecalcOffset );


    void    UpdateValues( FBEvaluateInfo* pEvalInfo );

    void    SetDefinitionScaleVector(   FBSkeletonNodeId pSkeletonId, FBVector3d pScaleVector, bool pSymmetricUpdate = true );

    void    GetDefinitionScaleVector(   FBSkeletonNodeId pSkeletonId, FBVector3d &pScaleVector );

    void    SetDefinitionRotationVector(    FBSkeletonNodeId pSkeletonId, FBVector3d pRotationVector, bool pSymmetricUpdate = true );
    
    void    SetActorTranslation( FBVector3d pTranslationVector );    

    FBSkeletonState*    GetDefaultSkeletonState ();

    FBSkeletonState*    GetCurrentSkeletonState (bool pResetOrientation=false);

    FBModel* GetLeftGloveReferenceModel( );

    void SetLeftGloveReferenceModel( FBModel* pReferenceModel );

    FBModel* GetRightGloveReferenceModel( );

    void SetRightGloveReferenceModel( FBModel* pReferenceModel );

private:
    FBSkeletonState*        mDefaultSkeletonState;
    FBSkeletonState*        mCurrentSkeletonState;
};

__FB_FORWARD( FBMocapJointsState );
class FBSDK_DLL FBMocapJointsState
{
public:
    
    FBMocapJointsState(int pSkeletonJointsCount);
    ~FBMocapJointsState();

    int                             mSkeletonJointsCount;                   
    double                          mFloorClipPlaneW;                       
    FBSkeletonTrackingState         mSkeletonTrackingState;                 
    FBTVector                       mSkeletonPosition;                      
    FBTVector*                      mSkeletonJointsPositions;               
    FBMatrix*                       mSkeletonJointsGlobalOrientations;       
    FBSkeletonJointTrackingState*   mSkeletonJointTrackingState;            
};

// FBCharacter - Representation of a character
FB_FORWARD( FBPlotOptions );
__FB_FORWARD( FBCharacter );
FB_DEFINE_COMPONENT( FBSDK_DLL, Character );

class FBSDK_DLL FBCharacter : public FBConstraint
{
    //--- Open Reality declaration.
    __FBClassDeclare( FBCharacter, FBConstraint );
public:
    FBCharacter(const char* pName, HIObject pObject=NULL);

    IObject_Declare(K_IMPLEMENTATION);              // Interface to IObject.

    virtual void FBDelete();

    FBCharacter* Clone();

    FBPropertyCharacterInputType    InputType;      
    FBPropertyCharacterKeyingMode   KeyingMode;     
    FBPropertyActor                 InputActor;     
    FBPropertyCharacter             InputCharacter; 
    FBPropertyBool                  ActiveInput;    

    FBPropertyListCharacterExtension CharacterExtensions;   

    void CycleAnalysisCurrentCharacter();

    FBCycleAnalysisNode* GetCycleAnalysisNode();

    void AddCharacterExtension(FBCharacterExtension* pExt);  

    void RemoveCharacterExtension(FBCharacterExtension* pExt);

    FBModel* GetModel( FBBodyNodeId pBodyNodeId );

    void GetSkinModelList( FBModelList& pSkinModelList );

    FBBodyNodeId GetIndexByModel( FBModel* pModel );

    FBModel* GetCtrlRigModel( FBBodyNodeId pBodyNodeId );

    FBBodyNodeId GetCtrlRigIndexByModel( FBModel* pModel );

    FBModel* GetEffectorModel( FBEffectorId pEffectorId, FBEffectorSetID  pEffectorSetID = FBEffectorSetDefault );

    FBModel* GetFloorContactModel( FBFloorContactID pMemberIndex );

    FBModel* GetGoalModel( FBBodyNodeId pBodyNodeId );

    /* Get The Translation Offset associated to the given BodyPart
    *   \param pTVector  The Translation Offset
    */
    void GetTOffset( FBBodyNodeId pBodyNodeId, FBTVector* pTVector );

    /* Get The Rotation Offset associated to the given BodyPart
    *   \param pRVector  The Rotation Offset
    */
    void GetROffset( FBBodyNodeId pBodyNodeId, FBRVector* pRVector );

    /* Get The Scaling Offset associated to the given BodyPart
    *   \param pTVector  The Scaling Offset
    */
    void GetSOffset( FBBodyNodeId pBodyNodeId, FBSVector* pSVector );

    /* Get The Transform Offset associated to the given BodyPart
    *   \param pOffsetMatrix  The Translation, Rotation and Scaling Offset
    */
    void GetTransformOffset( FBBodyNodeId pBodyNodeId, FBMatrix *pOffsetMatrix );

    /* Get The Parent Rotation Offset associated to the given BodyPart
    *   \param pRVector  The Rotation Offset
    */
    void GetParentROffset( FBBodyNodeId pBodyNodeId, FBRVector* pRVector );

    virtual bool PlotAnimation( FBCharacterPlotWhere pPlotWhere, FBPlotOptions* pPlotOptions );

    bool ReadyForRetarget();

    void Retarget( bool pOnBaseLayer );

    void CopyAnimation();

    virtual void ResetProperties( FBCharacterResetProperties pType );

    void SelectModels( bool pSelect, bool pApplyToCharacter, bool pApplyToRig, bool pApplyToExtensions );

    void GoToStancePose( bool pPushUndo = false, bool pIncludeCharacterExtensions = true );
    
    void SetMocapCalibrationState(FBCalibrationState pState);

    FBCalibrationState GetMocapCalibrationState();

    void SetupDeviceMocap(FBDevice* pDevice, int pSkeletonJointsCount, FBBodyNodeId* pSkeletonJointsOrder );

    void SetSensorFloorOffset(double pSensorFloorOffset);

    void PassDeviceMocapData(FBMocapJointsState* pDeviceMocapData);

    bool SetCharacterizeOn( bool pSetAsBiped );
    
    const char * GetCharacterizeError();

    void SetCharacterizeOff();
    
    bool GetCharacterize();
    
    bool CreateControlRig(bool pSetFKIK);

    void ConnectControlRig(FBControlSet* pControlSet, bool pUpdateLimit, bool pResetHierarchy);

    void DisconnectControlRig();

    bool CreateAuxiliary(FBEffectorId pEffectorId, bool pPivot, double pAuxReachT=100, double pAuxReachR=100);

    FBControlSet * GetCurrentControlSet(bool pForce = false);

    bool CreateCharacterMarkerSet(bool pSetActive);

    FBCharacterMarkerSet * GetCharacterMarkerSet(bool pForce = false);

    bool IsParentNodeOffset( FBBodyNodeId pNodeId );

    FBCharacterSolver *GetExternalSolver();

    void SetExternalSolver(int pIndex);

    void SetExternalSolver(FBCharacterSolver* pSolver);

    void GetActiveBodyPart(bool* pActivePart);

    bool        IsRotationPin(FBEffectorId pEffectorIndex);
    bool        IsTranslationPin(FBEffectorId pEffectorIndex);

    bool        IsCtrlSetReady();

    bool        IsPlottingActorToCtrlRig();

    FBControlSetState*  GetControlSetEvaluationCache(FBEvaluateInfo* pEvaluateInfo);
    
    FBEffectorSetState* GetEffectorEvaluationCache(FBEvaluateInfo* pEvaluateInfo);

    void MirrorCharacterExtensions(FBEvaluateInfo* pEvaluateInfo);

    FBVisibilityState GetIKVisibility();

    bool SetIKVisibility( bool pState );

    FBVisibilityState GetFKVisibility();

    bool SetFKVisibility( bool pState );

    FBVisibilityState GetSkeletonVisibility();

    bool SetSkeletonVisibility( bool pState );

    FBString mCharacterizeError;

    // ParamModifier
    FBPropertyBool                          MirrorMode;                 
    FBPropertyAnimatableDouble              ShoulderCorrection;         
    FBPropertyBool                          LeftKneeKillPitch;          
    FBPropertyBool                          RightKneeKillPitch;         
    FBPropertyBool                          LeftElbowKillPitch;         
    FBPropertyBool                          RightElbowKillPitch;        
    FBPropertyCharacterHipsTranslationMode  HipsTranslationMode;        
    FBPropertyBool                          WriteReference;             
    FBPropertyBool                          SyncMode;                   
    FBPropertyBool                          InverseLeftKnee;            
    FBPropertyBool                          InverseRightKnee;           
    FBPropertyBool                          InverseLeftElbow;           
    FBPropertyBool                          InverseRightElbow;          
    FBPropertyCharacterRollSolver           RollSolver;                 
    FBPropertyCharacterContactBehaviour     ContactBehaviour;           

    FBPropertyAnimatableDouble              ScaleCompensation;
    FBPropertyAnimatableDouble              HipsHeightCompensation;
    FBPropertyAnimatableDouble              AnkleHeightCompensation;
    FBPropertyAnimatableDouble              AnkleProximityCompensation;

    FBPropertyBool                          LockX;          
    FBPropertyBool                          LockY;          
    FBPropertyBool                          LockZ;          
};


// Property List: MarkerSet

class FBSDK_DLL FBPropertyListMarkerSet : public FBPropertyListComponent
{
public:
    FBPropertyListMarkerSet();
    FBMarkerSet* operator[](int pIndex);
    virtual int Duplicate(int pIndex);
};

// Property List: CharacterMarkerSet

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

// Property List: ControlSet

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

// Property List: Actor

class FBSDK_DLL FBPropertyListActor : public FBPropertyListComponent
{
  public:
    FBPropertyListActor();
    FBActor* operator[]( int pIndex );
    virtual int Duplicate( int pIndex );
};


// Property List: Character
FB_FORWARD      ( FBPropertyListCharacter );

class FBSDK_DLL FBPropertyListCharacter : public FBPropertyListComponent
{
  public:
    FBPropertyListCharacter();
    FBCharacter* operator[]( int pIndex );
    virtual int Duplicate( int pIndex );
};

//Helpers

FBSDK_DLL FBCharacterKeyingMode FBGetCharactersKeyingMode();

FBSDK_DLL FBBodyPartId FBGetEffectorBodyPart( FBEffectorId pEffectorId );

FBSDK_DLL FBBodyPartId FBGetBodyNodeBodyPart( FBBodyNodeId pBodyNodeId );

FBSDK_DLL FBCharacter* FBGetCharacterByAssociatedPart(FBComponent* pPart);

FBSDK_DLL bool FBGetCharacterFloorContactsVisibility();

FBSDK_DLL void FBSetCharacterFloorContactsVisibility(bool pShow);

FBSDK_DLL bool FBGetCharacterFingerTipsVisibility();

FBSDK_DLL void FBSetCharacterFingerTipsVisibility(bool pShow);

FBSDK_DLL bool FBGetActorMarkerSetVisibility();

FBSDK_DLL bool FBSetActorMarkerSetVisibility(bool pShow);



#ifdef FBSDKUseNamespace
    }
#endif
#endif /* _FB_CHARACTER_H_ */