PipelineInspector.cpp

#include "Inspectors.h"
 
#include "InspectorGuiHelper.h"
#include "Context.h"
 
#include "Services/Variables.h"
 
#include "Renderer/Renderer.h"
#include "Renderer/RenderPipelineManager.h"
#include "Renderer/RenderTexture.h"
#include "Renderer/RenderList.h"
#include "Renderer/RenderTarget.h"
#include "Renderer/RenderBuffer.h"
#include "Renderer/RenderMaterialInstance.h"
 
#include "Renderer/Tasks/GenerateListTask.h"
#include "Renderer/Tasks/ProcessTask.h"
#include "Renderer/Tasks/PostProcessTask.h"
#include "Renderer/Tasks/FilterListTask.h"
#include "Renderer/Tasks/RenderListTask.h"
 
#include "Resources/TextureManager.h"
 
#include "Foundation/Reflection/TypeDatabase.h"
 
 
using namespace Cogs::Reflection;
 
namespace {
  using namespace Cogs::Core;
 
  void binaryNumber(uint32_t number)
  {
    ImGui::Text("0b_%u%u%u%u_%u%u%u%u_%u%u%u%u_%u%u%u%u_%u%u%u%u_%u%u%u%u_%u%u%u%u_%u%u%u%u",
                (number & (1 << 31)) ? 1 : 0,
                (number & (1 << 30)) ? 1 : 0,
                (number & (1 << 29)) ? 1 : 0,
                (number & (1 << 28)) ? 1 : 0,
                (number & (1 << 27)) ? 1 : 0,
                (number & (1 << 26)) ? 1 : 0,
                (number & (1 << 25)) ? 1 : 0,
                (number & (1 << 24)) ? 1 : 0,
                (number & (1 << 23)) ? 1 : 0,
                (number & (1 << 22)) ? 1 : 0,
                (number & (1 << 21)) ? 1 : 0,
                (number & (1 << 20)) ? 1 : 0,
                (number & (1 << 19)) ? 1 : 0,
                (number & (1 << 18)) ? 1 : 0,
                (number & (1 << 17)) ? 1 : 0,
                (number & (1 << 16)) ? 1 : 0,
                (number & (1 << 15)) ? 1 : 0,
                (number & (1 << 14)) ? 1 : 0,
                (number & (1 << 13)) ? 1 : 0,
                (number & (1 << 12)) ? 1 : 0,
                (number & (1 << 11)) ? 1 : 0,
                (number & (1 << 10)) ? 1 : 0,
                (number & (1 << 9)) ? 1 : 0,
                (number & (1 << 8)) ? 1 : 0,
                (number & (1 << 7)) ? 1 : 0,
                (number & (1 << 6)) ? 1 : 0,
                (number & (1 << 5)) ? 1 : 0,
                (number & (1 << 4)) ? 1 : 0,
                (number & (1 << 3)) ? 1 : 0,
                (number & (1 << 2)) ? 1 : 0,
                (number & (1 << 1)) ? 1 : 0,
                (number & (1 << 0)) ? 1 : 0);
  }
 
