InspectorGuiHelper.cpp

#include "InspectorGuiHelper.h"
 
#include "Context.h"
 
#include "Components/Core/SceneComponent.h"
 
#include "Renderer/Renderer.h"
 
#include "Resources/TextureManager.h"
#include "Renderer/RenderTexture.h"
 
#include "Resources/Mesh.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialOptions.h"
#include "Resources/MaterialInstance.h"
#include "Resources/Model.h"
#include "Resources/Animation.h"
 
#include "Types.h"
 
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
#include <glm/gtc/type_ptr.hpp>
 
#include <algorithm>
#include <cctype>
#include <cstdio>
 
namespace
{
  bool lc_eq(unsigned char l, unsigned char r)
  {
    return (std::tolower(l) == std::tolower(r));
  }
}
 
std::string Cogs::Core::guiWindowTitle;
std::vector<size_t> Cogs::Core::guiIdsStack;
 
enum struct EMeshDataType : uint8_t
{
  Integer = 0,
  UnsignedInt,
  Float,
  Normalized,
  UnsignedNorm,
  Other
};
 
struct ColumnInfo
{
  EMeshDataType type = EMeshDataType::Other;
  uint16_t size = 0;
  uint16_t offset = 0;
  std::string header;
  ImU32 color = IM_COL32(255, 255, 255, 255);
};
 
 
// Per https://www.khronos.org/opengl/wiki/Normalized_Integer
template <typename T>
constexpr float normalizeNumber(T value) {
  return std::max(static_cast<float>(value) / static_cast<float>(std::numeric_limits<T>::max()), -1.0f);
}
 
void Cogs::Core::guiBegin(const std::string & title, bool * show)
{
  ImGui::Begin(title.c_str(), show, 0);
  guiWindowTitle = title;
 
  assert(guiIdsStack.empty());
}
 
void Cogs::Core::guiEnd()
{
  ImGui::End();
  guiIdsStack.clear();
}
 
std::string Cogs::Core::getUniqueHeader(const std::string & header)
{
  if (guiIdsStack.empty()) {
    guiIdsStack.push_back(0);
  } else {
    guiIdsStack.back()++;
  }
 
  assert(!guiWindowTitle.empty());
  std::string id = guiWindowTitle;
  for (auto top : guiIdsStack) {
    if (!id.empty()) {
      id += "_";
    }
    id += std::to_string(top);
  }
 
  std::string res;
  res.reserve(header.size() + 2 + id.size());
  res.append(header);
  res.append("##");
  res.append(id);
 
  return res;
}
 
 
void Cogs::Core::appendBytesize(std::string& out, size_t byteSize)
{
  std::array<char, 32> tmp;
 
  constexpr size_t k = static_cast<size_t>(1024);
  constexpr size_t m = k * k;
  constexpr size_t g = k * k * k;
 
  if (byteSize < k) {
    out.append(std::to_string(byteSize));
    out.append("b");
  }
  else if (byteSize < m) {
    if (int n = snprintf(tmp.data(), tmp.size(), "%.1f", double(byteSize) / double(k)); 0 <= n && size_t(n) < tmp.size()) {
      out.append(std::string_view(tmp.data(), n));
    }
    out.append("kb");
  }
  else if (byteSize < g) {
    if (int n = snprintf(tmp.data(), tmp.size(), "%.1f", double(byteSize) / double(m)); 0 <= n && size_t(n) < tmp.size()) {
      out.append(std::string_view(tmp.data(), n));
    }
    out.append("mb");
  }
  else {
    if (int n = snprintf(tmp.data(), tmp.size(), "%.1f", double(byteSize) / double(g)); 0 <= n && size_t(n) < tmp.size()) {
      out.append(std::string_view(tmp.data(), n));
    }
    out.append("gb");
  }
}
 
 
bool Cogs::Core::containsInvariantCase(std::string_view str, std::string_view substr)
{
  return std::search(str.begin(), str.end(), substr.begin(), substr.end(), lc_eq) != str.end();
}
 
 
bool Cogs::Core::findHierarchyWithMatch(const Cogs::ComponentModel::Entity& entity, std::string_view entityNamePattern, std::string_view componentNamePattern)
{
  if (entityNamePattern.empty() && componentNamePattern.empty()) {
    return true;
  }
 
  bool showEntity = true;
  if (!entityNamePattern.empty() && !containsInvariantCase(entity.getName(), entityNamePattern)) {
    showEntity = false;
  }
 
  if (showEntity && !componentNamePattern.empty()) {
    showEntity = false;
    for (const Cogs::ComponentModel::ComponentHandle& c : entity.getComponents()) {
      Cogs::ComponentModel::Component* component = c.resolve();
      if (component) {
        showEntity = showEntity || containsInvariantCase(component->getType().getName().c_str(), componentNamePattern);
      }
    }
  }
 
  if (!showEntity) {
    // Search children for matching. Must show parent to navigate to child
    const Cogs::Core::SceneComponent* sceneComponent = entity.getComponent<Cogs::Core::SceneComponent>();
    if (sceneComponent) {
      for (const Cogs::Core::EntityPtr& child : sceneComponent->children) {
        showEntity = findHierarchyWithMatch(*child, entityNamePattern, componentNamePattern);
        if (showEntity) {
          break;
        }
      }
    }
  }
  return showEntity;
}
 
