BVB Source Codes

CRYENGINE Show CharacterRenderNode.cpp Source code

Return Download CRYENGINE: download CharacterRenderNode.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. #include "StdAfx.h"
  2. #include "CharacterRenderNode.h"
  3.  
  4. #include "ObjMan.h"
  5. #include "3dEngine.h"
  6. #include <CryAnimation/ICryAnimation.h>
  7.  
  8. //////////////////////////////////////////////////////////////////////////
  9. static bool IsMatrixValid(const Matrix34& mat)
  10. {
  11.         Vec3 vScaleTest = mat.TransformVector(Vec3(0, 0, 1));
  12.         float fDist = mat.GetTranslation().GetDistance(Vec3(0, 0, 0));
  13.  
  14.         if (vScaleTest.GetLength() > 1000.f || vScaleTest.GetLength() < 0.01f || fDist > 256000 ||
  15.             !_finite(vScaleTest.x) || !_finite(vScaleTest.y) || !_finite(vScaleTest.z))
  16.                 return false;
  17.  
  18.         return true;
  19. }
  20.  
  21. //////////////////////////////////////////////////////////////////////////
  22. CCharacterRenderNode::CCharacterRenderNode()
  23.         : m_pCharacterInstance(nullptr)
  24.         , m_pPhysicsEntity(nullptr)
  25. {
  26.         m_boundsWorld = AABB(0.0f);
  27.         m_boundsLocal = AABB(0.0f);
  28.         m_matrix.SetIdentity();
  29.         m_renderOffset.SetIdentity();
  30.  
  31.         GetInstCount(GetRenderNodeType())++;
  32. }
  33.  
  34. //////////////////////////////////////////////////////////////////////////
  35. CCharacterRenderNode::~CCharacterRenderNode()
  36. {
  37.         Dephysicalize();
  38.         Get3DEngine()->FreeRenderNodeState(this);
  39.  
  40.         m_pCharacterInstance = nullptr;
  41.         m_pPhysicsEntity = nullptr;
  42.  
  43.         if (m_pCameraSpacePos)
  44.         {
  45.                 delete m_pCameraSpacePos;
  46.                 m_pCameraSpacePos = nullptr;
  47.         }
  48.  
  49.         Cry3DEngineBase::GetInstCount(GetRenderNodeType())--;
  50. }
  51.  
  52. //////////////////////////////////////////////////////////////////////////
  53. const char* CCharacterRenderNode::GetName() const
  54. {
  55.         if (m_pCharacterInstance)
  56.                 return m_pCharacterInstance->GetFilePath();
  57.         return "Unknown";
  58. }
  59.  
  60. //////////////////////////////////////////////////////////////////////////
  61. void CCharacterRenderNode::Render(const SRendParams& inputRendParams, const SRenderingPassInfo& passInfo)
  62. {
  63.         FUNCTION_PROFILER_3DENGINE;
  64.  
  65.         if (!m_pCharacterInstance || m_dwRndFlags & ERF_HIDDEN)
  66.                 return;
  67.  
  68.         // some parameters will be modified
  69.         SRendParams rParms(inputRendParams);
  70.  
  71.         rParms.nMaterialLayers = m_nMaterialLayers;
  72.         rParms.pMatrix = &m_matrix;
  73.         rParms.pMaterial = m_pMaterial;
  74.  
  75.         rParms.dwFObjFlags |= FOB_TRANS_MASK | FOB_DYNAMIC_OBJECT;
  76.         rParms.dwFObjFlags |= (GetRndFlags() & ERF_FOB_RENDER_AFTER_POSTPROCESSING) ? FOB_RENDER_AFTER_POSTPROCESSING : 0;
  77.  
  78.         if (GetRndFlags() & ERF_FOB_NEAREST)
  79.         {
  80.                 if (passInfo.IsRecursivePass()) // Nearest objects are not rendered in the recursive passes.
  81.                         return;
  82.  
  83.                 rParms.dwFObjFlags |= FOB_NEAREST;
  84.  
  85.                 // Nearest objects recalculate instance matrix every frame
  86.                 //m_bPermanentRenderObjectMatrixValid = false;
  87.                 QuatTS offset;
  88.                 offset.SetIdentity();
  89.                 Matrix34 nearestMatrix = m_matrix;
  90.                 CalcNearestTransform(nearestMatrix, passInfo);
  91.                 rParms.pMatrix = &nearestMatrix;
  92.  
  93.                 m_pCharacterInstance->Render(rParms, offset, passInfo);
  94.         }
  95.         else
  96.         {
  97.                 m_pCharacterInstance->Render(rParms, m_renderOffset, passInfo);
  98.         }
  99. }
  100.  
  101. void CCharacterRenderNode::SetMatrix(const Matrix34& transform)
  102. {
  103.         if (!m_pCharacterInstance)
  104.                 return;
  105.  
  106.         if (!IsMatrixValid(transform))
  107.         {
  108.                 Warning("Error: IRenderNode::SetMatrix: Invalid matrix ignored");
  109.                 return;
  110.         }
  111.  
  112.         bool bMoved = !Matrix34::IsEquivalent(m_matrix, transform, 0.00001f);
  113.         m_matrix = transform;
  114.  
  115.         //if (bMoved)
  116.         {
  117.                 m_boundsLocal = m_pCharacterInstance->GetAABB();
  118.                 m_boundsWorld.SetTransformedAABB(m_matrix, m_boundsLocal);
  119.  
  120.                 Get3DEngine()->UnRegisterEntityAsJob(this);
  121.                 Get3DEngine()->RegisterEntity(this);
  122.  
  123.                 m_pCharacterInstance->SetAttachmentLocation_DEPRECATED(QuatTS(transform));
  124.         }
  125. }
  126.  
  127. //////////////////////////////////////////////////////////////////////////
  128. void CCharacterRenderNode::Physicalize(bool bInstant)
  129. {
  130.         // Not implemented
  131.         assert(0);
  132. }
  133.  
  134. //////////////////////////////////////////////////////////////////////////
  135. float CCharacterRenderNode::GetMaxViewDist()
  136. {
  137.         if (GetRndFlags() & ERF_FORCE_POST_3D_RENDER)
  138.         {
  139.                 // Always want to render models in post 3d render (menus), whatever distance they are
  140.                 return FLT_MAX;
  141.         }
  142.  
  143.         if (GetRndFlags() & ERF_CUSTOM_VIEW_DIST_RATIO)
  144.         {
  145.                 float s = max(max((m_boundsWorld.max.x - m_boundsWorld.min.x), (m_boundsWorld.max.y - m_boundsWorld.min.y)), (m_boundsWorld.max.z - m_boundsWorld.min.z));
  146.                 return max(GetCVars()->e_ViewDistMin, s * GetCVars()->e_ViewDistRatioCustom * GetViewDistRatioNormilized());
  147.         }
  148.  
  149.         if (GetMinSpecFromRenderNodeFlags(m_dwRndFlags) == CONFIG_DETAIL_SPEC)
  150.                 return max(GetCVars()->e_ViewDistMin, min(GetFloatCVar(e_ViewDistCompMaxSize), m_boundsLocal.GetRadius()) * GetCVars()->e_ViewDistRatioDetail * GetViewDistRatioNormilized());
  151.  
  152.         return max(GetCVars()->e_ViewDistMin, min(GetFloatCVar(e_ViewDistCompMaxSize), m_boundsLocal.GetRadius()) * GetCVars()->e_ViewDistRatio * GetViewDistRatioNormilized());
  153. }
  154.  
  155. //////////////////////////////////////////////////////////////////////////
  156. CLodValue CCharacterRenderNode::ComputeLod(int wantedLod, const SRenderingPassInfo& passInfo)
  157. {
  158.         if (m_pCharacterInstance)
  159.         {
  160.                 return m_pCharacterInstance->ComputeLod(wantedLod, passInfo);
  161.         }
  162.  
  163.         return CLodValue(wantedLod);
  164. }
  165.  
  166. //////////////////////////////////////////////////////////////////////////
  167. bool CCharacterRenderNode::GetLodDistances(const SFrameLodInfo& frameLodInfo, float* distances) const
  168. {
  169.         const float fEntityLodRatio = GetLodRatioNormalized();
  170.         if (fEntityLodRatio > 0.0f)
  171.         {
  172.                 float fLodDistance = FLT_MAX;
  173.                 if (m_pCharacterInstance)
  174.                 {
  175.                         fLodDistance = sqrt(m_pCharacterInstance->ComputeGeometricMean().fGeometricMean);
  176.                 }
  177.                 const float fDistMultiplier = 1.0f / (fEntityLodRatio * frameLodInfo.fTargetSize);
  178.  
  179.                 for (uint i = 0; i < SMeshLodInfo::s_nMaxLodCount; ++i)
  180.                 {
  181.                         distances[i] = fLodDistance * (i + 1) * fDistMultiplier;
  182.                 }
  183.         }
  184.         else
  185.         {
  186.                 for (uint i = 0; i < SMeshLodInfo::s_nMaxLodCount; ++i)
  187.                 {
  188.                         distances[i] = FLT_MAX;
  189.                 }
  190.         }
  191.  
  192.         return true;
  193. }
  194.  
  195. //////////////////////////////////////////////////////////////////////////
  196. void CCharacterRenderNode::OnRenderNodeBecomeVisible(const SRenderingPassInfo& passInfo)
  197. {
  198.         if (!passInfo.IsCachedShadowPass())
  199.         {
  200.                 if (m_pCharacterInstance)
  201.                 {
  202.                         m_pCharacterInstance->SetFlags(m_pCharacterInstance->GetFlags() | CS_FLAG_RENDER_NODE_VISIBLE);
  203.                 }
  204.  
  205.                 if (GetOwnerEntity() && (GetRndFlags() & ERF_ENABLE_ENTITY_RENDER_CALLBACK))
  206.                 {
  207.                         // When render node becomes visible notify our owner render node that it is now visible.
  208.                         GetOwnerEntity()->OnRenderNodeVisibilityChange(true);
  209.                 }
  210.         }
  211. }
  212.  
  213. //////////////////////////////////////////////////////////////////////////
  214. void CCharacterRenderNode::OnRenderNodeBecomeInvisible()
  215. {
  216.         if (m_pCharacterInstance)
  217.         {
  218.                 m_pCharacterInstance->SetFlags(m_pCharacterInstance->GetFlags() & ~CS_FLAG_RENDER_NODE_VISIBLE);
  219.                 m_pCharacterInstance->KillAllSkeletonEffects();
  220.         }
  221.         if (GetOwnerEntity() && (GetRndFlags() & ERF_ENABLE_ENTITY_RENDER_CALLBACK))
  222.         {
  223.                 // When render node becomes invisible notify our owner render node that it is now invisible.
  224.                 GetOwnerEntity()->OnRenderNodeVisibilityChange(false);
  225.         }
  226. }
  227.  
  228. //////////////////////////////////////////////////////////////////////////
  229. void CCharacterRenderNode::SetCameraSpacePos(Vec3* pCameraSpacePos)
  230. {
  231.         if (pCameraSpacePos)
  232.         {
  233.                 if (!m_pCameraSpacePos)
  234.                         m_pCameraSpacePos = new Vec3;
  235.                 *m_pCameraSpacePos = *pCameraSpacePos;
  236.         }
  237.         else
  238.         {
  239.                 delete m_pCameraSpacePos;
  240.                 m_pCameraSpacePos = nullptr;
  241.         }
  242. }
  243. //////////////////////////////////////////////////////////////////////////
  244. void CCharacterRenderNode::SetCharacter(ICharacterInstance* pCharacter)
  245. {
  246.         if (m_pCharacterInstance != pCharacter)
  247.         {
  248.                 m_pCharacterInstance = pCharacter;
  249.                 InvalidatePermanentRenderObject();
  250.         }
  251. }
  252.  
  253. void CCharacterRenderNode::SetCharacterRenderOffset(const QuatTS& renderOffset)
  254. {
  255.         m_renderOffset = renderOffset;
  256. }
  257.  
  258. //////////////////////////////////////////////////////////////////////////
  259. void CCharacterRenderNode::OffsetPosition(const Vec3& delta)
  260. {
  261.         if (m_pTempData)
  262.                 m_pTempData->OffsetPosition(delta);
  263.         m_matrix.SetTranslation(m_matrix.GetTranslation() + delta);
  264.         m_boundsWorld.Move(delta);
  265. }
  266.  
  267. //////////////////////////////////////////////////////////////////////////
  268. void CCharacterRenderNode::CalcNearestTransform(Matrix34& transformMatrix, const SRenderingPassInfo& passInfo)
  269. {
  270.         // Camera space
  271.         if (m_pCameraSpacePos)
  272.         {
  273.                 // Use camera space relative position
  274.                 const Matrix33 cameraRotation = Matrix33(passInfo.GetCamera().GetViewMatrix());
  275.                 transformMatrix.SetTranslation(*m_pCameraSpacePos * cameraRotation);
  276.         }
  277.         else
  278.         {
  279.                 // We don't have camera space relative position, so calculate it out from world space
  280.                 // (This will not have the precision advantages of camera space rendering)
  281.                 transformMatrix.AddTranslation(-passInfo.GetCamera().GetPosition());
  282.         }
  283. }
  284.  
  285. namespace
  286. {
  287. void CollectRenderMeshMaterials(IMaterial* pMaterial, IRenderMesh* pRenderMesh, std::vector<std::pair<IMaterial*, float>>& collectedMaterials)
  288. {
  289.         if (!pMaterial || !pRenderMesh)
  290.         {
  291.                 return;
  292.         }
  293.  
  294.         stl::push_back_unique(collectedMaterials, std::pair<IMaterial*, float>(pMaterial, 1.0f));
  295.  
  296.         TRenderChunkArray& chunks = pRenderMesh->GetChunks();
  297.         const uint subMtlCount = pMaterial->GetSubMtlCount();
  298.  
  299.         const uint numChunks = chunks.size();
  300.         for (uint i = 0; i < numChunks; ++i)
  301.         {
  302.                 CRenderChunk& chunk = chunks[i];
  303.                 if (chunk.nNumIndices > 0 && chunk.nNumVerts > 0 && chunk.m_nMatID < subMtlCount)
  304.                 {
  305.                         stl::push_back_unique(collectedMaterials, std::pair<IMaterial*, float>(pMaterial->GetSubMtl(chunk.m_nMatID), chunk.m_texelAreaDensity));
  306.                 }
  307.         }
  308. }
  309. }
  310.  
  311. void CCharacterRenderNode::PrecacheCharacterCollect(const float fImportance, ICharacterInstance* pCharacter, IMaterial* pSlotMat, const Matrix34& matParent,
  312.                                                     const float fEntDistance, const float fScale, int nMaxDepth, bool bFullUpdate, bool bDrawNear, int nLod,
  313.                                                     const int nRoundId, std::vector<std::pair<IMaterial*, float>>& collectedMaterials)
  314. {
  315.         if (!nMaxDepth || !pCharacter)
  316.                 return;
  317.         nMaxDepth--;
  318.  
  319.         static ICVar* pSkipVertexAnimationLOD = gEnv->pConsole->GetCVar("ca_vaSkipVertexAnimationLOD");
  320.         const bool bSkipVertexAnimationLOD = pSkipVertexAnimationLOD != NULL ? pSkipVertexAnimationLOD->GetIVal() != 0 : false;
  321.  
  322.         int minLod = 0;
  323.         if (bSkipVertexAnimationLOD && pCharacter->HasVertexAnimation())
  324.         {
  325.                 minLod = max(minLod, 1);
  326.                 nLod = 1;
  327.         }
  328.  
  329.         SFrameLodInfo lodParam = gEnv->p3DEngine->GetFrameLodInfo();
  330.  
  331.         IAttachmentManager* pAttMan = pCharacter->GetIAttachmentManager();
  332.         ICharacterInstance* pCharInstance = pAttMan->GetSkelInstance();
  333.         if (pCharInstance && pCharInstance != pCharacter)
  334.         {
  335.                 PrecacheCharacterCollect(fImportance, pCharInstance, pSlotMat, matParent, fEntDistance, fScale, nMaxDepth, bFullUpdate, bDrawNear, nLod, nRoundId, collectedMaterials);
  336.         }
  337.  
  338.         int nCount = pAttMan->GetAttachmentCount();
  339.         for (int i = 0; i < nCount; i++)
  340.         {
  341.                 if (IAttachment* pAtt = pAttMan->GetInterfaceByIndex(i))
  342.                 {
  343.                         IAttachmentObject* pIAttachmentObject = pAtt->GetIAttachmentObject();
  344.                         if (pIAttachmentObject)
  345.                         {
  346.                                 IAttachmentSkin* pIAttachmentSkin = pIAttachmentObject->GetIAttachmentSkin();
  347.                                 if (pIAttachmentSkin)
  348.                                 {
  349.                                         ISkin* pISkin = pIAttachmentSkin->GetISkin();
  350.  
  351.                                         const int maxLod = (int)pISkin->GetNumLODs() - 1;
  352.  
  353.                                         const int minPrecacheLod = clamp_tpl(nLod - 1, minLod, maxLod);
  354.                                         const int maxPrecacheLod = clamp_tpl(nLod + 1, minLod, maxLod);
  355.  
  356.                                         IMaterial* pAttMatOverride = (IMaterial*)pIAttachmentObject->GetReplacementMaterial();
  357.                                         IMaterial* pAttMat = pAttMatOverride ? pAttMatOverride : (IMaterial*)pIAttachmentObject->GetBaseMaterial();
  358.  
  359.                                         for (int currentLod = minPrecacheLod; currentLod <= maxPrecacheLod; ++currentLod)
  360.                                         {
  361.                                                 pISkin->PrecacheMesh(bFullUpdate, nRoundId, currentLod);
  362.  
  363.                                                 IRenderMesh* pRenderMesh = pISkin->GetIRenderMesh(currentLod); //get the baseLOD
  364.                                                 IMaterial* pCharObjMat = pISkin->GetIMaterial(currentLod);
  365.  
  366.                                                 CollectRenderMeshMaterials(pAttMat, pRenderMesh, collectedMaterials);
  367.                                                 if (pCharObjMat != pAttMat)
  368.                                                 {
  369.                                                         CollectRenderMeshMaterials(pCharObjMat, pRenderMesh, collectedMaterials);
  370.                                                 }
  371.                                         }
  372.  
  373.                                         continue;
  374.                                 }
  375.  
  376.                                 CStatObj* pStatObj = (CStatObj*)pIAttachmentObject->GetIStatObj();
  377.                                 if (pStatObj)
  378.                                 {
  379.                                         if (!pStatObj || pStatObj->GetFlags() & STATIC_OBJECT_HIDDEN)
  380.                                                 continue;
  381.  
  382.                                         const int minLod = pStatObj->GetMinUsableLod();
  383.                                         const int maxLod = (int)pStatObj->m_nMaxUsableLod;
  384.                                         const int minPrecacheLod = clamp_tpl(nLod - 1, minLod, maxLod);
  385.                                         const int maxPrecacheLod = clamp_tpl(nLod + 1, minLod, maxLod);
  386.  
  387.                                         const QuatT& q = pAtt->GetAttAbsoluteDefault();
  388.                                         Matrix34A tm34 = matParent * Matrix34(q);
  389.  
  390.                                         for (int currentLod = minPrecacheLod; currentLod <= maxPrecacheLod; ++currentLod)
  391.                                         {
  392.                                                 pStatObj->UpdateStreamableComponents(fImportance, tm34, bFullUpdate, currentLod);
  393.  
  394.                                                 pStatObj = (CStatObj*)pStatObj->GetLodObject(currentLod, true);
  395.                                                 IMaterial* pAttMatOverride = (IMaterial*)pIAttachmentObject->GetReplacementMaterial();
  396.                                                 IMaterial* pAttMat = pAttMatOverride ? pAttMatOverride : (IMaterial*)pIAttachmentObject->GetBaseMaterial();
  397.                                                 IMaterial* pMaterial = pAttMat ? pAttMat : pStatObj->GetMaterial();
  398.  
  399.                                                 CollectRenderMeshMaterials(pMaterial, pStatObj->GetRenderMesh(), collectedMaterials);
  400.                                         }
  401.  
  402.                                         continue;
  403.                                 }
  404.  
  405.                                 ICharacterInstance* pSkelInstance = pIAttachmentObject->GetICharacterInstance();
  406.                                 if (pSkelInstance)
  407.                                 {
  408.                                         IMaterial* pAttMatOverride = (IMaterial*)pIAttachmentObject->GetReplacementMaterial();
  409.                                         IMaterial* pAttMat = pAttMatOverride ? pAttMatOverride : (IMaterial*)pIAttachmentObject->GetBaseMaterial();
  410.  
  411.                                         PrecacheCharacterCollect(fImportance, pSkelInstance, pAttMat, matParent, fEntDistance, fScale, nMaxDepth, bFullUpdate, bDrawNear, nLod, nRoundId, collectedMaterials);
  412.                                         continue;
  413.                                 }
  414.                         }
  415.                 }
  416.         }
  417.  
  418.         IMaterial* pCharObjMat = pCharacter->GetIMaterial();
  419.  
  420.         IDefaultSkeleton& rIDefaultSkeleton = pCharacter->GetIDefaultSkeleton();
  421.         rIDefaultSkeleton.PrecacheMesh(bFullUpdate, nRoundId, nLod);
  422.  
  423.         IRenderMesh* pIRenderMesh = rIDefaultSkeleton.GetIRenderMesh(); //get the baseLOD
  424.         CollectRenderMeshMaterials(pSlotMat, pIRenderMesh, collectedMaterials);
  425.         if (pSlotMat != pCharObjMat)
  426.         {
  427.                 CollectRenderMeshMaterials(pCharObjMat, pIRenderMesh, collectedMaterials);
  428.         }
  429.  
  430.         if (pCharInstance->GetObjectType() == CGA)
  431.         {
  432.                 // joints
  433.                 if (ISkeletonPose* pSkeletonPose = pCharacter->GetISkeletonPose())
  434.                 {
  435.                         uint32 numJoints = pCharacter->GetIDefaultSkeleton().GetJointCount();
  436.  
  437.                         // check StatObj attachments
  438.                         for (uint32 i = 0; i < numJoints; i++)
  439.                         {
  440.                                 CStatObj* pStatObj = (CStatObj*)pSkeletonPose->GetStatObjOnJoint(i);
  441.                                 if (!pStatObj || pStatObj->GetFlags() & STATIC_OBJECT_HIDDEN)
  442.                                         continue;
  443.  
  444.                                 const int minLod = pStatObj->GetMinUsableLod();
  445.                                 const int maxLod = (int)pStatObj->m_nMaxUsableLod;
  446.                                 const int minPrecacheLod = clamp_tpl(nLod - 1, minLod, maxLod);
  447.                                 const int maxPrecacheLod = clamp_tpl(nLod + 1, minLod, maxLod);
  448.  
  449.                                 for (int currentLod = minPrecacheLod; currentLod <= maxPrecacheLod; ++currentLod)
  450.                                 {
  451.                                         Matrix34A tm34 = matParent * Matrix34(pSkeletonPose->GetAbsJointByID(i));
  452.                                         pStatObj->UpdateStreamableComponents(fImportance, tm34, bFullUpdate, currentLod);
  453.  
  454.                                         IMaterial* pStatObjMat = pStatObj->GetMaterial();
  455.                                         IStatObj* pStatObjLod = pStatObj->GetLodObject(currentLod, true);
  456.                                         GetObjManager()->PrecacheStatObjMaterial(pStatObjMat ? pStatObjMat : pSlotMat, fEntDistance / fScale, pStatObjLod, bFullUpdate, bDrawNear);
  457.                                 }
  458.                         }
  459.                 }
  460.         }
  461. }
  462.  
  463. void CCharacterRenderNode::PrecacheCharacter(const float fImportance, ICharacterInstance* pCharacter, IMaterial* pSlotMat, const Matrix34& matParent,
  464.                                              const float fEntDistance, const float fScale, int nMaxDepth, bool bFullUpdate, bool bDrawNear, int nLod)
  465. {
  466.         const int nRoundId = bFullUpdate
  467.                              ? GetObjManager()->m_nUpdateStreamingPrioriryRoundIdFast
  468.                              : GetObjManager()->m_nUpdateStreamingPrioriryRoundId;
  469.  
  470.         static std::vector<std::pair<IMaterial*, float>> s_collectedMaterials;
  471.         s_collectedMaterials.clear();
  472.         PrecacheCharacterCollect(fImportance, pCharacter, pSlotMat, matParent, fEntDistance, fScale, nMaxDepth, bFullUpdate, bDrawNear, nLod, nRoundId, s_collectedMaterials);
  473.  
  474.         const uint numMaterials = s_collectedMaterials.size();
  475.         if (numMaterials > 0)
  476.         {
  477.                 int nFlags = 0;
  478.                 float scaledEntDistance = fEntDistance / fScale;
  479.  
  480.                 if (bDrawNear)
  481.                 {
  482.                         nFlags |= FPR_HIGHPRIORITY;
  483.                 }
  484.                 else
  485.                 {
  486.                         scaledEntDistance = max(GetFloatCVar(e_StreamPredictionMinReportDistance), scaledEntDistance);
  487.                 }
  488.  
  489.                 const float fMipFactor = scaledEntDistance * scaledEntDistance;
  490.  
  491.                 for (uint i = 0; i < numMaterials; ++i)
  492.                 {
  493.                         const std::pair<IMaterial*, float>& collectedMaterial = s_collectedMaterials[i];
  494.                         CMatInfo* pMaterial = ((CMatInfo*)collectedMaterial.first);
  495.                         const float density = GetCVars()->e_StreamPredictionTexelDensity ? collectedMaterial.second : 1.0f;
  496.                         pMaterial->PrecacheTextures(fMipFactor * density, nFlags, bFullUpdate);
  497.                 }
  498.         }
  499. }
  500.  
  501. //////////////////////////////////////////////////////////////////////////
  502. void CCharacterRenderNode::UpdateStreamingPriority(const SUpdateStreamingPriorityContext& streamingContext)
  503. {
  504.         if (!m_pCharacterInstance)
  505.                 return;
  506.         if (!streamingContext.pPassInfo)
  507.                 return;
  508.  
  509.         bool bDrawNear = 0 != (GetRndFlags() & ERF_FOB_NEAREST);
  510.         if ((m_pCharacterInstance->GetFlags() & CS_FLAG_STREAM_HIGH_PRIORITY) != 0)
  511.         {
  512.                 bDrawNear = true;
  513.         }
  514.  
  515.         FRAME_PROFILER("UpdateObjectsStreamingPriority_PrecacheCharacter", GetSystem(), PROFILE_3DENGINE);
  516.  
  517.         const SRenderingPassInfo& passInfo = *streamingContext.pPassInfo;
  518.         // If the object is in camera space, don't use the prediction position.
  519.         const float fApproximatePrecacheDistance = (bDrawNear)
  520.                                                    ? sqrt_tpl(Distance::Point_AABBSq(passInfo.GetCamera().GetPosition(), m_boundsWorld))
  521.                                                    : streamingContext.distance;
  522.         float fObjScale = 1.0f;
  523.         PrecacheCharacter(streamingContext.importance, m_pCharacterInstance, m_pMaterial, m_matrix, fApproximatePrecacheDistance, fObjScale, bDrawNear ? 4 : 2, streamingContext.bFullUpdate, bDrawNear, streamingContext.lod);
  524. }
  525.  
downloadCharacterRenderNode.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