BVB Source Codes

CRYENGINE Show FlowStatsNodes.cpp Source code

Return Download CRYENGINE: download FlowStatsNodes.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.  
  8.    -------------------------------------------------------------------------
  9.    History:
  10.    - 30:6:2005   18:43 : Created by Mrcio Martins
  11.    - 21:10:2008                 Mario Silva added extended version of the FrameStats node
  12.  
  13. *************************************************************************/
  14. #include "StdAfx.h"
  15.  
  16. #include <CryFlowGraph/IFlowBaseNode.h>
  17.  
  18. class CFlowNode_MemoryStats : public CFlowBaseNode<eNCT_Singleton>
  19. {
  20. public:
  21.         enum Outputs
  22.         {
  23.                 OUT_SYSMEM,
  24.                 OUT_VIDEOMEM_THISFRAME,
  25.                 OUT_VIDEOMEM_RECENTLY,
  26.                 OUT_MESHMEM,
  27.         };
  28.         CFlowNode_MemoryStats(SActivationInfo* pActInfo)
  29.         {
  30.         }
  31.         virtual void GetConfiguration(SFlowNodeConfig& config)
  32.         {
  33.                 static const SInputPortConfig in_config[] = {
  34.                         { 0 }
  35.                 };
  36.                 static const SOutputPortConfig out_config[] = {
  37.                         OutputPortConfig<int>("sysmem"),
  38.                         OutputPortConfig<int>("videomem_thisframe"),
  39.                         OutputPortConfig<int>("videomem_recently"),
  40.                         OutputPortConfig<int>("meshmem"),
  41.                         { 0 }
  42.                 };
  43.  
  44.                 config.pInputPorts = in_config;
  45.                 config.pOutputPorts = out_config;
  46.                 config.SetCategory(EFLN_DEBUG);
  47.         }
  48.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  49.         {
  50.                 switch (event)
  51.                 {
  52.                 case eFE_Initialize:
  53.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  54.                         break;
  55.                 case eFE_Update:
  56.                         {
  57.                                 ISystem* pSystem = GetISystem();
  58.                                 IRenderer* pRenderer = gEnv->pRenderer;
  59.  
  60.                                 int sysMem = pSystem->GetUsedMemory();
  61.                                 size_t vidMemThisFrame(0);
  62.                                 size_t vidMemRecently(0);
  63.                                 pRenderer->GetVideoMemoryUsageStats(vidMemThisFrame, vidMemRecently);
  64.                                 int meshMem = 0;
  65.                                 pRenderer->EF_Query(EFQ_Alloc_APIMesh, meshMem);
  66.  
  67.                                 ActivateOutput(pActInfo, OUT_SYSMEM, sysMem);
  68.                                 // potentially unsafe if we start using >2gb of video memory...?
  69.                                 ActivateOutput(pActInfo, OUT_VIDEOMEM_THISFRAME, int(vidMemThisFrame));
  70.                                 ActivateOutput(pActInfo, OUT_VIDEOMEM_RECENTLY, int(vidMemRecently));
  71.                                 ActivateOutput(pActInfo, OUT_MESHMEM, meshMem);
  72.                         }
  73.                         break;
  74.                 }
  75.         }
  76.  
  77.         virtual void GetMemoryUsage(ICrySizer* s) const
  78.         {
  79.                 s->Add(*this);
  80.         }
  81. };
  82.  
  83. class CFlowNode_FrameStats : public CFlowBaseNode<eNCT_Singleton>
  84. {
  85. public:
  86.         enum Outputs
  87.         {
  88.                 OUT_FRAMETIME,
  89.                 OUT_FRAMERATE,
  90.                 OUT_FRAMEID,
  91.         };
  92.         CFlowNode_FrameStats(SActivationInfo* pActInfo)
  93.         {
  94.         }
  95.         virtual void GetConfiguration(SFlowNodeConfig& config)
  96.         {
  97.                 static const SInputPortConfig in_config[] = {
  98.                         { 0 }
  99.                 };
  100.                 static const SOutputPortConfig out_config[] = {
  101.                         OutputPortConfig<float>("frametime"),
  102.                         OutputPortConfig<float>("framerate"),
  103.                         OutputPortConfig<int>("frameid"),
  104.                         { 0 }
  105.                 };
  106.  
  107.                 config.pInputPorts = in_config;
  108.                 config.pOutputPorts = out_config;
  109.                 config.SetCategory(EFLN_DEBUG);
  110.         }
  111.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  112.         {
  113.                 switch (event)
  114.                 {
  115.                 case eFE_Initialize:
  116.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  117.                         break;
  118.                 case eFE_Update:
  119.                         {
  120.                                 ISystem* pSystem = GetISystem();
  121.                                 IRenderer* pRenderer = gEnv->pRenderer;
  122.  
  123.                                 float frameTime = gEnv->pTimer->GetFrameTime();
  124.                                 float frameRate = gEnv->pTimer->GetFrameRate();
  125.                                 int frameId = pRenderer->GetFrameID(false);
  126.  
  127.                                 ActivateOutput(pActInfo, OUT_FRAMETIME, frameTime);
  128.                                 ActivateOutput(pActInfo, OUT_FRAMERATE, frameRate);
  129.                                 ActivateOutput(pActInfo, OUT_FRAMEID, frameId);
  130.                         }
  131.                         break;
  132.                 }
  133.         }
  134.  
  135.         virtual void GetMemoryUsage(ICrySizer* s) const
  136.         {
  137.                 s->Add(*this);
  138.         }
  139. };
  140.  
  141. //////////////////////////////////////////////////////////////////////////
  142. // Extended version of the FrameStats node
  143. class CFlowNode_FrameStatsEx : public CFlowBaseNode<eNCT_Singleton>
  144. {
  145.         enum EInputs
  146.         {
  147.                 eIN_Start,
  148.                 eIN_Stop,
  149.                 eIN_Reset,
  150.         };
  151.         enum EOutputs
  152.         {
  153.                 eOUT_FrameTime,
  154.                 eOUT_FrameRate,
  155.                 eOUT_FrameID,
  156.                 eOUT_Min,
  157.                 eOUT_Max,
  158.                 eOUT_Average,
  159.         };
  160.  
  161. public:
  162.         CFlowNode_FrameStatsEx(SActivationInfo* pActInfo)
  163.         {
  164.                 Reset();
  165.         };
  166.  
  167.         ~CFlowNode_FrameStatsEx()
  168.         {
  169.         };
  170.  
  171.         virtual void GetConfiguration(SFlowNodeConfig& config)
  172.         {
  173.                 static const SInputPortConfig in_config[] = {
  174.                         InputPortConfig_AnyType("Start", _HELP("Trigger to start gathering the frame rate data, it also resets the previous values")),
  175.                         InputPortConfig_AnyType("Stop",  _HELP("Trigger to stop gathering the frame rate data")),
  176.                         InputPortConfig_AnyType("Reset", _HELP("Trigger to reset the frame rate data")),
  177.                         { 0 }
  178.                 };
  179.                 static const SOutputPortConfig out_config[] = {
  180.                         OutputPortConfig<float>("FrameTime",        _HELP("Current frame time")),
  181.                         OutputPortConfig<float>("FrameRate",        _HELP("Current frame rate")),
  182.                         OutputPortConfig<int>("FrameId",            _HELP("Current frame id")),
  183.                         OutputPortConfig<float>("MinFrameRate",     _HELP("Minimum frame rate")),
  184.                         OutputPortConfig<float>("MaxFrameRate",     _HELP("Maximum frame rate")),
  185.                         OutputPortConfig<float>("AverageFrameRate", _HELP("Average frame rate")),
  186.                         { 0 }
  187.                 };
  188.  
  189.                 config.pInputPorts = in_config;
  190.                 config.pOutputPorts = out_config;
  191.                 config.sDescription = _HELP("When activated, this node outputs the current frame rate data and the lowest, highest and the average frame rate.");
  192.                 config.SetCategory(EFLN_DEBUG);
  193.         }
  194.  
  195.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  196.         {
  197.                 CRY_ASSERT(pActInfo != NULL);
  198.  
  199.                 switch (event)
  200.                 {
  201.                 case eFE_Initialize:
  202.                         {
  203.                                 pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  204.                                 Reset();
  205.                         }
  206.                         break;
  207.  
  208.                 case eFE_Activate:
  209.                         {
  210.                                 if (IsPortActive(pActInfo, eIN_Start))
  211.                                 {
  212.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  213.                                 }
  214.                                 if (IsPortActive(pActInfo, eIN_Stop))
  215.                                 {
  216.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  217.                                 }
  218.                                 if (IsPortActive(pActInfo, eIN_Reset))
  219.                                 {
  220.                                         Reset();
  221.                                 }
  222.                         }
  223.                         break;
  224.  
  225.                 case eFE_Update:
  226.                         {
  227.                                 IRenderer* pRenderer = gEnv->pRenderer;
  228.  
  229.                                 float fFrameTime = gEnv->pTimer->GetFrameTime();
  230.                                 float fFrameRate = gEnv->pTimer->GetFrameRate();
  231.                                 int fFrameId = pRenderer->GetFrameID(false);
  232.  
  233.                                 m_fMinFrameRate = min(fFrameRate, m_fMinFrameRate);
  234.                                 m_fMaxFrameRate = max(fFrameRate, m_fMaxFrameRate);
  235.                                 m_fSumFrameRate += fFrameRate;
  236.                                 ++m_lFrameCounter;
  237.  
  238.                                 ActivateOutput(pActInfo, eOUT_FrameTime, fFrameTime);
  239.                                 ActivateOutput(pActInfo, eOUT_FrameRate, fFrameRate);
  240.                                 ActivateOutput(pActInfo, eOUT_FrameID, fFrameId);
  241.                                 ActivateOutput(pActInfo, eOUT_Min, m_fMinFrameRate);
  242.                                 ActivateOutput(pActInfo, eOUT_Max, m_fMaxFrameRate);
  243.                                 ActivateOutput(pActInfo, eOUT_Average, (m_fSumFrameRate / m_lFrameCounter));
  244.                         }
  245.                         break;
  246.  
  247.                 default:
  248.                         break;
  249.                 }
  250.         }
  251.  
  252.         void Reset()
  253.         {
  254.                 m_fMinFrameRate = FLT_MAX;
  255.                 m_fMaxFrameRate = 0.0f;
  256.                 m_fSumFrameRate = 0.0f;
  257.                 m_lFrameCounter = 0;
  258.         }
  259.  
  260.         virtual void GetMemoryUsage(ICrySizer* crySizer) const
  261.         {
  262.                 crySizer->Add(*this);
  263.         }
  264.  
  265. private:
  266.         float         m_fMinFrameRate;
  267.         float         m_fMaxFrameRate;
  268.         float         m_fSumFrameRate;
  269.         unsigned long m_lFrameCounter;
  270. };
  271.  
  272. REGISTER_FLOW_NODE("Debug:Memory", CFlowNode_MemoryStats);
  273. REGISTER_FLOW_NODE("Debug:Frame", CFlowNode_FrameStats);
  274. REGISTER_FLOW_NODE("Debug:FrameExtended", CFlowNode_FrameStatsEx);
  275.  
downloadFlowStatsNodes.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