Fix Vulkan RT pipelining frame state

Author: anirul

frame/vulkan/buffer_resources.cpp

@@ -23,7 +23,7 @@ void BufferResourceManager::Clear()
 {
     storage_buffers_.clear();
     storage_buffer_indices_.clear();
-    uniform_buffer_ = {};
+    uniform_buffers_.clear();
 }
 
 BufferResource BufferResourceManager::MakeGpuBuffer(
@@ -216,57 +216,74 @@ bool BufferResourceManager::UpdateStorageBuffer(
     return true;
 }
 
-void BufferResourceManager::BuildUniformBuffer(vk::DeviceSize size_bytes)
+void BufferResourceManager::BuildUniformBuffers(
+    std::size_t count,
+    vk::DeviceSize size_bytes)
 {
-    if (size_bytes == 0)
+    if (count == 0 || size_bytes == 0)
     {
-        throw std::runtime_error("Uniform buffer size must be non-zero.");
+        throw std::runtime_error(
+            "Uniform buffer count and size must be non-zero.");
     }
 
-    vk::UniqueDeviceMemory uniform_memory;
-    auto uniform_buf = memory_manager_->CreateBuffer(
-        size_bytes,
-        vk::BufferUsageFlagBits::eUniformBuffer,
-        vk::MemoryPropertyFlagBits::eHostVisible |
-            vk::MemoryPropertyFlagBits::eHostCoherent,
-        uniform_memory);
+    uniform_buffers_.clear();
+    uniform_buffers_.reserve(count);
+    for (std::size_t i = 0; i < count; ++i)
+    {
+        vk::UniqueDeviceMemory uniform_memory;
+        auto uniform_buf = memory_manager_->CreateBuffer(
+            size_bytes,
+            vk::BufferUsageFlagBits::eUniformBuffer,
+            vk::MemoryPropertyFlagBits::eHostVisible |
+                vk::MemoryPropertyFlagBits::eHostCoherent,
+            uniform_memory);
 
-    uniform_buffer_.name = "uniforms";
-    uniform_buffer_.size = size_bytes;
-    uniform_buffer_.buffer = std::move(uniform_buf);
-    uniform_buffer_.memory = std::move(uniform_memory);
+        BufferResource uniform_buffer = {};
+        uniform_buffer.name = "uniforms_" + std::to_string(i);
+        uniform_buffer.size = size_bytes;
+        uniform_buffer.buffer = std::move(uniform_buf);
+        uniform_buffer.memory = std::move(uniform_memory);
+        uniform_buffers_.push_back(std::move(uniform_buffer));
+    }
 }
 
 void BufferResourceManager::UpdateUniform(
+    std::size_t index,
     const void* data,
     std::size_t byte_count) const
 {
-    if (!uniform_buffer_.buffer ||
-        !uniform_buffer_.memory ||
-        uniform_buffer_.size == 0)
+    if (index >= uniform_buffers_.size())
+    {
+        (*logger_)->warn("Uniform buffer index {} is out of range.", index);
+        return;
+    }
+    const auto& uniform_buffer = uniform_buffers_[index];
+    if (!uniform_buffer.buffer ||
+        !uniform_buffer.memory ||
+        uniform_buffer.size == 0)
     {
         (*logger_)->warn("Uniform buffer not initialized before update.");
         return;
     }
-    if (byte_count > static_cast<std::size_t>(uniform_buffer_.size))
+    if (byte_count > static_cast<std::size_t>(uniform_buffer.size))
     {
         (*logger_)->warn(
             "Uniform update size {} exceeds buffer capacity {}.",
             byte_count,
-            static_cast<std::size_t>(uniform_buffer_.size));
+            static_cast<std::size_t>(uniform_buffer.size));
         return;
     }
     void* mapped = device_.mapMemory(
-        *uniform_buffer_.memory, 0, uniform_buffer_.size);
+        *uniform_buffer.memory, 0, uniform_buffer.size);
     if (data && byte_count > 0)
     {
         std::memcpy(mapped, data, byte_count);
     }
     else
     {
-        std::memset(mapped, 0, uniform_buffer_.size);
+        std::memset(mapped, 0, uniform_buffer.size);
     }
-    device_.unmapMemory(*uniform_buffer_.memory);
+    device_.unmapMemory(*uniform_buffer.memory);
 }
 
 void BufferResourceManager::LogCpuBufferSamples(

frame/vulkan/buffer_resources.h

@@ -39,17 +39,39 @@ class BufferResourceManager
     bool UpdateStorageBuffer(
         const std::string& name,
         const std::vector<std::uint8_t>& bytes);
-    void BuildUniformBuffer(vk::DeviceSize size_bytes);
-    void UpdateUniform(const void* data, std::size_t byte_count) const;
+    void BuildUniformBuffers(
+        std::size_t count,
+        vk::DeviceSize size_bytes);
+    void BuildUniformBuffer(vk::DeviceSize size_bytes)
+    {
+        BuildUniformBuffers(1, size_bytes);
+    }
+    void UpdateUniform(
+        std::size_t index,
+        const void* data,
+        std::size_t byte_count) const;
+    void UpdateUniform(const void* data, std::size_t byte_count) const
+    {
+        UpdateUniform(0, data, byte_count);
+    }
 
     const std::vector<BufferResource>& GetStorageBuffers() const
     {
         return storage_buffers_;
     }
 
+    const BufferResource* GetUniformBuffer(std::size_t index) const
+    {
+        if (index >= uniform_buffers_.size())
+        {
+            return nullptr;
+        }
+        return uniform_buffers_[index].buffer ? &uniform_buffers_[index]
+                                              : nullptr;
+    }
     const BufferResource* GetUniformBuffer() const
     {
-        return uniform_buffer_.buffer ? &uniform_buffer_ : nullptr;
+        return GetUniformBuffer(0);
     }
 
     void LogCpuBufferSamples(
@@ -69,7 +91,7 @@ class BufferResourceManager
     const Logger* logger_;
     std::vector<BufferResource> storage_buffers_;
     std::unordered_map<std::string, std::size_t> storage_buffer_indices_;
-    BufferResource uniform_buffer_;
+    std::vector<BufferResource> uniform_buffers_;
 };
 
 } // namespace frame::vulkan

