Fix issue with descriptor rebinding

Descriptor binding affected in-flight frames

Author: Pursche

Source/Renderer/Renderer/Renderers/Vulkan/Backend/DescriptorHandlerVK.cpp

@@ -28,6 +28,14 @@ namespace Renderer
         };
         constexpr u32 maxDescriptorSets = 128;
 
+        // [Frame-safe descriptor rebind] A buffer descriptor write that must wait until its target frame
+        // slot is no longer being read by an in-flight frame before it can safely be applied.
+        struct PendingBufferWrite
+        {
+            BufferID bufferID;
+            DescriptorType type;
+        };
+
         struct DescriptorSet
         {
             DescriptorSetDesc desc;
@@ -50,6 +58,11 @@ namespace Renderer
 
             // Reverse map: buffer -> binding (for fast lookup during validation)
             std::unordered_map<BufferID::type, u32> bufferToBinding;
+
+            // [Frame-safe descriptor rebind] Buffer-binding writes recorded per frame-copy and applied in
+            // FlushPendingBufferWrites once that slot's fence has been waited (its previous frame is done),
+            // so we never rewrite a descriptor copy an in-flight frame is still reading.
+            std::unordered_map<u32, PendingBufferWrite> pendingBufferWritesPerSlot[RenderDeviceVK::FRAME_INDEX_COUNT];
         };
 
         struct DescriptorHandlerData : public IDescriptorHandlerData
@@ -339,7 +352,7 @@ namespace Renderer
             }
         }
 
-        void DescriptorHandlerVK::BindDescriptor(DescriptorSetID setID, u32 binding, BufferID bufferID, VkBuffer buffer, DescriptorType type, u32 frameIndex)
+        void DescriptorHandlerVK::BindDescriptor(DescriptorSetID setID, u32 binding, BufferID bufferID, DescriptorType type, u32 frameIndex)
         {
             ZoneScoped;
             DescriptorHandlerData& data = *static_cast<DescriptorHandlerData*>(_data);
@@ -385,15 +398,26 @@ namespace Renderer
 
             // Mark binding as bound
             descriptorSet.unboundBindings.Unset(binding);
-            
-            // Vulkan descriptor update
+
+            // [Frame-safe descriptor rebind] A GPUVector resize swaps in a NEW VkBuffer, BufferIDs are
+            // recycled, and two frames are in flight sharing this set's per-frame descriptor copies. The only
+            // moment at which writing a slot's copy is both safe (the slot's previous frame is fully done, so
+            // no in-flight read races the write under UPDATE_AFTER_BIND) and current is right after that slot's
+            // fence has been waited. So record the desired buffer per (slot, binding) here and apply it in
+            // FlushPendingBufferWrites, which runs in FlipFrame immediately after that fence wait. The actual
+            // VkBuffer is resolved from bufferID at flush time, so it always reflects the latest generation.
+            descriptorSet.pendingBufferWritesPerSlot[frameIndex][binding] = PendingBufferWrite{ bufferID, type };
+        }
+
+        void DescriptorHandlerVK::WriteBufferDescriptor(DescriptorSet& descriptorSet, u32 binding, VkBuffer buffer, DescriptorType type, u32 frameIndex)
+        {
             VkDescriptorBufferInfo bufferInfo{};
             bufferInfo.buffer = buffer;
             bufferInfo.offset = 0;
             bufferInfo.range = VK_WHOLE_SIZE;
 
             VkWriteDescriptorSet descriptorWrite{ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET };
-            descriptorWrite.dstSet = GetVkDescriptorSet(setID, frameIndex);
+            descriptorWrite.dstSet = descriptorSet.sets[frameIndex];
             descriptorWrite.dstBinding = binding;
             descriptorWrite.descriptorCount = 1;
             descriptorWrite.descriptorType = FormatConverterVK::ToVkDescriptorType(type);
@@ -402,6 +426,23 @@ namespace Renderer
             vkUpdateDescriptorSets(_device->_device, 1, &descriptorWrite, 0, nullptr);
         }
 
