Renderer/Vulkan: fix descriptor lifetime issues and swapchain sync

Author: SternXD

src/core/renderer/Vulkan/VulkanRenderer.cpp

@@ -100,7 +100,8 @@ bool VulkanRenderer::initialize()
 	if (!m_vulkanResources.createBackgroundVertexBuffer(m_vulkanDevice))
 		return false;
 
-	if (!m_vulkanResources.createSyncObjects(m_vulkanDevice.getDevice()))
+	if (!m_vulkanResources.createSyncObjects(m_vulkanDevice.getDevice(),
+			static_cast<uint32_t>(m_vulkanSwapchain.getImages().size())))
 		return false;
 
 	if (!createCommandBuffers())
@@ -325,6 +326,13 @@ void VulkanRenderer::resize(uint32_t width, uint32_t height)
 	m_imagesInFlight.clear();
 	m_imagesInFlight.resize(m_vulkanSwapchain.getImages().size(), VK_NULL_HANDLE);
 
+	if (!m_vulkanResources.recreateRenderFinishedSemaphores(m_vulkanDevice.getDevice(),
+			static_cast<uint32_t>(m_vulkanSwapchain.getImages().size())))
+	{
+		Logger::error("VK: Failed to recreate render-finished semaphores after resize");
+		return;
+	}
+
 	if (!createCommandBuffers())
 	{
 		Logger::error("VK: Failed to recreate command buffers");
@@ -431,6 +439,44 @@ void VulkanRenderer::prepareVertexData()
 	Logger::debug("VK: Vertex buffer created (host-visible) for animation updates");
 }
 
