InspectorGuiRenderer.cpp

#include "InspectorGuiRenderer.h"
 
#include "imgui.h"
#include "imgui_internal.h"
 
#include "Context.h"
#include "Engine.h"
 
#include "Renderer/IRenderer.h"
 
#include "Editor/IEditor.h"
 
#include "InspectorGuiHelper.h"
#include "EntityInspector.h"
#include "Inspectors.h"
#include "Platform/Instrumentation.h"
#include "Services/QualityService.h"
 
#ifdef COGS_USE_MICROPROFILE
#include <microprofileui.h>
#endif
 
void Cogs::Core::InspectorGuiRenderer::initialize(Context * /*context*/, IRenderer* renderer)
{
  imguiRenderer = renderer->getGuiRenderer();
  imguiContext = imguiRenderer->createGuiContext();
 
#ifdef COGS_USE_MICROPROFILE
  MicroProfileInitUI();
 
  auto & profiler = *MicroProfileGet();
  profiler.nDisplay = MP_DRAW_DETAILED;
  profiler.nAllGroupsWanted = 1;
#endif
}
 
void Cogs::Core::InspectorGuiRenderer::registerInspector(const std::string& name, Inspector inspector)
{
  inspectors.emplace_back(RegisteredInspector{ name, inspector, false });
}
 
void Cogs::Core::InspectorGuiRenderer::beginRender(Context* context, IRenderer* renderer)
{
  RenderInstrumentationScope(renderer->getDevice()->getImmediateContext(), SCOPE_RENDERING, "GuiRenderer::beginRender");
 
  imguiRenderer->frame(imguiContext, *context->getDefaultView());
  imguiRenderer->style();
}
 
