[Window] Fixed maximizing and minimizing.

ChunkTreasure1 · ChunkTreasure1 · commit 4c52aeb6d5ea · 2026-07-04T23:07:21.000+02:00
diff --git a/Engine/Source/VulkanRHIModule/Private/VulkanRHIModule/Graphics/VulkanSwapchain.cpp b/Engine/Source/VulkanRHIModule/Private/VulkanRHIModule/Graphics/VulkanSwapchain.cpp
@@ -76,7 +76,7 @@ namespace Volt::RHI
 			return 0;
 		}
 
-		inline static VkSurfaceFormatKHR ChooseSwapchainFormat(const std::span<VulkanSwapchain::SurfaceFormat> swapchainFormats, bool useHDRIfAvailable)
+		inline static VkSurfaceFormatKHR ChooseSwapchainFormat(const std::span<VulkanSwapchain::SurfaceFormat> swapchainFormats, bool useHDRIfAvailable, ColorSpace& outColorSpace)
 		{
 			VT_PROFILE_FUNCTION();
 
@@ -154,51 +154,7 @@ namespace Volt::RHI
 
 	void VulkanSwapchain::BeginFrame()
 	{
-		VT_PROFILE_FUNCTION();
-
-		if (m_swapchainNeedsRebuild)
-		{
-			QuerySwapchainCapabilities();
-			Invalidate(m_width, m_height, m_VSyncEnabled);
-			m_swapchainNeedsRebuild = false;
-		}
-
-		auto device = GraphicsContext::GetDevice();
-		auto& frameData = m_perFrameInFlightData.at(m_currentFrameIndex);
-
-		vkWaitForFences(device->GetHandle<VkDevice>(), 1, &frameData.renderFence, VK_TRUE, UINT64_MAX);
-		vkResetFences(device->GetHandle<VkDevice>(), 1, &frameData.renderFence);
-
-		VkResult swapchainStatus;
-		{
-			VT_PROFILE_SCOPE("AcquireNextImage");
-
-			// Reset the 'wait' of the semaphore
-			VulkanSemaphore* vkSemaphore = ResourceCast(frameData.acquireSemaphore.GetRaw());
-			vkSemaphore->ResetWait();
-
-			m_swapchainMutex.lock();
-			swapchainStatus = vkAcquireNextImageKHR(device->GetHandle<VkDevice>(), m_swapchain, 1000000000, frameData.acquireSemaphore->GetHandle<VkSemaphore>(), nullptr, &m_currentImageIndex);
-			m_swapchainMutex.unlock();
-		}
-
-		if (swapchainStatus == VK_SUCCESS || swapchainStatus == VK_SUBOPTIMAL_KHR)
-		{
-			if (m_perImageData[m_currentImageIndex].imageReference == nullptr)
-			{
-				CreateSwapchainImage(m_currentImageIndex);
-			}
-		}
-
-		if (swapchainStatus == VK_ERROR_OUT_OF_DATE_KHR)
-		{
-			m_swapchainNeedsRebuild = true;
-			return;
-		}
-		else if (swapchainStatus != VK_SUCCESS && swapchainStatus != VK_SUBOPTIMAL_KHR)
-		{
-			VT_ENSURE_NO_ENTRY();
-		}
+		BeginFrameInternal(true);
 	}
 
 	void VulkanSwapchain::Present()
@@ -227,11 +183,6 @@ namespace Volt::RHI
 
 		m_commandBuffers.at(m_currentFrameIndex)->End();
 
-		if (m_swapchainNeedsRebuild)
-		{
-			return;
-		}
-
 		PerFrameInFlightData& frameData = m_perFrameInFlightData.at(m_currentFrameIndex);
 		PerImageData& imageData = m_perImageData.at(m_currentImageIndex);
 
@@ -350,8 +301,17 @@ namespace Volt::RHI
 
 		QuerySwapchainCapabilities();
 
-		CreateSwapchain(width, height, enableVSync);
-		CreateSyncObjects();
+		VkSwapchainKHR oldSwapchain = CreateSwapchain(width, height, enableVSync);
+
+		if (oldSwapchain)
+		{
+			ReleasePreviousSwapchain(oldSwapchain);
+		}
+
+		if (m_perFrameInFlightData.empty())
+		{
+			CreateSyncObjects();
+		}
 		CreateRenderSemaphores();
 	}
 