  void showRenderItem(Context* /*context*/, Renderer* renderer, const RenderItem & item, size_t ix)
  {
    std::string header = "Item " + std::to_string(ix);
    if ((item.stateChanges & StateChangeFlags::ChangeAll) == StateChangeFlags::ChangeAll) {
      header += " All";
    } else {
      if ((item.stateChanges & StateChangeFlags::ChangeTransform) != 0) {
        header += " Tr";
      }
      if ((item.stateChanges & StateChangeFlags::ChangeMesh) != 0) {
        header += " Msh";
      }
      if ((item.stateChanges & StateChangeFlags::ChangeMaterialInstance) != 0) {
        header += " MatI";
      }
      if ((item.stateChanges & StateChangeFlags::ChangeMaterialVariant) != 0) {
        header += " MatV";
      }
      if ((item.stateChanges & StateChangeFlags::ChangeRasterizerState) != 0) {
        header += " Ras";
      }
      if ((item.stateChanges & StateChangeFlags::ChangeBlendState) != 0) {
        header += " Bld";
      }
      if ((item.stateChanges & StateChangeFlags::ChangeDepthStencilState) != 0) {
        header += " Dpt";
      }
      if ((item.stateChanges & StateChangeFlags::ChangeLayer) != 0) {
        header += " Lay";
      }
      if ((item.stateChanges & StateChangeFlags::ChangeViewport) != 0) {
        header += " VPort";
      }
    }
    if (item.materialInstance && item.materialInstance->material) {
      header.append(" mat=");
      header.append(item.materialInstance->material->definition.name);
      RenderMaterialInstance * renderMaterialInstance = renderer->getRenderResources().getRenderMaterialInstance(item.materialInstance);
      if (!renderMaterialInstance) {
        header.append("(no render material)");
      }
      else {
        header.append("(");
        if (renderMaterialInstance->loadedBindings.empty()) {
          header.append("no bindings");
        }
        else {
          for (auto & binding : renderMaterialInstance->loadedBindings) {
            if (binding.enginePermutation) {
              header.append(binding.enginePermutation->getName());
            }
            else {
              header.append("<no engine perm>");
            }
            header.append(": ");
            if (binding.binding) {
              if (binding.binding->renderEffect) {
                header.append("has renderEffect");
              }
              else {
                header.append("<no renderEffect>");
              }
            }
            else {
              header.append("<no binding>");
            }
          }
        }
        header.append(")");
      }
    }
    ImGui::Text("%s", header.c_str());
  }
 
  void showRenderList(Context* context, Renderer* renderer, const RenderBatch& batch, const std::string& name)
  {
    if (batch.empty()) return;
 
    if (ImGui::TreeNode(name.c_str(), "%s (%zu items)", name.c_str(), batch.size())) {
      for (size_t i = 0; i < batch.size(); i++) {
        showRenderItem(context, renderer, batch[i], i);
      }
      ImGui::TreePop();
    }
  }
  void showRenderList(Context* context, Renderer* renderer, const RenderItems& items, const std::string& name)
  {
    if (items.empty()) return;
 
    if (ImGui::TreeNode(name.c_str(), "%s (%zu items)", name.c_str(), items.size())) {
      for (size_t i = 0; i < items.size(); i++) {
        showRenderItem(context, renderer, items[i], i);
      }
      ImGui::TreePop();
    }
  }
 
  void showRenderTarget(Context* /*context*/, Renderer* /*renderer*/, const RenderTarget * renderTarget)
  {
    ImGui::Text("Width"); ImGui::SameLine(250.f); ImGui::Text("%u", renderTarget->width);
    ImGui::Text("Height"); ImGui::SameLine(250.f); ImGui::Text("%u", renderTarget->height);
    ImGui::Text("Subresource index"); ImGui::SameLine(250.f); ImGui::Text("%u", renderTarget->subresourceIndex);
    ImGui::Text("Depth layer index"); ImGui::SameLine(250.f); ImGui::Text("%u", renderTarget->depthLayerIndex);
    ImGui::Text("Level views"); ImGui::SameLine(250.f); ImGui::Text("%zu", renderTarget->mipLevelViews.size());
 
    auto size = ImVec2(128, 128);
    float aspectRatio = 1;
    if (renderTarget->width > 0 && renderTarget->height > 0) {
      aspectRatio = static_cast<float>(renderTarget->width) / static_cast<float>(renderTarget->height);
    }
 
    if (aspectRatio < 1) {
      size.x *= aspectRatio;
    } else {
      size.y /= aspectRatio;
    }
 
    ImGui::BeginGroup();
 
    for (size_t i = 0; i < renderTarget->textures.size(); i++) {
      if (i != 0) ImGui::SameLine(100 + i*150.f);
      ImGui::Text("    Tex %zu", i);
    }
    for (size_t i = 0; i < renderTarget->textures.size(); i++) {
      if (i != 0) ImGui::SameLine(100 + i*150.f);
      ImGui::Image(ImTextureID(renderTarget->textures[i]->textureHandle.handle), size);
    }
 
    if (renderTarget->depth) {
      ImGui::Text("    Depth");
      ImGui::Image(ImTextureID(renderTarget->depth->textureHandle.handle), size);
    }
 
    ImGui::EndGroup();
  }
 
