add renderer helper debug to pipeline

CMakeLists.txt

@@ -178,7 +178,7 @@ set(ENGINE_RENDERER
 #    src/limitless/pipeline/common/ssao_pass.cpp
 #    src/limitless/pipeline/common/fxaa_pass.cpp
     src/limitless/renderer/screen_pass.cpp
-#    src/limitless/pipeline/common/render_debug_pass.cpp
+    src/limitless/renderer/render_debug_pass.cpp
 #    src/limitless/pipeline/common/dof_pass.cpp
     src/limitless/renderer/outline_pass.cpp
 #    src/limitless/pipeline/common/ssr_pass.cpp

include/limitless/renderer/render_debug_pass.hpp

@@ -8,14 +8,9 @@ namespace Limitless {
     class RenderDebugPass final : public RendererPass {
     private:
         RendererHelper helper;
-        Lighting* lighting {};
     public:
-        explicit RenderDebugPass(Pipeline& pipeline, const RendererSettings& settings);
-        ~RenderDebugPass() override = default;
+        explicit RenderDebugPass(Renderer& renderer);
 
-        void update(Scene& scene, Instances& instances, Context& ctx, const Camera& camera) override;
-        void
-        draw(InstanceRenderer &renderer, Scene &scene, Context &ctx, const Assets &assets, const Camera &camera,
-             UniformSetter &setter) override;
+        void render(InstanceRenderer &renderer, Scene &scene, Context &ctx, const Assets &assets, const Camera &camera, UniformSetter &setter) override;
     };
 }

include/limitless/util/renderer_helper.hpp

@@ -13,10 +13,10 @@ namespace Limitless {
         const RendererSettings& settings;
         void renderLightsVolume(Context& context, const Lighting& lighting, const Assets& assets, const Camera& camera);
         void renderCoordinateSystemAxes(Context& context, const Assets& assets);
-        void renderBoundingBoxes(Context& context, const Assets& assets, const Camera& camera, Instances& instances);
+        void renderBoundingBoxes(Context& context, const Assets& assets, const Camera& camera, Scene& scene);
     public:
         explicit RendererHelper(const RendererSettings& settings);
 
-        void render(Context& context, const Assets& assets, const Camera& camera, const Lighting& lighting, Instances& instances);
+        void render(Context& context, const Assets& assets, const Camera& camera, const Lighting& lighting, Scene& scene);
     };
 }

src/limitless/renderer/render_debug_pass.cpp

@@ -1,29 +1,23 @@
 #include <limitless/renderer/render_debug_pass.hpp>
 
 #include <limitless/core/context.hpp>
-#include "limitless/core/uniform/uniform.hpp"
 #include <limitless/assets.hpp>
-#include "limitless/core/shader/shader_program.hpp"
-#include <limitless/pipeline/pipeline.hpp>
-#include <limitless/renderer/composite_pass.hpp>
-#include <limitless/util/renderer_helper.hpp>
+#include <limitless/renderer/renderer.hpp>
 #include <limitless/scene.hpp>
-using namespace Limitless;
-
-RenderDebugPass::RenderDebugPass(Pipeline& pipeline, const RendererSettings& settings)
-    : RendererPass(pipeline)
-    , helper {settings} {
-}
 
-void RenderDebugPass::draw(InstanceRenderer &renderer, Scene &scene, Context &ctx, const Assets &assets,
-                           const Camera &camera,
-                           UniformSetter &setter) {
-//    if (lighting) {
-//        helper.render(ctx, assets, camera, *lighting, instances);
-//    }
-}
+using namespace Limitless;
 
