MeshInspector.cpp

#include "Inspectors.h"
 
#include "InspectorGuiHelper.h"
#include "Context.h"
 
#include "Resources/MeshManager.h"
#include "Resources/BufferManager.h"
 
#include "MemoryContext.h"
 
#include "imgui.h"
 
namespace {
  using namespace Cogs::Core;
 
  // Helper item with mesh + calculated size used for sorting the view
  struct MeshInspectorItem
  {
    Mesh* mesh;
    size_t byteSize;
  };
 
}
 
 
void Cogs::Core::meshInspector(Context * context, bool * show)
{
  if (*show) {
    ImGui::SetNextWindowSize(ImVec2(600, 1000), ImGuiCond_Once);
 
    // Get all mesh resources.
    // Note that we get our own copy here, since new mesh resources can be created at any time.
    const std::vector<ResourceBase*> meshResources = context->meshManager->getAllocatedResources();
 
    // Calculate byte size of all meshes and populate a new array with this info.
    size_t totalByteSize = 0;
    size_t totalStreamCount = 0;
    std::vector<MeshInspectorItem> meshes;
    meshes.reserve(meshResources.size());
    for (ResourceBase* resource : meshResources) {
      if (resource->getSlot() == 0xFFFFFFFF) continue;
      assert(resource->getType() == ResourceTypes::Mesh);
      Mesh* mesh = reinterpret_cast<Mesh*>(resource);
 
      size_t byteSizeMesh = 0;
      for (const DataStream& stream : mesh->streams) {
        byteSizeMesh += stream.size();
      }
      totalByteSize += byteSizeMesh;
      totalStreamCount += mesh->streams.size();
      meshes.push_back({ .mesh = mesh, .byteSize = byteSizeMesh });
    }
 
    // Sort meshes the way the user wants
    const char* sortings[] = {
      "Unsorted",
      "Sort by size",
      "Sort by usage and size"
    };
    static int sorting = 0;
    switch (sorting) {
    case 0:
      break;
 
    case 1:
      std::sort(meshes.begin(), meshes.end(),
                [](const MeshInspectorItem& a, const MeshInspectorItem& b)
                {
                  return b.byteSize < a.byteSize;
                });
      break;
 
    case 2:
      std::sort(meshes.begin(), meshes.end(),
                [](const MeshInspectorItem& a, const MeshInspectorItem& b)
                {
                  if (a.mesh->referenceCount() == b.mesh->referenceCount()) return b.byteSize < a.byteSize;
                  return b.mesh->referenceCount() < a.mesh->referenceCount();
                });
      break;
 
    default:
      assert(false);
    }
 
    // Begin window header.
    std::string windowHeader;
    windowHeader.reserve(50);
    windowHeader.append("Meshes [");
    windowHeader.append(std::to_string(meshes.size()));
    windowHeader.append(" meshes, ");
    windowHeader.append(std::to_string(totalStreamCount));
    windowHeader.append(" streams, ");
    appendBytesize(windowHeader, totalByteSize);
    windowHeader.append("]");
 
    guiBegin(windowHeader, show);
 
    // Combo box to specify sorting
    ImGui::Combo("##sorting", &sorting, sortings, IM_ARRAYSIZE(sortings), 10);
 
    // List of meshes
    unsigned line = 0;
    std::string header;
    header.reserve(100);
    for (const MeshInspectorItem& item : meshes) {
      header.clear();
      header.append(std::to_string(line++));
      header.append(": ");
      if (std::string_view name = item.mesh->getName(); !name.empty()) {
        header.append(name);
      }
      else {
        header.append("Mesh");
      }
 
      header.append(" [");
      appendBytesize(header, item.byteSize);
      header.append(", ");
      header.append(std::to_string(item.mesh->referenceCount()));
      header.append(" refs]");
      showMesh(context, item.mesh, header);
    }
 
    guiEnd();
  }
}
 
void Cogs::Core::bufferInspector(Context * context, bool * show)
{
  if (*show) {
    ImGui::SetNextWindowSize(ImVec2(600, 1000), ImGuiCond_Once);
 
    std::vector<ResourceBase*> buffers = context->bufferManager->getAllocatedResources();
 
    guiBegin("Buffers", show);
 
    size_t mem = 0;
 
    for (ResourceBase* b : buffers) {
      BufferResource* buffer = static_cast<BufferResource*>(b);
      mem += buffer->size();
    }
 
    ImGui::Text("Count: %zu   Mem: %zu bytes", buffers.size(), mem);
 
    int id = 0;
    for (ResourceBase* b : buffers) {
      BufferResource* buffer = static_cast<BufferResource*>(b);
      std::string     header;
 
      ++id;
      std::string_view name = buffer->getName();
 
      if (name.empty()) {
        header = "Buffer " + std::to_string(id);
      }
      else {
        header = std::string(name);
      }
      header += " (" + std::to_string(buffer->size()) + " bytes)";
 
      ImGui::PushID(buffer);
 
      if (ImGui::TreeNode(header.c_str())) {
        bool isVB = buffer->isVertexBuffer();
        bool isIB = buffer->isIndexBuffer();
 
        bool isResident = buffer->isResident();
        bool hasChanged = buffer->hasChanged();
 
        ImGui::Checkbox("Vertex Buffer", &isVB);
        ImGui::Checkbox("Index Buffer", &isIB);
        ImGui::Checkbox("Resident", &isResident);
        ImGui::Checkbox("Changed", &hasChanged);
 
        ImGui::Text("Size: %zu", buffer->size());
 
        ImGui::TreePop();
      }
 
      ImGui::PopID();
    }
 
    guiEnd();
  }
}
 
void Cogs::Core::engineInspector(Context * context, bool * show)
{
  if (*show) {
    ImGui::SetNextWindowSize(ImVec2(600, 400), ImGuiCond_Once);
 
    std::string title = "Engine Statistics";
    guiBegin(title, show);
 
    auto & memory = *context->memory;
 
    if (ImGui::CollapsingHeader("Memory Allocation")) {
      ImGui::Columns(5, "Stats");
 
      ImGui::Text("Type"); ImGui::NextColumn();
      ImGui::Text("Count"); ImGui::NextColumn();
      ImGui::Text("Bytes"); ImGui::NextColumn();
      ImGui::Text("Peak Count"); ImGui::NextColumn();
      ImGui::Text("Peak Bytes"); ImGui::Separator(); ImGui::NextColumn();
 
      struct AllocatorStats
      {
        const char * name;
        Memory::Allocator * allocator;
      } allocators[] = {
        { "Base", memory.baseAllocator },
        { "Resources", memory.resourceAllocator },
        { "Components", memory.componentAllocator },
        { "Strings", memory.getStringsAllocator()},
      };
 
      for (auto & a : allocators) {
        ImGui::Text("%s", a.name); ImGui::NextColumn();
        ImGui::Text("%zu", getAllocationCount(a.allocator)); ImGui::NextColumn();
        ImGui::Text("%zu", getAllocatedBytes(a.allocator)); ImGui::NextColumn();
        ImGui::Text("%zu", getPeakCount(a.allocator)); ImGui::NextColumn();
        ImGui::Text("%zu", getPeakBytes(a.allocator)); ImGui::NextColumn();
      }
    }
 
    guiEnd();
  }
}