[Impeller] size vk swapchain to window size. (flutter#50205)

The size the engine recieves from the `AndroidSurfaceVulkanImpeller::OnScreenSurfaceResize` appears to be correct in the case of window rotation. Use this instead of physical surface properties to set the swapchain image size.

Querying the physical surface properties seems to have some additional non-deterministic delay. This means that querying the properties during a window rotation will frequently return old values.

Fixes flutter/flutter#138780
Fixes flutter/flutter#132708

Author: Jonah Williams

impeller/playground/backend/vulkan/playground_impl_vk.cc

@@ -85,6 +85,11 @@ PlaygroundImplVK::PlaygroundImplVK(PlaygroundSwitches switches)
     return;
   }
 
+  int width = 0;
+  int height = 0;
+  ::glfwGetWindowSize(window, &width, &height);
+  size_ = ISize{width, height};
+
   handle_.reset(window);
 
   ContextVK::Settings context_settings;
@@ -125,7 +130,7 @@ PlaygroundImplVK::PlaygroundImplVK(PlaygroundSwitches switches)
 
   vk::UniqueSurfaceKHR surface{vk_surface, context_vk->GetInstance()};
   auto context = context_vk->CreateSurfaceContext();
-  if (!context->SetWindowSurface(std::move(surface))) {
+  if (!context->SetWindowSurface(std::move(surface), size_)) {
     VALIDATION_LOG << "Could not set up surface for context.";
     return;
   }
@@ -150,6 +155,14 @@ std::unique_ptr<Surface> PlaygroundImplVK::AcquireSurfaceFrame(
     std::shared_ptr<Context> context) {
   SurfaceContextVK* surface_context_vk =
       reinterpret_cast<SurfaceContextVK*>(context_.get());
+
+  int width = 0;
+  int height = 0;
+  ::glfwGetWindowSize(reinterpret_cast<GLFWwindow*>(handle_.get()), &width,
+                      &height);
+  size_ = ISize{width, height};
+  surface_context_vk->UpdateSurfaceSize(ISize{width, height});
+
   return surface_context_vk->AcquireNextSurface();
 }
 

impeller/playground/backend/vulkan/playground_impl_vk.h

@@ -27,6 +27,7 @@ class PlaygroundImplVK final : public PlaygroundImpl {
   static void DestroyWindowHandle(WindowHandle handle);
   using UniqueHandle = std::unique_ptr<void, decltype(&DestroyWindowHandle)>;
   UniqueHandle handle_;
+  ISize size_ = {1, 1};
 
   // A global Vulkan instance which ensures that the Vulkan library will remain
   // loaded throughout the lifetime of the process.

impeller/renderer/backend/vulkan/BUILD.gn

@@ -19,6 +19,7 @@ impeller_component("vulkan_unittests") {
     "test/mock_vulkan.cc",
     "test/mock_vulkan.h",
     "test/mock_vulkan_unittests.cc",
+    "test/swapchain_unittests.cc",
   ]
   deps = [
     ":vulkan",

impeller/renderer/backend/vulkan/gpu_tracer_vk.cc

@@ -76,6 +76,9 @@ bool GPUTracerVK::IsEnabled() const {
 }
 
 void GPUTracerVK::MarkFrameStart() {
+  if (!enabled_) {
+    return;
+  }
   FML_DCHECK(!in_frame_);
   in_frame_ = true;
   raster_thread_id_ = std::this_thread::get_id();

impeller/renderer/backend/vulkan/surface_context_vk.cc

@@ -8,6 +8,7 @@
 #include "impeller/renderer/backend/vulkan/command_pool_vk.h"
 #include "impeller/renderer/backend/vulkan/context_vk.h"
 #include "impeller/renderer/backend/vulkan/swapchain_vk.h"
+#include "impeller/renderer/surface.h"
 
 namespace impeller {
 
@@ -61,8 +62,9 @@ void SurfaceContextVK::Shutdown() {
   parent_->Shutdown();
 }
 
-bool SurfaceContextVK::SetWindowSurface(vk::UniqueSurfaceKHR surface) {
-  auto swapchain = SwapchainVK::Create(parent_, std::move(surface));
+bool SurfaceContextVK::SetWindowSurface(vk::UniqueSurfaceKHR surface,
+                                        const ISize& size) {
+  auto swapchain = SwapchainVK::Create(parent_, std::move(surface), size);
   if (!swapchain) {
     VALIDATION_LOG << "Could not create swapchain.";
     return false;
@@ -93,6 +95,10 @@ void SurfaceContextVK::SetSyncPresentation(bool value) {
   parent_->SetSyncPresentation(value);
 }
 
+void SurfaceContextVK::UpdateSurfaceSize(const ISize& size) const {
+  swapchain_->UpdateSurfaceSize(size);
+}
+
 #ifdef FML_OS_ANDROID
 
 vk::UniqueSurfaceKHR SurfaceContextVK::CreateAndroidSurface(

impeller/renderer/backend/vulkan/surface_context_vk.h

@@ -72,10 +72,15 @@ class SurfaceContextVK : public Context,
   // |Context|
   void SetSyncPresentation(bool value) override;
 
-  [[nodiscard]] bool SetWindowSurface(vk::UniqueSurfaceKHR surface);
+  [[nodiscard]] bool SetWindowSurface(vk::UniqueSurfaceKHR surface,
+                                      const ISize& size);
 
   std::unique_ptr<Surface> AcquireNextSurface();
 
+  /// @brief Mark the current swapchain configuration as dirty, forcing it to be
+  ///        recreated on the next frame.
+  void UpdateSurfaceSize(const ISize& size) const;
+
 #ifdef FML_OS_ANDROID
   vk::UniqueSurfaceKHR CreateAndroidSurface(ANativeWindow* window) const;
 #endif  // FML_OS_ANDROID

impeller/renderer/backend/vulkan/surface_vk.cc

@@ -4,6 +4,7 @@
 
 #include "impeller/renderer/backend/vulkan/surface_vk.h"
 
+#include "impeller/core/formats.h"
 #include "impeller/renderer/backend/vulkan/swapchain_image_vk.h"
 #include "impeller/renderer/backend/vulkan/texture_vk.h"
 #include "impeller/renderer/surface.h"
@@ -13,30 +14,33 @@ namespace impeller {
 std::unique_ptr<SurfaceVK> SurfaceVK::WrapSwapchainImage(
     const std::shared_ptr<Context>& context,
     std::shared_ptr<SwapchainImageVK>& swapchain_image,
-    SwapCallback swap_callback) {
+    SwapCallback swap_callback,
+    bool enable_msaa) {
   if (!context || !swapchain_image || !swap_callback) {
     return nullptr;
   }
 
-  TextureDescriptor msaa_tex_desc;
-  msaa_tex_desc.storage_mode = StorageMode::kDeviceTransient;
-  msaa_tex_desc.type = TextureType::kTexture2DMultisample;
-  msaa_tex_desc.sample_count = SampleCount::kCount4;
-  msaa_tex_desc.format = swapchain_image->GetPixelFormat();
-  msaa_tex_desc.size = swapchain_image->GetSize();
-  msaa_tex_desc.usage = static_cast<uint64_t>(TextureUsage::kRenderTarget);
-
   std::shared_ptr<Texture> msaa_tex;
-  if (!swapchain_image->HasMSAATexture()) {
-    msaa_tex = context->GetResourceAllocator()->CreateTexture(msaa_tex_desc);
-    msaa_tex->SetLabel("ImpellerOnscreenColorMSAA");
-    if (!msaa_tex) {
-      VALIDATION_LOG << "Could not allocate MSAA color texture.";
-      return nullptr;
+  if (enable_msaa) {
+    TextureDescriptor msaa_tex_desc;
+    msaa_tex_desc.storage_mode = StorageMode::kDeviceTransient;
+    msaa_tex_desc.type = TextureType::kTexture2DMultisample;
+    msaa_tex_desc.sample_count = SampleCount::kCount4;
+    msaa_tex_desc.format = swapchain_image->GetPixelFormat();
+    msaa_tex_desc.size = swapchain_image->GetSize();
+    msaa_tex_desc.usage = static_cast<uint64_t>(TextureUsage::kRenderTarget);
+
+    if (!swapchain_image->HasMSAATexture()) {
+      msaa_tex = context->GetResourceAllocator()->CreateTexture(msaa_tex_desc);
+      msaa_tex->SetLabel("ImpellerOnscreenColorMSAA");
+      if (!msaa_tex) {
+        VALIDATION_LOG << "Could not allocate MSAA color texture.";
+        return nullptr;
+      }
+      swapchain_image->SetMSAATexture(msaa_tex);
+    } else {
+      msaa_tex = swapchain_image->GetMSAATexture();
     }
-    swapchain_image->SetMSAATexture(msaa_tex);
-  } else {
-    msaa_tex = swapchain_image->GetMSAATexture();
   }
 
   TextureDescriptor resolve_tex_desc;
@@ -60,11 +64,16 @@ std::unique_ptr<SurfaceVK> SurfaceVK::WrapSwapchainImage(
   resolve_tex->SetLabel("ImpellerOnscreenResolve");
 
   ColorAttachment color0;
-  color0.texture = msaa_tex;
   color0.clear_color = Color::DarkSlateGray();
   color0.load_action = LoadAction::kClear;
-  color0.store_action = StoreAction::kMultisampleResolve;
-  color0.resolve_texture = resolve_tex;
+  if (enable_msaa) {
+    color0.texture = msaa_tex;
+    color0.store_action = StoreAction::kMultisampleResolve;
+    color0.resolve_texture = resolve_tex;
+  } else {
+    color0.texture = resolve_tex;
+    color0.store_action = StoreAction::kStore;
+  }
 
   RenderTarget render_target_desc;
   render_target_desc.SetColorAttachment(color0, 0u);

impeller/renderer/backend/vulkan/surface_vk.h

@@ -21,7 +21,8 @@ class SurfaceVK final : public Surface {
   static std::unique_ptr<SurfaceVK> WrapSwapchainImage(
       const std::shared_ptr<Context>& context,
       std::shared_ptr<SwapchainImageVK>& swapchain_image,
-      SwapCallback swap_callback);
+      SwapCallback swap_callback,
+      bool enable_msaa = true);
 
   // |Surface|
   ~SurfaceVK() override;

impeller/renderer/backend/vulkan/swapchain_image_vk.h

@@ -5,7 +5,6 @@
 #ifndef FLUTTER_IMPELLER_RENDERER_BACKEND_VULKAN_SWAPCHAIN_IMAGE_VK_H_
 #define FLUTTER_IMPELLER_RENDERER_BACKEND_VULKAN_SWAPCHAIN_IMAGE_VK_H_
 
-#include "flutter/fml/macros.h"
 #include "impeller/geometry/size.h"
 #include "impeller/renderer/backend/vulkan/formats_vk.h"
 #include "impeller/renderer/backend/vulkan/texture_source_vk.h"

impeller/renderer/backend/vulkan/swapchain_impl_vk.cc

@@ -145,17 +145,18 @@ static std::optional<vk::Queue> ChoosePresentQueue(
 std::shared_ptr<SwapchainImplVK> SwapchainImplVK::Create(
     const std::shared_ptr<Context>& context,
     vk::UniqueSurfaceKHR surface,
-    vk::SwapchainKHR old_swapchain,
-    vk::SurfaceTransformFlagBitsKHR last_transform) {
+    const ISize& size,
+    bool enable_msaa,
+    vk::SwapchainKHR old_swapchain) {
   return std::shared_ptr<SwapchainImplVK>(new SwapchainImplVK(
-      context, std::move(surface), old_swapchain, last_transform));
+      context, std::move(surface), size, enable_msaa, old_swapchain));
 }
 
-SwapchainImplVK::SwapchainImplVK(
-    const std::shared_ptr<Context>& context,
-    vk::UniqueSurfaceKHR surface,
-    vk::SwapchainKHR old_swapchain,
-    vk::SurfaceTransformFlagBitsKHR last_transform) {
+SwapchainImplVK::SwapchainImplVK(const std::shared_ptr<Context>& context,
+                                 vk::UniqueSurfaceKHR surface,
+                                 const ISize& size,
+                                 bool enable_msaa,
+                                 vk::SwapchainKHR old_swapchain) {
   if (!context) {
     VALIDATION_LOG << "Cannot create a swapchain without a context.";
     return;
@@ -209,10 +210,10 @@ SwapchainImplVK::SwapchainImplVK(
   swapchain_info.imageColorSpace = format.value().colorSpace;
   swapchain_info.presentMode = vk::PresentModeKHR::eFifo;
   swapchain_info.imageExtent = vk::Extent2D{
-      std::clamp(surface_caps.currentExtent.width,
+      std::clamp(static_cast<uint32_t>(size.width),
                  surface_caps.minImageExtent.width,
                  surface_caps.maxImageExtent.width),
-      std::clamp(surface_caps.currentExtent.height,
+      std::clamp(static_cast<uint32_t>(size.height),
                  surface_caps.minImageExtent.height,
                  surface_caps.maxImageExtent.height),
   };
@@ -304,14 +305,19 @@ SwapchainImplVK::SwapchainImplVK(
   images_ = std::move(swapchain_images);
   synchronizers_ = std::move(synchronizers);
   current_frame_ = synchronizers_.size() - 1u;
+  size_ = size;
+  enable_msaa_ = enable_msaa;
   is_valid_ = true;
-  transform_if_changed_discard_swapchain_ = last_transform;
 }
 
 SwapchainImplVK::~SwapchainImplVK() {
   DestroySwapchain();
 }
 
+const ISize& SwapchainImplVK::GetSize() const {
+  return size_;
+}
+
 bool SwapchainImplVK::IsValid() const {
   return is_valid_;
 }
@@ -337,10 +343,6 @@ vk::Format SwapchainImplVK::GetSurfaceFormat() const {
   return surface_format_;
 }
 
-vk::SurfaceTransformFlagBitsKHR SwapchainImplVK::GetLastTransform() const {
-  return transform_if_changed_discard_swapchain_;
-}
-
 std::shared_ptr<Context> SwapchainImplVK::GetContext() const {
   return context_.lock();
 }
@@ -365,26 +367,6 @@ SwapchainImplVK::AcquireResult SwapchainImplVK::AcquireNextDrawable() {
     return SwapchainImplVK::AcquireResult{};
   }
 
-  //----------------------------------------------------------------------------
-  /// Poll to see if the orientation has changed.
-  ///
-  /// https://developer.android.com/games/optimize/vulkan-prerotation#using_polling
-  current_transform_poll_count_++;
-  if (current_transform_poll_count_ >= kPollFramesForOrientation) {
-    current_transform_poll_count_ = 0u;
-    auto [caps_result, caps] =
-        context.GetPhysicalDevice().getSurfaceCapabilitiesKHR(*surface_);
-    if (caps_result != vk::Result::eSuccess) {
-      VALIDATION_LOG << "Could not get surface capabilities: "
-                     << vk::to_string(caps_result);
-      return SwapchainImplVK::AcquireResult{};
-    }
-    if (caps.currentTransform != transform_if_changed_discard_swapchain_) {
-      transform_if_changed_discard_swapchain_ = caps.currentTransform;
-      return AcquireResult{true /* out of date */};
-    }
-  }
-
   //----------------------------------------------------------------------------
   /// Get the next image index.
   ///
@@ -430,7 +412,8 @@ SwapchainImplVK::AcquireResult SwapchainImplVK::AcquireNextDrawable() {
           return false;
         }
         return swapchain->Present(image, image_index);
-      }  // swap callback
+      },            // swap callback
+      enable_msaa_  //
       )};
 }