Fixed swapchain recreation crash issues with commandbuffer

Author: Raelr

engine/render/renderer/Renderer.cpp

@@ -122,7 +122,9 @@ void Renderer::EndFrame()
 
     commandBuffers.End();
 
-    auto result = swapchain.SubmitCommandBuffers(commandBuffers, &currentImageIndex);
+    commandBuffers.SetActiveBufferIndex(currentFrameIndex);
+
+    auto result = swapchain.SubmitCommandBuffers(commandBuffers, currentImageIndex);
 
     if (result == Vulkan::Utils::ERROR_RESIZED || window.WasResized())
     {

engine/render/renderer/platform/vulkan/CommandBuffer.cpp

@@ -54,11 +54,14 @@ void CommandBuffer::Swap(CommandBuffer& other)
 {
     auto tmpCmdBuffers = std::move(commandBuffers);
     auto tmpActiveCmdBuffer = activeCommandBuffer;
+    auto tmpCurrentActiveBufferIndex = currentActiveBufferIndex;
 
     commandBuffers = std::move(other.commandBuffers);
     activeCommandBuffer = other.activeCommandBuffer;
+    currentActiveBufferIndex = other.currentActiveBufferIndex;
 
     other.commandBuffers = std::move(tmpCmdBuffers);
     other.activeCommandBuffer = tmpActiveCmdBuffer;
+    other.currentActiveBufferIndex = tmpCurrentActiveBufferIndex;
 }
 } // namespace Siege::Vulkan

engine/render/renderer/platform/vulkan/CommandBuffer.h

@@ -9,10 +9,10 @@
 #ifndef SIEGE_ENGINE_VULKAN_COMMANDBUFFER_H
 #define SIEGE_ENGINE_VULKAN_COMMANDBUFFER_H
 
-#include "utils/Types.h"
-
 #include <utils/collections/HeapArray.h>
 