+void VulkanRenderer::writeDescriptorSets()
+{
+	if (m_descriptorSet == VK_NULL_HANDLE || m_uniformBuffer == VK_NULL_HANDLE || m_textureView == VK_NULL_HANDLE)
+		return;
+
+	VkDevice device = m_vulkanDevice.getDevice();
+	const VkDeviceSize uboSize = 320;
+
+	VkDescriptorBufferInfo bufferDescInfo{};
+	bufferDescInfo.buffer = m_uniformBuffer;
+	bufferDescInfo.offset = 0;
+	bufferDescInfo.range = uboSize;
+
+	VkDescriptorImageInfo imageDescInfo{};
+	imageDescInfo.sampler = m_textureSampler;
+	imageDescInfo.imageView = m_textureView;
+	imageDescInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+
+	VkWriteDescriptorSet descriptorWrites[2]{};
+	descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+	descriptorWrites[0].dstSet = m_descriptorSet;
+	descriptorWrites[0].dstBinding = 0;
+	descriptorWrites[0].dstArrayElement = 0;
+	descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+	descriptorWrites[0].descriptorCount = 1;
+	descriptorWrites[0].pBufferInfo = &bufferDescInfo;
+
+	descriptorWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+	descriptorWrites[1].dstSet = m_descriptorSet;
+	descriptorWrites[1].dstBinding = 1;
+	descriptorWrites[1].dstArrayElement = 0;
+	descriptorWrites[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+	descriptorWrites[1].descriptorCount = 1;
+	descriptorWrites[1].pImageInfo = &imageDescInfo;
+
+	vkUpdateDescriptorSets(device, 2, descriptorWrites, 0, nullptr);
+}
+
 void VulkanRenderer::updateUniformBuffer()
 {
 	VkDevice device = m_vulkanDevice.getDevice();
@@ -603,38 +649,7 @@ void VulkanRenderer::updateUniformBuffer()
 		descriptorWrites[1].descriptorCount = 1;
 		descriptorWrites[1].pImageInfo = &imageDescInfo;
 
-		vkUpdateDescriptorSets(device, 2, descriptorWrites, 0, nullptr);
-	}
-	else if (m_descriptorSet != VK_NULL_HANDLE && m_textureView != VK_NULL_HANDLE)
-	{
-		VkDescriptorBufferInfo bufferDescInfo{};
-		bufferDescInfo.buffer = m_uniformBuffer;
-		bufferDescInfo.offset = 0;
-		bufferDescInfo.range = uboSize;
-
-		VkDescriptorImageInfo imageDescInfo{};
-		imageDescInfo.sampler = m_textureSampler;
-		imageDescInfo.imageView = m_textureView;
-		imageDescInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-
-		VkWriteDescriptorSet descriptorWrites[2]{};
-		descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-		descriptorWrites[0].dstSet = m_descriptorSet;
-		descriptorWrites[0].dstBinding = 0;
-		descriptorWrites[0].dstArrayElement = 0;
-		descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-		descriptorWrites[0].descriptorCount = 1;
-		descriptorWrites[0].pBufferInfo = &bufferDescInfo;
-
-		descriptorWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-		descriptorWrites[1].dstSet = m_descriptorSet;
-		descriptorWrites[1].dstBinding = 1;
-		descriptorWrites[1].dstArrayElement = 0;
-		descriptorWrites[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-		descriptorWrites[1].descriptorCount = 1;
-		descriptorWrites[1].pImageInfo = &imageDescInfo;
-
-		vkUpdateDescriptorSets(device, 2, descriptorWrites, 0, nullptr);
+		writeDescriptorSets();
 	}
 
 	void* data;
@@ -773,6 +788,7 @@ bool VulkanRenderer::uploadTexture()
 	}
 	Logger::debug("VK: Texture image view created, calling updateUniformBuffer");
 
+	writeDescriptorSets();
 	updateUniformBuffer();
 
 	vkDestroyBuffer(device, stagingBuffer, nullptr);
@@ -874,7 +890,10 @@ bool VulkanRenderer::createCommandBuffers()
 		renderPassInfo.clearValueCount = static_cast<uint32_t>(clearValues.size());
 		renderPassInfo.pClearValues = clearValues.data();
 
-		vkCmdBeginRenderPass(m_commandBuffers[i], &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
+		VkSubpassBeginInfo subpassBegin{};
+		subpassBegin.sType = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO;
+		subpassBegin.contents = VK_SUBPASS_CONTENTS_INLINE;
+		vkCmdBeginRenderPass2(m_commandBuffers[i], &renderPassInfo, &subpassBegin);
 
 		VkBuffer bgBuffer = m_vulkanResources.getBackgroundVertexBuffer();
 		if (m_background.shouldRender && m_vulkanPipeline.getBackgroundPipeline() != VK_NULL_HANDLE && bgBuffer != VK_NULL_HANDLE)
@@ -919,7 +938,9 @@ bool VulkanRenderer::createCommandBuffers()
 			vkCmdDraw(m_commandBuffers[i], m_vertexCount, 1, 0, 0);
 		}
 
-		vkCmdEndRenderPass(m_commandBuffers[i]);
+		VkSubpassEndInfo subpassEnd{};
+		subpassEnd.sType = VK_STRUCTURE_TYPE_SUBPASS_END_INFO;
+		vkCmdEndRenderPass2(m_commandBuffers[i], &subpassEnd);
 
 		if (vkEndCommandBuffer(m_commandBuffers[i]) != VK_SUCCESS)
 		{
@@ -948,7 +969,6 @@ void VulkanRenderer::submitFrame()
 
 		VkFence fence = m_vulkanResources.getInFlightFence(m_currentFrame);
 		VkSemaphore imageAvailable = m_vulkanResources.getImageAvailableSemaphore(m_currentFrame);
-		VkSemaphore renderFinished = m_vulkanResources.getRenderFinishedSemaphore(m_currentFrame);
 		vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX);
 
 		uint32_t imageIndex;
@@ -966,6 +986,8 @@ void VulkanRenderer::submitFrame()
 			return;
 		}
 
