BVB Source Codes

CRYENGINE Show StatisticsHelpers.cpp Source code

Return Download CRYENGINE: download StatisticsHelpers.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   StatisticsHelpers.cpp
  5. //  Version:     v1.00
  6. //  Created:     04/03/2010 by Sergey Mikhtonyuk
  7. //  Description:
  8. // -------------------------------------------------------------------------
  9. //  History:
  10. //
  11. ////////////////////////////////////////////////////////////////////////////
  12. #include "StdAfx.h"
  13. #include "StatisticsHelpers.h"
  14. #include "GameStatistics.h"
  15. #include "CryActionCVars.h"
  16. #include "StatsSizer.h"
  17.  
  18. //////////////////////////////////////////////////////////////////////////
  19. // CStatsTracker
  20. //////////////////////////////////////////////////////////////////////////
  21.  
  22. CStatsTracker::CStatsTracker(const SNodeLocator& locator, CGameStatistics* pGameStats, IScriptTable* pTable)
  23.         : m_pGameStats(pGameStats)
  24.         , m_locator(locator)
  25.         , m_scriptTable(pTable)
  26. {
  27.         int eventCount = pGameStats->GetEventCount();
  28.         int stateCount = pGameStats->GetStateCount();
  29.         m_container = m_pGameStats->GetStorageFactory()->CreateContainer();
  30.         m_container->Init(eventCount, stateCount);
  31. }
  32.  
  33. //////////////////////////////////////////////////////////////////////////
  34.  
  35. CStatsTracker::~CStatsTracker()
  36. {
  37. }
  38.  
  39. //////////////////////////////////////////////////////////////////////////
  40.  
  41. SNodeLocator CStatsTracker::GetLocator() const
  42. {
  43.         return m_locator;
  44. }
  45.  
  46. //////////////////////////////////////////////////////////////////////////
  47.  
  48. IScriptTable* CStatsTracker::GetScriptTable() const
  49. {
  50.         return m_scriptTable.GetPtr();
  51. }
  52.  
  53. //////////////////////////////////////////////////////////////////////////
  54.  
  55. IStatsContainer* CStatsTracker::GetStatsContainer()
  56. {
  57.         return m_container;
  58. }
  59.  
  60. //////////////////////////////////////////////////////////////////////////
  61.  
  62. void CStatsTracker::StateValue(size_t stateID, const SStatAnyValue& value)
  63. {
  64. #if STATS_MODE_CVAR
  65.         if (CCryActionCVars::Get().g_statisticsMode != 2)
  66.                 return;
  67. #endif
  68.  
  69.         m_container->AddState(stateID, value);
  70.  
  71.         m_pGameStats->OnTrackedState(m_locator, stateID, value);
  72. }
  73.  
  74. //////////////////////////////////////////////////////////////////////////
  75.  
  76. void CStatsTracker::Event(size_t eventID, const SStatAnyValue& value)
  77. {
  78. #if STATS_MODE_CVAR
  79.         if (CCryActionCVars::Get().g_statisticsMode != 2)
  80.                 return;
  81. #endif
  82.  
  83.         CTimeValue timeVal = gEnv->pTimer->GetFrameStartTime(ITimer::ETIMER_UI);
  84.         m_container->AddEvent(eventID, timeVal, value);
  85.  
  86.         m_pGameStats->OnTrackedEvent(m_locator, eventID, timeVal, value);
  87. }
  88.  
  89. //////////////////////////////////////////////////////////////////////////
  90.  
  91. void CStatsTracker::GetMemoryStatistics(ICrySizer* pSizer)
  92. {
  93.         pSizer->Add(*this);
  94.         m_container->GetMemoryStatistics(pSizer);
  95. }
  96.  
  97. //////////////////////////////////////////////////////////////////////////
  98.  
  99. //////////////////////////////////////////////////////////////////////////
  100. // CStatsContainer
  101. //////////////////////////////////////////////////////////////////////////
  102.  
  103. void CStatsContainer::Init(size_t numEvents, size_t numStates)
  104. {
  105.         m_events.reserve(numEvents);
  106.         m_states.reserve(numStates);
  107. }
  108.  
  109. //////////////////////////////////////////////////////////////////////////
  110.  
  111. void CStatsContainer::AddEvent(size_t eventID, const CTimeValue& time, const SStatAnyValue& val)
  112. {
  113.         // Do we have a track for this event?
  114.         if (eventID >= m_events.size())
  115.         {
  116.                 // Events must be obsolete, extending event set
  117.                 m_events.resize(eventID + 1);
  118.         }
  119.  
  120.         m_events[eventID].push_back(std::make_pair(time, val));
  121.  
  122.         CStatsSizer sizer;
  123.         val.GetMemoryUsage(&sizer);
  124.         m_unloadableMemUsage += sizer.GetTotalSize();
  125. }
  126.  
  127. //////////////////////////////////////////////////////////////////////////
  128.  
  129. void CStatsContainer::AddState(size_t stateID, const SStatAnyValue& val)
  130. {
  131.         // Do we have a track for this event?
  132.         if (stateID >= m_states.size())
  133.         {
  134.                 // Events must be obsolete, extending event set
  135.                 m_states.resize(stateID + 1);
  136.         }
  137.  
  138.         m_states[stateID] = val;
  139.  
  140.         CStatsSizer sizer;
  141.         val.GetMemoryUsage(&sizer);
  142.         m_unloadableMemUsage += sizer.GetTotalSize();
  143. }
  144.  
  145. //////////////////////////////////////////////////////////////////////////
  146.  
  147. size_t CStatsContainer::GetEventTrackLength(size_t eventID) const
  148. {
  149.         return eventID >= m_events.size() ? 0 : m_events[eventID].size();
  150. }
  151.  
  152. //////////////////////////////////////////////////////////////////////////
  153.  
  154. void CStatsContainer::GetEventInfo(size_t eventID, size_t idx, CTimeValue& outTime, SStatAnyValue& outParam) const
  155. {
  156.         if (eventID < m_events.size() && idx < m_events[eventID].size())
  157.         {
  158.                 outTime = m_events[eventID][idx].first;
  159.                 outParam = m_events[eventID][idx].second;
  160.         }
  161.         else
  162.         {
  163.                 outTime = CTimeValue();
  164.                 outParam = SStatAnyValue();
  165.         }
  166. }
  167.  
  168. //////////////////////////////////////////////////////////////////////////
  169.  
  170. void CStatsContainer::GetStateInfo(size_t stateID, SStatAnyValue& outValue) const
  171. {
  172.         if (stateID < m_states.size())
  173.                 outValue = m_states[stateID];
  174.         else
  175.                 outValue = SStatAnyValue();
  176. }
  177.  
  178. //////////////////////////////////////////////////////////////////////////
  179.  
  180. void CStatsContainer::Clear()
  181. {
  182.         for (size_t i = 0; i != m_events.size(); ++i)
  183.                 m_events[i].clear();
  184.  
  185.         for (size_t i = 0; i != m_states.size(); ++i)
  186.         {
  187.                 SStatAnyValue none;
  188.                 m_states[i] = none;
  189.         }
  190.  
  191.         m_unloadableMemUsage = 0;
  192. }
  193.  
  194. //////////////////////////////////////////////////////////////////////////
  195.  
  196. bool CStatsContainer::IsEmpty() const
  197. {
  198.         return m_unloadableMemUsage == 0;
  199. }
  200.  
  201. //////////////////////////////////////////////////////////////////////////
  202.  
  203. void CStatsContainer::GetMemoryStatistics(ICrySizer* pSizer)
  204. {
  205.         pSizer->Add(*this);
  206.         pSizer->AddContainer(m_events);
  207.         pSizer->AddContainer(m_states);
  208.  
  209.         for (size_t i = 0; i != m_events.size(); ++i)
  210.         {
  211.                 const TEventTrack& track = m_events[i];
  212.                 pSizer->AddContainer(track);
  213.         }
  214.  
  215.         pSizer->AddObject(this, m_unloadableMemUsage);
  216. }
  217.  
  218. //////////////////////////////////////////////////////////////////////////
  219.  
  220. void CStatsContainer::AddRef()
  221. {
  222.         ++m_refCount;
  223. }
  224.  
  225. //////////////////////////////////////////////////////////////////////////
  226.  
  227. void CStatsContainer::Release()
  228. {
  229.         --m_refCount;
  230.         if (m_refCount <= 0)
  231.         {
  232.                 delete this;
  233.         }
  234. }
  235.  
  236. //////////////////////////////////////////////////////////////////////////
  237.  
  238. IStatsContainer* CDefaultStorageFactory::CreateContainer()
  239. {
  240.         return new CStatsContainer();
  241. }
  242.  
  243. //////////////////////////////////////////////////////////////////////////
  244.  
  245. //////////////////////////////////////////////////////////////////////////
  246. // SDeadStatNode
  247. //////////////////////////////////////////////////////////////////////////
  248.  
  249. SDeadStatNode::SDeadStatNode(const SNodeLocator& loc, CStatsTracker* track)
  250.         : locator(loc)
  251.         , tracker(track)
  252.         , cachedMemoryStats(MEMORY_LIMIT_MAXIMUM)
  253. {}
  254.  
  255. //////////////////////////////////////////////////////////////////////////
  256.  
  257. SDeadStatNode::~SDeadStatNode()
  258. {
  259.         delete tracker;
  260. }
  261.  
  262. //////////////////////////////////////////////////////////////////////////
  263.  
  264. size_t SDeadStatNode::GetMemoryStatistics() const
  265. {
  266.         // The sub-tree is static, so we can calculate memory once and cache it
  267.         if (cachedMemoryStats == MEMORY_LIMIT_MAXIMUM)
  268.         {
  269.                 CStatsSizer sizer;
  270.  
  271.                 sizer.Add(*this);
  272.                 sizer.AddContainer(children);
  273.                 tracker->GetMemoryStatistics(&sizer);
  274.  
  275.                 for (size_t i = 0; i != children.size(); ++i)
  276.                         children[i]->GetMemoryStatistics(&sizer);
  277.  
  278.                 cachedMemoryStats = sizer.GetTotalSize();
  279.         }
  280.  
  281.         return cachedMemoryStats;
  282. }
  283.  
  284. //////////////////////////////////////////////////////////////////////////
  285.  
  286. void SDeadStatNode::GetMemoryStatistics(ICrySizer* pSizer) const
  287. {
  288.         pSizer->AddObject(this, GetMemoryStatistics());
  289. }
  290.  
  291. //////////////////////////////////////////////////////////////////////////
  292.  
  293. //////////////////////////////////////////////////////////////////////////
  294. // SScopeData
  295. //////////////////////////////////////////////////////////////////////////
  296.  
  297. SScopeData::SScopeData(SNodeLocator _locator, CStatsTracker* _tracker)
  298.         : locator(_locator)
  299.         , tracker(_tracker)
  300. {}
  301.  
  302. //////////////////////////////////////////////////////////////////////////
  303.  
  304. void SScopeData::GetMemoryStatistics(ICrySizer* pSizer) const
  305. {
  306.         pSizer->Add(*this);
  307.         pSizer->AddContainer(elements);
  308.         pSizer->AddContainer(deadNodes);
  309.  
  310.         for (TElements::const_iterator it = elements.begin(); it != elements.end(); ++it)
  311.                 it->second->GetMemoryStatistics(pSizer);
  312.  
  313.         for (size_t i = 0; i != deadNodes.size(); ++i)
  314.                 deadNodes[i]->GetMemoryStatistics(pSizer);
  315. }
  316.  
  317. //////////////////////////////////////////////////////////////////////////
  318.  
  319. //////////////////////////////////////////////////////////////////////////
  320. // CGameScope
  321. //////////////////////////////////////////////////////////////////////////
  322.  
  323. CGameScopes::CGameScopes()
  324. {
  325.         GetISystem()->GetXmlUtils()->InitStatsXmlNodePool(64 * 1024);
  326. }
  327.  
  328. //////////////////////////////////////////////////////////////////////////
  329.  
  330. bool CGameScopes::RegisterGameScopes(const SGameScopeDesc scopeDescs[], size_t numScopes)
  331. {
  332.         CRY_ASSERT(scopeDescs);
  333.         CRY_ASSERT(numScopes > 0);
  334.  
  335.         if (!ValidateScopes(scopeDescs, numScopes))
  336.                 return false;
  337.  
  338.         GrowRegistry(numScopes);
  339.         InsertScopesInRegistry(scopeDescs, numScopes);
  340.  
  341.         return true;
  342. }
  343.  
  344. //////////////////////////////////////////////////////////////////////////
  345.  
  346. const SGameScopeDesc* CGameScopes::GetScopeDesc(size_t id) const
  347. {
  348.         return id < m_scopeRegistry.size() ? &m_scopeRegistry[id] : 0;
  349. }
  350.  
  351. //////////////////////////////////////////////////////////////////////////
  352.  
  353. const SGameScopeDesc* CGameScopes::GetScopeDesc(const char* scriptName) const
  354. {
  355.         TScopeMap::const_iterator it = m_scopeMap.find(scriptName);
  356.         return it != m_scopeMap.end() ? GetScopeDesc(it->second) : 0;
  357. }
  358.  
  359. //////////////////////////////////////////////////////////////////////////
  360.  
  361. CStatsTracker* CGameScopes::PushGameScope(size_t scopeID, uint32 timestamp, CGameStatistics* gameStatistics)
  362. {
  363.         CRY_ASSERT(scopeID < m_scopeRegistry.size());
  364.         if (scopeID >= m_scopeRegistry.size())
  365.                 return 0;
  366.  
  367.         // Check that same scope isn't already on the stack
  368.         size_t pos = FindScopePos(scopeID);
  369.         CRY_ASSERT_MESSAGE(pos == m_scopeStack.size(), "Same scope can't be pushed twice");
  370.         if (pos != m_scopeStack.size())
  371.                 return 0;
  372.  
  373.         SNodeLocator locator(scopeID);
  374.         locator.timeStamp = timestamp;
  375.         CStatsTracker* tracker = new CStatsTracker(locator, gameStatistics);
  376.         m_scopeStack.push_back(SScopeData(locator, tracker));
  377.  
  378.         return tracker;
  379. }
  380.  
  381. //////////////////////////////////////////////////////////////////////////
  382.  
  383. SDeadStatNode* CGameScopes::PopGameScope()
  384. {
  385.         SNodeLocator locator = m_scopeStack.back().locator;
  386.         CStatsTracker* tracker = m_scopeStack.back().tracker;
  387.  
  388.         SDeadStatNode* deadScope = new SDeadStatNode(locator, tracker);
  389.         std::swap(deadScope->children, m_scopeStack.back().deadNodes);
  390.  
  391.         m_scopeStack.pop_back();
  392.  
  393.         if (!m_scopeStack.empty())
  394.                 m_scopeStack.back().deadNodes.push_back(deadScope);
  395.         else
  396.                 stl::free_container(m_scopeStack);
  397.  
  398.         return deadScope;
  399. }
  400.  
  401. //////////////////////////////////////////////////////////////////////////
  402.  
  403. size_t CGameScopes::FindScopePos(size_t scopeID) const
  404. {
  405.         size_t size = m_scopeStack.size();
  406.         for (size_t i = 0; i < size; ++i)
  407.         {
  408.                 if (m_scopeStack[i].locator.scopeID == scopeID)
  409.                 {
  410.                         return i;
  411.                 }
  412.         }
  413.         return size;
  414. }
  415.  
  416. //////////////////////////////////////////////////////////////////////////
  417.  
  418. size_t CGameScopes::GetRegisteredCount() const
  419. {
  420.         return m_scopeRegistry.size();
  421. }
  422.  
  423. //////////////////////////////////////////////////////////////////////////
  424.  
  425. size_t CGameScopes::GetStackSize() const
  426. {
  427.         return m_scopeStack.size();
  428. }
  429.  
  430. //////////////////////////////////////////////////////////////////////////
  431.  
  432. const SScopeData& CGameScopes::GetScopeAt(size_t pos) const
  433. {
  434.         return m_scopeStack[pos];
  435. }
  436.  
  437. //////////////////////////////////////////////////////////////////////////
  438.  
  439. SScopeData& CGameScopes::GetScopeAt(size_t pos)
  440. {
  441.         return m_scopeStack[pos];
  442. }
  443.  
  444. //////////////////////////////////////////////////////////////////////////
  445.  
  446. const SScopeData& CGameScopes::GetLastScope() const
  447. {
  448.         return m_scopeStack.back();
  449. }
  450.  
  451. //////////////////////////////////////////////////////////////////////////
  452.  
  453. SScopeData& CGameScopes::GetLastScope()
  454. {
  455.         return m_scopeStack.back();
  456. }
  457.  
  458. //////////////////////////////////////////////////////////////////////////
  459.  
  460. bool CGameScopes::ValidateScopes(const SGameScopeDesc scopeDescs[], size_t numScopes)
  461. {
  462.         const size_t firstFreeID = m_scopeRegistry.size();
  463.  
  464.         std::set<const char*, stl::less_strcmp<const char*>> scriptNames;
  465.  
  466.         for (size_t i = 0; i != numScopes; ++i)
  467.         {
  468.                 if (!scopeDescs[i].IsValid())
  469.                         return false;
  470.  
  471.                 if (scopeDescs[i].statID < firstFreeID || scopeDescs[i].statID >= (firstFreeID + numScopes))
  472.                         return false;
  473.  
  474.                 if (m_scopeMap.find(scopeDescs[i].scriptName) != m_scopeMap.end()) // name collision
  475.                         return false;
  476.  
  477.                 if (!scriptNames.insert(scopeDescs[i].scriptName.c_str()).second)
  478.                         return false;
  479.         }
  480.         return true;
  481. }
  482.  
  483. //////////////////////////////////////////////////////////////////////////
  484.  
  485. void CGameScopes::GrowRegistry(size_t numScopes)
  486. {
  487.         m_scopeRegistry.resize(m_scopeRegistry.size() + numScopes);
  488. }
  489.  
  490. //////////////////////////////////////////////////////////////////////////
  491.  
  492. void CGameScopes::InsertScopesInRegistry(const SGameScopeDesc scopeDescs[], size_t numScopes)
  493. {
  494.         for (size_t i = 0; i != numScopes; ++i)
  495.         {
  496.                 CRY_ASSERT(m_scopeRegistry[scopeDescs[i].statID].scriptName.empty());
  497.  
  498.                 m_scopeRegistry[scopeDescs[i].statID] = scopeDescs[i];
  499.  
  500.                 m_scopeMap.insert(std::make_pair(scopeDescs[i].scriptName, scopeDescs[i].statID));
  501.         }
  502. }
  503.  
  504. //////////////////////////////////////////////////////////////////////////
  505.  
  506. void CGameScopes::GetMemoryStatistics(ICrySizer* pSizer) const
  507. {
  508.         pSizer->AddContainer(m_scopeRegistry);
  509.         pSizer->AddContainer(m_scopeMap);
  510.         pSizer->AddContainer(m_scopeStack);
  511.  
  512.         for (size_t i = 0; i != m_scopeStack.size(); ++i)
  513.                 m_scopeStack[i].GetMemoryStatistics(pSizer);
  514. }
  515.  
  516. //////////////////////////////////////////////////////////////////////////
  517.  
  518. //////////////////////////////////////////////////////////////////////////
  519. // CStatRegistry
  520. //////////////////////////////////////////////////////////////////////////
  521.  
  522. bool CStatRegistry::Register(const SGameStatDesc statDescs[], size_t numStats)
  523. {
  524.         CRY_ASSERT(statDescs);
  525.         if (!numStats) return true;
  526.  
  527.         const size_t firstFreeID = m_statRegistry.size();
  528.  
  529.         if (!ValidateRegistration(statDescs, numStats))
  530.                 return false;
  531.  
  532.         // Copy new events to registry and map
  533.         m_statRegistry.resize(firstFreeID + numStats);
  534.  
  535.         for (size_t i = 0; i != numStats; ++i)
  536.         {
  537.                 // Check for overwrite
  538.                 CRY_ASSERT(m_statRegistry[statDescs[i].statID].scriptName.empty());
  539.  
  540.                 m_statRegistry[statDescs[i].statID] = statDescs[i];
  541.  
  542.                 m_statMap.insert(std::make_pair(statDescs[i].scriptName, statDescs[i].statID));
  543.         }
  544.  
  545.         return true;
  546. }
  547.  
  548. //////////////////////////////////////////////////////////////////////////
  549.  
  550. size_t CStatRegistry::Register(const char* scriptName, const char* serializeName)
  551. {
  552.         SGameStatDesc newStat(m_statRegistry.size(), scriptName, serializeName);
  553.  
  554.         if (!ValidateRegistration(&newStat, 1))
  555.                 return INVALID_STAT_ID;
  556.  
  557.         m_statRegistry.push_back(newStat);
  558.         m_statMap.insert(std::make_pair(scriptName, newStat.statID));
  559.  
  560.         return m_statRegistry.back().statID;
  561. }
  562.  
  563. //////////////////////////////////////////////////////////////////////////
  564.  
  565. size_t CStatRegistry::Count() const
  566. {
  567.         return m_statRegistry.size();
  568. }
  569.  
  570. //////////////////////////////////////////////////////////////////////////
  571.  
  572. size_t CStatRegistry::GetID(const char* scriptName) const
  573. {
  574.         CRY_ASSERT(scriptName);
  575.  
  576.         TStatMap::const_iterator it = m_statMap.find(scriptName);
  577.         return (it == m_statMap.end())
  578.                ? INVALID_STAT_ID
  579.                : it->second;
  580. }
  581.  
  582. //////////////////////////////////////////////////////////////////////////
  583.  
  584. const SGameStatDesc* CStatRegistry::GetDesc(size_t statID) const
  585. {
  586.         return (statID >= m_statRegistry.size()) ?
  587.                0 :
  588.                &m_statRegistry[statID];
  589. }
  590.  
  591. //////////////////////////////////////////////////////////////////////////
  592.  
  593. bool CStatRegistry::ValidateRegistration(const SGameStatDesc* statDescs, size_t numStats)
  594. {
  595.         const size_t firstFreeID = m_statRegistry.size();
  596.  
  597.         std::set<const char*, stl::less_strcmp<const char*>> scriptNames;
  598.  
  599.         for (size_t i = 0; i != numStats; ++i)
  600.         {
  601.                 if (!statDescs[i].IsValid())
  602.                         return false;
  603.  
  604.                 if (statDescs[i].statID < firstFreeID || statDescs[i].statID >= (firstFreeID + numStats)) // bad id
  605.                         return false;
  606.  
  607.                 if ((m_statMap.find(statDescs[i].scriptName) != m_statMap.end())) // name collision
  608.                         return false;
  609.  
  610.                 if (!scriptNames.insert(statDescs[i].scriptName.c_str()).second)
  611.                         return false;
  612.         }
  613.         return true;
  614. }
  615.  
  616. //////////////////////////////////////////////////////////////////////////
  617.  
  618. void CStatRegistry::GetMemoryStatistics(ICrySizer* pSizer) const
  619. {
  620.         pSizer->AddContainer(m_statRegistry);
  621.         pSizer->AddContainer(m_statMap);
  622. }
  623.  
  624. //////////////////////////////////////////////////////////////////////////
  625.  
  626. //////////////////////////////////////////////////////////////////////////
  627. // CElemRegistry
  628. //////////////////////////////////////////////////////////////////////////
  629.  
  630. bool CElemRegistry::Register(const SGameElementDesc elemDescs[], size_t numElems)
  631. {
  632.         CRY_ASSERT(elemDescs);
  633.         if (!numElems) return true;
  634.  
  635.         const size_t firstFreeID = m_elemRegistry.size();
  636.  
  637.         if (!ValidateRegistration(elemDescs, numElems))
  638.                 return false;
  639.  
  640.         // Copy new events to registry and map
  641.         m_elemRegistry.resize(firstFreeID + numElems);
  642.  
  643.         for (size_t i = 0; i != numElems; ++i)
  644.         {
  645.                 // Check for overwrite
  646.                 CRY_ASSERT(m_elemRegistry[elemDescs[i].statID].scriptName.empty());
  647.  
  648.                 m_elemRegistry[elemDescs[i].statID] = elemDescs[i];
  649.  
  650.                 m_elemMap.insert(std::make_pair(elemDescs[i].scriptName, elemDescs[i].statID));
  651.         }
  652.  
  653.         return true;
  654. }
  655.  
  656. //////////////////////////////////////////////////////////////////////////
  657.  
  658. size_t CElemRegistry::Count() const
  659. {
  660.         return m_elemRegistry.size();
  661. }
  662.  
  663. //////////////////////////////////////////////////////////////////////////
  664.  
  665. size_t CElemRegistry::GetID(const char* scriptName) const
  666. {
  667.         CRY_ASSERT(scriptName);
  668.  
  669.         TElemMap::const_iterator it = m_elemMap.find(scriptName);
  670.         return (it == m_elemMap.end())
  671.                ? INVALID_STAT_ID
  672.                : it->second;
  673. }
  674.  
  675. //////////////////////////////////////////////////////////////////////////
  676.  
  677. const SGameElementDesc* CElemRegistry::GetDesc(size_t statID) const
  678. {
  679.         return (statID >= m_elemRegistry.size())
  680.                ? 0
  681.                : &m_elemRegistry[statID];
  682. }
  683.  
  684. //////////////////////////////////////////////////////////////////////////
  685.  
  686. bool CElemRegistry::ValidateRegistration(const SGameElementDesc* elemDescs, size_t numElems)
  687. {
  688.         const size_t firstFreeID = m_elemRegistry.size();
  689.  
  690.         std::set<const char*, stl::less_strcmp<const char*>> scriptNames;
  691.  
  692.         for (size_t i = 0; i != numElems; ++i)
  693.         {
  694.                 if (!elemDescs[i].IsValid())
  695.                         return false;
  696.  
  697.                 if (elemDescs[i].statID < firstFreeID || elemDescs[i].statID >= (firstFreeID + numElems)) // bad id
  698.                         return false;
  699.  
  700.                 if ((m_elemMap.find(elemDescs[i].scriptName) != m_elemMap.end())) // name collision
  701.                         return false;
  702.  
  703.                 if (!scriptNames.insert(elemDescs[i].scriptName.c_str()).second)
  704.                         return false;
  705.         }
  706.         return true;
  707. }
  708.  
  709. //////////////////////////////////////////////////////////////////////////
  710.  
  711. void CElemRegistry::GetMemoryStatistics(ICrySizer* pSizer) const
  712. {
  713.         pSizer->AddContainer(m_elemRegistry);
  714.         pSizer->AddContainer(m_elemMap);
  715. }
  716.  
  717. //////////////////////////////////////////////////////////////////////////
  718.  
downloadStatisticsHelpers.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