@@ -467,7 +427,8 @@ namespace Volt::RHI
 
 			VT_VK_CHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice->GetHandle<VkPhysicalDevice>(), m_surface, &presentModeCount, vkPresentModes.data()));
 
-			m_capabilities.presentModes.resize(presentModeCount);
+			m_capabilities.presentModes.clear();
+			m_capabilities.presentModes.reserve(presentModeCount);
 
 			for (VkPresentModeKHR presentMode : vkPresentModes)
 			{
@@ -486,18 +447,12 @@ namespace Volt::RHI
 	{
 		VT_PROFILE_FUNCTION();
 
-		const VkSurfaceFormatKHR surfaceFormat = Utility::ChooseSwapchainFormat(m_capabilities.surfaceFormats, m_createInfo.useHDRIfAvailable);
+		std::scoped_lock lock{ m_swapchainMutex };
 
-		if (surfaceFormat.format == VK_FORMAT_R16G16B16A16_SFLOAT ||
-			surfaceFormat.format == VK_FORMAT_A2R10G10B10_UNORM_PACK32 ||
-			surfaceFormat.format == VK_FORMAT_A2B10G10R10_UNORM_PACK32)
-		{
-			m_isHDREnabled = true;
-		}
-		else
-		{
-			m_isHDREnabled = false;
-		}
+		ColorSpace selectedColorSpace;
+		const VkSurfaceFormatKHR surfaceFormat = Utility::ChooseSwapchainFormat(m_capabilities.surfaceFormats, m_createInfo.useHDRIfAvailable, selectedColorSpace);
+
+		m_isHDREnabled = Utility::IsHDRColorSpace(selectedColorSpace);
 
 		const VkPresentModeKHR presentMode = Utility::ChooseSwapchainPresentMode(enableVSync, m_capabilities.presentModes);
 
@@ -508,8 +463,23 @@ namespace Volt::RHI
 		}
 
 		// Make sure the requested size is within the capabilities of the swapchain
-		m_width = m_capabilities.currentExtent.width;
-		m_height = m_capabilities.currentExtent.height;
+		if (m_capabilities.currentExtent.width == 0 || m_capabilities.currentExtent.height == 0)
+		{
+			return nullptr;
+		}
+
+		if (m_capabilities.currentExtent.width == 0xFFFFFFFF)
+		{
+			m_width = width;
+		}
+
+		if (m_capabilities.currentExtent.height == 0xFFFFFFFF)
+		{
+			m_height = m_capabilities.currentExtent.height;
+		}
+
+		m_width = std::clamp(m_width, m_capabilities.minImageExtent.width, m_capabilities.maxImageExtent.width);
+		m_height = std::clamp(m_height, m_capabilities.minImageExtent.height, m_capabilities.maxImageExtent.height);
 
 		VkSwapchainKHR oldSwapchain = m_swapchain;
 
@@ -615,7 +585,7 @@ namespace Volt::RHI
 		auto vulkanContext = GraphicsContext::Get().As<VulkanGraphicsContext>();
 		VkInstance instance = vulkanContext->GetHandle<VkInstance>();
 
-		vkCreateWin32SurfaceKHR(instance, &createInfo, VT_VULKAN_ALLOCATOR, &m_surface);
+		VT_VK_CHECK(vkCreateWin32SurfaceKHR(instance, &createInfo, VT_VULKAN_ALLOCATOR, &m_surface));
 #endif
 	}
 
@@ -681,4 +651,52 @@ namespace Volt::RHI
 
 		}, nullptr);
 	}
