[*] Add wrapper code for descriptors and textures for rendergraph2

Author: IAmNotHanni

example-app/application.cpp

@@ -382,8 +382,8 @@ ExampleApp::ExampleApp(int argc, char **argv) {
     m_device = std::make_unique<Device>(*m_instance, m_surface->surface(), physical_device, required_features,
                                         required_extensions);
 
-    m_swapchain = std::make_unique<Swapchain>(*m_device, m_surface->surface(), m_window->width(), m_window->height(),
-                                              m_vsync_enabled);
+    m_swapchain = std::make_unique<Swapchain>(*m_device, "Default Swapchain", m_surface->surface(), m_window->width(),
+                                              m_window->height(), m_vsync_enabled);
 
     m_camera = std::make_unique<Camera>(glm::vec3(6.0f, 10.0f, 2.0f), 180.0f, 0.0f,
                                         static_cast<float>(m_window->width()), static_cast<float>(m_window->height()));

example-app/renderer.hpp

@@ -55,7 +55,7 @@ class RenderGraph;
 // Using declarations
 using inexor::vulkan_renderer::BufferResource;
 using inexor::vulkan_renderer::BufferUsage;
-using inexor::vulkan_renderer ::GraphicsStage;
+using inexor::vulkan_renderer::GraphicsStage;
 using inexor::vulkan_renderer::ImGUIOverlay;
 using inexor::vulkan_renderer::PhysicalStage;
 using inexor::vulkan_renderer::RenderGraph;

include/inexor/vulkan-renderer/render-graph/buffer.hpp

@@ -44,6 +44,9 @@ class Buffer {
 
     // TODO: Add methods create(), destroy_buffer(), destroy_staging_buffer(), destroy_all()
 
+    /// The descriptor buffer info (required for uniform buffers)
+    VkDescriptorBufferInfo m_descriptor_buffer_info;
+
 public:
     /// Default constructor
     /// @param device The device wrapper
@@ -57,6 +60,10 @@ class Buffer {
 
     Buffer &operator=(const Buffer &) = delete;
     Buffer &operator=(Buffer &&) = delete;
+
+    [[nodiscard]] const auto *descriptor_buffer_info() const {
+        return &m_descriptor_buffer_info;
+    }
 };
 
 } // namespace inexor::vulkan_renderer::render_graph

include/inexor/vulkan-renderer/render-graph/graphics_pass.hpp

@@ -0,0 +1,106 @@
+#pragma once
+
+#include <volk.h>
+
+#include "inexor/vulkan-renderer/render-graph/buffer.hpp"
+#include "inexor/vulkan-renderer/render-graph/texture.hpp"
+#include "inexor/vulkan-renderer/wrapper/descriptors/descriptor_set_layout.hpp"
+#include "inexor/vulkan-renderer/wrapper/device.hpp"
+#include "inexor/vulkan-renderer/wrapper/swapchains/swapchain.hpp"
+
+#include <array>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace inexor::vulkan_renderer::wrapper::commands {
+// Forward declaration
+class CommandBuffer;
+} // namespace inexor::vulkan_renderer::wrapper::commands
+
+namespace inexor::vulkan_renderer::render_graph {
+
+// Forward declaration
+class RenderGraph;
+
+// Using declarations
+using wrapper::CommandBuffer;
+using wrapper::descriptors::DescriptorSetLayout;
+using wrapper::swapchains::Swapchain;
+
+/// Using declaration
+using OnRecordCommandBufferForPass = std::function<void(const CommandBuffer &)>;
+
+/// A wrapper for graphics passes inside of rendergraph
+class GraphicsPass {
+    friend class RenderGraph;
+
+private:
+    /// The name of the graphics pass
+    std::string m_name;
+    /// The command buffer recording function of the graphics pass
+    OnRecordCommandBufferForPass m_on_record_cmd_buffer{[](auto &) {}};
+    /// The descriptor set layout of the pass (this will be created by rendergraph)
+    std::unique_ptr<DescriptorSetLayout> m_descriptor_set_layout;
+    /// The descriptor set of the pass (this will be created by rendergraph)
+    VkDescriptorSet m_descriptor_set{VK_NULL_HANDLE};
+    /// The color of the debug label region (visible in graphics debuggers like RenderDoc)
+    std::array<float, 4> m_debug_label_color;
+    /// The extent
+    VkExtent2D m_extent{0, 0};
+    /// The graphics passes this pass reads from
+    std::vector<std::weak_ptr<GraphicsPass>> m_graphics_pass_reads;
+    /// TODO: Do we need this?
+    /// A weak pointer to the previous graphics pass
+    std::weak_ptr<GraphicsPass> m_previous_pass{};
+    /// A weak pointer to the next graphics pass
+    std::weak_ptr<GraphicsPass> m_next_pass{};
+    /// The texture attachments of this pass (unified means color, depth, stencil attachment or a swapchain)
+    std::vector<std::pair<std::weak_ptr<Texture>, std::optional<VkClearValue>>> m_write_attachments{};
+    /// The swapchains this graphics pass writes to
+    std::vector<std::pair<std::weak_ptr<Swapchain>, std::optional<VkClearValue>>> m_write_swapchains{};
+
+    // All the data below will be filled and used by rendergraph only
+
+    /// The rendering info will be filled during rendergraph compilation so we don't have to do this while rendering.
+    /// This means we must make sure that the memory of the attachment infos below is still valid during rendering,
+    /// which is why we store them as members here.
+    VkRenderingInfo m_rendering_info{};
+    /// The color attachments inside of m_rendering_info
+    std::vector<VkRenderingAttachmentInfo> m_color_attachments{};
+    /// Does this graphics pass have any depth attachment?
+    bool m_has_depth_attachment{false};
+    /// The depth attachment inside of m_rendering_info
+    VkRenderingAttachmentInfo m_depth_attachment{};
+    /// Does this graphics pass have any stencil attachment?
+    bool m_has_stencil_attachment{false};
+    /// The stencil attachment inside of m_rendering_info
+    VkRenderingAttachmentInfo m_stencil_attachment{};
+
+    /// Reset the rendering info
+    void reset_rendering_info();
+
+public:
+    /// Default constructor
+    /// @param name The name of the graphics pass
+    /// @param on_record_cmd_buffer The command buffer recording function of the graphics pass
+    /// @param graphics_pass_reads The graphics passes this graphics pass reads from
+    /// @param write_attachments The attachment this graphics pass writes to
+    /// @param write_swapchains The swapchains this graphics pass writes to
+    /// @param pass_debug_label_color The debug label of the pass (visible in graphics debuggers like RenderDoc)
+    GraphicsPass(std::string name, OnRecordCommandBufferForPass on_record_cmd_buffer,
+                 std::vector<std::weak_ptr<GraphicsPass>> graphics_pass_reads,
+                 std::vector<std::pair<std::weak_ptr<Texture>, std::optional<VkClearValue>>> write_attachments,
+                 std::vector<std::pair<std::weak_ptr<Swapchain>, std::optional<VkClearValue>>> write_swapchains,
+                 wrapper::DebugLabelColor pass_debug_label_color);
+
+    GraphicsPass(const GraphicsPass &) = delete;
+    GraphicsPass(GraphicsPass &&other) noexcept;
+    ~GraphicsPass() = default;
+
+    GraphicsPass &operator=(const GraphicsPass &) = delete;
+    GraphicsPass &operator=(GraphicsPass &&) = delete;
+};
+
+} // namespace inexor::vulkan_renderer::render_graph

