-Dev: SSAO pre-pass added (raytraced and classic). Still no blurr

Author: AEspinosaDev

examples/renderer-app/application.cpp

@@ -18,7 +18,7 @@ void Application::init(Systems::RendererSettings settings) {
                                          std::placeholders::_3,
                                          std::placeholders::_4));
 
-    m_renderer = new Systems::ForwardRenderer(m_window, ShadowResolution::MEDIUM, settings);
+    m_renderer = new Systems::DeferredRenderer(m_window, ShadowResolution::MEDIUM, settings);
 
     setup();
 

include/engine/common.h

@@ -289,6 +289,9 @@ typedef enum ColorFormatTypeFlagBits
     SRGB_32F  = VK_FORMAT_R32G32B32_SFLOAT,
     SRGBA_16F = VK_FORMAT_R16G16B16A16_SFLOAT, // HDR precission 16
     SRGBA_32F = VK_FORMAT_R32G32B32A32_SFLOAT, // HDR precission 32
+    R_8U      = VK_FORMAT_R8_UNORM,
+    RG_8U     = VK_FORMAT_R8G8_UNORM,
+    RGB_8U    = VK_FORMAT_R8G8B8_UNORM,
     RGBA_8U   = VK_FORMAT_R8G8B8A8_UNORM,
     DEPTH_16F = VK_FORMAT_D16_UNORM,
     DEPTH_32F = VK_FORMAT_D32_SFLOAT

include/engine/core/passes/composition_pass.h

@@ -24,9 +24,9 @@ enum class OutputBuffer
     NORMAL   = 2,
     POSITION = 3,
     MATERIAL = 4,
