#include "orcharactersolver_hik.h"
#include "filterset2fbcharacter.h"
ORCONSTRAINTHIK__CLASS,
ORCONSTRAINTHIK__LABEL,
ORCONSTRAINTHIK__DESC,
"character_solver.tif" );
int Actor2HIK[] =
{
HipsNodeId,
LeftHipNodeId,
LeftKneeNodeId,
LeftAnkleNodeId,
LeftFootNodeId,
RightHipNodeId,
RightKneeNodeId,
RightAnkleNodeId,
RightFootNodeId,
WaistNodeId,
Spine1NodeId,
LeftCollarNodeId,
LeftShoulderNodeId,
LeftElbowNodeId,
LeftWristNodeId,
RightCollarNodeId,
RightShoulderNodeId,
RightElbowNodeId,
RightWristNodeId,
NeckNodeId,
HeadNodeId,
LeftThumbANodeId,
LeftThumbBNodeId,
LeftThumbCNodeId,
LeftIndexANodeId,
LeftIndexBNodeId,
LeftIndexCNodeId,
LeftMiddleANodeId,
LeftMiddleBNodeId,
LeftMiddleCNodeId,
LeftRingANodeId,
LeftRingBNodeId,
LeftRingCNodeId,
LeftPinkyANodeId,
LeftPinkyBNodeId,
LeftPinkyCNodeId,
RightThumbANodeId,
RightThumbBNodeId,
RightThumbCNodeId,
RightIndexANodeId,
RightIndexBNodeId,
RightIndexCNodeId,
RightMiddleANodeId,
RightMiddleBNodeId,
RightMiddleCNodeId,
RightRingANodeId,
RightRingBNodeId,
RightRingCNodeId,
RightPinkyANodeId,
RightPinkyBNodeId,
RightPinkyCNodeId,
ReferenceNodeId,
};
static void LegSNSSet(
HIObject pObject,
bool pValue)
{
ORCharacterSolver_HIK* lConstraint = FBCast<ORCharacterSolver_HIK>(pObject);
int LegFilter = (HIKSolvingStepLeftLegSnS | HIKSolvingStepRightLegSnS);
if(pValue)
lConstraint->SolvingStepFilter |= LegFilter;
else
lConstraint->SolvingStepFilter &= ~LegFilter;
lConstraint->LegSNS.SetPropertyValue(pValue);
lConstraint->mHIKCharacterHostEvaluator.SetSolvingStep( lConstraint->SolvingStepFilter );
lConstraint->mHIKControlRigHostEvaluator.SetSolvingStep( lConstraint->SolvingStepFilter );
}
static void ArmSNSSet(
HIObject pObject,
bool pValue)
{
ORCharacterSolver_HIK* lConstraint = FBCast<ORCharacterSolver_HIK>(pObject);
int ArmFilter = (HIKSolvingStepLeftArmSnS | HIKSolvingStepRightArmSnS);
if(pValue)
lConstraint->SolvingStepFilter |= ArmFilter;
else
lConstraint->SolvingStepFilter &= ~ArmFilter;
lConstraint->ArmSNS.SetPropertyValue(pValue);
lConstraint->mHIKCharacterHostEvaluator.SetSolvingStep( lConstraint->SolvingStepFilter );
lConstraint->mHIKControlRigHostEvaluator.SetSolvingStep( lConstraint->SolvingStepFilter );
}
int ORCharacterSolver_HIK::mInternalPropertiesCount = 0;
int ORCharacterSolver_HIK::mSolverPropertiesCount = 0;
bool ORCharacterSolver_HIK::FBCreate()
{
mHIKEffectorSetStatePlot =
NULL;
mHIKCharacterStateStance =
NULL;
mHIKCharacterDebug =
NULL;
mHIKCharacterStateDebug =
NULL;
mHIKCharacterStateOutDebug =
NULL;
mHIKEffectorSetStateDebug =
NULL;
mHIKPropertySetStateDebug =
NULL;
mControlSetManipulator =
NULL;
mEvaluationId = -1;
mAlreadyConnected = false;
HIKHostPropertiesInit(mHIKCharacterHost);
HIKHostPropertiesInit(mHIKCharacterHostSrc);
HIKHostPropertiesInit(mHIKCharacterHostDebug);
mApplication.OnFileNewCompleted.Add(
this, (
FBCallback)&ORCharacterSolver_HIK::EventListen );
mApplication.OnFileOpenCompleted.Add(
this, (
FBCallback)&ORCharacterSolver_HIK::EventListen );
mApplication.OnFileNew.Add(
this, (
FBCallback)&ORCharacterSolver_HIK::EventSuspend );
mApplication.OnFileOpen.Add(
this, (
FBCallback)&ORCharacterSolver_HIK::EventSuspend );
mApplication.OnFileExit.Add(
this, (
FBCallback)&ORCharacterSolver_HIK::EventSuspend );
ExtraCollarRatio.SetMinMax(0.,100.);
CollarStiffnessX.SetMinMax(-100.,100.);
CollarStiffnessY.SetMinMax(-100.,100.);
CollarStiffnessZ.SetMinMax(-100.,100.);
ReachLeftShoulder.SetMinMax(0, 100);
ReachRightShoulder.SetMinMax(0, 100);
RealisticLeftKneeSolving.SetMinMax(0, 100);
RealisticRightKneeSolving.SetMinMax(0, 100);
StretchStartArmsAndLegs.SetMinMax(0,100);
StretchStopArmsAndLegs.SetMinMax(100,200);
SnSScaleArmsAndLegs.SetMinMax(0,100);
SnSReachLeftWrist.SetMinMax(0,100);
SnSReachRightWrist.SetMinMax(0,100);
SnSReachLeftAnkle.SetMinMax(0,100);
SnSReachRightAnkle.SetMinMax(0,100);
SnSScaleSpine.SetMinMax(0,100);
SnSScaleSpineChildren.SetMinMax(0,100);
SnSSpineFreedom.SetMinMax(0,100);
SnSReachChestEnd.SetMinMax(0,100);
SnSScaleNeck.SetMinMax(0,100);
SnSNeckFreedom.SetMinMax(0,100);
SnSReachHead.SetMinMax(0,100);
ResetPropertiesToDefault();
SolvingStepFilter = HIKSolvingStepAll;
if( mInternalPropertiesCount == 0 && mSolverPropertiesCount == 0 )
{
ORCharacterSolver_HIK lSolver("TestSolver");
mInternalPropertiesCount = lSolver.PropertyList.GetCount();
lSolver.FBCreate();
mSolverPropertiesCount = lSolver.PropertyList.GetCount();
}
return true;
}
void ORCharacterSolver_HIK::FBDestroy()
{
if(mHIKCharacter !=
NULL)
{
HIKCharacterDestroy(mHIKCharacter,&free);
}
if(mHIKCharacterSrc !=
NULL)
{
HIKCharacterDestroy(mHIKCharacterSrc,&free);
}
if(mHIKCharacterSrc !=
NULL)
{
HIKCharacterDestroy(mHIKCharacterSrc,&free);
}
{
HIKCharacterDestroy(mHIKActorSrc,&free);
}
if(mHIKEffectorSetStatePlot !=
NULL)
{
HIKEffectorSetStateDestroy(mHIKEffectorSetStatePlot,&free);
mHIKEffectorSetStatePlot =
NULL;
}
if(mHIKCharacterStateStance !=
NULL)
{
HIKCharacterStateDestroy(mHIKCharacterStateStance,&free);
mHIKCharacterStateStance =
NULL;
}
if(mHIKCharacterDebug !=
NULL)
{
HIKCharacterDestroy(mHIKCharacterDebug,&free);
}
if(mHIKCharacterStateDebug !=
NULL)
{
HIKCharacterStateDestroy(mHIKCharacterStateDebug,&free);
mHIKCharacterStateDebug =
NULL;
}
if(mHIKCharacterStateOutDebug !=
NULL)
{
HIKCharacterStateDestroy(mHIKCharacterStateOutDebug,&free);
mHIKCharacterStateOutDebug =
NULL;
}
if(mHIKEffectorSetStateDebug !=
NULL)
{
HIKEffectorSetStateDestroy(mHIKEffectorSetStateDebug,&free);
mHIKEffectorSetStateDebug =
NULL;
}
if(mHIKPropertySetStateDebug !=
NULL)
{
HIKPropertySetStateDestroy(mHIKPropertySetStateDebug,&free);
mHIKPropertySetStateDebug =
NULL;
}
RemoveAllAnimationNodes();
}
static bool SolveDestinationOnControlRig(FBCharacter* pCharacter)
{
if(pCharacter->IsPlottingActorToCtrlRig())
{
FBControlSet* lControlSet = pCharacter->GetCurrentControlSet(true);
}
return false;
}
void ORCharacterSolver_HIK::SetupAllAnimationNodes()
{
FBCharacter* lCharacter = TargetCharacter;
FBComponent* lSource = Source;
FBCharacter* lCharacterSrc = dynamic_cast<FBCharacter*>(lSource);
FBControlSet* lControlRig = dynamic_cast<FBControlSet*>(lSource);
mActorSrc = dynamic_cast<FBActor*>(lSource);
if(lCharacter !=
NULL && lCharacter->GetCharacterize())
{
if(mControlSetManipulator)
{
mControlSetManipulator->DeallocateState();
mControlSetManipulator->AllocateState(lCharacter);
}
SetupTargetCharacter(lCharacter);
SetupAutoProperties(lCharacter);
{
SetupInputControlRig( lControlRig, GetRigAlign() );
}
else if(lCharacterSrc !=
NULL)
{
HIKCharacterHostFromMBCharacterHierarchy(mHIKCharacterHostSrc,lCharacterSrc,
NULL);
mHIKCharacterSrc = mHIKCharacterHostSrc.CharacterCreate(&malloc);
HIKCharacterHostFromMBCharacterGeometry(mHIKCharacterHostSrc,mHIKCharacterSrc,lCharacterSrc);
HIKCharacterizeGeometry(mHIKCharacterSrc);
HIKHostPropertiesFromCharacter(mHIKCharacterHostSrc,lCharacterSrc);
mHIKCharacterHostEvaluator.Init(mHIKCharacter,&mHIKCharacterHost,mHIKCharacterSrc,&mHIKCharacterHostSrc,&malloc);
RegisterExtraProperties(mHIKCharacterHostSrc);
}
else if(mActorSrc !=
NULL)
{
HIKCharacterDefinition lHIKDef;
for(int lNodeIter = 0; lNodeIter < LastNodeId; lNodeIter++)
{
lHIKDef.mUsedNodes[lNodeIter] = HIKNodeNotUsed;
}
{
lHIKDef.mUsedNodes[Actor2HIK[lActorIter]] |= HIKNodeUsed;
}
mHIKActorSrc = HIKCharacterCreate(&lHIKDef,&malloc,AutodeskCustomerString,AutodeskCustomerKey);
FBSkeletonState* lSkeletonState = mActorSrc->GetDefaultSkeletonState();
FBMatrix lGX;
if (lSkeletonState)
{
{
FBMatrix lGX;
FBSVector lGS;
HIKSetCharacterizeNodeStatedv(mHIKActorSrc,Actor2HIK[lActorIter], (double*)lGX);
}
}
HIKCharacterizeGeometry(mHIKActorSrc);
mHIKCharacterHostEvaluator.Init(mHIKCharacter,&mHIKCharacterHost,mHIKActorSrc,
NULL,&malloc);
}
if (lPlotToRig)
{
SetupInputControlRig( lCharacter->GetCurrentControlSet(
true),
true );
}
}
mHIKCharacterHostEvaluator.SetSolvingStep( SolvingStepFilter );
mHIKControlRigHostEvaluator.SetSolvingStep( SolvingStepFilter );
GetState(0);
}
void ORCharacterSolver_HIK::SetupTargetCharacter(FBCharacter* pCharacter)
{
HIKCharacterHostFromMBCharacterHierarchy(mHIKCharacterHost,pCharacter,this, SolveDestinationOnControlRig(pCharacter));
FBModel *lLeftShoulderExtra = GetExtraBoneModelAt(LEFT_EXTRA_COLLAR);
FBModel *lRightShoulderExtra = GetExtraBoneModelAt(RIGHT_EXTRA_COLLAR);
if (lLeftShoulderExtra || lRightShoulderExtra)
HIKCharacterHostFromHIKHostMB(mHIKCharacterHost, lLeftShoulderExtra, lRightShoulderExtra, this);
mHIKCharacter = mHIKCharacterHost.CharacterCreate(&malloc);
HIKCharacterHostFromMBCharacterGeometry(mHIKCharacterHost,mHIKCharacter,pCharacter);
if(lLeftShoulderExtra || lRightShoulderExtra)
{
FBRVector lLeftR, lRightR, lLeftRPOff, lRightRPOff;
FBSVector lLeftS, lRightS;
GetTransformOffset(lLeftT, lLeftR, lLeftS, LEFT_EXTRA_COLLAR);
GetParentRotationOffset(lLeftRPOff, LEFT_EXTRA_COLLAR);
GetTransformOffset(lRightT, lRightR, lRightS, RIGHT_EXTRA_COLLAR);
GetParentRotationOffset(lRightRPOff, RIGHT_EXTRA_COLLAR);
CharacterizeHIKCharacterHostFromHIKHostMB(mHIKCharacterHost,mHIKCharacter,
lLeftT, lLeftQ, lLeftS, lLeftQPOff,
lRightT, lRightQ, lRightS, lRightQPOff);
}
HIKCharacterizeGeometry(mHIKCharacter);
HIKInverseJoint(mHIKCharacter,HIKLeftKnee, pCharacter->InverseLeftKnee);
HIKInverseJoint(mHIKCharacter,HIKRightKnee, pCharacter->InverseRightKnee);
HIKInverseJoint(mHIKCharacter,HIKLeftElbow, pCharacter->InverseLeftElbow);
HIKInverseJoint(mHIKCharacter,HIKRightElbow, pCharacter->InverseRightElbow);
HIKHostPropertiesFromCharacter(mHIKCharacterHost,pCharacter);
RegisterExtraProperties(mHIKCharacterHost);
mHIKCharacterStateStance = HIKCharacterStateCreate(mHIKCharacter, &malloc);
HIKGetDefaultState(mHIKCharacter, mHIKCharacterStateStance);
}
void ORCharacterSolver_HIK::SetupExtraFK(FBCharacter* pCharacter, int pExtraBoneId, FBModelMarker** pExtraMarker)
{
FBSVector lS;
if((*pExtraMarker))
{
if((*pExtraMarker)->Children.GetCount() == 0)
{
(*pExtraMarker)->FBDelete();
}
}
if (!(*pExtraMarker))
{
(*pExtraMarker) = new FBModelMarker(pExtraBoneId == LEFT_EXTRA_COLLAR ? "Left Shoulder Extra FK" : "Right Shoulder Extra FK");
SetExtraFKModelAt((*pExtraMarker), pExtraBoneId );
if (lShoulderFK)
{
for (int lIter = 0; lIter < lShoulderFK->Children.GetCount(); lIter++)
{
FBModel *lChild = dynamic_cast<FBModel*>(lShoulderFK->Children.GetAt(lIter));
(*pExtraMarker)->Children.Add( lChild );
}
lShoulderFK->Children.RemoveAll();
lShoulderFK->Children.Add((*pExtraMarker));
lParent = lShoulderFK;
}
}
else
{
lParent = (*pExtraMarker);
}
FBModel *lShoulderExtraBone = GetExtraBoneModelAt(pExtraBoneId);
for (int lIter = 0; lIter < lShoulderExtraBone->Children.GetCount(); lIter++)
{
FBModel *lChild = dynamic_cast<FBModel*>(lShoulderExtraBone->Children.GetAt(lIter));
FBMatrix lMatrix;
pCharacter->GetTransformOffset(pCharacter->GetIndexByModel(lChild), &lMatrix);
FBModel* lChildFK = dynamic_cast<FBModel*>(lParent->Children.GetAt(lIter));
lT.Set(lTVector);
lChildFK->SetVector(lT);
}
GetTransformOffset(lT, lR, lS, pExtraBoneId);
}
void ORCharacterSolver_HIK::SetupInputControlRig(FBControlSet* pControlRig, bool pConstraintRig )
{
FBModelMarker* lLeftShoulderExtraFK =
NULL;
FBModelMarker* lRightShoulderExtraFK =
NULL;
if(GetExtraBoneModelAt(LEFT_EXTRA_COLLAR) || GetExtraBoneModelAt(RIGHT_EXTRA_COLLAR) )
{
FBCharacter* lCharacter = TargetCharacter;
lLeftShoulderExtraFK = dynamic_cast<FBModelMarker*>(GetExtraFKModelAt(LEFT_EXTRA_COLLAR));
lRightShoulderExtraFK = dynamic_cast<FBModelMarker*>(GetExtraFKModelAt(RIGHT_EXTRA_COLLAR));
FBMatrix lMatrix;
FBSVector lS;
if( GetExtraBoneModelAt(LEFT_EXTRA_COLLAR) )
{
SetupExtraFK(lCharacter, LEFT_EXTRA_COLLAR, &lLeftShoulderExtraFK);
}
if( GetExtraBoneModelAt(RIGHT_EXTRA_COLLAR) )
{
SetupExtraFK(lCharacter, RIGHT_EXTRA_COLLAR, &lRightShoulderExtraFK);
GetTransformOffset(lT, lR, lS, RIGHT_EXTRA_COLLAR);
}
}
HIKControlRigHostFromMBControlRig(mHIKControlRigHost, pControlRig, (pConstraintRig) ?
this :
NULL );
HIKExtraShoulderControlRigHost(mHIKControlRigHost,lLeftShoulderExtraFK, lRightShoulderExtraFK, (pConstraintRig) ?
this :
NULL );
mHIKControlRigHostEvaluator.Init(mHIKCharacter,&mHIKCharacterHost,&mHIKControlRigHost, &malloc);
}
void ORCharacterSolver_HIK::SetupAutoProperties(FBCharacter* pCharacter)
{
for (
int i = 0;
i < HIKLastPropertyId;
i++ )
{
if ( HIKGetPropertyInfoModeType(
i) == HIKPropertyOffAutoUser || HIKGetPropertyInfoModeType(
i) == HIKPropertyAutoUser )
{
FBAnimationNode* lANode = AnimationNodeInCreate( 2000+
i, mHIKCharacterHost.GetProperty(
i).Get().mValueP );
if (lANode)
mAutoPropertyConnArray.Add( lANode );
}
}
}
void ORCharacterSolver_HIK::RemoveAllAnimationNodes()
{
if(mHIKCharacter !=
NULL)
{
HIKCharacterDestroy(mHIKCharacter,&free);
}
if(mHIKCharacterSrc !=
NULL)
{
HIKCharacterDestroy(mHIKCharacterSrc,&free);
}
{
HIKCharacterDestroy(mHIKActorSrc,&free);
}
for(int lNodeIter = 0; lNodeIter < LastNodeId; lNodeIter++)
{
mHIKCharacterHost.GetNode(lNodeIter).Get().Clear();
mHIKCharacterHostSrc.GetNode(lNodeIter).Get().Clear();
mHIKControlRigHost.GetNode(lNodeIter).Get().Clear();
}
{
{
mHIKControlRigHost.GetEffector(lEffIter,lSetIter).Get().Clear();
}
}
mHIKControlRigHostEvaluator.Clear(&free);
mHIKCharacterHostEvaluator.Clear(&free);
mAutoPropertyConnArray.Clear();
ClearStates();
}
bool ORCharacterSolver_HIK::FbxStore( FBFbxObject* pFbxObject,
kFbxObjectStore pStoreWhat )
{
return true;
}
bool ORCharacterSolver_HIK::FbxRetrieve( FBFbxObject* pFbxObject,
kFbxObjectStore pStoreWhat )
{
return true;
}
void ORCharacterSolver_HIK::FreezeSuggested()
{
FBConstraint::FreezeSuggested();
if( ReferenceGet( 0,0 ) )
{
FreezeSRT( (FBModel*)ReferenceGet( 0, 0), true, true, true );
}
}
HIKEvaluationState* ORCharacterSolver_HIK::EvaluationStateCreator()
{
HIKEvaluationState* lNewState = new HIKEvaluationState();
bool lInitControlRig = (mHIKControlRigHostEvaluator.mHIKCharacter !=
NULL);
{
lNewState->Init(mHIKCharacter, mHIKActorSrc, lInitControlRig, &malloc);
}
else
{
lNewState->Init(mHIKCharacter, mHIKCharacterSrc, lInitControlRig, &malloc);
}
return lNewState;
}
bool ORCharacterSolver_HIK::AnimationNodeNotify(FBAnimationNode* pConnector,FBEvaluateInfo* pEvaluateInfo,FBConstraintInfo* pConstraintInfo)
{
if(pEvaluateInfo->GetRecursionLevel(this) > 0)
{
return false;
}
if(mHIKControlRigHostEvaluator.mHIKCharacterHost)
{
if(mHIKControlRigHostEvaluator.mHIKCharacterHost->GetNode(ReferenceNodeId).Valid())
{
if( mHIKControlRigHostEvaluator.mHIKCharacterHost->GetNode(ReferenceNodeId).Get().IsDestinationConn(pConnector) )
return false;
}
}
if(mHIKControlRigHostEvaluator.mHIKControlRigHost)
{
if(mHIKControlRigHostEvaluator.mHIKControlRigHost->GetNode(ReferenceNodeId).Valid())
{
if( mHIKControlRigHostEvaluator.mHIKControlRigHost->GetNode(ReferenceNodeId).Get().IsDestinationConn(pConnector) )
return false;
}
}
HIKEvaluationState* lCurrentState = GetState(pEvaluateInfo);
if(lCurrentState->mEvaluateId != pEvaluateInfo->GetEvaluationID())
{
lCurrentState->mEvaluateId = pEvaluateInfo->GetEvaluationID();
{
mActorSrc->UpdateValues(pEvaluateInfo);
FBMatrix lGX;
FBSVector lGS;
FBSkeletonState* lSkeletonState = mActorSrc->GetCurrentSkeletonState ();
{
HIKSetNodeStatedv(mHIKCharacterHostEvaluator.mHIKCharacterSrc, lCurrentState->mStateSrc,Actor2HIK[lActorIter], (double*)lGX);
}
for(int lPIter = 0; lPIter < HIKLastPropertyId; lPIter++)
{
HIKSetPropertyMode(lCurrentState->mSrcPropertySetState,lPIter,HIKGetPropertyInfoDefaultMode(lPIter));
if(lPIter == HIKFootBottomToAnkleId)
{
FBSVector lGS;
HIKSetPropertyValue(lCurrentState->mSrcPropertySetState,lPIter,7.5f*lGS[1]);
}
else
{
HIKSetPropertyValue(lCurrentState->mSrcPropertySetState,lPIter,HIKGetPropertyInfoDefaultValue(lPIter));
}
}
}
if(mHIKCharacterHostEvaluator.mHIKCharacterDst != 0)
{
mHIKCharacterHostEvaluator.Read(pEvaluateInfo, lCurrentState);
if(lCurrentState->mDstPropertySetState)
{
HIKSetPropertyValue( lCurrentState->mDstPropertySetState, HIKChestTOffsetXId, -1.0 * HIKGetPropertyValue(lCurrentState->mDstPropertySetState, HIKChestTOffsetXId));
HIKSetPropertyValue( lCurrentState->mDstPropertySetState, HIKChestTOffsetYId, -1.0 * HIKGetPropertyValue(lCurrentState->mDstPropertySetState, HIKChestTOffsetYId));
HIKSetPropertyValue( lCurrentState->mDstPropertySetState, HIKChestTOffsetZId, -1.0 * HIKGetPropertyValue(lCurrentState->mDstPropertySetState, HIKChestTOffsetZId));
}
FBCharacter* lCharacter = TargetCharacter;
mHIKCharacterHostEvaluator.Solve(lCurrentState);
mHIKCharacterHostEvaluator.Write(pEvaluateInfo, lCurrentState, SolveDestinationOnControlRig(lCharacter));
if(lCharacter->IsPlottingActorToCtrlRig())
{
if(mHIKEffectorSetStatePlot ==
NULL)
{
mHIKEffectorSetStatePlot = HIKEffectorSetStateCreate(&malloc);
}
HIKEffectorSetFromCharacter(mHIKCharacterHostEvaluator.mHIKCharacterDst, mHIKEffectorSetStatePlot,
lCurrentState->mStateDst, lCurrentState->mDstPropertySetState);
if(mHIKControlRigHostEvaluator.mHIKControlRigHost)
{
mHIKControlRigHostEvaluator.mHIKControlRigHost->WriteEffectors(mHIKEffectorSetStatePlot, pEvaluateInfo, false);
mHIKControlRigHostEvaluator.mHIKControlRigHost->WriteState(mHIKControlRigHostEvaluator.mHIKCharacter, lCurrentState->mStateDst, pEvaluateInfo, true);
}
}
}
else if(mHIKControlRigHostEvaluator.mHIKCharacter != 0)
{
if (lPlotToRig)
{
mHIKControlRigHostEvaluator.ReadSkeletonSolveOnRig(pEvaluateInfo,lCurrentState);
mHIKControlRigHost.WriteState(mHIKCharacter, lCurrentState->mCRState, pEvaluateInfo, true);
FBControlSet* lCtrlSet = TargetCharacter->GetCurrentControlSet(true);
for(
int lIKIter =
kFBHipsEffectorId; lIKIter < kFBLastEffectorId && mHIKControlRigHostEvaluator.mHIKControlRigHost; lIKIter++)
{
int lPivotCount = lCtrlSet->GetIKEffectorPivotCount((
FBEffectorId)lIKIter);
for(int lPivotIter = 0; lPivotIter < lPivotCount; lPivotIter++)
{
if ( mHIKControlRigHostEvaluator.mHIKControlRigHost->GetEffector(lIKIter,lPivotIter).Valid() )
{
HIKGetEffectorStateTQSdv(lCurrentState->mCREffectorSetState, lIKIter, lT.mValue, lQ.mValue, lS.mValue);
mHIKControlRigHostEvaluator.mHIKControlRigHost->GetEffector(lIKIter,lPivotIter).Get().mDestTConn->WriteData(lT,pEvaluateInfo);
mHIKControlRigHostEvaluator.mHIKControlRigHost->GetEffector(lIKIter,lPivotIter).Get().mDestRConn->WriteData(lRot,pEvaluateInfo);
mHIKControlRigHostEvaluator.mHIKControlRigHost->GetEffector(lIKIter,lPivotIter).Get().mDestSConn->WriteData(lS,pEvaluateInfo);
}
}
}
}
else
{
FBControlSet* lControlSet = TargetCharacter->GetCurrentControlSet(true);
FBEvaluateInfo* lEvaluation = GetRigAlign() ? BackgroundEvaluateInfoBegin(pEvaluateInfo) : pEvaluateInfo;
mHIKControlRigHostEvaluator.Read(lEvaluation,lControlSet->ControlSetType ==
kFBControlSetTypeFKIK,lCurrentState);
mHIKControlRigHostEvaluator.Solve(lCurrentState);
mHIKControlRigHostEvaluator.Write(pEvaluateInfo,lCurrentState,GetRigAlign());
if(!GetRigAlign())
SyncPivot(lControlSet);
else
BackgroundEvaluateInfoEnd(lEvaluation);
}
}
else
{
mHIKCharacterHost.WriteState(mHIKCharacter, mHIKCharacterStateStance, pEvaluateInfo, false);
}
}
HIKPropertySetState * lPropState = (lCurrentState->mDstPropertySetState) ? lCurrentState->mDstPropertySetState : lCurrentState->mCRPropertySetState;
if (lPropState)
{
int lHIKPropIndex = pConnector->Reference - 2000;
if ( lHIKPropIndex >= 0 && lHIKPropIndex < HIKLastPropertyId)
{
if ( HIKIsPropertyAuto(lPropState, lHIKPropIndex) )
{
double lValue = HIKGetPropertyValue( lPropState, lHIKPropIndex );
pConnector->WriteData(&lValue, pEvaluateInfo);
}
}
}
return true;
}
FBCharacterManipulatorCtrlSet* ORCharacterSolver_HIK::CreateCharacterManipulatorCtrlSet(const char* pName)
{
mControlSetManipulator = new ORCharacterManipulatorCtrlSet(pName);
mControlSetManipulator->FBCreate();
return mControlSetManipulator;
}
void ORCharacterSolver_HIK::EventListen(
HISender pSender,
HKEvent pEvent )
{
if(!mAlreadyConnected)
{
mSystem.OnConnectionNotify.Add(
this, (
FBCallback)&ORCharacterSolver_HIK::ConnectionNotify);
mAlreadyConnected = true;
}
}
void ORCharacterSolver_HIK::EventSuspend(
HISender pSender,
HKEvent pEvent )
{
if(mAlreadyConnected)
{
mSystem.OnConnectionNotify.Remove(
this, (
FBCallback)&ORCharacterSolver_HIK::ConnectionNotify);
mAlreadyConnected = false;
}
}
{
}
int ORCharacterSolver_HIK::GetExtraFKCount()
{
return 2;
}
FBString gLeftExtraCollar_FK = FBString(HIKNodeNameFromNodeId(LeftCollarExtraNodeId)) + "_FK";
FBString gRightExtraCollar_FK = FBString(HIKNodeNameFromNodeId(RightCollarExtraNodeId)) + "_FK";
const char* ORCharacterSolver_HIK::GetExtraFKNameAt(int pIndex)
{
switch (pIndex)
{
case LEFT_EXTRA_COLLAR:
return gLeftExtraCollar_FK;
break;
case RIGHT_EXTRA_COLLAR:
return gRightExtraCollar_FK;
break;
}
}
FBBodyPartId ORCharacterSolver_HIK::GetExtraFKBodyPartAt(
int pIndex)
{
switch (pIndex)
{
case LEFT_EXTRA_COLLAR:
break;
case RIGHT_EXTRA_COLLAR:
break;
}
}
int ORCharacterSolver_HIK::GetExtraBoneCount()
{
return 2;
}
const char* ORCharacterSolver_HIK::GetExtraBoneNameAt(int pIndex)
{
switch (pIndex)
{
case LEFT_EXTRA_COLLAR:
return HIKNodeNameFromNodeId(LeftCollarExtraNodeId);
break;
case RIGHT_EXTRA_COLLAR:
return HIKNodeNameFromNodeId(RightCollarExtraNodeId);
break;
}
}
FBBodyPartId ORCharacterSolver_HIK::GetExtraBoneBodyPartAt(
int pIndex)
{
switch (pIndex)
{
case LEFT_EXTRA_COLLAR:
break;
case RIGHT_EXTRA_COLLAR:
break;
}
}
void ORCharacterSolver_HIK::RegisterExtraProperties(HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> &pHIKCharacterHost)
{
pHIKCharacterHost.GetProperty(HIKExtraCollarRatioId).Get().Init(
NULL, &ExtraCollarRatio, 0,100.f,
false);
pHIKCharacterHost.GetProperty(HIKCollarStiffnessX).Get().Init(
NULL, &CollarStiffnessX, 0, 100.f,
false);
pHIKCharacterHost.GetProperty(HIKCollarStiffnessY).Get().Init(
NULL, &CollarStiffnessY, 0,100.f,
false);
pHIKCharacterHost.GetProperty(HIKCollarStiffnessZ).Get().Init(
NULL, &CollarStiffnessZ, 0, 100.f,
false);
pHIKCharacterHost.GetProperty(HIKReachActorLeftShoulderId).Get().Init(
NULL, &ReachLeftShoulder, 0, 100.f,
false);
pHIKCharacterHost.GetProperty(HIKReachActorRightShoulderId).Get().Init(
NULL, &ReachRightShoulder, 0, 100.f,
false);
pHIKCharacterHost.GetProperty(HIKFingerPropagationId).Get().Init(&FingerSolvingPropagation,
NULL, 0, 1.f,
false);
pHIKCharacterHost.GetProperty(HIKRealisticLeftKneeSolvingId).Get().Init(
NULL, &RealisticLeftKneeSolving, 0, 100.f,
false);
pHIKCharacterHost.GetProperty(HIKRealisticRightKneeSolvingId).Get().Init(
NULL, &RealisticRightKneeSolving, 0, 100.f,
false);
pHIKCharacterHost.GetProperty(HIKStretchStartArmsAndLegs).Get().Init(
NULL, &StretchStartArmsAndLegs,0,100,
false);
pHIKCharacterHost.GetProperty(HIKStretchStopArmsAndLegs).Get().Init(
NULL, &StretchStopArmsAndLegs,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSScaleArmsAndLegs).Get().Init(
NULL, &SnSScaleArmsAndLegs,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSReachLeftWrist).Get().Init(
NULL, &SnSReachLeftWrist,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSReachRightWrist).Get().Init(
NULL, &SnSReachRightWrist,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSReachLeftAnkle).Get().Init(
NULL, &SnSReachLeftAnkle,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSReachRightAnkle).Get().Init(
NULL, &SnSReachRightAnkle,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSScaleSpine).Get().Init(
NULL, &SnSScaleSpine,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSScaleSpineChildren).Get().Init(
NULL, &SnSScaleSpineChildren,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSSpineFreedom).Get().Init(
NULL, &SnSSpineFreedom,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSReachChestEnd).Get().Init(
NULL, &SnSReachChestEnd,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSScaleNeck).Get().Init(
NULL, &SnSScaleNeck,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSNeckFreedom).Get().Init(
NULL, &SnSNeckFreedom,0,100,
false);
pHIKCharacterHost.GetProperty(HIKSnSReachHead).Get().Init(
NULL, &SnSReachHead,0,100,
false);
}
void ORCharacterSolver_HIK::ResetExtraProperties()
{
RemoveAnimations();
ResetPropertiesToDefault();
}
void ORCharacterSolver_HIK::ResetPropertiesToDefault()
{
Weight = 100;
ExtraCollarRatio = 50;
CollarStiffnessX = 0;
CollarStiffnessY = 0;
CollarStiffnessZ = 0;
ReachLeftShoulder = 0;
ReachRightShoulder = 0;
FingerSolvingPropagation = false;
RealisticLeftKneeSolving = 0;
RealisticRightKneeSolving = 0;
LegSNS = false;
ArmSNS = false;
StretchStartArmsAndLegs = HIKGetPropertyInfoDefaultValue(HIKStretchStartArmsAndLegs) * 100;
StretchStopArmsAndLegs = HIKGetPropertyInfoDefaultValue(HIKStretchStopArmsAndLegs) * 100;
SnSScaleArmsAndLegs = HIKGetPropertyInfoDefaultValue(HIKSnSScaleArmsAndLegs) * 100;
SnSReachLeftWrist = HIKGetPropertyInfoDefaultValue(HIKSnSReachLeftWrist) * 100;
SnSReachRightWrist = HIKGetPropertyInfoDefaultValue(HIKSnSReachRightWrist) * 100;
SnSReachLeftAnkle = HIKGetPropertyInfoDefaultValue(HIKSnSReachLeftAnkle) * 100;
SnSReachRightAnkle = HIKGetPropertyInfoDefaultValue(HIKSnSReachRightAnkle) * 100;
SnSScaleSpine = HIKGetPropertyInfoDefaultValue(HIKSnSScaleSpine) * 100;
SnSScaleSpineChildren = HIKGetPropertyInfoDefaultValue(HIKSnSScaleSpineChildren) * 100;
SnSSpineFreedom = HIKGetPropertyInfoDefaultValue(HIKSnSSpineFreedom) * 100;
SnSReachChestEnd = HIKGetPropertyInfoDefaultValue(HIKSnSReachChestEnd) * 100;
SnSScaleNeck = HIKGetPropertyInfoDefaultValue(HIKSnSScaleNeck) * 100;
SnSNeckFreedom = HIKGetPropertyInfoDefaultValue(HIKSnSNeckFreedom) * 100;
SnSReachHead = HIKGetPropertyInfoDefaultValue(HIKSnSReachHead) * 100;
}
void ORCharacterSolver_HIK::RemoveAnimations()
{
FBUndoManager lUndoManager;
const int lPropertyCount = mSolverPropertiesCount < PropertyList.GetCount() ? mSolverPropertiesCount : PropertyList.GetCount();
for( int lPropID = mInternalPropertiesCount; lPropID < lPropertyCount; ++lPropID )
{
FBProperty* lProp = PropertyList[lPropID];
{
if( lUndoManager.TransactionIsOpen() )
lUndoManager.TransactionAddProperty(lProp);
if( lProp->IsAnimatable() )
{
FBPropertyAnimatable* lEvalProp = (FBPropertyAnimatable*) lProp;
if(lEvalProp)
lEvalProp->SetAnimated(false);
}
}
}
if( lUndoManager.TransactionIsOpen() )
lUndoManager.TransactionAddProperty( &Weight );
Weight.SetAnimated(false);
}
void ORCharacterSolver_HIK::SyncPivot(FBControlSet* pControlSet)
{
if(!pControlSet)
return;
HIKEvaluationState* lCurrentState = GetState(lEvalInfo);
{
{
FBModelMarker* lPivotEffector =
dynamic_cast<FBModelMarker*
>(pControlSet->GetIKEffectorModel((
FBEffectorId)lIter, lSetIter));
if(lPivotEffector && lPivotEffector->IKSync)
{
lPivotEffector->IKPivot.GetData(lTemp4dVector, sizeof(lTemp4dVector));
lIKPivot.
mValue[0] = lTemp4dVector.mValue[0];
lIKPivot.mValue[1] = lTemp4dVector.mValue[1];
lIKPivot.mValue[2] = lTemp4dVector.mValue[2];
HIKGetEffectorStateTQSdv(lCurrentState->mCREffectorSetState, (
FBEffectorId)lIter, lGTVector.mValue, lCurrentGRQuat.mValue, lGSVector.mValue );
if( lIKPivot.mValue[0] != 0.0 ||
lIKPivot.mValue[1] != 0.0 ||
lIKPivot.mValue[2] != 0.0)
{
FBSVector lPivotGSVector;
lPivotEffector->GetVector(lPivotGSVector,
kModelScaling,
true, lEvalInfo);
lIKPivot.mValue[0] *= lPivotGSVector.mValue[0];
lIKPivot.mValue[1] *= lPivotGSVector.mValue[1];
lIKPivot.mValue[2] *= lPivotGSVector.mValue[2];
FBMatrix lGRM;
double V0, V1, V2;
V0 = lIKPivot.mValue[0];
V1 = lIKPivot.mValue[1];
V2 = lIKPivot.mValue[2];
lIKPivot.mValue[0] = lGRM(0,0) * V0 + lGRM(1,0) * V1 + lGRM(2,0) * V2;
lIKPivot.mValue[1] = lGRM(0,1) * V0 + lGRM(1,1) * V1 + lGRM(2,1) * V2;
lIKPivot.mValue[2] = lGRM(0,2) * V0 + lGRM(1,2) * V1 + lGRM(2,2) * V2;
lTempTVector.
mValue[0] = lIKPivot.mValue[0];
lTempTVector.mValue[1] = lIKPivot.mValue[1];
lTempTVector.mValue[2] = lIKPivot.mValue[2];
FBSub(lTempTVector,lGTVector,lTempTVector);
lIKPivot.mValue[0] = lTempTVector.mValue[0];
lIKPivot.mValue[1] = lTempTVector.mValue[1];
lIKPivot.mValue[2] = lTempTVector.mValue[2];
}
else
{
lIKPivot.mValue[0] = lGTVector.mValue[0];
lIKPivot.mValue[1] = lGTVector.mValue[1];
lIKPivot.mValue[2] = lGTVector.mValue[2];
}
lPivotEffector->SetVector(lGRVector,
kModelRotation,
true,
false, lEvalInfo);
}
}
}
}
void ORCharacterSolver_HIK::CharacterPasteState( FBCharacter* pFromCharacter, FBCharacterPose* pPose, FBCharacterPoseOptions& pCharacterPoseOptions )
{
if(mHIKControlRigHostEvaluator.mHIKCharacter == 0)
{
return;
}
HIKCharacter* lHIKFromCharacter =
NULL;
HIKCharacterState* lFromCharacterState =
NULL;
HIKPropertySetState* lFromPropertySetState =
NULL;
PastePoseToTempHikCharacter( pFromCharacter, pPose, pCharacterPoseOptions, lCurrentState,
lHIKFromCharacter, lFromCharacterState, lFromPropertySetState );
bool lPasted = false;
FBMatrix lHipsOffsetGX;
if( pCharacterPoseOptions.mModelToMatch )
{
FBMatrix lMatchModel_CurrentGRM;
pCharacterPoseOptions.mModelToMatch->GetMatrix(lMatchModel_CurrentGRM,
kModelRotation,
true);
pCharacterPoseOptions.mModelToMatch->GetVector(lMatchModel_CurrentGT,
kModelTranslation,
true);
FBMatrix lMatchModel_PoseTRS;
int lHIKNodeId = -1;
int lHIKEffectorId = -1;
GetNodeEffectIds( pCharacterPoseOptions.mModelToMatch, lHIKNodeId, lHIKEffectorId, lEffectorId, lPivotIndex );
bool lIsMatchModelExtension = (lHIKNodeId == -1 && lHIKEffectorId == -1);
{
if( lIsMatchModelExtension )
{
GetTRSForMatchModel_Extension( pPose, pCharacterPoseOptions.mModelToMatch, lMatchModel_PoseTRS );
}
else
{
GetTRSForMatchModel_Body(pCharacterPoseOptions, lHIKFromCharacter, lFromCharacterState, lFromPropertySetState, lCurrentState, &lHipsOffsetGX, lHIKNodeId, lHIKEffectorId, lEffectorId, lPivotIndex, &lMatchModel_PoseTRS);
}
GetRotationOffset( lMatchModel_CurrentGRM, lMatchModel_PoseTRS, pCharacterPoseOptions.GetFlag(
kFBCharacterPoseGravity ), lHipsOffsetGX );
DoPasteCharacter(lHIKFromCharacter, lFromCharacterState, lFromPropertySetState, lCurrentState, pCharacterPoseOptions.mCharacterPoseKeyingMode, &lHipsOffsetGX);
lPasted = true;
}
{
if( lIsMatchModelExtension )
{
GetTRSForMatchModel_Extension( pPose, pCharacterPoseOptions.mModelToMatch, lMatchModel_PoseTRS );
}
else
{
GetTRSForMatchModel_Body(pCharacterPoseOptions, lHIKFromCharacter, lFromCharacterState, lFromPropertySetState, lCurrentState, &lHipsOffsetGX, lHIKNodeId, lHIKEffectorId, lEffectorId, lPivotIndex, &lMatchModel_PoseTRS);
}
GetTranslationOffset( lMatchModel_CurrentGT, lMatchModel_PoseTRS,
lHipsOffsetGX );
DoPasteCharacter(lHIKFromCharacter, lFromCharacterState, lFromPropertySetState, lCurrentState, pCharacterPoseOptions.mCharacterPoseKeyingMode, &lHipsOffsetGX);
lPasted = true;
}
}
if(!lPasted)
{
DoPasteCharacter(lHIKFromCharacter, lFromCharacterState, lFromPropertySetState, lCurrentState, pCharacterPoseOptions.mCharacterPoseKeyingMode, &lHipsOffsetGX);
}
mHIKControlRigHostEvaluator.WriteRigCandidate(
FBGetDisplayInfo(),lCurrentState);
DoPasteCharacterExtension(pPose, pCharacterPoseOptions, lCurrentState);
FBCharacter* lToCharacter = TargetCharacter;
SyncPivot(lToCharacter->GetCurrentControlSet());
HIKCharacterDestroy(lHIKFromCharacter,&free);
HIKPropertySetStateDestroy(lFromPropertySetState,&free);
HIKCharacterStateDestroy(lFromCharacterState,&free);
}
void ORCharacterSolver_HIK::GetTRSForMatchModel_Body(FBCharacterPoseOptions& pCharacterPoseOptions, HIKCharacter* pHIKFromCharacter, HIKCharacterState* pFromCharacterState,
HIKPropertySetState* pFromPropertySetState, HIKEvaluationState* pCurrentState, FBMatrix* pHipsOffsetGX,
int pHIKNodeId,
int pHIKEffectorId,
FBEffectorId pEffectorId,
int pPivotIndex, FBMatrix* pValue)
{
if(pCharacterPoseOptions.mModelToMatch)
{
HIKCharacterState* lPoseState = HIKCharacterStateCreate(mHIKCharacter,&malloc);
HIKPasteState(mHIKCharacter, lPoseState, pCurrentState->mCRState,
pHIKFromCharacter, pFromCharacterState,
pCurrentState->mCRPropertySetState, pFromPropertySetState,
(double*)pHipsOffsetGX );
if(pHIKNodeId != -1)
{
HIKGetNodeStatedv(mHIKCharacter, lPoseState, pHIKNodeId, (double*)pValue);
}
else if(pHIKEffectorId != -1)
{
HIKCharacterState* lTempCharacterState = HIKCharacterStateCreate(mHIKCharacter,&malloc);
HIKCharacterStateCopy(lTempCharacterState, pCurrentState->mCRState);
{
DoPasteForBodyPart(pCurrentState, lPoseState);
}
else
{
HIKCharacterStateCopy(pCurrentState->mCRState, lPoseState);
mHIKControlRigHostEvaluator.EffectorStateFromControlSet(pCurrentState);
}
double lValue[16];
HIKGetEffectorStatedv(pCurrentState->mCREffectorSetState, pHIKEffectorId, lValue);
if(pPivotIndex)
{
FBModelMarker* lPivotEffector = dynamic_cast<FBModelMarker*>(TargetCharacter->GetCurrentControlSet()->GetIKEffectorModel(pEffectorId, pPivotIndex));
if(lPivotEffector)
{
lPivotEffector->IKPivot.GetData(lTemp, sizeof(lTemp));
lValue[12] -= lTemp.
mValue[0];
lValue[13] -= lTemp.mValue[1];
lValue[14] -= lTemp.mValue[2];
}
}
pValue->Set(lValue);
HIKCharacterStateCopy(pCurrentState->mCRState, lTempCharacterState);
mHIKControlRigHostEvaluator.EffectorStateFromControlSet(pCurrentState);
HIKCharacterStateDestroy(lTempCharacterState,&free);
}
HIKCharacterStateDestroy(lPoseState,&free);
}
}
void ORCharacterSolver_HIK::DoPasteCharacter(HIKCharacter* pHIKFromCharacter, HIKCharacterState* pFromCharacterState, HIKPropertySetState* pFromPropertySetState, HIKEvaluationState* pCurrentState,
FBCharacterPoseKeyingMode pKeyingMode, FBMatrix* pHipsOffsetGX)
{
HIKCharacterState* lPoseState = HIKCharacterStateCreate(mHIKCharacter,&malloc);
HIKPasteState(mHIKCharacter, lPoseState, pCurrentState->mCRState,
pHIKFromCharacter, pFromCharacterState,
pCurrentState->mCRPropertySetState, pFromPropertySetState,
*pHipsOffsetGX );
{
DoPasteForBodyPart(pCurrentState, lPoseState);
}
else
{
HIKCharacterStateCopy(pCurrentState->mCRState, lPoseState);
mHIKControlRigHostEvaluator.EffectorStateFromControlSet(pCurrentState);
}
HIKCharacterStateDestroy(lPoseState,&free);
}
#ifndef _WIN32
#include <stdlib.h>
static void* _aligned_malloc(size_t pSize, size_t pAlignment)
{
if ( posix_memalign( &lMemory, pAlignment, pSize ) == 0 )
return lMemory;
else
}
#define _aligned_free free
#endif
void ORCharacterSolver_HIK::DoPasteForBodyPart(HIKEvaluationState* pCurrentState, HIKCharacterState* pPoseState)
{
TargetCharacter->GetActiveBodyPart(lActiveBodyPart);
int lNodeIdDesc[LastNodeId + 1];
HIKDataDescription lDescription = {
HIKDataDescription::HIKLocalSpace,
sizeof(KHIKNodeState),
lNodeIdDesc
};
int lNodeCounter ;
for(lNodeCounter = 0 ; lNodeCounter < LastNodeId ; lNodeCounter++)
{
if(HIKGetNodeUse(mHIKControlRigHostEvaluator.mHIKCharacter, lNodeCounter) )
{
lDescription.mHIKNodeId[lNodeCounter] = lNodeCounter;
}
else
{
lDescription.mHIKNodeId[lNodeCounter] = HIKNotUsed;
}
}
lDescription.mHIKNodeId[LastNodeId] = HIKLastNode;
KHIKNodeState* lPoseDataSet = (KHIKNodeState*)_aligned_malloc( sizeof(KHIKNodeState) * LastNodeId, 16);
HIKGetCharacterStateTransformTQS( mHIKCharacter, pPoseState, &lDescription, lPoseDataSet);
KHIKNodeState* lCurrentDataSet = (KHIKNodeState*)_aligned_malloc( sizeof(KHIKNodeState) * LastNodeId, 16);
HIKGetCharacterStateTransformTQS( mHIKCharacter, pCurrentState->mCRState, &lDescription, lCurrentDataSet);
{
{
HIKNodeId lNodeId = gFBBodyNodeToHIKNodeId[lNodeCounter];
lCurrentDataSet[lNodeId].mTfv[0] = lPoseDataSet[lNodeId].mTfv[0];
lCurrentDataSet[lNodeId].mTfv[1] = lPoseDataSet[lNodeId].mTfv[1];
lCurrentDataSet[lNodeId].mTfv[2] = lPoseDataSet[lNodeId].mTfv[2];
lCurrentDataSet[lNodeId].mTfv[3] = lPoseDataSet[lNodeId].mTfv[3];
lCurrentDataSet[lNodeId].mQfv[0] = lPoseDataSet[lNodeId].mQfv[0];
lCurrentDataSet[lNodeId].mQfv[1] = lPoseDataSet[lNodeId].mQfv[1];
lCurrentDataSet[lNodeId].mQfv[2] = lPoseDataSet[lNodeId].mQfv[2];
lCurrentDataSet[lNodeId].mQfv[3] = lPoseDataSet[lNodeId].mQfv[3];
lCurrentDataSet[lNodeId].mSfv[0] = lPoseDataSet[lNodeId].mSfv[0];
lCurrentDataSet[lNodeId].mSfv[1] = lPoseDataSet[lNodeId].mSfv[1];
lCurrentDataSet[lNodeId].mSfv[2] = lPoseDataSet[lNodeId].mSfv[2];
lCurrentDataSet[lNodeId].mSfv[3] = lPoseDataSet[lNodeId].mSfv[3];
}
}
if(GetExtraBoneModelAt(LEFT_EXTRA_COLLAR) && lActiveBodyPart[GetExtraBoneBodyPartAt(LEFT_EXTRA_COLLAR)])
{
lCurrentDataSet[LeftCollarExtraNodeId].mTfv[0] = lPoseDataSet[LeftCollarExtraNodeId].mTfv[0];
lCurrentDataSet[LeftCollarExtraNodeId].mTfv[1] = lPoseDataSet[LeftCollarExtraNodeId].mTfv[1];
lCurrentDataSet[LeftCollarExtraNodeId].mTfv[2] = lPoseDataSet[LeftCollarExtraNodeId].mTfv[2];
lCurrentDataSet[LeftCollarExtraNodeId].mTfv[3] = lPoseDataSet[LeftCollarExtraNodeId].mTfv[3];
lCurrentDataSet[LeftCollarExtraNodeId].mQfv[0] = lPoseDataSet[LeftCollarExtraNodeId].mQfv[0];
lCurrentDataSet[LeftCollarExtraNodeId].mQfv[1] = lPoseDataSet[LeftCollarExtraNodeId].mQfv[1];
lCurrentDataSet[LeftCollarExtraNodeId].mQfv[2] = lPoseDataSet[LeftCollarExtraNodeId].mQfv[2];
lCurrentDataSet[LeftCollarExtraNodeId].mQfv[3] = lPoseDataSet[LeftCollarExtraNodeId].mQfv[3];
lCurrentDataSet[LeftCollarExtraNodeId].mSfv[0] = lPoseDataSet[LeftCollarExtraNodeId].mSfv[0];
lCurrentDataSet[LeftCollarExtraNodeId].mSfv[1] = lPoseDataSet[LeftCollarExtraNodeId].mSfv[1];
lCurrentDataSet[LeftCollarExtraNodeId].mSfv[2] = lPoseDataSet[LeftCollarExtraNodeId].mSfv[2];
lCurrentDataSet[LeftCollarExtraNodeId].mSfv[3] = lPoseDataSet[LeftCollarExtraNodeId].mSfv[3];
}
if(GetExtraBoneModelAt(RIGHT_EXTRA_COLLAR) && lActiveBodyPart[GetExtraBoneBodyPartAt(RIGHT_EXTRA_COLLAR)])
{
lCurrentDataSet[RightCollarExtraNodeId].mTfv[0] = lPoseDataSet[RightCollarExtraNodeId].mTfv[0];
lCurrentDataSet[RightCollarExtraNodeId].mTfv[1] = lPoseDataSet[RightCollarExtraNodeId].mTfv[1];
lCurrentDataSet[RightCollarExtraNodeId].mTfv[2] = lPoseDataSet[RightCollarExtraNodeId].mTfv[2];
lCurrentDataSet[RightCollarExtraNodeId].mTfv[3] = lPoseDataSet[RightCollarExtraNodeId].mTfv[3];
lCurrentDataSet[RightCollarExtraNodeId].mQfv[0] = lPoseDataSet[RightCollarExtraNodeId].mQfv[0];
lCurrentDataSet[RightCollarExtraNodeId].mQfv[1] = lPoseDataSet[RightCollarExtraNodeId].mQfv[1];
lCurrentDataSet[RightCollarExtraNodeId].mQfv[2] = lPoseDataSet[RightCollarExtraNodeId].mQfv[2];
lCurrentDataSet[RightCollarExtraNodeId].mQfv[3] = lPoseDataSet[RightCollarExtraNodeId].mQfv[3];
lCurrentDataSet[RightCollarExtraNodeId].mSfv[0] = lPoseDataSet[RightCollarExtraNodeId].mSfv[0];
lCurrentDataSet[RightCollarExtraNodeId].mSfv[1] = lPoseDataSet[RightCollarExtraNodeId].mSfv[1];
lCurrentDataSet[RightCollarExtraNodeId].mSfv[2] = lPoseDataSet[RightCollarExtraNodeId].mSfv[2];
lCurrentDataSet[RightCollarExtraNodeId].mSfv[3] = lPoseDataSet[RightCollarExtraNodeId].mSfv[3];
}
HIKSetCharacterStateTransformTQS(mHIKCharacter, pCurrentState->mCRState, &lDescription, lCurrentDataSet);
HIKEffectorSetFromCharacter(mHIKCharacter, pCurrentState->mCREffectorSetState, pCurrentState->mCRState, pCurrentState->mCRPropertySetState);
mHIKControlRigHostEvaluator.Solve(pCurrentState);
_aligned_free(lPoseDataSet);
_aligned_free(lCurrentDataSet);
}
void ORCharacterSolver_HIK::DoPasteCharacterExtension(FBCharacterPose* pPose, FBCharacterPoseOptions& pCharacterPoseOptions, HIKEvaluationState* pCurrentState)
{
FBEvaluateInfo* lEvaluation = BackgroundEvaluateInfoBegin(
FBGetDisplayInfo(),
true);
FBCharacter* lToCharacter = TargetCharacter;
int lCharacterExtensionCount = lToCharacter->CharacterExtensions.GetCount();
for(
int i = 0;
i < lCharacterExtensionCount;
i++)
{
FBCharacterExtension* lCharacterExtension = (FBCharacterExtension*)lToCharacter->CharacterExtensions.GetAt(
i);
{
if( lCharacterExtension !=
NULL && !lCharacterExtension->IsElementSelected() )
continue;
}
FBObjectPose* lCharacterExtPose =
NULL;
if(lCharacterExtension !=
NULL)
{
lCharacterExtPose = pPose->GetCharacterExtensionPose(lCharacterExtension->Label);
}
if(lCharacterExtension && lCharacterExtPose)
{
FBObjectPoseOptions* lObjectPoseOptions = new FBObjectPoseOptions();
{
}
{
{
}
else
{
}
}
FBModel* lReferenceModel = lCharacterExtension->ReferenceModel !=
NULL ? lCharacterExtension->ReferenceModel : lToCharacter->GetModel(
kFBHipsNodeId );
if(lReferenceModel)
{
lReferenceModel->GetMatrix(lObjectPoseOptions->mReferenceGRM,
kModelRotation,
true, lEvaluation);
lReferenceModel->GetMatrix(lObjectPoseOptions->mReferenceGSM,
kModelScaling,
true, lEvaluation);
}
else
{
lObjectPoseOptions->mReferenceGT.Init();
lObjectPoseOptions->mReferenceGRM.Identity();
lObjectPoseOptions->mReferenceGSM.Identity();
}
lCharacterExtension->GetMirrorExtension() &&
pPose->GetCharacterExtensionPose(lCharacterExtension->GetMirrorExtension()->Label))
{
FBVector4<double> lMirrorPlaneEquation;
pPose->GetMirrorPlaneEquation(lMirrorPlaneEquation, *lToCharacter, pCharacterPoseOptions);
FBObjectPose lMirrorExtensionPose(FBComponentGetLongName(lCharacterExtPose));
FBCharacterExtension* lSrcCharacterExtension = lCharacterExtension->GetMirrorExtension();
assert(lSrcCharacterExtension);
FBObjectPose* lSrcExtensionPose = pPose->GetCharacterExtensionPose(lSrcCharacterExtension->Label);
assert(lSrcExtensionPose);
int lObjectIter = 0;
for( lObjectIter = 0; lObjectIter < lCharacterExtension->GetSubObjectCount(); lObjectIter++ )
{
FBModel* lObject = (FBModel*)(lCharacterExtension->GetSubObject(lObjectIter));
if( lObject )
{
FBString lObjectLabel;
lCharacterExtension->GetLabelNameWithExtensionObject(lObjectLabel,lObject,true);
FBObjectPose::RetargetPose
(
lMirrorExtensionPose,
*lSrcExtensionPose,
lObjectLabel,
lObjectLabel
);
FBObjectPose* lSrcStancePose = lSrcCharacterExtension->GetStancePose();
FBObjectPose* lDstStancePose = lCharacterExtension->GetStancePose();
if( lSrcStancePose && lDstStancePose )
{
FBObjectPose::MirrorRetargetPose
(
lMirrorExtensionPose,
*lSrcExtensionPose,
*lDstStancePose,
*lSrcStancePose,
lMirrorPlaneEquation,
lObjectLabel,
lObjectLabel
);
}
lMirrorExtensionPose.PasteTransform( (char*)lObjectLabel, *lObject, *lObjectPoseOptions, lEvaluation );
}
}
}
else
{
int lObjectIter = 0;
for( lObjectIter = 0; lObjectIter < lCharacterExtension->GetSubObjectCount(); lObjectIter++ )
{
FBModel* lObject = (FBModel*)(lCharacterExtension->GetSubObject(lObjectIter));
if( lObject )
{
FBString lObjectLabel;
lCharacterExtension->GetLabelNameWithExtensionObject(lObjectLabel,lObject,true);
lCharacterExtPose->PasteTransform( (char*)lObjectLabel, *lObject, *lObjectPoseOptions, lEvaluation );
}
}
}
}
}
BackgroundEvaluateInfoEnd(lEvaluation);
}
void ORCharacterSolver_HIK::GetTRSForMatchModel_Extension( FBCharacterPose* pPose, FBModel* pMatchModel, FBMatrix& pExtensionTRS )
{
FBMatrix lExtensionRM;
FBMatrix lExtensionSM;
for(
int i = 0;
i < pPose->GetCharacterExtensionPoseCount();
i++ )
{
FBObjectPose* lFBExtensionPose = pPose->GetCharacterExtensionPoseAt(
i );
if( lFBExtensionPose->IsTransformStored( pMatchModel->Name.AsString() ) )
{
lFBExtensionPose->GetTransform( lExtensionT, lExtensionRM, lExtensionSM, (pMatchModel->Name).AsString(),
kFBPoseTransformGlobal );
break;
}
}
FBSVector lSVector;
}
void ORCharacterSolver_HIK::GetRotationOffset( const FBMatrix& pMatchModel_CurrentGRM, const FBMatrix& pMatchMode_PoseTRSM, const bool pGravity, FBMatrix& pHipsOffsetGX )
{
FBMatrix lOffsetRM;
FBMatrixMult( lOffsetRM, pMatchModel_CurrentGRM, lOffsetRM );
if( pGravity )
{
FBMatrix lRM;
}
}
void ORCharacterSolver_HIK::GetTranslationOffset(
const FBVector3d& pMatchModel_CurrentGT,
const FBMatrix& pMatchMode_PoseTRSM,
bool pMatchX,
bool pMatchY,
bool pMatchZ,
bool pGravity, FBMatrix& pHipsOffsetGX )
{
lGTTVector1.
mValue[0] = pMatchModel_CurrentGT.mValue[0];
lGTTVector1.mValue[1] = pMatchModel_CurrentGT.mValue[1];
lGTTVector1.mValue[2] = pMatchModel_CurrentGT.mValue[2];
FBSub( lOffsetT, lGTTVector1, lPastedVector );
if( !pMatchX )
{
lOffsetT[0] = 0.0;
}
if( !pMatchY || pGravity )
{
lOffsetT[1] = 0.0;
}
if( !pMatchZ )
{
lOffsetT[2] = 0.0;
}
pHipsOffsetGX(3,0) = lOffsetT[0];
pHipsOffsetGX(3,1) = lOffsetT[1];
pHipsOffsetGX(3,2) = lOffsetT[2];
pHipsOffsetGX(3,3) = lOffsetT[3];
}
void ORCharacterSolver_HIK::GetNodeEffectIds( FBModel* pModelToMatch,
int& pHIKNodeId,
int& pHIKEffectorId,
FBEffectorId& pEffectorId,
FBEffectorSetID& pPivotIndex )
{
int lNodeId = TargetCharacter->GetIndexByModel( pModelToMatch);
{
if(GetExtraBoneModelAt(LEFT_EXTRA_COLLAR) == pModelToMatch)
{
lNodeId = LeftCollarExtraNodeId;
}
else if(GetExtraBoneModelAt(RIGHT_EXTRA_COLLAR) == pModelToMatch)
{
lNodeId = RightCollarExtraNodeId;
}
}
{
{
{
{
break;
}
}
}
}
{
if(lNodeId >= kFBLastNodeId_Old)
{
pHIKNodeId = lNodeId;
}
else
{
}
}
{
}
}
void ORCharacterSolver_HIK::PastePoseToTempHikCharacter( FBCharacter* pFromCharacter, FBCharacterPose* pPose, FBCharacterPoseOptions& pCharacterPoseOptions, HIKEvaluationState* pCurrentState,
HIKCharacter*& pHIKFromCharacter, HIKCharacterState*& pFromCharacterState, HIKPropertySetState*& pFromPropertySetState )
{
FBCharacter* lToCharacter = TargetCharacter;
UndoSetup(lToCharacter);
HIKCharacterHost<HIKHostNodeMB,HIKHostPropertyMB> lHIKFromCharacterHost;
HIKHostPropertiesInit(lHIKFromCharacterHost);
HIKCharacterHostFromMBCharacterHierarchy(lHIKFromCharacterHost, pFromCharacter,
NULL);
if(pPose->GetExtraBoneCount() >= 2)
{
FBModel *lLeftShoulderExtra = pPose->GetExtraBoneModelAt(0);
FBModel *lRightShoulderExtra = pPose->GetExtraBoneModelAt(1);
if (lLeftShoulderExtra || lRightShoulderExtra)
{
HIKCharacterHostFromHIKHostMB(lHIKFromCharacterHost, lLeftShoulderExtra, lRightShoulderExtra,
NULL);
}
}
pHIKFromCharacter = lHIKFromCharacterHost.CharacterCreate(&malloc);
pFromCharacterState = HIKCharacterStateCreate(pHIKFromCharacter,&malloc);
HIKCharacterHostFromMBCharacterGeometry(lHIKFromCharacterHost,pHIKFromCharacter,pFromCharacter);
if(pPose->GetExtraBoneCount() >= 2)
{
FBRVector lLeftR, lRightR, lLeftRPOff, lRightRPOff;
FBSVector lLeftS, lRightS;
pPose->GetExtraBoneTransformOffset(lLeftT, lLeftR, lLeftS, LEFT_EXTRA_COLLAR);
pPose->GetExtraBoneParentRotationOffset(lLeftRPOff, LEFT_EXTRA_COLLAR);
pPose->GetExtraBoneTransformOffset(lRightT, lRightR, lRightS, RIGHT_EXTRA_COLLAR);
pPose->GetExtraBoneParentRotationOffset(lRightRPOff, RIGHT_EXTRA_COLLAR);
CharacterizeHIKCharacterHostFromHIKHostMB(lHIKFromCharacterHost,pHIKFromCharacter,
lLeftT, lLeftQ, lLeftS, lLeftQPOff,
lRightT, lRightQ, lRightS, lRightQPOff);
FBModel *lLeftShoulderExtra = pPose->GetExtraBoneModelAt(0);
FBModel *lRightShoulderExtra = pPose->GetExtraBoneModelAt(1);
FBMatrix lMatrix;
if(lLeftShoulderExtra)
{
pPose->GetExtraBoneTransform(lTranslation, lRotation, lScale, LEFT_EXTRA_COLLAR);
FBSVector lSVector( lScale );
HIKSetNodeStatedv(pHIKFromCharacter, pFromCharacterState, LeftCollarExtraNodeId, lMatrix);
}
if(lRightShoulderExtra)
{
pPose->GetExtraBoneTransform(lTranslation, lRotation, lScale, RIGHT_EXTRA_COLLAR);
FBSVector lSVector( lScale );
HIKSetNodeStatedv(pHIKFromCharacter, pFromCharacterState, RightCollarExtraNodeId, lMatrix);
}
}
int iter = 0;
{
FBMatrix lMatrix = pPose->GetNodeMatrixGlobal(iter);
HIKSetNodeStatedv(pHIKFromCharacter, pFromCharacterState, lHIKId, (double*)lMatrix);
}
HIKCharacterizeGeometry(pHIKFromCharacter);
HIKHostPropertiesFromCharacter(lHIKFromCharacterHost, pFromCharacter);
RegisterExtraProperties(lHIKFromCharacterHost);
pFromPropertySetState = HIKPropertySetStateCreate(&malloc);
lHIKFromCharacterHost.ReadPropertySetState(pFromPropertySetState,
FBGetDisplayInfo());
{
FBMatrix lMirrorPlaneMatrix;
pPose->GetMirrorPlaneEquation(lMirrorPlaneMatrix, *lToCharacter, pCharacterPoseOptions);
HIKMirrorState( pHIKFromCharacter, pFromCharacterState, pFromCharacterState, pHIKFromCharacter, lMirrorPlaneEquationQ.mValue);
}
{
if (lHIKId != -1)
{
HIKSetTranslationActive(pCurrentState->mCREffectorSetState, lIter, 0.0);
HIKSetPull( pCurrentState->mCREffectorSetState, lIter, 0.0 );
}
}
}