+		VkSemaphore renderFinished = m_vulkanResources.getRenderFinishedSemaphore(imageIndex);
+
 		if (m_imagesInFlight[imageIndex] != VK_NULL_HANDLE)
 		{
 			vkWaitForFences(device, 1, &m_imagesInFlight[imageIndex], VK_TRUE, UINT64_MAX);
@@ -1023,13 +1045,31 @@ void VulkanRenderer::submitFrame()
 
 void VulkanRenderer::setVSync(bool enabled)
 {
-	if (m_vulkanDevice.getDevice() != VK_NULL_HANDLE)
-	{
-		m_vulkanSwapchain.setVSync(m_vulkanDevice, enabled);
+	if (m_vulkanDevice.getDevice() == VK_NULL_HANDLE || !m_initialized)
+		return;
 
-		if (m_config)
+	VkDevice device = m_vulkanDevice.getDevice();
+	if (m_vulkanSwapchain.setVSync(m_vulkanDevice, enabled))
+	{
+		vkDeviceWaitIdle(device);
+		m_imagesInFlight.clear();
+		m_imagesInFlight.resize(m_vulkanSwapchain.getImages().size(), VK_NULL_HANDLE);
+		if (!m_vulkanResources.recreateRenderFinishedSemaphores(device,
+				static_cast<uint32_t>(m_vulkanSwapchain.getImages().size())))
 		{
-			m_config->setVSync(enabled);
+			Logger::error("VK: Failed to recreate render-finished semaphores after VSync change");
 		}
+		if (!m_commandBuffers.empty())
+		{
+			vkFreeCommandBuffers(device, m_vulkanResources.getCommandPool(),
+				static_cast<uint32_t>(m_commandBuffers.size()), m_commandBuffers.data());
+			m_commandBuffers.clear();
+		}
+		if (!createCommandBuffers())
+			Logger::error("VK: Failed to recreate command buffers after VSync change");
+		m_iconChanged = true;
 	}
+
+	if (m_config)
+		m_config->setVSync(enabled);
 }

src/core/renderer/Vulkan/VulkanRenderer.h

@@ -105,6 +105,7 @@ class VulkanRenderer : public Renderer
 
 	bool createCommandBuffers();
 	bool uploadTexture();
+	void writeDescriptorSets();
 	void updateBackgroundVertexData();
 
 	void prepareVertexData();

src/core/renderer/Vulkan/VulkanResources.cpp

@@ -28,7 +28,37 @@ bool VulkanResources::createCommandPool(VkDevice device, uint32_t queueFamily)
 	return true;
 }
 
-bool VulkanResources::createSyncObjects(VkDevice device)
+bool VulkanResources::recreateRenderFinishedSemaphores(VkDevice device, uint32_t swapchainImageCount)
+{
+	for (VkSemaphore s : m_renderFinishedSemaphores)
+	{
+		if (s != VK_NULL_HANDLE)
+			vkDestroySemaphore(device, s, nullptr);
+	}
+	m_renderFinishedSemaphores.clear();
+	m_renderFinishedSemaphores.resize(swapchainImageCount);
+
+	VkSemaphoreCreateInfo semaphoreInfo{};
+	semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+
+	for (uint32_t i = 0; i < swapchainImageCount; ++i)
+	{
+		if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &m_renderFinishedSemaphores[i]) != VK_SUCCESS)
+		{
+			Logger::error("VK: Failed to create render-finished semaphore {}", i);
+			for (uint32_t j = 0; j < i; ++j)
+			{
+				vkDestroySemaphore(device, m_renderFinishedSemaphores[j], nullptr);
+				m_renderFinishedSemaphores[j] = VK_NULL_HANDLE;
+			}
+			m_renderFinishedSemaphores.clear();
+			return false;
+		}
+	}
+	return true;
+}
+
+bool VulkanResources::createSyncObjects(VkDevice device, uint32_t swapchainImageCount)
 {
 	VkSemaphoreCreateInfo semaphoreInfo{};
 	semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
@@ -40,14 +70,16 @@ bool VulkanResources::createSyncObjects(VkDevice device)
 	for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
 	{
 		if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &m_imageAvailableSemaphores[i]) != VK_SUCCESS ||
-			vkCreateSemaphore(device, &semaphoreInfo, nullptr, &m_renderFinishedSemaphores[i]) != VK_SUCCESS ||
 			vkCreateFence(device, &fenceInfo, nullptr, &m_inFlightFences[i]) != VK_SUCCESS)
 		{
 			Logger::error("VK: Failed to create synchronization objects for frame {}", i);
 			return false;
 		}
 	}
 