  void showResource(Context* context, Renderer* renderer, const RenderTaskResource* resource)
  {
    constexpr char const * fmtTitle[] = {
      "Unknown",
      "%s [TaskResource@0x%p]",
      "%s [RenderTarget@0x%p]",
      "%s [RenderList@0x%p]",
      "%s [RenderBuffer@0x%p]",
      "%s [RenderTexture@0x%p]",
      "Error",
    };
 
    ImGui::PushID(resource);
    if (ImGui::TreeNode("RenderResource", fmtTitle[static_cast<int>(resource->type)], std::string(resource->resource->getName()).c_str(), resource->resource)) {
      switch (resource->type)
      {
      case RenderResourceType::RenderTarget:
      {
        showRenderTarget(context, renderer, resource->renderTarget);
        break;
      }
      case RenderResourceType::RenderList:
      {
        auto renderList = resource->renderList;
        showRenderList(context, renderer, renderList->batch, "All items");
        showRenderList(context, renderer, renderList->buckets[size_t(BucketType::Backdrop)], "Backdrop bucket");
        showRenderList(context, renderer, renderList->buckets[size_t(BucketType::SolidOrderedBack)], "Solid ordered back bucket");
        showRenderList(context, renderer, renderList->buckets[size_t(BucketType::Solid)], "Solid bucket");
        showRenderList(context, renderer, renderList->buckets[size_t(BucketType::SolidOrderedFront)], "Solid ordered front bucket");
        showRenderList(context, renderer, renderList->buckets[size_t(BucketType::Transparent)], "Transparent bucket");
        showRenderList(context, renderer, renderList->buckets[size_t(BucketType::Overlay)], "Overlay bucket");
        showRenderList(context, renderer, renderList->buckets[size_t(BucketType::Custom)], "Custombucket");
        break;
      }
      case RenderResourceType::RenderTexture:
      {
        showRenderTexture(context, renderer, resource->renderTexure);
        break;
      }
      case RenderResourceType::RenderBuffer:
      case RenderResourceType::TaskResource:
      default:
        break;
      }
 
      ImGui::TreePop();
    }
 
    ImGui::PopID();
  }
 
  void showTaskInner(Context* /*context*/, Renderer* /*renderer*/, const GenerateListTask* task)
  {
    if (task == nullptr) return;
 
    ImGui::Text("list obj buffer %u of %u, size=%zukb",
                task->listObjectBuffer.fill,
                task->listObjectBuffer.cpuCapacity,
                ((size_t(task->listObjectBuffer.stride) * task->listObjectBuffer.gpuCapacity) + 1023) / 1024);
  }
 
  void showTaskInner(Context* /*context*/, Renderer* /*renderer*/, const ProcessTask* task)
  {
    if (task == nullptr) return;
 
  }
 
  void showTaskInner(Context* /*context*/, Renderer* /*renderer*/, const PostProcessTask* task)
  {
    if (task == nullptr) return;
 
  }
 