+#include "utils/Types.h"
+
 namespace Siege::Vulkan
 {
 /**
@@ -73,13 +73,24 @@ class CommandBuffer
     /**
      * Returns the raw Vulkan CommandBuffer pointer
      * @param index the index of the CommandBuffer to be accessed
-     * @return
+     * @warn this function does not bounds check - please ensure that the provided index is in
+     * bounds, otherwise undefined behaviour may occur
+     * @return a raw Vulkan Command Buffer
      */
-    VkCommandBuffer Get(const size_t index = 0)
+    VkCommandBuffer Get(const size_t index) const
     {
         return commandBuffers[index];
     }
 
+    /**
+     * Returns the raw Vulkan CommandBuffer pointer of the current active Command Buffer
+     * @return the current active command buffer
+     */
+    VkCommandBuffer Get() const
+    {
+        return commandBuffers[currentActiveBufferIndex];
+    }
+
     /**
      * Returns the active command buffer (the one being recorded)
      * @return the vulkan command buffer pointer
@@ -120,6 +131,11 @@ class CommandBuffer
         commandBuffer.Submit();
     }
 
+    inline void SetActiveBufferIndex(uint32_t index)
+    {
+        currentActiveBufferIndex = index;
+    }
+
 private:
 
     /**
@@ -130,6 +146,7 @@ class CommandBuffer
 
     ::Siege::Utils::MHArray<VkCommandBuffer> commandBuffers;
     VkCommandBuffer activeCommandBuffer {nullptr};
+    uint32_t currentActiveBufferIndex {0};
 };
 } // namespace Siege::Vulkan
 

engine/render/renderer/platform/vulkan/Fence.cpp

@@ -37,7 +37,6 @@ Fence::~Fence()
 {
     if (fences == nullptr) return;
 
-    CC_LOG_INFO("[FENCE] Destroying Fence")
     auto device = Context::GetVkLogicalDevice();
 
     size = (initState == FENCE_EMPTY || initState == FENCE_EMPTY_SIGNALED) * size;

engine/render/renderer/platform/vulkan/Renderer.cpp

@@ -147,35 +147,34 @@ void Swapchain::EndRenderPass(Vulkan::CommandBuffer& commandBuffer)
     vkCmdEndRenderPass(OUT commandBuffer.GetActiveCommandBuffer());
 }
 
-Utils::Result Swapchain::SubmitCommandBuffers(CommandBuffer& buffers, uint32_t* imageIndex)
+Utils::Result Swapchain::SubmitCommandBuffers(const CommandBuffer& buffers, uint32_t imageIndex)
 {
-    uint32_t index = *imageIndex;
-    uint32_t frameIdx = currentFrame;
-
     // If the image being asked for is being used, we wait for it to become available
-    imagesInFlight.Wait(index);
+    imagesInFlight.Wait(imageIndex);
 
     // Get the frame's image and move it to our images in flight
-    imagesInFlight.Set(index, inFlightFences[currentFrame]);
+    imagesInFlight.Set(imageIndex, inFlightFences[currentFrame]);
 
     inFlightFences.Reset(currentFrame);
 
     Utils::SubmitGraphicsCommand()
         .ToQueue(Vulkan::Context::GetCurrentDevice()->GetGraphicsQueue())
         .WaitOnSemaphores({imageAvailableSemaphores[currentFrame]})
         .WithPipelineStages({VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT})
-        .WithCommandBuffers({buffers[currentFrame]})
+        .WithCommandBuffers({buffers.Get()})
         .SignalSemaphores({renderFinishedSemaphores[currentFrame]})
         .Submit(inFlightFences[currentFrame]);
 
+    uint32_t previousFrame = currentFrame;
+
     currentFrame = ((currentFrame + 1) < MAX_FRAMES_IN_FLIGHT) * (currentFrame + 1);
 
     // Return the result of the rendering process
     return Utils::SubmitPresentCommand()
         .ToQueue(Vulkan::Context::GetCurrentDevice()->GetPresentQueue())
-        .SignalSemaphores({renderFinishedSemaphores[frameIdx]})
+        .SignalSemaphores({renderFinishedSemaphores[previousFrame]})
         .ForSwapchains({swapchain})
-        .WithImageIndices({index})
+        .WithImageIndices({imageIndex})
         .Submit();
 }
 

engine/render/renderer/platform/vulkan/Renderer.h

@@ -97,7 +97,7 @@ class Swapchain
      * @param imageIndex - the index of the image being drawn
      * @return VkResult - the result of submitting the buffer
      */
-    Utils::Result SubmitCommandBuffers(CommandBuffer& commandBuffer, uint32_t* imageIndex);
+    Utils::Result SubmitCommandBuffers(const CommandBuffer& commandBuffer, uint32_t imageIndex);
 
     /**
      * Compares the inputted image and depth formats to the ones used in the Swapchain

engine/render/renderer/platform/vulkan/Swapchain.cpp

@@ -29,8 +29,8 @@ VkCommandBuffer CommandBuffer::AllocateCommandBuffer(VkDevice device, VkCommandP
 }
 
 ::Siege::Utils::MHArray<VkCommandBuffer> CommandBuffer::AllocateCommandBuffers(VkDevice device,
-                                                             VkCommandPool pool,
-                                                             uint32_t count)
+                                                                               VkCommandPool pool,
+                                                                               uint32_t count)
 {
     using ::Siege::Utils::MHArray;
     MHArray<VkCommandBuffer> buffers(count);

engine/render/renderer/platform/vulkan/Swapchain.h

@@ -9,9 +9,8 @@
 #ifndef SIEGE_ENGINE_COMMANDBUFFER_H
 #define SIEGE_ENGINE_COMMANDBUFFER_H
 
-#include <volk/volk.h>
-
 #include <utils/collections/HeapArray.h>
+#include <volk/volk.h>
 
 namespace Siege::Vulkan::Utils
 {
@@ -20,7 +19,9 @@ class CommandBuffer
 public:
 
     static VkCommandBuffer AllocateCommandBuffer(VkDevice device, VkCommandPool pool);
-    static ::Siege::Utils::MHArray<VkCommandBuffer> AllocateCommandBuffers(VkDevice, VkCommandPool, uint32_t);
+    static ::Siege::Utils::MHArray<VkCommandBuffer> AllocateCommandBuffers(VkDevice,
+                                                                           VkCommandPool,
+                                                                           uint32_t);
     static void BeginSingleTimeCommand(VkCommandBuffer buffer);
     static void EndCommandBuffer(VkCommandBuffer commandBuffer);
 };