Vulkan: detect swapchain recreation passively

include/platform/FeaturesVk.h

@@ -150,12 +150,12 @@ struct FeaturesVk : FeatureSetBase
 
     // When the scissor is (0,0,0,0) on Windows Intel, the driver acts as if the scissor was
     // disabled.  Work-around this by setting the scissor to just outside of the render area
-    // (e.g. (renderArea.x, renderArea.y, 1, 1)). http://anglebug.com/3153
+    // (e.g. (renderArea.x, renderArea.y, 1, 1)). http://anglebug.com/3407
     Feature forceNonZeroScissor = {
         "force_non_zero_scissor", FeatureCategory::VulkanWorkarounds,
         "On Windows Intel, when the scissor is (0,0,0,0), the driver acts as if the "
         "scissor was disabled",
-        &members, "http://anglebug.com/3153"};
+        &members, "http://anglebug.com/3407"};
 
     // OES_depth_texture is a commonly expected feature on Android. However it
     // requires that D16_UNORM support texture filtering
@@ -174,6 +174,16 @@ struct FeaturesVk : FeatureSetBase
         "disable_flipping_blit_with_command", FeatureCategory::VulkanWorkarounds,
         "On some android devices, vkCmdBlitImage with flipped coordinates blits incorrectly.",
         &members, "http://anglebug.com/3498"};
+
+    // On platform with Intel or AMD GPU, a window resizing would not trigger the vulkan driver to
+    // return VK_ERROR_OUT_OF_DATE on swapchain present.  Work-around by query current window extent
+    // every frame to detect a window resizing.
+    // http://anglebug.com/3623, http://anglebug.com/3624, http://anglebug.com/3625
+    Feature perFrameWindowSizeQuery = {
+        "per_frame_window_size_query", FeatureCategory::VulkanWorkarounds,
+        "On platform with Intel or AMD gpu, vulkan swapchain is not returning VK_ERROR_OUT_OF_DATE"
+        "when window resizing",
+        &members, "http://anglebug.com/3623, http://anglebug.com/3624, http://anglebug.com/3625"};
 };
 
 inline FeaturesVk::FeaturesVk()  = default;

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -1240,6 +1240,12 @@ void RendererVk::initFeatures(const ExtensionNameList &deviceExtensionNames)
         mFeatures.forceNonZeroScissor.enabled = true;
     }
 
+    if (IsIntel(mPhysicalDeviceProperties.vendorID) ||
+        (IsWindows() && IsAMD(mPhysicalDeviceProperties.vendorID)))
+    {
+        mFeatures.perFrameWindowSizeQuery.enabled = true;
+    }
+
     if (IsAndroid() && IsQualcomm(mPhysicalDeviceProperties.vendorID))
     {
         mFeatures.forceD16TexFilter.enabled = true;

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -581,6 +581,8 @@ angle::Result WindowSurfaceVk::createSwapChain(vk::Context *context,
                                                const gl::Extents &extents,
                                                VkSwapchainKHR oldSwapchain)
 {
+    ANGLE_TRACE_EVENT0("gpu.angle", "WindowSurfaceVk::createSwapchain");
+
     ASSERT(mSwapchain == VK_NULL_HANDLE);
 
     RendererVk *renderer = context->getRenderer();
@@ -705,40 +707,45 @@ bool WindowSurfaceVk::isMultiSampled() const
 
 angle::Result WindowSurfaceVk::checkForOutOfDateSwapchain(ContextVk *contextVk,
                                                           uint32_t swapHistoryIndex,
-                                                          bool swapchainOutOfDate)
+                                                          bool presentOutOfDate)
 {
     bool swapIntervalChanged = mSwapchainPresentMode != mDesiredSwapchainPresentMode;
 
-    // Check for window resize and recreate swapchain if necessary.
-    gl::Extents currentExtents;
-    ANGLE_TRY(getCurrentWindowSize(contextVk, &currentExtents));
-
-    gl::Extents swapchainExtents(getWidth(), getHeight(), 0);
-
-    // If window size has changed, check with surface capabilities.  It has been observed on
-    // Android that `getCurrentWindowSize()` returns 1920x1080 for example, while surface
-    // capabilities returns the size the surface was created with.
-    if (currentExtents != swapchainExtents)
+    // If anything has changed, recreate the swapchain.
+    if (swapIntervalChanged || presentOutOfDate ||
+        contextVk->getRenderer()->getFeatures().perFrameWindowSizeQuery.enabled)
     {
-        const VkPhysicalDevice &physicalDevice = contextVk->getRenderer()->getPhysicalDevice();
-        ANGLE_VK_TRY(contextVk, vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, mSurface,
-                                                                          &mSurfaceCaps));
+        gl::Extents swapchainExtents(getWidth(), getHeight(), 0);
 
-        uint32_t width  = mSurfaceCaps.currentExtent.width;
-        uint32_t height = mSurfaceCaps.currentExtent.height;
+        gl::Extents currentExtents;
+        ANGLE_TRY(getCurrentWindowSize(contextVk, &currentExtents));
 
-        if (width != 0xFFFFFFFFu)
+        // If window size has changed, check with surface capabilities.  It has been observed on
+        // Android that `getCurrentWindowSize()` returns 1920x1080 for example, while surface
+        // capabilities returns the size the surface was created with.
+        if (currentExtents != swapchainExtents)
         {
-            ASSERT(height != 0xFFFFFFFFu);
-            currentExtents.width  = width;
-            currentExtents.height = height;
+            const VkPhysicalDevice &physicalDevice = contextVk->getRenderer()->getPhysicalDevice();
+            ANGLE_VK_TRY(contextVk, vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+                                        physicalDevice, mSurface, &mSurfaceCaps));
+
+            uint32_t width  = mSurfaceCaps.currentExtent.width;
+            uint32_t height = mSurfaceCaps.currentExtent.height;
+
+            if (width != 0xFFFFFFFFu)
+            {
+                ASSERT(height != 0xFFFFFFFFu);
+                currentExtents.width  = width;
+                currentExtents.height = height;
+            }
         }
-    }
 