include/inexor/vulkan-renderer/render-graph/render_graph.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "inexor/vulkan-renderer/render-graph/buffer.hpp"
+#include "inexor/vulkan-renderer/render-graph/graphics_pass.hpp"
 #include "inexor/vulkan-renderer/render-graph/texture.hpp"
 
 #include <memory>
@@ -24,9 +25,11 @@ class RenderGraph {
     const Device &m_device;
 
     /// The buffers (vertex buffers, index buffers, uniform buffers...)
-    std::vector<std::shared_ptr<render_graph::Buffer>> m_buffers;
+    std::vector<std::shared_ptr<Buffer>> m_buffers;
     /// The textures (back buffers, depth buffers, textures...)
-    std::vector<std::shared_ptr<render_graph::Texture>> m_textures;
+    std::vector<std::shared_ptr<Texture>> m_textures;
+    /// The graphics passes
+    std::vector<std::shared_ptr<GraphicsPass>> m_graphics_passes;
 
 public:
     /// Default constructor
@@ -40,6 +43,13 @@ class RenderGraph {
     /// @return A weak pointer to the buffer resource which was created
     std::weak_ptr<Buffer> add_buffer(std::string name, BufferType type, std::function<void()> on_update);
 
+    ///
+    ///
+    ///
+    ///
+    ///
+    std::weak_ptr<GraphicsPass> add_graphics_pass();
+
     // @TODO How to handle optional texture update depending on texture type?
 
     /// Add a texture to the rendergraph
@@ -50,6 +60,12 @@ class RenderGraph {
     std::weak_ptr<Texture> add_texture(std::string name, TextureType type,
                                        std::optional<std::function<void()>> on_update = std::nullopt);
 
+    /// Compile the rendergraph
+    void compile();
+
+    /// Render the rendergraph
+    void render();
+
     /// Reset the entire rendergraph
     void reset();
 };

include/inexor/vulkan-renderer/render-graph/texture.hpp

@@ -1,18 +1,26 @@
 #pragma once
 
+#include "inexor/vulkan-renderer/wrapper/image.hpp"
+#include "inexor/vulkan-renderer/wrapper/sampler.hpp"
+
 #include <functional>
+#include <memory>
 #include <optional>
 #include <string>
 
 namespace inexor::vulkan_renderer::wrapper {
 // Forward declaration
 class Device;
+class Image;
+class Sampler;
 } // namespace inexor::vulkan_renderer::wrapper
 
 namespace inexor::vulkan_renderer::render_graph {
 
 // Using declaration
 using wrapper::Device;
+using wrapper::Image;
+using wrapper::Sampler;
 
 /// Specifies the use of the texture
 enum class TextureType {
@@ -33,6 +41,44 @@ class Texture {
     // The texture update function
     std::optional<std::function<void()>> m_on_update;
 
+    /// The format of the texture
+    VkFormat m_format{VK_FORMAT_UNDEFINED};
+    /// The width of the texture
+    std::uint32_t m_width{0};
+    /// The height of the texture
+    std::uint32_t m_height{0};
+    /// The channel count of the texture (4 by default)
+    // TODO: Can we determine the number of channels based on the given format?
+    std::uint32_t m_channels{4};
+    /// The sample count of the MSAA image (if MSAA is enabled)
+    VkSampleCountFlagBits m_samples{VK_SAMPLE_COUNT_1_BIT};
+
+    std::unique_ptr<Sampler> m_default_sampler;
+
+    /// The image of the texture
+    std::shared_ptr<Image> m_image;
+
+    // TODO: MSAA support?
+
+    // This is used for initializing textures and for updating dynamic textures
+    bool m_update_requested{true};
+    void *m_src_texture_data{nullptr};
+    std::size_t m_src_texture_data_size{0};
+
+    /// By definition, if this is not std::nullopt, this is a dynamic texture
+    std::function<void()> m_on_check_for_updates;
+
+    // The staging buffer for updating the texture data
+    VkBuffer m_staging_buffer{VK_NULL_HANDLE};
+    VmaAllocation m_staging_buffer_alloc{VK_NULL_HANDLE};
+    VmaAllocationInfo m_staging_buffer_alloc_info{};
+
+    /// This part of the image wrapper is for external use outside of rendergraph
+    /// The descriptor image info required for descriptor updates
+    VkDescriptorImageInfo m_descriptor_img_info{};
+
+    // @TODO: create(), destroy() destroy_staging_buffer(), update()
+
 public:
     /// Default constructor
     /// @param device The device wrapper
@@ -41,11 +87,54 @@ class Texture {
     /// @param on_update The texture update function
     Texture(const Device &device, std::string name, TextureType type, std::optional<std::function<void()>> on_update);
 
+    /*
+    /// Default constructor
+    /// @param device The device wrapper
+    /// @param name The internal debug name of the texture
+    /// @param usage The usage of the texture inside of rendergraph
+    /// @param format The format of the texture
+    /// @param width The width of the texture
+    /// @param height The height of the texture
+    /// @param channels The channel count of the texture
+    /// @param samples The sample count of the texture
+    /// @param on_check_for_updates The update function of the texture
+    Texture(const Device &device,
+            std::string name,
+            TextureUsage usage,
+            VkFormat format,
+            std::uint32_t width,
+            std::uint32_t height,
+            std::uint32_t channels,
+            VkSampleCountFlagBits samples,
+            std::function<void()> on_check_for_updates);
+    */
+
     Texture(const Texture &) = delete;
     Texture(Texture &&) noexcept;
 
     Texture &operator=(const Texture &) = delete;
     Texture &operator=(Texture &&) = delete;
+
+    [[nodiscard]] const auto *descriptor_image_info() const {
+        return &m_descriptor_img_info;
+    }
+
+    [[nodiscard]] VkExtent2D extent() const {
+        return {
+            .width = m_width,
+            .height = m_height,
+        };
+    }
+
+    [[nodiscard]] VkFormat format() const {
+        return m_format;
+    }
+
+    [[nodiscard]] const auto &name() const {
+        return m_name;
+    }
+
+    // TODO: Request update method!
 };
 
 } // namespace inexor::vulkan_renderer::render_graph

include/inexor/vulkan-renderer/wrapper/descriptors/descriptor_pool.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <volk.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace inexor::vulkan_renderer::wrapper {
+// Forward declaration
+class Device;
+} // namespace inexor::vulkan_renderer::wrapper
+
+namespace inexor::vulkan_renderer::wrapper::descriptors {
+
+// Forward declaration
+class DescriptorPoolAllocator;
+
+/// RAII wrapper for VkDescriptorPool
+/// For internal use inside of rendergraph only!
+class DescriptorPool {
+private:
+    const Device &m_device;
+    VkDescriptorPool m_descriptor_pool{VK_NULL_HANDLE};
+    std::vector<VkDescriptorPoolSize> m_pool_sizes;
+    std::string m_name;
+
+public:
+    /// Default constructor is private so only DescriptorPoolAllocator can access it
+    /// @param device The device wrapper
+    /// @param pool_sizes The descriptor pool sizes (must not be empty!)
+    /// @param max_sets The max descriptor set count
+    /// @param name The internal debug name of this descriptor pool (must not be empty!)
+    /// @exception std::invalid_argument Internal debug name for descriptor pool must not be empty
+    /// @exception std::invalid_argument Descriptor pool sizes must not be empty
+    /// @exception VulkanException vkCreateDescriptorPool call failed
+    DescriptorPool(const Device &device, std::vector<VkDescriptorPoolSize> pool_sizes, std::uint32_t max_sets,
+                   std::string name);
+
+    DescriptorPool(const DescriptorPool &) = delete;
+    DescriptorPool(DescriptorPool &&) noexcept;
+
+    /// Call vkDestroyDescriptorPool
+    ~DescriptorPool();
+
+    DescriptorPool &operator=(const DescriptorPool &) = delete;
+    DescriptorPool &operator=(DescriptorPool &&) = delete;
+
+    [[nodiscard]] auto descriptor_pool() const noexcept {
+        return m_descriptor_pool;
+    }
+};
+
+} // namespace inexor::vulkan_renderer::wrapper::descriptors