+        void DescriptorHandlerVK::FlushPendingBufferWrites(u32 frameIndex)
+        {
+            ZoneScoped;
+            DescriptorHandlerData& data = *static_cast<DescriptorHandlerData*>(_data);
+
+            for (DescriptorSet& descriptorSet : data.descriptorSets)
+            {
+                auto& pending = descriptorSet.pendingBufferWritesPerSlot[frameIndex];
+                for (auto& [binding, write] : pending)
+                {
+                    VkBuffer buffer = _bufferHandler->GetBuffer(write.bufferID);
+                    WriteBufferDescriptor(descriptorSet, binding, buffer, write.type, frameIndex);
+                }
+                pending.clear();
+            }
+        }
+
         void DescriptorHandlerVK::BindDescriptor(DescriptorSetID setID, u32 binding, VkImageView image, DescriptorType type, bool isRT, u32 frameIndex)
         {
             ZoneScoped;

Source/Renderer/Renderer/Renderers/Vulkan/Backend/DescriptorHandlerVK.h

@@ -33,7 +33,11 @@ namespace Renderer
 
             DescriptorSetID CreateDescriptorSet(const DescriptorSetDesc& desc);
 
-            void BindDescriptor(DescriptorSetID setID, u32 binding, BufferID bufferID, VkBuffer buffer, DescriptorType type, u32 frameIndex);
+            void BindDescriptor(DescriptorSetID setID, u32 binding, BufferID bufferID, DescriptorType type, u32 frameIndex);
+
+            // [Frame-safe descriptor rebind] Apply buffer descriptor writes that were deferred while their
+            // frame slot was in flight. Call once per frame, right after that slot's fence has been waited.
+            void FlushPendingBufferWrites(u32 frameIndex);
             void BindDescriptor(DescriptorSetID setID, u32 binding, VkImageView image, DescriptorType type, bool isRT, u32 frameIndex);
             void BindDescriptorArray(DescriptorSetID setID, u32 binding, VkImageView image, u32 arrayOffset, DescriptorType type, bool isRT, u32 frameIndex);
             void BindDescriptorArray(DescriptorSetID setID, u32 binding, std::vector<VkImageView>& images, u32 arrayOffset, DescriptorType type, bool isRT, u32 frameIndex);
@@ -51,6 +55,7 @@ namespace Renderer
         private:
             void CreateDescriptorPool();
             void CreateDescriptorSet(DescriptorSet& descriptorSet);
+            void WriteBufferDescriptor(DescriptorSet& descriptorSet, u32 binding, VkBuffer buffer, DescriptorType type, u32 frameIndex);
             bool ValidatePermissionViolations(u32 slot, const DescriptorSet& descriptorSet, const PersistentBitSet& accesses, const BitSet& permissions, const char* permissionName, const PersistentBitSet* usedBindings = nullptr);
 
         private:

Source/Renderer/Renderer/Renderers/Vulkan/RendererVK.cpp

@@ -253,8 +253,10 @@ namespace Renderer
 
     void RendererVK::BindDescriptor(DescriptorSetID descriptorSetID, u32 bindingIndex, BufferID bufferID, DescriptorType type, u32 frameIndex)
     {
-        VkBuffer buffer = _bufferHandler->GetBuffer(bufferID);
-        _descriptorHandler->BindDescriptor(descriptorSetID, bindingIndex, bufferID, buffer, type, frameIndex);
+        // [Frame-safe descriptor rebind] The handler records this write per frame-copy and applies it in
+        // FlushPendingBufferWrites (FlipFrame), after that slot's fence has been waited. The VkBuffer is
+        // resolved from bufferID at that point, so it always reflects the latest GPUVector generation.
+        _descriptorHandler->BindDescriptor(descriptorSetID, bindingIndex, bufferID, type, frameIndex);
     }
 
     void RendererVK::BindDescriptor(DescriptorSetID descriptorSetID, u32 bindingIndex, ImageID imageID, u32 mipLevel, DescriptorType type, u32 frameIndex)
@@ -409,6 +411,11 @@ namespace Renderer
             timeWaited = timer.GetLifeTime();
         }
 
+        // [Frame-safe descriptor rebind] This slot's previous frame has now completed (fence waited above),
+        // so it is finally safe to apply any buffer descriptor writes that were deferred while it was in
+        // flight. Done before any of this frame's command lists record/use the descriptor sets.
+        _descriptorHandler->FlushPendingBufferWrites(_frameIndex);
+
         _imageHandler->FlipFrame(frameIndex);
         if (_renderSizeChanged)
         {