TextureInspector.cpp

#include "Inspectors.h"
 
#include "imgui.h"
 
#include "Context.h"
#include "Renderer/RenderTexture.h"
#include "Resources/TextureManager.h"
 
#include "InspectorGuiHelper.h"
 
namespace {
  struct TextureInfo {
    Cogs::Core::Texture*  texture;
    std::string           header;
 
    TextureInfo(Cogs::Core::ResourceBase* r, int& idx) {
      texture = static_cast<Cogs::Core::Texture*>(r);
 
      Cogs::Core::RenderResource*     attachment = texture->getAttachedResource();
      const Cogs::TextureDescription* description = &texture->description;
 
      if (attachment) {
        if (attachment->getType() == Cogs::Core::RenderResourceType::RenderTexture) {
          description = &static_cast<Cogs::Core::RenderTexture*>(attachment)->description;
        }
      }
      if (texture->getName().size()) {
        header = texture->getName();
      }
      else if (texture->getId() != Cogs::Core::NoResourceId) {
        header = "Texture (ID: " + std::to_string(r->getId()) + ")";
      }
      else {
        header = "Texture (" + std::to_string(idx++) + ")";
      }
 
      header += " [" + std::to_string(description->width) + "x" + std::to_string(description->height);
      if (description->depth > 1) {
        header += " d:" + std::to_string(description->depth);
      }
      if (description->samples > 1) {
        header += " s:" + std::to_string(description->samples);
      }
 
      const Cogs::FormatInfo* info = Cogs::getFormatInfo(description->format);
 
      if (info && info->name) {
        header += ", ";
        header += info->name;
        header += ", " + byteString(description->estimateMemorySize());
      }
 
      if (description->flags & Cogs::TextureFlags::RenderTarget) {
        header += " RenderTarget";
      }
      if (description->flags & Cogs::TextureFlags::DepthBuffer) {
        header += " DepthBuffer";
      }
      if (description->flags & Cogs::TextureFlags::GenerateMipMaps) {
        header += " GenerateMipMaps";
      }
      if (description->flags & Cogs::TextureFlags::CubeMap) {
        header += " CubeMap";
      }
      if (description->flags & Cogs::TextureFlags::ReadWriteTexture) {
        header += " ReadWriteTexture";
      }
      if (description->flags & Cogs::TextureFlags::ExternalTexture) {
        header += " ExternalTexture";
      }
      if (description->flags & Cogs::TextureFlags::UsageReadStaging) {
        header += " UsageReadStaging";
      }
      if (description->flags & Cogs::TextureFlags::UsageWriteStaging) {
        header += " UsageWriteStaging";
      }
      if (description->flags & Cogs::TextureFlags::NoDelete) {
        header += " NoDelete";
      }
      header += "]";
    }
 
    static std::string byteString(size_t bytes) {
      if (bytes < 16 * 1024) {
        return std::to_string(bytes) + " B";
      }
      bytes = bytes / 1024;
      if (bytes < 16 * 1024) {
        return std::to_string(bytes) + " KiB";
      }
      bytes = bytes / 1024;
      if (bytes < 16 * 1024) {
        return std::to_string(bytes) + " MiB";
      }
      bytes = bytes / 1024;
      return std::to_string(bytes) + " GiB";
    }
  };
}
 
void Cogs::Core::textureInspector(Context * context, bool * show)
{
  if (*show) {
    std::vector<ResourceBase*>  allocatedTextures = context->textureManager->getAllocatedResources();
    std::vector<TextureInfo>    textures;
    std::string                 windowHeader;
    int                         idx = 0;
 
    windowHeader.reserve(50);
    windowHeader.append("Textures [");
    windowHeader.append(std::to_string(allocatedTextures.size()));
    windowHeader.append("]###TextureInspector");
 
    for (ResourceBase* res : allocatedTextures) {
      textures.push_back(TextureInfo(res, idx));
    }
    std::sort(textures.begin(), textures.end(), [](const TextureInfo& lhs, const TextureInfo& rhs) { return lhs.header < rhs.header; });
 
    guiBegin(windowHeader, show);
 
    for (const TextureInfo& info : textures) {
      if (ImGui::CollapsingHeader(getUniqueHeader(info.header).c_str())) {
        Renderer*       renderer = dynamic_cast<Cogs::Core::Renderer*>(context->renderer);
        RenderResource* attachment = info.texture->getAttachedResource();
 
        if (attachment && (attachment->getType() == RenderResourceType::RenderTexture)) {
          showRenderTexture(context, renderer, static_cast<RenderTexture*>(attachment));
        }
        else {
          showTexture(context, renderer, info.texture);
        }
      }
    }
    guiEnd();
  }
}