-    // If anything has changed, recreate the swapchain.
-    if (swapchainOutOfDate || swapIntervalChanged || currentExtents != swapchainExtents)
-    {
-        ANGLE_TRY(recreateSwapchain(contextVk, currentExtents, swapHistoryIndex));
+        // Check for window resize and recreate swapchain if necessary.
+        // Work-around for some device which does not return OUT_OF_DATE after window resizing
+        if (swapIntervalChanged || presentOutOfDate || currentExtents != swapchainExtents)
+        {
+            ANGLE_TRY(recreateSwapchain(contextVk, currentExtents, swapHistoryIndex));
+        }
     }
 
     return angle::Result::Continue;
@@ -864,7 +871,7 @@ egl::Error WindowSurfaceVk::swap(const gl::Context *context)
 angle::Result WindowSurfaceVk::present(ContextVk *contextVk,
                                        EGLint *rects,
                                        EGLint n_rects,
-                                       bool &swapchainOutOfDate)
+                                       bool *presentOutOfDate)
 {
     ANGLE_TRACE_EVENT0("gpu.angle", "WindowSurfaceVk::present");
 
@@ -973,8 +980,8 @@ angle::Result WindowSurfaceVk::present(ContextVk *contextVk,
     // recreate the swapchain with a new window orientation. We aren't quite ready for that so just
     // ignore for now.
     // TODO: Check for preRotation: http://anglebug.com/3502
-    swapchainOutOfDate = result == VK_ERROR_OUT_OF_DATE_KHR;
-    if (!swapchainOutOfDate && result != VK_SUBOPTIMAL_KHR)
+    *presentOutOfDate = result == VK_ERROR_OUT_OF_DATE_KHR;
+    if (!*presentOutOfDate && result != VK_SUBOPTIMAL_KHR)
     {
         ANGLE_VK_TRY(contextVk, result);
     }
@@ -989,13 +996,13 @@ angle::Result WindowSurfaceVk::swapImpl(const gl::Context *context, EGLint *rect
     ContextVk *contextVk = vk::GetImpl(context);
     DisplayVk *displayVk = vk::GetImpl(context->getDisplay());
 
-    bool swapchainOutOfDate = false;
+    bool presentOutOfDate = false;
     // Save this now, since present() will increment the value.
     size_t currentSwapHistoryIndex = mCurrentSwapHistoryIndex;
 
-    ANGLE_TRY(present(contextVk, rects, n_rects, swapchainOutOfDate));
+    ANGLE_TRY(present(contextVk, rects, n_rects, &presentOutOfDate));
 
-    ANGLE_TRY(checkForOutOfDateSwapchain(contextVk, currentSwapHistoryIndex, swapchainOutOfDate));
+    ANGLE_TRY(checkForOutOfDateSwapchain(contextVk, currentSwapHistoryIndex, presentOutOfDate));
 
     {
         // Note: TRACE_EVENT0 is put here instead of inside the function to workaround this issue:

src/libANGLE/renderer/vulkan/SurfaceVk.h

@@ -171,7 +171,7 @@ class WindowSurfaceVk : public SurfaceVk
     angle::Result present(ContextVk *contextVk,
                           EGLint *rects,
                           EGLint n_rects,
-                          bool &swapchainOutOfDate);
+                          bool *presentOutOfDate);
 
     angle::Result swapImpl(const gl::Context *context, EGLint *rects, EGLint n_rects);
 

src/tests/egl_tests/EGLSurfaceTest.cpp

@@ -302,6 +302,9 @@ TEST_P(EGLSurfaceTest, ResizeWindow)
     // TODO(syoussefi): http://anglebug.com/3123
     ANGLE_SKIP_TEST_IF(IsAndroid());
 
+    // Necessary for a window resizing test
+    mOSWindow->setVisible(true);
+
     GLenum platform               = GetParam().getRenderer();
     bool platformSupportsZeroSize = platform == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE ||
                                     platform == EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;