BVB Source Codes

CRYENGINE Show DebugHistory.cpp Source code

Return Download CRYENGINE: download DebugHistory.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 "DebugHistory.h"
  5. //#include "PersistantDebug.h"
  6.  
  7. std::set<CDebugHistoryManager*>* CDebugHistoryManager::m_allhistory;
  8.  
  9. static int g_currentlyVisibleCount = 0;
  10.  
  11. //--------------------------------------------------------------------------------
  12.  
  13. void Draw2DLine(float x1, float y1, float x2, float y2, ColorF color, float fThickness)
  14. {
  15.         IRenderAuxGeom* pAux = gEnv->pRenderer->GetIRenderAuxGeom();
  16.         ColorB rgba((uint8)(color.r * 255.0f), (uint8)(color.g * 255.0f), (uint8)(color.b * 255.0f), (uint8)(color.a * 255.0f));
  17.         x1 /= gEnv->pRenderer->GetWidth();
  18.         y1 /= gEnv->pRenderer->GetHeight();
  19.         x2 /= gEnv->pRenderer->GetWidth();
  20.         y2 /= gEnv->pRenderer->GetHeight();
  21.         pAux->DrawLine(Vec3(x1, y1, 0), rgba, Vec3(x2, y2, 0), rgba, fThickness);
  22. }
  23.  
  24. //--------------------------------------------------------------------------------
  25.  
  26. CDebugHistory::CDebugHistory(const char* name, int size)
  27.         : m_szName(name)
  28.         , m_show(false)
  29.         , m_layoutTopLeft(Vec2(100.0f, 100.0f))
  30.         , m_layoutExtent(Vec2(100.0f, 100.0f))
  31.         , m_layoutMargin(0.0f)
  32.         , m_scopeOuterMax(0.0f)
  33.         , m_scopeOuterMin(0.0f)
  34.         , m_scopeInnerMax(0.0f)
  35.         , m_scopeInnerMin(0.0f)
  36.         , m_scopeCurMax(0.0f)
  37.         , m_scopeCurMin(0.0f)
  38.         , m_colorCurveNormal(ColorF(1, 1, 1, 1))
  39.         , m_colorCurveClamped(ColorF(1, 1, 1, 1))
  40.         , m_colorBox(ColorF(0.2f, 0.2f, 0.2f, 0.2f))
  41.         , m_colorGridLine(ColorF(0.0f, 0.0f, 1.0f, 0.2f))
  42.         , m_colorGridNumber(ColorF(1.0f, 1.0f, 1.0f, 1.0f))
  43.         , m_colorName(ColorF(1, 1, 0, 1.0f))
  44.         , m_wantedGridLineCountX(4)
  45.         , m_wantedGridLineCountY(3)
  46.         , m_gridLineCount(0)
  47.         , m_pValues(nullptr)
  48.         , m_maxCount(size)
  49.         , m_head(0)
  50.         , m_count(0)
  51.         , m_scopeRefreshDelay(0)
  52.         , m_gridRefreshDelay(0)
  53.         , m_hasDefaultValue(false)
  54.         , m_defaultValue(0.0f)
  55.         , m_gotValue(false)
  56. {
  57.         SetVisibility(false);
  58.  
  59.         for (int i = 0; i < GRIDLINE_MAXCOUNT; ++i)
  60.         {
  61.                 m_gridLine[i] = 0.0f;
  62.         }
  63. }
  64.  
  65. //--------------------------------------------------------------------------------
  66.  
  67. CDebugHistory::~CDebugHistory()
  68. {
  69.         SetVisibility(false);
  70. }
  71.  
  72. //--------------------------------------------------------------------------------
  73.  
  74. void CDebugHistory::SetName(const char* newName)
  75. {
  76.         m_szName = newName;
  77. }
  78.  
  79. //--------------------------------------------------------------------------------
  80.  
  81. void CDebugHistory::SetVisibility(bool show)
  82. {
  83.         if (m_show != show)
  84.         {
  85.                 if (show)
  86.                         g_currentlyVisibleCount++;
  87.                 else
  88.                         g_currentlyVisibleCount--;
  89.         }
  90.  
  91.         m_show = show;
  92.  
  93.         if (show)
  94.         {
  95.                 if (m_pValues == NULL)
  96.                 {
  97.                         m_pValues = new float[m_maxCount];
  98.                         ClearHistory();
  99.                 }
  100.         }
  101.         else
  102.         {
  103.                 if (m_pValues != NULL)
  104.                 {
  105.                         delete[] m_pValues;
  106.                         m_pValues = NULL;
  107.                 }
  108.         }
  109. }
  110.  
  111. //--------------------------------------------------------------------------------
  112.  
  113. void CDebugHistory::SetupLayoutAbs(float leftx, float topy, float width, float height, float margin)
  114. {
  115.         //float RefWidth = 800.0f;
  116.         //float RefHeight = 600.0f;
  117.         float RefWidth = 1024.0f;
  118.         float RefHeight = 768.0f;
  119.         SetupLayoutRel(leftx / RefWidth, topy / RefHeight, width / RefWidth, height / RefHeight, margin / RefHeight);
  120. }
  121.  
  122. //--------------------------------------------------------------------------------
  123.  
  124. void CDebugHistory::SetupLayoutRel(float leftx, float topy, float width, float height, float margin)
  125. {
  126.         m_layoutTopLeft.x = leftx * gEnv->pRenderer->GetWidth();
  127.         m_layoutTopLeft.y = topy * gEnv->pRenderer->GetHeight();
  128.         m_layoutExtent.x = width * gEnv->pRenderer->GetWidth();
  129.         m_layoutExtent.y = height * gEnv->pRenderer->GetHeight();
  130.         m_layoutMargin = margin * gEnv->pRenderer->GetHeight();
  131. }
  132.  
  133. //--------------------------------------------------------------------------------
  134.  
  135. void CDebugHistory::SetupScopeExtent(float outermin, float outermax, float innermin, float innermax)
  136. {
  137.         m_scopeOuterMax = outermax;
  138.         m_scopeOuterMin = outermin;
  139.         m_scopeInnerMax = innermax;
  140.         m_scopeInnerMin = innermin;
  141.         m_scopeCurMax = m_scopeInnerMax;
  142.         m_scopeCurMin = m_scopeInnerMin;
  143. }
  144.  
  145. //--------------------------------------------------------------------------------
  146.  
  147. void CDebugHistory::SetupScopeExtent(float outermin, float outermax)
  148. {
  149.         m_scopeOuterMax = outermax;
  150.         m_scopeOuterMin = outermin;
  151.         m_scopeInnerMax = outermin;
  152.         m_scopeInnerMin = outermax;
  153.         m_scopeCurMax = m_scopeInnerMax;
  154.         m_scopeCurMin = m_scopeInnerMin;
  155. }
  156.  
  157. //--------------------------------------------------------------------------------
  158.  
  159. void CDebugHistory::SetupColors(ColorF curvenormal, ColorF curveclamped, ColorF box, ColorF gridline, ColorF gridnumber, ColorF name)
  160. {
  161.         m_colorCurveNormal = curvenormal;
  162.         m_colorCurveClamped = curveclamped;
  163.         m_colorBox = box;
  164.         m_colorGridLine = gridline;
  165.         m_colorGridNumber = gridnumber;
  166.         m_colorName = name;
  167. }
  168. void CDebugHistory::SetGridlineCount(int nGridlinesX, int nGridlinesY)
  169. {
  170.         m_wantedGridLineCountX = nGridlinesX + 1;
  171.         m_wantedGridLineCountY = nGridlinesY + 1;
  172. }
  173.  
  174. //--------------------------------------------------------------------------------
  175.  
  176. void CDebugHistory::ClearHistory()
  177. {
  178.         m_head = 0;
  179.         m_count = 0;
  180.         m_scopeCurMax = m_scopeInnerMax;
  181.         m_scopeCurMin = m_scopeInnerMin;
  182. }
  183.  
  184. //--------------------------------------------------------------------------------
  185.  
  186. void CDebugHistory::AddValue(float value)
  187. {
  188.         if (m_pValues == NULL)
  189.                 return;
  190.  
  191.         // Store value in history
  192.         m_head = (m_head + 1) % m_maxCount;
  193.         m_pValues[m_head] = value;
  194.         if (m_count < m_maxCount)
  195.                 m_count++;
  196.  
  197.         if (m_scopeRefreshDelay == 0)
  198.         {
  199.                 UpdateExtent();
  200.  
  201.                 static int delay = 1;
  202.                 m_scopeRefreshDelay = delay;
  203.         }
  204.         else
  205.         {
  206.                 m_scopeRefreshDelay--;
  207.         }
  208.  
  209.         if (m_gridRefreshDelay == 0)
  210.         {
  211.                 UpdateGridLines();
  212.                 static int delay = 5;
  213.                 m_gridRefreshDelay = delay;
  214.         }
  215.         else
  216.         {
  217.                 m_gridRefreshDelay--;
  218.         }
  219. }
  220.  
  221. //--------------------------------------------------------------------------------
  222.  
  223. void CDebugHistory::UpdateExtent()
  224. {
  225.         m_scopeCurMax = m_scopeInnerMax;
  226.         m_scopeCurMin = m_scopeInnerMin;
  227.  
  228.         for (int i = 0; i < m_count; ++i)
  229.         {
  230.                 int j = (m_head - i + m_maxCount) % m_maxCount;
  231.                 float value = m_pValues[j];
  232.                 if (value < m_scopeCurMin)
  233.                 {
  234.                         m_scopeCurMin = value;
  235.                         if (m_scopeCurMin < m_scopeOuterMin)
  236.                         {
  237.                                 m_scopeCurMin = m_scopeOuterMin;
  238.                         }
  239.                 }
  240.                 if (value > m_scopeCurMax)
  241.                 {
  242.                         m_scopeCurMax = value;
  243.                         if (m_scopeCurMax > m_scopeOuterMax)
  244.                         {
  245.                                 m_scopeCurMax = m_scopeOuterMax;
  246.                         }
  247.                 }
  248.         }
  249.         if (abs(m_scopeCurMax - m_scopeCurMin) < 0.0005f)
  250.         {
  251.                 float scopeCurMid = 0.5f * (m_scopeCurMin + m_scopeCurMax);
  252.                 m_scopeCurMin = max(scopeCurMid - 0.001f, m_scopeOuterMin);
  253.                 m_scopeCurMax = min(scopeCurMid + 0.001f, m_scopeOuterMax);
  254.         }
  255. }
  256.  
  257. //--------------------------------------------------------------------------------
  258.  
  259. void CDebugHistory::UpdateGridLines()
  260. {
  261.         if ((m_colorGridLine.a == 0.0f) || (m_colorGridNumber.a == 0.0f))
  262.                 return;
  263.  
  264.         float scopeCurSpan = (m_scopeCurMax - m_scopeCurMin);
  265.         if (scopeCurSpan == 0.0f)
  266.                 return;
  267.  
  268.         m_gridLineCount = 2;
  269.         m_gridLine[0] = m_scopeCurMin;
  270.         m_gridLine[1] = m_scopeCurMax;
  271.  
  272.         const uint8 HISTOGRAM_SLOTS = 50;
  273.         uint16 histogramCount[HISTOGRAM_SLOTS];
  274.         float histogramSum[HISTOGRAM_SLOTS];
  275.  
  276.         for (int s = 0; s < HISTOGRAM_SLOTS; ++s)
  277.         {
  278.                 histogramCount[s] = 0;
  279.                 histogramSum[s] = 0.0f;
  280.         }
  281.         for (int i = 0; i < m_count; ++i)
  282.         {
  283.                 int j = (m_head - i + m_maxCount) % m_maxCount;
  284.                 float v = m_pValues[j];
  285.                 int s = (int)((float)(HISTOGRAM_SLOTS - 1) * ((v - m_scopeCurMin) / scopeCurSpan));
  286.                 s = max(0, min(HISTOGRAM_SLOTS - 1, s));
  287.                 histogramSum[s] += v;
  288.                 histogramCount[s]++;
  289.         }
  290.  
  291.         for (int s = 0; s < HISTOGRAM_SLOTS; ++s)
  292.         {
  293.                 float count = (float)histogramCount[s];
  294.                 if (count > 0.0f)
  295.                         histogramSum[s] /= count;
  296.                 else
  297.                         histogramSum[s] = 0.0f;
  298.         }
  299.  
  300.         static int minThresholdMul = 1;
  301.         static int minThresholdDiv = 4;
  302.         int minThreshold = ((m_maxCount / (GRIDLINE_MAXCOUNT - 2)) * minThresholdMul) / minThresholdDiv;
  303.         for (int i = 0; i < GRIDLINE_MAXCOUNT; ++i)
  304.         {
  305.                 int highest = -1;
  306.                 for (int s = 0; s < HISTOGRAM_SLOTS; ++s)
  307.                 {
  308.                         if (((highest == -1) || (histogramCount[s] > histogramCount[highest])) &&
  309.                             (histogramCount[s] > minThreshold))
  310.                         {
  311.                                 bool uniqueEnough = true;
  312.                                 static float minSpacing = 1.0f / 8.0f; // percent of whole extent, TODO: should be based on font size versus layout height
  313.                                 float deltaThreshold = minSpacing * (m_scopeCurMax - m_scopeCurMin);
  314.                                 for (int j = 0; j < m_gridLineCount; ++j)
  315.                                 {
  316.                                         float delta = abs(histogramSum[s] - m_gridLine[j]);
  317.                                         if (delta < deltaThreshold)
  318.                                         {
  319.                                                 uniqueEnough = false;
  320.                                                 break;
  321.                                         }
  322.                                 }
  323.                                 if (uniqueEnough)
  324.                                 {
  325.                                         highest = s;
  326.                                 }
  327.                         }
  328.                 }
  329.  
  330.                 if (highest != -1)
  331.                 {
  332.                         histogramCount[highest] = 0;
  333.                         m_gridLine[m_gridLineCount] = histogramSum[highest];
  334.                         m_gridLineCount++;
  335.                 }
  336.         }
  337.  
  338.         m_gotValue = true;
  339. }
  340.  
  341. //--------------------------------------------------------------------------------
  342.  
  343. void CDebugHistory::Render()
  344. {
  345.         if (!m_show)
  346.                 return;
  347.  
  348.         if (!m_gotValue && m_hasDefaultValue)
  349.                 AddValue(m_defaultValue);
  350.         m_gotValue = false;
  351.  
  352.         if (m_colorBox.a > 0.0f)
  353.         {
  354.                 float x1 = m_layoutTopLeft.x;
  355.                 float y1 = m_layoutTopLeft.y;
  356.                 float x2 = m_layoutTopLeft.x + m_layoutExtent.x;
  357.                 float y2 = m_layoutTopLeft.y + m_layoutExtent.y;
  358.  
  359.                 Draw2DLine(x1, y1, x2, y1, m_colorBox);
  360.                 Draw2DLine(x1, y2, x2, y2, m_colorBox);
  361.                 Draw2DLine(x1, y1, x1, y2, m_colorBox);
  362.                 Draw2DLine(x2, y1, x2, y2, m_colorBox);
  363.         }
  364.  
  365.         float scopeExtent = (m_scopeCurMax - m_scopeCurMin);
  366.  
  367.         if (m_colorGridLine.a > 0.0f)
  368.         {
  369.                 float x1 = m_layoutTopLeft.x;
  370.                 float y1 = m_layoutTopLeft.y + m_layoutMargin;
  371.                 float x2 = m_layoutTopLeft.x + m_layoutExtent.x;
  372.                 float y2 = m_layoutTopLeft.y + m_layoutExtent.y - m_layoutMargin * 2.0f;
  373.  
  374.                 for (int i = 0; i < m_gridLineCount; i++)
  375.                 {
  376.                         float y = m_gridLine[i];
  377.                         float scopefractiony = (scopeExtent != 0.0f) ? (y - m_scopeCurMin) / scopeExtent : 0.5f;
  378.                         float screeny = LERP(y2, y1, scopefractiony);
  379.                         Draw2DLine(x1, screeny, x2, screeny, m_colorGridLine);
  380.                 }
  381.  
  382.                 for (int i = 1; i < m_wantedGridLineCountX; i++)
  383.                 {
  384.                         float scopefractionx = (float)i / (float)m_wantedGridLineCountX;
  385.                         float screenx = LERP(x2, x1, scopefractionx);
  386.                         Draw2DLine(screenx, y1, screenx, y2, m_colorGridLine);
  387.                 }
  388.                 for (int i = 1; i < m_wantedGridLineCountY; i++)
  389.                 {
  390.                         float scopefractiony = (float)i / (float)m_wantedGridLineCountY;
  391.                         float screeny = LERP(y2, y1, scopefractiony);
  392.                         Draw2DLine(x1, screeny, x2, screeny, m_colorGridLine);
  393.                 }
  394.         }
  395.  
  396.         if (m_colorGridNumber.a > 0.0f)
  397.         {
  398.                 float x1 = m_layoutTopLeft.x;
  399.                 float y1 = m_layoutTopLeft.y + m_layoutMargin;
  400.                 //              float x2 = m_layoutTopLeft.x + m_layoutExtent.x;
  401.                 float y2 = m_layoutTopLeft.y + m_layoutExtent.y - m_layoutMargin * 2.0f;
  402.  
  403.                 char* gridNumberPrecision = "%f";
  404.                 if (scopeExtent >= 100.0f)
  405.                 {
  406.                         gridNumberPrecision = "%.0f";
  407.                 }
  408.                 else if (scopeExtent >= 10.0f)
  409.                 {
  410.                         gridNumberPrecision = "%.1f";
  411.                 }
  412.                 else if (scopeExtent >= 1.0f)
  413.                 {
  414.                         gridNumberPrecision = "%.2f";
  415.                 }
  416.                 else if (scopeExtent > 0.1f)
  417.                 {
  418.                         gridNumberPrecision = "%.3f";
  419.                 }
  420.                 else if (scopeExtent < 0.1f)
  421.                 {
  422.                         gridNumberPrecision = "%.4f";
  423.                 }
  424.  
  425.                 for (int i = 0; i < m_gridLineCount; i++)
  426.                 {
  427.                         static float offsety = -7; // should be based on font size
  428.                         static float offsetx = 30; // should be based on font size
  429.                         float y = m_gridLine[i];
  430.                         float scopefractiony = (scopeExtent != 0.0f) ? (y - m_scopeCurMin) / scopeExtent : 0.5f;
  431.                         static float slots = 8.0f; // TODO: should be based on font size versus layout height
  432.                         float x = x1 + offsetx * (float)((uint8)(scopefractiony * (slots - 1.0f)) & 1);
  433.                         float screeny = LERP(y2, y1, scopefractiony);
  434.  
  435.                         CryFixedStringT<32> label;
  436.                         label.Format(gridNumberPrecision, y);
  437.  
  438.                         IRenderAuxText::DrawText(Vec3(x, screeny + offsety, 0.5f), 1.4f, m_colorGridNumber, eDrawText_2D | eDrawText_800x600 | eDrawText_FixedSize | eDrawText_IgnoreOverscan, label.c_str());
  439.                 }
  440.         }
  441.  
  442.         if (m_colorCurveNormal.a > 0.0f)
  443.         {
  444.                 float x1 = m_layoutTopLeft.x;
  445.                 float y1 = m_layoutTopLeft.y + m_layoutMargin;
  446.                 float x2 = m_layoutTopLeft.x + m_layoutExtent.x;
  447.                 float y2 = m_layoutTopLeft.y + m_layoutExtent.y - m_layoutMargin * 2.0f;
  448.  
  449.                 float prevscreenx = 0.0f;
  450.                 float prevscreeny = 0.0f;
  451.  
  452.                 for (int i = 0; i < m_count; i++)
  453.                 {
  454.                         int j = (m_head - i + m_maxCount) % m_maxCount;
  455.                         float y = m_pValues[j];
  456.                         float scopefractiony = (scopeExtent != 0.0f) ? (y - m_scopeCurMin) / scopeExtent : 0.5f;
  457.                         float screeny = LERP(y2, y1, scopefractiony);
  458.                         float scopefractionx = (float)i / (float)m_maxCount;
  459.                         float screenx = LERP(x2, x1, scopefractionx);
  460.  
  461.                         if (i > 0)
  462.                         {
  463.                                 Draw2DLine(screenx, screeny, prevscreenx, prevscreeny, m_colorCurveNormal);
  464.                         }
  465.  
  466.                         prevscreenx = screenx;
  467.                         prevscreeny = screeny;
  468.                 }
  469.         }
  470.  
  471.         if (m_colorName.a > 0.0f)
  472.         {
  473.                 const int offsety = -12;
  474.  
  475.                 IRenderAuxText::DrawText(Vec3(m_layoutTopLeft.x + 0.5f * m_layoutExtent.x, m_layoutTopLeft.y + offsety, 0.5f), 1.2f, m_colorName, eDrawText_2D | eDrawText_800x600 | eDrawText_FixedSize | eDrawText_Center | eDrawText_IgnoreOverscan, m_szName);
  476.         }
  477. }
  478.  
  479. //--------------------------------------------------------------------------------
  480. IDebugHistory* CDebugHistoryManager::CreateHistory(const char* id, const char* name)
  481. {
  482.         if (!name)
  483.                 name = id;
  484.  
  485.         MapIterator it = m_histories.find(CONST_TEMP_STRING(id));
  486.         CDebugHistory* history = (it != m_histories.end()) ? (*it).second : NULL;
  487.         if (history == NULL)
  488.         {
  489.                 history = new CDebugHistory(name, 100);
  490.                 m_histories.insert(std::make_pair(id, history));
  491.         }
  492.  
  493.         return history;
  494. }
  495.  
  496. //--------------------------------------------------------------------------------
  497.  
  498. void CDebugHistoryManager::RemoveHistory(const char* id)
  499. {
  500.         MapIterator it = m_histories.find(CONST_TEMP_STRING(id));
  501.         if (it != m_histories.end())
  502.         {
  503.                 delete it->second;
  504.                 m_histories.erase(it);
  505.         }
  506. }
  507.  
  508. //--------------------------------------------------------------------------------
  509.  
  510. IDebugHistory* CDebugHistoryManager::GetHistory(const char* id)
  511. {
  512.         MapIterator it = m_histories.find(CONST_TEMP_STRING(id));
  513.         CDebugHistory* history = (it != m_histories.end()) ? (*it).second : NULL;
  514.         return history;
  515. }
  516.  
  517. //--------------------------------------------------------------------------------
  518.  
  519. void CDebugHistoryManager::Render(bool bSetupRenderer)
  520. {
  521.         if (m_histories.empty())
  522.                 return;
  523.  
  524.         FUNCTION_PROFILER(GetISystem(), PROFILE_ACTION);
  525.  
  526.         if (bSetupRenderer)
  527.                 CDebugHistoryManager::SetupRenderer();
  528.  
  529.         MapIterator it = m_histories.begin();
  530.         while (it != m_histories.end())
  531.         {
  532.                 CDebugHistory* history = (*it).second;
  533.                 history->Render();
  534.  
  535.                 ++it;
  536.         }
  537. }
  538.  
  539. //--------------------------------------------------------------------------------
  540.  
  541. void CDebugHistoryManager::Release()
  542. {
  543.         delete this;
  544. }
  545.  
  546. //--------------------------------------------------------------------------------
  547.  
  548. void CDebugHistoryManager::GetMemoryUsage(ICrySizer* s) const
  549. {
  550.         s->AddContainer(m_histories);
  551.         s->Add(*this);
  552. }
  553.  
  554. //--------------------------------------------------------------------------------
  555.  
  556. void CDebugHistoryManager::SetupRenderer()
  557. {
  558.         gEnv->pRenderer->SetMaterialColor(1, 1, 1, 1);
  559.         int screenw = gEnv->pRenderer->GetWidth();
  560.         int screenh = gEnv->pRenderer->GetHeight();
  561.  
  562.         IRenderAuxGeom* pAux = gEnv->pRenderer->GetIRenderAuxGeom();
  563.         SAuxGeomRenderFlags flags = pAux->GetRenderFlags();
  564.         flags.SetMode2D3DFlag(e_Mode2D);
  565.         pAux->SetRenderFlags(flags);
  566. }
  567.  
  568. //--------------------------------------------------------------------------------
  569.  
  570. void CDebugHistoryManager::RenderAll()
  571. {
  572.         if (g_currentlyVisibleCount == 0)
  573.                 return;
  574.  
  575.         if (m_allhistory)
  576.         {
  577.                 SetupRenderer();
  578.                 for (std::set<CDebugHistoryManager*>::iterator iter = m_allhistory->begin(); iter != m_allhistory->end(); ++iter)
  579.                         (*iter)->Render(false);
  580.         }
  581. }
  582.  
  583. //--------------------------------------------------------------------------------
  584.  
  585. void CDebugHistoryManager::LayoutHelper(const char* id, const char* name, bool visible, float minout, float maxout, float minin, float maxin, float x, float y, float w /*=1.0f*/, float h /*=1.0f*/)
  586. {
  587.         if (!visible)
  588.         {
  589.                 this->RemoveHistory(id);
  590.                 return;
  591.         }
  592.  
  593.         IDebugHistory* pDH = this->GetHistory(id);
  594.         if (pDH != NULL)
  595.                 return;
  596.  
  597.         if (name == NULL)
  598.                 name = id;
  599.  
  600.         pDH = this->CreateHistory(id, name);
  601.         pDH->SetupScopeExtent(minout, maxout, minin, maxin);
  602.         pDH->SetVisibility(true);
  603.  
  604.         static float x0 = 0.01f;
  605.         static float y0 = 0.05f;
  606.         static float x1 = 0.99f;
  607.         static float y1 = 1.00f;
  608.         static float dx = x1 - x0;
  609.         static float dy = y1 - y0;
  610.         static float xtiles = 6.0f;
  611.         static float ytiles = 4.0f;
  612.         pDH->SetupLayoutRel(x0 + dx * x / xtiles,
  613.                             y0 + dy * y / ytiles,
  614.                             dx * w * 0.95f / xtiles,
  615.                             dy * h * 0.93f / ytiles,
  616.                             dy * 0.02f / ytiles);
  617. }
  618.  
  619. //--------------------------------------------------------------------------------
  620.  
downloadDebugHistory.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