ShadowMapInspector.cpp

#include "imgui.h"
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ICapabilities.h"
 
#include "Inspectors.h"
#include "InspectorGuiHelper.h"
#include "Context.h"
#include "Renderer/Renderer.h"
#include "Renderer/InspectorGui/InspectorGuiRenderer.h"
#include "Resources/TextureManager.h"
#include "Renderer/RenderTexture.h"
#include "Systems/Core/LightSystem.h"
#include "Utilities/Math.h"
 
namespace {
  using namespace Cogs::Core;
 
  bool orient2D(const float * P, const size_t stride, const unsigned ia, const unsigned ib, const unsigned ic)
  {
    auto a = glm::make_vec2(P + stride * ia);
    auto b = glm::make_vec2(P + stride * ib);
    auto c = glm::make_vec2(P + stride * ic);
    auto ab = glm::vec3(b - a, 0);
    auto ac = glm::vec3(c - a, 0);
    return 0.f < glm::cross(ab, ac).z;
  }
 
  // Impl. of gift wrapping / Jarvis march, not particularly tested yet.
  // stride is number of elements, not bytes.
  void basicConvexHull2D(Context* /*context*/, std::vector<unsigned>& loop, const float* P, const size_t stride, const size_t N)
  {
    if (N == 0) return;
    auto n = unsigned(N);
 
    // Find one point guaranteed to be on the convex hull.
    unsigned k0 = 0;
    auto ll = glm::make_vec2(P + k0 * stride);
    for (unsigned i = 1; i < n; i++) {
      auto p = glm::make_vec2(P + i * stride);
      if (p.x < ll.x || (p.x == ll.x && p.y < ll.y)) {
        ll = p;
        k0 = i;
      }
    }
 
    loop.push_back(k0);
    while (loop.size() < N)
    {
      unsigned e = 0;
      for (unsigned j = 1; j < n; j++) {
        if (e == loop.back() || orient2D(P, stride, j, loop.back(), e)) {
          e = j;
        }
      }
      if (loop.front() == e) {
        break;
      }
      loop.push_back(e);
    }
 
  }
 
 
  std::vector<ImVec2> buildConvexHull(Context* context, const ImVec2 o, std::vector<glm::vec3>& P, float s, const glm::mat4& M)
  {
    std::vector<unsigned> loop;
    basicConvexHull2D(context, loop, reinterpret_cast<float*>(P.data()), 3, P.size());
    std::vector<ImVec2> loop_points;
    for (auto & ix : loop) {
      auto & p = P[ix];
      auto q = glm::vec2(s / 2.f)* (glm::vec2(euclidean(M * glm::vec4(p, 1))) + glm::vec2(1));
      loop_points.push_back(ImVec2(o.x + q.x, o.y + q.y));
    }
    return loop_points;
  }
 
