BVB Source Codes

CRYENGINE Show IKTorsoAim.cpp Source code

Return Download CRYENGINE: download IKTorsoAim.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 <Cry3DEngine/I3DEngine.h>
  5. #include <CryRenderer/IRenderAuxGeom.h>
  6.  
  7. #include "IKTorsoAim.h"
  8.  
  9. CRYREGISTER_CLASS(CIKTorsoAim)
  10.  
  11. CIKTorsoAim::STorsoAim_CVars CIKTorsoAim::s_CVars;
  12.  
  13. #define DO_DEBUG_RENDER 0
  14.  
  15. #if DO_DEBUG_RENDER
  16.  
  17. static Vec3 g_effPos;
  18. static Vec3 g_effFwds;
  19. static Vec3 g_aimJointPos;
  20. static Vec3 g_localTgtDir;
  21. static QuatT g_newAimJointPos;
  22.  
  23. #endif //DO_DEBUG_RENDER
  24.  
  25. //
  26. //////////////////////////////////////////////////////////////////////////
  27. //////////////////////////////////////////////////////////////////////////
  28. void CIKTorsoAim::STorsoAim_CVars::InitCvars()
  29. {
  30.         if (m_initialized)
  31.                 return;
  32.  
  33.         m_initialized = true;
  34.  
  35.         REGISTER_CVAR(STAP_DEBUG, 0, VF_NULL, "Enable STAP Debug Rendering");
  36.         REGISTER_CVAR(STAP_DISABLE, 0, VF_NULL, "Disable torso orientation");
  37.         REGISTER_CVAR(STAP_TRANSLATION_FUDGE, 1, VF_NULL, "Enable STAP Translation Fudge");
  38.         REGISTER_CVAR(STAP_TRANSLATION_FEATHER, 1, VF_NULL, "Enable STAP Translation Feathering");
  39.         REGISTER_CVAR(STAP_LOCK_EFFECTOR, 0, VF_NULL, "Lock the STAP Effector Joint");
  40.         REGISTER_CVAR(STAP_OVERRIDE_TRACK_FACTOR, -1.0f, VF_NULL, "Override the base anim tracking factor");
  41. }
  42.  
  43. void CIKTorsoAim::STorsoAim_CVars::ReleaseCVars()
  44. {
  45.         /*
  46.            if (gEnv->pConsole)
  47.            {
  48.            gEnv->pConsole->UnregisterVariable("STAP_DEBUG", true);
  49.            gEnv->pConsole->UnregisterVariable("STAP_DISABLE", true);
  50.            gEnv->pConsole->UnregisterVariable("STAP_TRANSLATION_FUDGE", true);
  51.            gEnv->pConsole->UnregisterVariable("STAP_TRANSLATION_FEATHER", true);
  52.            gEnv->pConsole->UnregisterVariable("STAP_LOCK_EFFECTOR", true);
  53.            gEnv->pConsole->UnregisterVariable("STAP_OVERRIDE_TRACK_FACTOR", true);
  54.            }
  55.          */
  56. }
  57.  
  58. //////////////////////////////////////////////////////////////////////////
  59. //////////////////////////////////////////////////////////////////////////
  60.  
  61. CIKTorsoAim::SParams::SParams()
  62. {
  63.         blend = 0.0f;
  64.         blendPosition = 0.0f;
  65.         targetDirection.zero();
  66.         viewOffset.SetIdentity();
  67.         absoluteTargetPosition.zero();
  68.         baseAnimTrackFactor = 1.0f;
  69.         numParents = 0;
  70.         effectorJoint = -1;
  71.         aimJoint = -1;
  72.         weights[0] = 1.0f;
  73. }
  74.  
  75. CIKTorsoAim::CIKTorsoAim()
  76. {
  77.         Init();
  78. };
  79. //
  80.  
  81. void CIKTorsoAim::Init()
  82. {
  83.         m_aimToEffector = Vec3(ZERO);
  84.         m_effectorDirQuat.SetIdentity();
  85.         m_lastProcessedEffector.SetIdentity();
  86. }
  87.  
  88. void CIKTorsoAim::InitCVars()
  89. {
  90.         s_CVars.InitCvars();
  91. }
  92.  
  93. void CIKTorsoAim::SetBlendWeight(float blend)
  94. {
  95.         m_setParams.blend = blend;
  96. }
  97.  
  98. void CIKTorsoAim::SetBlendWeightPosition(float blendPos)
  99. {
  100.         m_setParams.blendPosition = blendPos;
  101. }
  102.  
  103. void CIKTorsoAim::SetTargetDirection(const Vec3& direction)
  104. {
  105.         m_setParams.targetDirection = direction;
  106. }
  107.  
  108. void CIKTorsoAim::SetViewOffset(const QuatT& offset)
  109. {
  110.         m_setParams.viewOffset = offset;
  111. }
  112.  
  113. void CIKTorsoAim::SetAbsoluteTargetPosition(const Vec3& targetPosition)
  114. {
  115.         m_setParams.absoluteTargetPosition = targetPosition;
  116. }
  117.  
  118. void CIKTorsoAim::SetFeatherWeights(uint32 weights, const f32* customBlends)
  119. {
  120.         assert(weights <= TORSOAIM_MAX_JOINTS);
  121.         memcpy(m_setParams.weights, customBlends, sizeof(f32) * weights);
  122.         m_setParams.numParents = weights - 1;
  123. }
  124.  
  125. void CIKTorsoAim::SetJoints(uint32 jntEffector, uint32 jntAdjustment)
  126. {
  127.         m_setParams.aimJoint = jntAdjustment;
  128.         m_setParams.effectorJoint = jntEffector;
  129. }
  130.  
  131. void CIKTorsoAim::SetBaseAnimTrackFactor(float factor)
  132. {
  133.         m_setParams.baseAnimTrackFactor = factor;
  134. }
  135.  
  136. // IAnimationPoseModifier
  137.  
  138. bool CIKTorsoAim::Prepare(const SAnimationPoseModifierParams& params)
  139. {
  140.         bool ShowDebug = s_CVars.STAP_DEBUG != 0;
  141.  
  142.         const float XPOS = 20.0f;
  143.         const float YPOS = 35.0f;
  144.         const float FONT_SIZE = 2.0f;
  145.         const float FONT_COLOUR[4] = { 1, 1, 1, 1 };
  146.         if (ShowDebug)
  147.         {
  148.                 IRenderAuxText::Draw2dLabel(XPOS, YPOS, FONT_SIZE, FONT_COLOUR, false, "Torso Aim Pose: %f (%f, %f, %f)", m_params.blend, m_params.targetDirection.x, m_params.targetDirection.y, m_params.targetDirection.z);
  149.                 IRenderAuxText::Draw2dLabel(XPOS, YPOS + 15.0f, FONT_SIZE, FONT_COLOUR, false, "Absolute Position: (%f, %f, %f)", m_setParams.absoluteTargetPosition.x, m_setParams.absoluteTargetPosition.y, m_setParams.absoluteTargetPosition.z);
  150.         }
  151.  
  152. #if DO_DEBUG_RENDER
  153.  
  154.         const float SPHERE_SIZE = 0.1f;
  155.         IRenderAuxGeom* pAux = gEnv->pRenderer->GetIRenderAuxGeom();
  156.         const ColorF red(1.0f, 0.0f, 0.0f, 1.0f);
  157.         const ColorF green(0.0f, 1.0f, 0.0f, 1.0f);
  158.         const ColorF yellow(1.0f, 1.0f, 0.0f, 1.0f);
  159.         const ColorF blue(0.0f, 0.0f, 1.0f, 1.0f);
  160.  
  161.         //--- TODO
  162.         if (ShowDebug)
  163.         {
  164.                 //--- Debug draw
  165.                 Vec3 effTarget = g_effPos + (g_effFwds * 100.0f);
  166.                 Vec3 localTgtPos = g_effPos + (g_localTgtDir * 100.0f);
  167.  
  168.                 SAuxGeomRenderFlags renderFlags(e_Def3DPublicRenderflags);
  169.                 pAux->SetRenderFlags(renderFlags);
  170.                 pAux->DrawSphere(params.location * effTarget, SPHERE_SIZE, red);
  171.                 pAux->DrawSphere(params.location * localTgtPos, SPHERE_SIZE, green);
  172.                 pAux->DrawLine(params.location * g_aimJointPos, yellow, params.location * effTarget, red);
  173.                 pAux->DrawLine(params.location * g_aimJointPos, yellow, params.location * localTgtPos, green);
  174.                 //--- Debug draw
  175.         }
  176.         //--- TODO
  177.         if (ShowDebug)
  178.         {
  179.                 const float CAMERA_EFFECTOR_LEN = 5.0f;
  180.                 //--- Debug draw
  181.                 QuatT wsAim = params.location * g_newAimJointPos;
  182.                 QuatT wsEffector = params.location * m_lastProcessedEffector;
  183.  
  184.                 pAux->DrawLine(wsEffector.t, red, m_params.targetDirection, green);
  185.                 pAux->DrawSphere(wsEffector.t, SPHERE_SIZE, red);
  186.                 pAux->DrawSphere(wsAim.t, SPHERE_SIZE, green);
  187.  
  188.                 pAux->DrawLine(wsEffector.t, red, wsEffector.t + (wsEffector.GetColumn1() * CAMERA_EFFECTOR_LEN), blue);
  189.  
  190.                 //--- Draw effector AXIS
  191.                 //const float AXIS_LENGTH = 0.5f;
  192.                 //Vec3 DEBUG_init_right = pAbsolutePose[m_params.effectorJoint].GetColumn0();
  193.                 //Vec3 DEBUG_init_fwd = pAbsolutePose[m_params.effectorJoint].GetColumn1();
  194.                 //Vec3 DEBUG_init_up = pAbsolutePose[m_params.effectorJoint].GetColumn2();
  195.                 //pAux->DrawLine(params.locationNextPhysics * pAbsolutePose[m_params.effectorJoint].t, red, params.locationNextPhysics * (pAbsolutePose[m_params.effectorJoint].t + (DEBUG_init_right * AXIS_LENGTH)), red);
  196.                 //pAux->DrawLine(params.locationNextPhysics * pAbsolutePose[m_params.effectorJoint].t, green, params.locationNextPhysics * (pAbsolutePose[m_params.effectorJoint].t + (DEBUG_init_fwd * AXIS_LENGTH)), green);
  197.                 //pAux->DrawLine(params.locationNextPhysics * pAbsolutePose[m_params.effectorJoint].t, blue, params.locationNextPhysics * (pAbsolutePose[m_params.effectorJoint].t + (DEBUG_init_up * AXIS_LENGTH)), blue);
  198.                 //--- Debug draw
  199.         }
  200.  
  201. #endif //DO_DEBUG_RENDER
  202.  
  203.         m_params = m_setParams;
  204.  
  205.         return true;
  206. }
  207.  
  208. bool CIKTorsoAim::Execute(const SAnimationPoseModifierParams& params)
  209. {
  210.         const IDefaultSkeleton& rIDefaultSkeleton = params.GetIDefaultSkeleton();
  211.         if ((m_params.effectorJoint < 0) || (m_params.aimJoint < 0))
  212.                 return false;
  213.  
  214.         bool StapDisable = s_CVars.STAP_DISABLE != 0;
  215.         bool StapLockEffector = s_CVars.STAP_LOCK_EFFECTOR != 0;
  216.         float OverrideTrackFactor = s_CVars.STAP_OVERRIDE_TRACK_FACTOR;
  217.         if (StapDisable)
  218.         {
  219.                 return false;
  220.         }
  221.  
  222.         uint32 numJoints = params.pPoseData->GetJointCount();
  223.         ;
  224.         params.pPoseData->SetJointAbsolute(0, QuatT(params.pPoseData->GetJointRelative(0)));
  225.         for (uint32 i = 1; i < numJoints; i++)
  226.         {
  227.                 params.pPoseData->SetJointAbsolute(i,
  228.                                                    params.pPoseData->GetJointAbsolute(rIDefaultSkeleton.GetJointParentIDByID(i)) *
  229.                                                    params.pPoseData->GetJointRelative(i));
  230.         }
  231.  
  232.         QuatT inverseInitialAim = params.pPoseData->GetJointAbsolute(m_params.aimJoint).GetInverted();
  233.  
  234.         //      CryLogAlways("CIKTorsoAim::Execute: Anim:(%f, %f, %f, %f)", params.locationNextAnimation.q.v.x, params.locationNextAnimation.q.v.y, params.locationNextAnimation.q.v.z, params.locationNextAnimation.q.w);
  235.         //      CryLogAlways("CIKTorsoAim::Execute: Phys:(%f, %f, %f, %f)", params.locationNextPhysics.q.v.x, params.locationNextPhysics.q.v.y, params.locationNextPhysics.q.v.z, params.locationNextPhysics.q.w);
  236.  
  237.         const bool RemoveInitialRoll = true;
  238.  
  239.         Vec3 localTgtDir = m_params.targetDirection;
  240.  
  241.         Quat relHeadQuat;
  242.         Vec3 effFwds = params.pPoseData->GetJointAbsolute(m_params.effectorJoint).GetColumn1();
  243.  
  244.         Vec3 initialEffectorMS = effFwds;
  245.         Vec3 targetEffectorMS = localTgtDir;
  246.  
  247.         //--- Calculate initial roll, ready for removal
  248.         Vec3 idealRight = params.pPoseData->GetJointAbsolute(m_params.effectorJoint).GetColumn1().Cross(Vec3Constants<float>::fVec3_OneZ).GetNormalizedSafe();
  249.         float upDP = params.pPoseData->GetJointAbsolute(m_params.effectorJoint).GetColumn2().Dot(idealRight);
  250.         float initialRoll = (f32)(g_PI * 0.5f) - acos_tpl(upDP);
  251.  
  252.         Quat effectorDirQuat = m_effectorDirQuat;
  253.         Vec3 aimToEffector = m_aimToEffector;
  254.         float baseFactor = (float) __fsel(OverrideTrackFactor, OverrideTrackFactor, m_params.baseAnimTrackFactor);
  255.         if (!StapLockEffector)
  256.         {
  257.                 if (baseFactor > 0.0f)
  258.                 {
  259.                         effectorDirQuat = RemoveInitialRoll ? Quat::CreateRotationVDir(initialEffectorMS, initialRoll) : Quat::CreateRotationVDir(initialEffectorMS);
  260.                         aimToEffector = inverseInitialAim * params.pPoseData->GetJointAbsolute(m_params.effectorJoint).t;
  261.  
  262.                         if (baseFactor == 1.0f)
  263.                         {
  264.                                 m_effectorDirQuat = effectorDirQuat;
  265.                                 m_aimToEffector = aimToEffector;
  266.                         }
  267.                         else
  268.                         {
  269.                                 effectorDirQuat = Quat::CreateSlerp(m_effectorDirQuat, effectorDirQuat, baseFactor);
  270.                                 aimToEffector.SetLerp(m_aimToEffector, aimToEffector, baseFactor);
  271.                         }
  272.                 }
  273.         }
  274.  
  275.         Quat rebase = !effectorDirQuat* params.pPoseData->GetJointAbsolute(m_params.aimJoint).q;
  276.         Quat targetDirQuat = Quat::CreateRotationVDir(targetEffectorMS);
  277.         Quat absHeadQuat = targetDirQuat * rebase;
  278.         relHeadQuat = inverseInitialAim.q * absHeadQuat;
  279.         relHeadQuat.NormalizeSafe();
  280.  
  281.         bool useAbsoluteTarget = (m_params.absoluteTargetPosition.IsZero() == false);
  282.  
  283.         const bool useAbsoluteCameraPos = true;
  284.  
  285.         Vec3 viewOffsetTran = (targetDirQuat * !effectorDirQuat) * m_params.viewOffset.t;
  286.  
  287.         Vec3 absoluteOffset(0.0f, 0.0f, 0.0f);
  288.         if (useAbsoluteTarget)
  289.         {
  290.                 absoluteOffset = m_params.absoluteTargetPosition;
  291.         }
  292.  
  293.         Vec3 relativeOffset = absoluteOffset - params.pPoseData->GetJointAbsolute(m_params.aimJoint).t;
  294.  
  295. #if DO_DEBUG_RENDER
  296.         g_effPos = params.pPoseData->GetJointAbsolute(m_params.effectorJoint).t;
  297.         g_effFwds = effFwds;
  298.         g_aimJointPos = params.pPoseData->GetJointAbsolute((m_params.aimJoint).t;
  299.                                                            g_localTgtDir = localTgtDir;
  300. #endif //DO_DEBUG_RENDER
  301.  
  302.         int16 idx = m_params.aimJoint;
  303.         int16 childidx = -1;
  304.         for (int16 i = m_params.numParents; i >= 0; i--)
  305.         {
  306.                 int16 pidx = rIDefaultSkeleton.GetJointParentIDByID(idx);
  307.                 float weight = m_params.weights[i] * m_params.blend;
  308.  
  309.                 if (childidx < 0)
  310.                 {
  311.                         Quat adjustFactored = relHeadQuat * !params.pPoseData->GetJointAbsolute(idx).q * m_params.viewOffset.q * params.pPoseData->GetJointAbsolute(idx).q;
  312.                         Quat lerpSpine = Quat::CreateSlerp(Quat(IDENTITY), adjustFactored, weight);
  313.                         params.pPoseData->SetJointAbsoluteO(idx, params.pPoseData->GetJointAbsolute(idx).q * lerpSpine);
  314.  
  315.                         if (useAbsoluteCameraPos)
  316.                         {
  317.                                 Vec3 newEffectorT = params.pPoseData->GetJointAbsolute(m_params.aimJoint) * aimToEffector;
  318.                                 relativeOffset = absoluteOffset - newEffectorT;
  319.                         }
  320.                 }
  321.                 else
  322.                 {
  323.                         Quat targetPose = params.pPoseData->GetJointAbsolute(childidx).q * !params.pPoseData->GetJointRelative(childidx).q;
  324.                         Quat Diff = !params.pPoseData->GetJointAbsolute(idx).q * targetPose;
  325.                         Quat lerpSpine = Quat::CreateSlerp(Quat(IDENTITY), Diff, weight);
  326.                         params.pPoseData->SetJointAbsoluteO(idx, params.pPoseData->GetJointAbsolute(idx).q * lerpSpine);
  327.                 }
  328.  
  329.                 if (useAbsoluteTarget)
  330.                 {
  331.                         params.pPoseData->SetJointAbsoluteP(idx, params.pPoseData->GetJointAbsolute(idx).t + relativeOffset * (weight * m_params.blendPosition));
  332.                 }
  333.  
  334.                 params.pPoseData->SetJointAbsoluteP(idx, params.pPoseData->GetJointAbsolute(idx).t + viewOffsetTran * weight);
  335.                 params.pPoseData->SetJointAbsoluteO(idx, params.pPoseData->GetJointAbsolute(idx).q.GetNormalized());
  336.  
  337.                 childidx = idx;
  338.                 assert(params.pPoseData->GetJointAbsolute(idx).IsValid());
  339.                 assert(params.pPoseData->GetJointAbsolute(idx).q.IsUnit());
  340.  
  341.                 idx = pidx;
  342.         }
  343.  
  344.         idx = m_params.aimJoint;
  345.         for (int16 i = m_params.numParents; i >= 0; i--)
  346.         {
  347.                 int16 pidx = rIDefaultSkeleton.GetJointParentIDByID(idx);
  348.                 params.pPoseData->SetJointRelative(idx, params.pPoseData->GetJointAbsolute(pidx).GetInverted() * params.pPoseData->GetJointAbsolute(idx));
  349.  
  350.                 assert(params.pPoseData->GetJointRelative(idx).IsValid());
  351.                 assert(params.pPoseData->GetJointRelative(idx).q.IsUnit());
  352.  
  353.                 idx = pidx;
  354.         }
  355.  
  356.         for (int i = 1; i < numJoints; i++)
  357.         {
  358.                 int32 p = rIDefaultSkeleton.GetJointParentIDByID(i);
  359.                 params.pPoseData->SetJointAbsolute(i, params.pPoseData->GetJointAbsolute(p) * params.pPoseData->GetJointRelative(i));
  360.                 assert(params.pPoseData->GetJointAbsolute(idx).IsValid());
  361.                 assert(params.pPoseData->GetJointAbsolute(idx).q.IsUnit());
  362.         }
  363.  
  364. #if DO_DEBUG_RENDER
  365.         g_newAimJointPos = params.pPoseData->GetJointAbsolute(m_params.aimJoint);
  366. #endif //DO_DEBUG_RENDER
  367.  
  368.         m_lastProcessedEffector = params.pPoseData->GetJointAbsolute(m_params.effectorJoint);
  369.  
  370.                                                                      return true;
  371. }
  372.  
  373. void CIKTorsoAim::Synchronize()
  374. {
  375. }
  376.  
downloadIKTorsoAim.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