+	if (!recreateRenderFinishedSemaphores(device, swapchainImageCount))
+		return false;
+
 	VkFenceCreateInfo singleTimeFenceInfo{};
 	singleTimeFenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
 	singleTimeFenceInfo.flags = 0; // Not signaled
@@ -72,18 +104,20 @@ void VulkanResources::destroy(VkDevice device)
 		m_singleTimeFence = VK_NULL_HANDLE;
 	}
 
+	for (VkSemaphore s : m_renderFinishedSemaphores)
+	{
+		if (s != VK_NULL_HANDLE)
+			vkDestroySemaphore(device, s, nullptr);
+	}
+	m_renderFinishedSemaphores.clear();
+
 	for (uint32_t i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
 	{
 		if (m_inFlightFences[i] != VK_NULL_HANDLE)
 		{
 			vkDestroyFence(device, m_inFlightFences[i], nullptr);
 			m_inFlightFences[i] = VK_NULL_HANDLE;
 		}
-		if (m_renderFinishedSemaphores[i] != VK_NULL_HANDLE)
-		{
-			vkDestroySemaphore(device, m_renderFinishedSemaphores[i], nullptr);
-			m_renderFinishedSemaphores[i] = VK_NULL_HANDLE;
-		}
 		if (m_imageAvailableSemaphores[i] != VK_NULL_HANDLE)
 		{
 			vkDestroySemaphore(device, m_imageAvailableSemaphores[i], nullptr);

src/core/renderer/Vulkan/VulkanResources.h

@@ -6,6 +6,7 @@
 #include <vulkan/vulkan.h>
 #include <cstdint>
 #include <array>
+#include <vector>
 #include "Logger.h"
 
 class VulkanDevice;
@@ -44,7 +45,8 @@ class VulkanResources
 	VulkanResources& operator=(const VulkanResources&) = delete;
 
 	bool createCommandPool(VkDevice device, uint32_t queueFamily);
-	bool createSyncObjects(VkDevice device);
+	bool createSyncObjects(VkDevice device, uint32_t swapchainImageCount);
+	bool recreateRenderFinishedSemaphores(VkDevice device, uint32_t swapchainImageCount);
 	void destroy(VkDevice device);
 
 	VkCommandBuffer beginSingleTimeCommands(VkDevice device);
@@ -64,14 +66,14 @@ class VulkanResources
 
 	VkCommandPool getCommandPool() const { return m_commandPool; }
 	VkSemaphore getImageAvailableSemaphore(uint32_t frameIndex) const { return m_imageAvailableSemaphores[frameIndex]; }
-	VkSemaphore getRenderFinishedSemaphore(uint32_t frameIndex) const { return m_renderFinishedSemaphores[frameIndex]; }
+	VkSemaphore getRenderFinishedSemaphore(uint32_t imageIndex) const { return m_renderFinishedSemaphores[imageIndex]; }
 	VkFence getInFlightFence(uint32_t frameIndex) const { return m_inFlightFences[frameIndex]; }
 	VkBuffer getBackgroundVertexBuffer() const { return m_bgVertexBuffer; }
 
 private:
 	VkCommandPool m_commandPool = VK_NULL_HANDLE;
 	std::array<VkSemaphore, MAX_FRAMES_IN_FLIGHT> m_imageAvailableSemaphores{};
-	std::array<VkSemaphore, MAX_FRAMES_IN_FLIGHT> m_renderFinishedSemaphores{};
+	std::vector<VkSemaphore> m_renderFinishedSemaphores;
 	std::array<VkFence, MAX_FRAMES_IN_FLIGHT> m_inFlightFences{};
 	VkFence m_singleTimeFence = VK_NULL_HANDLE;