  std::vector<ImVec2> buildConvexHull(Context* context, const ImVec2 o, std::vector<glm::vec3>& P, float scale, float s, const glm::vec2& c)
  {
    std::vector<unsigned> loop;
    basicConvexHull2D(context, loop, reinterpret_cast<float*>(P.data()), 3, P.size());
    std::vector<ImVec2> loop_points;
    for (auto & ix : loop) {
      auto & r = P[ix];
      auto q = glm::vec2(o.x, o.y) + scale * (glm::vec2(r) - c) + glm::vec2(s / 2);
      loop_points.push_back(ImVec2(q.x, q.y));
    }
    return loop_points;
  }
 
}
 
 
void Cogs::Core::shadowMapInspector(Context * context, bool * show)
{
  if (*show == false) return;
 
  Cogs::Core::Renderer* renderer = dynamic_cast<Cogs::Core::Renderer*>(context->renderer);
  guiBegin("Shadow maps", show);
  {
    float expFactor = context->variables->get("shadows.cascades.expFactor")->getFloat();
    if (ImGui::InputFloat("shadows.cascades.expFactor", &expFactor, 0.025f, 0.1f)) {
      context->variables->set("shadows.cascades.expFactor", glm::clamp(expFactor, 0.f, 1.f));
    }
  }
  {
    float overlapFactor = context->variables->get("shadows.cascades.overlapFactor")->getFloat();
    if (ImGui::InputFloat("shadows.cascades.overlapFactor", &overlapFactor, 0.025f, 0.1f)) {
      context->variables->set("shadows.cascades.overlapFactor", glm::clamp(overlapFactor, 0.f, 1.f));
    }
  }
  {
    float maxShadowDistance = context->variables->get("renderer.maxShadowDistance")->getFloat();
    if (ImGui::InputFloat("renderer.maxShadowDistance", &maxShadowDistance, 10.f, 1000.f)) {
      context->variables->set("renderer.maxShadowDistance", glm::clamp(maxShadowDistance, 0.f, 100000.f));
    }
  }
 
  bool flipTexture = false;
  switch (context->renderer->getDevice()->getType()) {
  case Cogs::GraphicsDeviceType::OpenGL20:
  case Cogs::GraphicsDeviceType::OpenGLES30:
    flipTexture = true;
    break;
  default:
    break;
  }
 
  for (auto & lightComp : context->lightSystem->pool) {
    auto * entity = lightComp.getContainer();
 
    auto name = entity->getName() + " (" + std::to_string(entity->getId()) + ")";
 
    bool empty = false;
    if (lightComp.enabled == false) {
      name += " (disabled)";
      empty = true;
    }
    else if (lightComp.castShadows == false) {
      name += " (casts no shadows)";
      empty = true;
    }
 
    ImU32 colors[4] = {
      IM_COL32(255, 255, 0, 255),
      IM_COL32(0, 255, 0, 255),
      IM_COL32(0, 0, 255, 255),
      IM_COL32(255, 0, 255, 255)
    };
    ImU32 colors_light[4] = {
      IM_COL32(255, 255, 200, 255),
      IM_COL32(200, 255, 200, 255),
      IM_COL32(200, 200, 255, 255),
      IM_COL32(255, 200, 255, 255)
    };
 
    if (ImGui::CollapsingHeader(getUniqueHeader(name).c_str(), ImGuiTreeNodeFlags_DefaultOpen | (empty? ImGuiTreeNodeFlags_Leaf:0)) && !empty) {
      auto & lightData = context->lightSystem->getData(&lightComp);
      auto * texture = lightData.shadowTexture.resolve();
 
      if (lightComp.lightType == LightType::Directional) {
        lightData.frustaPointsCapture = true;
        const auto s = 256.0f;
        auto dl = ImGui::GetWindowDrawList();
 
        auto o = ImGui::GetCursorScreenPos();
        ImGui::InvisibleButton(getUniqueHeader(name + " canvas").c_str(), ImVec2(s, s));
        {
          auto viewportMin = lightData.frustaPoints[0].viewportMin;
          auto viewportMax = lightData.frustaPoints[0].viewportMax;
          for (unsigned i = 0; i < lightData.numViewports; i++) {
            auto & frustumPoints = lightData.frustaPoints[i];
            viewportMin = glm::min(viewportMin, frustumPoints.viewportMin);
            viewportMax = glm::max(viewportMax, frustumPoints.viewportMax);
          }
          auto size = glm::max(viewportMax.x - viewportMin.x,
                               viewportMax.y - viewportMin.y);
          auto scale = s / size;
 
          auto c = 0.5f*(viewportMin + viewportMax);
 
          for (int i = lightData.numViewports - 1; 0 <= i; --i) {
            RenderTexture * renderTexture = renderer->getRenderResources().getRenderTexture(context->textureManager->generateHandle((Texture *)texture));
            if (renderTexture) {
              auto & frustumPoints = lightData.frustaPoints[i];
              auto a = glm::vec2(o.x, o.y) + scale * (frustumPoints.viewportMin - c) + glm::vec2(s / 2);
              auto b = glm::vec2(o.x, o.y) + scale * (frustumPoints.viewportMax - c) + glm::vec2(s / 2);
 
              dl->AddCallback(setGuiMode, (void*)(uint64_t)(GUI_MODE_TEX_CHANNELS_RED | GUI_MODE_TEX_TYPE_ARRAY | (lightData.arrayOffset + i)));   // show only alpha channel for the next texture
 
              if (flipTexture) {
                dl->AddImage(ImTextureID(renderTexture->textureHandle.handle), ImVec2(a.x, a.y), ImVec2(b.x, b.y), ImVec2(0, 0), ImVec2(1, 1), colors_light[i & 3]);
              }
              else {
                dl->AddImage(ImTextureID(renderTexture->textureHandle.handle), ImVec2(a.x, a.y), ImVec2(b.x, b.y), ImVec2(0, 1), ImVec2(1, 0), colors_light[i & 3]);
              }
            }
          }
          dl->AddCallback(setGuiMode, (void*)(GUI_MODE_DEFAULT));   // restore the default texture rendering state
 
 
          for (unsigned i = 0; i < lightData.numViewports; i++) {
            auto loop_points = buildConvexHull(context, o, lightData.frustaPoints[i].points, scale, s, c);
            dl->AddPolyline(loop_points.data(), int(loop_points.size()), colors[i & 3], true, 1.f);
          }
          //for (unsigned i = 0; i < lightData.numViewports; i++) {
          //  auto & frustumPoints = lightData.frustaPoints[i];
          //  auto a = glm::vec2(o.x, o.y) + scale * (frustumPoints.viewportMin - c) + glm::vec2(s / 2);
          //  auto b = glm::vec2(o.x, o.y) + scale * (frustumPoints.viewportMax - c) + glm::vec2(s / 2);
          //  dl->AddRect(ImVec2(a.x, a.y), ImVec2(b.x, b.y), colors[i & 3], 0.f, -1, 2.f);
          //}
        }
 
        for (unsigned i = 0; i < lightData.numViewports; i++) {
          auto & lightCameraData = lightData.lightCameraData[i];
 
          RenderTexture * renderTexture = renderer->getRenderResources().getRenderTexture(context->textureManager->generateHandle((Texture *)texture));
          if (!renderTexture) continue;
 
          ImGui::SameLine();
 
          auto oo = ImGui::GetCursorScreenPos();
          ImGui::InvisibleButton(getUniqueHeader(name + " canvas lod" + std::to_string(i)).c_str(), ImVec2(s, s));
 
          dl->AddCallback(setGuiMode, (void*)(uint64_t)(GUI_MODE_TEX_CHANNELS_RED | GUI_MODE_TEX_TYPE_ARRAY | (lightData.arrayOffset + i)));   // show only alpha channel for the next texture
          if (flipTexture) {
            dl->AddImage(ImTextureID(renderTexture->textureHandle.handle), oo, ImVec2(oo.x + s, oo.y + s), ImVec2(0, 0), ImVec2(1, 1), colors_light[i & 3]);
          }
          else {
            dl->AddImage(ImTextureID(renderTexture->textureHandle.handle), oo, ImVec2(oo.x + s, oo.y + s), ImVec2(0, 1), ImVec2(1, 0), colors_light[i & 3]);
          }
          //ImGui::Image(ImTextureID(renderTexture->textureHandle.handle), ImVec2(s, s), ImVec2(0, 1), ImVec2(1, 0));
          dl->AddCallback(setGuiMode, (void*)(GUI_MODE_DEFAULT));   // restore the default texture rendering state
 
          {
 
            glm::vec4 cullBox_in[4] =
            {
              glm::vec4(-1, -1, 0, 1),
              glm::vec4(1, -1, 0, 1),
              glm::vec4(1, 1, 0, 1),
              glm::vec4(-1, 1, 0, 1),
            };
 
            ImVec2 cullBox[4];
            auto M = lightCameraData.rawViewProjection * glm::inverse(lightCameraData.rawViewCullMatrix);
 
            for (unsigned j = 0; j < 4; j++) {
              const auto q = glm::vec2(s / 2.f) * (glm::vec2(euclidean(M * cullBox_in[j])) + glm::vec2(1));
              cullBox[j] = ImVec2(oo.x + q.x, oo.y + q.y);
            }
 
            ImGui::PushClipRect(oo, ImVec2(oo.x + s, oo.y + s), true);
            dl->AddPolyline(cullBox, 4, colors[i & 3], true, 1.f);
            ImGui::PopClipRect();
          }
 
          auto loop_points = buildConvexHull(context, oo, lightData.frustaPoints[i].points, s, lightCameraData.rawProjectionMatrix);
          dl->AddPolyline(loop_points.data(), int(loop_points.size()), colors[i & 3], true, 3.f);
 
          for (auto & r : lightData.frustaPoints[i].points) {
            auto q = glm::vec2(s/2.f)* (glm::vec2(euclidean(lightCameraData.rawProjectionMatrix * glm::vec4(r, 1))) + glm::vec2(1));
            dl->AddCircleFilled(ImVec2(oo.x + q.x, oo.y + q.y), 4.f, colors[i & 3]);
          }
 
        }
      }
    }
 
  }
 
 
  guiEnd();
}