BVB Source Codes

CRYENGINE Show PoseAlignerC3.cpp Source code

Return Download CRYENGINE: download PoseAlignerC3.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.  
  5. #include <CryExtension/CryCreateClassInstance.h>
  6. #include <CryExtension/ClassWeaver.h>
  7. #include <CryAnimation/ICryAnimation.h>
  8.  
  9. #include "PoseAligner.h"
  10.  
  11. #define UNKNOWN_GROUND_HEIGHT -1E10f
  12.  
  13. // Pinger specific Raycaster. Finds and updates the foot position for the pinger.
  14.  
  15. class CContactRaycastPinger : public PoseAligner::CContactReporter
  16. {
  17. public:
  18.         CContactRaycastPinger(IVehicle& pinger, float length)
  19.                 : m_pinger(pinger)
  20.                 , m_length(length)
  21.         {}
  22.  
  23.         // CContactReporter
  24. public:
  25.         virtual bool Update(Vec3& position, Vec3& normal);
  26.  
  27. private:
  28.         IVehicle& m_pinger;
  29.         float     m_length;
  30. };
  31.  
  32. typedef _smart_ptr<CContactRaycastPinger> CContactRaycastPingerPtr;
  33.  
  34. bool CContactRaycastPinger::Update(Vec3& position, Vec3& normal)
  35. {
  36.         Vec3 positionPrevious = position;
  37.         Vec3 positionPreviousGlobal = positionPrevious;
  38.  
  39.         Vec3 rayPosition = positionPreviousGlobal;
  40.         rayPosition.z += m_length;
  41.  
  42.         IPhysicalEntity* pSkipEntities[10];
  43.         int nSkip = m_pinger.GetSkipEntities(pSkipEntities, 10);
  44.  
  45.         static const int totalHits = 6;
  46.         ray_hit hits[totalHits];
  47.         IPhysicalWorld::SRWIParams rp;
  48.  
  49.         rp.Init(rayPosition, Vec3(0.0f, 0.0f, -m_length * 2.0f), ent_static | ent_terrain, rwi_pierceability0,
  50.                 SCollisionClass(0, collision_class_living | collision_class_articulated),
  51.                 &hits[0], totalHits, pSkipEntities, nSkip);
  52.  
  53.         int hitCount = gEnv->pPhysicalWorld->RayWorldIntersection(rp);
  54.  
  55.         // Find best hit. This is the highest contact, that is a viable place to put the foot.
  56.         //      eg. Not on poles, other Pinger's legs, or other unwanted places.
  57.  
  58.         ray_hit* pHit = NULL;
  59.         for (int i = 0; i < totalHits; i++)
  60.         {
  61.                 ray_hit& hit = hits[i];
  62.                 if (!hit.pCollider)
  63.                         continue;
  64.                 if (!hit.bTerrain)
  65.                 {
  66.                         // Ignore small and fast things.
  67.                         pe_params_flags pgetflags;
  68.                         pe_status_pos sgetpos;
  69.                         if (hit.pCollider->GetStatus(&sgetpos) && hit.pCollider->GetParams(&pgetflags))
  70.                                 if (sgetpos.iSimClass == 2 && (pgetflags.flags & ref_small_and_fast) != 0)
  71.                                         continue;
  72.  
  73.                         pe_params_part pgetpart;
  74.                         pgetpart.ipart = hit.ipart;
  75.  
  76.                         phys_geometry* geometry = NULL;
  77.                         if (hit.pCollider->GetParams(&pgetpart))
  78.                         {
  79.                                 if (pgetpart.flagsOR & geom_no_coll_response)
  80.                                         continue;
  81.  
  82.                                 geometry = pgetpart.pPhysGeomProxy ? pgetpart.pPhysGeomProxy : pgetpart.pPhysGeom;
  83.                         }
  84.  
  85.                         Vec3 sz;
  86.                         if (geometry && geometry->pGeom)
  87.                         {
  88.                                 primitives::box tempBox;
  89.                                 geometry->pGeom->GetBBox(&tempBox);
  90.                                 sz = tempBox.size;
  91.                         }
  92.                         else
  93.                         {
  94.                                 pe_params_bbox pgetbox;
  95.                                 hit.pCollider->GetParams(&pgetbox);
  96.                                 sz = (pgetbox.BBox[1] - pgetbox.BBox[0]);
  97.                         }
  98.  
  99.                         // Ignore small objects. (Matches similar check in livingentity physics code)
  100.                         const float maxarea = max(max(sz.x * sz.y, sz.x * sz.z), sz.y * sz.z) * sqr(pgetpart.scale) * 4;
  101.                         const float maxdim = max(max(sz.x, sz.y), sz.z) * pgetpart.scale * 2;
  102.                         if (maxarea < sqr(sz.x) * g_PI * 0.25f && maxdim < sz.z * 1.4f)
  103.                                 continue;
  104.                 }
  105.                 pHit = ((!pHit) || hit.dist < pHit->dist) ? &hit : pHit;
  106.         }
  107.  
  108.         // Apply the chosen hit results.
  109.         if (pHit)
  110.         {
  111.                 position.z = pHit->pt.z;
  112.                 normal = pHit->n * (float)__fsel(pHit->n.z, 1.f, -1.f);
  113.                 normal.NormalizeSafe(Vec3(0.0f, 0.0f, 1.0f));
  114.         }
  115.  
  116. #ifndef _RELEASE
  117.         if (PoseAligner::CVars::GetInstance().m_debugDraw)
  118.         {
  119.                 SAuxGeomRenderFlags flags = gEnv->pRenderer->GetIRenderAuxGeom()->GetRenderFlags();
  120.                 flags.SetDepthTestFlag(e_DepthTestOff);
  121.                 gEnv->pRenderer->GetIRenderAuxGeom()->SetRenderFlags(flags);
  122.  
  123.                 if (pHit)
  124.                 {
  125.                         gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(pHit->pt, 0.05f, ColorB(0xff, 0xff, 0x00, 0xff));
  126.                 }
  127.                 gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(positionPreviousGlobal, 0.05f, ColorB(0xff, 0x00, 0xff, 0xff));
  128.  
  129.                 gEnv->pRenderer->GetIRenderAuxGeom()->DrawLine(
  130.                   rayPosition, ColorB(0xff, 0xff, 0xff, 0xff),
  131.                   rayPosition + Vec3(0.0f, 0.0f, -m_length * 2.0f), ColorB(0xff, 0xff, 0xff, 0xff));
  132.         }
  133. #endif //_RELEASE
  134.  
  135.         return pHit != NULL;
  136. }
  137.  
  138. // TEMP
  139. // This code does the initialization of the PoseAligner. Currently all values
  140. // are hard-coded here, however the plan is to have all of these be read from
  141. // auxiliary parameters in the CHRPARAMS or as part of the entity properties.
  142.  
  143. ILINE bool InitializePoseAlignerBipedHuman(PoseAligner::CPose& pose, IEntity& entity, ICharacterInstance& character)
  144. {
  145.         IDefaultSkeleton& rIDefaultSkeleton = character.GetIDefaultSkeleton();
  146.         int jointIndexRoot = rIDefaultSkeleton.GetJointIDByName("Bip01 Pelvis");
  147.         if (jointIndexRoot < 0)
  148.                 return false;
  149.         int jointIndexFrontLeft = rIDefaultSkeleton.GetJointIDByName("Bip01 planeTargetLeft");
  150.         if (jointIndexFrontLeft < 0)
  151.                 return false;
  152.         int jointIndexFrontRight = rIDefaultSkeleton.GetJointIDByName("Bip01 planeTargetRight");
  153.         if (jointIndexFrontRight < 0)
  154.                 return false;
  155.  
  156.         int jointIndexLeftBlend = rIDefaultSkeleton.GetJointIDByName("Bip01 planeWeightLeft");
  157.         int jointIndexRightBlend = rIDefaultSkeleton.GetJointIDByName("Bip01 planeWeightRight");
  158.  
  159.         if (!pose.Initialize(entity, jointIndexRoot))
  160.                 return false;
  161.  
  162.         pose.SetRootOffsetMinMax(-0.4f, 0.0f);
  163.  
  164.         PoseAligner::SChainDesc chainDesc;
  165.         chainDesc.name = "Left";
  166.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  167.         chainDesc.solver = CCrc32::ComputeLowercase("LftLeg01");
  168.         chainDesc.contactJointIndex = jointIndexFrontLeft;
  169.         chainDesc.targetBlendJointIndex = jointIndexLeftBlend;
  170.         chainDesc.bBlendProcedural = true;
  171.         chainDesc.bTargetSmoothing = true;
  172.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, 0.0f);
  173.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.6f);
  174.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  175.         {
  176.                 pContactRaycast->SetLength(1.0f);
  177.                 chainDesc.pContactReporter = pContactRaycast;
  178.         }
  179.         if (!pose.CreateChain(chainDesc))
  180.                 return false;
  181.  
  182.         chainDesc.name = "Right";
  183.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  184.         chainDesc.solver = CCrc32::ComputeLowercase("RgtLeg01");
  185.         chainDesc.contactJointIndex = jointIndexFrontRight;
  186.         chainDesc.targetBlendJointIndex = jointIndexRightBlend;
  187.         chainDesc.bBlendProcedural = true;
  188.         chainDesc.bTargetSmoothing = true;
  189.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, 0.0f);
  190.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.6f);
  191.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  192.         {
  193.                 pContactRaycast->SetLength(1.0f);
  194.                 chainDesc.pContactReporter = pContactRaycast;
  195.         }
  196.         if (!pose.CreateChain(chainDesc))
  197.                 return false;
  198.  
  199.         return pose.GetChainCount() != 0;
  200. }
  201.  
  202. ILINE bool InitializePoseAlignerBipedAlien(PoseAligner::CPose& pose, IEntity& entity, ICharacterInstance& character)
  203. {
  204.         IDefaultSkeleton& rIDefaultSkeleton = character.GetIDefaultSkeleton();
  205.         // Stalker, Grunt
  206.         int jointIndexRoot = rIDefaultSkeleton.GetJointIDByName("Pelvis");
  207.         if (jointIndexRoot < 0)
  208.                 return false;
  209.         int jointIndexFrontLeft = rIDefaultSkeleton.GetJointIDByName("L Heel");
  210.         if (jointIndexFrontLeft < 0)
  211.                 return false;
  212.         int jointIndexFrontRight = rIDefaultSkeleton.GetJointIDByName("R Heel");
  213.         if (jointIndexFrontRight < 0)
  214.                 return false;
  215.  
  216.         if (!pose.Initialize(entity, jointIndexRoot))
  217.                 return false;
  218.  
  219.         pose.SetRootOffsetMinMax(-0.5f, 0.0f);
  220.  
  221.         PoseAligner::SChainDesc chainDesc;
  222.         chainDesc.name = "Left";
  223.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  224.         chainDesc.solver = CCrc32::ComputeLowercase("LftLeg01");
  225.         chainDesc.contactJointIndex = jointIndexFrontLeft;
  226.         chainDesc.bBlendProcedural = true;
  227.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, -0.1f);
  228.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, +0.5f);
  229.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  230.         {
  231.                 pContactRaycast->SetLength(1.0f);
  232.                 chainDesc.pContactReporter = pContactRaycast;
  233.         }
  234.         if (!pose.CreateChain(chainDesc))
  235.                 return false;
  236.  
  237.         chainDesc.name = "Right";
  238.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  239.         chainDesc.solver = CCrc32::ComputeLowercase("RgtLeg01");
  240.         chainDesc.contactJointIndex = jointIndexFrontRight;
  241.         chainDesc.bBlendProcedural = true;
  242.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, -0.1f);
  243.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, +0.5f);
  244.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  245.         {
  246.                 pContactRaycast->SetLength(1.0f);
  247.                 chainDesc.pContactReporter = pContactRaycast;
  248.         }
  249.         if (!pose.CreateChain(chainDesc))
  250.                 return false;
  251.  
  252.         return pose.GetChainCount() != 0;
  253. }
  254.  
  255. ILINE bool InitializePoseAlignerPinger(PoseAligner::CPose& pose, IEntity& entity, ICharacterInstance& character)
  256. {
  257.         IDefaultSkeleton& rIDefaultSkeleton = character.GetIDefaultSkeleton();
  258.  
  259.         const bool bIsMP = gEnv->bMultiplayer;
  260.  
  261.         IVehicle* pVehicle = gEnv->pGameFramework->GetIVehicleSystem()->GetVehicle(entity.GetId());
  262.         if (bIsMP && !pVehicle)
  263.                 return false;
  264.  
  265. #define CREATEPINGERCONTACTREPORTER                                                                          \
  266.   if (bIsMP)                                                                                                 \
  267.   {                                                                                                          \
  268.     if (_smart_ptr<CContactRaycastPinger> pContactRaycast = new CContactRaycastPinger(*pVehicle, 3.f))       \
  269.     {                                                                                                        \
  270.       chainDesc.pContactReporter = pContactRaycast;                                                          \
  271.     }                                                                                                        \
  272.   }                                                                                                          \
  273.   else                                                                                                       \
  274.   {                                                                                                          \
  275.     if (_smart_ptr<PoseAligner::CContactRaycast> pContactRaycast = new PoseAligner::CContactRaycast(entity)) \
  276.     {                                                                                                        \
  277.       pContactRaycast->SetLength(4.f);                                                                       \
  278.       chainDesc.pContactReporter = pContactRaycast;                                                          \
  279.     }                                                                                                        \
  280.   }
  281.  
  282.         int jointIndexRoot = rIDefaultSkeleton.GetJointIDByName("Pelvis");
  283.         if (jointIndexRoot < 0)
  284.                 return false;
  285.         int jointIndexFrontLeft = rIDefaultSkeleton.GetJointIDByName("planeAlignerLeft");
  286.         if (jointIndexFrontLeft < 0)
  287.                 return false;
  288.         int jointIndexFrontLeftBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightLeft");
  289.         if (jointIndexFrontLeftBlend < 0)
  290.                 return false;
  291.         int jointIndexFrontRight = rIDefaultSkeleton.GetJointIDByName("planeAlignerRight");
  292.         if (jointIndexFrontRight < 0)
  293.                 return false;
  294.         int jointIndexFrontRightBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightRight");
  295.         if (jointIndexFrontRightBlend < 0)
  296.                 return false;
  297.         int jointIndexFrontCenter = rIDefaultSkeleton.GetJointIDByName("planeAlignerCenter");
  298.         if (jointIndexFrontCenter < 0)
  299.                 return false;
  300.         int jointIndexFrontCenterBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightCenter");
  301.         if (jointIndexFrontCenterBlend < 0)
  302.                 return false;
  303.  
  304.         if (!pose.Initialize(entity, jointIndexRoot))
  305.                 return false;
  306.  
  307.         PoseAligner::SChainDesc chainDesc;
  308.         chainDesc.name = "Left";
  309.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  310.         chainDesc.solver = CCrc32::ComputeLowercase("LftLeg01");
  311.         chainDesc.contactJointIndex = jointIndexFrontLeft;
  312.         chainDesc.targetBlendJointIndex = jointIndexFrontLeftBlend;
  313.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, bIsMP ? -1.8f : -1.8f);
  314.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, bIsMP ? +0.75f : +1.f);
  315.         chainDesc.bForceNoIntersection = true;
  316.  
  317.         float rootMax = -chainDesc.offsetMin.z;
  318.         float rootMin = -chainDesc.offsetMax.z;
  319.  
  320.         CREATEPINGERCONTACTREPORTER;
  321.  
  322.         if (!pose.CreateChain(chainDesc))
  323.                 return false;
  324.  
  325.         chainDesc.name = "Right";
  326.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  327.         chainDesc.solver = CCrc32::ComputeLowercase("RgtLeg01");
  328.         chainDesc.contactJointIndex = jointIndexFrontRight;
  329.         chainDesc.targetBlendJointIndex = jointIndexFrontRightBlend;
  330.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, bIsMP ? -1.8f : -1.8f);
  331.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, bIsMP ? +0.75f : +1.f);
  332.         chainDesc.bForceNoIntersection = true;
  333.  
  334.         rootMax = min(rootMax, -chainDesc.offsetMin.z);
  335.         rootMin = max(rootMin, -chainDesc.offsetMax.z);
  336.  
  337.         CREATEPINGERCONTACTREPORTER;
  338.  
  339.         if (!pose.CreateChain(chainDesc))
  340.                 return false;
  341.  
  342.         chainDesc.name = "Center";
  343.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  344.         chainDesc.solver = CCrc32::ComputeLowercase("CtrLeg01");
  345.         chainDesc.contactJointIndex = jointIndexFrontCenter;
  346.         chainDesc.targetBlendJointIndex = jointIndexFrontCenterBlend;
  347.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, bIsMP ? -2.f : -2.f);
  348.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, bIsMP ? +1.3f : +1.6f);
  349.         chainDesc.bForceNoIntersection = true;
  350.  
  351.         rootMax = min(rootMax, -chainDesc.offsetMin.z);
  352.         rootMin = max(rootMin, -chainDesc.offsetMax.z);
  353.  
  354.         CREATEPINGERCONTACTREPORTER;
  355.  
  356.         pose.SetRootOffsetMinMax(rootMin, rootMax);
  357.         pose.SetRootOffsetAverage(!bIsMP);
  358.  
  359.         if (!pose.CreateChain(chainDesc))
  360.                 return false;
  361.  
  362.         return pose.GetChainCount() != 0;
  363. }
  364.  
  365. ILINE bool InitializePoseAlignerScorcher(PoseAligner::CPose& pose, IEntity& entity, ICharacterInstance& character)
  366. {
  367.         IDefaultSkeleton& rIDefaultSkeleton = character.GetIDefaultSkeleton();
  368.         int jointIndexRoot = rIDefaultSkeleton.GetJointIDByName("hips_joint");
  369.         if (jointIndexRoot < 0)
  370.                 return false;
  371.         int jointIndexBackLeft = rIDefaultSkeleton.GetJointIDByName("l_bwd_leg_end_joint");
  372.         if (jointIndexBackLeft < 0)
  373.                 return false;
  374.         int jointIndexBackLeftBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightBackLeft");
  375.         if (jointIndexBackLeftBlend < 0)
  376.                 return false;
  377.         int jointIndexBackRight = rIDefaultSkeleton.GetJointIDByName("r_bwd_leg_end_joint");
  378.         if (jointIndexBackRight < 0)
  379.                 return false;
  380.         int jointIndexBackRightBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightBackRight");
  381.         if (jointIndexBackRightBlend < 0)
  382.                 return false;
  383.         int jointIndexFrontLeft = rIDefaultSkeleton.GetJointIDByName("l_fwd_leg_end_joint");
  384.         if (jointIndexFrontLeft < 0)
  385.                 return false;
  386.         int jointIndexFrontLeftBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightFrontLeft");
  387.         if (jointIndexFrontLeftBlend < 0)
  388.                 return false;
  389.         int jointIndexFrontRight = rIDefaultSkeleton.GetJointIDByName("r_fwd_leg_end_joint");
  390.         if (jointIndexFrontRight < 0)
  391.                 return false;
  392.         int jointIndexFrontRightBlend = rIDefaultSkeleton.GetJointIDByName("planeLockWeightFrontRight");
  393.         if (jointIndexFrontRightBlend < 0)
  394.                 return false;
  395.  
  396.         if (!pose.Initialize(entity, jointIndexRoot))
  397.                 return false;
  398.  
  399.         pose.SetRootOffsetMinMax(-1.0f, 1.0f);
  400.  
  401.         PoseAligner::SChainDesc chainDesc;
  402.         chainDesc.name = "Left";
  403.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  404.         chainDesc.solver = CCrc32::ComputeLowercase("LftLeg01");
  405.         chainDesc.contactJointIndex = jointIndexBackLeft;
  406.         chainDesc.targetBlendJointIndex = jointIndexBackLeftBlend;
  407.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, -1.0f);
  408.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.15f);
  409.         chainDesc.bTargetSmoothing = true;
  410.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  411.         {
  412.                 pContactRaycast->SetLength(1.0f);
  413.                 chainDesc.pContactReporter = pContactRaycast;
  414.         }
  415.         if (!pose.CreateChain(chainDesc))
  416.                 return false;
  417.  
  418.         chainDesc.name = "Right";
  419.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  420.         chainDesc.solver = CCrc32::ComputeLowercase("RgtLeg01");
  421.         chainDesc.contactJointIndex = jointIndexBackRight;
  422.         chainDesc.targetBlendJointIndex = jointIndexBackRightBlend;
  423.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, -1.0f);
  424.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.15f);
  425.         chainDesc.bTargetSmoothing = true;
  426.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  427.         {
  428.                 pContactRaycast->SetLength(1.0f);
  429.                 chainDesc.pContactReporter = pContactRaycast;
  430.         }
  431.         if (!pose.CreateChain(chainDesc))
  432.                 return false;
  433.  
  434.         chainDesc.name = "FrontLeft";
  435.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  436.         chainDesc.solver = CCrc32::ComputeLowercase("LftArm01");
  437.         chainDesc.contactJointIndex = jointIndexFrontLeft;
  438.         chainDesc.targetBlendJointIndex = jointIndexFrontLeftBlend;
  439.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, -1.0f);
  440.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.15f);
  441.         chainDesc.bTargetSmoothing = true;
  442.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  443.         {
  444.                 pContactRaycast->SetLength(1.0f);
  445.                 chainDesc.pContactReporter = pContactRaycast;
  446.         }
  447.         if (!pose.CreateChain(chainDesc))
  448.                 return false;
  449.  
  450.         chainDesc.name = "FrontRight";
  451.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  452.         chainDesc.solver = CCrc32::ComputeLowercase("RgtArm01");
  453.         chainDesc.contactJointIndex = jointIndexFrontRight;
  454.         chainDesc.targetBlendJointIndex = jointIndexFrontRightBlend;
  455.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, -1.0f);
  456.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.15f);
  457.         chainDesc.bTargetSmoothing = true;
  458.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  459.         {
  460.                 pContactRaycast->SetLength(1.0f);
  461.                 chainDesc.pContactReporter = pContactRaycast;
  462.         }
  463.         if (!pose.CreateChain(chainDesc))
  464.                 return false;
  465.  
  466.         return pose.GetChainCount() != 0;
  467. }
  468.  
  469. ILINE bool InitializePoseAlignerDeer(PoseAligner::CPose& pose, IEntity& entity, ICharacterInstance& character)
  470. {
  471.         IDefaultSkeleton& rIDefaultSkeleton = character.GetIDefaultSkeleton();
  472.         int jointIndexRoot = rIDefaultSkeleton.GetJointIDByName("Def_COG_jnt");
  473.         if (jointIndexRoot < 0)
  474.                 return false;
  475.         int jointIndexBackLeft = rIDefaultSkeleton.GetJointIDByName("Def_L_ToeEnd_jnt");
  476.         if (jointIndexBackLeft < 0)
  477.                 return false;
  478.         int jointIndexBackRight = rIDefaultSkeleton.GetJointIDByName("Def_R_ToeEnd_jnt");
  479.         if (jointIndexBackRight < 0)
  480.                 return false;
  481.         int jointIndexFrontLeft = rIDefaultSkeleton.GetJointIDByName("Def_L_WristEnd_jnt");
  482.         if (jointIndexFrontLeft < 0)
  483.                 return false;
  484.         int jointIndexFrontRight = rIDefaultSkeleton.GetJointIDByName("Def_R_WristEnd_jnt");
  485.         if (jointIndexFrontRight < 0)
  486.                 return false;
  487.  
  488.         if (!pose.Initialize(entity, jointIndexRoot))
  489.                 return false;
  490.  
  491.         pose.SetRootOffsetMinMax(-0.1f, 0.04f);
  492.  
  493.         PoseAligner::SChainDesc chainDesc;
  494.         chainDesc.name = "Left";
  495.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  496.         chainDesc.solver = CCrc32::ComputeLowercase("LftLeg01");
  497.         chainDesc.contactJointIndex = jointIndexBackLeft;
  498.         chainDesc.bBlendProcedural = true;
  499.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, -0.05f);
  500.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.4f);
  501.  
  502.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  503.         {
  504.                 pContactRaycast->SetLength(1.0f);
  505.                 chainDesc.pContactReporter = pContactRaycast;
  506.         }
  507.         if (!pose.CreateChain(chainDesc))
  508.                 return false;
  509.  
  510.         chainDesc.name = "Right";
  511.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  512.         chainDesc.solver = CCrc32::ComputeLowercase("RgtLeg01");
  513.         chainDesc.contactJointIndex = jointIndexBackRight;
  514.         chainDesc.bBlendProcedural = true;
  515.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, -0.05f);
  516.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.4f);
  517.  
  518.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  519.         {
  520.                 pContactRaycast->SetLength(1.0f);
  521.                 chainDesc.pContactReporter = pContactRaycast;
  522.         }
  523.         if (!pose.CreateChain(chainDesc))
  524.                 return false;
  525.  
  526.         chainDesc.name = "FrontLeft";
  527.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  528.         chainDesc.solver = CCrc32::ComputeLowercase("LftArm01");
  529.         chainDesc.contactJointIndex = jointIndexFrontLeft;
  530.         chainDesc.bBlendProcedural = true;
  531.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, -0.05f);
  532.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.02f);
  533.  
  534.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  535.         {
  536.                 pContactRaycast->SetLength(1.0f);
  537.                 chainDesc.pContactReporter = pContactRaycast;
  538.         }
  539.         if (!pose.CreateChain(chainDesc))
  540.                 return false;
  541.  
  542.         chainDesc.name = "FrontRight";
  543.         chainDesc.eType = IAnimationPoseAlignerChain::eType_Limb;
  544.         chainDesc.solver = CCrc32::ComputeLowercase("RgtArm01");
  545.         chainDesc.contactJointIndex = jointIndexFrontRight;
  546.         chainDesc.bBlendProcedural = true;
  547.         chainDesc.offsetMin = Vec3(0.0f, 0.0f, -0.05f);
  548.         chainDesc.offsetMax = Vec3(0.0f, 0.0f, 0.02f);
  549.  
  550.         if (PoseAligner::CContactRaycastPtr pContactRaycast = new PoseAligner::CContactRaycast(entity))
  551.         {
  552.                 pContactRaycast->SetLength(1.0f);
  553.                 chainDesc.pContactReporter = pContactRaycast;
  554.         }
  555.         if (!pose.CreateChain(chainDesc))
  556.                 return false;
  557.  
  558.         return pose.GetChainCount() != 0;
  559. }
  560.  
  561. ILINE bool InitializePoseAligner(PoseAligner::CPose& pose, IEntity& entity, ICharacterInstance& character)
  562. {
  563.         // TEMP: Make sure we do string comparison only once!
  564.         if (pose.m_bInitialized)
  565.                 return pose.m_pEntity != NULL;
  566.  
  567.         if (!InitializePoseAlignerBipedHuman(pose, entity, character))
  568.                 if (!InitializePoseAlignerBipedAlien(pose, entity, character))
  569.                         if (!InitializePoseAlignerPinger(pose, entity, character))
  570.                                 if (!InitializePoseAlignerScorcher(pose, entity, character))
  571.                                         if (!InitializePoseAlignerDeer(pose, entity, character))
  572.                                         {
  573.                                                 pose.m_bInitialized = true;
  574.                                                 return false;
  575.                                         }
  576.  
  577.         pose.m_bInitialized = true;
  578.         return pose.GetChainCount() != 0;
  579. }
  580.  
  581. class CPoseAlignerC3 :
  582.         PoseAligner::CPose
  583. {
  584.         CRYGENERATE_CLASS(CPoseAlignerC3, "AnimationPoseAlignerC3", 0xf5381a4c1374ff00, 0x8de19ba730cf572b)
  585.  
  586.         virtual ~CPoseAlignerC3() {}
  587.  
  588. public:
  589.         virtual bool Initialize(IEntity& entity) override;
  590. };
  591.  
  592. bool CPoseAlignerC3::Initialize(IEntity& entity)
  593. {
  594.         ICharacterInstance* pCharacter = entity.GetCharacter(0);
  595.         if (!pCharacter)
  596.                 return false;
  597.  
  598.         return InitializePoseAligner(*this, entity, *pCharacter);
  599. }
  600.  
  601. CRYREGISTER_CLASS(CPoseAlignerC3)
  602.  
downloadPoseAlignerC3.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