-void RenderDebugPass::update(Scene& scene, [[maybe_unused]] Instances& instances, [[maybe_unused]] Context& ctx, [[maybe_unused]] const Camera& camera) {
-    lighting = &scene.getLighting();
+RenderDebugPass::RenderDebugPass(Renderer& renderer)
+    : RendererPass (renderer)
+    , helper {renderer.getSettings()} {
 }
 
+void RenderDebugPass::render(
+        [[maybe_unused]] InstanceRenderer &renderer,
+        Scene &scene,
+        Context &ctx,
+        const Assets &assets,
+        const Camera &camera,
+        [[maybe_unused]] UniformSetter &setter) {
+    helper.render(ctx, assets, camera, scene.getLighting(), scene);
+}

src/limitless/renderer/renderer.cpp

@@ -20,6 +20,7 @@
 #include <limitless/renderer/screen_pass.hpp>
 #include <limitless/renderer/deferred_framebuffer_pass.hpp>
 #include <limitless/renderer/outline_pass.hpp>
+#include <limitless/renderer/render_debug_pass.hpp>
 
 using namespace Limitless;
 
@@ -138,7 +139,7 @@ Renderer::Builder &Renderer::Builder::addScreenPass() {
 }
 
 Renderer::Builder &Renderer::Builder::addRenderDebugPass() {
-//    renderer->passes.emplace_back(std::make_unique<RenderDebugPass>(renderer));
+    renderer->passes.emplace_back(std::make_unique<RenderDebugPass>(*renderer));
     return *this;
 }
 
@@ -169,6 +170,9 @@ Renderer::Builder &Renderer::Builder::deferred() {
         addFXAAPass();
     }
     addScreenPass();
+    if (renderer->settings.bounding_box || renderer->settings.light_radius || renderer->settings.coordinate_system_axes) {
+        addRenderDebugPass();
+    }
     return *this;
 }
 
@@ -237,6 +241,17 @@ Renderer::Builder & Renderer::Builder::update() {
 //        remove<FXAAPass>();
 //    }
 
+    if (settings.bounding_box || settings.light_radius || settings.coordinate_system_axes) {
+        if (!renderer->isPresent<RenderDebugPass>()) {
+            addRenderDebugPass();
+        }
+    }
+    if (!settings.bounding_box && !settings.light_radius && !settings.coordinate_system_axes) {
+        if (renderer->isPresent<RenderDebugPass>()) {
+            remove<RenderDebugPass>();
+        }
+    }
+
     return *this;
 }
 

src/limitless/util/renderer_helper.cpp

@@ -6,12 +6,11 @@
 #include <limitless/assets.hpp>
 #include <limitless/core/context.hpp>
 
-#include <limitless/ms/property.hpp>
 #include <limitless/ms/blending.hpp>
 #include <limitless/models/line.hpp>
 #include <limitless/instances/model_instance.hpp>
 #include <limitless/models/cylinder.hpp>
-#include <iostream>
+#include <limitless/renderer/instance_renderer.hpp>
 
 using namespace Limitless;
 using namespace Limitless::ms;