void Cogs::Core::showTexture(const Context * context, Renderer * renderer, Texture * texture, bool showTitle)
{
  if (showTitle) {
    if (!texture->getName().empty()) {
      ImGui::Text("Name: %.*s", StringViewFormat(texture->getName()));
    }
    else if (texture->getId() != NoResourceId) {
      ImGui::Text("Id: %d", texture->getId());
    }
  }
 
  ImGui::Text("Refs: %u", texture->referenceCount());
  ImGui::SameLine();
  ImGui::Text("Target: %s", getResourceDimensionsName(texture->description.target));
  ImGui::SameLine();
  switch(texture->description.target){
  case ResourceDimensions::Unknown:
    ImGui::Text("Size: Unknown");
    break;
  case ResourceDimensions::Buffer:
    ImGui::Text("Size: Buffer");
    break;
  case ResourceDimensions::Texture1D:
    ImGui::Text("Size: %d", texture->description.width);
    break;
  case ResourceDimensions::Texture1DArray:
    ImGui::Text("Size: %d Layers %d", texture->description.width, texture->description.layers);
    break;
  case ResourceDimensions::Texture2D:
    ImGui::Text("Size: %dx%d", texture->description.width, texture->description.height);
    break;
  case ResourceDimensions::Texture2DArray:
    ImGui::Text("Size: %dx%d Layers %d", texture->description.width, texture->description.height, texture->description.layers);
    break;
  case ResourceDimensions::Texture2DMS:
    ImGui::Text("Size: %dx%d Samples %d", texture->description.width, texture->description.height, texture->description.samples);
    break;
  case ResourceDimensions::Texture2DMSArray:
    ImGui::Text("Size: %dx%d Layers %d Samples %d", texture->description.width, texture->description.height, texture->description.layers, texture->description.samples);
    break;
  case ResourceDimensions::Texture3D:
    ImGui::Text("Size: %dx%dx%d", texture->description.width, texture->description.height, texture->description.depth);
    break;
  case ResourceDimensions::Texture3DArray:
    ImGui::Text("Size: %dx%dx%d Layers %d", texture->description.width, texture->description.height, texture->description.depth, texture->description.layers);
    break;
  case ResourceDimensions::TextureCube:
    ImGui::Text("Size: %dx%d Faces %d", texture->description.width, texture->description.height, texture->description.faces);
    break;
  case ResourceDimensions::TextureCubeArray:
    ImGui::Text("Size: %dx%d Faces %d Layers %d", texture->description.width, texture->description.height, texture->description.faces, texture->description.layers);
    break;
  case ResourceDimensions::RenderBuffer:
    ImGui::Text("Size: %dx%d", texture->description.width, texture->description.height);
    break;
  case ResourceDimensions::ResourceDimensions_Size:
    break;
  }
  ImGui::SameLine();
  ImGui::Text("Mips %d", texture->description.levels);
  ImGui::SameLine();
  auto tmp = getFormatInfo(texture->description.format);
  if(tmp && tmp->name)
    ImGui::Text("Format: %s", tmp->name);
 
  RenderTexture * renderTexture = renderer->getRenderResources().getRenderTexture(context->textureManager->generateHandle(texture));
 
  if (renderTexture && HandleIsValid(renderTexture->textureHandle)) {
    float aspectRatio = 1;
    if (texture->description.width > 0 && texture->description.height > 0) {
      aspectRatio = static_cast<float>(texture->description.width) / static_cast<float>(texture->description.height);
    }
 
    auto size = ImVec2(256, 256);
    if (aspectRatio < 1) {
      size.x *= aspectRatio;
    } else {
      size.y /= aspectRatio;
    }
 
    uint64_t mode = GUI_MODE_TEX_TYPE_2D;
    if (texture->description.target == ResourceDimensions::Texture2DMS) {
      mode = GUI_MODE_TEX_TYPE_2DMS;
    }
    else if (texture->description.target == ResourceDimensions::Texture1DArray ||
             texture->description.target == ResourceDimensions::Texture2DArray) {
      mode = GUI_MODE_TEX_TYPE_ARRAY;
    }
    else if (texture->description.target == ResourceDimensions::TextureCube ||
             texture->description.target == ResourceDimensions::TextureCubeArray) {
      mode = GUI_MODE_TEX_TYPE_CUBE;
    }
 
    auto dl = ImGui::GetWindowDrawList();
    dl->AddCallback(setGuiMode, reinterpret_cast<void*>(mode));
    ImGui::Image(ImTextureID(renderTexture->textureHandle.handle), size);
    ImGui::SameLine();
    dl->AddCallback(setGuiMode, reinterpret_cast<void*>(mode | GUI_MODE_TEX_CHANNELS_ALPHA));   // show only alpha channel for the next texture
    ImGui::Image(ImTextureID(renderTexture->textureHandle.handle), size);
    dl->AddCallback(setGuiMode, reinterpret_cast<void*>(GUI_MODE_DEFAULT));   // restore the default texture rendering state
  }
}
 
