#include "hikhostmb.h"
#include "filterset2fbcharacter.h"
#include "orcharactersolver_hik.h"
void HIKHostPropertiesInit(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost)
{
for(int lPIter = 0; lPIter < HIKLastPropertyId; lPIter++)
{
pHIKCharacterHost.GetProperty(lPIter).Get().mDefaultMode = HIKGetPropertyInfoDefaultMode(lPIter);
pHIKCharacterHost.GetProperty(lPIter).Get().mDefaultValue = HIKGetPropertyInfoDefaultValue(lPIter);
}
}
void HIKCharacterHostFromMBCharacterHierarchy(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost,FBCharacter* pCharacter, FBConstraint* pConstraint,bool pPlotActorToCtrlRig)
{
FBModel* lModel;
if(lModel)
pHIKCharacterHost.GetFloorNode(HIKLeftFootFloor).Get().SetNode(lModel,
NULL);
else
pHIKCharacterHost.GetFloorNode(HIKLeftFootFloor).Get().Clear();
if(lModel)
pHIKCharacterHost.GetFloorNode(HIKRightFootFloor).Get().SetNode(lModel,
NULL);
else
pHIKCharacterHost.GetFloorNode(HIKRightFootFloor).Get().Clear();
if(lModel)
pHIKCharacterHost.GetFloorNode(HIKLeftHandFloor).Get().SetNode(lModel,
NULL);
else
pHIKCharacterHost.GetFloorNode(HIKLeftHandFloor).Get().Clear();
if(lModel)
pHIKCharacterHost.GetFloorNode(HIKRightHandFloor).Get().SetNode(lModel,
NULL);
else
pHIKCharacterHost.GetFloorNode(HIKRightHandFloor).Get().Clear();
if(!pPlotActorToCtrlRig)
{
int lCounter;
{
if (lModel)
pHIKCharacterHost.GetNode(lHIKId).Get().SetNode(lModel, pConstraint);
else
pHIKCharacterHost.GetNode(lHIKId).Get().Clear();
}
}
else
{
int lCounter;
{
{
lModel = pCharacter->GetCtrlRigModel((
FBBodyNodeId)lCounter);
if (lHIKId != -1)
{
if (lModel)
pHIKCharacterHost.GetNode(lHIKId).Get().SetNode(lModel, pConstraint);
else
pHIKCharacterHost.GetNode(lHIKId).Get().Clear();
}
}
}
}
}
void HIKCharacterHostFromMBCharacterGeometry(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost,HIKCharacter *pHIKCharacter,FBCharacter* pCharacter)
{
{
FBMatrix lXForm;
int lCounter;
{
if(pHIKCharacterHost.GetNode(lHIKId).Valid())
{
pCharacter->GetTransformOffset((
FBBodyNodeId)lCounter, &lXForm);
HIKSetCharacterizeNodeStatedv(pHIKCharacter,lHIKId, (double *)lXForm);
double lParentSOffset[4];
lParentTOffset.mValue[3] = 1.0;
pCharacter->GetParentROffset((
FBBodyNodeId)lCounter, &lRotationVector);
lParentSOffset[0] = 1.0;
lParentSOffset[1] = 1.0;
lParentSOffset[2] = 1.0;
lParentSOffset[3] = 1.0;
HIKSetParentOffsetdv(pHIKCharacter,lHIKId,&lParentTOffset.mValue[0],&lParentQOffset.mValue[0],&lParentSOffset[0]);
}
}
}
}
void HIKHostPropertiesFromCharacter(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost, FBCharacter* pCharacter)
{
int lIter = 0;
for(lIter = 0; lIter < HIKLastPropertyId; lIter++)
{
pHIKCharacterHost.GetProperty(lIter).Get().Init(0,0,0,1.0,false);
}
{
for(lIter = 0; lIter < FilterSet2FBCharacterParam::mParamCount; lIter++)
{
int lId = HIKGetPropertyId(FilterSet2FBCharacterParam::GetAt(lIter).mFilterSetName);
if(lId != -1)
{
FBProperty* lModeP = FilterSet2FBCharacterParam::GetAt(lIter).mFbxCharacterPropertyModeName !=
NULL ? pCharacter->PropertyList.Find(FilterSet2FBCharacterParam::GetAt(lIter).mFbxCharacterPropertyModeName,
false) :
NULL;
FBProperty* lValueP = FilterSet2FBCharacterParam::GetAt(lIter).mFbxCharacterPropertyName !=
NULL ? pCharacter->PropertyList.Find(FilterSet2FBCharacterParam::GetAt(lIter).mFbxCharacterPropertyName,
false) :
NULL;
int lValueIndex = FilterSet2FBCharacterParam::GetAt(lIter).mIndex;
HIKPropertyUnit lPropUnit = HIKGetPropertyInfoUnit(lId);
if( lId == HIKLeftUpLegRollExId ||
lId == HIKLeftLegRollExId ||
lId == HIKRightUpLegRollExId ||
lId == HIKRightLegRollExId ||
lId == HIKLeftArmRollExId ||
lId == HIKLeftForeArmRollExId ||
lId == HIKRightArmRollExId ||
lId == HIKRightForeArmRollExId )
{
lPropUnit = HIKPropertyPercent;
}
double lValueScale = (lPropUnit == HIKPropertyPercent) ? 100.0 : 1.0;
bool lIsEnum = HIKGetPropertyInfoUnit(lId) == HIKPropertyEnum;
pHIKCharacterHost.GetProperty(lId).Get().Init(lModeP,lValueP,lValueIndex,lValueScale,lIsEnum);
}
}
}
}
void HIKControlRigHostFromMBControlRig(HIKControlRigHost<HIKHostNodeMB> &pHIKControlRigHost, FBCharacter* pCharacter)
{
{
pHIKControlRigHost.GetNode(lHIKId).Get().SetNode(lModel,
NULL);
}
else
pHIKControlRigHost.GetNode(lHIKId).Get().Clear();
{
{
FBModel* lModel = pCharacter->GetCtrlRigModel( (
FBBodyNodeId)lCount );
pHIKControlRigHost.GetNode(lHIKId).Get().SetNode(lModel,
NULL);
else
pHIKControlRigHost.GetNode(lHIKId).Get().Clear();
}
{
{
pHIKControlRigHost.GetEffector(lEffIter,lSetIter).Get().SetNode(lModel,
NULL);
else
pHIKControlRigHost.GetEffector(lEffIter,lSetIter).Get().Clear();
}
}
}
}
void HIKControlRigHostFromMBControlRig(HIKControlRigHost<HIKHostNodeMB> &pHIKControlRigHost, FBControlSet* pControlRig, FBConstraint* pConstraint)
{
int lHIKId = HIKNodeIdFromNodeName( pControlRig->GetReferenceName());
if(lHIKId != -1)
{
FBModel *lXNode = pControlRig->GetReferenceModel();
pHIKControlRigHost.GetNode(lHIKId).Get().SetNode(lXNode,pConstraint);
else
pHIKControlRigHost.GetNode(lHIKId).Get().Clear();
}
int FKCount = pControlRig->GetFKCount();
for(int lFKIter = 0; lFKIter < FKCount; lFKIter++)
{
const char* lFKName = pControlRig->GetFKName(lFKIter);
lHIKId = HIKNodeIdFromNodeName( lFKName );
if(lHIKId != -1)
{
FBModel* lXNode = pControlRig->GetFKModel(lFKIter);
{
pHIKControlRigHost.GetNode(lHIKId).Get().SetNode(lXNode,pConstraint);
}
else
{
pHIKControlRigHost.GetNode(lHIKId).Get().Clear();
}
}
}
{
int lPivotCount = pControlRig->GetIKEffectorPivotCount((
FBEffectorId)lIKIter);
{
FBModel* lXNode = lPivotIter < lPivotCount ? pControlRig->GetIKEffectorModel((
FBEffectorId)lIKIter, lPivotIter) :
NULL;
{
pHIKControlRigHost.GetEffector(lIKIter,lPivotIter).Get().SetNode(lXNode,pConstraint);
}
else
{
pHIKControlRigHost.GetEffector(lIKIter,lPivotIter).Get().Clear();
}
}
}
}
void HIKExtraShoulderControlRigHost(HIKControlRigHost<HIKHostNodeMB> &pHIKControlRigHost, FBModel* pLeftShoulderModel, FBModel* pRightShoulderModel, FBConstraint* pConstraint)
{
if(pLeftShoulderModel)
pHIKControlRigHost.GetNode(LeftCollarExtraNodeId).Get().SetNode(pLeftShoulderModel, pConstraint);
else
pHIKControlRigHost.GetNode(LeftCollarExtraNodeId).Get().Clear();
if(pRightShoulderModel)
pHIKControlRigHost.GetNode(RightCollarExtraNodeId).Get().SetNode(pRightShoulderModel, pConstraint);
else
pHIKControlRigHost.GetNode(RightCollarExtraNodeId).Get().Clear();
}
void HIKCharacterHostFromHIKHostMB(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost, FBModel* pLeftShoulderModel, FBModel* pRightShoulderModel, FBConstraint* pConstraint)
{
if(pLeftShoulderModel)
pHIKCharacterHost.GetNode(LeftCollarExtraNodeId).Get().SetNode(pLeftShoulderModel, pConstraint);
else
pHIKCharacterHost.GetNode(LeftCollarExtraNodeId).Get().Clear();
if(pRightShoulderModel)
pHIKCharacterHost.GetNode(RightCollarExtraNodeId).Get().SetNode(pRightShoulderModel, pConstraint);
else
pHIKCharacterHost.GetNode(RightCollarExtraNodeId).Get().Clear();
}
void CharacterizeHIKCharacterHostFromHIKHostMB(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost,HIKCharacter *pHIKCharacter,
{
double lParentSOffset[4];
lParentTOffset.mValue[3] = 1.0;
lParentSOffset[0] = 1.0;
lParentSOffset[1] = 1.0;
lParentSOffset[2] = 1.0;
lParentSOffset[3] = 1.0;
if(pHIKCharacterHost.GetNode(LeftCollarExtraNodeId).Valid())
{
HIKSetCharacterizeNodeStateTQSdv(pHIKCharacter,LeftCollarExtraNodeId,pLeftT.mValue,pLeftR.mValue,pLeftS.mValue);
pHIKCharacterHost.TransfertRotationsAndLimits(pHIKCharacter, LeftCollarExtraNodeId);
if ( !pHIKCharacterHost.IsParentDirect(LeftCollarExtraNodeId) )
HIKSetParentOffsetdv(pHIKCharacter,LeftCollarExtraNodeId,&lParentTOffset.mValue[0],&pLeftPROff.mValue[0],&lParentSOffset[0]);
}
if(pHIKCharacterHost.GetNode(RightCollarExtraNodeId).Valid())
{
HIKSetCharacterizeNodeStateTQSdv(pHIKCharacter,RightCollarExtraNodeId,pRightT.mValue,pRightR.mValue,pRightS.mValue);
pHIKCharacterHost.TransfertRotationsAndLimits(pHIKCharacter, RightCollarExtraNodeId);
if ( !pHIKCharacterHost.IsParentDirect(RightCollarExtraNodeId) )
HIKSetParentOffsetdv(pHIKCharacter,RightCollarExtraNodeId,&lParentTOffset.mValue[0],&pRightPROff.mValue[0],&lParentSOffset[0]);
}
}
int GetSolvingStepBasedOnActivePart(int pIndex)
{
int lSolvingStep = 0;
switch(pIndex)
{
default: break;
}
return lSolvingStep;
}
HIKHostNodeMB::HIKHostNodeMB()
{
Clear();
}
void HIKHostNodeMB::SetNode(FBModel *pNode, FBConstraint *pConstraint)
{
assert(pNode);
Clear();
mNode = pNode;
mReachT = mNode->PropertyList.Find("IK Reach Translation");
mReachR = mNode->PropertyList.Find("IK Reach Rotation");
{
FBAnimationNode *lAnimationNode = pConstraint->AnimationNodeInGet();
if (lAnimationNode)
{
}
}
}
void HIKHostNodeMB::Clear()
{
}
bool HIKHostNodeMB::IsDestinationConn(FBAnimationNode* pConnector)
{
return pConnector &&
(( mDestTConn && mDestTConn->GetHIObject() == pConnector->GetHIObject() )
|| ( mDestRConn && mDestRConn->GetHIObject() == pConnector->GetHIObject() )
|| ( mDestSConn && mDestSConn->GetHIObject() == pConnector->GetHIObject() ));
}
HIKHostPropertyMB::HIKHostPropertyMB()
{
mDefaultMode = 0;
mDefaultValue = 0.0;
mModeP = 0;
mValueP = 0;
mValueIndex = 0;
mValueScale = 1.0;
mIsEnum = false;
}
void HIKHostPropertyMB::Init(FBProperty *pModeP, FBProperty *pValueP,int pValueIndex,double pValueScale,bool pIsEnum)
{
mModeP = pModeP;
mValueP = pValueP;
mValueIndex = pValueIndex;
mValueScale = pValueScale;
mIsEnum = pIsEnum;
}
double dClamp(
double x,
double lMin,
double lMax)
{
return (x < lMin) ? lMin : ((x > lMax) ? lMax : x);
}
template <>
bool HIKHostNode<HIKHostNodeMB>::Valid()
{
FBModel *lModel = Get().mNode;
bool lValid = (lModel !=
NULL) && (lModel->GetHIObject() !=
NULL);
return lValid;
}
template <>
void HIKHostNode<HIKHostNodeMB>::ReadXForm(double *pXForm,void *pUserData)
{
FBMatrix *lMatrix = reinterpret_cast<FBMatrix *>(pXForm);
lMatrix->Identity();
if(Valid())
{
FBEvaluateInfo *lInfo = reinterpret_cast<FBEvaluateInfo *>(pUserData);
}
}
template <>
void HIKHostNode<HIKHostNodeMB>::WriteXForm(double *pXForm,void *pUserData)
{
if(Valid())
{
FBEvaluateInfo *lInfo = reinterpret_cast<FBEvaluateInfo *>(pUserData);
FBSVector lS;
if(Get().mDestTConn !=
NULL) Get().mDestTConn->WriteData(lT,lInfo);
if(Get().mDestRConn !=
NULL) Get().mDestRConn->WriteData(lR,lInfo);
if(Get().mDestSConn !=
NULL) Get().mDestSConn->WriteData(lS,lInfo);
}
}
template <>
void HIKHostNode<HIKHostNodeMB>::WriteXFormCandidate(double *pXForm,void *pUserData)
{
if(Valid())
{
FBEvaluateInfo *lInfo = reinterpret_cast<FBEvaluateInfo *>(pUserData);
Get().mNode->SetMatrix( *reinterpret_cast<FBMatrix *>(pXForm),
kModelTransformation,
true,
false, lInfo);
}
}
template <>
double HIKHostNode<HIKHostNodeMB>::ReadReachT(void *pUserData)
{
double lRet = 0.0;
if(Valid())
{
FBEvaluateInfo *lInfo = reinterpret_cast<FBEvaluateInfo *>(pUserData);
if(Get().mReachT !=
NULL)
{
double lValue = 0;
Get().mReachT->GetData(&lValue, sizeof(lValue), lInfo);
lRet = dClamp( lValue/100.0, 0.0, 1.0);
}
}
return lRet;
}
template <>
double HIKHostNode<HIKHostNodeMB>::ReadReachR(void *pUserData)
{
double lRet = 0.0;
if(Valid())
{
FBEvaluateInfo *lInfo = reinterpret_cast<FBEvaluateInfo *>(pUserData);
if(Get().mReachR !=
NULL)
{
double lValue = 0;
Get().mReachR->GetData(&lValue, sizeof(lValue), lInfo);
lRet = dClamp( lValue/100.0, 0.0, 1.0);
}
}
return lRet;
}
template <>
void HIKHostNode<HIKHostNodeMB>::ReadIKPivot(double *pIKPivot, void *)
{
if(Valid())
{
FBModelMarker* lMarker = dynamic_cast<FBModelMarker*>(Get().mNode);
{
lMarker->IKPivot.GetData(lVector, sizeof(lVector) );
}
}
}
template <>
bool HIKHostNode<HIKHostNodeMB>::GetIKSync()
{
bool lIKSync = false;
if(Valid())
{
FBModelMarker* lMarker = dynamic_cast<FBModelMarker*>(Get().mNode);
{
lIKSync = lMarker->IKSync;
}
}
return lIKSync;
}
template <>
{
if(Valid())
{
FBEvaluateInfo *lInfo = reinterpret_cast<FBEvaluateInfo *>(pUserData);
mNode.mNode->GetVector(retVector,pWhat,pGlobalInfo,lInfo);
}
else
{
retVector[0]=retVector[1]=retVector[2]=1;
else
retVector.Init();
}
}
template <>
bool HIKHostNode<HIKHostNodeMB>::GetUseLimits()
{
bool lRet = false;
if( Valid() && mNode.mNode->RotationActive )
{
lRet = true;
}
return lRet;
}
template <>
int HIKHostNode<HIKHostNodeMB>::GetRotationOrder()
{
int lRet = HIKOrderEulerXYZ;
if(Valid() && mNode.mNode->RotationActive )
{
lRet = mNode.mNode->RotationOrder * 2;
}
return lRet;
}
template <>
void HIKHostNode<HIKHostNodeMB>::GetPreQ(double *pPreQ)
{
pPreQ[0] = 0.0;
pPreQ[1] = 0.0;
pPreQ[2] = 0.0;
pPreQ[3] = 1.0;
if(Valid() && mNode.mNode->RotationActive )
{
}
}
template <>
void HIKHostNode<HIKHostNodeMB>::GetPostQ(double *pPostQ)
{
pPostQ[0] = 0.0;
pPostQ[1] = 0.0;
pPostQ[2] = 0.0;
pPostQ[3] = 1.0;
if(Valid() && mNode.mNode->RotationActive )
{
}
}
#define K_DEG_TO_RAD .017453292519943295769236907684886127134428718885417 // pi/180
template <>
int HIKHostNode<HIKHostNodeMB>::GetMinXYZ(double *pXYZ)
{
int lActiveMask = 0;
if(Valid() && mNode.mNode->RotationActive )
{
*
reinterpret_cast<FBVector3d *
>(pXYZ) = mNode.mNode->RotationMin;
FBTVector *lRotationMin = reinterpret_cast<FBTVector *>(pXYZ);
FBMult(*lRotationMin, *lRotationMin, K_DEG_TO_RAD);
lActiveMask |= mNode.mNode->RotationMinX ? HIKActiveMinX : 0;
lActiveMask |= mNode.mNode->RotationMinY ? HIKActiveMinY : 0;
lActiveMask |= mNode.mNode->RotationMinZ ? HIKActiveMinZ : 0;
}
return lActiveMask;
}
template <>
int HIKHostNode<HIKHostNodeMB>::GetMaxXYZ(double *pXYZ)
{
int lActiveMask = 0;
if(Valid() && mNode.mNode->RotationActive )
{
*
reinterpret_cast<FBVector3d *
>(pXYZ) = mNode.mNode->RotationMax;
FBTVector *lRotationMax = reinterpret_cast<FBTVector *>(pXYZ);
FBMult(*lRotationMax, *lRotationMax, K_DEG_TO_RAD);
lActiveMask |= mNode.mNode->RotationMaxX ? HIKActiveMaxX : 0;
lActiveMask |= mNode.mNode->RotationMaxY ? HIKActiveMaxY : 0;
lActiveMask |= mNode.mNode->RotationMaxZ ? HIKActiveMaxZ : 0;
}
return lActiveMask;
}
template <>
int HIKHostProperty<HIKHostPropertyMB>::ReadMode(void *pUserData)
{
int lMode = Get().mDefaultMode;
{
Get().mModeP->GetData(&lMode, sizeof(lMode));
}
return lMode;
}
template <>
double HIKHostProperty<HIKHostPropertyMB>::ReadValue(void *pUserData)
{
double lValue = Get().mDefaultValue;
if(Get().mValueP !=
NULL)
{
int lValueIndex = Get().mValueIndex;
FBEvaluateInfo *lInfo = reinterpret_cast<FBEvaluateInfo *>(pUserData);
Get().mValueP->GetData(&lVector, sizeof(lVector), lInfo);
switch ( lPropType )
{
{
lValue = *((int*)&lVector);
}
break;
{
lValue = *((bool*)&lVector);
}
break;
{
lValue = *((int*)&lVector);
}
break;
default:
{
lValue = lVector[lValueIndex];
}
break;
}
}
return lValue / Get().mValueScale;
}
void HIKAdjustPostureForQuadriped(HIKCharacter *pHIKCharacter)
{
HIKCharacterState* lState = HIKCharacterStateCreate(pHIKCharacter, &malloc);
HIKGetDefaultState(pHIKCharacter, lState);
HIKSubQuadripedOffset(pHIKCharacter, lState);
HIKAddQuadripedOffset(pHIKCharacter, lState);
float lX[16];
for(i=0;i<LastNodeId;i++)
{
HIKGetNodeStatefv(pHIKCharacter, lState, i, lX);
HIKSetCharacterizeNodeStatefv(pHIKCharacter, i, lX);
}
HIKCharacterStateDestroy(lState, &free);
}
void UndoSetup(FBCharacter* pCharacter)
{
FBUndoManager lUndoManager;
if ( lUndoManager.TransactionIsOpen() )
{
FBCharacterSolver* lExtSolver = pCharacter->GetExternalSolver();
ORCharacterSolver_HIK* lConstraint =
NULL;
if(lExtSolver)
{
lConstraint = dynamic_cast<ORCharacterSolver_HIK*>(lExtSolver);
if(lConstraint)
{
FBModel* lShoulder = lConstraint->GetExtraFKModelAt(LEFT_EXTRA_COLLAR);
if (lShoulder)
{
lUndoManager.TransactionAddModelTRS(lShoulder);
if (lShoulder)
lUndoManager.TransactionAddModelTRS(lShoulder);
}
lShoulder = lConstraint->GetExtraFKModelAt(RIGHT_EXTRA_COLLAR);
if (lShoulder)
{
lUndoManager.TransactionAddModelTRS(lShoulder);
if (lShoulder)
lUndoManager.TransactionAddModelTRS(lShoulder);
}
if ( lConstraint->ArmSNS || lConstraint->LegSNS )
{
{
FBModel *lModel = pCharacter->GetCtrlRigModel( (
FBBodyNodeId)lBodyNodeIndex );
if ( lModel )
{
lUndoManager.TransactionAddModelTRS(lModel);
}
}
}
}
}
}
}