feat(rendering): compute pass infrastructure, IPipeline, GraphicPass/ComputePass split

ZEngine/ZEngine/Core/Containers/ContainerCommon.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <ZEngine/Helpers/MemoryOperations.h>
+#include <rapidhash.h>
+#include <cstdint>
+
+namespace ZEngine::Core::Containers
+{
+    enum class EntryState : uint8_t
+    {
+        Empty    = 0,
+        Occupied = 1,
+        Deleted  = 2,
+    };
+
+    inline uint64_t hash_compute(const char* str)
+    {
+        return rapidhash(str, Helpers::secure_strlen(str));
+    }
+} // namespace ZEngine::Core::Containers

ZEngine/ZEngine/Core/Containers/HashMap.h

@@ -1,9 +1,8 @@
 #pragma once
 #include <ZEngine/Core/Containers/Array.h>
+#include <ZEngine/Core/Containers/ContainerCommon.h>
 #include <ZEngine/Core/Memory/Allocator.h>
-#include <ZEngine/Helpers/MemoryOperations.h>
 #include <ZEngine/ZEngineDef.h>
-#include <rapidhash.h>
 #include <algorithm>
 #include <cstddef>
 #include <iterator>
@@ -22,14 +21,6 @@
 
 namespace ZEngine::Core::Containers
 {
-    // EntryState is also defined in UnorderedHashMap.h — keep both identical.
-    enum class EntryState : uint8_t
-    {
-        Empty    = 0,
-        Occupied = 1,
-        Deleted  = 2
-    };
-
     template <typename K, typename V>
     struct OrderedHashEntry
     {
@@ -441,8 +432,4 @@ namespace ZEngine::Core::Containers
         size_type               m_tail          = npos;
     };
 
-    inline uint64_t hash_compute(const char* str)
-    {
-        return rapidhash(str, Helpers::secure_strlen(str));
-    }
 } // namespace ZEngine::Core::Containers

ZEngine/ZEngine/Core/Containers/UnorderedHashMap.h

@@ -1,9 +1,8 @@
 #pragma once
 #include <ZEngine/Core/Containers/Array.h>
+#include <ZEngine/Core/Containers/ContainerCommon.h>
 #include <ZEngine/Core/Memory/Allocator.h>
-#include <ZEngine/Helpers/MemoryOperations.h>
 #include <ZEngine/ZEngineDef.h>
-#include <rapidhash.h>
 #include <cstddef>
 #include <stdexcept>
 #include <type_traits>
@@ -21,13 +20,6 @@
 
 namespace ZEngine::Core::Containers
 {
-    enum class EntryState : uint8_t
-    {
-        Empty    = 0,
-        Occupied = 1,
-        Deleted  = 2,
-    };
-
     template <typename K, typename V>
     struct HashEntry
     {
@@ -373,9 +365,4 @@ namespace ZEngine::Core::Containers
         size_type               m_size          = 0;
     };
 
-    inline uint64_t hash_compute(const char* str)
-    {
-        return rapidhash(str, Helpers::secure_strlen(str));
-    }
-
 } // namespace ZEngine::Core::Containers

ZEngine/ZEngine/Hardwares/VulkanDevice.cpp

@@ -1255,7 +1255,7 @@ namespace ZEngine::Hardwares
         m_command_buffer_state = CommandBufferState::Recording;
     }
 
-    void CommandBuffer::BeginSecondary(Rendering::Renderers::RenderPasses::RenderPass* const render_pass, VkFramebuffer framebuffer)
+    void CommandBuffer::BeginSecondary(Rendering::Renderers::RenderPasses::GraphicPass* const render_pass, VkFramebuffer framebuffer)
     {
         ZENGINE_VALIDATE_ASSERT(m_command_buffer_state == CommandBufferState::Idle, "command buffer must be in Idle state")
         ZENGINE_VALIDATE_ASSERT(BufferType == CommandBufferType::Secondary, "command buffer must be Secondary Buffer Type")
@@ -1273,7 +1273,7 @@ namespace ZEngine::Hardwares
         ZENGINE_VALIDATE_ASSERT(vkBeginCommandBuffer(m_command_buffer, &command_buffer_begin_info) == VK_SUCCESS, "Failed to begin the Command Buffer")
 
         m_command_buffer_state = CommandBufferState::Recording;
-        m_active_render_pass   = render_pass;
+        m_in_render_pass       = true;
     }
 
     void CommandBuffer::End()