void Cogs::Core::showRenderTexture(const Context * /*context*/, Renderer * /*renderer*/, const RenderTexture * renderTexture, bool showTitle)
{
  auto texture = renderTexture->getResource();
  float aspectRatio = 1;
 
  if (texture) {
    if (showTitle) {
      if (!texture->getName().empty()) {
        ImGui::Text("Name: %.*s", StringViewFormat(texture->getName()));
      }
      else if (texture->getId() != NoResourceId) {
        ImGui::Text("Id: %d", texture->getId());
      }
    }
 
    ImGui::Text("Refs: %u", texture->referenceCount());
    ImGui::Text("Size: %d x %d", renderTexture->description.width, renderTexture->description.height);
 
    if (renderTexture->description.width > 0 && renderTexture->description.height > 0) {
      aspectRatio = static_cast<float>(renderTexture->description.width) / static_cast<float>(renderTexture->description.height);
    }
  }
 
  if (renderTexture && HandleIsValid(renderTexture->textureHandle)) {
    ImVec2      size(256, 256);
    ImDrawList* dl = ImGui::GetWindowDrawList();
 
    if (aspectRatio < 1) {
      size.x *= aspectRatio;
    }
    else {
      size.y /= aspectRatio;
    }
 
    if (renderTexture->description.target == ResourceDimensions::Texture2DMS) {
      dl->AddCallback(setGuiMode, reinterpret_cast<void*>(GUI_MODE_TEX_TYPE_2DMS));   // Use the Texture2DMS slot for the next texture
      ImGui::Image(ImTextureID(renderTexture->textureHandle.handle), size);
      ImGui::SameLine();
      dl->AddCallback(setGuiMode, reinterpret_cast<void*>(GUI_MODE_TEX_TYPE_2DMS | GUI_MODE_TEX_CHANNELS_ALPHA));  // Show only alpha channel for the next texture
      ImGui::Image(ImTextureID(renderTexture->textureHandle.handle), size);
      dl->AddCallback(setGuiMode, reinterpret_cast<void*>(GUI_MODE_DEFAULT));             // Restore the default texture rendering state
    }
    else {
      ImGui::Image(ImTextureID(renderTexture->textureHandle.handle), size);
      ImGui::SameLine();
      dl->AddCallback(setGuiMode, reinterpret_cast<void*>(GUI_MODE_TEX_CHANNELS_ALPHA));  // Show only alpha channel for the next texture
      ImGui::Image(ImTextureID(renderTexture->textureHandle.handle), size);
      dl->AddCallback(setGuiMode, reinterpret_cast<void*>(GUI_MODE_DEFAULT));             // Restore the default texture rendering state
    }
  }
}
 
bool Cogs::Core::showMatrix(const std::string & header, glm::mat4& m)
{
  bool changed = false;
  if (ImGui::TreeNode(header.c_str()))  {
    ScopedIndent si;
 
    if (ImGui::DragFloat4("row_0", glm::value_ptr(m))) {
      changed = true;
    }
    if (ImGui::DragFloat4("row_1", glm::value_ptr(m) + 4)) {
      changed = true;
    }
    if (ImGui::DragFloat4("row_2", glm::value_ptr(m) + 8)) {
      changed = true;
    }
    if (ImGui::DragFloat4("row_3", glm::value_ptr(m) + 12)) {
      changed = true;
    }
 
    ImGui::TreePop();
  }
 
  return changed;
}
 
bool Cogs::Core::showArray3D(const std::string & header, std::span<glm::vec3> array)
{
  bool changed = false;
 
  if (array.empty()) {
    ImGui::Text("%s: Empty", header.c_str());
  } else {
    if (ImGui::CollapsingHeader(getUniqueHeader(std::string(header + " [size=" + std::to_string(array.size()) + "]")).c_str())) {
      ScopedIndent si;
 
      int i = 0;
      for (auto& v : array) {
        auto label = std::to_string(i++);
 
        if (ImGui::DragFloat3(getUniqueHeader(label).c_str(), glm::value_ptr(v))) {
          changed = true;
        }
      }
    }
  }
 
  return changed;
}
 
