humanik.h

Go to the documentation of this file.

/**************************************************************************************

Copyright (C) 2015 Autodesk, Inc.
All Rights Reserved.

The coded instructions, statements, computer programs, and/or related material (collectively "Data")
in these files contain unpublished information proprietary to Autodesk, Inc., ("Autodesk") 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.

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.

***************************************************************************************/

#ifndef _HUMAN_IK_
#define _HUMAN_IK_

#define HUMANIK_VERSION_MAJOR  2016
#define HUMANIK_VERSION_MINOR  1
#define HUMANIK_VERSION_THIRD  0


// Generate the version string based on HIK version.
#define HIK_EXPAND_TO_STRING_(x) #x
#define HIK_EXPAND_TO_STRING(x) HIK_EXPAND_TO_STRING_(x)

#define HUMANIK_VERSION_STRING                    \
    HIK_EXPAND_TO_STRING( HUMANIK_VERSION_MAJOR ) \
    "."                                           \
    HIK_EXPAND_TO_STRING( HUMANIK_VERSION_MINOR ) \
    "."                                           \
    HIK_EXPAND_TO_STRING( HUMANIK_VERSION_THIRD )


#ifndef HIK_EXPORT     
    #define HIK_EXPORT extern    
#endif

#if ( !defined(_MSC_VER) && !defined(HIK_API) )
    #define HIK_API
#else 
    #define HIK_API  __cdecl
#endif

#include <stddef.h> // for size_t