@@ -1347,7 +1347,7 @@ namespace ZEngine::Hardwares
         m_clear_value[1].depthStencil.stencil = stencil;
     }
 
-    void CommandBuffer::BeginRenderPass(Rendering::Renderers::RenderPasses::RenderPass* const render_pass, VkFramebuffer framebuffer, bool is_content_secondary_command_buffer)
+    void CommandBuffer::BeginRenderPass(Rendering::Renderers::RenderPasses::GraphicPass* const render_pass, VkFramebuffer framebuffer, bool is_content_secondary_command_buffer)
     {
         ZENGINE_VALIDATE_ASSERT(m_command_buffer != nullptr, "Command buffer can't be null")
         ZENGINE_VALIDATE_ASSERT(BufferType == CommandBufferType::Primary, "command buffer must be Primary Buffer Type")
@@ -1402,30 +1402,30 @@ namespace ZEngine::Hardwares
 
         vkCmdBeginRenderPass(m_command_buffer, &render_pass_begin_info, is_content_secondary_command_buffer ? VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS : VK_SUBPASS_CONTENTS_INLINE);
 
-        m_active_render_pass = render_pass;
+        m_in_render_pass = true;
 
         ZReleaseScratch(scratch);
     }
 
     void CommandBuffer::EndRenderPass()
     {
-        if (m_active_render_pass)
+        if (m_in_render_pass)
         {
             ZENGINE_VALIDATE_ASSERT(m_command_buffer != nullptr, "Command buffer can't be null")
             vkCmdEndRenderPass(m_command_buffer);
-            m_active_render_pass = nullptr;
+            m_active_pipeline = nullptr;
+            m_in_render_pass  = false;
         }
     }
 
     void CommandBuffer::BindDescriptorSets(uint32_t frame_index, const uint32_t* dynamic_offsets, uint32_t dynamic_offset_count)
     {
         ZENGINE_VALIDATE_ASSERT(m_command_buffer != nullptr, "Command buffer can't be null")
 
-        if (auto render_pass = m_active_render_pass)
+        if (m_active_pipeline)
         {
-            auto                   pipeline           = render_pass->Pipeline;
-            auto                   pipeline_layout    = pipeline->Layout;
-            auto                   shader             = pipeline->Shader;
+            auto                   pipeline_layout    = m_active_pipeline->Layout;
+            auto                   shader             = m_active_pipeline->Shader;
             const auto&            set_layout         = shader->SetLayouts;
             const auto&            descriptor_set_map = shader->DescriptorSetMap;
 
@@ -1459,7 +1459,7 @@ namespace ZEngine::Hardwares
 
                 const uint32_t* offsets = (actual_dynamic_count > 0) ? dynamic_offsets : nullptr;
                 uint32_t        count   = (actual_dynamic_count > 0) ? actual_dynamic_count : 0;
-                vkCmdBindDescriptorSets(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, frame_sets.size(), frame_sets.data(), count, offsets);
+                vkCmdBindDescriptorSets(m_command_buffer, m_active_pipeline->GetBindPoint(), pipeline_layout, 0, frame_sets.size(), frame_sets.data(), count, offsets);
             }
             ZReleaseScratch(scratch);
         }
@@ -1469,22 +1469,21 @@ namespace ZEngine::Hardwares
     {
         ZENGINE_VALIDATE_ASSERT(m_command_buffer != nullptr, "Command buffer can't be null")
         ZENGINE_VALIDATE_ASSERT(descriptor != nullptr, "DescriptorSet can't be null")
-        if (auto render_pass = m_active_render_pass)
+        if (m_active_pipeline)
         {
-            auto            pipeline_layout = render_pass->Pipeline->Layout;
-            VkDescriptorSet desc_set[1]     = {descriptor};
-            vkCmdBindDescriptorSets(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0, 1, desc_set, 0, nullptr);
+            VkDescriptorSet desc_set[1] = {descriptor};
+            vkCmdBindDescriptorSets(m_command_buffer, m_active_pipeline->GetBindPoint(), m_active_pipeline->Layout, 0, 1, desc_set, 0, nullptr);
         }
     }
 