void Cogs::Core::showMesh(const Context * /*context*/, Mesh * mesh, const std::string & header)
{
  ImGui::PushID(mesh);
 
  if (ImGui::TreeNode(header.c_str())) {
 
    if (ImGui::TreeNode("Bounding box")) {
      ScopedIndent si;
      bool changed = ImGui::DragFloat3("min", glm::value_ptr(mesh->boundingBox.min));
      if (ImGui::DragFloat3("max", glm::value_ptr(mesh->boundingBox.max))) changed = true;
      if (changed) {
        mesh->setMeshFlag(MeshFlags::BoundingBoxSet);
      }
      ImGui::TreePop();
    }
 
    showEnum<Cogs::PrimitiveType::EPrimitiveType>("Primitive type", mesh->primitiveType);
 
    ImGui::Text("Number of primitives: %d", mesh->getCount());
 
    if (mesh->isIndexed()) {
      if (mesh->hasIndexesU16()) {
        showArray1D("IndexesU16", mesh->getIndexesU16());
      }
      else {
        showArray1D("IndexesU32", mesh->getIndexes());
      }
    }
 
    if (!mesh->streams.empty()) {
      if (ImGui::TreeNode(("Streams [size=" + std::to_string(mesh->streams.size()) + "]").c_str())) {
        ScopedIndent si;
        int streamNum = 0;
        for (DataStream& stream : mesh->streams)
        {
          std::string typeAsString;
          switch (stream.type)
          {
          case VertexDataType::Positions:
            typeAsString = "Positions";
            break;
          case VertexDataType::Normals:
            typeAsString = "Normals";
            break;
          case VertexDataType::Tangents:
            typeAsString = "Tangents";
            break;
          case VertexDataType::Bitangents:
            typeAsString = "Bitangents";
            break;
          case VertexDataType::TexCoords0:
            typeAsString = "TexCoords0";
            break;
          case VertexDataType::TexCoords1:
            typeAsString = "TexCoords1";
            break;
          case VertexDataType::TexCoords2:
            typeAsString = "TexCoords2";
            break;
          case VertexDataType::Colors0:
            typeAsString = "Colors0";
            break;
          case VertexDataType::Colors1:
            typeAsString = "Colors1";
            break;
          case VertexDataType::Colors2:
            typeAsString = "Colors2";
            break;
          case VertexDataType::Colors3:
            typeAsString = "Colors3";
            break;
          case VertexDataType::Interleaved0:
            typeAsString = "Interleaved0";
            break;
          case VertexDataType::Interleaved1:
            typeAsString = "Interleaved1";
            break;
          case VertexDataType::Indexes:
            typeAsString = "Indexes";
          break;
          case VertexDataType::PoseIndexes:
            typeAsString = "PoseIndexes";
            break;
          case VertexDataType::SubMeshes:
            typeAsString = "SubMeshes";
            break;
          case VertexDataType::Reserved:
            typeAsString = "Reserved";
            break;
          default:
            break;
          }
 
          ImGui::PushID(&stream);
 
          std::string stream_header;
          stream_header.reserve(50);
          stream_header.append("Stream ");
          stream_header.append(!typeAsString.empty() ? typeAsString : std::to_string(streamNum++));
          stream_header.append(" [elements=");
          stream_header.append(std::to_string(stream.numElements));
          stream_header.append(", stride=");
          stream_header.append(std::to_string(stream.stride));
          stream_header.append(", size=");
          appendBytesize(stream_header, stream.size());
          stream_header.append("]");
 
          if (ImGui::TreeNode(stream_header.c_str())) {
            ScopedIndent si2;
 
            static constexpr std::array colors = { IM_COL32(255,255,128,255), IM_COL32(255,128,255,255), IM_COL32(128,255,255,255),
                   IM_COL32(255,200,200,255), IM_COL32(200,255,200,255), IM_COL32(200,200,255,255) };
 
            // Show Vertex Elements information
            const Cogs::VertexFormat* format = HandleIsValid(stream.format) ? Cogs::VertexFormats::getVertexFormat(stream.format) : nullptr;
            if (format && ImGui::TreeNode(("Vertex Format Elements [size=" + std::to_string(format->elements.size()) + "]").c_str())) {
              ScopedIndent si3;
              int colorElement = 0;
              for (uint16_t i = 0; i < format->elements.size(); ++i) {
                const Cogs::VertexElement& element = format->elements[i];
                const Cogs::FormatInfo* formatInfo = Cogs::getFormatInfo(element.format);
 
                ImGui::PushStyleColor(ImGuiCol_Text, colors[colorElement]);
                colorElement = (colorElement + 1) % colors.size();
 
                std::string elementHeader;
                elementHeader.reserve(127);
                elementHeader += std::to_string(i);
                elementHeader += ": [offset=";
                elementHeader += std::to_string(element.offset);
                elementHeader += ", size=";
                elementHeader += std::to_string(formatInfo->blockSize);
                elementHeader += "]";
 
                if (ImGui::TreeNode(elementHeader.c_str())) {
                  ImGui::Text("DataFormat: %s", formatInfo->name);
 
                  std::string flagsStr;
                  const FormatFlags flags = formatInfo->flags;
                  if ((flags & FormatFlags::Alpha) != FormatFlags::None) { flagsStr += "Alpha "; }
                  if ((flags & FormatFlags::VertexFormat) != FormatFlags::None) { flagsStr += "VertexFormat "; }
                  if ((flags & FormatFlags::Depth) != FormatFlags::None) { flagsStr += "Depth "; }
                  if ((flags & FormatFlags::Typeless) != FormatFlags::None) { flagsStr += "Typeless "; }
                  if ((flags & FormatFlags::Integer) != FormatFlags::None) { flagsStr += "Integer "; }
                  if ((flags & FormatFlags::Unsigned) != FormatFlags::None) { flagsStr += "Unsigned "; }
                  ImGui::Text("Flags: %s", flagsStr.c_str());
 
                  ImGui::Text("Semantic: %.*s%u", StringViewFormat(Cogs::getElementSemanticName(element.semantic)), element.semanticIndex);
                  const char* inputType = element.inputType == InputType::VertexData ? "VertexData" : "InstanceData";
                  ImGui::Text("InputType: %s [step=%u]", inputType, element.instanceStep);
 
                  ImGui::TreePop();
                }
                ImGui::PopStyleColor();
              }
              ImGui::TreePop();
            }
 
            // Try to show formated Data for this stream
            if (format && ImGui::TreeNode("Data")) {
              std::vector<ColumnInfo> columns;
              int colorIndex = 0;
 
              // Assemble Columns info for all Vertex Elements
              // Assume for now that all channels in one Vertex Element are of the same type and size
              for (const Cogs::VertexElement& element : format->elements) {
                const Cogs::FormatInfo* formatInfo = Cogs::getFormatInfo(element.format);
                ColumnInfo column;
                column.size = formatInfo->blockSize / formatInfo->elements;
                column.color = colors[colorIndex];
                colorIndex = (colorIndex + 1) % colors.size();
 
                std::string prefix;
                if (element.semantic == ElementSemantic::Position) { prefix = "V"; }
                else if (element.semantic == ElementSemantic::Normal) { prefix = "N"; }
                else if (element.semantic == ElementSemantic::Color) { prefix = "C"; }
                else if (element.semantic == ElementSemantic::TextureCoordinate) { prefix = "T"; }
                else if (element.semantic == ElementSemantic::Tangent) { prefix = "Tg"; }
                else if (element.semantic == ElementSemantic::InstanceVector) { prefix = "IV"; }
                else if (element.semantic == ElementSemantic::InstanceMatrix) { prefix = "IM"; }
                else if (element.semantic == ElementSemantic::Semantic_Size) { prefix = "S"; }
 
                std::string_view name(formatInfo->name);
                if (name.find("UINT") != std::string_view::npos) {
                  column.type = EMeshDataType::UnsignedInt;
                }
                else if (name.find("SINT") != std::string_view::npos) {
                  column.type = EMeshDataType::Integer;
                }
                else if (name.find("FLOAT") != std::string_view::npos) {
                  column.type = EMeshDataType::Float;
                }
                else if (name.find("UNORM") != std::string_view::npos) {
                  column.type = EMeshDataType::UnsignedNorm;
                }
                else if (name.find("SNORM") != std::string_view::npos) {
                  column.type = EMeshDataType::Normalized;
                }
 
                for (uint16_t j = 0; j < formatInfo->elements; ++j) {
                  column.offset = element.offset + j * column.size;
                  // Assume for header that Vertex Elements are sequential (ascending offsets)
                  column.header = prefix + "." + std::to_string(j);
                  columns.push_back(column);
                }
              }
 
              // Show formatted table for all data elements
              const char* p = static_cast<const char*>(stream.data());
              ImGui::Columns(static_cast<int>(columns.size() + 1));
              // Headers row
              ImGui::NextColumn();
              for (const ColumnInfo& column : columns) {
                ImGui::Text("%s", column.header.c_str());
                ImGui::NextColumn();
              }
              // Data table, one row per Element
              for (size_t k = 0; k < stream.numElements; k++) {
                ImGui::Text("%zu", k); 
                ImGui::NextColumn();
 
                for (const ColumnInfo& column: columns) {
                  const void* data = p + column.offset;
                  bool other = true;
                  ImGui::PushStyleColor(ImGuiCol_Text, column.color);
 
                  if (column.type == EMeshDataType::Float) {
                    if (column.size == 4) {
                      ImGui::Text("%.2f", *(static_cast<const float*>(data)));
                      other = false;
                    }
                    else if (column.size == 2) {
                      ImGui::Text("%.2f", glm::detail::toFloat32(*static_cast<const uint16_t*>(data)));
                      other = false;
                    }
                  }
                  else if (column.type == EMeshDataType::Integer) {
                    if (column.size == 1) {
                      ImGui::Text("%d", *static_cast<const int8_t*>(data));
                      other = false;
                    }
                    else if (column.size == 2) {
                      ImGui::Text("%d", *static_cast<const int16_t*>(data));
                      other = false;
                    }
                    else if (column.size == 4) {
                      ImGui::Text("%d", *static_cast<const int32_t*>(data));
                      other = false;
                    }
                  }
                  else if (column.type == EMeshDataType::UnsignedInt) {
                    if (column.size == 1) {
                      ImGui::Text("%d", *static_cast<const uint8_t*>(data));
                      other = false;
                    }
                    else if (column.size == 2) {
                      ImGui::Text("%d", *static_cast<const uint16_t*>(data));
                      other = false;
                    }
                    else if (column.size == 4) {
                      ImGui::Text("%d", *static_cast<const uint32_t*>(data));
                      other = false;
                    }
                  }
                  else if (column.type == EMeshDataType::Normalized) {
                    if (column.size == 1) {
                      ImGui::Text("%.2f", normalizeNumber<int8_t>(*static_cast<const int8_t*>(data)));
                      other = false;
                    }
                    else if (column.size == 2) {
                      ImGui::Text("%.2f", normalizeNumber<int16_t>(*static_cast<const int16_t*>(data)));
                      other = false;
                    }
                    else if (column.size == 4) {
                      ImGui::Text("%.2f", normalizeNumber<int32_t>(*static_cast<const int32_t*>(data)));
                      other = false;
                    }
                  }
                  else if (column.type == EMeshDataType::UnsignedNorm) {
                    if (column.size == 1) {
                      ImGui::Text("%.2f", normalizeNumber<uint8_t>(*static_cast<const uint8_t*>(data)));
                      other = false;
                    }
                    else if (column.size == 2) {
                      ImGui::Text("%.2f", normalizeNumber<uint16_t>(*static_cast<const uint16_t*>(data)));
                      other = false;
                    }
                    else if (column.size == 4) {
                      ImGui::Text("%.2f", normalizeNumber<uint32_t>(*static_cast<const uint32_t*>(data)));
                      other = false;
                    }
                  }
                  if (other) {
                    // Data Format that we cannot parse, for now
                    ImGui::Text("-");
                  }
                  ImGui::NextColumn();
                  ImGui::PopStyleColor();
                }
                p += stream.stride;
              }
              ImGui::Columns(1);
 
              ImGui::TreePop();
            }
 
            // Use writable streams to allow changing stream data.
            const size_t size = stream.size() / sizeof(float);
            const size_t intSize = stream.size() / sizeof(int);
            const std::span<float> data(static_cast<float*>(stream.data()), size);
            const std::span<int> intData(static_cast<int*>(stream.data()), intSize);
            bool streamChanged = false;
 
            if(stream.format == VertexFormats::Pos2f)
              streamChanged = showArray2D<float>("Data", data);
            else if(stream.format == VertexFormats::Pos3f)
              streamChanged = showArray3D<float>("Data", data);
            else if(stream.format == VertexFormats::Pos4f)
              streamChanged = showArray4D<float>("Data", data);
            else if(stream.format == VertexFormats::Norm3f)
              streamChanged = showArray3D<float>("Data", data);
            else if(stream.format == VertexFormats::Tang3f)
              streamChanged = showArray3D<float>("Data", data);
            else if(stream.format == VertexFormats::Tex2f)
              streamChanged = showArray2D<float>("Data", data);
            else if(stream.format == VertexFormats::Color4f)
              streamChanged = showArray4D<float>("Data", data);
            else if(stream.format == VertexFormats::BoneIndex4i)
              streamChanged = showArray4D<int>("Data", intData);
            else if(stream.format == VertexFormats::BoneWeight4f)
              streamChanged = showArray4D<float>("Data", data);
            else {
              // Unsupported format. Can be mixed: VertexFormats::Pos3fNorm3f etc.
            }
 
            if (streamChanged) {
              mesh->markStreamChanged(stream.type);
            }
 
            ImGui::TreePop();
          }
 
          ImGui::PopID();
        }
 
        ImGui::TreePop();
      }
    } else {
      ImGui::Text("Streams: Empty");
    }
 
    if (!mesh->getSubMeshes().empty()) {
      if (ImGui::TreeNode(("Sub-meshes [size=" + std::to_string(mesh->getSubMeshes().size()) + "]").c_str())) {
        ScopedIndent si;
        int id = 0;
        for (SubMesh& subMesh : mesh->getSubMeshes()) {
          if (ImGui::TreeNode(("Sub-meshes " + std::to_string(id++)).c_str())) {
            ScopedIndent si2;
            ImGui::Text("Start index: %d", subMesh.startIndex);
            ImGui::Text("Number of indexes: %d", subMesh.numIndexes);
            showEnum<Cogs::PrimitiveType::EPrimitiveType>("Primitive type", subMesh.primitiveType);
 
            ImGui::TreePop();
          }
        }
 
        ImGui::TreePop();
      }
    } else {
      ImGui::Text("Sub-meshes: Empty");
    }
 
    ImGui::TreePop();
  }
 
  ImGui::PopID();
}
 
