#include "hikhostmb.h"
#include "filterset2fbcharacter.h"
#include "orcharactersolver_hik.h"
static const double K_DEG_TO_RAD = .017453292519943295769236907684886127134428718885417;
{
{
const HIKNodeId lHIKNodeId = gFBBodyNodeToHIKNodeId[pBodyNode];
return lHIKNodeId;
}
else
{
}
}
{
{
const int lHIKEffectorId = (
int)pEffector;
return lHIKEffectorId;
}
return -1;
}
HIKNodeId ExtraIndexToHIKNodeId(
int pExtraIndex)
{
if(pExtraIndex == LEFT_EXTRA_COLLAR)
{
}
else if(pExtraIndex == RIGHT_EXTRA_COLLAR)
{
}
else
{
}
}
{
{
return LEFT_EXTRA_COLLAR;
}
{
return RIGHT_EXTRA_COLLAR;
}
else
{
return -1;
}
}
{
switch (pFloorContact)
{
break;
break;
break;
break;
}
}
void HIKHostPropertiesInit(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost)
{
{
}
}
void HIKHostPropertiesFromCharacter(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost, FBCharacter* pCharacter)
{
int lIter = 0;
{
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;
{
}
pHIKCharacterHost.GetProperty(lId).Get().Init(lModeP,lValueP,lValueIndex,lValueScale,lIsEnum);
}
}
FBProperty* lProperty = pCharacter->PropertyList.Find("ChestReduction", false);
OR_HIK_ASSERT(lProperty);
pHIKCharacterHost.GetChestReduction().Get().Init(
NULL,lProperty,0,1.f,
false);
lProperty = pCharacter->PropertyList.Find("NeckReduction", false);
OR_HIK_ASSERT(lProperty);
pHIKCharacterHost.GetNeckReduction().Get().Init(
NULL,lProperty,0,1.f,
false);
lProperty = pCharacter->PropertyList.Find("HeadReduction", false);
OR_HIK_ASSERT(lProperty);
pHIKCharacterHost.GetHeadReduction().Get().Init(
NULL,lProperty,0,1.f,
false);
lProperty = pCharacter->PropertyList.Find("CollarReduction", false);
OR_HIK_ASSERT(lProperty);
pHIKCharacterHost.GetShoulderReduction().Get().Init(
NULL,lProperty,0,1.f,
false);
}
}
static void HIKHostFromFBCharacterAndSolver(HIKHost<HIKHostNodeMB> &pHost, FBCharacter* pCharacter, FBCharacterSolver* pCharacterSolver, FBConstraint* pConstraint, bool pCtrlRigNodes, bool pSetReference)
{
OR_HIK_ASSERT(pCharacter);
OR_HIK_ASSERT(pCharacterSolver ==
NULL || pCharacter == (FBCharacter*)pCharacterSolver->TargetCharacter);
FBModel* lModel;
if(!pCtrlRigNodes)
{
{
{
int lHIKId = FBBodyNodeIdToHIKNodeId((
FBBodyNodeId)lCounter);
if (lModel)
pHost.GetNode(lHIKId).Get().SetNode(lModel, pConstraint, (
HIKNodeId)lHIKId );
else
pHost.GetNode(lHIKId).Get().Clear();
}
}
if(pCharacterSolver)
{
const int lExtraCount = pCharacterSolver->GetExtraBoneCount();
for( int lCounter=0; lCounter < lExtraCount; lCounter++)
{
lModel = pCharacterSolver->GetExtraBoneModelAt(lCounter);
int lHIKId = ExtraIndexToHIKNodeId(lCounter);
if (lModel)
pHost.GetNode(lHIKId).Get().SetNode(lModel, pConstraint, (
HIKNodeId)lHIKId );
else
pHost.GetNode(lHIKId).Get().Clear();
}
}
}
else
{
{
{
int lHIKId = FBBodyNodeIdToHIKNodeId((
FBBodyNodeId)lCounter);
lModel = pCharacter->GetCtrlRigModel((
FBBodyNodeId)lCounter);
if (lModel)
pHost.GetNode(lHIKId).Get().SetNode(lModel, pConstraint, (
HIKNodeId)lHIKId );
else
pHost.GetNode(lHIKId).Get().Clear();
}
}
if(pCharacterSolver)
{
const int lExtraCount = pCharacterSolver->GetExtraFKCount();
for( int lCounter=0; lCounter < lExtraCount; lCounter++)
{
lModel = pCharacterSolver->GetExtraFKModelAt(lCounter);
int lHIKId = ExtraIndexToHIKNodeId(lCounter);
if (lModel)
pHost.GetNode(lHIKId).Get().SetNode(lModel, pConstraint, (
HIKNodeId)lHIKId );
else
pHost.GetNode(lHIKId).Get().Clear();
}
}
}
}
static void HIKCharacterHostFloorContactsFromFBCharacter(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost, FBCharacter* pCharacter)
{
FBModel* lModel;
{
if(lModel)
pHIKCharacterHost.GetFloorNode(lHIKFloorId).Get().SetNode(lModel,
NULL);
else
pHIKCharacterHost.GetFloorNode(lHIKFloorId).Get().Clear();
}
}
void HIKCharacterHostFromFBCharacter(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost, FBCharacter* pCharacter, bool pFloorContacts)
{
if(pFloorContacts)
{
HIKCharacterHostFloorContactsFromFBCharacter(pHIKCharacterHost, pCharacter);
}
HIKHostFromFBCharacterAndSolver(pHIKCharacterHost, pCharacter, pCharacter->GetExternalSolver(),
NULL,
false,
true);
}
void HIKCharacterHostFromFBCharacterSolver(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost, FBCharacterSolver* pCharacterSolver, FBConstraint* pConstraint, bool pFloorContacts)
{
FBCharacter* lCharacter = pCharacterSolver->TargetCharacter;
if(pFloorContacts)
{
HIKCharacterHostFloorContactsFromFBCharacter(pHIKCharacterHost, lCharacter);
}
HIKHostFromFBCharacterAndSolver(pHIKCharacterHost, lCharacter, pCharacterSolver, pConstraint, false, true);
}
void HIKControlRigHostFromFBCharacterSolver(HIKControlRigHost<HIKHostNodeMB> &pHIKControlRigHost, FBCharacterSolver* pCharacterSolver, FBControlSet* pControlSet, FBConstraint* pConstraint)
{
FBModel* lModel;
FBCharacter* lCharacter = pCharacterSolver->TargetCharacter;
HIKHostFromFBCharacterAndSolver(pHIKControlRigHost, lCharacter, pCharacterSolver, pConstraint, true, true);
{
int lPivotCount = pControlSet->GetIKEffectorPivotCount((
FBEffectorId)lIKIter);
{
lModel = lPivotIter < lPivotCount ? pControlSet->GetIKEffectorModel((
FBEffectorId)lIKIter, lPivotIter) :
NULL;
if(lModel !=
NULL && lModel->GetHIObject() !=
NULL)
{
pHIKControlRigHost.GetEffector(lIKIter,lPivotIter).Get().SetNode(lModel,pConstraint, (
HIKEffectorId)lIKIter);
}
else
{
pHIKControlRigHost.GetEffector(lIKIter,lPivotIter).Get().Clear();
}
}
}
}
void HIKCharacterHostFromFBCharacterPose(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost, FBCharacter* pPoseCharacter, FBCharacterPose* pPose)
{
OR_HIK_ASSERT(pPoseCharacter && pPose);
HIKHostFromFBCharacterAndSolver(pHIKCharacterHost, pPoseCharacter,
NULL,
NULL,
false,
true);
FBModel* lModel;
const int lExtraCount = pPose->GetExtraBoneCount();
for( int lCounter=0; lCounter < lExtraCount; lCounter++)
{
lModel = pPose->GetExtraBoneModelAt(lCounter);
int lHIKId = ExtraIndexToHIKNodeId(lCounter);
if (lModel)
pHIKCharacterHost.GetNode(lHIKId).Get().SetNode(lModel,
NULL);
else
pHIKCharacterHost.GetNode(lHIKId).Get().Clear();
}
}
static void CopyCharacterization( HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost,
HIKCharacter *pHIKCharacter,
HIKNodeId pNodeId,
{
OR_HIK_ASSERT(pHIKCharacterHost.GetNode(pNodeId).Valid());
pHIKCharacterHost.TransfertRotationsAndLimits(pHIKCharacter, pNodeId, true);
if ( !pHIKCharacterHost.IsParentDirect(pNodeId) )
{
lParentTOffset.
Init(); lParentTOffset.mValue[3] = 1.0;
lParentSOffset[0] = lParentSOffset[1] = lParentSOffset[2] = lParentSOffset[3] = 1.0;
}
}
static void CopyCharacterization( HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost,
HIKCharacter *pHIKCharacter,
FBCharacter* pCharacter, FBCharacterSolver* pCharacterSolver, FBCharacterPose* pCharacterPose,
{
OR_HIK_ASSERT(pCharacter);
OR_HIK_ASSERT(pCharacterSolver ==
NULL || pCharacter == (FBCharacter*)pCharacterSolver->TargetCharacter);
OR_HIK_ASSERT(pHIKCharacterHost.GetNode(pNodeId).Valid());
if(pBodyNodeId != kFBLastNodeId)
{
pCharacter->GetTOffset(pBodyNodeId, &lT);
pCharacter->GetROffset(pBodyNodeId, &lR);
pCharacter->GetSOffset(pBodyNodeId, (FBSVector*)&lS);
pCharacter->GetParentROffset(pBodyNodeId, &lPROffset);
CopyCharacterization(pHIKCharacterHost, pHIKCharacter, pNodeId, lT, lR, lS, lPROffset );
}
else if(pCharacterSolver)
{
int lExtraIndex = HIKNodeIdToExtraIndex(pNodeId);
if(lExtraIndex != -1)
{
pCharacterSolver->GetTransformOffset(*(
FBVector3d*)&lT, lR, *(FBSVector*)&lS, lExtraIndex);
pCharacterSolver->GetParentRotationOffset(lPROffset, lExtraIndex);
CopyCharacterization(pHIKCharacterHost, pHIKCharacter, pNodeId, lT, lR, lS, lPROffset );
}
else
{
OR_HIK_ASSERT(false);
}
}
else if(pCharacterPose)
{
int lExtraIndex = HIKNodeIdToExtraIndex(pNodeId);
if(lExtraIndex != -1)
{
pCharacterPose->GetExtraBoneTransformOffset(*(
FBVector3d*)&lT, lR, *(FBSVector*)&lS, lExtraIndex);
pCharacterPose->GetExtraBoneParentRotationOffset(lPROffset, lExtraIndex);
CopyCharacterization(pHIKCharacterHost, pHIKCharacter, pNodeId, lT, lR, lS, lPROffset );
}
}
}
static void HIKCharacterFromFBCharacterAndSolver( HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost,
HIKCharacter*& pHIKCharacter,
FBCharacter* pCharacter, FBCharacterSolver* pCharacterSolver, FBCharacterPose* pCharacterPose )
{
OR_HIK_ASSERT(pHIKCharacter ==
NULL);
OR_HIK_ASSERT(pCharacter);
OR_HIK_ASSERT(pCharacterSolver ==
NULL || pCharacter == (FBCharacter*)pCharacterSolver->TargetCharacter);
pHIKCharacter = pHIKCharacterHost.CharacterCreate(&malloc);
{
int lHIKId = FBBodyNodeIdToHIKNodeId((
FBBodyNodeId)lCounter);
if(pHIKCharacterHost.GetNode(lHIKId).Valid())
{
CopyCharacterization(pHIKCharacterHost, pHIKCharacter, pCharacter, pCharacterSolver,
NULL, (
HIKNodeId)lHIKId, (
FBBodyNodeId)lCounter);
}
}
if(pCharacterSolver || pCharacterPose)
{
{
CopyCharacterization(pHIKCharacterHost, pHIKCharacter, pCharacter, pCharacterSolver, pCharacterPose,
LeftCollarExtraNodeId);
}
{
CopyCharacterization(pHIKCharacterHost, pHIKCharacter, pCharacter, pCharacterSolver, pCharacterPose,
RightCollarExtraNodeId);
}
}
}
void HIKCharacterFromFBCharacter(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost,
HIKCharacter*& pHIKCharacter,FBCharacter* pCharacter)
{
HIKCharacterFromFBCharacterAndSolver(pHIKCharacterHost, pHIKCharacter, pCharacter, pCharacter->GetExternalSolver(),
NULL);
}
void HIKCharacterFromFBCharacterSolver(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost,
HIKCharacter*& pHIKCharacter,FBCharacterSolver* pCharacterSolver)
{
FBCharacter* lCharacter = pCharacterSolver->TargetCharacter;
HIKCharacterFromFBCharacterAndSolver(pHIKCharacterHost, pHIKCharacter, lCharacter, pCharacterSolver,
NULL);
}
void HIKCharacterFromFBActor(
HIKCharacter*& pHIKActorCharacter, FBActor* pActor)
{
for(
int lNodeIter = 0; lNodeIter <
LastNodeId; lNodeIter++)
{
}
{
lHIKDef.mUsedNodes[gActor2HIK[lActorIter]] |=
HIKNodeUsed;
}
FBSkeletonState* lSkeletonState = pActor->GetDefaultSkeletonState();
if (lSkeletonState)
{
{
FBMatrix lGX;
FBSVector lGS;
}
}
}
void HIKCharacterFromFBCharacterPose(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost,
HIKCharacter*& pHIKCharacter,FBCharacter* pPoseCharacter, FBCharacterPose* pPose)
{
HIKCharacterFromFBCharacterAndSolver(pHIKCharacterHost, pHIKCharacter, pPoseCharacter,
NULL, pPose);
}
int GetSolvingStepBasedOnActivePart(int pIndex)
{
int lSolvingStep = 0;
switch(pIndex)
{
default: break;
}
return lSolvingStep;
}
{
int lNodeIdDesc[LastNodeId + 1];
HIKFillCharacterDescription(pHIKCharacter, lNodeIdDesc);
HIKDataDescription::HIKLocalSpace,
sizeof(KHIKNodeState),
lNodeIdDesc
};
if(pGlobal && lParentNodeId != -1)
{
FBMatrix lPGX;
if(pT) lT = *pT;
if(pQ) lQ = *pQ;
if(pS) lS = *pS;
FBMatrix lGX;
FBMatrix lLX;
if(pT)
{
pDataSet[pNodeId].mTfv[0] = lT.mValue[0];
pDataSet[pNodeId].mTfv[1] = lT.mValue[1];
pDataSet[pNodeId].mTfv[2] = lT.mValue[2];
pDataSet[pNodeId].mTfv[3] = lT.mValue[3];
}
if(pQ)
{
pDataSet[pNodeId].mQfv[0] = lQ.mValue[0];
pDataSet[pNodeId].mQfv[1] = lQ.mValue[1];
pDataSet[pNodeId].mQfv[2] = lQ.mValue[2];
pDataSet[pNodeId].mQfv[3] = lQ.mValue[3];
}
if(pS)
{
pDataSet[pNodeId].mSfv[0] = lS.mValue[0];
pDataSet[pNodeId].mSfv[1] = lS.mValue[1];
pDataSet[pNodeId].mSfv[2] = lS.mValue[2];
pDataSet[pNodeId].mSfv[3] = 1;
}
}
else
{
if(pT)
{
pDataSet[pNodeId].mTfv[0] = pT->mValue[0];
pDataSet[pNodeId].mTfv[1] = pT->mValue[1];
pDataSet[pNodeId].mTfv[2] = pT->mValue[2];
pDataSet[pNodeId].mTfv[3] = pT->mValue[3];
}
if(pQ)
{
pDataSet[pNodeId].mQfv[0] = pQ->mValue[0];
pDataSet[pNodeId].mQfv[1] = pQ->mValue[1];
pDataSet[pNodeId].mQfv[2] = pQ->mValue[2];
pDataSet[pNodeId].mQfv[3] = pQ->mValue[3];
}
if(pS)
{
pDataSet[pNodeId].mSfv[0] = pS->mValue[0];
pDataSet[pNodeId].mSfv[1] = pS->mValue[1];
pDataSet[pNodeId].mSfv[2] = pS->mValue[2];
pDataSet[pNodeId].mSfv[3] = 1;
}
}
}
void ResetControRigModelTransformation(
HIKCharacter *pHIKCharacter, HIKEvaluationState* pStanceState,
HIKNodeId pNodeId, FBModel* pModel )
{
int lNodeIdDesc[LastNodeId + 1];
HIKFillCharacterDescription(pHIKCharacter, lNodeIdDesc);
HIKDataDescription::HIKLocalSpace,
sizeof(KHIKNodeState),
lNodeIdDesc
};
lLT.mValue[0] = pStanceState->mDataSet[pNodeId].mTfv[0];
lLT.mValue[1] = pStanceState->mDataSet[pNodeId].mTfv[1];
lLT.mValue[2] = pStanceState->mDataSet[pNodeId].mTfv[2];
lLT.mValue[3] = pStanceState->mDataSet[pNodeId].mTfv[3];
lLQ.mValue[0] = pStanceState->mDataSet[pNodeId].mQfv[0];
lLQ.mValue[1] = pStanceState->mDataSet[pNodeId].mQfv[1];
lLQ.mValue[2] = pStanceState->mDataSet[pNodeId].mQfv[2];
lLQ.mValue[3] = pStanceState->mDataSet[pNodeId].mQfv[3];
lLS.mValue[0] = pStanceState->mDataSet[pNodeId].mSfv[0];
lLS.mValue[1] = pStanceState->mDataSet[pNodeId].mSfv[1];
lLS.mValue[2] = pStanceState->mDataSet[pNodeId].mSfv[2];
lLS.mValue[3] = pStanceState->mDataSet[pNodeId].mSfv[3];
}
bool GetNodeIdOrEffectIdFromModel( FBCharacterSolver* pSolver, FBModel* pModel,
int& pHIKNodeId,
int& pHIKEffectorId,
FBEffectorId& pEffectorId,
FBEffectorSetID& pPivotIndex )
{
pHIKNodeId = -1;
pHIKEffectorId = -1;
FBCharacter* lCharacter = pSolver->TargetCharacter;
OR_HIK_ASSERT(lCharacter && pSolver);
int lBodyNodeId = lCharacter->GetIndexByModel( pModel );
{
pHIKNodeId = FBBodyNodeIdToHIKNodeId((
FBBodyNodeId)lBodyNodeId);
return true;
}
const int lExtraBoneCount = pSolver->GetExtraBoneCount();
for(
int i = 0;
i < lExtraBoneCount;
i++)
{
if(pSolver->GetExtraBoneModelAt(
i) == pModel)
{
pHIKNodeId = ExtraIndexToHIKNodeId(
i);
return true;
}
}
lBodyNodeId = lCharacter->GetCtrlRigIndexByModel( pModel );
{
pHIKNodeId = FBBodyNodeIdToHIKNodeId((
FBBodyNodeId)lBodyNodeId);
return true;
}
const int lExtraFKCount = pSolver->GetExtraFKCount();
for(
int i = 0;
i < lExtraFKCount;
i++)
{
if(pSolver->GetExtraFKModelAt(
i) == pModel)
{
pHIKNodeId = ExtraIndexToHIKNodeId(
i);
return true;
}
}
OR_HIK_ASSERT(lExtraBoneCount == lExtraFKCount);
{
{
{
pHIKEffectorId = FBEffectorIdToHIKId(pEffectorId);
return true;
}
}
}
return false;
}
AnimationNode_Id::AnimationNode_Id()
{
mId = 0;
}
AnimationNode_Id::AnimationNode_Id(const AnimationNode_Id &pSource)
{
mId = pSource.mId;
}
AnimationNode_Id::AnimationNode_Id(const int pSource)
{
mId = pSource;
}
{
mId = ((pId+1) << 11) | 1;
OR_HIK_ASSERT( IsValidEffectorId() && (GetEffectorId() == pId) && IsValidNodeId() == false );
OR_HIK_ASSERT( IsValidType() == false );
}
AnimationNode_Id::AnimationNode_Id(
HIKNodeId pId)
{
int lEffectorId = HIKNodeIdToHIKEffectorId_LastInChain((
HIKNodeId)pId) & 0x3FF;
mId = ((lEffectorId+1) << 11) | ((pId+1) << 1) | 1;
OR_HIK_ASSERT( IsValidNodeId() && (GetEffectorId() == lEffectorId) && (GetNodeId() == pId));
OR_HIK_ASSERT( IsValidType() == false );
}
HIKHostNodeMB::HIKHostNodeMB()
{
Clear();
}
void HIKHostNodeMB::SetNode(FBModel *pNode, FBConstraint *pConstraint, AnimationNode_Id pConnectorId)
{
OR_HIK_ASSERT(pNode);
Clear();
mNode = pNode;
if(pNode->Is(FBModelMarker::TypeInfo))
{
FBModelMarker* lMarker = FBCast<FBModelMarker>(pNode);
{
mReachT = mNode->PropertyList.Find("IK Reach Translation",false);
mReachR = mNode->PropertyList.Find("IK Reach Rotation",false);
}
}
{
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;
}
static 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, FBEvaluateInfo* pEvalInfo)
{
FBMatrix *lMatrix = reinterpret_cast<FBMatrix *>(pXForm);
lMatrix->Identity();
if(Valid())
{
}
}
template <>
void HIKHostNode<HIKHostNodeMB>::WriteXForm(double *pXForm, FBEvaluateInfo* pEvalInfo)
{
if(Valid())
{
FBSVector lS;
if(Get().mDestTConn !=
NULL) Get().mDestTConn->WriteData(lT,pEvalInfo);
if(Get().mDestRConn !=
NULL) Get().mDestRConn->WriteData(lR,pEvalInfo);
if(Get().mDestSConn !=
NULL) Get().mDestSConn->WriteData(lS,pEvalInfo);
}
}
template <>
void HIKHostNode<HIKHostNodeMB>::WriteXFormCandidate(double *pXForm, FBEvaluateInfo* pEvalInfo)
{
if(Valid())
{
Get().mNode->SetMatrix( *reinterpret_cast<FBMatrix *>(pXForm),
kModelTransformation,
true,
false, pEvalInfo);
}
}
template <>
{
if(Valid())
{
pS.mValue[3]=1;
}
else
{
pT.Init();
pQ.Init();
pS.mValue[0]=pS.mValue[1]=pS.mValue[2]=pS.mValue[3]=1;
}
}
template <>
int HIKHostNode<HIKHostNodeMB>::IsEvaluationRecursiveTQS(FBEvaluateInfo* pEvalInfo)
{
int lRecursiveNodes = eNoRecursion;
if(Valid())
{
if(Get().mNode->Translation.GetAnimationNode() && Get().mNode->Translation.GetAnimationNode()->IsEvaluationRecursive(pEvalInfo))
{
lRecursiveNodes |= eRecursiveT;
}
if(Get().mNode->Rotation.GetAnimationNode() && Get().mNode->Rotation.GetAnimationNode()->IsEvaluationRecursive(pEvalInfo))
{
lRecursiveNodes |= eRecursiveR;
}
if(Get().mNode->Scaling.GetAnimationNode() && Get().mNode->Scaling.GetAnimationNode()->IsEvaluationRecursive(pEvalInfo))
{
lRecursiveNodes |= eRecursiveS;
}
}
return lRecursiveNodes;
}
template <>
{
if(Valid())
{
if(Get().mDestTConn !=
NULL) Get().mDestTConn->WriteData(pT.mValue,pEvalInfo);
if(Get().mDestRConn !=
NULL) Get().mDestRConn->WriteData(lR.mValue,pEvalInfo);
if(Get().mDestSConn !=
NULL) Get().mDestSConn->WriteData(pS.mValue,pEvalInfo);
}
}
template <>
{
if(Valid())
{
if(Get().mDestTConn !=
NULL)
{
if((pRecursivityInfo & eRecursiveT) > 0 )
{
Get().mDestTConn->DisableIfNotWritten(pEvalInfo);
}
else
{
Get().mDestTConn->WriteData(pT.mValue,pEvalInfo);
}
}
if(Get().mDestRConn !=
NULL)
{
if((pRecursivityInfo & eRecursiveR) > 0 )
{
Get().mDestRConn->DisableIfNotWritten(pEvalInfo);
}
else
{
Get().mDestRConn->WriteData(lR.mValue,pEvalInfo);
}
}
if(Get().mDestSConn !=
NULL)
{
if((pRecursivityInfo & eRecursiveS) > 0 )
{
Get().mDestSConn->DisableIfNotWritten(pEvalInfo);
}
else
{
Get().mDestSConn->WriteData(pS.mValue,pEvalInfo);
}
}
}
}
template <>
{
if(Valid())
{
}
}
template <>
{
if(Valid())
{
Get().mNode->Translation.SetGlobalCandidate( pT.mValue, sizeof(pT), pEvalInfo);
Get().mNode->Rotation.SetGlobalCandidate( lR.mValue, sizeof(lR), pEvalInfo);
Get().mNode->Scaling.SetGlobalCandidate( pS.mValue, sizeof(lR), pEvalInfo);
}
}
template <>
double HIKHostNode<HIKHostNodeMB>::ReadReachT( FBEvaluateInfo* pEvalInfo )
{
double lRet = 0.0;
if(Valid())
{
if(Get().mReachT !=
NULL)
{
double lValue = 0;
Get().mReachT->GetData(&lValue, sizeof(lValue), pEvalInfo);
lRet = dClamp( lValue/100.0, 0.0, 1.0);
}
}
return lRet;
}
template <>
double HIKHostNode<HIKHostNodeMB>::ReadReachR( FBEvaluateInfo* pEvalInfo )
{
double lRet = 0.0;
if(Valid())
{
if(Get().mReachR !=
NULL)
{
double lValue = 0;
Get().mReachR->GetData(&lValue, sizeof(lValue), pEvalInfo);
lRet = dClamp( lValue/100.0, 0.0, 1.0);
}
}
return lRet;
}
template <>
void HIKHostNode<HIKHostNodeMB>::ReadIKPivot(double *pIKPivot, FBEvaluateInfo* pEvalInfo )
{
if(Valid())
{
FBModelMarker* lMarker = dynamic_cast<FBModelMarker*>(Get().mNode);
{
lMarker->IKPivot.GetData(lVector, sizeof(lVector), pEvalInfo );
}
}
}
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())
{
mNode.mNode->GetVector(retVector,pWhat,pGlobalInfo,pEvalInfo);
}
else
{
retVector[0]=retVector[1]=retVector[2]=1;
else
retVector.Init();
}
}
template <>
bool HIKHostNode<HIKHostNodeMB>::GetUseTranslationLimits()
{
bool lRet = false;
if( Valid() && mNode.mNode->TranslationActive )
{
lRet = true;
}
return lRet;
}
template <>
bool HIKHostNode<HIKHostNodeMB>::GetUseRotationLimits()
{
bool lRet = false;
if( Valid() && mNode.mNode->RotationActive )
{
lRet = true;
}
return lRet;
}
template <>
int HIKHostNode<HIKHostNodeMB>::GetRotationOrder()
{
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 )
{
}
}
template <>
int HIKHostNode<HIKHostNodeMB>::GetRotationMinXYZ(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);
}
return lActiveMask;
}
template <>
int HIKHostNode<HIKHostNodeMB>::GetRotationMaxXYZ(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);
}
return lActiveMask;
}
template <>
int HIKHostNode<HIKHostNodeMB>::GetTranslationMinXYZ(double *pXYZ)
{
int lActiveMask = 0;
if(Valid() && mNode.mNode->TranslationActive )
{
*
reinterpret_cast<FBVector3d *
>(pXYZ) = mNode.mNode->TranslationMin;
}
return lActiveMask;
}
template <>
int HIKHostNode<HIKHostNodeMB>::GetTranslationMaxXYZ(double *pXYZ)
{
int lActiveMask = 0;
if(Valid() && mNode.mNode->TranslationActive )
{
*
reinterpret_cast<FBVector3d *
>(pXYZ) = mNode.mNode->TranslationMax;
}
return lActiveMask;
}
template <>
int HIKHostProperty<HIKHostPropertyMB>::ReadMode( FBEvaluateInfo* pEvalInfo )
{
int lMode = Get().mDefaultMode;
{
Get().mModeP->GetData(&lMode, sizeof(lMode));
}
return lMode;
}
template <>
double HIKHostProperty<HIKHostPropertyMB>::ReadValue( FBEvaluateInfo* pEvalInfo )
{
double lValue = Get().mDefaultValue;
if(Get().mValueP !=
NULL)
{
int lValueIndex = Get().mValueIndex;
Get().mValueP->GetData(&lVector, sizeof(lVector), pEvalInfo);
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)
{
float lX[16];
{
}
}
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);
}
}
}
}
}
}
}