BVB Source Codes

CRYENGINE Show VisibleRenderNodeManager.cpp Source code

Return Download CRYENGINE: download VisibleRenderNodeManager.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 "3dEngine.h"
  5.  
  6. //////////////////////////////////////////////////////////////////////////
  7. void SRenderNodeTempData::Free()
  8. {
  9.         FreeRenderObjects();
  10.  
  11.         if (userData.m_pFoliage)
  12.         {
  13.                 userData.m_pFoliage->Release();
  14.                 userData.m_pFoliage = NULL;
  15.         }
  16.  
  17.         userData.pOwnerNode = nullptr;
  18.         userData.bToDelete = true;
  19. }
  20.  
  21. //////////////////////////////////////////////////////////////////////////
  22. void SRenderNodeTempData::FreeRenderObjects()
  23. {
  24.         // Release permanent CRenderObject(s)
  25.         for (int lod = 0; lod < MAX_STATOBJ_LODS_NUM; ++lod)
  26.         {
  27.                 if (userData.arrPermanentRenderObjects[lod])
  28.                 {
  29.                         gEnv->pRenderer->EF_FreeObject(userData.arrPermanentRenderObjects[lod]);
  30.                         userData.arrPermanentRenderObjects[lod] = 0;
  31.                 }
  32.         }
  33. }
  34.  
  35. void SRenderNodeTempData::InvalidateRenderObjectsInstanceData()
  36. {
  37.         // Release permanent CRenderObject(s)
  38.         for (int lod = 0; lod < MAX_STATOBJ_LODS_NUM; ++lod)
  39.         {
  40.                 if (userData.arrPermanentRenderObjects[lod])
  41.                 {
  42.                         userData.arrPermanentRenderObjects[lod]->m_bInstanceDataDirty = true;
  43.                 }
  44.         }
  45. }
  46.  
  47. //////////////////////////////////////////////////////////////////////////
  48. CVisibleRenderNodesManager::CVisibleRenderNodesManager()
  49.         : m_lastStartUpdateNode(0)
  50.         , m_currentNodesToDelete(0)
  51.         , m_lastUpdateFrame(0)
  52. {
  53.  
  54. }
  55.  
  56. CVisibleRenderNodesManager::~CVisibleRenderNodesManager()
  57. {
  58.         ClearAll();
  59. }
  60.  
  61. SRenderNodeTempData* CVisibleRenderNodesManager::AllocateTempData(int lastSeenFrame)
  62. {
  63.         SRenderNodeTempData* pData = m_pool.New();
  64.  
  65.         {
  66.                 CryAutoCriticalSectionNoRecursive lock(m_accessLock);
  67.                 m_visibleNodes.push_back(pData);
  68.         }
  69.         return pData;
  70. }
  71.  
  72. //////////////////////////////////////////////////////////////////////////
  73. bool CVisibleRenderNodesManager::SetLastSeenFrame(SRenderNodeTempData* pTempData, const SRenderingPassInfo& passInfo)
  74. {
  75.         int frame = passInfo.GetFrameID();
  76.         bool bCanRenderThisFrame = true;
  77.  
  78.         if (passInfo.IsShadowPass())
  79.         {
  80.                 pTempData->userData.lastSeenShadowFrame = frame;
  81.         }
  82.         else
  83.         {
  84.                 int recursion = passInfo.IsRecursivePass() ? 1 : 0;
  85.                 // Only return true if last seen frame is different form the current
  86.                 bCanRenderThisFrame = pTempData->userData.lastSeenFrame[recursion] != frame;
  87.                 pTempData->userData.lastSeenFrame[recursion] = frame;
  88.         }
  89.         return bCanRenderThisFrame;
  90. }
  91.  
  92. //////////////////////////////////////////////////////////////////////////
  93. void CVisibleRenderNodesManager::UpdateVisibleNodes(int currentFrame, int maxNodesToCheck)
  94. {
  95.         if (m_lastUpdateFrame == currentFrame) // Fast exit if happens on the same frame
  96.                 return;
  97.         m_lastUpdateFrame = currentFrame;
  98.  
  99.         FUNCTION_PROFILER_3DENGINE;
  100.  
  101.         assert(gEnv->mMainThreadId == CryGetCurrentThreadId());
  102.  
  103.         m_currentNodesToDelete++;
  104.         m_currentNodesToDelete = (m_currentNodesToDelete) % MAX_DELETE_BUFFERS; // Always cycle delete buffers.
  105.         for (auto* node : m_toDeleteNodes[m_currentNodesToDelete])
  106.         {
  107.                 m_pool.Delete(node);
  108.         }
  109.         m_toDeleteNodes[m_currentNodesToDelete].clear();
  110.  
  111.         {
  112.                 // LOCK START
  113.                 CryAutoCriticalSectionNoRecursive lock(m_accessLock);
  114.  
  115.                 int numNodes = m_visibleNodes.size();
  116.                 int start = m_lastStartUpdateNode;
  117.                 if (start >= numNodes)
  118.                 {
  119.                         start = 0;
  120.                         m_lastStartUpdateNode = 0;
  121.                 }
  122.                 int end = start + maxNodesToCheck;
  123.                 if (end > numNodes)
  124.                         end = numNodes;
  125.  
  126.                 int lastNode = numNodes - 1;
  127.  
  128.                 int maxFrames = (uint32)C3DEngine::GetCVars()->e_RNTmpDataPoolMaxFrames;
  129.                 int numItemsToDelete = 0;
  130.                 for (int i = start; i < end && i <= lastNode; ++i)
  131.                 {
  132.                         SRenderNodeTempData* RESTRICT_POINTER pTempData = m_visibleNodes[i];
  133.  
  134.                         int lastSeenFrame = std::max(pTempData->userData.lastSeenFrame[0], pTempData->userData.lastSeenFrame[1]);
  135.                         lastSeenFrame = std::max(lastSeenFrame, pTempData->userData.lastSeenShadowFrame);
  136.                         int diff = std::abs(currentFrame - lastSeenFrame);
  137.                         if (diff > maxFrames || pTempData->userData.bToDelete)
  138.                         {
  139.                                 if (pTempData->userData.pOwnerNode)
  140.                                 {
  141.                                         pTempData->userData.pOwnerNode->OnRenderNodeBecomeInvisible();
  142.                                         pTempData->userData.pOwnerNode->m_pTempData = nullptr; // clear reference to use from owning render node.
  143.                                 }
  144.                                 m_visibleNodes[i]->Free();
  145.                                 m_toDeleteNodes[m_currentNodesToDelete].push_back(m_visibleNodes[i]);
  146.                                 if (i < lastNode)
  147.                                 {
  148.                                         // move item from the end of the array to this spot, and repeat check on same index.
  149.                                         m_visibleNodes[i] = m_visibleNodes[lastNode];
  150.                                         lastNode--;
  151.                                         i--;
  152.                                 }
  153.                                 numItemsToDelete++;
  154.                         }
  155.                         m_lastStartUpdateNode = i + 1;
  156.                 }
  157.                 // delete not relevant items at the end.
  158.                 if (numItemsToDelete > 0)
  159.                 {
  160.                         m_visibleNodes.resize(m_visibleNodes.size() - numItemsToDelete);
  161.                 }
  162.                 // LOCK END
  163.         }
  164.         return;
  165. }
  166.  
  167. //////////////////////////////////////////////////////////////////////////
  168. void CVisibleRenderNodesManager::InvalidateAll()
  169. {
  170.         {
  171.                 // LOCK START
  172.                 CryAutoCriticalSectionNoRecursive lock(m_accessLock);
  173.                 for (auto* node : m_visibleNodes)
  174.                 {
  175.                         node->userData.bToDelete = true;
  176.                 }
  177.                 // LOCK END
  178.         }
  179. }
  180.  
  181. //////////////////////////////////////////////////////////////////////////
  182. void CVisibleRenderNodesManager::ClearAll()
  183. {
  184.         CryAutoCriticalSectionNoRecursive lock(m_accessLock);
  185.  
  186.         for (auto* node : m_visibleNodes)
  187.         {
  188.                 if (node->userData.pOwnerNode)
  189.                 {
  190.                         node->userData.pOwnerNode->OnRenderNodeBecomeInvisible();
  191.                         node->userData.pOwnerNode->m_pTempData = nullptr; // clear reference to use from owning render node.
  192.                 }
  193.                 m_pool.Delete(node);
  194.         }
  195.         m_visibleNodes.clear();
  196.  
  197.         for (auto& nodes : m_toDeleteNodes)
  198.         {
  199.                 for (auto* node : nodes)
  200.                 {
  201.                         m_pool.Delete(node);
  202.                 }
  203.                 nodes.clear();
  204.         }
  205. }
  206.  
  207. CVisibleRenderNodesManager::Statistics CVisibleRenderNodesManager::GetStatistics() const
  208. {
  209.         Statistics stats;
  210.         stats.numFree = 0;
  211.         stats.numUsed = m_visibleNodes.size();
  212.         return stats;
  213. }
  214.  
downloadVisibleRenderNodeManager.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