void Cogs::Core::showMaterialOptions(const Context * /*context*/, MaterialOptions * options, const std::string & header)
{
  ImGui::PushID(options);
 
  if (ImGui::TreeNode(header.c_str())) {
    showEnum("Cull mode", options->cullMode);
 
    ImGui::Checkbox("Depth write", &options->depthWriteEnabled);
    ImGui::Checkbox("Depth test", &options->depthTestEnabled);
    ImGui::Checkbox("Depth bias", &options->depthBiasEnabled);
 
    if (ImGui::CollapsingHeader("Depth bias##DepthBiasHeader")) {
      ImGui::DragFloat("Constant", &options->depthBias.constant);
      ImGui::DragFloat("Slope", &options->depthBias.slope);
      ImGui::DragFloat("Clamp", &options->depthBias.clamp);
    }
 
    showEnum("Depth func", options->depthFunc);
    showEnum("Transparent", options->transparencyMode);
    showEnum("Blend mode", options->blendMode);
 
    ImGui::TreePop();
  }
 
  ImGui::PopID();
}
 
void Cogs::Core::showMaterialVariants(MaterialInstance* material)
{
  if (ImGui::TreeNode("Variants")) {
    for (const ShaderVariantDefinition& v : material->material->definition.variants) {
 
      size_t value = v.isShared ? v.defaultValue : material->variantSelectors[v.index].value;
 
      switch (v.type) {
      case ShaderVariantType::Enum:
      {
        std::vector<const char*> enumNames(v.values.size());
 
        for (size_t i = 0; i < v.values.size(); ++i) {
          enumNames[i] = v.values[i].key.c_str();
        }
 
        int currentIndex = static_cast<int>(value);
        if (ImGui::Combo(v.name.c_str(), &currentIndex, enumNames.data(), static_cast<int>(enumNames.size()))) {
          if (!v.isShared) material->setVariant(v.name, enumNames[currentIndex]);
        }
      }
      break;
 
      case ShaderVariantType::Bool:
        if (bool boolean = value != 0; ImGui::Checkbox(v.name.c_str(), &boolean)) {
          if (!v.isShared) material->setVariant(v.name, boolean);
        }
        break;
 
      case ShaderVariantType::Int:
        if (int integer = static_cast<int>(value); ImGui::InputInt(v.name.c_str(), &integer, 1)) {
          if (!v.isShared) material->setVariant(v.name, integer);
        }
        break;
 
      // Don't show: VertexStreamPosition0": { "type": "format", "value" : "BASE_MATERIAL_VERTEX_POSITION0",..
      case ShaderVariantType::Format:
        break;
 
      default:
        ImGui::Text("Unsupported: %s", v.name.c_str());
        break;
      }
    }
 
    ImGui::TreePop();
  }
}
 