#ifdef __cplusplus
extern "C" {
#endif

/* *********************************************** */
enum HIKNodeId 
{
    ReferenceNodeId = 0,            

    HipsNodeId,
    LeftHipNodeId,
    LeftKneeNodeId,
    LeftAnkleNodeId,
    RightHipNodeId,
    RightKneeNodeId,
    RightAnkleNodeId,
    WaistNodeId,
    LeftShoulderNodeId,
    LeftElbowNodeId,
    LeftWristNodeId,
    RightShoulderNodeId,
    RightElbowNodeId,
    RightWristNodeId,
    HeadNodeId,
    LeftFootNodeId,
    RightFootNodeId,
    LeftCollarNodeId,
    RightCollarNodeId,
    NeckNodeId,
    LeftHandNodeId,
    RightHandNodeId,
    Spine1NodeId,
    Spine2NodeId,
    Spine3NodeId,
    Spine4NodeId,
    Spine5NodeId,
    Spine6NodeId,
    Spine7NodeId,
    Spine8NodeId,
    Spine9NodeId,
    Neck1NodeId,
    Neck2NodeId,
    Neck3NodeId,
    Neck4NodeId,
    Neck5NodeId,
    Neck6NodeId,
    Neck7NodeId,
    Neck8NodeId,
    Neck9NodeId,
    LeftHipRollNodeId,
    LeftKneeRollNodeId,
    RightHipRollNodeId,
    RightKneeRollNodeId,
    LeftShoulderRollNodeId,
    LeftElbowRollNodeId,
    RightShoulderRollNodeId,
    RightElbowRollNodeId,
    HipsTranslationId,
    LeftThumbANodeId,
    LeftThumbBNodeId,
    LeftThumbCNodeId,
    LeftThumbDNodeId,
    LeftIndexANodeId,
    LeftIndexBNodeId,
    LeftIndexCNodeId,
    LeftIndexDNodeId,
    LeftMiddleANodeId,
    LeftMiddleBNodeId,
    LeftMiddleCNodeId,
    LeftMiddleDNodeId,
    LeftRingANodeId,
    LeftRingBNodeId,
    LeftRingCNodeId,
    LeftRingDNodeId,
    LeftPinkyANodeId,
    LeftPinkyBNodeId,
    LeftPinkyCNodeId,
    LeftPinkyDNodeId,
    LeftExtraFingerANodeId,
    LeftExtraFingerBNodeId,
    LeftExtraFingerCNodeId,
    LeftExtraFingerDNodeId,
    RightThumbANodeId,
    RightThumbBNodeId,
    RightThumbCNodeId,
    RightThumbDNodeId,
    RightIndexANodeId,
    RightIndexBNodeId,
    RightIndexCNodeId,
    RightIndexDNodeId,
    RightMiddleANodeId,
    RightMiddleBNodeId,
    RightMiddleCNodeId,
    RightMiddleDNodeId,
    RightRingANodeId,
    RightRingBNodeId,
    RightRingCNodeId,
    RightRingDNodeId,
    RightPinkyANodeId,
    RightPinkyBNodeId,
    RightPinkyCNodeId,
    RightPinkyDNodeId,
    RightExtraFingerANodeId,
    RightExtraFingerBNodeId,
    RightExtraFingerCNodeId,
    RightExtraFingerDNodeId,
    LeftFootThumbANodeId,
    LeftFootThumbBNodeId,
    LeftFootThumbCNodeId,
    LeftFootThumbDNodeId,
    LeftFootIndexANodeId,
    LeftFootIndexBNodeId,
    LeftFootIndexCNodeId,
    LeftFootIndexDNodeId,
    LeftFootMiddleANodeId,
    LeftFootMiddleBNodeId,
    LeftFootMiddleCNodeId,
    LeftFootMiddleDNodeId,
    LeftFootRingANodeId,
    LeftFootRingBNodeId,
    LeftFootRingCNodeId,
    LeftFootRingDNodeId,
    LeftFootPinkyANodeId,
    LeftFootPinkyBNodeId,
    LeftFootPinkyCNodeId,
    LeftFootPinkyDNodeId,
    LeftExtraFootFingerANodeId,
    LeftExtraFootFingerBNodeId,
    LeftExtraFootFingerCNodeId,
    LeftExtraFootFingerDNodeId,
    RightFootThumbANodeId,
    RightFootThumbBNodeId,
    RightFootThumbCNodeId,
    RightFootThumbDNodeId,
    RightFootIndexANodeId,
    RightFootIndexBNodeId,
    RightFootIndexCNodeId,
    RightFootIndexDNodeId,
    RightFootMiddleANodeId,
    RightFootMiddleBNodeId,
    RightFootMiddleCNodeId,
    RightFootMiddleDNodeId,
    RightFootRingANodeId,
    RightFootRingBNodeId,
    RightFootRingCNodeId,
    RightFootRingDNodeId,
    RightFootPinkyANodeId,
    RightFootPinkyBNodeId,
    RightFootPinkyCNodeId,
    RightFootPinkyDNodeId,
    RightExtraFootFingerANodeId,
    RightExtraFootFingerBNodeId,
    RightExtraFootFingerCNodeId,
    RightExtraFootFingerDNodeId,
    LeftThumbInNodeId,
    LeftIndexInNodeId,
    LeftMiddleInNodeId,
    LeftRingInNodeId,
    LeftPinkyInNodeId,
    LeftExtraFingerInNodeId,
    RightThumbInNodeId,
    RightIndexInNodeId,
    RightMiddleInNodeId,
    RightRingInNodeId,
    RightPinkyInNodeId,
    RightExtraFingerInNodeId,
    LeftFootThumbInNodeId,
    LeftFootIndexInNodeId,
    LeftFootMiddleInNodeId,
    LeftFootRingInNodeId,
    LeftFootPinkyInNodeId,
    LeftExtraFootFingerInNodeId,
    RightFootThumbInNodeId,
    RightFootIndexInNodeId,
    RightFootMiddleInNodeId,
    RightFootRingInNodeId,
    RightFootPinkyInNodeId,
    RightExtraFootFingerInNodeId,
    LeftCollarExtraNodeId,
    RightCollarExtraNodeId,
    LastNodeId                      
};

/* *********************************************** */
enum HIKEffectorId
{
    HipsEffectorId = 0,             // 0 
    LeftAnkleEffectorId,             // 1 
    RightAnkleEffectorId,            // 2 
    LeftWristEffectorId,             // 3 
    RightWristEffectorId,            // 4 
    LeftKneeEffectorId,              // 5 
    RightKneeEffectorId,             // 6 
    LeftElbowEffectorId,             // 7 
    RightElbowEffectorId,            // 8 
    ChestOriginEffectorId,           // 9 
    ChestEndEffectorId,             // 10 
    LeftFootEffectorId,              // 11 
    RightFootEffectorId,             // 12 
    LeftShoulderEffectorId,          // 13 
    RightShoulderEffectorId,         // 14 
    HeadEffectorId,                  // 15 
    LeftHipEffectorId,               // 16 
    RightHipEffectorId,              // 17 
    LeftHandEffectorId,              // 18 
    RightHandEffectorId,             // 19 
    LeftHandThumbEffectorId,         // 20 
    LeftHandIndexEffectorId,         // 21 
    LeftHandMiddleEffectorId,        // 22 
    LeftHandRingEffectorId,          // 23 
    LeftHandPinkyEffectorId,         // 24 
    LeftHandExtraFingerEffectorId,   // 25 
    RightHandThumbEffectorId,        // 26 
    RightHandIndexEffectorId,        // 27 
    RightHandMiddleEffectorId,       // 28 
    RightHandRingEffectorId,         // 29 
    RightHandPinkyEffectorId,        // 30 
    RightHandExtraFingerEffectorId,  // 31 
    LeftFootThumbEffectorId,         // 32 
    LeftFootIndexEffectorId,         // 33 
    LeftFootMiddleEffectorId,        // 34 
    LeftFootRingEffectorId,          // 35 
    LeftFootPinkyEffectorId,         // 36 
    LeftFootExtraFingerEffectorId,   // 37 
    RightFootThumbEffectorId,        // 38 
    RightFootIndexEffectorId,        // 39 
    RightFootMiddleEffectorId,       // 40 
    RightFootRingEffectorId,         // 41 
    RightFootPinkyEffectorId,        // 42 
    RightFootExtraFingerEffectorId,  // 43 
    LastEffectorId                   // 44 
};

/* *********************************************** */
enum HIKFloorContact
{
    HIKLeftHandFloor=0,             
    HIKRightHandFloor,              
    HIKLeftFootFloor,               
    HIKRightFootFloor,              
    HIKLastFloorId                  
};

/* *********************************************** */
enum HIKSolvingStep
{ 
    HIKSolvingStepBodyPull          = 1 << 0,
    HIKSolvingStepContact           = 1 << 1,
    HIKSolvingStepContactApprox     = 1 << 2,
    HIKSolvingStepLeftShoulder      = 1 << 3,   
    HIKSolvingStepRightShoulder     = 1 << 4,   
    HIKSolvingStepLeftArm           = 1 << 5,   
    HIKSolvingStepRightArm          = 1 << 6,   
    HIKSolvingStepLeftLeg           = 1 << 7,   
    HIKSolvingStepRightLeg          = 1 << 8,   
    HIKSolvingStepLeftHand          = 1 << 9,   
    HIKSolvingStepRightHand         = 1 << 10,  
    HIKSolvingStepLeftFoot          = 1 << 11,  
    HIKSolvingStepRightFoot         = 1 << 12,  
    HIKSolvingStepHead              = 1 << 13,  
    HIKSolvingStepSpine             = 1 << 14,  
    HIKSolvingStepHipsTranslation   = 1 << 15,  

    HIKSolvingStepRollExtraction    = 1 << 16,
    HIKSolvingStepLeftArmSnS        = 1 << 17,  
    HIKSolvingStepRightArmSnS       = 1 << 18,  
    HIKSolvingStepLeftLegSnS        = 1 << 19,  
    HIKSolvingStepRightLegSnS       = 1 << 20,  
    HIKSolvingStepModifiers         = 1 << 21,  

    HIKSolvingStepAllParts      = HIKSolvingStepLeftShoulder | HIKSolvingStepRightShoulder | HIKSolvingStepLeftArm  | HIKSolvingStepRightArm  |
                                  HIKSolvingStepLeftLeg      | HIKSolvingStepRightLeg      | HIKSolvingStepLeftHand | HIKSolvingStepRightHand |
                                  HIKSolvingStepLeftFoot     | HIKSolvingStepRightFoot     | HIKSolvingStepHead     | HIKSolvingStepSpine,
    HIKSolvingStepAll = HIKSolvingStepBodyPull | HIKSolvingStepContact | HIKSolvingStepContactApprox | HIKSolvingStepAllParts | HIKSolvingStepHipsTranslation | HIKSolvingStepRollExtraction | HIKSolvingStepModifiers
};

typedef void* (HIK_API * HIKMalloc)(size_t);

typedef void  (HIK_API * HIKFree)(void *);


/* *********************************************** */
struct HIKCharacter;


struct HIKEffectorSetState;


struct HIKCharacterState;


struct HIKPropertySetState;

enum HIKNodeFlags
{
    HIKNodeNotUsed      = 0,                            
    HIKNodeUsed         = 1 << 0,                       
    HIKNodeParentOffset = 1 << 1 | HIKNodeUsed,         
    HIKNodeLimits       = 1 << 2 | HIKNodeParentOffset, 
    HIKNodeIsLeafRoll   = 1 << 3                        
};

typedef struct sHIKCharacterDefinition
{
    int mUsedNodes[LastNodeId];
} HIKCharacterDefinition;


/* *********************************************** */
    #if defined(HIK_VERBOSE)

    bool HIKValidateHierarchy(const HIKCharacterDefinition *pCharacterDefinition);

    bool HIKValidateGeometry(const HIKCharacter *pCharacter);
#endif

   HIK_EXPORT HIKCharacter      * HIK_API HIKCharacterCreate( const HIKCharacterDefinition *pCharacterDefinition, HIKMalloc pMalloc, const char *pValidationString);

   HIK_EXPORT HIKCharacter      * HIK_API HIKCharacterCreateInPlace( const HIKCharacterDefinition *pCharacterDefinition, void* pBuffer, const char *pValidationString);
   

HIK_EXPORT HIKEffectorSetState * HIK_API HIKEffectorSetStateCreate( HIKMalloc pMalloc);

HIK_EXPORT HIKEffectorSetState * HIK_API HIKEffectorSetStateCreateInPlace(void* pBuffer);

HIK_EXPORT HIKCharacterState   * HIK_API HIKCharacterStateCreate(const HIKCharacter *pCharacter, HIKMalloc pMalloc);

HIK_EXPORT HIKCharacterState * HIK_API HIKCharacterStateCreateInPlace(const HIKCharacter *pCharacter, void* pBuffer);

/* *********************************************** */
HIK_EXPORT void  HIK_API HIKCharacterDestroy         (HIKCharacter        *pCharacter,      HIKFree pFree);

HIK_EXPORT void  HIK_API HIKEffectorSetStateDestroy  (HIKEffectorSetState *pESetState,      HIKFree pFree);

HIK_EXPORT void  HIK_API HIKCharacterStateDestroy    (HIKCharacterState   *pCharacterState, HIKFree pFree);

/* *********************************************** */
enum HIKLimitActiveMask
{ 
    HIKActiveMinX = 1 << 0, 
    HIKActiveMinY = 1 << 1, 
    HIKActiveMinZ = 1 << 2, 
    HIKActiveMaxX = 1 << 3, 
    HIKActiveMaxY = 1 << 4, 
    HIKActiveMaxZ = 1 << 5  
};

enum HIKRotationOrder
{ 
    HIKOrderEulerXYZ = 0,   
    HIKOrderEulerXYX,       
    HIKOrderEulerXZY,       
    HIKOrderEulerXZX,       
    HIKOrderEulerYZX,       
    HIKOrderEulerYZY,       
    HIKOrderEulerYXZ,       
    HIKOrderEulerYXY,       
    HIKOrderEulerZXY,       
    HIKOrderEulerZXZ,       
    HIKOrderEulerZYX,       
    HIKOrderEulerZYZ,       
    HIKOrderSphericXYZ      
};

typedef enum HIKRotationOrder    eHIKRotationOrder;


HIK_EXPORT void  HIK_API HIKSetCharacterizeNodeStatefv(HIKCharacter *pCharacter, int pNodeId, const float  pXForm[16]);
HIK_EXPORT void  HIK_API HIKSetCharacterizeNodeStatedv(HIKCharacter *pCharacter, int pNodeId, const double pXForm[16]);

HIK_EXPORT void  HIK_API HIKSetCharacterizeNodeStateTQSfv(HIKCharacter *pCharacter, int pNodeId, const float  pT[4], const float  pQ[4], const float  pS[4]);
HIK_EXPORT void  HIK_API HIKSetCharacterizeNodeStateTQSdv(HIKCharacter *pCharacter, int pNodeId, const double pT[4], const double pQ[4], const double pS[4]);

HIK_EXPORT void  HIK_API HIKGetCharacterizeNodeStateTQSfv(const HIKCharacter *pCharacter, int pNodeId, float  pT[4], float  pQ[4], float  pS[4]);
HIK_EXPORT void  HIK_API HIKGetCharacterizeNodeStateTQSdv(const HIKCharacter *pCharacter, int pNodeId, double pT[4], double pQ[4], double pS[4]);

HIK_EXPORT void  HIK_API HIKGetCharacterizeNodeStatefv(const HIKCharacter *pCharacter, int pNodeId, float  pXForm[16]);

HIK_EXPORT bool  HIK_API HIKCharacterizeGeometry(HIKCharacter *pCharacter);

HIK_EXPORT void  HIK_API HIKGetDefaultState(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState);


HIK_EXPORT void  HIK_API HIKGetRelaxPose(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState);

HIK_EXPORT int       HIK_API HIKGetNodeUse(const HIKCharacter *pCharacter, int pNodeId);

HIK_EXPORT void  HIK_API HIKSetParentOffsetfv(HIKCharacter *pCharacter, int pNodeId, const float pParentTOffset[4], const float pParentQOffset[4], const float pParentSOffset[4]);
HIK_EXPORT void  HIK_API HIKSetParentOffsetdv(HIKCharacter *pCharacter, int pNodeId, const double pParentTOffset[4], const double pParentQOffset[4], const double pParentSOffset[4]);

HIK_EXPORT void  HIK_API HIKGetParentOffsetfv(const HIKCharacter *pCharacter, int pNodeId, float pParentTOffset[4], float pParentQOffset[4], float pParentSOffset[4]);
HIK_EXPORT void  HIK_API HIKGetParentOffsetdv(const HIKCharacter *pCharacter, int pNodeId, double pParentTOffset[4], double pParentQOffset[4], double pParentSOffset[4]);

enum HIKMiddleJoint
{
    HIKLeftKnee = 0,    
    HIKRightKnee,       
    HIKLeftElbow,       
    HIKRightElbow       
};

typedef enum HIKMiddleJoint eHIKMiddleJoint;

HIK_EXPORT void  HIK_API HIKInverseJoint(HIKCharacter *pCharacter, eHIKMiddleJoint pJoint, int pInverse);

HIK_EXPORT int  HIK_API HIKIsJointInverted(const HIKCharacter *pCharacter, eHIKMiddleJoint pJoint);

HIK_EXPORT void  HIK_API HIKSetMinXYZRotationfv(HIKCharacter *pCharacter, int pNodeId, const float pMin[3], int pMinActiveMask);
HIK_EXPORT void  HIK_API HIKSetMinXYZRotationdv(HIKCharacter *pCharacter, int pNodeId, const double pMin[3], int pMinActiveMask);

HIK_EXPORT void  HIK_API HIKSetMaxXYZRotationfv(HIKCharacter *pCharacter, int pNodeId, const float pMax[3], int pMaxActiveMask);
HIK_EXPORT void  HIK_API HIKSetMaxXYZRotationdv(HIKCharacter *pCharacter, int pNodeId, const double pMax[3], int pMaxActiveMask);

HIK_EXPORT void  HIK_API HIKSetRotationOrder(HIKCharacter *pCharacter, int pNodeId, eHIKRotationOrder pRotationOrder);

HIK_EXPORT void  HIK_API HIKSetPreQfv(HIKCharacter *pCharacter, int pNodeId, const float pPreQ[4]);
HIK_EXPORT void  HIK_API HIKSetPreQdv(HIKCharacter *pCharacter, int pNodeId, const double pPreQ[4]);

HIK_EXPORT void  HIK_API HIKSetPostQfv(HIKCharacter *pCharacter, int pNodeId, const float pPostQ[4]);
HIK_EXPORT void  HIK_API HIKSetPostQdv(HIKCharacter *pCharacter, int pNodeId, const double pPostQ[4]);

HIK_EXPORT void  HIK_API HIKSetLimitsfv(HIKCharacter *pCharacter, int pNodeId, 
                                           const float pMin[3], const float pMax[3], 
                                           const float pPreQ[4], const float pPostQ[4],
                                           int pActiveMask,
                                           eHIKRotationOrder pRotationOrder);
HIK_EXPORT void  HIK_API HIKSetLimitsdv(HIKCharacter *pCharacter, int pNodeId, 
                                           const double pMin[3], const double pMax[3], 
                                           const double pPreQ[4], const double pPostQ[4],
                                           int pActiveMask,
                                           eHIKRotationOrder pRotationOrder);

HIK_EXPORT void HIKSetTranslationLimitsf(HIKCharacter *pCharacter,int pNodeId, 
                                float pMin, float pMax, bool pActive);

HIK_EXPORT void HIKSetTranslationLimitsd(HIKCharacter *pCharacter,int pNodeId, 
                                double pMin, double pMax, bool pActive);

HIK_EXPORT void  HIK_API HIKGetLimitsfv(const HIKCharacter *pCharacter, int pNodeId, 
                                           float pMin[3], float pMax[3], 
                                           float pPreQ[4], float pPostQ[4],
                                           int &pActiveMask,
                                           eHIKRotationOrder &pRotationOrder);
HIK_EXPORT void  HIK_API HIKGetLimitsdv(const HIKCharacter *pCharacter, int pNodeId, 
                                           double pMin[3], double pMax[3], 
                                           double pPreQ[4],double pPostQ[4],
                                           int &pActiveMask,
                                           eHIKRotationOrder &pRotationOrder);

HIK_EXPORT void  HIK_API HIKAddQuadripedOffset(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState);

HIK_EXPORT void  HIK_API HIKSubQuadripedOffset(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState);

/* *********************************************** */
HIK_EXPORT void  HIK_API HIKSolveForCharacter(const HIKCharacter *pDstCharacter, HIKCharacterState *pCharacterState, const HIKCharacter *pSrcCharacter, const HIKCharacterState *pSrcCharacterState, HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pDstPropertyState, const HIKPropertySetState *pSrcPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForCharacterRetarget(const HIKCharacter *pDstCharacter, HIKCharacterState *pDstCharacterState, const HIKCharacter *pSrcCharacter, const HIKCharacterState *pSrcCharacterState, const HIKPropertySetState *pDstPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForCharacterPrepareEffectorSet(const HIKCharacter *pDstCharacter, HIKCharacterState *pDstCharacterState, const HIKCharacter *pSrcCharacter, const HIKCharacterState *pSrcCharacterState, HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pDstPropertyState, const HIKPropertySetState *pSrcPropertyState);

// ***********************************************
HIK_EXPORT void     HIK_API HIKGetEffectorStateFromCharacterfv(const HIKCharacter *pCharacter, int pEffectorIndex, const HIKCharacterState *pCharacterState, const HIKPropertySetState *pPropertyState, float pXForm[16]);
HIK_EXPORT void     HIK_API HIKGetEffectorStateFromCharacterdv(const HIKCharacter *pCharacter, int pEffectorIndex, const HIKCharacterState *pCharacterState, const HIKPropertySetState *pPropertyState, double pXForm[16]);

HIK_EXPORT void     HIK_API HIKEffectorSetFromCharacter(const HIKCharacter *pCharacter, HIKEffectorSetState *pEffectorSetState, const HIKCharacterState *pCharacterState, const HIKPropertySetState *pPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForEffectorSet(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForEffectorSetBegin(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForEffectorSetFloorContactApprox(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState,HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForEffectorSetBodyPull(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState,HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForEffectorSetArmsAndLegs(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState,HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForEffectorSetFingersAndToes(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState,HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForEffectorSetHeadAndNeck(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState,HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForEffectorSetFloorContact(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState,HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForEffectorSetHipsTranslation(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState,HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForEffectorSetRollExtraction(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState,HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pPropertyState);

HIK_EXPORT void  HIK_API HIKSolveForEffectorSetModifiers(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, HIKEffectorSetState *pEffectorSetState, const HIKPropertySetState *pPropertyState);

// ***********************************************
HIK_EXPORT void  HIK_API HIKSetEffectorStatefv(HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, const float pXForm[16]);
HIK_EXPORT void  HIK_API HIKSetEffectorStatedv(HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, const double pXForm[16]);

HIK_EXPORT void  HIK_API HIKSetEffectorStateTQSfv(HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, const float pT[4], const float pQ[4], const float pS[4]);
HIK_EXPORT void  HIK_API HIKSetEffectorStateTQSdv(HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, const double pT[4], const double pQ[4], const double pS[4]);

HIK_EXPORT void  HIK_API HIKSetEffectorStateTQSAlignfv(HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, const float* pTQS, size_t pTOffset, size_t pQOffset, size_t pSOffset);

HIK_EXPORT void  HIK_API HIKSetEffectorStateTQAlignfv(HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, const float* pTQ, size_t pTOffset, size_t pQOffset);

HIK_EXPORT void  HIK_API HIKGetEffectorStatefv(const HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, float pXForm[16]);
HIK_EXPORT void  HIK_API HIKGetEffectorStatedv(const HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, double pXForm[16]);

HIK_EXPORT void  HIK_API HIKGetEffectorStateTQSfv(const HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, float pT[4], float pQ[4], float pS[4]);
HIK_EXPORT void  HIK_API HIKGetEffectorStateTQfv(const HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, float pT[4], float pQ[4]);
HIK_EXPORT void  HIK_API HIKGetEffectorStateTQSdv(const HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, double pT[4], double pQ[4], double pS[4]);

HIK_EXPORT void  HIK_API HIKGetEffectorStateTQSAlignfv(const HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, float* pTQS, size_t pTOffset, size_t pQOffset, size_t pSOffset);

HIK_EXPORT void  HIK_API HIKGetEffectorStateTQAlignfv(const HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, float* pTQ, size_t pTOffset, size_t pQOffset);

HIK_EXPORT void  HIK_API HIKSetTranslationActive(HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, float pValue);

HIK_EXPORT float     HIK_API HIKGetTranslationActive(const HIKEffectorSetState *pEffectorSetState, int pEffectorIndex);

HIK_EXPORT void  HIK_API HIKSetRotationActive(HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, float pValue);

HIK_EXPORT float     HIK_API HIKGetRotationActive(const HIKEffectorSetState *pEffectorSetState, int pEffectorIndex);

HIK_EXPORT void  HIK_API HIKSetPull(HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, float pValue);

HIK_EXPORT float     HIK_API HIKGetPull(const HIKEffectorSetState *pEffectorSetState, int pEffectorIndex);

HIK_EXPORT void  HIK_API HIKSetResist(HIKEffectorSetState *pEffectorSetState, int pEffectorIndex, float pValue);

HIK_EXPORT float     HIK_API HIKGetResist(const HIKEffectorSetState *pEffectorSetState, int pEffectorIndex);


HIK_EXPORT void  HIK_API HIKSetHandPullHips(HIKEffectorSetState *pEffectorSetState, int pLeft, float pValue);

HIK_EXPORT float     HIK_API HIKGetHandPullHips(const HIKEffectorSetState *pEffectorSetState, int pLeft);

HIK_EXPORT void  HIK_API HIKSetEffectorFloorStatefv(HIKEffectorSetState *pEffectorSetState, int pFloor, const float pXForm[16]);
HIK_EXPORT void  HIK_API HIKSetEffectorFloorStatedv(HIKEffectorSetState *pEffectorSetState, int pFloor, const double pXForm[16]);

HIK_EXPORT void  HIK_API HIKSetEffectorFloorStateTQfv(HIKEffectorSetState *pEffectorSetState, int pFloor, const float pT[4], const float pQ[4]);
HIK_EXPORT void  HIK_API HIKSetEffectorFloorStateTQdv(HIKEffectorSetState *pEffectorSetState, int pFloor, const double pT[4], const double pQ[4]);

HIK_EXPORT void  HIK_API HIKGetEffectorFloorStatefv(const HIKEffectorSetState *pEffectorSetState, int pFloor, float pXForm[16]);
HIK_EXPORT void  HIK_API HIKGetEffectorFloorStatedv(const HIKEffectorSetState *pEffectorSetState, int pFloor, double pXForm[16]);

HIK_EXPORT void  HIK_API HIKGetEffectorFloorStateTQfv(const HIKEffectorSetState *pEffectorSetState, int pFloor, float pT[4], float pQ[4]);
HIK_EXPORT void  HIK_API HIKGetEffectorFloorStateTQdv(const HIKEffectorSetState *pEffectorSetState, int pFloor, double pT[4],double pQ[4]);

HIK_EXPORT int       HIK_API HIKGetIKSolvingStep(const HIKEffectorSetState *pEffectorSetState);

HIK_EXPORT void     HIK_API HIKSetIKSolvingStep(HIKEffectorSetState *pEffectorSetState,int pSolvingStep);

// ***********************************************
enum HIKToken
{
    HIKNotUsed =  -1,   
    HIKLastNode = -2    
};

typedef enum HIKToken eHIKToken;


typedef struct sHIKDataDescription
{  
    enum
    { 
        HIKGlobalSpace = 0,     
        HIKLocalSpace  = 1      
    }mTransformSpace;

    size_t mTOffset;            
    size_t mQOffset;            
    size_t mSOffset;            
    size_t mStride;             
    int *mHIKNodeId;            
} HIKDataDescription;

typedef struct sHIKDataDescriptionMatrix
{  
    enum
    { 
        HIKGlobalSpace = 0,     
        HIKLocalSpace  = 1      
    }mTransformSpace;           

    size_t mMatrixOffset;       
    size_t mStride;             
    int *mHIKNodeId;            
} HIKDataDescriptionMatrix;

HIK_EXPORT void  HIK_API HIKSetCharacterStateTransformTQS(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, const HIKDataDescription* pDataDescription, const void* pDataSet);
HIK_EXPORT void  HIK_API HIKSetCharacterStateTransformTQ(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, const HIKDataDescription* pDataDescription, const void* pDataSet);

HIK_EXPORT void  HIK_API HIKSetCharacterStateTransform(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, const HIKDataDescriptionMatrix* pDataDescription, const void* pDataSet);

HIK_EXPORT void  HIK_API HIKSetCharacterStateTransformTQS_SoA(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, const HIKDataDescription* pDataDescription, const void* pDataSet);

HIK_EXPORT void  HIK_API HIKSetNodeStatefv(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, int pNodeId, const float pXForm[16]);
HIK_EXPORT void  HIK_API HIKSetNodeStatedv(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, int pNodeId, const double pXForm[16]);

HIK_EXPORT void  HIK_API HIKSetNodeStateTQSfv(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, int pNodeId, const float pT[4], const float pQ[4], const float pS[4]);
HIK_EXPORT void  HIK_API HIKSetNodeStateTQNonUniformSfv(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, int pNodeId, const float pT[4], const float pQ[4], const float pS[4]);
HIK_EXPORT void  HIK_API HIKSetNodeStateTQSdv(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, int pNodeId, const double pT[4], const double pQ[4], const double pS[4]);

HIK_EXPORT void HIKSetNodeStateTQSfvComputeDependent(const HIKCharacter* pCharacter, HIKCharacterState *pCharacterState, int pNodeId, const float * pT, const float * pQ, const float * pS, const bool pLocal);

HIK_EXPORT void  HIK_API HIKSetNodeStateTQfv(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, int pNodeId, const float pT[4], const float pQ[4]);

HIK_EXPORT void  HIK_API HIKSetNodeStateTQSAlignfv(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, int pNodeId, const float* pTQS, size_t pTOffset, size_t pQOffset, size_t pSOffset);

HIK_EXPORT void  HIK_API HIKSetNodeStateTQAlignfv(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, int pNodeId, const float* pTQ, size_t pTOffset, size_t pQOffset);


HIK_EXPORT void  HIK_API HIKGetCharacterStateTransformTQS(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, const HIKDataDescription* pDataDescription, void* pDataSet);
HIK_EXPORT void  HIK_API HIKGetCharacterStateTransformTQ(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, const HIKDataDescription* pDataDescription, void* pDataSet);
HIK_EXPORT void  HIK_API HIKGetCharacterStateTransformQ(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, const HIKDataDescription* pDataDescription, void* pDataSet);

HIK_EXPORT void  HIK_API HIKGetCharacterStateTransform(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, const HIKDataDescriptionMatrix* pDataDescription, void* pDataSet);

HIK_EXPORT void  HIK_API HIKGetCharacterStateTransformTQS_SoA(const HIKCharacter *pCharacter, HIKCharacterState *pCharacterState, const HIKDataDescription* pDataDescription, void* pDataSet);

HIK_EXPORT void  HIK_API HIKGetNodeStatefv(const HIKCharacter *pCharacter, const HIKCharacterState *pCharacterState, int pNodeId, float pXForm[16]);
HIK_EXPORT void  HIK_API HIKGetNodeStatedv(const HIKCharacter *pCharacter, const HIKCharacterState *pCharacterState, int pNodeId, double pXForm[16]);

HIK_EXPORT void  HIK_API HIKGetNodeStateTQSfv(const HIKCharacter *pCharacter, const HIKCharacterState *pCharacterState, int pNodeId, float pT[4], float pQ[4], float pS[4]);
HIK_EXPORT void  HIK_API HIKGetNodeStateTQNonUniformSfv(const HIKCharacter *pCharacter, const HIKCharacterState *pCharacterState, int pNodeId, float pT[4], float pQ[4], float pS[4]);
HIK_EXPORT void  HIK_API HIKGetNodeStateTQSdv(const HIKCharacter *pCharacter, const HIKCharacterState *pCharacterState, int pNodeId, double pT[4], double pQ[4], double pS[4]);

HIK_EXPORT void  HIK_API HIKGetNodeStateTQfv(const HIKCharacter *pCharacter, const HIKCharacterState *pCharacterState, int pNodeId, float pT[4], float pQ[4]);

HIK_EXPORT void  HIK_API HIKGetNodeStateTQSAlignfv(const HIKCharacter *pCharacter, const HIKCharacterState *pCharacterState, int pNodeId, float* pTQS, size_t pTOffset, size_t pQOffset, size_t pSOffset);

HIK_EXPORT void  HIK_API HIKGetNodeStateTQAlignfv(const HIKCharacter *pCharacter, const HIKCharacterState *pCharacterState, int pNodeId, float* pTQ, size_t pTOffset, size_t pQOffset);


typedef struct sHIKEffectorDataDescription
{  
    size_t mTOffset;            
    size_t mQOffset;            
    size_t mSOffset;            
    size_t mParameterOffset;    
    size_t mStride;             
    int *mHIKEffectorId;        
} HIKEffectorDataDescription;

typedef struct sHIKEffectorDataDescriptionMatrix
{  
    size_t mMatrixOffset;       
    size_t mParameterOffset;    
    size_t mStride;             
    int *mHIKEffectorId;        
} HIKEffectorDataDescriptionMatrix;

HIK_EXPORT void  HIK_API HIKSetEffectorStateDataTQS(HIKEffectorSetState *pEffectorSetState, const HIKEffectorDataDescription* pDataDescription, const void* pDataSet);

HIK_EXPORT void  HIK_API HIKSetEffectorStateData(HIKEffectorSetState *pEffectorSetState, const HIKEffectorDataDescriptionMatrix* pDataDescription, const void* pDataSet);

HIK_EXPORT void  HIK_API HIKGetEffectorStateDataTQS(const HIKEffectorSetState *pEffectorSetState, const HIKEffectorDataDescription* pDataDescription, void* pDataSet);

HIK_EXPORT void  HIK_API HIKGetEffectorStateData(const HIKEffectorSetState *pEffectorSetState, const HIKEffectorDataDescriptionMatrix* pDataDescription, void* pDataSet);

// ***********************************************
HIK_EXPORT int          HIK_API HIKNodeIdFromNodeName(const char* pName);

HIK_EXPORT const char*  HIK_API HIKNodeNameFromNodeId(int pNodeId);

HIK_EXPORT int          HIK_API HIKEffectorIdFromEffectorName(const char* pName);

HIK_EXPORT const char*  HIK_API HIKEffectorNameFromEffectorId(int pEffectorId);

HIK_EXPORT void HIK_API HIKGetLocalQFromDOFfv(const HIKCharacter *pCharacter, int pNodeId, const float pEuler[4], float pQuat[4]);

HIK_EXPORT void HIK_API HIKGetDOFFromLocalQfv(const HIKCharacter *pCharacter, int pNodeId, const float pQuat[4], float pEuler[4]);

HIK_EXPORT void HIK_API HIKQTransform(const float quat[4], const float p[4], float q[4]);

HIK_EXPORT void HIK_API HIKEulerFromQuat(const float quat[4], float euler[4]);

HIK_EXPORT void HIK_API HIKSetOriginalSnSLength(HIKCharacter *pCharacter, bool pFromCharacterizationPose, HIKCharacterState *pCharacterState);

// ***********************************************
HIK_EXPORT size_t  HIK_API HIKCharacterDefinitionSize(const HIKCharacterDefinition *pCharacterDefinition);

HIK_EXPORT size_t  HIK_API HIKCharacterStateSizeFromDefinition(const HIKCharacterDefinition *pCharacterDefinition);



HIK_EXPORT size_t  HIK_API HIKCharacterSize(const HIKCharacter* pCharacter);

HIK_EXPORT size_t  HIK_API HIKCharacterStateSize(const HIKCharacter* pCharacter);


HIK_EXPORT size_t  HIK_API HIKCharacterStateSizeFromState(const HIKCharacterState* pCharacterState);

HIK_EXPORT size_t  HIK_API HIKEffectorSetStateSize();

#ifdef __cplusplus
}
#endif
#define HIK_INTERNAL_PLACEHOLDER
#endif