MaterialEditor.cpp

#include "MaterialEditor.h"
 
#include "imgui.h"
 
#include "Renderer/InspectorGui/InspectorGuiHelper.h"
 
#include "Resources/MaterialManager.h"
 
#include "Commands/FieldCommands.h"
#include "Commands/ResourceCommands.h"
 
void Cogs::Core::MaterialEditor::showMaterialProperties(MaterialInstanceHandle& materialInstanceHandle)
{
  MaterialInstance* material = materialInstanceHandle.resolve();
 
  for (auto& 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)) {
        editor->apply<SetMaterialPropertyCommand<float>>(materialInstanceHandle, prop.name, 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))) {
        editor->apply<SetMaterialPropertyCommand<glm::vec2>>(materialInstanceHandle, prop.name, 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))) {
          editor->apply<SetMaterialPropertyCommand<glm::vec3>>(materialInstanceHandle, prop.name, value);
        }
      }
      else {
        if (ImGui::DragFloat3(prop.name.c_str(), glm::value_ptr(value))) {
          editor->apply<SetMaterialPropertyCommand<glm::vec3>>(materialInstanceHandle, prop.name, 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))) {
          editor->apply<SetMaterialPropertyCommand<glm::vec4>>(materialInstanceHandle, prop.name, value);
        }
      }
      else {
        if (ImGui::DragFloat4(prop.name.c_str(), glm::value_ptr(value))) {
          editor->apply<SetMaterialPropertyCommand<glm::vec4>>(materialInstanceHandle, prop.name, value);
        }
      }
    }
    break;
 
 
    case MaterialDataType::Float4x4:
    {
      glm::mat4 value = {};
      material->getProperty(prop.key, &value, sizeof(value));
      if (showMatrix(prop.name, value)) {
        editor->apply<SetMaterialPropertyCommand<glm::mat4>>(materialInstanceHandle, prop.name, 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)) {
        editor->apply<SetMaterialPropertyCommand<int32_t>>(materialInstanceHandle, prop.name, 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)) {
        editor->apply<SetMaterialPropertyCommand<uint32_t>>(materialInstanceHandle, prop.name, (uint32_t)value);
      }
    }
    break;
 
    case MaterialDataType::Bool:
    {
      bool value = {};
      material->getProperty(prop.key, &value, sizeof(value));
      if (ImGui::Checkbox(prop.name.c_str(), &value)) {
        editor->apply<SetMaterialPropertyCommand<bool>>(materialInstanceHandle, prop.name, value);
      }
    }
    break;
 
    default:
      editor->showText("Unsupported: %d", static_cast<int>(prop.type));
      break;
    }
  }
}
 
bool Cogs::Core::MaterialEditor::showMaterialInstance(FieldInfo & fieldInfo, MaterialInstanceHandle & materialInstanceHandle)
{
  auto state = editor->getState();
 
  if (!materialInstanceHandle) {
    if (editor->imageButton(Icon::New, 26, 2)) {
      auto material = context->materialManager->getMaterial("StandardMaterial");
      auto materialInstance = context->materialInstanceManager->createMaterialInstance(material);
 
      editor->apply<SetFieldCommand<MaterialInstanceHandle>>(state->selected, fieldInfo, materialInstance);
 
      return true;
    }
  } else {
    if (materialInstanceHandle->material->getName() == "StandardMaterial") {
      MaterialInstance* material = materialInstanceHandle.resolve();
 
      for (auto & texVar : material->textureVariables) {
        auto & name = texVar.property->name;
 
        TextureHandle& value = texVar.texture.handle;
 
        ImGui::PushID(&texVar.texture.handle);
 
        if (editor->showTexture(name, value)) {
          editor->apply<SetTexturePropertyCommand>(materialInstanceHandle, name, value);
 
          if (name == "albedoMap") {
            material->setVariant("AlbedoMap", true);
          } else if (name == "normalMap") {
            material->setVariant("NormalMap", true);
          } else if (name == "specularMap") {
            material->setVariant("SpecularMap", true);
          } else if (name == "roughnessMap") {
            material->setVariant("RoughnessMap", true);
          } else if (name == "metallicMap") {
            material->setVariant("MetallicMap", true);
          } else if (name == "opacityMap") {
            material->setVariant("OpacityMap", true);
          }
 
          material->setVariant("Textured", true);
          material->setChanged();
        }
 
        ImGui::PopID();
      }
    }
 
    auto material = materialInstanceHandle.resolve();
 
    std::string flags;
    flags += material->isBackdrop() ? "Backdrop " : "";
    flags += material->hasTransparency() ? "Transparent " : "";
    flags += material->isDefaultMaterial() ? "Default " : "";
    flags = flags.size() ? "Flags: " + flags : "Flags: None";
 
    editor->showText("%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::MaterialEditor::showMaterialProperties(materialInstanceHandle);
  }
 
  return false;
}