void Cogs::Core::showMaterialProperties(MaterialInstance* material)
{
  for (const MaterialProperty& prop : material->material->constantBuffers.variables) {
  
    switch (prop.type) {
    case MaterialDataType::Float:
    {
      float value = {};
      material->getProperty(prop.key, &value, sizeof(value));
      if (ImGui::DragFloat(prop.name.c_str(), &value)) {
        material->setFloatProperty(prop.key, value);
      }
    }
    break;
 
    case MaterialDataType::Float2:
    {
      glm::vec2 value = {};
      material->getProperty(prop.key, &value, sizeof(value));
      if (ImGui::DragFloat2(prop.name.c_str(), glm::value_ptr(value))) {
        material->setVec2Property(prop.key, value);
      }
    }
    break;
 
    case MaterialDataType::Float3:
    {
      glm::vec3 value = {};
      material->getProperty(prop.key, &value, sizeof(value));
      if ((prop.flags & MaterialPropertyFlags::sRGB) == MaterialPropertyFlags::sRGB) {
        if (ImGui::ColorEdit3(prop.name.c_str(), glm::value_ptr(value))) {
          material->setVec3Property(prop.key, value);
        }
      }
      else {
        if (ImGui::DragFloat3(prop.name.c_str(), glm::value_ptr(value))) {
          material->setVec3Property(prop.key, value);
        }
      }
    }
    break;
 
    case MaterialDataType::Float4:
    {
      glm::vec4 value = {};
      material->getProperty(prop.key, &value, sizeof(value));
      if ((prop.flags & MaterialPropertyFlags::sRGB) == MaterialPropertyFlags::sRGB) {
        if (ImGui::ColorEdit4(prop.name.c_str(), glm::value_ptr(value))) {
          material->setVec4Property(prop.key, value);
        }
      }
      else {
        if (ImGui::DragFloat4(prop.name.c_str(), glm::value_ptr(value))) {
          material->setVec4Property(prop.key, value);
        }
      }
    }
    break;
 
    case MaterialDataType::Float4x4:
    {
      glm::mat4 value = {};
      material->getProperty(prop.key, &value, sizeof(value));
      if (showMatrix(prop.name, value)) {
        material->setMat4Property(prop.key, value);
      }
    }
    break;
 
    case MaterialDataType::Int:
    {
      int32_t value = {};
      material->getProperty(prop.key, &value, sizeof(value));
      if (ImGui::DragInt(prop.name.c_str(), &value, 1.0f, 0, 100)) {
        material->setIntProperty(prop.key, value);
      }
      break;
    }
 
    case MaterialDataType::UInt:
    {
      int32_t value = {};
      material->getProperty(prop.key, &value, sizeof(value));
      if (ImGui::DragInt(prop.name.c_str(), &value, 1.0f, 0, 100)) {
        material->setUIntProperty(prop.key, static_cast<uint32_t>(value));
      }
    }
    break;
 
    case MaterialDataType::Bool:
    {
      bool value = {};
      material->getProperty(prop.key, &value, sizeof(value));
      if (ImGui::Checkbox(prop.name.c_str(), &value)) {
        material->setBoolProperty(prop.key, value);
      }
    }
    break;
 
    default:
      ImGui::Text("Unsupported: %d", static_cast<int>(prop.type));
      break;
    }
  }
}
 
