-Dev: First Approach to VXGI

Author: AEspinosaDev

examples/resources/scenes/sponza.xml

@@ -293,7 +293,7 @@
 
         <intensity value="2" />
         <color r="0.14" g="0.37" b="0.58" />
-        <direction x="2.0" y="20.0" z="5.0" />
+        <direction x="2.0" y="30.0" z="5.0" />
 
         <Shadow type="rt">
             <samples value="2" />

include/engine/core/passes/composition_pass.h

@@ -28,14 +28,21 @@ enum class OutputBuffer
     EMISSIVE = 6,
     SSR      = 7,
 };
-struct SSRSettings {
+struct SSR { // Settings for Screen Space Reflections
     uint32_t maxSteps              = 64;
     float    stride                = 0.1f;
     uint32_t binaryRefinementSteps = 6;
     float    thickness             = 0.2f;
     float    jitter                = 0.1f;
-    int      enabled               = 1;
+    uint32_t enabled               = 1;
 };
+struct VXGI { // Settings for Voxel Based GI
+    float    strength   = 0.2f;
+    uint32_t resolution = 256;
+    uint32_t samples    = 8;
+    uint32_t enabled    = 1;
+};
+
 class CompositionPass : public GraphicPass
 {
     /*Setup*/
@@ -54,7 +61,8 @@ class CompositionPass : public GraphicPass
     struct Settings {
         OutputBuffer outputBuffer = OutputBuffer::LIGHTING;
         int          enableAO     = 1;
-        SSRSettings  ssr          = {};
+        VXGI         vxgi         = {};
+        SSR          ssr          = {};
     };
     Settings m_settings = {};
 
@@ -71,12 +79,18 @@ class CompositionPass : public GraphicPass
         , m_vignette(vignette) {
     }
 
-    inline void set_SSR_settings(SSRSettings settings) {
+    inline void set_SSR_settings(SSR settings) {
         m_settings.ssr = settings;
     };
-    inline SSRSettings get_SSR_settings() const {
+    inline SSR get_SSR_settings() const {
         return m_settings.ssr;
     };
+    inline void set_VXGI_settings(VXGI settings) {
+        m_settings.vxgi = settings;
+    };
+    inline VXGI get_VXGI_settings() const {
+        return m_settings.vxgi;
+    };
     inline void set_output_buffer(OutputBuffer buffer) {
         m_settings.outputBuffer = buffer;
     };
@@ -105,6 +119,8 @@ class CompositionPass : public GraphicPass
 
     void set_envmap_descriptor(Graphics::Image env, Graphics::Image irr);
 
+    void set_voxelization_descriptor(Graphics::Image voxel);
+
     void update();
 
     void cleanup();

include/engine/core/passes/pass.h

@@ -26,6 +26,11 @@ VULKAN_ENGINE_NAMESPACE_BEGIN
 
 namespace Core {
 
+/*
+Data containing a dependicy image's location belonging to a previows pass
+*/
+struct ImageDependency;
+
 /*
 Core abstract class needed for a renderer to work.
 It controls the flow of the renderer state, what information and how it is being
@@ -47,13 +52,12 @@ class BasePass
     Graphics::RenderPass               m_renderpass = {};
     std::vector<Graphics::Framebuffer> m_framebuffers;
     uint32_t                           m_framebufferImageDepth; // In case if multilayered rendering.
+    // In case is not graphical or need auxiliar data, other graphic data can be stored onto these images
+    std::vector<Graphics::Image> m_resourceImages;
 
-    Extent2D    m_imageExtent;
-    std::string m_name;
-
-    // Key: Vec2 (Renderpass ID, Framebuffer ID)
-    // Value: Framebuffer's image attachment IDs
-    std::unordered_map<iVec2, std::vector<uint32_t>> m_imageDepedanceTable;
+    Extent2D                     m_imageExtent;
+    std::string                  m_name;
+    std::vector<ImageDependency> m_imageDependencies; // Previous passes image dependency list
 
     // Query
     bool m_initiatized  = false;
@@ -106,6 +110,9 @@ class BasePass
     inline std::vector<Graphics::Framebuffer> const get_framebuffers() const {
         return m_framebuffers;
     }
+    inline std::vector<Graphics::Image> const get_resource_images() const {
+        return m_resourceImages;
+    }
     inline void set_attachment_clear_value(VkClearValue value, size_t attachmentLayout = 0) {
         m_renderpass.attachmentsInfo[attachmentLayout].clearValue = value;
     }
@@ -133,17 +140,14 @@ class BasePass
     inline std::unordered_map<std::string, Graphics::ShaderPass*> const get_shaderpasses() const {
         return m_shaderPasses;
     }
-
     /*
-    Sets a table of depedencies with different passes.
-    - Key: Vec2 (Renderpass ID, Framebuffer ID)
-    - Value: array of framebuffer's image attachment IDs
+    Sets a vector of depedencies with different passes.
     */
-    inline void set_image_dependace_table(std::unordered_map<iVec2, std::vector<uint32_t>> table) {
-        m_imageDepedanceTable = table;
+    inline void set_image_dependencies(std::vector<ImageDependency> dependencies) {
+        m_imageDependencies = dependencies;
     }
-    inline std::unordered_map<iVec2, std::vector<uint32_t>> get_image_dependace_table() const {
-        return m_imageDepedanceTable;
+    inline std::vector<ImageDependency> get_image_dependencies() const {
+        return m_imageDependencies;
     }
 
 #pragma endregion
@@ -185,6 +189,28 @@ class BasePass
 #pragma endregion
 };
 
+#pragma region IMAGE DEP
+
+struct ImageDependency {
+    uint32_t passID = 0; // The pass that produces this image
+    uint32_t fboID  = 0; // The FBO within the pass that produces this image
+    bool isFBO = true;   // If set to false, It will take the attachments from the pass resourceImages (Useful if not a
+                         // graphical pass).
+    std::vector<uint32_t> attachmentIDs; // The attachment indeces within the FBO
+
+    ImageDependency(uint32_t passId, u_int fboId, std::vector<uint32_t> attachmentIds)
+        : passID(passId)
+        , fboID(fboId)
+        , attachmentIDs(attachmentIds) {
+    }
+    ImageDependency(uint32_t passId, std::vector<uint32_t> attachmentIds)
+        : passID(passId)
+        , attachmentIDs(attachmentIds)
+        , isFBO(false) {
+    }
+};
+
+#pragma endregion
 } // namespace Core
 
 VULKAN_ENGINE_NAMESPACE_END

include/engine/core/passes/precomposition_pass.h

@@ -48,7 +48,6 @@ class PreCompositionPass : public GraphicPass
     const size_t     MAX_KERNEL_MEMBERS = 64;
     Graphics::Buffer m_kernelBuffer;
     bool             m_updateSamplesKernel = true;
-    Graphics::Image  m_blurredSSAO;
     /*Settings*/
     SSAOSettings m_AO = {};
 

include/engine/core/passes/voxelization_pass.h

@@ -17,8 +17,6 @@ namespace Core {
 
 class VoxelizationPass : public GraphicPass
 {
-    Graphics::Image m_voxelization = {};
-
     /*Descriptors*/
     struct FrameDescriptors {
         Graphics::DescriptorSet globalDescritor;
@@ -32,6 +30,7 @@ class VoxelizationPass : public GraphicPass
   public:
     VoxelizationPass(Graphics::Device* ctx, uint32_t resolution)
         : BasePass(ctx, {resolution, resolution}, 1, 1, false, "VOXELIZATION") {
+            m_resourceImages.resize(1);
     }
 
     void setup_attachments(std::vector<Graphics::AttachmentInfo>&    attachments,

include/engine/core/scene/scene.h

@@ -182,7 +182,7 @@ class Scene : public Object3D
     Setup axis-aligned bounding volume for the entire scene. This object might be necessary for some functionalities,
     sush as voxelization of the scene.
     */
-    void        setup_AABB();
+    void        update_AABB();
     inline AABB get_AABB() const {
         return m_volume;
     }

include/engine/graphics/command_buffer.h

@@ -110,6 +110,20 @@ struct CommandBuffer {
     void push_constants(ShaderPass& pass, ShaderStageFlags stage, const void* data, uint32_t size, uint32_t offset = 0);
 
     void dispatch_compute(Extent3D grid);
+
+    void copy_buffer(Buffer& srcBuffer, Buffer& dstBuffer, size_t size);
+
+    /*
+    Expected layout is LAYOUT_UNDEFINED
+    */
+    void copy_buffer_to_image(Image& img, Buffer& buffer);
+
+    /*
+    Generates mipmaps for a given image following a downsampling by 2 strategy
+    */
+    void generate_mipmaps(Image&      img,
+                          ImageLayout initialLayout = LAYOUT_TRANSFER_DST_OPTIMAL,
+                          ImageLayout finalLayout   = LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 };
 struct CommandPool {
     VkCommandPool handle = VK_NULL_HANDLE;

include/engine/graphics/device.h

@@ -54,14 +54,24 @@ class Device
                                              VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME,
                                              VK_KHR_RAY_QUERY_EXTENSION_NAME};
     // Utils
-    Utils::UploadContext      m_uploadContext = {};
-    Utils::QueueFamilyIndices m_queueFamilies = {};
+    struct UploadContext {
+        Fence         uploadFence;
+        CommandPool   commandPool;
+        CommandBuffer commandBuffer;
+
+        void immediate_submit(std::function<void(CommandBuffer cmd)>&& function);
+        void cleanup();
+    };
+    UploadContext      m_uploadContext = {};
+
 #ifdef NDEBUG
     const bool m_enableValidationLayers{false};
 #else
     const bool m_enableValidationLayers{true};
 #endif
 
+    void create_upload_context();
+
   public:
     /*
     GETTERS
@@ -113,12 +123,13 @@ class Device
     Framebuffer create_framebuffer(RenderPass& renderpass, Extent2D extent, uint32_t layers = 1, uint32_t id = 0);
     Framebuffer create_framebuffer(RenderPass& renderpass, Image& img);
     Semaphore   create_semaphore();
-    Fence       create_fence();
+    Fence       create_fence(bool signaled = true);
     /*Create Frame. A frame is a data structure that contains the objects needed for synchronize each frame rendered and
      * buffers to contain data needed for the GPU to render*/
     Frame create_frame(uint16_t id);
     /*Create RenderPass*/
-    RenderPass create_render_pass(std::vector<AttachmentInfo>& attachments, std::vector<SubPassDependency>& dependencies);
+    RenderPass create_render_pass(std::vector<AttachmentInfo>&    attachments,
+                                  std::vector<SubPassDependency>& dependencies);
     /*Create Descriptor Pool*/
     DescriptorPool create_descriptor_pool(uint32_t                       maxSets,
                                           uint32_t                       numUBO,

include/engine/graphics/image.h

@@ -66,10 +66,6 @@ struct Image {
 
     void create_GUI_handle();
 
-    void upload_image(VkCommandBuffer& cmd, Buffer* stagingBuffer);
-
-    void generate_mipmaps(VkCommandBuffer& cmd);
-
     void cleanup(bool destroySampler = true);
 
     Image clone() const;

include/engine/graphics/utilities/bootstrap.h

@@ -38,6 +38,7 @@ VkDevice create_logical_device(std::unordered_map<QueueType, VkQueue> &queues, V
 // VMA
 VmaAllocator setup_memory(VkInstance instance, VkDevice device, VkPhysicalDevice gpu);
 
+
 }; // namespace Booter
 
 } // namespace Graphics