Merge pull request #82 from hotstreams/feature/allow-no-blur

allow blur to be disabled

Author: hotstreams

include/limitless/renderer/composite_pass.hpp

@@ -5,17 +5,7 @@
 #include <limitless/renderer/instance_renderer.hpp>
 
 namespace Limitless {
-    /**
-     * CompositePass combines results from previous passes together
-     *
-     * result from transparent pass (lighting image + transparent objects) combined with bloom pass result
-     */
-    class CompositePass final : public RendererPass {
-    private:
-        /**
-         * Result framebuffer
-         */
-        Framebuffer framebuffer;
+    class CompositePass : public RendererPass {
     public:
         float tone_mapping_exposure = 1.0f;
         float gamma = 2.2f;
@@ -24,14 +14,31 @@ namespace Limitless {
 
         std::shared_ptr<Texture> getResult();
 
-        /**
-         *
-         */
         void render(InstanceRenderer &renderer, Scene &scene, Context &ctx, const Assets &assets, const Camera &camera, UniformSetter &setter) override;
 
         /**
          * Updates framebuffer size
          */
         void onFramebufferChange(glm::uvec2 size) override;
+
+        ~CompositePass() override = default;
+
+    protected:
+        /**
+         * Result framebuffer
+         */
+        Framebuffer framebuffer;
+    };
+
+    /**
+     * CompositeWithBloomPass combines results from previous passes together
+     *
+     * result from transparent pass (lighting image + transparent objects) combined with bloom pass result
+     */
+    class CompositeWithBloomPass final : public CompositePass {
+    public:
+        explicit CompositeWithBloomPass(Renderer& renderer);
+
+        void render(InstanceRenderer &renderer, Scene &scene, Context &ctx, const Assets &assets, const Camera &camera, UniformSetter &setter) override;
     };
 }

include/limitless/renderer/renderer.hpp

@@ -124,6 +124,7 @@ namespace Limitless {
             Builder& addTranslucentPass();
             Builder& addBloomPass();
             Builder& addOutlinePass();
+            Builder& addCompositeWithBloomPass();
             Builder& addCompositePass();
             Builder& addFXAAPass();
             Builder& addScreenPass();

shaders/pipeline/composite.frag

@@ -8,15 +8,12 @@ out vec3 color;
 
 uniform sampler2D lightened;
 
-uniform sampler2D bloom;
 uniform sampler2D outline;
-uniform float bloom_strength;
 uniform float tone_mapping_exposure;
 uniform float gamma;
 
 void main() {
-    vec3 bloom_color = texture(bloom, uv).rgb * bloom_strength;
-    color = texture(lightened, uv).rgb + bloom_color;
+    color = texture(lightened, uv).rgb;
 
     // apply tone mapping function to HDR
     color = toneMapping(color, tone_mapping_exposure);

shaders/pipeline/composite_with_bloom.frag

@@ -0,0 +1,29 @@
+ENGINE::COMMON
+
+#include "../functions/tone_mapping.glsl"
+
+in vec2 uv;
+
+out vec3 color;
+
+uniform sampler2D lightened;
+
+uniform sampler2D bloom;
+uniform sampler2D outline;
+uniform float bloom_strength;
+uniform float tone_mapping_exposure;
+uniform float gamma;
+
+void main() {
+    vec3 bloom_color = texture(bloom, uv).rgb * bloom_strength;
+    color = texture(lightened, uv).rgb + bloom_color;
+
+    // apply tone mapping function to HDR
+    color = toneMapping(color, tone_mapping_exposure);
+
+    // apply gamma correction
+    color = pow(color, vec3(1.0 / gamma));
+
+    // add objects outlining
+    color += texture(outline, uv).rgb;
+}

shaders/pipeline/composite_with_bloom.vert

@@ -0,0 +1,11 @@
+ENGINE::COMMON
+
+layout (location = 0) in vec3 vertex_position;
+layout (location = 1) in vec2 vertex_uv;
+
+out vec2 uv;
+
+void main() {
+    uv = vertex_uv;
+    gl_Position = vec4(vertex_position, 1.0);
+}

src/limitless/renderer/composite_pass.cpp

@@ -20,6 +20,46 @@ std::shared_ptr<Texture> CompositePass::getResult() {
 }
 
 void CompositePass::render(
+        [[maybe_unused]] InstanceRenderer &instance_renderer,
+        [[maybe_unused]] Scene &scene,
+        Context &ctx,
+        const Assets &assets,
+        [[maybe_unused]] const Camera &camera,
+        [[maybe_unused]] UniformSetter &setter
+) {
+    
+    ctx.disable(Capabilities::DepthTest);
+    ctx.disable(Capabilities::Blending);
+
+    {
+        ctx.setViewPort(getResult()->getSize());
+        framebuffer.clear();
+
+        auto& shader = assets.shaders.get("composite");
+
+        shader.setUniform("lightened", renderer.getPass<TranslucentPass>().getResult());
+
+        {
+            shader.setUniform("outline", renderer.getPass<OutlinePass>().getResult())
+                  .setUniform("tone_mapping_exposure", tone_mapping_exposure)
+                  .setUniform("gamma", gamma);
+        }
+
+        shader.use();
+
+        assets.meshes.at("quad")->draw();
+    }
+}
+
+void CompositePass::onFramebufferChange(glm::uvec2 size) {
+    framebuffer.onFramebufferChange(size);
+}
+
+CompositeWithBloomPass::CompositeWithBloomPass(Renderer& renderer)
+    : CompositePass {renderer} {
+}
+
+void CompositeWithBloomPass::render(
         [[maybe_unused]] InstanceRenderer &instance_renderer,
         [[maybe_unused]] Scene &scene,
         Context &ctx,
@@ -34,7 +74,7 @@ void CompositePass::render(
         ctx.setViewPort(getResult()->getSize());
         framebuffer.clear();
 
-        auto& shader = assets.shaders.get("composite");
+        auto& shader = assets.shaders.get("composite_with_bloom");
 
         shader.setUniform("lightened", renderer.getPass<TranslucentPass>().getResult());
 
@@ -55,7 +95,3 @@ void CompositePass::render(
         assets.meshes.at("quad")->draw();
     }
 }
-
-void CompositePass::onFramebufferChange(glm::uvec2 size) {
-    framebuffer.onFramebufferChange(size);
-}

src/limitless/renderer/deferred.cpp

@@ -108,7 +108,11 @@ void Deferred::build(Context& ctx, const RendererSettings& settings) {
     /*
      *  Combines shaded translucent result and bloom
      */
-    add<CompositePass>(size);
+    if (settings.bloom) {
+        add<CompositeWithBloomPass>(size);
+    } else {
+        add<CompositePass>(size);
+    }
 
 //    if (settings.fast_approximate_antialiasing) {
 //        add<FXAAPass>(size);

src/limitless/renderer/renderer.cpp

@@ -132,6 +132,11 @@ Renderer::Builder &Renderer::Builder::addOutlinePass() {
     return *this;
 }
 
+Renderer::Builder &Renderer::Builder::addCompositeWithBloomPass() {
+    renderer->passes.emplace_back(std::make_unique<CompositeWithBloomPass>(*renderer));
+    return *this;
+}
+
 Renderer::Builder &Renderer::Builder::addCompositePass() {
     renderer->passes.emplace_back(std::make_unique<CompositePass>(*renderer));
     return *this;
@@ -175,7 +180,11 @@ Renderer::Builder &Renderer::Builder::deferred() {
         addBloomPass();
     }
     addOutlinePass();
-    addCompositePass();
+    if (renderer->settings.bloom) {
+        addCompositeWithBloomPass();
+    } else {
+        addCompositePass();
+    }
     if (renderer->settings.fast_approximate_antialiasing) {
         addFXAAPass();
     }

src/limitless/renderer/screen_pass.cpp

@@ -39,7 +39,7 @@ void ScreenPass::render(
         if (renderer.isPresent<FXAAPass>()) {
             screen = renderer.getPass<FXAAPass>().getResult();
         } else {
-            screen = renderer.getPass<CompositePass>().getResult();;
+            screen = renderer.getPass<CompositePass>().getResult();
         }
 
         shader.setUniform("screen_texture", screen);

src/limitless/shader_storage.cpp

@@ -112,7 +112,11 @@ void ShaderStorage::initialize(Context& ctx, const RendererSettings& settings, c
     }
 
     add("deferred", compiler.compile(shader_dir / "pipeline/deferred"));
-    add("composite", compiler.compile(shader_dir / "pipeline/composite"));
+    if (settings.bloom) {
+        add("composite_with_bloom", compiler.compile(shader_dir / "pipeline/composite_with_bloom"));
+    } else {
+        add("composite", compiler.compile(shader_dir / "pipeline/composite"));
+    }
     add("outline", compiler.compile(shader_dir / "pipeline/outline"));