void Cogs::Core::showMaterialInstance(const Context * context, MaterialInstance * material, const std::string & header)
{
  ImGui::PushID(material);
 
  if (ImGui::TreeNodeEx(header.c_str(), ImGuiTreeNodeFlags_NoAutoOpenOnLog)) {
    std::string flags;
    flags += material->isBackdrop() ? "Backdrop " : "";
    flags += material->hasTransparency() ? "Transparent " : "";
    flags += material->isDefaultMaterial() ? "Default " : "";
    flags = flags.size() ? "Flags: " + flags : "Flags: None";
 
    ImGui::Text("%s", flags.c_str());
 
    int permutationIndex = static_cast<int>(material->permutationIndex);
    std::vector<const char*> permutations;
 
    for (auto& permutation : material->material->definition.permutations) {
      permutations.push_back(permutation.permutationName.c_str());
    }
 
    if (ImGui::Combo("Permutation", &permutationIndex, permutations.data(), static_cast<int>(permutations.size()))) {
      material->setPermutation(permutations[permutationIndex]);
    }
 
    Cogs::Core::showMaterialVariants(material);
 
    Cogs::Core::showMaterialOptions(context, &material->options, "Options");
 
    Cogs::Core::showMaterialProperties(material);
 
    if (!material->textureVariables.empty()) {
      if (ImGui::CollapsingHeader(("Textures [size=" + std::to_string(material->textureVariables.size()) + "]").c_str())) {
        ScopedIndent si;
        for (VariableKey texVarKey = 0; texVarKey < material->textureVariables.size(); ++texVarKey) {
          TextureValue& texVar = material->textureVariables[texVarKey];
          const std::string& tex_header = texVar.property->name;
 
          if (HandleIsValid(texVar.texture.handle)) {
            Texture* texture = texVar.texture.handle.resolve();
 
            if (ImGui::CollapsingHeader(tex_header.c_str())) {
              ScopedIndent si2;
              Cogs::Core::Renderer* renderer = dynamic_cast<Cogs::Core::Renderer*>(context->renderer);
              showTexture(context, renderer, texture, true);
 
              // Make copy of current state and change copy - then use methods to update MaterialInstance.
              TextureWithSampler textureCopy = texVar.texture;
              ImGui::PushItemWidth(ImGui::CalcTextSize("Mirror").x + ImGui::GetStyle().FramePadding.x * 2.0f + ImGui::GetTextLineHeightWithSpacing());
              if (showEnum("##sAddressMode", textureCopy.sMode)) {
                material->setTextureAddressMode(texVarKey, textureCopy.sMode, textureCopy.tMode, textureCopy.uMode);
              }
              ImGui::SameLine();
              if (showEnum("##tAddressMode", textureCopy.tMode)) {
                material->setTextureAddressMode(texVarKey, textureCopy.sMode, textureCopy.tMode, textureCopy.uMode);
              }
              ImGui::SameLine();
              if (showEnum("##uAddressMode", textureCopy.uMode)) {
                material->setTextureAddressMode(texVarKey, textureCopy.sMode, textureCopy.tMode, textureCopy.uMode);
              }
              ImGui::PopItemWidth();
 
              ImGui::SameLine();
              ImGui::SetNextItemWidth(ImGui::CalcTextSize("ComparisonMinMagMipLinear").x + ImGui::GetStyle().FramePadding.x * 2.0f + ImGui::GetTextLineHeightWithSpacing());
              if (showEnum("##filterMode", textureCopy.filterMode)) {
                material->setTextureFilterMode(texVarKey, textureCopy.filterMode);
              }
            }
          }
          else {
            ImGui::Text("%s: Empty", tex_header.c_str());
          }
 
        }
      }
    } else {
      ImGui::Text("Textures: Empty");
    }
 
    ImGui::TreePop();
  }
 
  ImGui::PopID();
}
 