  void showTaskInner(Context* /*context*/, Renderer* renderer, const FilterListTask* task)
  {
    if (task == nullptr) return;
 
    ImGui::Text("BucketMask");
    ImGui::SameLine(250.f);
    ImGui::Text("%s%s%s%s%s%s%s",
                hasBucket(task->bucketMask, BucketType::Backdrop) ? "BucketBackdrop " : "",
                hasBucket(task->bucketMask, BucketType::SolidOrderedBack) ? "SolidOrderedBack " : "",
                hasBucket(task->bucketMask, BucketType::Solid) ? "Solid " : "",
                hasBucket(task->bucketMask, BucketType::SolidOrderedFront) ? "SolidOrderedFront " : "",
                hasBucket(task->bucketMask, BucketType::Transparent) ? "Transparent " : "",
                hasBucket(task->bucketMask, BucketType::Overlay) ? "Overlay " : "",
                hasBucket(task->bucketMask, BucketType::Custom) ? "Custom " : "");
 
    ImGui::Text("Wireframe");
    ImGui::SameLine(250.f);
    ImGui::Text("%s", task->wireframe ? "yes" : "no");
 
    ImGui::Text("RenderMask");
    ImGui::SameLine(250.f);
    ImGui::Text("%s%s%s%s",
      ((task->renderMask & RenderLayers::Default) != RenderLayers::None) ? "Default " : "",
      ((task->renderMask & RenderLayers::Ocean) != RenderLayers::None) ? "Ocean " : "",
      ((task->renderMask & RenderLayers::Annotations) != RenderLayers::None) ? "Annotations " : "",
      ((task->renderMask & RenderLayers::Sky) != RenderLayers::None) ? "Sky " : "");
 
    ImGui::Text("Permutation");
    ImGui::SameLine(250.f);
    ImGui::Text("%s", renderer->getEnginePermutations().get(task->permutation)->getName().c_str());
 
  }
 
  void showTaskInner(Context* /*context*/, Renderer* renderer, const RenderListTask* task)
  {
    if (task == nullptr) return;
 
    ImGui::Columns(2);
    ImGui::TextUnformatted("Object buffer mode:");
    ImGui::NextColumn();
    switch (task->objectBufferMode) {
    case RenderListTask::ObjectBufferMode::Single:
      ImGui::TextUnformatted("Single");
      break;
    case RenderListTask::ObjectBufferMode::Batched:
      ImGui::TextUnformatted("Batched");
      break;
    case RenderListTask::ObjectBufferMode::List:
      ImGui::TextUnformatted("List");
      break;
    }
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Permutation index:");
    ImGui::NextColumn();
    ImGui::Text("%s (%zu)", renderer->getEnginePermutations().get(task->permutationIndex)->getName().c_str(), task->permutationIndex);
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Bucket mask:");
    ImGui::NextColumn();
    binaryNumber(uint32_t(task->bucketMask));
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("State change mask:");
    ImGui::NextColumn();
    binaryNumber(uint32_t(task->stateChangeMask));
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Lighting layers:");
    ImGui::NextColumn();
    binaryNumber(uint32_t(task->lightingMask));
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Blend mode:");
    ImGui::NextColumn();
    ImGui::Text("%u", uint32_t(task->blendMode));
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Depth mode:");
    ImGui::NextColumn();
    ImGui::Text("%u", uint32_t(task->depthMode));
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Depth func:");
    ImGui::NextColumn();
    ImGui::Text("%u", uint32_t(task->depthFunc));
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Clear color:");
    ImGui::NextColumn();
    ImGui::TextUnformatted(task->colorClear ? "yes" : "no");
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Clear depth:");
    ImGui::NextColumn();
    ImGui::TextUnformatted(task->depthClear ? "yes" : "no");
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Depth write:");
    ImGui::NextColumn();
    ImGui::TextUnformatted(task->depthWrite ? "yes" : "no");
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Discard color:");
    ImGui::NextColumn();
    ImGui::TextUnformatted(task->discardColor ? "yes" : "no");
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Discard depth:");
    ImGui::NextColumn();
    ImGui::TextUnformatted(task->discardDepth ? "yes" : "no");
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Default viewport size:");
    ImGui::NextColumn();
    ImGui::Text("[%d x %d]", task->defaultViewportSize.x, task->defaultViewportSize.y);
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Viewport from target:");
    ImGui::NextColumn();
    ImGui::TextUnformatted(task->viewportFromTarget ? "yes" : "no");
    ImGui::NextColumn();
 
    ImGui::TextUnformatted("Temporal offsets:");
    ImGui::NextColumn();
    ImGui::TextUnformatted(task->temporalOffsets ? "yes" : "no");
    ImGui::NextColumn();
 
  }
 
