[Impeller] More efficient usage of transient onscreen attachments.

impeller/renderer/backend/vulkan/surface_vk.cc

@@ -30,14 +30,13 @@ std::unique_ptr<SurfaceVK> SurfaceVK::WrapSwapchainImage(
     msaa_tex_desc.size = swapchain_image->GetSize();
     msaa_tex_desc.usage = static_cast<uint64_t>(TextureUsage::kRenderTarget);
 
-    if (!swapchain_image->HasMSAATexture()) {
+    if (!swapchain_image->GetMSAATexture()) {
       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();
     }
@@ -77,6 +76,10 @@ std::unique_ptr<SurfaceVK> SurfaceVK::WrapSwapchainImage(
 
   RenderTarget render_target_desc;
   render_target_desc.SetColorAttachment(color0, 0u);
+  render_target_desc.SetupDepthStencilAttachments(
+      *context, *context->GetResourceAllocator(), swapchain_image->GetSize(),
+      enable_msaa, "Onscreen", RenderTarget::kDefaultStencilAttachmentConfig,
+      swapchain_image->GetDepthStencilTexture());
 
   // The constructor is private. So make_unique may not be used.
   return std::unique_ptr<SurfaceVK>(

impeller/renderer/backend/vulkan/surface_vk.h

@@ -7,7 +7,6 @@
 
 #include <memory>
 
-#include "flutter/fml/macros.h"
 #include "impeller/renderer/backend/vulkan/context_vk.h"
 #include "impeller/renderer/backend/vulkan/swapchain_image_vk.h"
 #include "impeller/renderer/surface.h"

impeller/renderer/backend/vulkan/swapchain_image_vk.cc

@@ -36,15 +36,20 @@ bool SwapchainImageVK::IsValid() const {
 }
 
 std::shared_ptr<Texture> SwapchainImageVK::GetMSAATexture() const {
-  return msaa_tex_;
+  return msaa_texture_;
 }
 
-bool SwapchainImageVK::HasMSAATexture() const {
-  return msaa_tex_ != nullptr;
+std::shared_ptr<Texture> SwapchainImageVK::GetDepthStencilTexture() const {
+  return depth_stencil_texture_;
 }
 
-void SwapchainImageVK::SetMSAATexture(std::shared_ptr<Texture> msaa_tex) {
-  msaa_tex_ = std::move(msaa_tex);
+void SwapchainImageVK::SetMSAATexture(std::shared_ptr<Texture> texture) {
+  msaa_texture_ = std::move(texture);
+}
+
+void SwapchainImageVK::SetDepthStencilTexture(
+    std::shared_ptr<Texture> texture) {
+  depth_stencil_texture_ = std::move(texture);
 }
 
 PixelFormat SwapchainImageVK::GetPixelFormat() const {

impeller/renderer/backend/vulkan/swapchain_image_vk.h

@@ -33,21 +33,24 @@ class SwapchainImageVK final : public TextureSourceVK {
 
   std::shared_ptr<Texture> GetMSAATexture() const;
 
-  bool HasMSAATexture() const;
+  std::shared_ptr<Texture> GetDepthStencilTexture() const;
 
   // |TextureSourceVK|
   vk::ImageView GetImageView() const override;
 
   vk::ImageView GetRenderTargetView() const override;
 
-  void SetMSAATexture(std::shared_ptr<Texture> msaa_tex);
+  void SetMSAATexture(std::shared_ptr<Texture> texture);
+
+  void SetDepthStencilTexture(std::shared_ptr<Texture> texture);
 
   bool IsSwapchainImage() const override { return true; }
 
  private:
   vk::Image image_ = VK_NULL_HANDLE;
   vk::UniqueImageView image_view_ = {};
-  std::shared_ptr<Texture> msaa_tex_;
+  std::shared_ptr<Texture> msaa_texture_;
+  std::shared_ptr<Texture> depth_stencil_texture_;
   bool is_valid_ = false;
 
   SwapchainImageVK(const SwapchainImageVK&) = delete;

impeller/renderer/backend/vulkan/swapchain_impl_vk.cc

@@ -6,6 +6,7 @@
 
 #include "fml/synchronization/semaphore.h"
 #include "impeller/base/validation.h"
+#include "impeller/core/formats.h"
 #include "impeller/renderer/backend/vulkan/command_buffer_vk.h"
 #include "impeller/renderer/backend/vulkan/command_encoder_vk.h"
 #include "impeller/renderer/backend/vulkan/context_vk.h"
@@ -228,6 +229,37 @@ SwapchainImplVK::SwapchainImplVK(const std::shared_ptr<Context>& context,
   texture_desc.size = ISize::MakeWH(swapchain_info.imageExtent.width,
                                     swapchain_info.imageExtent.height);
 
+  // Allocate a single onscreen MSAA texture and Depth+Stencil Texture to
+  // be shared by all swapchain images.
+  TextureDescriptor msaa_desc;
+  msaa_desc.storage_mode = StorageMode::kDeviceTransient;
+  msaa_desc.type = TextureType::kTexture2DMultisample;
+  msaa_desc.sample_count = SampleCount::kCount4;
+  msaa_desc.format = texture_desc.format;
+  msaa_desc.size = texture_desc.size;
+  msaa_desc.usage = static_cast<uint64_t>(TextureUsage::kRenderTarget);
+
+  TextureDescriptor depth_stencil_desc;
+  depth_stencil_desc.storage_mode = StorageMode::kDeviceTransient;
+  if (enable_msaa) {
+    depth_stencil_desc.type = TextureType::kTexture2DMultisample;
+    depth_stencil_desc.sample_count = SampleCount::kCount4;
+  } else {
+    depth_stencil_desc.type = TextureType::kTexture2D;
+    depth_stencil_desc.sample_count = SampleCount::kCount1;
+  }
+  depth_stencil_desc.format =
+      context->GetCapabilities()->GetDefaultDepthStencilFormat();
+  depth_stencil_desc.size = texture_desc.size;
+  depth_stencil_desc.usage = static_cast<uint64_t>(TextureUsage::kRenderTarget);
+
+  std::shared_ptr<Texture> msaa_texture;
+  if (enable_msaa) {
+    msaa_texture = context->GetResourceAllocator()->CreateTexture(msaa_desc);
+  }
+  std::shared_ptr<Texture> depth_stencil_texture =
+      context->GetResourceAllocator()->CreateTexture(depth_stencil_desc);
+
   std::vector<std::shared_ptr<SwapchainImageVK>> swapchain_images;
   for (const auto& image : images) {
     auto swapchain_image =
@@ -239,6 +271,8 @@ SwapchainImplVK::SwapchainImplVK(const std::shared_ptr<Context>& context,
       VALIDATION_LOG << "Could not create swapchain image.";
       return;
     }
+    swapchain_image->SetMSAATexture(msaa_texture);
+    swapchain_image->SetDepthStencilTexture(depth_stencil_texture);
 
     ContextVK::SetDebugName(
         vk_context.GetDevice(), swapchain_image->GetImage(),

impeller/renderer/backend/vulkan/test/mock_vulkan.cc

@@ -44,6 +44,8 @@ struct MockSwapchainKHR {
 
 struct MockSemaphore {};
 
+struct MockFramebuffer {};
+
 static ISize currentImageSize = ISize{1, 1};
 
 class MockDevice final {
@@ -719,6 +721,20 @@ VkResult vkAcquireNextImageKHR(VkDevice device,
   return VK_SUCCESS;
 }
 
+VkResult vkCreateFramebuffer(VkDevice device,
+                             const VkFramebufferCreateInfo* pCreateInfo,
+                             const VkAllocationCallbacks* pAllocator,
+                             VkFramebuffer* pFramebuffer) {
+  *pFramebuffer = reinterpret_cast<VkFramebuffer>(new MockFramebuffer());
+  return VK_SUCCESS;
+}
+
+void vkDestroyFramebuffer(VkDevice device,
+                          VkFramebuffer framebuffer,
+                          const VkAllocationCallbacks* pAllocator) {
+  delete reinterpret_cast<MockFramebuffer*>(framebuffer);
+}
+
 PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance,
                                             const char* pName) {
   if (strcmp("vkEnumerateInstanceExtensionProperties", pName) == 0) {
@@ -855,6 +871,10 @@ PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance,
     return (PFN_vkVoidFunction)vkDestroySurfaceKHR;
   } else if (strcmp("vkAcquireNextImageKHR", pName) == 0) {
     return (PFN_vkVoidFunction)vkAcquireNextImageKHR;
+  } else if (strcmp("vkCreateFramebuffer", pName) == 0) {
+    return (PFN_vkVoidFunction)vkCreateFramebuffer;
+  } else if (strcmp("vkDestroyFramebuffer", pName) == 0) {
+    return (PFN_vkVoidFunction)vkDestroyFramebuffer;
   }
   return noop;
 }

impeller/renderer/backend/vulkan/test/swapchain_unittests.cc

@@ -6,6 +6,7 @@
 #include "gtest/gtest.h"
 #include "impeller/renderer/backend/vulkan/swapchain_vk.h"
 #include "impeller/renderer/backend/vulkan/test/mock_vulkan.h"
+#include "impeller/renderer/backend/vulkan/texture_vk.h"
 #include "vulkan/vulkan_enums.hpp"
 
 namespace impeller {
@@ -52,5 +53,43 @@ TEST(SwapchainTest, RecreateSwapchainWhenSizeChanges) {
   EXPECT_EQ(image_b->GetSize(), expected_size);
 }
 
+TEST(SwapchainTest, CachesRenderPassOnSwapchainImage) {
+  auto const context = MockVulkanContextBuilder().Build();
+
+  auto surface = CreateSurface(*context);
+  auto swapchain =
+      SwapchainVK::Create(context, std::move(surface), ISize{1, 1});
+
+  EXPECT_TRUE(swapchain->IsValid());
+
+  // We should create 3 swapchain images with the current mock setup. However,
+  // we will only ever return the first image, so the render pass and
+  // framebuffer will be cached after one call to AcquireNextDrawable.
+  auto drawable = swapchain->AcquireNextDrawable();
+  RenderTarget render_target = drawable->GetTargetRenderPassDescriptor();
+
+  auto texture = render_target.GetRenderTargetTexture();
+  auto& texture_vk = TextureVK::Cast(*texture);
+  EXPECT_EQ(texture_vk.GetFramebuffer(), nullptr);
+  EXPECT_EQ(texture_vk.GetRenderPass(), nullptr);
+
+  auto command_buffer = context->CreateCommandBuffer();
+  auto render_pass = command_buffer->CreateRenderPass(render_target);
+
+  render_pass->EncodeCommands();
+
+  EXPECT_NE(texture_vk.GetFramebuffer(), nullptr);
+  EXPECT_NE(texture_vk.GetRenderPass(), nullptr);
+
+  {
+    auto drawable = swapchain->AcquireNextDrawable();
+    auto texture = render_target.GetRenderTargetTexture();
+    auto& texture_vk = TextureVK::Cast(*texture);
+
+    EXPECT_NE(texture_vk.GetFramebuffer(), nullptr);
+    EXPECT_NE(texture_vk.GetRenderPass(), nullptr);
+  }
+}
+
 }  // namespace testing
 }  // namespace impeller

impeller/renderer/backend/vulkan/texture_source_vk.cc

@@ -62,4 +62,22 @@ fml::Status TextureSourceVK::SetLayout(const BarrierVK& barrier) const {
   return {};
 }
 
+void TextureSourceVK::SetFramebuffer(
+    const SharedHandleVK<vk::Framebuffer>& framebuffer) {
+  framebuffer_ = framebuffer;
+}
+
+void TextureSourceVK::SetRenderPass(
+    const SharedHandleVK<vk::RenderPass>& render_pass) {
+  render_pass_ = render_pass;
+}
+
+SharedHandleVK<vk::Framebuffer> TextureSourceVK::GetFramebuffer() const {
+  return framebuffer_;
+}
+
+SharedHandleVK<vk::RenderPass> TextureSourceVK::GetRenderPass() const {
+  return render_pass_;
+}
+
 }  // namespace impeller

impeller/renderer/backend/vulkan/texture_source_vk.h

@@ -125,12 +125,40 @@ class TextureSourceVK {
   ///
   virtual bool IsSwapchainImage() const = 0;
 
+  // These methods should only be used by render_pass_vk.h
+
+  /// Store the last framebuffer object used with this texture.
+  ///
+  /// This field is only set if this texture is used as the resolve texture
+  /// of a render pass. By construction, this framebuffer should be compatible
+  /// with any future render passes.
+  void SetFramebuffer(const SharedHandleVK<vk::Framebuffer>& framebuffer);
+
+  /// Store the last render pass object used with this texture.
+  ///
+  /// This field is only set if this texture is used as the resolve texture
+  /// of a render pass. By construction, this framebuffer should be compatible
+  /// with any future render passes.
+  void SetRenderPass(const SharedHandleVK<vk::RenderPass>& render_pass);
+
+  /// Retrieve the last framebuffer object used with this texture.
+  ///
+  /// May be nullptr if no previous framebuffer existed.
+  SharedHandleVK<vk::Framebuffer> GetFramebuffer() const;
+
+  /// Retrieve the last render pass object used with this texture.
+  ///
+  /// May be nullptr if no previous render pass existed.
+  SharedHandleVK<vk::RenderPass> GetRenderPass() const;
+
  protected:
   const TextureDescriptor desc_;
 
   explicit TextureSourceVK(TextureDescriptor desc);
 
  private:
+  SharedHandleVK<vk::Framebuffer> framebuffer_;
+  SharedHandleVK<vk::RenderPass> render_pass_;
   mutable RWMutex layout_mutex_;
   mutable vk::ImageLayout layout_ IPLR_GUARDED_BY(layout_mutex_) =
       vk::ImageLayout::eUndefined;

impeller/renderer/backend/vulkan/texture_vk.cc

@@ -176,20 +176,20 @@ vk::ImageView TextureVK::GetRenderTargetView() const {
 
 void TextureVK::SetFramebuffer(
     const SharedHandleVK<vk::Framebuffer>& framebuffer) {
-  framebuffer_ = framebuffer;
+  source_->SetFramebuffer(framebuffer);
 }
 
 void TextureVK::SetRenderPass(
     const SharedHandleVK<vk::RenderPass>& render_pass) {
-  render_pass_ = render_pass;
+  source_->SetRenderPass(render_pass);
 }
 
 SharedHandleVK<vk::Framebuffer> TextureVK::GetFramebuffer() const {
-  return framebuffer_;
+  return source_->GetFramebuffer();
 }
 
 SharedHandleVK<vk::RenderPass> TextureVK::GetRenderPass() const {
-  return render_pass_;
+  return source_->GetRenderPass();
 }
 
 void TextureVK::SetMipMapGenerated() {

impeller/renderer/backend/vulkan/texture_vk.h

@@ -77,8 +77,6 @@ class TextureVK final : public Texture, public BackendCast<TextureVK, Texture> {
  private:
   std::weak_ptr<Context> context_;
   std::shared_ptr<TextureSourceVK> source_;
-  SharedHandleVK<vk::Framebuffer> framebuffer_ = nullptr;
-  SharedHandleVK<vk::RenderPass> render_pass_ = nullptr;
 
   // |Texture|
   void SetLabel(std::string_view label) override;

impeller/renderer/render_target.cc

@@ -11,6 +11,7 @@
 #include "impeller/core/allocator.h"
 #include "impeller/core/formats.h"
 #include "impeller/core/texture.h"
+#include "impeller/core/texture_descriptor.h"
 #include "impeller/renderer/context.h"
 
 namespace impeller {