void Cogs::Core::showModel(const Context * context, Model * model, const std::string & header)
{
  ImGui::PushID(model);
 
  if (ImGui::TreeNode(header.c_str())) {
    ScopedIndent si;
 
    ImGui::Text("Loaded: %s", model->isLoaded() ? "true" : "false");
 
    uint32_t maxProp = model->parts.empty() ? model->properties.size() : model->parts[0].firstProperty;
    if (uint32_t ix = model->properties.findProperty(0, maxProp, Strings::add("modelOrigin")); ix != PropertyStore::NoProperty) {
 
      if (std::span<const double> view = model->properties.getDoubleArray(ix); view.size() == 3) {
        ImGui::Text("Model origin: [%.2f %.2f %.2f]", view[0], view[1], view[2]);
      }
    }
 
 
    if (ImGui::TreeNode("Parts", "Parts: %zd", model->parts.size())) {
      size_t index = 0;
      for (auto & part : model->parts) {
        ImGui::PushID(&part);
 
        std::string name(model->getPartName(part));
 
        std::string partName = name.empty() ? (std::string("Part ") + std::to_string(index)) : name;
 
        if (ImGui::TreeNode(partName.c_str())) {
          if (part.meshIndex != uint32_t(-1)) {
            ImGui::Text("Mesh: %u", part.meshIndex);
          } else {
            ImGui::Text("Mesh: None");
          }
 
          if (part.materialIndex != uint32_t(-1)) {
            ImGui::Text("Material: %u", part.materialIndex);
          } else {
            ImGui::Text("Material: None");
          }
 
          ImGui::Text("StartIndex: %ud", part.startIndex);
          ImGui::Text("VertexCount: %ud", part.vertexCount);
 
          // Allow editing xform.
          glm::mat4 matrix = model->getPartTransform(part);
          if (showMatrix("Transform", matrix)) {
            model->setPartTransform(part, matrix);
          }
 
          ImGui::TreePop();
        }
 
        ImGui::PopID();
      }
 
      ImGui::TreePop();
    }
 
    if (ImGui::TreeNode("Meshes", "Meshes: %zd", model->meshes.size())) {
      size_t index = 0;
      for (auto & mesh : model->meshes) {
        std::string meshName = mesh->getName().empty() ? (std::string("Mesh ") + std::to_string(index)) : std::string(mesh->getName());
        ++index;
 
        showMesh(context, mesh.resolve(), meshName);
      }
 
      ImGui::TreePop();
    }
 
    if (ImGui::TreeNode("Materials", "Materials: %zd", model->materials.size())) {
      size_t index = 0;
      for (auto & material : model->materials) {
        std::string materialName = material->getName().empty() ? (std::string("Material ") + std::to_string(index)) : std::string(material->getName());
        ++index;
 
        showMaterialInstance(context, material.resolve(), materialName);
      }
 
      ImGui::TreePop();
    }
 
    if (model->skeleton.bones.size()) {
      if (ImGui::TreeNode("Skeleton")) {
        if (ImGui::TreeNode("Bones")) {
          for (auto & bone : model->skeleton.bones) {
            if (ImGui::TreeNode(bone.name.c_str())) {
              ImGui::Text("Name: %s", bone.name.c_str());
              if (bone.parentBone < model->skeleton.bones.size()) {
                ImGui::Text("Parent: %zd (%s)", bone.parentBone, model->skeleton.bones[bone.parentBone].name.c_str());
              } else {
                ImGui::Text("Parent: None");
              }
 
              ImGui::TreePop();
            }
          }
 
          ImGui::TreePop();
        }
 
        ImGui::TreePop();
      }
    }
 
    if (model->animation) {
      if (ImGui::TreeNode("Animation")) {
        auto animation = model->animation.resolve();
 
        if (ImGui::TreeNode("Clips")) {
          for (auto & clip : animation->clips) {
            if (ImGui::TreeNode(clip.name.c_str())) {
              ImGui::Text("Duration: %f", clip.duration);
              ImGui::Text("Resolution: %f", clip.resolution);
 
              if (ImGui::TreeNode("Tracks")) {
                for (auto& track : clip.tracks) {
                  std::string trackName = "Bone index " + std::to_string(track.boneIndex);
                  if (ImGui::TreeNode(trackName.c_str())) {
                    if (track.boneIndex < animation->skeleton.bones.size()) {
                      ImGui::Text("Bone: %s", animation->skeleton.bones[track.boneIndex].name.c_str());
                    }
                    ImGui::Text("Keyframes: %zd", track.translations.size());
 
                    ImGui::TreePop();
                  }
                }
 
                ImGui::TreePop();
              }
 
              ImGui::TreePop();
            }
          }
 
          ImGui::TreePop();
        }
 
        ImGui::TreePop();
      }
    }
 
    ImGui::TreePop();
  }
 
  ImGui::PopID();
}