BVB Source Codes

CRYENGINE Show Command_Commands.cpp Source code

Return Download CRYENGINE: download Command_Commands.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "stdafx.h"
  4. #include "Command_Commands.h"
  5.  
  6. #include "Helper.h"
  7. #include "ControllerOpt.h"
  8. #include "CharacterInstance.h"
  9. #include "SkeletonAnim.h"
  10. #include "SkeletonPose.h"
  11. #include "Command_Buffer.h"
  12. #include "Skeleton.h"
  13. #include "LoaderDBA.h"
  14. #include "CharacterManager.h"
  15. #include "AttachmentBone.h"
  16. #include "AttachmentPRow.h"
  17. #include "PoseModifier/PoseModifierHelper.h"
  18.  
  19. extern float g_YLine;
  20.  
  21. namespace Command
  22. {
  23.  
  24. void LoadControllers(const GlobalAnimationHeaderCAF& rGAH, const Command::CState& state, IController** controllers)
  25. {
  26.         memset(controllers, 0, state.m_jointCount * sizeof(IController*));
  27.  
  28.         if (rGAH.IsAssetOnDemand())
  29.         {
  30.                 assert(rGAH.IsAssetLoaded());
  31.                 if (rGAH.IsAssetLoaded() == 0)
  32.                 {
  33.                         return;
  34.                         //      int nCurrentFrameID = g_pCharacterManager->m_nUpdateCounter;
  35.                         //      CryFatalError("CryAnimation: Asset Not Loaded: %s   nCurrentFrameID: %d  Weight: %f",rCAF.GetFilePath(),nCurrentFrameID,ac.m_fWeight);
  36.                 }
  37.         }
  38.  
  39.         if (rGAH.m_nControllers2)
  40.         {
  41.                 if (rGAH.m_nControllers == 0)
  42.                 {
  43.                         uint32 dba_exists = 0;
  44.                         if (rGAH.m_FilePathDBACRC32)
  45.                         {
  46.                                 size_t numDBA_Files = g_AnimationManager.m_arrGlobalHeaderDBA.size();
  47.                                 for (uint32 d = 0; d < numDBA_Files; d++)
  48.                                 {
  49.                                         CGlobalHeaderDBA& pGlobalHeaderDBA = g_AnimationManager.m_arrGlobalHeaderDBA[d];
  50.                                         if (rGAH.m_FilePathDBACRC32 != pGlobalHeaderDBA.m_FilePathDBACRC32)
  51.                                                 continue;
  52.  
  53.                                         dba_exists++;
  54.                                         break;
  55.                                 }
  56.  
  57.                         }
  58.  
  59.                         if (dba_exists)
  60.                         {
  61.                                 if (Console::GetInst().ca_DebugCriticalErrors)
  62.                                 {
  63.                                         //this case is virtually impossible, unless something went wrong with a DBA or maybe a CAF in a DBA was compressed to death and all controllers removed
  64.                                         //      const char* mname = state.m_pInstance->GetFilePath();
  65.                                         //      f32 fColor[4] = {1,1,0,1};
  66.                                         //      g_pAuxGeom->Draw2dLabel( 1,g_YLine, 1.2f, fColor, false,"model: %s",mname);
  67.                                         //      g_YLine+=0x10;
  68.                                         //      g_pAuxGeom->Draw2dLabel( 1,g_YLine, 2.3f, fColor, false,"No Controllers found in Asset: %02x %08x %s",rGAH.m_nControllers2,rGAH.m_FilePathDBACRC32,rGAH.m_FilePath.c_str() );
  69.                                         //      g_YLine+=23.0f;
  70.                                         CryFatalError("CryAnimation: No Controllers found in Asset: %s", rGAH.GetFilePath());
  71.                                 }
  72.  
  73.                                 g_pISystem->Warning(VALIDATOR_MODULE_ANIMATION, VALIDATOR_WARNING, VALIDATOR_FLAG_FILE, 0, "No Controllers found in Asset: %s", rGAH.GetFilePath());
  74.                         }
  75.  
  76.                         return;  //return and don't play animation, because we don't have any controllers
  77.                 }
  78.         }
  79.  
  80.         const uint32* pLodJointMask = NULL;
  81.         uint32 lodJointMaskCount = 0;
  82.         if (state.m_lod > 0)
  83.         {
  84.                 if (uint32 lodCount = state.m_pDefaultSkeleton->m_arrAnimationLOD.size())
  85.                 {
  86.                         uint32 lod = state.m_lod;
  87.                         if (lod > lodCount)
  88.                                 lod = lodCount;
  89.                         --lod;
  90.  
  91.                         pLodJointMask = &state.m_pDefaultSkeleton->m_arrAnimationLOD[lod][0];
  92.                         lodJointMaskCount = state.m_pDefaultSkeleton->m_arrAnimationLOD[lod].size();
  93.                 }
  94.         }
  95.  
  96.         const CDefaultSkeleton::SJoint* pModelJoint = &state.m_pDefaultSkeleton->m_arrModelJoints[0];
  97.         uint32 jointCount = state.m_jointCount;
  98.         for (uint32 i = 0; i < jointCount; ++i)
  99.         {
  100.                 const uint32 crc32 = pModelJoint[i].m_nJointCRC32;
  101.                 if (pLodJointMask)
  102.                 {
  103.                         if (Helper::FindFromSorted(pLodJointMask, lodJointMaskCount, crc32) == NULL)
  104.                                 continue;
  105.                 }
  106.  
  107.                 if (!state.IsJointActive(crc32))
  108.                         continue;
  109.  
  110.                 controllers[i] = rGAH.GetControllerByJointCRC32(pModelJoint[i].m_nJointCRC32);
  111.         }
  112. }
  113.  
  114. void ClearPoseBuffer::Execute(const CState& state, CEvaluationContext& context) const
  115. {
  116.         assert(m_TargetBuffer <= Command::TargetBuffer);
  117.  
  118.         const float identityConstant = m_nPoseInit ? 1.0f : 0.0f;
  119.  
  120.         //clear buffer for the relative pose
  121.         const auto pRelPoseDst = static_cast<QuatT*>(context.m_buffers[m_TargetBuffer + 0]);
  122.         const auto pScalingDst = static_cast<float*>(context.m_buffers[m_TargetBuffer + 3]);
  123.         for (uint32 j = 0; j < state.m_jointCount; ++j)
  124.         {
  125.                 pRelPoseDst[j].q.v.x = 0.0f;
  126.                 pRelPoseDst[j].q.v.y = 0.0f;
  127.                 pRelPoseDst[j].q.v.z = 0.0f;
  128.                 pRelPoseDst[j].q.w = identityConstant;
  129.                 pRelPoseDst[j].t.x = 0.0f;
  130.                 pRelPoseDst[j].t.y = 0.0f;
  131.                 pRelPoseDst[j].t.z = 0.0f;
  132.                 pScalingDst[j] = identityConstant;
  133.         }
  134.  
  135.         //clear buffer joint states
  136.         const auto pStatusDst = static_cast<JointState*>(context.m_buffers[m_TargetBuffer + 1]);
  137.         for (uint32 j = 0; j < state.m_jointCount; ++j)
  138.         {
  139.                 pStatusDst[j] = m_nJointStatus;
  140.         }
  141.  
  142.         //clear buffer for weight mask (this is only used for partial body blends)
  143.         const auto pWeightMask = static_cast<Vec3*>(context.m_buffers[m_TargetBuffer + 2]);
  144.         if (pWeightMask)
  145.         {
  146.                 for (uint32 j = 0; j < state.m_jointCount; ++j)
  147.                 {
  148.                         pWeightMask[j] = Vec3(ZERO);
  149.                 }
  150.         }
  151. }
  152.  
  153. //this function operates on "rGlobalAnimHeaderCAF"
  154. void SampleAddAnimFull::Execute(const CState& state, CEvaluationContext& context) const
  155. {
  156.  
  157.         const QuatT* const defaultPose = state.m_pDefaultSkeleton->m_poseDefaultData.GetJointsRelativeMain();
  158.         const float* const defaultScale = state.m_pDefaultSkeleton->m_poseDefaultData.GetScalingRelative();
  159.  
  160.         const auto& rCAF = [&]() -> const GlobalAnimationHeaderCAF&
  161.         {
  162.                 assert(m_nEAnimID >= 0);
  163.  
  164.                 const ModelAnimationHeader* pMAG = state.m_pDefaultSkeleton->m_pAnimationSet->GetModelAnimationHeader(m_nEAnimID);
  165.                 assert(pMAG);
  166.                 assert(pMAG->m_nAssetType == CAF_File);
  167.                 assert(pMAG->m_nGlobalAnimId >= 0);
  168.  
  169.                 return g_AnimationManager.m_arrGlobalCAF[pMAG->m_nGlobalAnimId];
  170.         } ();
  171.         assert(rCAF.IsAssetLoaded());
  172.  
  173.         PREFAST_SUPPRESS_WARNING(6255);
  174.         const auto parrJointControllers = static_cast<IController**>(alloca(state.m_jointCount * sizeof(IController*)));
  175.         LoadControllers(rCAF, state, parrJointControllers);
  176.  
  177.         const int32 bufferIndex = (m_flags & Flag_TmpBuffer) ? Command::TmpBuffer : Command::TargetBuffer;
  178.         const auto outputRelPose = static_cast<QuatT*>(context.m_buffers[bufferIndex + 0]);
  179.         const auto outputRelScale = static_cast<float*>(context.m_buffers[bufferIndex + 3]);
  180.         const auto outputPoseState = static_cast<JointState*>(context.m_buffers[bufferIndex + 1]);
  181.  
  182.         const f32 keyTimeNew = rCAF.NTime2KTime(m_fETimeNew);
  183.         const uint32 startingJointIndex = (m_flags & Flag_ADMotion) ? (1) : (0);
  184.  
  185.         if (startingJointIndex == 1)
  186.         {
  187.                 // Root is always "identity" with animation-driven motions.
  188.                 // TODO: What should we do about the root scaling in this case?
  189.                 outputRelPose[0].SetIdentity();
  190.                 outputRelScale[0] = 1.0;
  191.         }
  192.  
  193.         if (rCAF.IsAssetAdditive())
  194.         {
  195.                 for (uint32 j = startingJointIndex; j < state.m_jointCount; ++j)
  196.                 {
  197.                         QuatT tempPose(defaultPose[j].q, defaultPose[j].t);
  198.                         Diag33 tempScale = Diag33(defaultScale ? defaultScale[j] : 1.0f);
  199.  
  200.                         if (parrJointControllers[j])
  201.                         {
  202.                                 const JointState ops = parrJointControllers[j]->GetOPS(keyTimeNew, tempPose.q, tempPose.t, tempScale);
  203.                                 if (ops & eJS_Orientation)
  204.                                 {
  205.                                         tempPose.q *= defaultPose[j].q;
  206.                                 }
  207.                                 if (ops & eJS_Position)
  208.                                 {
  209.                                         tempPose.t += defaultPose[j].t;
  210.                                 }
  211.                                 if (ops & eJS_Scale)
  212.                                 {
  213.                                         tempScale *= Diag33(defaultScale ? defaultScale[j] : 1.0f);
  214.                                         context.m_isScalingPresent = true;
  215.                                 }
  216.  
  217.                                 tempPose.q *= fsgnnz(defaultPose[j].q | tempPose.q);
  218.                         }
  219.                         assert(tempPose.IsValid());
  220.  
  221.                         outputRelPose[j].q += (tempPose.q * m_fWeight);
  222.                         outputRelPose[j].t += (tempPose.t * m_fWeight);
  223.                         outputRelScale[j] += (tempScale.x * m_fWeight);
  224.                 }
  225.         }
  226.         else
  227.         {
  228.                 const QuatT* parrHemispherePose = Console::GetInst().ca_SampleQuatHemisphereFromCurrentPose ? outputRelPose : defaultPose; // joints to compare with in quaternion dot product
  229.                 for (uint32 j = startingJointIndex; j < state.m_jointCount; ++j)
  230.                 {
  231.                         QuatT tempPose(defaultPose[j].q, defaultPose[j].t);
  232.                         Diag33 tempScale = Diag33(defaultScale ? defaultScale[j] : 1.0f);
  233.  
  234.                         if (parrJointControllers[j])
  235.                         {
  236.                                 const JointState ops = parrJointControllers[j]->GetOPS(keyTimeNew, tempPose.q, tempPose.t, tempScale);
  237.  
  238.                                 if (ops & eJS_Scale)
  239.                                 {
  240.                                         context.m_isScalingPresent = true;
  241.                                 }
  242.  
  243.                                 tempPose.q *= fsgnnz(parrHemispherePose[j].q | tempPose.q);
  244.                         }
  245.  
  246.                         assert(tempPose.IsValid());
  247.  
  248.                         outputRelPose[j].q += (tempPose.q * m_fWeight);
  249.                         outputRelPose[j].t += (tempPose.t * m_fWeight);
  250.                         outputRelScale[j] += (tempScale.x * m_fWeight);
  251.                 }
  252.         }
  253.  
  254.         static_assert(sizeof(*outputPoseState) == 1, "Invalid assumption on the size of the joint state descriptor!");
  255.         memset(outputPoseState, (eJS_Position | eJS_Orientation | eJS_Scale), state.m_jointCount); // If we have an animation in the base-layer, then we ALWAYS initialize all joints.
  256.  
  257.         g_pCharacterManager->g_SkeletonUpdates++;
  258.  
  259.         std::for_each(outputRelPose, outputRelPose + state.m_jointCount, [](const QuatT& x)
  260.                 {
  261.                         assert(x.q.IsValid());
  262.                         assert(x.t.IsValid());
  263.           });
  264.  
  265.         std::for_each(outputRelScale, outputRelScale + state.m_jointCount, [](const float& x)
  266.                 {
  267.                         assert(NumberValid(x));
  268.           });
  269. }
  270.  
  271. //this function operates on "rGlobalAnimHeaderAIM"
  272. void SampleAddPoseFull::Execute(const CState& state, CEvaluationContext& context) const
  273. {
  274.  
  275.         const CDefaultSkeleton::SJoint* const pModelJoint = state.m_pDefaultSkeleton->m_arrModelJoints.data();
  276.         const QuatT* const parrDefJoints = state.m_pDefaultSkeleton->m_poseDefaultData.GetJointsRelativeMain();
  277.         const float* const parrDefScaling = state.m_pDefaultSkeleton->m_poseDefaultData.GetScalingRelative();
  278.         const auto& rGlobalAnimHeaderAIM = [&]() -> const GlobalAnimationHeaderAIM&
  279.         {
  280.                 assert(m_nEAnimID >= 0);
  281.                 const ModelAnimationHeader* pMAG = state.m_pDefaultSkeleton->m_pAnimationSet->GetModelAnimationHeader(m_nEAnimID);
  282.                 assert(pMAG);
  283.                 assert(pMAG->m_nAssetType == AIM_File);
  284.                 return g_AnimationManager.m_arrGlobalAIM[pMAG->m_nGlobalAnimId];
  285.  
  286.         } ();
  287.  
  288.         PREFAST_SUPPRESS_WARNING(6255)
  289.         const auto parrController = static_cast<IController**>(alloca(state.m_jointCount * sizeof(IController*)));
  290.         memset(parrController, 0, state.m_jointCount * sizeof(IController*));
  291.         for (uint32 i = 0; i < state.m_jointCount; ++i)
  292.         {
  293.                 parrController[i] = rGlobalAnimHeaderAIM.GetControllerByJointCRC32(pModelJoint[i].m_nJointCRC32);
  294.         }
  295.  
  296.         const int32 nBufferID = (m_flags& SampleAddAnimFull::Flag_TmpBuffer) ? Command::TmpBuffer : Command::TargetBuffer;
  297.         const auto parrRelJointsDst = static_cast<QuatT*>(context.m_buffers[nBufferID + 0]);
  298.         const auto parrRelScalingDst = static_cast<float*>(context.m_buffers[nBufferID + 3]);
  299.         const auto parrStatusDst = static_cast<JointState*>(context.m_buffers[nBufferID + 1]);
  300.         const QuatT* parrHemispherePose = Console::GetInst().ca_SampleQuatHemisphereFromCurrentPose ? parrRelJointsDst : parrDefJoints; // joints to compare with in quaternion dot product
  301.  
  302.         const f32 fKeyTimeNew = rGlobalAnimHeaderAIM.NTime2KTime(m_fETimeNew);
  303.         for (uint32 j = 0; j < state.m_jointCount; ++j)
  304.         {
  305.                 Quat rot;
  306.                 Vec3 pos;
  307.                 Diag33 scl;
  308.                 if (parrController[j])
  309.                 {
  310.                         const JointState jointState = parrController[j]->GetOPS(fKeyTimeNew, rot, pos, scl);
  311.  
  312.                         if (jointState & eJS_Scale)
  313.                         {
  314.                                 context.m_isScalingPresent = true;
  315.                         }
  316.  
  317.                         rot *= fsgnnz(parrHemispherePose[j].q | rot); // TODO: This could be optimized at loading-time
  318.                 }
  319.                 else
  320.                 {
  321.                         rot = parrDefJoints[j].q;
  322.                         pos = parrDefJoints[j].t;
  323.                         scl = Diag33(parrDefScaling ? parrDefScaling[j] : 1.0f);
  324.                 }
  325.                 assert(rot.IsUnit());
  326.                 assert(rot.IsValid());
  327.                 assert(pos.IsValid());
  328.                 assert(scl.IsValid());
  329.  
  330.                 parrRelJointsDst[j].q += m_fWeight * rot;
  331.                 parrRelJointsDst[j].t += m_fWeight * pos;
  332.                 parrRelScalingDst[j] += m_fWeight * scl.x;
  333.         }
  334.  
  335.         static_assert(sizeof(*parrStatusDst) == 1, "Invalid assumption on the size of the joint state descriptor!");
  336.         memset(parrStatusDst, (eJS_Position | eJS_Orientation | eJS_Scale), state.m_jointCount); // See comment in SampleAddAnimFull::Execute().
  337.  
  338.         std::for_each(parrRelJointsDst, parrRelJointsDst + state.m_jointCount, [](const QuatT& x)
  339.                 {
  340.                         assert(x.q.IsValid());
  341.                         assert(x.t.IsValid());
  342.           });
  343.  
  344.         std::for_each(parrRelScalingDst, parrRelScalingDst + state.m_jointCount, [](const float& x)
  345.                 {
  346.                         assert(NumberValid(x));
  347.           });
  348. }
  349.  
  350. //reads content from m_SourceBuffer, multiplies the pose by a blend weight, and adds the result to the m_TargetBuffer
  351. void AddPoseBuffer::Execute(const CState& state, CEvaluationContext& context) const
  352. {
  353.         const AddPoseBuffer& ac = *this;
  354.         void** CBTemp = context.m_buffers;
  355.  
  356.         assert(ac.m_SourceBuffer <= Command::TargetBuffer);
  357.         QuatT* parrRelPoseSrc = (QuatT*)  CBTemp[ac.m_SourceBuffer + 0];
  358.         JointState* parrStatusSrc = (JointState*)CBTemp[ac.m_SourceBuffer + 1];
  359.  
  360.         assert(ac.m_TargetBuffer <= Command::TargetBuffer);
  361.         QuatT* parrRelPoseDst = (QuatT*)  CBTemp[ac.m_TargetBuffer + 0];
  362.         JointState* parrStatusDst = (JointState*)CBTemp[ac.m_TargetBuffer + 1];
  363.  
  364.         f32 t = ac.m_fWeight;
  365.  
  366.         uint32 numJoints = state.m_jointCount;
  367.         for (uint32 i = 0; i < numJoints; i++)
  368.         {
  369.                 parrRelPoseDst[i].q += parrRelPoseSrc[i].q * t;
  370.                 parrRelPoseDst[i].t += parrRelPoseSrc[i].t * t;
  371.                 parrStatusDst[i] |= parrStatusSrc[i];
  372.         }
  373. #ifdef _DEBUG
  374.         for (uint32 j = 0; j < numJoints; j++)
  375.         {
  376.                 assert(parrRelPoseDst[j].q.IsValid());
  377.                 assert(parrRelPoseDst[j].t.IsValid());
  378.         }
  379. #endif
  380. }
  381.  
  382. void NormalizeFull::Execute(const CState& state, CEvaluationContext& context) const
  383. {
  384.         const NormalizeFull& ac = *this;
  385.         void** CBTemp = context.m_buffers;
  386.  
  387.         assert(ac.m_TargetBuffer <= Command::TargetBuffer);
  388.         QuatT* parrRelPoseDst = (QuatT*)  CBTemp[ac.m_TargetBuffer + 0];
  389.         JointState* parrStatusDst = (JointState*)CBTemp[ac.m_TargetBuffer + 1];
  390.  
  391.         f32 fDotLocator = fabsf(parrRelPoseDst[0].q | parrRelPoseDst[0].q);
  392.         if (fDotLocator > 0.0001f)
  393.                 parrRelPoseDst[0].q *= isqrt_tpl(fDotLocator);
  394.         else
  395.                 parrRelPoseDst[0].q.SetIdentity();
  396.  
  397.         uint32 numJoints = state.m_jointCount;
  398.         for (uint32 i = 1; i < numJoints; i++)
  399.         {
  400.                 f32 dot = fabsf(parrRelPoseDst[i].q | parrRelPoseDst[i].q);
  401.                 if (dot > 0.0001f)
  402.                         parrRelPoseDst[i].q *= isqrt_tpl(dot);
  403.                 else
  404.                         parrRelPoseDst[i].q.SetIdentity();
  405.                 assert(parrRelPoseDst[i].q.IsUnit());
  406.         }
  407. }
  408.  
  409. void ScaleUniformFull::Execute(const CState& state, CEvaluationContext& context) const
  410. {
  411.         assert(m_TargetBuffer <= Command::TargetBuffer);
  412.  
  413.         const auto parrRelPoseDst = static_cast<QuatT*>(context.m_buffers[m_TargetBuffer + 0]);
  414.         const auto parrStatusDst = static_cast<JointState*>(context.m_buffers[m_TargetBuffer + 1]);
  415.  
  416.         for (uint32 j = 0; j < state.m_jointCount; ++j)
  417.         {
  418.                 if (parrStatusDst[j] & eJS_Orientation) // TODO: This check doesn't make sense, why is it performed?
  419.                 {
  420.                         parrRelPoseDst[j].t *= m_fScale;
  421.                 }
  422.         }
  423.  
  424.         std::for_each(parrRelPoseDst, parrRelPoseDst + state.m_jointCount, [](const QuatT& x)
  425.                 {
  426.                         assert(x.q.IsValid());
  427.                         assert(x.t.IsValid());
  428.           });
  429. }
  430.  
  431. #if defined(USE_PROTOTYPE_ABS_BLENDING)
  432. struct SAbsoluteTransform
  433. {
  434.         Quat prevAbs;
  435.         Quat newAbs;
  436. };
  437. #endif //!(USE_PROTOTYPE_ABS_BLENDING)
  438.  
  439. void SampleAddAnimPart::Execute(const CState& state, CEvaluationContext& context) const
  440. {
  441.  
  442.         assert(m_TargetBuffer <= Command::TargetBuffer);
  443.         const auto parrRelPoseDst = static_cast<QuatT*>(context.m_buffers[m_TargetBuffer + 0]);
  444.         const auto parrScalingDst = static_cast<float*>(context.m_buffers[m_TargetBuffer + 3]);
  445.         const auto parrStatusDst = static_cast<JointState*>(context.m_buffers[m_TargetBuffer + 1]);
  446.         const auto parrJWeightsDst = static_cast<Vec3*>(context.m_buffers[m_TargetBuffer + 2]);
  447.         if (!parrJWeightsDst)
  448.         {
  449.                 return;
  450.         }
  451.  
  452.         const auto& rCAF = [&]() -> const GlobalAnimationHeaderCAF& // TODO: move outside
  453.         {
  454.                 assert(m_nEAnimID >= 0);
  455.  
  456.                 const ModelAnimationHeader* pMAG = state.m_pDefaultSkeleton->m_pAnimationSet->GetModelAnimationHeader(m_nEAnimID);
  457.                 assert(pMAG);
  458.                 assert(pMAG->m_nAssetType == CAF_File);
  459.                 assert(pMAG->m_nGlobalAnimId >= 0);
  460.  
  461.                 return g_AnimationManager.m_arrGlobalCAF[pMAG->m_nGlobalAnimId];
  462.         } ();
  463.         assert(rCAF.IsAssetLoaded());
  464.  
  465.         PREFAST_SUPPRESS_WARNING(6255)
  466.         const auto parrController = static_cast<IController**>(alloca(state.m_jointCount * sizeof(IController*)));
  467.         LoadControllers(rCAF, state, parrController);
  468.  
  469.         assert(m_fAnimTime >= 0.0f && m_fAnimTime <= 1.0f);
  470.         const f32 fKeyTimeNew = rCAF.NTime2KTime(m_fAnimTime);
  471.  
  472.         if (rCAF.IsAssetAdditive())
  473.         {
  474.                 for (uint32 j = 1; j < state.m_jointCount; ++j)
  475.                 {
  476.                         if (parrController[j])
  477.                         {
  478.                                 Quat rot;
  479.                                 Vec3 pos;
  480.                                 Diag33 scl;
  481.                                 const JointState jointState = parrController[j]->GetOPS(fKeyTimeNew, rot, pos, scl);
  482.  
  483.                                 if (jointState & eJS_Orientation)
  484.                                 {
  485.                                         parrJWeightsDst[j].x += m_fWeight;
  486.                                         parrRelPoseDst[j].q = Quat::CreateNlerp(IDENTITY, rot, m_fWeight) * parrRelPoseDst[j].q;
  487.                                 }
  488.                                 if (jointState & eJS_Position)
  489.                                 {
  490.                                         parrJWeightsDst[j].y += m_fWeight;
  491.                                         parrRelPoseDst[j].t += pos * m_fWeight;
  492.                                 }
  493.                                 if (jointState & eJS_Scale)
  494.                                 {
  495.                                         parrJWeightsDst[j].z += m_fWeight;
  496.                                         parrScalingDst[j] *= LERP(1.0f, scl.x, m_fWeight);
  497.                                         context.m_isScalingPresent = true;
  498.                                 }
  499.  
  500.                                 parrStatusDst[j] |= jointState;
  501.                         }
  502.                 }
  503.         }
  504.         else
  505.         {
  506.                 const QuatT* parrDefJoints = state.m_pDefaultSkeleton->m_poseDefaultData.GetJointsRelativeMain();
  507.                 const QuatT* parrHemispherePose = Console::GetInst().ca_SampleQuatHemisphereFromCurrentPose ? parrRelPoseDst : parrDefJoints; // joints to compare with in quaternion dot product
  508.  
  509.                 for (uint32 j = 1; j < state.m_jointCount; ++j)
  510.                 {
  511.                         if (parrController[j])
  512.                         {
  513.                                 Quat rot;
  514.                                 Vec3 pos;
  515.                                 Diag33 scl;
  516.                                 const JointState jointState = parrController[j]->GetOPS(fKeyTimeNew, rot, pos, scl);
  517.  
  518.                                 if (jointState & eJS_Orientation)
  519.                                 {
  520.                                         parrJWeightsDst[j].x += m_fWeight;
  521.                                         parrRelPoseDst[j].q += rot * fsgnnz(parrHemispherePose[j].q | rot) * m_fWeight;
  522.                                 }
  523.                                 if (jointState & eJS_Position)
  524.                                 {
  525.                                         parrJWeightsDst[j].y += m_fWeight;
  526.                                         parrRelPoseDst[j].t += pos * m_fWeight;
  527.                                 }
  528.                                 if (jointState & eJS_Scale)
  529.                                 {
  530.                                         parrJWeightsDst[j].z += m_fWeight;
  531.                                         parrScalingDst[j] += scl.x * m_fWeight; // Take the x component only, we don't support non-uniform scaling yet.
  532.                                         context.m_isScalingPresent = true;
  533.                                 }
  534.  
  535.                                 parrStatusDst[j] |= jointState;
  536.                         }
  537.                 }
  538.         }
  539.  
  540.         g_pCharacterManager->g_SkeletonUpdates++;
  541.  
  542. #ifdef _DEBUG
  543.         {
  544.                 uint32 o = 0;
  545.                 uint32 p = 0;
  546.                 uint32 s = 0;
  547.                 for (uint32 j = 0; j < state.m_jointCount; ++j)
  548.                 {
  549.                         if (parrStatusDst[j] & eJS_Orientation)
  550.                         {
  551.                                 const Quat rot = parrRelPoseDst[j].q;
  552.                                 assert(parrRelPoseDst[j].q.IsValid());
  553.                                 o++;
  554.                         }
  555.                         if (parrStatusDst[j] & eJS_Position)
  556.                         {
  557.                                 const Vec3 pos = parrRelPoseDst[j].t;
  558.                                 assert(parrRelPoseDst[j].t.IsValid());
  559.                                 p++;
  560.                         }
  561.                         if (parrStatusDst[j] & eJS_Scale)
  562.                         {
  563.                                 const float scl = parrScalingDst[j];
  564.                                 assert(NumberValid(parrScalingDst[j]));
  565.                                 s++;
  566.                         }
  567.                 }
  568.         }
  569. #endif
  570.  
  571. }
  572.  
  573. void PerJointBlending::Execute(const CState& state, CEvaluationContext& context) const
  574. {
  575.         assert(m_TargetBuffer <= Command::TargetBuffer);
  576.  
  577.         // This is source-buffer No.1
  578.         const auto parrRelPoseLayer = static_cast<QuatT*>(context.m_buffers[m_SourceBuffer + 0]);
  579.         const auto parrScalingLayer = static_cast<float*>(context.m_buffers[m_SourceBuffer + 3]);
  580.         const auto parrStatusLayer = static_cast<JointState*>(context.m_buffers[m_SourceBuffer + 1]);
  581.         const auto parrWeightsLayer = static_cast<Vec3*>(context.m_buffers[m_SourceBuffer + 2]);
  582.         if (!parrWeightsLayer)
  583.         {
  584.                 return;
  585.         }
  586.  
  587.         // This is Source-Buffer No.2 and also the Target-Buffer
  588.         const auto parrRelPoseBase = static_cast<QuatT*>(context.m_buffers[m_TargetBuffer + 0]);
  589.         const auto parrScalingBase = static_cast<float*>(context.m_buffers[m_TargetBuffer + 3]);
  590.  
  591.         if (m_BlendMode)
  592.         {
  593.                 for (uint32 j = 0; j < state.m_jointCount; ++j)
  594.                 {
  595.                         // Additive Blending
  596.                         if (parrStatusLayer[j] & eJS_Orientation)
  597.                         {
  598.                                 parrRelPoseBase[j].q = Quat::CreateNlerp(IDENTITY, parrRelPoseLayer[j].q, parrWeightsLayer[j].x) * parrRelPoseBase[j].q;
  599.                         }
  600.                         if (parrStatusLayer[j] & eJS_Position)
  601.                         {
  602.                                 parrRelPoseBase[j].t += parrRelPoseLayer[j].t * parrWeightsLayer[j].y;
  603.                         }
  604.                         if (parrStatusLayer[j] & eJS_Scale)
  605.                         {
  606.                                 parrScalingBase[j] *= LERP(1.0f, parrScalingLayer[j], parrWeightsLayer[j].z);
  607.                         }
  608.                 }
  609.         }
  610.         else
  611.         {
  612.                 for (uint32 j = 0; j < state.m_jointCount; ++j)
  613.                 {
  614.                         // Override Blending
  615.                         if (parrStatusLayer[j] & eJS_Orientation)
  616.                         {
  617.                                 parrRelPoseBase[j].q = (parrRelPoseBase[j].q * (1.0f - parrWeightsLayer[j].x) + parrRelPoseLayer[j].q * fsgnnz(parrRelPoseBase[j].q | parrRelPoseLayer[j].q)).GetNormalized(); // Quaternion LERP
  618.                         }
  619.                         if (parrStatusLayer[j] & eJS_Position)
  620.                         {
  621.                                 parrRelPoseBase[j].t = parrRelPoseBase[j].t * (1.0f - parrWeightsLayer[j].y) + parrRelPoseLayer[j].t;  // Vector LERP
  622.                         }
  623.                         if (parrStatusLayer[j] & eJS_Scale)
  624.                         {
  625.                                 parrScalingBase[j] = parrScalingBase[j] * (1.0f - parrWeightsLayer[j].y) + parrScalingLayer[j];
  626.                         }
  627.                 }
  628.         }
  629. }
  630.  
  631. void PoseModifier::Execute(const CState& state, CEvaluationContext& context) const
  632. {
  633.         const PoseModifier& ac = *this;
  634.         void** CBTemp = context.m_buffers;
  635.  
  636.         SAnimationPoseModifierParams params;
  637.         params.pCharacterInstance = state.m_pInstance;
  638.         params.pPoseData = state.m_pPoseData;
  639.         params.timeDelta = state.m_originalTimeDelta;
  640.         params.location = state.m_location;
  641.         ac.m_pPoseModifier->Execute(params);
  642.         /*
  643.            #ifdef _DEBUG
  644.            for (uint32 j=0; j<params.jointCount; j++)
  645.            {
  646.             assert( params.pPoseRelative[j].q.IsUnit() );
  647.             assert( params.pPoseAbsolute[j].q.IsUnit() );
  648.             assert( params.pPoseRelative[j].IsValid() );
  649.             assert( params.pPoseAbsolute[j].IsValid() );
  650.            }
  651.            #endif
  652.          */
  653. }
  654.  
  655. void UpdateRedirectedJoint::Execute(const CState& state, CEvaluationContext& context) const
  656. {
  657.         m_attachmentBone->Update_Redirected(*state.m_pPoseData);
  658. }
  659.  
  660. void UpdatePendulumRow::Execute(const CState& state, CEvaluationContext& context) const
  661. {
  662.         m_attachmentPendulumRow->UpdateRow(*state.m_pPoseData);
  663. }
  664.  
  665. void PrepareAllRedirectedTransformations::Execute(const CState& state, CEvaluationContext& context) const
  666. {
  667.         state.m_pInstance->m_AttachmentManager.PrepareAllRedirectedTransformations(*state.m_pPoseData);
  668. }
  669.  
  670. void GenerateProxyModelRelativeTransformations::Execute(const CState& state, CEvaluationContext& context) const
  671. {
  672.         state.m_pInstance->m_AttachmentManager.GenerateProxyModelRelativeTransformations(*state.m_pPoseData);
  673. }
  674.  
  675. void ComputeAbsolutePose::Execute(const CState& state, CEvaluationContext& context) const
  676. {
  677.         state.m_pPoseData->ValidateRelative(*state.m_pInstance->m_pDefaultSkeleton);
  678.         state.m_pPoseData->ComputeAbsolutePose(*state.m_pInstance->m_pDefaultSkeleton, state.m_pDefaultSkeleton->m_ObjectType == CHR);
  679.         state.m_pPoseData->ValidateAbsolute(*state.m_pInstance->m_pDefaultSkeleton);
  680. }
  681.  
  682. void ProcessAnimationDrivenIkFunction(CCharInstance& instance, IAnimationPoseData* pAnimationPoseData, const QuatTS location)
  683. {
  684.         DEFINE_PROFILER_FUNCTION();
  685.  
  686.         Skeleton::CPoseData* pPoseData = Skeleton::CPoseData::GetPoseData(pAnimationPoseData);
  687.         if (!pPoseData)
  688.                 return;
  689.  
  690.         int jointCount = int(pPoseData->GetJointCount());
  691.  
  692.         const CDefaultSkeleton& modelSkeleton = *instance.m_pDefaultSkeleton;
  693.  
  694.         QuatT* const __restrict pPoseRelative = pPoseData->GetJointsRelative();
  695.         QuatT* const __restrict pPoseAbsolute = pPoseData->GetJointsAbsolute();
  696.  
  697.         uint targetCount = uint(modelSkeleton.m_ADIKTargets.size());
  698.         for (uint i = 0; i < targetCount; i++)
  699.         {
  700.                 LimbIKDefinitionHandle nHandle = modelSkeleton.m_ADIKTargets[i].m_nHandle;
  701.  
  702.                 int targetJointIndex = modelSkeleton.m_ADIKTargets[i].m_idxTarget;
  703.                 assert(targetJointIndex < (int)jointCount);
  704.                 if (targetJointIndex < 0)
  705.                         continue;
  706.  
  707.                 int targetWeightJointIndex = modelSkeleton.m_ADIKTargets[i].m_idxWeight;
  708.                 assert(targetWeightJointIndex < (int)jointCount);
  709.                 if (targetWeightJointIndex < 0)
  710.                         continue;
  711.  
  712.                 int32 limbDefinitionIndex = modelSkeleton.GetLimbDefinitionIdx(nHandle);
  713.                 if (limbDefinitionIndex < 0)
  714.                         continue;
  715.  
  716.                 const IKLimbType& limbType = modelSkeleton.m_IKLimbTypes[limbDefinitionIndex];
  717.  
  718.                 const QuatT& targetLocationAbsolute = pPoseAbsolute[targetJointIndex];
  719.                 float targetBlendWeight = pPoseRelative[targetWeightJointIndex].t.x;
  720.                 targetBlendWeight = clamp_tpl(targetBlendWeight, 0.0f, 1.0f);
  721.                 if (targetBlendWeight > 0.01f)
  722.                 {
  723.                         uint numLinks = uint(limbType.m_arrJointChain.size());
  724.                         int endEffectorJointIndex = limbType.m_arrJointChain[numLinks - 1].m_idxJoint;
  725.                         int endEffectorParentJointIndex = modelSkeleton.m_arrModelJoints[endEffectorJointIndex].m_idxParent;
  726.  
  727.                         pPoseAbsolute[0] = pPoseRelative[0];
  728.                         ANIM_ASSET_ASSERT(pPoseRelative[0].q.IsUnit());
  729.                         for (uint j = 1; j < numLinks; ++j)
  730.                         {
  731.                                 int p = limbType.m_arrRootToEndEffector[j - 1];
  732.                                 int c = limbType.m_arrRootToEndEffector[j];
  733.                                 ANIM_ASSET_ASSERT(pPoseRelative[c].q.IsUnit());
  734.                                 ANIM_ASSET_ASSERT(pPoseRelative[p].q.IsUnit());
  735.                                 pPoseAbsolute[c] = pPoseAbsolute[p] * pPoseRelative[c];
  736.                                 ANIM_ASSET_ASSERT(pPoseRelative[c].q.IsUnit());
  737.                         }
  738.  
  739.                         const char* _2BIK = "2BIK";
  740.                         const char* _3BIK = "3BIK";
  741.                         const char* _CCDX = "CCDX";
  742.                         Vec3 vLocalTarget;
  743.                         vLocalTarget.SetLerp(pPoseAbsolute[endEffectorJointIndex].t, targetLocationAbsolute.t, targetBlendWeight);
  744.                         if (limbType.m_nSolver == *(uint32*)_2BIK)
  745.                                 PoseModifierHelper::IK_Solver2Bones(vLocalTarget, limbType, *pPoseData);
  746.                         if (limbType.m_nSolver == *(uint32*)_3BIK)
  747.                                 PoseModifierHelper::IK_Solver3Bones(vLocalTarget, limbType, *pPoseData);
  748.                         if (limbType.m_nSolver == *(uint32*)_CCDX)
  749.                                 PoseModifierHelper::IK_SolverCCD(vLocalTarget, limbType, *pPoseData);
  750.  
  751.                         for (uint j = 1; j < numLinks; ++j)
  752.                         {
  753.                                 int c = limbType.m_arrJointChain[j].m_idxJoint;
  754.                                 int p = limbType.m_arrJointChain[j - 1].m_idxJoint;
  755.                                 pPoseAbsolute[c] = pPoseAbsolute[p] * pPoseRelative[c];
  756.                                 ANIM_ASSET_ASSERT(pPoseAbsolute[c].q.IsUnit());
  757.                         }
  758.  
  759. #ifdef _DEBUG
  760.                         ANIM_ASSET_ASSERT(targetLocationAbsolute.q.IsUnit());
  761.                         ANIM_ASSET_ASSERT(targetLocationAbsolute.q.IsValid());
  762.                         ANIM_ASSET_ASSERT(pPoseAbsolute[endEffectorJointIndex].q.IsUnit());
  763.                         ANIM_ASSET_ASSERT(pPoseAbsolute[endEffectorJointIndex].q.IsValid());
  764. #endif
  765.                         pPoseAbsolute[endEffectorJointIndex].q.SetNlerp(
  766.                           pPoseAbsolute[endEffectorJointIndex].q, targetLocationAbsolute.q, targetBlendWeight);
  767. #ifdef _DEBUG
  768.                         ANIM_ASSET_ASSERT(pPoseAbsolute[endEffectorParentJointIndex].q.IsUnit());
  769.                         ANIM_ASSET_ASSERT(pPoseAbsolute[endEffectorParentJointIndex].q.IsValid());
  770.                         ANIM_ASSET_ASSERT(pPoseAbsolute[endEffectorJointIndex].q.IsUnit());
  771.                         ANIM_ASSET_ASSERT(pPoseAbsolute[endEffectorJointIndex].q.IsValid());
  772. #endif
  773.                         pPoseRelative[endEffectorJointIndex].q = !pPoseAbsolute[endEffectorParentJointIndex].q * pPoseAbsolute[endEffectorJointIndex].q;
  774.  
  775.                         uint numChilds = modelSkeleton.m_IKLimbTypes[limbDefinitionIndex].m_arrLimbChildren.size();
  776.                         const int16* pJointIdx = &modelSkeleton.m_IKLimbTypes[limbDefinitionIndex].m_arrLimbChildren[0];
  777.                         for (uint u = 0; u < numChilds; u++)
  778.                         {
  779.                                 int c = pJointIdx[u];
  780.                                 int p = modelSkeleton.m_arrModelJoints[c].m_idxParent;
  781.                                 pPoseAbsolute[c] = pPoseAbsolute[p] * pPoseRelative[c];
  782. #ifdef _DEBUG
  783.                                 ANIM_ASSET_ASSERT(pPoseAbsolute[c].q.IsUnit());
  784.                                 ANIM_ASSET_ASSERT(pPoseAbsolute[p].q.IsUnit());
  785.                                 ANIM_ASSET_ASSERT(pPoseRelative[c].q.IsUnit());
  786.                                 ANIM_ASSET_ASSERT(pPoseAbsolute[c].q.IsValid());
  787.                                 ANIM_ASSET_ASSERT(pPoseAbsolute[p].q.IsValid());
  788.                                 ANIM_ASSET_ASSERT(pPoseRelative[c].q.IsValid());
  789. #endif
  790.                         }
  791.                 }
  792.  
  793.                 if (Console::GetInst().ca_DebugADIKTargets)
  794.                 {
  795.                         const char* pName = modelSkeleton.m_ADIKTargets[i].m_strTarget;
  796.  
  797.                         float fColor[4] = { 0, 1, 0, 1 };
  798.                         g_pAuxGeom->Draw2dLabel(1, g_YLine, 1.4f, fColor, false, "LHand_IKTarget: name: %s  rot: (%f %f %f %f)  pos: (%f %f %f) blend: %f", pName, targetLocationAbsolute.q.w, targetLocationAbsolute.q.v.x, targetLocationAbsolute.q.v.y, targetLocationAbsolute.q.v.z, targetLocationAbsolute.t.x, targetLocationAbsolute.t.y, targetLocationAbsolute.t.z, pPoseRelative[targetWeightJointIndex].t.x);
  799.                         g_YLine += 16.0f;
  800.  
  801.                         static Ang3 angle(0, 0, 0);
  802.                         angle += Ang3(0.01f, +0.02f, +0.03f);
  803.                         AABB aabb = AABB(Vec3(-0.015f, -0.015f, -0.015f), Vec3(+0.015f, +0.015f, +0.015f));
  804.  
  805.                         Matrix33 m33 = Matrix33::CreateRotationXYZ(angle);
  806.                         OBB obb = OBB::CreateOBBfromAABB(m33, aabb);
  807.                         Vec3 obbPos = location * targetLocationAbsolute.t;
  808.                         g_pAuxGeom->DrawOBB(obb, obbPos, 1, RGBA8(0xff, 0x00, 0x1f, 0xff), eBBD_Extremes_Color_Encoded);
  809.                 }
  810.         }
  811. }
  812.  
  813. void ProcessAnimationDrivenIk::Execute(const CState& state, CEvaluationContext& context) const
  814. {
  815.         if (!state.m_pInstance->m_SkeletonPose.m_physics.m_bPhysicsRelinquished && state.m_pInstance->m_SkeletonAnim.m_IsAnimPlaying && Console::GetInst().ca_useADIKTargets)
  816.         {
  817.                 ProcessAnimationDrivenIkFunction(*state.m_pInstance, state.m_pPoseData, state.m_location);
  818.         }
  819. }
  820.  
  821. void PhysicsSync::Execute(const CState& state, CEvaluationContext& context) const
  822. {
  823.         state.m_pInstance->m_SkeletonPose.m_physics.Job_Physics_SynchronizeFrom(*state.m_pPoseData, state.m_originalTimeDelta);
  824. }
  825.  
  826. #ifdef _DEBUG
  827. void VerifyFull::Execute(const CState& state, CEvaluationContext& context) const
  828. {
  829.         const VerifyFull& ac = *this;
  830.         void** CBTemp = context.m_buffers;
  831.  
  832.         assert(ac.m_TargetBuffer <= Command::TargetBuffer);
  833.         QuatT* parrRelPoseDst = (QuatT*)    CBTemp[ac.m_TargetBuffer + 0];
  834.         JointState* parrStatusDst = (JointState*)  CBTemp[ac.m_TargetBuffer + 1];
  835.         uint32 numJoints = state.m_jointCount;
  836.         for (uint32 j = 0; j < numJoints; j++)
  837.         {
  838.                 JointState s4 = parrStatusDst[j];
  839.                 assert(parrRelPoseDst[j].q.IsValid());
  840.                 assert(parrRelPoseDst[j].t.IsValid());
  841.         }
  842. }
  843. #endif
  844.  
  845. } // namespace Command
  846.  
downloadCommand_Commands.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top