-    EMISSIVE = 5,
-    SSR      = 6,
-    SSAO     = 7
+    SSAO     = 5,
+    EMISSIVE = 6,
+    SSR      = 7,
 };
 struct SSRSettings {
     uint32_t maxSteps              = 64;
@@ -53,6 +53,7 @@ class CompositionPass : public GraphicPass
 
     struct Settings {
         OutputBuffer outputBuffer = OutputBuffer::LIGHTING;
+        int          enableAO     = 1;
         SSRSettings  ssr          = {};
     };
     Settings m_settings = {};
@@ -83,6 +84,12 @@ class CompositionPass : public GraphicPass
     inline OutputBuffer get_output_buffer() const {
         return m_settings.outputBuffer;
     };
+    inline bool enable_AO() const {
+        return m_settings.enableAO;
+    }
+    inline void enable_AO(bool op) {
+        m_settings.enableAO = op;
+    }
 
     void setup_attachments(std::vector<Graphics::Attachment>&        attachments,
                            std::vector<Graphics::SubPassDependency>& dependencies);

include/engine/core/passes/precomposition_pass.h

@@ -0,0 +1,86 @@
+/*
+    This file is part of Vulkan-Engine, a simple to use Vulkan based 3D library
+
+    MIT License
+
+    Copyright (c) 2023 Antonio Espinosa Garcia
+
+*/
+#ifndef PRECOMPOSITION_PASS_H
+#define PRECOMPOSITION_PASS_H
+#include <engine/core/passes/pass.h>
+#include <engine/core/resource_manager.h>
+#include <random>
+
+VULKAN_ENGINE_NAMESPACE_BEGIN
+namespace Core {
+    
+typedef enum class AmbientOcclusionType
+{
+    SSAO = 0,
+    RTAO = 1, // Raytraced AO
+} AOType;
+struct SSAOSettings {
+    float    radius  = 0.75;
+    float    bias    = 0.0;
+    uint32_t samples = 16;
+    AOType   type    = AOType::RTAO;
+    uint32_t enabled = 1;
+};
+/*
+Pre-composition pass called before the Composition (Lighting) pass in a deferred framework. This pass computes
+SSAO and other lighting effects, such as blurring raytraced shadows by bilinear filering them, in order to be used in
+future lighting passes.
+*/
+class PreCompositionPass : public GraphicPass
+{
+    Mesh* m_vignette;
+    /*Descriptors*/
+    struct FrameDescriptors {
+        Graphics::DescriptorSet globalDescritor;
+    };
+    std::vector<FrameDescriptors> m_descriptors;
+    /*Resources*/
+    const size_t     MAX_KERNEL_MEMBERS = 64;
+    Graphics::Buffer m_kernelBuffer;
+    bool             m_updateSamplesKernel = true;
+    Graphics::Image  m_blurredSSAO;
+    /*Settings*/
+    SSAOSettings m_AO = {};
+
+    void create_samples_kernel();
+
+  public:
+    PreCompositionPass(Graphics::Device* ctx, VkExtent2D extent, uint32_t framebufferCount, Mesh* vignette)
+        : BasePass(ctx, extent, framebufferCount, 1, false, "PRE-COMPOSITION")
+        , m_vignette(vignette) {
+    }
+
+    inline void set_SSAO_settings(SSAOSettings settings) {
+        if (settings.samples != m_AO.samples)
+            m_updateSamplesKernel = true;
+        m_AO = settings;
+    };
+    inline SSAOSettings get_SSAO_settings() const {
+        return m_AO;
+    };
+
+    void setup_attachments(std::vector<Graphics::Attachment>&        attachments,
+                           std::vector<Graphics::SubPassDependency>& dependencies);
+
+    void setup_uniforms(std::vector<Graphics::Frame>& frames);
+
+    void setup_shader_passes();
+
+    void render(Graphics::Frame& currentFrame, Scene* const scene, uint32_t presentImageIndex = 0);
+
+    void connect_to_previous_images(std::vector<Graphics::Image> images);
+
+    void update_uniforms(uint32_t frameIndex, Scene* const scene);
+
+    void cleanup();
+};
+} // namespace Core
+VULKAN_ENGINE_NAMESPACE_END
+
+#endif

include/engine/systems/renderers/deferred.h

@@ -5,6 +5,7 @@
 #include <engine/core/passes/composition_pass.h>
 #include <engine/core/passes/geometry_pass.h>
 #include <engine/core/passes/postprocess_pass.h>
+#include <engine/core/passes/precomposition_pass.h>
 #include <engine/core/passes/variance_shadow_pass.h>
 
 #include <engine/systems/renderers/renderer.h>
@@ -20,13 +21,13 @@ class DeferredRenderer : public BaseRenderer
 {
     enum RendererPasses
     {
-        SHADOW_PASS      = 0,
-        GEOMETRY_PASS    = 1,
-        COMPOSITION_PASS = 2,
-        // SSR_PASS         = 3,
-        BLOOM_PASS      = 3,
-        TONEMAPPIN_PASS = 4,
-        FXAA_PASS       = 5,
+        SHADOW_PASS         = 0,
+        GEOMETRY_PASS       = 1,
+        PRECOMPOSITION_PASS = 2,
+        COMPOSITION_PASS    = 3,
+        BLOOM_PASS          = 4,
+        TONEMAPPIN_PASS     = 5,
+        FXAA_PASS           = 6,
     };
 
     ShadowResolution m_shadowQuality = ShadowResolution::MEDIUM;
@@ -72,12 +73,24 @@ class DeferredRenderer : public BaseRenderer
     inline Core::SSRSettings get_SSR_settings() const {
         return static_cast<Core::CompositionPass*>(m_passes[COMPOSITION_PASS])->get_SSR_settings();
     };
+    inline void set_SSAO_settings(Core::SSAOSettings settings) {
+        static_cast<Core::CompositionPass*>(m_passes[COMPOSITION_PASS])->enable_AO(settings.enabled);
+        static_cast<Core::PreCompositionPass*>(m_passes[PRECOMPOSITION_PASS])->set_SSAO_settings(settings);
+    };
+    inline Core::SSAOSettings get_SSAO_settings() const {
+        return static_cast<Core::PreCompositionPass*>(m_passes[PRECOMPOSITION_PASS])->get_SSAO_settings();
+    };
     inline void set_shading_output(Core::OutputBuffer output) {
         static_cast<Core::CompositionPass*>(m_passes[COMPOSITION_PASS])->set_output_buffer(output);
     }
     inline Core::OutputBuffer get_shading_output() const {
         return static_cast<Core::CompositionPass*>(m_passes[COMPOSITION_PASS])->get_output_buffer();
     }
+    inline void set_clearcolor(Vec4 c) {
+        BaseRenderer::set_clearcolor(c);
+        m_passes[GEOMETRY_PASS]->set_attachment_clear_value(
+            {m_settings.clearColor.r, m_settings.clearColor.g, m_settings.clearColor.b, m_settings.clearColor.a}, 2);
+    }
 
   protected:
     virtual void on_before_render(Core::Scene* const scene);

include/engine/systems/renderers/renderer.h

@@ -85,9 +85,6 @@ class BaseRenderer
     inline void set_settings(RendererSettings settings) {
         m_settings = settings;
     }
-    inline void set_clearcolor(Vec4 c) {
-        m_settings.clearColor = c;
-    }
     inline void set_antialiasing(MSAASamples msaa) {
         m_settings.samplesMSAA = msaa;
     }
@@ -111,6 +108,9 @@ class BaseRenderer
         if (m_initialized)
             m_updateFramebuffers = true;
     }
+    virtual inline void set_clearcolor(Vec4 c) {
+        m_settings.clearColor = c;
+    }
 
 #pragma endregion
 #pragma region Public Functions

resources/shaders/compute/box_filter_swap.glsl

@@ -0,0 +1,23 @@
+#shader compute
+#version 460
+
+layout(set = 0, binding = 7) uniform sampler2D  InputImage; 
+layout(set = 0, binding = 8) uniform image2D    OutputImage; 
+
+
+layout(local_size_x = 16, local_size_y = 16) in;
+
+void main() {
+    // Get the image coordinates of the current thread
+    ivec2 pixelCoord = ivec2(gl_GlobalInvocationID.xy);
+
+    // // Read the R channel from the input image
+    // float rValue = texture(uInputImage, pixelCoord).r;
+
+    // // Write the value into the G channel of the output image
+    // vec4 color = texture(uOutputImage, pixelCoord); // Load existing data in output image
+    // color.g = rValue; // Store R value into G channel
+
+    // Store the updated color back into the output image
+    imageStore(OutputImage, pixelCoord, vec4(1.0));
+}

resources/shaders/deferred/composition.glsl

@@ -26,15 +26,15 @@ void main() {
 #include utils.glsl
 #include shadow_mapping.glsl
 #include fresnel.glsl
-#include ssao.glsl
 #include IBL.glsl
-#include reindhart.glsl
 #include BRDFs/schlick_smith_BRDF.glsl
 #include BRDFs/marschner_BSDF.glsl
+#include warp.glsl
 #include raytracing.glsl
 #include hashing.glsl
 #include SSR.glsl
 
+
 //INPUT
 layout(location = 0) in  vec2 v_uv;
 
@@ -53,13 +53,25 @@ layout(set = 1, binding = 1) uniform sampler2D normalBuffer;
 layout(set = 1, binding = 2) uniform sampler2D colorBuffer;
 layout(set = 1, binding = 3) uniform sampler2D materialBuffer;
 layout(set = 1, binding = 4) uniform sampler2D emissionBuffer;
-layout(set = 1, binding = 5) uniform sampler2D prevBuffer;
+layout(set = 1, binding = 5) uniform sampler2D preCompositionBuffer;
+
+layout(set = 1, binding = 6) uniform sampler2D prevBuffer;
+
 //SETTINGS
 layout(push_constant) uniform Settings {
     uint    bufferOutput;
+    uint    enableAO;
     SSR     ssr;
 } settings;
 
+// DEBUGGING QUERIES
+#define LIGHTING_MODE   settings.bufferOutput == 0
+#define ALBEDO_OUTPUT   settings.bufferOutput == 1
+#define NORMALS_OUTPUT  settings.bufferOutput == 2
+#define POSITION_OUTPUT settings.bufferOutput == 3
+#define MATERIAL_OUTPUT settings.bufferOutput == 4
+#define SSAO_OUTPUT     settings.bufferOutput == 5
+
 //SURFACE PROPERTIES
 vec3    g_pos; 
 float   g_depth; 
@@ -71,6 +83,7 @@ vec3    g_emission;
 int     g_isReflective;
 vec4    g_temp; 
 
+
 void main()
 {
 
@@ -89,10 +102,18 @@ void main()
     g_emission  = emissionFresnelThreshold.rgb;
     g_isReflective = int(emissionFresnelThreshold.w);
     g_temp      = vec4(0.0);
+    ///////////////////////////////////
+    // PRE-COMPUTED DATA
+    ///////////////////////////////////
+    vec2 preComputedData    = texture(preCompositionBuffer,v_uv).rg;
+    float SSAO              = preComputedData.r;
+    float rtShadow          = preComputedData.g;
+
 
     vec3 color            = vec3(0.0);
     vec3 reflectedColor   = vec3(0.0);
-    if(settings.bufferOutput == 0){
+
+    if(LIGHTING_MODE){
     //////////////////////////////////////
     // IF LIT MATERIAL
     //////////////////////////////////////
@@ -137,6 +158,9 @@ void main()
                                 lighting *= computeShadow(shadowMap, scene.lights[i], i, modelPos);
                             if(scene.lights[i].shadowType == 1) //VSM   
                                 lighting *= computeVarianceShadow(shadowMap, scene.lights[i], i, modelPos);
+                            // if(scene.lights[i].shadowType == 2) //Raytraced 
+                            //     lighting *= texture(preCompositionBuffer,v_uv).g; 
+                            
                             if(scene.lights[i].shadowType == 2) //Raytraced  
                                 lighting *= computeRaytracedShadow(
                                     TLAS, 
@@ -167,7 +191,7 @@ void main()
             }else{
                 ambient = (scene.ambientIntensity * scene.ambientColor) * brdf.albedo;
             }
-            ambient *= brdf.ao;
+            ambient *= settings.enableAO == 1 ? (brdf.ao * SSAO) : brdf.ao;
             //SSR ________________________________
             vec3 fresnel = fresnelSchlick(max(dot(g_normal, normalize(g_pos)), 0.0), brdf.F0);
             if(settings.ssr.enabled == 1 && g_isReflective == 1){
@@ -226,7 +250,7 @@ void main()
         color = g_albedo;
     }
 
-
+    //Fog ________________________________
     if(scene.enableFog){
         float f = computeFog(g_depth);
         color = f * color + (1 - f) * scene.fogColor.rgb;
@@ -236,21 +260,21 @@ void main()
 
     }
     else{ //DEBUG MODE
-        if(settings.bufferOutput == 1) //Albedo
+        if(ALBEDO_OUTPUT) 
             outColor = vec4(g_albedo,1.0);
-        if(settings.bufferOutput == 2) //Normals
-            outColor = vec4(g_normal,1.0);
-        if(settings.bufferOutput == 3) //Position
-            outColor = vec4(g_pos,1.0);
-        if(settings.bufferOutput == 4) //Material
+        if(NORMALS_OUTPUT)
+            outColor = vec4((camera.invView  * vec4(g_normal.xyz, 0.0)).xyz,1.0);
+        if(POSITION_OUTPUT)
+            outColor = vec4((camera.invView * vec4(g_pos.xyz, 1.0)).xyz,1.0);
+        if(MATERIAL_OUTPUT)
             outColor = g_material;
-        if(settings.bufferOutput == 5) //SSR
-            outColor = vec4(reflectedColor,1.0);
-        }
+        if(SSAO_OUTPUT) 
+            outColor = vec4(SSAO,SSAO,SSAO,1.0);
+    }
 
     // check whether result is higher than some threshold, if so, output as bloom threshold color
     float brightness = dot(color, vec3(0.2126, 0.7152, 0.0722));
-    if(brightness > 1.0 && settings.bufferOutput == 0)
+    if(brightness > 1.0 && LIGHTING_MODE)
         outBrightColor = vec4(color, 1.0);
     else
         outBrightColor = vec4(0.0, 0.0, 0.0, 1.0);