-    void CommandBuffer::BindPipeline(Rendering::Specifications::PipelineBindPoint bind_point, Rendering::Renderers::Pipelines::GraphicPipeline* const pipeline)
+    void CommandBuffer::BindPipeline(Rendering::Renderers::Pipelines::IPipeline* const pipeline)
     {
         ZENGINE_VALIDATE_ASSERT(m_command_buffer != nullptr, "Command buffer can't be null")
         ZENGINE_VALIDATE_ASSERT(pipeline != nullptr, "Pipeline can't be null")
         ZENGINE_VALIDATE_ASSERT(pipeline->Handle != VK_NULL_HANDLE, "Pipeline Handle can't be null")
 
-        // todo : adapt value based on bind_point
-        vkCmdBindPipeline(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->Handle);
+        vkCmdBindPipeline(m_command_buffer, pipeline->GetBindPoint(), pipeline->Handle);
+        m_active_pipeline = pipeline;
     }
 
     void CommandBuffer::DrawIndirect(VkBuffer buffer, uint32_t offset, uint32_t draw_count)
@@ -1592,10 +1591,9 @@ namespace ZEngine::Hardwares
     {
         ZENGINE_VALIDATE_ASSERT(m_command_buffer != nullptr, "Command buffer can't be null")
 
-        if (auto render_pass = m_active_render_pass)
+        if (m_active_pipeline)
         {
-            auto pipeline_layout = render_pass->Pipeline->Layout;
-            vkCmdPushConstants(m_command_buffer, pipeline_layout, stage_flags, offset, size, data);
+            vkCmdPushConstants(m_command_buffer, m_active_pipeline->Layout, stage_flags, offset, size, data);
         }
     }
 
@@ -1838,7 +1836,13 @@ namespace ZEngine::Hardwares
 
     Rendering::Renderers::RenderPasses::RenderPass* VulkanDevice::CreateRenderPass(Rendering::Specifications::RenderPassSpecification spec)
     {
-        auto pass = ZPushStructCtorArgs(Arena, Rendering::Renderers::RenderPasses::RenderPass);
+        if (spec.Type == Rendering::Specifications::RenderPassType::COMPUTE)
+        {
+            auto pass = ZPushStructCtorArgs(Arena, Rendering::Renderers::RenderPasses::ComputePass);
+            pass->Initialize(this, std::move(spec));
+            return pass;
+        }
+        auto pass = ZPushStructCtorArgs(Arena, Rendering::Renderers::RenderPasses::GraphicPass);
         pass->Initialize(this, std::move(spec));
         return pass;
     }

ZEngine/ZEngine/Hardwares/VulkanDevice.h

@@ -1,5 +1,15 @@
 #pragma once
 #include <vulkan/vulkan.h>
+
+namespace ZEngine::Rendering::Renderers::Pipelines
+{
+    struct IPipeline;
+}
+namespace ZEngine::Rendering::Renderers::RenderPasses
+{
+    struct GraphicPass;
+}
+
 // clang-format off
 #include <ZEngine/Core/Containers/SPSCQueue.h>
 #include <ZEngine/Core/Memory/GpuAllocator.h>
@@ -138,7 +148,7 @@ namespace ZEngine::Hardwares
         void                              Free();
         VkCommandBuffer                   GetHandle() const;
         void                              Begin();
-        void                              BeginSecondary(Rendering::Renderers::RenderPasses::RenderPass* const render_pass, VkFramebuffer framebuffer);
+        void                              BeginSecondary(Rendering::Renderers::RenderPasses::GraphicPass* const render_pass, VkFramebuffer framebuffer);
         void                              End();
         bool                              Completed();
         bool                              IsExecutable();
@@ -152,11 +162,11 @@ namespace ZEngine::Hardwares
         Rendering::Primitives::Fence*     GetSignalFence();
         void                              ClearColor(float r, float g, float b, float a);
         void                              ClearDepth(float depth_color, uint32_t stencil);
-        void                              BeginRenderPass(Rendering::Renderers::RenderPasses::RenderPass* const, VkFramebuffer framebuffer, bool is_content_secondary_command_buffer);
+        void                              BeginRenderPass(Rendering::Renderers::RenderPasses::GraphicPass* const, VkFramebuffer framebuffer, bool is_content_secondary_command_buffer);
         void                              EndRenderPass();
         void                              BindDescriptorSets(uint32_t frame_index = 0, const uint32_t* dynamic_offsets = nullptr, uint32_t dynamic_offset_count = 0);
         void                              BindDescriptorSet(const VkDescriptorSet& descriptor);