@@ -21,89 +20,91 @@ RendererHelper::RendererHelper(const RendererSettings& _settings)
 }
 
 void RendererHelper::renderLightsVolume(Context& context, const Lighting& lighting, const Assets& assets, const Camera& camera) {
-//    if (lighting.getLights().empty()) {
-//        return;
-//    }
-//
-//    context.enable(Capabilities::DepthTest);
-//    context.setDepthFunc(DepthFunc::Less);
-//    context.setDepthMask(DepthMask::False);
-////    context.disable(Capabilities::DepthTest);
-//
-//    auto sphere_instance = ModelInstance(assets.models.at("sphere"), assets.materials.at("default"), glm::vec3(0.0f));
-//
-//    context.setPolygonMode(CullFace::FrontBack, PolygonMode::Line);
-//    for (const auto& [_, light] : lighting.getLights()) {
-//        if (light.isPoint()) {
-//            sphere_instance.setPosition(light.getPosition());
-//            sphere_instance.setScale(glm::vec3(light.getRadius()));
-//            sphere_instance.update(context, camera);
-//            sphere_instance.draw(context, assets, ShaderType::Forward, ms::Blending::Opaque);
-//        }
-//        if (light.isSpot()) {
-//            auto cone = std::make_shared<Cylinder>(0.0f, light.getRadius() / 1.5f * glm::sin(glm::acos(glm::radians(light.getCone().y))), light.getRadius());
-//            auto cone_instance = ModelInstance(cone, assets.materials.at("default"), glm::vec3(0.0f));
-//
-//            cone_instance.setPosition(light.getPosition());
-//
-//            auto y = glm::vec3{0.0f, 1.0f, 0.0f};
-//            auto a = glm::cross(y, light.getDirection());
-//            if (a == glm::vec3(0.0f)) {
-//                a = glm::vec3(1.0f, 0.0f, 0.0f);
-//            }
-//            auto angle = glm::acos(glm::dot(y, light.getDirection()));
-//
-//            cone_instance.setRotation(a * angle);
-//            cone_instance.update(context, camera);
-//            cone_instance.draw(context, assets, ShaderType::Forward, ms::Blending::Opaque);
-//        }
-//    }
-//
-//    context.setPolygonMode(CullFace::FrontBack, PolygonMode::Fill);
+    if (lighting.getLights().empty()) {
+        return;
+    }
+
+    context.enable(Capabilities::DepthTest);
+    context.setDepthFunc(DepthFunc::Less);
+    context.setDepthMask(DepthMask::False);
+//    context.disable(Capabilities::DepthTest);
+
+    auto sphere_instance = ModelInstance(assets.models.at("sphere"), assets.materials.at("default"), glm::vec3(0.0f));
+
+    context.setPolygonMode(CullFace::FrontBack, PolygonMode::Line);
+    for (const auto& [_, light] : lighting.getLights()) {
+        if (light.isPoint()) {
+            sphere_instance.setPosition(light.getPosition());
+            sphere_instance.setScale(glm::vec3(light.getRadius()));
+            sphere_instance.update(camera);
+
+            InstanceRenderer::render(sphere_instance, {context, assets, ShaderType::Forward, ms::Blending::Opaque, {}});
+        }
+        if (light.isSpot()) {
+            auto cone = std::make_shared<Cylinder>(0.0f, light.getRadius() / 1.5f * glm::sin(glm::acos(glm::radians(light.getCone().y))), light.getRadius());
+            auto cone_instance = ModelInstance(cone, assets.materials.at("default"), glm::vec3(0.0f));
+
+            cone_instance.setPosition(light.getPosition());
+
+            auto y = glm::vec3{0.0f, 1.0f, 0.0f};
+            auto a = glm::cross(y, light.getDirection());
+            if (a == glm::vec3(0.0f)) {
+                a = glm::vec3(1.0f, 0.0f, 0.0f);
+            }
+            auto angle = glm::acos(glm::dot(y, light.getDirection()));
+
+            cone_instance.setRotation(a * angle);
+            cone_instance.update(camera);
+
+            InstanceRenderer::render(cone_instance, {context, assets, ShaderType::Forward, ms::Blending::Opaque, {}});
+
+        }
+    }
+
+    context.setPolygonMode(CullFace::FrontBack, PolygonMode::Fill);
 }
 
 void RendererHelper::renderCoordinateSystemAxes(Context& context, const Assets& assets) {
-//    context.enable(Capabilities::DepthTest);
-//    context.setDepthFunc(DepthFunc::Less);
-//    context.setDepthMask(DepthMask::False);
-//    context.disable(Capabilities::DepthTest);
-//
-//    context.setLineWidth(2.5f);
-//
-//    static const auto x = std::make_shared<Line>(glm::vec3{0.0f, 0.0f, 0.0f}, glm::vec3{1.0f, 0.0f, 0.0f});
-//    static const auto y = std::make_shared<Line>(glm::vec3{0.0f, 0.0f, 0.0f}, glm::vec3{0.0f, 1.0f, 0.0f});
-//    static const auto z = std::make_shared<Line>(glm::vec3{0.0f, 0.0f, 0.0f}, glm::vec3{0.0f, 0.0f, -5.0f});
-//
-//    static ModelInstance x_i {x, assets.materials.at("green"), {5.0f, 1.0f, 0.0f}};
-//    static ModelInstance y_i {y, assets.materials.at("blue"), {5.0f, 1.0f, 0.0f}};
-//    static ModelInstance z_i {z, assets.materials.at("red"), {5.0f, 1.0f, 0.0f}};
-//
-//    x_i.draw(context, assets, ShaderType::Forward, ms::Blending::Opaque);
-//    y_i.draw(context, assets, ShaderType::Forward, ms::Blending::Opaque);
-//    z_i.draw(context, assets, ShaderType::Forward, ms::Blending::Opaque);
+    context.enable(Capabilities::DepthTest);
+    context.setDepthFunc(DepthFunc::Less);
+    context.setDepthMask(DepthMask::False);
+    context.disable(Capabilities::DepthTest);
+
+    context.setLineWidth(2.5f);
+
+    static const auto x = std::make_shared<Line>(glm::vec3{0.0f, 0.0f, 0.0f}, glm::vec3{1.0f, 0.0f, 0.0f});
+    static const auto y = std::make_shared<Line>(glm::vec3{0.0f, 0.0f, 0.0f}, glm::vec3{0.0f, 1.0f, 0.0f});
+    static const auto z = std::make_shared<Line>(glm::vec3{0.0f, 0.0f, 0.0f}, glm::vec3{0.0f, 0.0f, -5.0f});
+
+    static ModelInstance x_i {x, assets.materials.at("green"), {5.0f, 1.0f, 0.0f}};
+    static ModelInstance y_i {y, assets.materials.at("blue"), {5.0f, 1.0f, 0.0f}};
+    static ModelInstance z_i {z, assets.materials.at("red"), {5.0f, 1.0f, 0.0f}};
+
+    InstanceRenderer::render(x_i, {context, assets, ShaderType::Forward, ms::Blending::Opaque, {}});
+    InstanceRenderer::render(y_i, {context, assets, ShaderType::Forward, ms::Blending::Opaque, {}});
+    InstanceRenderer::render(z_i, {context, assets, ShaderType::Forward, ms::Blending::Opaque, {}});
 }
 