void Cogs::Core::InspectorGuiRenderer::renderTimes(Context * context)
{
  QualityService* quality = context->qualityService.get();
 
  // double n = nowToSeconds(Cogs::now()-nowReference());
  // double c = currentTimeToSeconds(Cogs::currentTime()-currentTimeReference());
  // ImGui::Text("now %f currentTime %f", n, c);
 
  size_t timesCount = quality->TIMES_COUNT;
 
  ImU32 CpuTimeColor = IM_COL32(255, 50, 50, 255);
  ImU32 PreRenderColor = IM_COL32(0, 128, 0, 255);
  ImU32 PresentColor = IM_COL32(255, 255, 50, 255);
  ImU32 IdleColor = IM_COL32(0, 127, 255, 255);
 
  float dt = static_cast<float>(delta_timer.elapsedSeconds());
  delta_timer = Timer::startNew();
  delta_akk += dt;
  if(delta_akk > delta_update){
    cogsTime = quality->getMetric(MetricType::Frame)*1000.0f;
    idleTime = quality->getMetric(MetricType::Idle)*1000.0f;
    frameTime = cogsTime+idleTime;
    preRenderTime = quality->getMetric(MetricType::PreRender)*1000.0f;
    presentTime = quality->getMetric(MetricType::Present)*1000.0f;
    cpuTime = cogsTime-presentTime;
    cogsFPS = 1000.0f/cogsTime;
    frameFPS = 1000.0f/frameTime;
    cpuFps = 1000.0f/cpuTime;
    delta_akk = 0.0f;
  }
 
  frameMax = std::max(frameMax, frameTime);
  frameMin = std::min(frameMin, frameTime);
 
  cogsMax = std::max(cogsMax, cogsTime);
  cogsMin = std::min(cogsMin, cogsTime);
 
  static std::vector<float> scales = { 10.0f, 16.67f, 33.33f, 100.0f };
 
  float scale = scales.front();
  for (auto & s : scales) {
    if (frameMax < scale) {
      break;
    } else if (frameMax > scale && frameMax < s) {
      scale = s;
      break;
    } else {
      scale = s;
    }
  }
  scale /= 1000.0f;
 
  ImGui::Text("Frame: %.3fms Max: %.3fms (%.2f FPS)", frameTime, frameMax, frameFPS);
  ImGui::Text("Cogs: %.3fms Max: %.3fms (%.2f FPS)", cogsTime, cogsMax, cogsFPS);
  ImGui::TextColored(ImColor(PreRenderColor), "PreRender: %.3fms", preRenderTime);
  ImGui::SameLine();
  ImGui::TextColored(ImColor(CpuTimeColor), "CPU: %.3fms (%.2f FPS)", cpuTime, cpuFps);
  ImGui::TextColored(ImColor(PresentColor), "Present: %.3fms", presentTime);
  ImGui::SameLine();
  ImGui::TextColored(ImColor(IdleColor), "Idle: %.3fms", idleTime);
 
  {
    ImVec2 canvas_p0 = ImGui::GetCursorScreenPos();
    ImVec2 canvas_sz = ImGui::GetContentRegionAvail();
    if (canvas_sz.x < 50.0f) canvas_sz.x = 50.0f;
    canvas_sz.y = 140.0f;
    ImVec2 canvas_p1 = ImVec2(canvas_p0.x + canvas_sz.x, canvas_p0.y + canvas_sz.y);
 
    ImGui::PushClipRect(canvas_p0, canvas_p1, true);
 
    ImDrawList *draw_list = ImGui::GetWindowDrawList();
    draw_list->AddRectFilled(canvas_p0, canvas_p1, IM_COL32(50, 50, 50, 255));
 
    ImGui::InvisibleButton("canvas", canvas_sz, ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight);
    // const bool is_hovered = ImGui::IsItemHovered(); // Hovered
    // Cpu Time
    for(size_t i=0; i<timesCount; i++){
      size_t idx = (quality->times_idx+quality->TIMES_COUNT-i)%quality->TIMES_COUNT;
      float x0 = (float)i/timesCount;
      float x1 = (float)(i+1)/timesCount;
      float y0 = quality->times[idx][(size_t)MetricType::Frame]/scale;
      ImVec2 pos0(canvas_p0.x+x0*canvas_sz.x, canvas_p0.y+canvas_sz.y*(1.0f-y0));
      ImVec2 pos1(canvas_p0.x+x1*canvas_sz.x, canvas_p1.y);
      draw_list->AddRectFilled(pos0, pos1, CpuTimeColor);
    }
    // Pre-Render
    for(size_t i=0; i<timesCount; i++){
      size_t idx = (quality->times_idx+quality->TIMES_COUNT-i)%quality->TIMES_COUNT;
      float x0 = (float)i/timesCount;
      float x1 = (float)(i+1)/timesCount;
      float y0 = quality->times[idx][(size_t)MetricType::PreRender]/scale;
      float y1 = 0.0f;
      ImVec2 pos0(canvas_p0.x+x0*canvas_sz.x, canvas_p0.y+canvas_sz.y*(1.0f-y0));
      ImVec2 pos1(canvas_p0.x+x1*canvas_sz.x, canvas_p0.y+canvas_sz.y*(1.0f-y1));
      draw_list->AddRectFilled(pos0, pos1, PreRenderColor);
    }
    // Present
    for(size_t i=0; i<timesCount; i++){
      size_t idx = (quality->times_idx+quality->TIMES_COUNT-i)%quality->TIMES_COUNT;
      float x0 = (float)i/timesCount;
      float x1 = (float)(i+1)/timesCount;
      float y0 = quality->times[idx][(size_t)MetricType::Frame]/scale;
      float y1 = (quality->times[idx][(size_t)MetricType::Frame]-quality->times[idx][(size_t)MetricType::Present])/scale;
      ImVec2 pos0(canvas_p0.x+x0*canvas_sz.x, canvas_p0.y+canvas_sz.y*(1.0f-y0));
      ImVec2 pos1(canvas_p0.x+x1*canvas_sz.x, canvas_p0.y+canvas_sz.y*(1.0f-y1));
      draw_list->AddRectFilled(pos0, pos1, PresentColor);
    }
    // Idle
    for(size_t i=0; i<timesCount; i++){
      size_t idx = (quality->times_idx+quality->TIMES_COUNT-i)%quality->TIMES_COUNT;
      float x0 = (float)i/timesCount;
      float x1 = (float)(i+1)/timesCount;
      float y0 = (quality->times[idx][(size_t)MetricType::Frame]+quality->times[idx][(size_t)MetricType::Idle])/scale;
      float y1 = quality->times[idx][(size_t)MetricType::Frame]/scale;
      ImVec2 pos0(canvas_p0.x+x0*canvas_sz.x, canvas_p0.y+canvas_sz.y*(1.0f-y0));
      ImVec2 pos1(canvas_p0.x+x1*canvas_sz.x, canvas_p0.y+canvas_sz.y*(1.0f-y1));
      draw_list->AddRectFilled(pos0, pos1, IdleColor);
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetNextWindowBgAlpha(0.7f);
      ImGui::BeginTooltip();
      ImVec2 cpos =ImGui::GetMousePos();
      ImVec2 rpos = cpos - canvas_p0;
      ImVec2 npos = rpos / canvas_sz;
      int i = (int)(npos.x * timesCount);
      i = std::max(i, 0);
      i = std::min(i, (int)timesCount-1);
      size_t idx = (quality->times_idx+quality->TIMES_COUNT-i)%quality->TIMES_COUNT;
      ImGui::Text("(%d, %.3fms)", i, (1.0f-npos.y)*scale);
      ImGui::Text("%.3fms", quality->times[idx][(size_t)MetricType::Frame]*1000);
 
      ImGui::TextColored(ImColor(PreRenderColor), "%.3fms", quality->times[idx][(size_t)MetricType::PreRender]*1000);
      ImGui::SameLine();
      ImGui::TextColored(ImColor(CpuTimeColor), "%.3fms", (quality->times[idx][(size_t)MetricType::Frame]-
                                                           quality->times[idx][(size_t)MetricType::Present])*1000);
      ImGui::TextColored(ImColor(PresentColor), "%.3fms", quality->times[idx][(size_t)MetricType::Present]*1000);
      ImGui::SameLine();
      ImGui::TextColored(ImColor(IdleColor), "%.3fms", quality->times[idx][(size_t)MetricType::Idle]*1000);
      ImGui::EndTooltip();
    }
 
    ImGui::PopClipRect();
  }
 
  // Upload statistics
  if(ImGui::TreeNode("Upload Statistics")){
    ImGui::BeginGroup();
    ImGui::Unindent();
    ImU32 BufferUploadColor = IM_COL32(0, 128, 0, 255);
    ImU32 TextureUploadColor = IM_COL32(255, 255, 50, 255);
 
    ImGui::TextColored(ImColor(BufferUploadColor), "Buffer Upload: %zu", quality->bufferUploadSize[(quality->times_idx+timesCount-1)%timesCount]);
    ImGui::SameLine();
    ImGui::TextColored(ImColor(TextureUploadColor), "Texture Upload: %zu", quality->textureUploadSize[(quality->times_idx+timesCount-1)%timesCount]);
 
    ImVec2 canvas_p0 = ImGui::GetCursorScreenPos();
    ImVec2 canvas_sz = ImGui::GetContentRegionAvail();
    if (canvas_sz.x < 50.0f) canvas_sz.x = 50.0f;
    canvas_sz.y = 140.0f;
    ImVec2 canvas_p1 = ImVec2(canvas_p0.x + canvas_sz.x, canvas_p0.y + canvas_sz.y);
    ImGui::PushClipRect(canvas_p0, canvas_p1, true);
 
    ImDrawList *draw_list = ImGui::GetWindowDrawList();
    draw_list->AddRectFilled(canvas_p0, canvas_p1, IM_COL32(50, 50, 50, 255));
 
    ImGui::InvisibleButton("canvas2", canvas_sz, ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight);
 
    float upload_scale = 1.0f/(1024.0f*1024.0f*64.0f);
 
    // Buffer Upload
    for(size_t i=0; i<timesCount; i++){
      size_t idx = (quality->times_idx+quality->TIMES_COUNT-i)%quality->TIMES_COUNT;
      float x0 = (float)i/timesCount;
      float x1 = (float)(i+1)/timesCount;
      float y0 = quality->bufferUploadSize[idx]*upload_scale;
      float y1 = 0.0f;
      ImVec2 pos0(canvas_p0.x+x0*canvas_sz.x, canvas_p0.y+canvas_sz.y*(1.0f-y0));
      ImVec2 pos1(canvas_p0.x+x1*canvas_sz.x, canvas_p0.y+canvas_sz.y*(1.0f-y1));
      draw_list->AddRectFilled(pos0, pos1, BufferUploadColor);
    }
    // Texture Upload
    for(size_t i=0; i<timesCount; i++){
      size_t idx = (quality->times_idx+quality->TIMES_COUNT-i)%quality->TIMES_COUNT;
      float x0 = (float)i/timesCount;
      float x1 = (float)(i+1)/timesCount;
      float y0 = (quality->bufferUploadSize[idx]+quality->textureUploadSize[idx])*upload_scale;
      float y1 = quality->bufferUploadSize[idx]*upload_scale;
      ImVec2 pos0(canvas_p0.x+x0*canvas_sz.x, canvas_p0.y+canvas_sz.y*(1.0f-y0));
      ImVec2 pos1(canvas_p0.x+x1*canvas_sz.x, canvas_p0.y+canvas_sz.y*(1.0f-y1));
      draw_list->AddRectFilled(pos0, pos1, TextureUploadColor);
    }
 
    if (ImGui::IsItemHovered()) {
      ImGui::SetNextWindowBgAlpha(0.7f);
      ImGui::BeginTooltip();
      ImVec2 cpos =ImGui::GetMousePos();
      ImVec2 rpos = cpos - canvas_p0;
      ImVec2 npos = rpos / canvas_sz;
      int i = (int)(npos.x * timesCount);
      i = std::max(i, 0);
      i = std::min(i, (int)timesCount-1);
      size_t idx = (quality->times_idx+quality->TIMES_COUNT-i)%quality->TIMES_COUNT;
      ImGui::TextColored(ImColor(BufferUploadColor), "%zu", quality->bufferUploadSize[idx]);
      ImGui::TextColored(ImColor(TextureUploadColor), "%zu", quality->textureUploadSize[idx]);
      ImGui::EndTooltip();
    }
 
    ImGui::PopClipRect();
    ImGui::EndGroup();
    ImGui::TreePop();
  }
 
  ImVec2 buttonSize(96, 24);
 
  if (ImGui::Button("Reset", buttonSize)) {
    frameMax = 0;
    frameMin = 10000;
    cogsMax = 0;
    cogsMin = 10000;
  }
  ImGui::SameLine();
  bool vSync = context->variables->get("renderer.vSync", false);
  if(ImGui::Checkbox("vSync", &vSync)){
    context->variables->set("renderer.vSync", vSync);
  }
  ImGui::SameLine();
  ImGui::Text("Scale Y %.3f", scale);
}
void Cogs::Core::InspectorGuiRenderer::render(Context * context, IRenderer * renderer)
{
  if (context->engine->getEditor() && context->engine->getEditor()->isActive()) {
    context->engine->getEditor()->show();
  }
 
  if (!context->variables->get("gui.enabled", false)) return;
 
  context->engine->triggerUpdate();
 
  RenderInstrumentationScope(renderer->getDevice()->getImmediateContext(), SCOPE_RENDERING, "GuiRenderer::render");
 
  struct VariableMap {
    StringView name;
    bool& toggle;
  } variableMapping[] = {
    { "gui.aboutCogs", showAboutCogs },
    { "gui.renderingStatsInspector", showRenderingStatsInspector },
    { "gui.textureInspector", showTextureInspector },
    { "gui.shadowMapInspector", showShadowMapInspector },
    { "gui.entityInspector", showEntityInspector },
    { "gui.fontInspector", showFontInspector },
    { "gui.variableInspector", showVariableInspector },
    { "gui.inputInspector", showInputInspector },
    { "gui.modelInspector", showModelInspector },
    { "gui.meshInspector", showMeshInspector },
    { "gui.materialInspector", showMaterialInspector },
    { "gui.materialInstanceInspector", showMaterialInstanceInspector },
    { "gui.resourceInspector", showResourceInspector },
    { "gui.scriptInspector", showScriptInspector },
    { "gui.scriptConsole", showScriptConsole },
    { "gui.profiler", showProfiler },
    { "gui.pipelineInspector", showPipelineInspector },
    { "gui.permutationInspector", showPermutationInspector },
    { "gui.assetInspector", showAssetInspector },
    { "gui.assetQueueInspector", showAssetQueueInspector },
    { "gui.boundsInspector", showBoundsInspector },
    { "gui.bufferInspector", showBufferInspector },
    { "gui.engineInspector", showEngineInspector },
    { "gui.exampleGui", showExampleGui },
    { "gui.gammaDebugger", showGammaDebugger },
    { "gui.showWebGPUCountersInspector", showWebGPUCountersInspector }
  };
 
  for (const VariableMap variableMap : variableMapping) {
    if (Variable* var = context->variables->getIfExists(variableMap.name); var != nullptr && !var->isEmpty()) {
      variableMap.toggle = var->getBool();
    }
  }
 
  bool show = true;
  if(ImGui::Begin("Engine", &show, ImGuiWindowFlags_MenuBar)){
    // MenuBar
    if (ImGui::BeginMenuBar()) {
      if (ImGui::BeginMenu("View")) {
        struct Button
        {
          const char * title;
          bool & toggle;
        } buttons[] = {
          { "Asset Queue", showAssetQueueInspector },
          { "Assets", showAssetInspector },
          { "Buffers", showBufferInspector },
          { "Console", showScriptConsole },
          { "Entities", showEntityInspector },
          { "Fonts", showFontInspector },
          { "Inputs", showInputInspector },
          { "Materials", showMaterialInspector },
          { "Material Instances", showMaterialInstanceInspector },
          { "Meshes", showMeshInspector},
          { "Models", showModelInspector},
          { "Render Pipeline", showPipelineInspector },
          { "Permutations", showPermutationInspector },
          { "Resources", showResourceInspector },
          { "Textures", showTextureInspector },
          { "Variables", showVariableInspector },
          { "ImGui Examples", showExampleGui},
          //{ nullptr, none },
        };
        for (size_t i = 0; i < glm::countof(buttons); ++i) {
          if (!buttons[i].title) continue;
          if (ImGui::MenuItem(buttons[i].title)) {
            buttons[i].toggle = !buttons[i].toggle;
          }
        }
        ImGui::EndMenu();
      }
      if (ImGui::BeginMenu("Debuggers")) {
        struct Button
        {
          const char * title;
          bool & toggle;
        } buttons[] = {
          { "Bounds", showBoundsInspector },
          { "Engine Statistics", showEngineInspector },
          { "Task Manager Statistics", showTaskManagerInspector },
          { "GammaDebugger", showGammaDebugger },
          { "Performance", showRenderingStatsInspector },
          { "Profiler", showProfiler },
          { "Shadow maps", showShadowMapInspector },
          { "WebGPU Counters", showWebGPUCountersInspector }
          //{ nullptr, none },
        };
        for (size_t i = 0; i < glm::countof(buttons); ++i) {
          if (!buttons[i].title) continue;
          if (ImGui::MenuItem(buttons[i].title)) {
            buttons[i].toggle = !buttons[i].toggle;
          }
        }
        ImGui::EndMenu();
      }
      if (inspectors.size() && ImGui::BeginMenu("Extensions")) {
        for (auto & inspector : inspectors) {
          if (ImGui::MenuItem(inspector.name.c_str())) {
            inspector.show = !inspector.show;
          }
        }
        ImGui::EndMenu();
      }
      if (ImGui::BeginMenu("Help")) {
        struct Button
        {
          const char * title;
          bool & toggle;
        } buttons[] = {
          { "About", showAboutCogs },
          //{ nullptr, none },
        };
        for (size_t i = 0; i < glm::countof(buttons); ++i) {
          if (!buttons[i].title) continue;
          if (ImGui::MenuItem(buttons[i].title)) {
            buttons[i].toggle = !buttons[i].toggle;
          }
        }
        ImGui::EndMenu();
      }
      ImGui::EndMenuBar();
    }
 
    renderTimes(context);
 
    // Combo box with various visualization modes
    {
      struct {
        const char* name;
        const char* pipeline;
      } visualizationModes[] = {
        { "No visualizer",        "" },
        { "Show normals",         "Pipelines/DebugView/ShowNormals.pipeline" },
        { "Show draw calls",      "Pipelines/DebugView/ShowDrawCalls.pipeline" },
        { "Show object IDs",      "Pipelines/DebugView/ShowObjectIDs.pipeline" },
        { "Show triangle size",   "Pipelines/DebugView/ShowTriangleSizes.pipeline" },
        { "Show shadow cascades", "Pipelines/DebugView/ShowShadowCascades.pipeline" }
      };
      if (ImGui::BeginCombo("##combo", visualizationModes[visualizationMode].name)) {
        for (size_t i = 0; i < IM_ARRAYSIZE(visualizationModes); i++) {
          bool selected = i == visualizationMode;
          if (ImGui::Selectable(visualizationModes[i].name, selected)) {
            visualizationMode = static_cast<uint8_t>(i);
            context->variables->set("renderer.pipeline.override", visualizationModes[i].pipeline);
          }
          if (selected) {
            ImGui::SetItemDefaultFocus();
          }
        }
        ImGui::EndCombo();
      }
 
      // Options for all visualizers
      if (visualizationMode != 0) {
        float edge = std::pow(context->variables->get("debugView.edge", 0.5f), 2.2f);
        if (ImGui::SliderFloat("Wireframe", &edge, 0.f, 1.f, "%.3f")) {
          context->variables->set("debugView.edge", std::pow(edge, 1.f / 2.2f));
        }
        float outline = std::pow(context->variables->get("debugView.outline", 1.0f), 2.2f);
        if (ImGui::SliderFloat("Outline", &outline, 0.f, 1.f, "%.3f")) {
          context->variables->set("debugView.outline", std::pow(outline, 1.f / 2.2f));
        }
      }
 
      // Options for triangle size
      if (visualizationMode == 4) {
        float lo = context->variables->get("debugView.triangleSize.lo", 10.f);
        float hi = context->variables->get("debugView.triangleSize.hi", 100.f);
        bool update = false;
        if (ImGui::SliderFloat("Yellow size", &lo, 1.f, 100.f, "%.1f")) {
          update = true;
        }
        if (ImGui::SliderFloat("Green size", &hi, 1.f, 100.f, "%.1f")) {
          lo = std::max(1.f, std::min(lo, hi - 1.f));
          update = true;
        }
        hi = std::max(lo + 1.f, hi);
        if (update) {
          context->variables->set("debugView.triangleSize.lo", lo);
          context->variables->set("debugView.triangleSize.hi", hi);
        }
      }
    }
 
    {
      QualityService* quality = context->qualityService.get();
      float qualitySetting = context->variables->get("quality.setting", 100.f);
      if (ImGui::SliderFloat("##Quality", &qualitySetting, 0.f, 200.f, "quality %.0f%%")) {
        context->variables->set("quality.setting", qualitySetting);
      }
      ImGui::Text("Current quality: %.2f, AssetSystem: %.2f",
                  quality->currentQuality,
                  quality->assetSystemToleranceScale);
      ImGui::Text("PoTreeSystem: %.2f/%.2f, 3DTilesSystem: %.2f/%.2f",
        quality->potreeSystemToleranceScale,
        quality->potreeSystemChunkCountScale,
        quality->ogc3DTilesSystemCacheControl,
        quality->ogc3DTilesSystemToleranceScale);
    }
    ImGui::Spacing();
 
    struct Button
    {
      const char * title;
      bool & toggle;
    } buttons[] = {
      { "Entities", showEntityInspector },
      { "Variables", showVariableInspector },
    };
    ImVec2 buttonSize(96, 24);
 
    for (size_t i = 0; i < glm::countof(buttons); ++i) {
      if (!buttons[i].title) continue;
 
      if (i % 2 != 0) ImGui::SameLine();
 
      if (ImGui::Button(buttons[i].title, buttonSize)) {
        buttons[i].toggle = !buttons[i].toggle;
      }
    }
  }
  ImGui::End();
 
  for (const VariableMap& variableMap : variableMapping) {
    if (Variable* var = context->variables->getIfExists(variableMap.name); var != nullptr && !var->isEmpty()) {
      var->setBool(variableMap.toggle);
    }
  }
 
  for (auto & inspector : inspectors) {
    inspector.inspector(context, &inspector.show);
  }
 
  aboutCogs(context, &showAboutCogs);
  textureInspector(context, &showTextureInspector);
  shadowMapInspector(context, &showShadowMapInspector);
  entityInspector(context, &showEntityInspector);
  variableInspector(context, &showVariableInspector);
  modelInspector(context, &showModelInspector);
  meshInspector(context, &showMeshInspector);
  materialInspector(context, &showMaterialInspector);
  materialInstanceInspector(context, &showMaterialInstanceInspector);
  fontInspector(context, &showFontInspector);
  inputInspector(context, &showInputInspector);
  resourceStoreInspector(context, &showResourceInspector);
  scriptInspector(context, &showScriptInspector);
  scriptConsole(context, &showScriptConsole);
  profileInspector(context, &showProfiler);
  renderingStatsInspector(context, &showRenderingStatsInspector);
  pipelineInspector(context, &showPipelineInspector);
  permutationInspector(context, &showPermutationInspector);
  assetInspector(context, &showAssetInspector);
  assetQueueInspector(context, &showAssetQueueInspector);
  boundsInspector(context, &showBoundsInspector);
  bufferInspector(context, &showBufferInspector);
  engineInspector(context, &showEngineInspector);
  gammaDebugger(context, &showGammaDebugger);
  taskManagerInspector(context, &showTaskManagerInspector);
  if(renderer->getDevice()->getType() == GraphicsDeviceType::WebGPU){
    webgpuCountersInspector(context, renderer, &showWebGPUCountersInspector);
  }
 
  if(showExampleGui) {
    ImGui::ShowDemoWindow(&showExampleGui);
  }
 
  if(!show){
    context->variables->set("gui.enabled", false);
  }
}
 
void Cogs::Core::InspectorGuiRenderer::endRender(Context * /*context*/, IRenderer * renderer)
{
  RenderInstrumentationScope(renderer->getDevice()->getImmediateContext(), SCOPE_RENDERING, "GuiRenderer::endRender");
 
  imguiRenderer->render();
}
 
void Cogs::Core::InspectorGuiRenderer::cleanup(Context * /*context*/, IRenderer * /*renderer*/)
{
  if (imguiContext) {
    imguiRenderer->deleteGuiContext(imguiContext);
    imguiContext = nullptr;
  }
}