MaterialInspector.cpp

#include "Inspectors.h"
 
#include "InspectorGuiHelper.h"
#include "Context.h"
#include "Resources/MaterialManager.h"
 
#include "Resources/MaterialInstance.h"
#include "Resources/Texture.h"
 
#include "imgui.h"
 
using namespace Cogs::Core;
 
namespace {
  void ShowPropertiy(Material* material, MaterialProperty &prop)
  {
    auto& buffer = material->constantBuffers.buffers[prop.buffer];
    switch (prop.type) {
    case MaterialDataType::Float:
    {
      float value = buffer.getValue<float>(prop.descriptor.offset);
      if (ImGui::DragFloat(prop.name.c_str(), &value, 0.01f, 0.0f, 1.0f)) {
        buffer.setValue(prop.descriptor.offset, value);
      }
    }
    break;
 
    case MaterialDataType::Int:
    {
      int32_t value = buffer.getValue<int32_t>(prop.descriptor.offset);
      if (ImGui::DragInt(prop.name.c_str(), &value, 1.0f, 0, 100)) {
        buffer.setValue(prop.descriptor.offset, value);
      }
    }
    break;
 
    case MaterialDataType::Bool:
    {
      bool value = buffer.getValue<bool>(prop.descriptor.offset);
      if (ImGui::Checkbox(prop.name.c_str(), &value)) {
        buffer.setValue(prop.descriptor.offset, value);
      }
    }
    break;
 
    case MaterialDataType::Float2:
    {
      glm::vec2 value = buffer.getValue<glm::vec2>(prop.descriptor.offset);
      if (ImGui::DragFloat2(prop.name.c_str(), glm::value_ptr(value))) {
        buffer.setValue(prop.descriptor.offset, value);
      }
    }
    break;
 
    case MaterialDataType::Float3:
    {
      glm::vec3 value = buffer.getValue<glm::vec3>(prop.descriptor.offset);
      if (ImGui::DragFloat3(prop.name.c_str(), glm::value_ptr(value))) {
        buffer.setValue(prop.descriptor.offset, value);
      }
    }
    break;
 
    case MaterialDataType::Float4:
    {
      glm::vec4 value = buffer.getValue<glm::vec4>(prop.descriptor.offset);
      if (ImGui::DragFloat4(prop.name.c_str(), glm::value_ptr(value))) {
        buffer.setValue(prop.descriptor.offset, value);
      }
    }
    break;
 
    case MaterialDataType::Float4x4:
    {
      auto value = buffer.getValue<glm::mat4>(prop.descriptor.offset);
      if (showMatrix(prop.name, value)) {
        buffer.setValue(prop.descriptor.offset, value);
      }
    }
    break;
 
    case MaterialDataType::UInt:
    {
      int32_t value = (int32_t)buffer.getValue<uint32_t>(prop.descriptor.offset);
      if (ImGui::DragInt(prop.name.c_str(), &value, 1.0f, 0, 100)) {
        buffer.setValue(prop.descriptor.offset, (uint32_t)value);
      }
    }
    break;
 
    default:
      ImGui::Text("Unsupported: %d", static_cast<int>(prop.type));
      break;
    }
  }
}
 