-        void                              BindPipeline(Rendering::Specifications::PipelineBindPoint bind_point, Rendering::Renderers::Pipelines::GraphicPipeline* const pipeline);
+        void                              BindPipeline(Rendering::Renderers::Pipelines::IPipeline* const pipeline);
         void                              DrawIndirect(VkBuffer buffer, uint32_t offset, uint32_t draw_count);
         void                              DrawIndexedIndirect(VkBuffer buffer, uint32_t offset, uint32_t count);
         void                              DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
@@ -177,7 +187,8 @@ namespace ZEngine::Hardwares
         VkClearValue        m_clear_value[2] = {0};
         ZRawPtr(Rendering::Primitives::Fence) m_signal_fence;
         ZRawPtr(Rendering::Primitives::Semaphore) m_signal_semaphore;
-        ZRawPtr(Rendering::Renderers::RenderPasses::RenderPass) m_active_render_pass;
+        Rendering::Renderers::Pipelines::IPipeline* m_active_pipeline = nullptr;
+        bool                                        m_in_render_pass  = false;
     };
 
     ZDEFINE_PTR(CommandBuffer);

ZEngine/ZEngine/Rendering/Renderers/Base/IComputeCallbackPass.cpp

@@ -7,23 +7,24 @@ namespace ZEngine::Rendering::Renderers
         SetupCompute(device, res_builder);
     }
 
-    void IComputeCallbackPass::Compile(Hardwares::VulkanDevicePtr const /*device*/, Rendering::Scenes::SceneDataPtr const /*scene*/, RenderPasses::RenderPassBuilder* /*pass_builder*/, RenderGraphResourceInspectorPtr /*res_inspector*/, RenderPasses::RenderPass** const /*output_pass*/)
+    void IComputeCallbackPass::Compile(Hardwares::VulkanDevicePtr const device, Rendering::Scenes::SceneDataPtr const /*scene*/, RenderPasses::RenderPassBuilder* pass_builder, RenderGraphResourceInspectorPtr /*res_inspector*/, RenderPasses::RenderPass** const output_pass)
     {
-        // TODO(compute-pipeline.md §5): construct ComputePassBuilder, call UseShader(GetShaderName()),
-        // optionally SetPushConstantRange(GetPushConstantSize()), then create and Bake() a
-        // COMPUTE RenderPass and write it to *output_pass.
+        if (!output_pass || *output_pass)
+            return;
+
+        auto spec    = pass_builder->UseComputeShader(GetShaderName(), GetPushConstantSize()).Detach();
+        *output_pass = device->CreateRenderPass(std::move(spec));
+        static_cast<RenderPasses::ComputePass*>(*output_pass)->Bake();
     }
 
-    void IComputeCallbackPass::Execute(Hardwares::VulkanDevicePtr const device, RenderGraphResourceInspectorPtr res_inspector, Rendering::Scenes::SceneDataPtr const scene, RenderPasses::RenderPass* const /*pass*/, Buffers::FramebufferVNext* const /*framebuffer — always null for compute passes*/, Hardwares::CommandBufferPtr const command_buffer)
+    void IComputeCallbackPass::Execute(Hardwares::VulkanDevicePtr const device, RenderGraphResourceInspectorPtr res_inspector, Rendering::Scenes::SceneDataPtr const scene, RenderPasses::RenderPass* const pass, Buffers::FramebufferVNext* const /*framebuffer*/, Hardwares::CommandBufferPtr const command_buffer)
     {
-        // TODO(compute-pipeline.md §4): bind compute pipeline via
-        //   vkCmdBindPipeline(command_buffer->GetHandle(), VK_PIPELINE_BIND_POINT_COMPUTE,
-        //                      pass->ComputePipeline->Handle);
-        // then delegate:
-        //   ExecuteCompute(device, res_inspector, scene,
-        //                  pass->ComputePipeline->Handle,
-        //                  pass->ComputePipeline->Layout, command_buffer);
-        ExecuteCompute(device, res_inspector, scene, VK_NULL_HANDLE, VK_NULL_HANDLE, command_buffer);
+        auto* cp = static_cast<RenderPasses::ComputePass*>(pass);
+        if (!cp->Pipeline || cp->Pipeline->Handle == VK_NULL_HANDLE)
+            return;
+
+        command_buffer->BindPipeline(cp->Pipeline);
+        ExecuteCompute(device, res_inspector, scene, cp->Pipeline->Handle, cp->Pipeline->Layout, command_buffer);
     }
 
 } // namespace ZEngine::Rendering::Renderers