+
+	void VulkanSwapchain::BeginFrameInternal(bool waitForFences)
+	{
+		VT_PROFILE_FUNCTION();
+
+		auto device = GraphicsContext::GetDevice();
+		auto& frameData = m_perFrameInFlightData.at(m_currentFrameIndex);
+
+		if (waitForFences)
+		{
+			vkWaitForFences(device->GetHandle<VkDevice>(), 1, &frameData.renderFence, VK_TRUE, UINT64_MAX);
+			vkResetFences(device->GetHandle<VkDevice>(), 1, &frameData.renderFence);
+		}
+
+		VkResult swapchainStatus;
+		{
+			VT_PROFILE_SCOPE("AcquireNextImage");
+
+			// Reset the 'wait' of the semaphore
+			VulkanSemaphore* vkSemaphore = ResourceCast(frameData.acquireSemaphore.GetRaw());
+			vkSemaphore->ResetWait();
+
+			m_swapchainMutex.lock();
+			swapchainStatus = vkAcquireNextImageKHR(device->GetHandle<VkDevice>(), m_swapchain, 1000000000, frameData.acquireSemaphore->GetHandle<VkSemaphore>(), nullptr, &m_currentImageIndex);
+			m_swapchainMutex.unlock();
+		}
+
+		if (swapchainStatus == VK_SUCCESS || swapchainStatus == VK_SUBOPTIMAL_KHR)
+		{
+			if (m_perImageData[m_currentImageIndex].imageReference == nullptr)
+			{
+				CreateSwapchainImage(m_currentImageIndex);
+			}
+		}
+
+		if (swapchainStatus == VK_ERROR_OUT_OF_DATE_KHR || swapchainStatus == VK_TIMEOUT)
+		{
+			Invalidate(m_width, m_height, m_VSyncEnabled);
+		
+			// Since the fence has already been reset, we should not wait on it,
+			// or it will wait indefinetly.
+			BeginFrameInternal(false);
+		}
+		else if (swapchainStatus != VK_SUCCESS && swapchainStatus != VK_SUBOPTIMAL_KHR)
+		{
+			VT_ENSURE_NO_ENTRY();
+		}
+	}
 }
diff --git a/Engine/Source/VulkanRHIModule/Public/VulkanRHIModule/Graphics/VulkanSwapchain.h b/Engine/Source/VulkanRHIModule/Public/VulkanRHIModule/Graphics/VulkanSwapchain.h
@@ -59,6 +59,8 @@ namespace Volt::RHI
 		void Invalidate(const uint32_t width, const uint32_t height, bool enableVSync);
 		void Release();
 
+		void BeginFrameInternal(bool waitForFences);
+
 		void QuerySwapchainCapabilities();
 
 		VkSwapchainKHR_T* CreateSwapchain(const uint32_t width, const uint32_t height, bool enableVSync);
diff --git a/Engine/Source/WindowModule/Private/WindowModule/Platform/WindowsWindow.cpp b/Engine/Source/WindowModule/Private/WindowModule/Platform/WindowsWindow.cpp
@@ -353,11 +353,44 @@ namespace Volt
 
 	void WindowsWindow::BeginFrame()
 	{
+		if (m_wasMinimizedPreviousFrame)
+		{
+			m_wasMinimizedPreviousFrame = false;
+			m_isMinimized = true;
+		}
+
+		if (m_wasRestoredPreviousFrame)
+		{
+			m_wasRestoredPreviousFrame = false;
+			m_isMinimized = false;
+		}
+
+		if (m_requiresResize)
+		{
+			m_requiresResize = false;
+
+			m_width = m_requestedWidth;
+			m_height = m_requestedHeight;
+
+			m_swapchain->Resize(m_width, m_height, m_enableVSync);
+			m_onWindowResize.Broadcast(*this, m_width, m_height);
+		}
+
+		if (m_isMinimized)
+		{
+			return;
+		}
+
 		m_swapchain->BeginFrame();
 	}
 
 	void WindowsWindow::Present()
 	{
+		if (m_isMinimized)
+		{
+			return;
+		}
+
 		m_swapchain->Present();
 	}
 