frame/vulkan/device.cpp

@@ -3213,14 +3213,15 @@ void Device::RecordCommandBuffer(
         {
             return;
         }
-        if (!buffer_resources_->GetUniformBuffer())
-        {
-            return;
-        }
-        auto block = MakeUniformBlock(
-            state, elapsed_time_seconds_);
-        buffer_resources_->UpdateUniform(
-            &block, sizeof(UniformBlock));
+        if (!buffer_resources_->GetUniformBuffer(current_frame_))
+        {
+            return;
+        }
+        auto block = MakeUniformBlock(
+            state, elapsed_time_seconds_);
+        buffer_resources_->UpdateUniform(
+            current_frame_,
+            &block, sizeof(UniformBlock));
     };
     update_uniform_buffer(scene_state);
 
@@ -3310,13 +3311,27 @@ void Device::RecordCommandBuffer(
             compute_output_in_shader_read_ = false;
         }
 
-        if (use_raytracing_pipeline_ &&
-            raytracing_pipeline_ &&
-            raytracing_pipeline_layout_)
-        {
-            command_buffer.bindPipeline(
-                vk::PipelineBindPoint::eRayTracingKHR,
-                *raytracing_pipeline_);
+        if (use_raytracing_pipeline_ &&
+            raytracing_pipeline_ &&
+            raytracing_pipeline_layout_)
+        {
+            if (use_hardware_raytracing_)
+            {
+                vk::MemoryBarrier acceleration_structure_barrier(
+                    vk::AccessFlagBits::eAccelerationStructureWriteKHR,
+                    vk::AccessFlagBits::eAccelerationStructureReadKHR |
+                        vk::AccessFlagBits::eShaderRead);
+                command_buffer.pipelineBarrier(
+                    vk::PipelineStageFlagBits::eAccelerationStructureBuildKHR,
+                    vk::PipelineStageFlagBits::eRayTracingShaderKHR,
+                    {},
+                    acceleration_structure_barrier,
+                    nullptr,
+                    nullptr);
+            }
+            command_buffer.bindPipeline(
+                vk::PipelineBindPoint::eRayTracingKHR,
+                *raytracing_pipeline_);
             command_buffer.bindDescriptorSets(
                 vk::PipelineBindPoint::eRayTracingKHR,
                 *raytracing_pipeline_layout_,
@@ -4987,18 +5002,28 @@ void Device::CreateDescriptorResources()
     }
 
 
-    const BufferResource* uniform = nullptr;
-    if (!uniform_bindings.empty())
-    {
-        buffer_resources_->BuildUniformBuffer(
-            static_cast<vk::DeviceSize>(sizeof(UniformBlock)));
-        uniform = buffer_resources_->GetUniformBuffer();
-        if (!uniform)
-        {
-            logger_->error("Failed to allocate Vulkan uniform buffer.");
-            return;
-        }
-    }
+    std::array<const BufferResource*, kMaxFramesInFlight> uniforms = {};
+    if (!uniform_bindings.empty())
+    {
+        buffer_resources_->BuildUniformBuffers(
+            kMaxFramesInFlight,
+            static_cast<vk::DeviceSize>(sizeof(UniformBlock)));
+        bool have_uniforms = true;
+        for (std::size_t frame = 0; frame < uniforms.size(); ++frame)
+        {
+            uniforms[frame] = buffer_resources_->GetUniformBuffer(frame);
+            if (!uniforms[frame])
+            {
+                have_uniforms = false;
+                break;
+            }
+        }
+        if (!have_uniforms)
+        {
+            logger_->error("Failed to allocate Vulkan uniform buffers.");
+            return;
+        }
+    }
 
     std::vector<vk::DescriptorImageInfo> texture_infos;
     if (!texture_ids.empty())
@@ -5211,12 +5236,12 @@ void Device::CreateDescriptorResources()
                 &storage_infos.back());
         }
 
-        if (uniform && !uniform_bindings.empty())
+        if (uniforms[frame] && !uniform_bindings.empty())
         {
             uniform_infos.emplace_back(
-                *uniform->buffer,
+                *uniforms[frame]->buffer,
                 0,
-                uniform->size);
+                uniforms[frame]->size);
             descriptor_writes.emplace_back(
                 descriptor_set,
                 uniform_bindings.front(),