  void showTask(Context* context, Renderer* renderer, const RenderTask* task)
  {
    std::string id = std::to_string(reinterpret_cast<size_t>(task));
    std::string name = task->name.empty() ? "<unnamed>" : task->name;
 
    if (task->flags & RenderTaskFlags::Persistent) {
      name += " [persistent]";
    }
 
    if (ImGui::TreeNode(id.c_str(), "%s", name.c_str())) {
 
      if (!task->input.resources.empty()) {
        if (ImGui::TreeNode("Inputs")) {
          for (const auto & resource : task->input.resources) {
            showResource(context, renderer, &resource);
          }
          ImGui::TreePop();
        }
      }
 
      if (!task->output.resources.empty()) {
        if (ImGui::TreeNode("Outputs")) {
          for (const auto & resource : task->output.resources) {
            showResource(context, renderer, &resource);
          }
          ImGui::TreePop();
        }
      }
 
      if (!task->dependencies.empty()) {
        if (ImGui::TreeNode("Dependencies")) {
          for (auto & dependency : task->dependencies) {
            ImGui::Text("%s", dependency.c_str());
          }
          ImGui::TreePop();
        }
      }
 
      if (!task->options.empty()) {
        if (ImGui::TreeNode("Options")) {
          for (auto & option : task->options) {
            ImGui::Text("%s=%s", option.first.c_str(), option.second.c_str());
          }
          ImGui::TreePop();
        }
      }
 
      showTaskInner(context, renderer, dynamic_cast<const GenerateListTask*>(task));
      showTaskInner(context, renderer, dynamic_cast<const ProcessTask*>(task));
      showTaskInner(context, renderer, dynamic_cast<const PostProcessTask*>(task));
      showTaskInner(context, renderer, dynamic_cast<const FilterListTask*>(task));
      showTaskInner(context, renderer, dynamic_cast<const RenderListTask*>(task));
 
      ImGui::TreePop();
    }
  }
 
  void showTasks(Context* context, Renderer* renderer)
  {
    std::vector<const PipelineInstance *> instances;
    instances.reserve(renderer->getPipelineManager()->getPipelineInstances().size());
    for (auto & it : renderer->getPipelineManager()->getPipelineInstances()) {
      instances.push_back(it.second.get());
    }
 
    std::sort(instances.begin(), instances.end(), [](const PipelineInstance * a, const PipelineInstance * b) { return a->priority < b->priority; });
 
    if (ImGui::TreeNode("Global resources")) {
      RenderTaskResource r;
      r.type = RenderResourceType::RenderList;
      r.key = "";
      r.renderList = const_cast<RenderList*>(renderer->getPipelineManager()->getMainRenderList());
      showResource(context, renderer, &r);
      ImGui::TreePop();
    }
 
    if (ImGui::TreeNode("Global tasks")) {
      showTask(context, renderer, renderer->getPipelineManager()->getGenerateListTask());
      ImGui::TreePop();
    }
 
    if (ImGui::TreeNode("Pipeline instance sequence")) {
      uint32_t id = 0;
      for (const auto instance : instances) {
        std::string name = "Unknown";
        if (!instance->name.empty()) {
          name = instance->name;
        }
 
        RenderPipelineDefinition * def = nullptr;
        if (instance->definitionKey != 0) {
          def = &renderer->getPipelineManager()->definitionByKey(context, instance->definitionKey);
          name += ", def=" + def->name;
        }
 
        ImGui::PushID(instance);
        if (ImGui::TreeNode("Instance", "%d: %s", id++, name.c_str())) {
 
          if (!instance->pipeline.updateResources.resources.empty()) {
            if (ImGui::TreeNode("Update resources")) {
              for (const auto & resource : instance->pipeline.updateResources.resources) {
                showResource(context, renderer, &resource);
              }
              ImGui::TreePop();
            }
          }
          if (!instance->pipeline.resources.resources.empty()) {
            if (ImGui::TreeNode("Resources")) {
              for (const auto & resource : instance->pipeline.resources.resources) {
                showResource(context, renderer, &resource);
              }
              ImGui::TreePop();
            }
          }
          if (!instance->pipeline.tasks.empty()) {
            if (ImGui::TreeNode("Tasks")) {
              for (const auto * task : instance->pipeline.tasks) {
                showTask(context, renderer, task);
              }
              ImGui::TreePop();
            }
          }
          ImGui::TreePop();
        }
        ImGui::PopID();
      }
 
      ImGui::TreePop();
    }
  }
}
 