void showMaterial(Context * context, Material * material, const std::string & header)
{
  ImGui::PushID(material);
 
  if (ImGui::TreeNode(header.c_str())) {
    ScopedIndent si;
 
    if (!material->constantBuffers.variables.empty()) {
      if (ImGui::TreeNode("Properties")) {
        for (auto & prop : material->constantBuffers.variables) {
          ShowPropertiy(material, prop);
        }
        ImGui::TreePop();
      }
    } else {
      ImGui::Text("Properties: Empty");
    }
 
    if (!material->textureProperties.empty() && ImGui::TreeNode("Textures")) {
      ScopedIndent si2;
      for (auto & prop : material->textureProperties) {
        if (!prop.texture.handle) {
          ImGui::Text("%s: Empty", prop.name.c_str());
        } else {
          if (ImGui::TreeNode(prop.name.c_str())) {
            ScopedIndent si3;
 
            showTexture(context, dynamic_cast<Cogs::Core::Renderer *>(context->renderer), prop.texture.handle.resolve());
 
            ImGui::TreePop();
          }
        }
      }
 
      ImGui::TreePop();
    }
 
    bool hasSharedVariants = false;
    if (!material->definition.variants.empty()) {
      for (const ShaderVariantDefinition& v : material->definition.variants) {
        if (v.isShared) {
          hasSharedVariants = true;
          break;
        }
      }
    }
    if (hasSharedVariants && ImGui::TreeNode("Variants")) {
      for (ShaderVariantDefinition& v : material->definition.variants) {
        if (!v.isShared) continue;
        size_t value = v.defaultValue;
 
        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()))) {
            // The shared setVariant function is not yet created for enums
          }
        }
        break;
 
        case ShaderVariantType::Bool:
          if (bool boolean = value != 0; ImGui::Checkbox(v.name.c_str(), &boolean)) {
            // The shared setVariant function is not yet created for bools
          }
          break;
 
        case ShaderVariantType::Int:
          if (int integer = static_cast<int>(value); ImGui::InputInt(v.name.c_str(), &integer, 1)) {
            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();
    }
 
    if (!material->constantBuffers.buffers.empty()) {
      if (ImGui::TreeNode("Buffers")) {
        ScopedIndent si2;
        for (auto & buffer : material->constantBuffers.buffers) {
          ImGui::Text("%s", buffer.name.c_str());
          ImGui::Text("  Size: %zu", buffer.size); ImGui::SameLine();
          ImGui::Text("  Shared: %s", buffer.isPerInstance ? "false" : "true"); ImGui::SameLine();
          ImGui::Text("  Gen: %zu", buffer.generation);
 
          ImGui::PushID(&buffer);
          if (!material->constantBuffers.variables.empty() && ImGui::TreeNode("Properties")) {
            for (auto& prop : material->constantBuffers.variables) {
              if (prop.buffer != buffer.index) continue;
              ShowPropertiy(material, prop);
            }
            ImGui::TreePop();
          }
          ImGui::PopID();
        }
        ImGui::TreePop();
      }
    }
 
    showMaterialOptions(context, &material->options, "Options");
 
    ImGui::TreePop();
  }
 
  ImGui::PopID();
}
 
void Cogs::Core::materialInspector(Context * context, bool * show)
{
  if (*show) {
    ImGui::SetNextWindowSize(ImVec2(600, 1000), ImGuiCond_Once);
 
    std::vector<Cogs::Core::ResourceBase*> materials = context->materialManager->getAllocatedResources();
    guiBegin("Materials " + std::to_string(materials.size()), show);
 
    int id = 0;
    for (auto & m : materials) {
      auto material = static_cast<Material *>(m);
      std::string header = (!material->getName().empty() ? std::string(material->getName()) : "Material " + std::to_string(id++));
      showMaterial(context, material, header);
    }
 
    guiEnd();
  }
}
 
 
void Cogs::Core::materialInstanceInspector(Context* context, bool* show)
{
  if (*show) {
    ImGui::SetNextWindowSize(ImVec2(600, 1000), ImGuiCond_Once);
 
    std::vector<Cogs::Core::ResourceBase*> materials = context->materialInstanceManager->getAllocatedResources();
    guiBegin("Material Instances " + std::to_string(materials.size()), show);
 
    int id = 0;
    for (auto& m : materials) {
      auto material = static_cast<MaterialInstance*>(m);
      std::string header = (!material->getName().empty() ? std::string(material->getName()) : "Material " + std::to_string(id++));
      showMaterialInstance(context, material, header);
    }
 
    guiEnd();
  }
}