Initial setup for images

LDAP · Feb 11, 2025 · 996e57e · 996e57e
1 parent f73daad
commit 996e57e
Show file tree

Hide file tree

Showing 11 changed files with 373 additions and 306 deletions.
diff --git a/include/merian-nodes/connectors/managed_vk_image_in.hpp b/include/merian-nodes/connectors/managed_vk_image_in.hpp
@@ -52,7 +52,6 @@ class ManagedVkImageIn : public TypedInputConnector<ManagedVkImageOutHandle, Ima
     static ManagedVkImageInHandle
     transfer_src(const std::string& name, const uint32_t delay = 0, const bool optional = false);
 
-  private:
     const vk::AccessFlags2 access_flags;
     const vk::PipelineStageFlags2 pipeline_stages;
     const vk::ImageLayout required_layout;

diff --git a/include/merian-nodes/connectors/managed_vk_image_out.hpp b/include/merian-nodes/connectors/managed_vk_image_out.hpp
@@ -1,122 +1,79 @@
-#pragma once
-
-#include "merian-nodes/graph/connector_output.hpp"
-#include "merian-nodes/resources/managed_vk_image_resource.hpp"
+#ifndef MANAGED_VK_IMAGE_OUT_HPP
+#define MANAGED_VK_IMAGE_OUT_HPP
+#include "vk_image_out.hpp"
 
 namespace merian_nodes {
-
 class ManagedVkImageOut;
 using ManagedVkImageOutHandle = std::shared_ptr<ManagedVkImageOut>;
 
-// Output a Vulkan image that is allocated and managed by the graph.
-// Note that it only supplies a descriptor if stage_flags contains at least one bit.
-class ManagedVkImageOut : public TypedOutputConnector<ImageHandle> {
-  public:
-    ManagedVkImageOut(const std::string& name,
-                      const vk::AccessFlags2& access_flags,
-                      const vk::PipelineStageFlags2& pipeline_stages,
-                      const vk::ImageLayout& required_layout,
-                      const vk::ShaderStageFlags& stage_flags,
-                      const vk::ImageCreateInfo& create_info,
-                      const bool persistent = false);
-
-    virtual std::optional<vk::DescriptorSetLayoutBinding> get_descriptor_info() const override;
-
-    virtual void get_descriptor_update(const uint32_t binding,
-                                       const GraphResourceHandle& resource,
-                                       const DescriptorSetHandle& update,
-                                       const ResourceAllocatorHandle& allocator) override;
-
-    virtual ConnectorStatusFlags
-    on_pre_process(GraphRun& run,
-                   const CommandBufferHandle& cmd,
-                   const GraphResourceHandle& resource,
-                   const NodeHandle& node,
-                   std::vector<vk::ImageMemoryBarrier2>& image_barriers,
-                   std::vector<vk::BufferMemoryBarrier2>& buffer_barriers) override;
-
-    virtual ConnectorStatusFlags
-    on_post_process(GraphRun& run,
-                    const CommandBufferHandle& cmd,
-                    const GraphResourceHandle& resource,
-                    const NodeHandle& node,
-                    std::vector<vk::ImageMemoryBarrier2>& image_barriers,
-                    std::vector<vk::BufferMemoryBarrier2>& buffer_barriers) override;
-
-    virtual GraphResourceHandle
-    create_resource(const std::vector<std::tuple<NodeHandle, InputConnectorHandle>>& inputs,
-                    const ResourceAllocatorHandle& allocator,
-                    const ResourceAllocatorHandle& aliasing_allocator,
-                    const uint32_t resoruce_index,
-                    const uint32_t ring_size) override;
-
-    virtual ImageHandle resource(const GraphResourceHandle& resource) override;
-
-  public:
-    static ManagedVkImageOutHandle compute_write(const std::string& name,
-                                                 const vk::Format format,
-                                                 const vk::Extent3D extent,
-                                                 const bool persistent = false);
-
-    static ManagedVkImageOutHandle compute_fragment_write(const std::string& name,
-                                                          const vk::Format format,
-                                                          const vk::Extent3D extent,
-                                                          const bool persistent = false);
-
-    static ManagedVkImageOutHandle compute_write(const std::string& name,
-                                                 const vk::Format format,
-                                                 const uint32_t width,
-                                                 const uint32_t height,
-                                                 const uint32_t depth = 1,
-                                                 const bool persistent = false);
-
-    static ManagedVkImageOutHandle compute_fragment_write(const std::string& name,
-                                                          const vk::Format format,
-                                                          const uint32_t width,
-                                                          const uint32_t height,
-                                                          const uint32_t depth = 1,
-                                                          const bool persistent = false);
-
-    static ManagedVkImageOutHandle
-    compute_read_write_transfer_dst(const std::string& name,
-                                    const vk::Format format,
-                                    const vk::Extent3D extent,
-                                    const vk::ImageLayout layout = vk::ImageLayout::eGeneral,
-                                    const bool persistent = false);
-
-    static ManagedVkImageOutHandle
-    compute_read_write_transfer_dst(const std::string& name,
-                                    const vk::Format format,
-                                    const uint32_t width,
-                                    const uint32_t height,
-                                    const uint32_t depth = 1,
-                                    const vk::ImageLayout layout = vk::ImageLayout::eGeneral,
-                                    const bool persistent = false);
-
-    static ManagedVkImageOutHandle compute_read_write(const std::string& name,
-                                                      const vk::Format format,
-                                                      const vk::Extent3D extent,
-                                                      const bool persistent = false);
-
-    static ManagedVkImageOutHandle transfer_write(const std::string& name,
-                                                  const vk::Format format,
-                                                  const vk::Extent3D extent,
-                                                  const bool persistent = false);
-
-    static ManagedVkImageOutHandle transfer_write(const std::string& name,
-                                                  const vk::Format format,
-                                                  const uint32_t width,
-                                                  const uint32_t height,
-                                                  const uint32_t depth = 1,
-                                                  const bool persistent = false);
-
-  public:
-    const vk::AccessFlags2 access_flags;
-    const vk::PipelineStageFlags2 pipeline_stages;
-    const vk::ImageLayout required_layout;
-    const vk::ShaderStageFlags stage_flags;
-    const vk::ImageCreateInfo create_info;
-    const bool persistent;
+class ManagedVkImageOut : public VkImageOut {
+public:
+  ManagedVkImageOut(const std::string& name,
+                    const vk::AccessFlags2& access_flags,
+                    const vk::PipelineStageFlags2& pipeline_stages,
+                    const vk::ImageLayout& required_layout,
+                    const vk::ShaderStageFlags& stage_flags,
+                    const vk::ImageCreateInfo& create_info,
+                    const bool persistent = false);
+
+  static ManagedVkImageOutHandle compute_write(const std::string& name,
+                                               const vk::Format format,
+                                               const vk::Extent3D extent,
+                                               const bool persistent = false);
+
+  static ManagedVkImageOutHandle compute_fragment_write(const std::string& name,
+                                                        const vk::Format format,
+                                                        const vk::Extent3D extent,
+                                                        const bool persistent = false);
+
+  static ManagedVkImageOutHandle compute_write(const std::string& name,
+                                               const vk::Format format,
+                                               const uint32_t width,
+                                               const uint32_t height,
+                                               const uint32_t depth = 1,
+                                               const bool persistent = false);
+
+  static ManagedVkImageOutHandle compute_fragment_write(const std::string& name,
+                                                        const vk::Format format,
+                                                        const uint32_t width,
+                                                        const uint32_t height,
+                                                        const uint32_t depth = 1,
+                                                        const bool persistent = false);
+
+  static ManagedVkImageOutHandle
+  compute_read_write_transfer_dst(const std::string& name,
+                                  const vk::Format format,
+                                  const vk::Extent3D extent,
+                                  const vk::ImageLayout layout = vk::ImageLayout::eGeneral,
+                                  const bool persistent = false);
+
+  static ManagedVkImageOutHandle
+  compute_read_write_transfer_dst(const std::string& name,
+                                  const vk::Format format,
+                                  const uint32_t width,
+                                  const uint32_t height,
+                                  const uint32_t depth = 1,
+                                  const vk::ImageLayout layout = vk::ImageLayout::eGeneral,
+                                  const bool persistent = false);
+
+  static ManagedVkImageOutHandle compute_read_write(const std::string& name,
+                                                    const vk::Format format,
+                                                    const vk::Extent3D extent,
+                                                    const bool persistent = false);
+
+  static ManagedVkImageOutHandle transfer_write(const std::string& name,
+                                                const vk::Format format,
+                                                const vk::Extent3D extent,
+                                                const bool persistent = false);
+
+  static ManagedVkImageOutHandle transfer_write(const std::string& name,
+                                                const vk::Format format,
+                                                const uint32_t width,
+                                                const uint32_t height,
+                                                const uint32_t depth = 1,
+                                                const bool persistent = false);
 };
+} // namespace merian-nodes
+
 
-} // namespace merian_nodes
+#endif //MANAGED_VK_IMAGE_OUT_HPP
diff --git a/include/merian-nodes/connectors/unmanaged_vk_image_out.hpp b/include/merian-nodes/connectors/unmanaged_vk_image_out.hpp
@@ -0,0 +1,22 @@
+#ifndef UNMANAGED_VK_IMAGE_OUT_HPP
+#define UNMANAGED_VK_IMAGE_OUT_HPP
+
+#include "vk_image_out.hpp"
+
+namespace merian_nodes {
+
+class UnmanagedVkImageOut;
+using UnmanagedVkImageOutHandle = std::shared_ptr<UnmanagedVkImageOut>;
+
+class UnmanagedVkImageOut : public VkImageOut {
+public:
+  UnmanagedVkImageOut(const std::string& name, const uint32_t array_size);
+
+  static UnmanagedVkImageOutHandle create(const std::string& name, const uint32_t array_size);
+};
+
+} // namespace merain_nodes
+
+
+
+#endif //UNMANAGED_VK_IMAGE_OUT_HPP
diff --git a/include/merian-nodes/connectors/vk_image_out.hpp b/include/merian-nodes/connectors/vk_image_out.hpp
@@ -0,0 +1,63 @@
+#pragma once
+
+#include "merian-nodes/graph/connector_output.hpp"
+#include "merian-nodes/resources/managed_vk_image_resource.hpp"
+
+namespace merian_nodes {
+
+class ManagedVkImageOut;
+using ManagedVkImageOutHandle = std::shared_ptr<ManagedVkImageOut>;
+
+// Output a Vulkan image that is allocated and managed by the graph.
+// Note that it only supplies a descriptor if stage_flags contains at least one bit.
+class VkImageOut : public TypedOutputConnector<ImageHandle> {
+  public:
+    VkImageOut(const std::string& name,
+                      const vk::AccessFlags2& access_flags,
+                      const vk::PipelineStageFlags2& pipeline_stages,
+                      const vk::ImageLayout& required_layout,
+                      const vk::ShaderStageFlags& stage_flags,
+                      const vk::ImageCreateInfo& create_info,
+                      const bool persistent = false);
+
+    virtual std::optional<vk::DescriptorSetLayoutBinding> get_descriptor_info() const override;
+
+    virtual void get_descriptor_update(const uint32_t binding,
+                                       const GraphResourceHandle& resource,
+                                       const DescriptorSetHandle& update,
+                                       const ResourceAllocatorHandle& allocator) override;
+
+    virtual ConnectorStatusFlags
+    on_pre_process(GraphRun& run,
+                   const CommandBufferHandle& cmd,
+                   const GraphResourceHandle& resource,
+                   const NodeHandle& node,
+                   std::vector<vk::ImageMemoryBarrier2>& image_barriers,
+                   std::vector<vk::BufferMemoryBarrier2>& buffer_barriers) override;
+
+    virtual ConnectorStatusFlags
+    on_post_process(GraphRun& run,
+                    const CommandBufferHandle& cmd,
+                    const GraphResourceHandle& resource,
+                    const NodeHandle& node,
+                    std::vector<vk::ImageMemoryBarrier2>& image_barriers,
+                    std::vector<vk::BufferMemoryBarrier2>& buffer_barriers) override;
+
+    virtual GraphResourceHandle
+    create_resource(const std::vector<std::tuple<NodeHandle, InputConnectorHandle>>& inputs,
+                    const ResourceAllocatorHandle& allocator,
+                    const ResourceAllocatorHandle& aliasing_allocator,
+                    const uint32_t resoruce_index,
+                    const uint32_t ring_size) override;
+
+    virtual ImageHandle resource(const GraphResourceHandle& resource) override;
+
+    const vk::AccessFlags2 access_flags;
+    const vk::PipelineStageFlags2 pipeline_stages;
+    const vk::ImageLayout required_layout;
+    const vk::ShaderStageFlags stage_flags;
+    const vk::ImageCreateInfo create_info;
+    const bool persistent;
+};
+
+} // namespace merian_nodes
diff --git a/include/merian-nodes/connectors/vk_texture_array_out.hpp b/include/merian-nodes/connectors/vk_texture_array_out.hpp
@@ -25,7 +25,7 @@ class VkTextureArrayOut : public TypedOutputConnector<TextureArrayResource&> {
     create_resource(const std::vector<std::tuple<NodeHandle, InputConnectorHandle>>& inputs,
                     const ResourceAllocatorHandle& allocator,
                     const ResourceAllocatorHandle& aliasing_allocator,
-                    const uint32_t resoruce_index,
+                    const uint32_t resource_index,
                     const uint32_t ring_size) override;
 
     TextureArrayResource& resource(const GraphResourceHandle& resource) override;

diff --git a/include/merian-nodes/resources/managed_vk_image_resource.hpp b/include/merian-nodes/resources/managed_vk_image_resource.hpp
@@ -21,7 +21,6 @@ class ManagedVkImageResource : public GraphResource {
         image->properties(props);
     }
 
-  private:
     const merian::ImageHandle image;
     std::optional<merian::TextureHandle> tex;