void Cogs::Core::pipelineInspector(class Context * context, bool * show)
{
  if (!*show) return;
  
  ImGui::SetNextWindowSize(ImVec2(600, 300), ImGuiCond_FirstUseEver);
  ImGui::Begin("Pipeline", show, 0);
 
  const char* tabs[2] = { "Pipeline Structure", "Settings" };
 
  static int tab = 0;
  ImGuiStyle & style = ImGui::GetStyle();
  ImVec2 itemSpacing = style.ItemSpacing;
  ImVec4 color = style.Colors[ImGuiCol_Button];
  ImVec4 colorActive = style.Colors[ImGuiCol_ButtonActive];
  ImVec4 colorHover = style.Colors[ImGuiCol_ButtonHovered];
 
  style.ItemSpacing.x = 1;
  style.ItemSpacing.y = 0;
 
  for (int i = 0; i < static_cast<int>(sizeof(tabs) / sizeof(const char*)); i++) {
    if (i != 0) ImGui::SameLine();
 
    if (i == tab) {
      style.Colors[ImGuiCol_Button] = colorActive;
      style.Colors[ImGuiCol_ButtonActive] = colorActive;
      style.Colors[ImGuiCol_ButtonHovered] = colorActive;
    }
    if (ImGui::Button(tabs[i])) tab = i;
    if (i == tab) {
      style.Colors[ImGuiCol_Button] = color;
      style.Colors[ImGuiCol_ButtonActive] = colorActive;
      style.Colors[ImGuiCol_ButtonHovered] = colorHover;
    }
  }
 
  style.ItemSpacing = itemSpacing;
  ImGui::Separator();
 
  switch (tab)
  {
  case 0:
    {
      Cogs::Core::Renderer* renderer = dynamic_cast<Cogs::Core::Renderer*>(context->renderer);
      showTasks(context, renderer);
      break;
    }
  case 1: break;
  default:
    break;
  }
 
  ImGui::End();
}
 
void Cogs::Core::permutationInspector(class Context * context, bool * show)
{
  if (!*show) return;
 
  ImGui::Begin("Permutations", show);
 
  for(size_t i=0, n= context->renderer->getEnginePermutations().size(); i<n; i++) {
    EnginePermutation* permutation = context->renderer->getEnginePermutations().get(i);
 
    ImGui::PushID(permutation);
    if (ImGui::TreeNode(permutation->getName().c_str())) {
      auto & properties = permutation->constantBuffers.variables;
      if (!properties.empty()) {
        if (ImGui::TreeNode("Properties")) {
          for (auto & prop : properties) {
            if (prop.type == MaterialDataType::Float) {
              float value = 0;
              if (ImGui::SliderFloat(prop.name.c_str(), &value, 0.0f, 2.0f)) {
                permutation->constantBuffers.buffers[prop.buffer].setValue(prop.descriptor.offset, value);
              }
            } else if (prop.type == MaterialDataType::Float4) {
              glm::vec4 value(0);
              if (ImGui::DragFloat4(prop.name.c_str(), glm::value_ptr(value), 0.01f, 0.0f, 2.0f)) {
                permutation->constantBuffers.buffers[prop.buffer].setValue(prop.descriptor.offset, value);
              }
            }
          }
 
          ImGui::TreePop();
        }
      }
 
      ImGui::TreePop();
    }
    ImGui::PopID();
  }
 
 
  ImGui::End();
}