-void RendererHelper::renderBoundingBoxes(Context& context, const Assets& assets, const Camera& camera, Instances& instances) {
-//    auto box = ModelInstance{assets.models.at("cube"), assets.materials.at("default"), glm::vec3{0.0f}};
-//
-//    context.setLineWidth(2.5f);
-//    context.setPolygonMode(CullFace::FrontBack, PolygonMode::Line);
-//    for (const auto& instance : instances) {
-//        auto& bounding_box = instance->getBoundingBox();
-//
-//        box
-//            .setPosition(bounding_box.center)
-//            .setScale(bounding_box.size)
-//            .update(context, camera);
-//
-//        box.draw(context, assets, ShaderType::Forward, ms::Blending::Opaque);
-//    }
-//    context.setPolygonMode(CullFace::FrontBack, PolygonMode::Fill);
+void RendererHelper::renderBoundingBoxes(Context& context, const Assets& assets, const Camera& camera, Scene& scene) {
+    auto box = ModelInstance {assets.models.at("cube"), assets.materials.at("default"), glm::vec3{0.0f}};
+
+    context.setLineWidth(2.5f);
+    context.setPolygonMode(CullFace::FrontBack, PolygonMode::Line);
+    for (const auto& instance : scene.getInstances()) {
+        auto& bounding_box = instance->getBoundingBox();
+
+        box .setPosition(bounding_box.center)
+            .setScale(bounding_box.size)
+            .update(camera);
+
+        InstanceRenderer::render(box, {context, assets, ShaderType::Forward, ms::Blending::Opaque, {}});
+    }
+    context.setPolygonMode(CullFace::FrontBack, PolygonMode::Fill);
 }
 
-void RendererHelper::render(Context& context, const Assets& assets, const Camera& camera, const Lighting& lighting, Instances& instances) {
+void RendererHelper::render(Context& context, const Assets& assets, const Camera& camera, const Lighting& lighting, Scene& scene) {
     if (settings.bounding_box) {
-        renderBoundingBoxes(context, assets, camera, instances);
+        renderBoundingBoxes(context, assets, camera, scene);
     }
 
     if (settings.coordinate_system_axes) {