@@ -368,6 +401,11 @@ namespace Volt
 
 	void WindowsWindow::Render()
 	{
+		if (m_isMinimized)
+		{
+			return;
+		}
+
 		m_onWindowRender.Broadcast(*this);
 	}
 
@@ -603,20 +641,25 @@ namespace Volt
 
 			case WM_SIZE:
 			{
-				UINT x = LOWORD(lParam);
-				UINT y = HIWORD(lParam);
-				
-				m_width = x;
-				m_height = y;
+				if (wParam == SIZE_MINIMIZED)
+				{
+					m_wasMinimizedPreviousFrame = true;
 
-				// This message might be called before the swapchain has been created (inside the CreateWindowW call)
-				// Only send an event and resize the swapchain if it exists.
-				if (m_swapchain)
+					// Should not resize swapchain when minimizing.
+					break;
+				}
+				else if (wParam == SIZE_RESTORED)
 				{
-					m_swapchain->Resize(x, y, m_enableVSync);
-					m_onWindowResize.Broadcast(*this, x, y);
+					m_wasRestoredPreviousFrame = true;
 				}
 
+				UINT x = LOWORD(lParam);
+				UINT y = HIWORD(lParam);
+				
+				m_requestedWidth = x;
+				m_requestedHeight = y;
+				m_requiresResize = true;
+
 				break;
 			}
 
diff --git a/Engine/Source/WindowModule/Private/WindowModule/Platform/WindowsWindow.h b/Engine/Source/WindowModule/Private/WindowModule/Platform/WindowsWindow.h
@@ -106,8 +106,14 @@ namespace Volt
 
 		uint32_t m_width;
 		uint32_t m_height;
+		uint32_t m_requestedWidth;
+		uint32_t m_requestedHeight;
 
 		bool m_enableVSync : 1;
 		bool m_isDecorated : 1;
+		bool m_wasMinimizedPreviousFrame : 1 = false;
+		bool m_wasRestoredPreviousFrame : 1 = false;
+		bool m_isMinimized : 1 = false;
+		bool m_requiresResize : 1 = false;
 	};
 }
diff --git a/Engine/Source/WindowModule/Private/WindowModule/Window.cpp b/Engine/Source/WindowModule/Private/WindowModule/Window.cpp
@@ -182,6 +182,11 @@ namespace Volt
 			}
 
 			voltWindow.m_shouldSkipDispatchResizeEvent = false;
+		
+			if (width > 0 && height > 0)
+			{
+				voltWindow.m_isMinimized = false;
+			}
 		});
 
 		glfwSetWindowCloseCallback(m_window, [](GLFWwindow* window)
@@ -447,19 +452,40 @@ namespace Volt
 
 	void Window::BeginFrame()
 	{
+		if (m_wasMinimized)
+		{
+			m_isMinimized = true;
+			m_wasMinimized = false;
+		}
+
+		if (m_isMinimized)
+		{
+			return;
+		}
+
 		m_swapchain->BeginFrame();
 
 		m_frameHasStarted = true;
 	}
 
 	void Window::Render(float timestep)
 	{
+		if (m_isMinimized)
+		{
+			return;
+		}
+
 		WindowRenderEvent renderEvent(*this, timestep);
 		EventSystem::DispatchEvent(renderEvent);
 	}
 
 	void Window::Present()
 	{
+		if (m_isMinimized)
+		{
+			return;
+		}
+
 		if (m_frameHasStarted)
 		{
 			m_swapchain->Present();
@@ -515,6 +541,7 @@ namespace Volt
 	void Window::Minimize() const
 	{
 		glfwIconifyWindow(m_window);
+		m_wasMinimized = true;
 	}
 
 	void Window::Restore() const
diff --git a/Engine/Source/WindowModule/Public/WindowModule/Window.h b/Engine/Source/WindowModule/Public/WindowModule/Window.h
