Vulkan: Refactor RenderTargetVk ImageViews.

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -821,8 +821,10 @@ angle::Result FramebufferVk::blit(const gl::Context *context,
         // Otherwise use a shader to do blit or resolve.
         else
         {
+            const vk::ImageView *readImageView = nullptr;
+            ANGLE_TRY(readRenderTarget->getImageView(contextVk, &readImageView));
             ANGLE_TRY(utilsVk.colorBlitResolve(contextVk, this, &readRenderTarget->getImage(),
-                                               readRenderTarget->getReadImageView(), params));
+                                               readImageView, params));
         }
     }
 
@@ -1209,7 +1211,11 @@ angle::Result FramebufferVk::getFramebuffer(ContextVk *contextVk, vk::Framebuffe
     {
         RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndexGL];
         ASSERT(colorRenderTarget);
-        attachments.push_back(colorRenderTarget->getDrawImageView()->getHandle());
+
+        const vk::ImageView *imageView = nullptr;
+        ANGLE_TRY(colorRenderTarget->getImageView(contextVk, &imageView));
+
+        attachments.push_back(imageView->getHandle());
 
         ASSERT(attachmentsSize.empty() || attachmentsSize == colorRenderTarget->getExtents());
         attachmentsSize = colorRenderTarget->getExtents();
@@ -1218,7 +1224,10 @@ angle::Result FramebufferVk::getFramebuffer(ContextVk *contextVk, vk::Framebuffe
     RenderTargetVk *depthStencilRenderTarget = mRenderTargetCache.getDepthStencil();
     if (depthStencilRenderTarget)
     {
-        attachments.push_back(depthStencilRenderTarget->getDrawImageView()->getHandle());
+        const vk::ImageView *imageView = nullptr;
+        ANGLE_TRY(depthStencilRenderTarget->getImageView(contextVk, &imageView));
+
+        attachments.push_back(imageView->getHandle());
 
         ASSERT(attachmentsSize.empty() ||
                attachmentsSize == depthStencilRenderTarget->getExtents());

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -18,25 +18,25 @@
 namespace rx
 {
 RenderTargetVk::RenderTargetVk()
-    : mImage(nullptr), mImageView(nullptr), mLevelIndex(0), mLayerIndex(0)
+    : mImage(nullptr), mImageViews(nullptr), mLevelIndex(0), mLayerIndex(0)
 {}
 
 RenderTargetVk::~RenderTargetVk() {}
 
 RenderTargetVk::RenderTargetVk(RenderTargetVk &&other)
     : mImage(other.mImage),
-      mImageView(other.mImageView),
+      mImageViews(other.mImageViews),
       mLevelIndex(other.mLevelIndex),
       mLayerIndex(other.mLayerIndex)
 {}
 
 void RenderTargetVk::init(vk::ImageHelper *image,
-                          const vk::ImageView *imageView,
+                          vk::ImageViewHelper *imageViews,
                           uint32_t levelIndex,
                           uint32_t layerIndex)
 {
     mImage      = image;
-    mImageView  = imageView;
+    mImageViews = imageViews;
     mLevelIndex = levelIndex;
     mLayerIndex = layerIndex;
 }
@@ -44,7 +44,7 @@ void RenderTargetVk::init(vk::ImageHelper *image,
 void RenderTargetVk::reset()
 {
     mImage      = nullptr;
-    mImageView  = nullptr;
+    mImageViews = nullptr;
     mLevelIndex = 0;
     mLayerIndex = 0;
 }
@@ -97,15 +97,12 @@ const vk::ImageHelper &RenderTargetVk::getImage() const
     return *mImage;
 }
 
-const vk::ImageView *RenderTargetVk::getDrawImageView() const
+angle::Result RenderTargetVk::getImageView(ContextVk *contextVk,
+                                           const vk::ImageView **imageViewOut) const
 {
-    ASSERT(mImageView && mImageView->valid());
-    return mImageView;
-}
-
-const vk::ImageView *RenderTargetVk::getReadImageView() const
-{
-    return getDrawImageView();
+    ASSERT(mImage && mImage->valid() && mImageViews);
+    return mImageViews->getLevelLayerDrawImageView(contextVk, *mImage, mLevelIndex, mLayerIndex,
+                                                   imageViewOut);
 }
 
 const vk::Format &RenderTargetVk::getImageFormat() const
@@ -120,11 +117,11 @@ gl::Extents RenderTargetVk::getExtents() const
     return mImage->getLevelExtents2D(static_cast<uint32_t>(mLevelIndex));
 }
 
-void RenderTargetVk::updateSwapchainImage(vk::ImageHelper *image, const vk::ImageView *imageView)
+void RenderTargetVk::updateSwapchainImage(vk::ImageHelper *image, vk::ImageViewHelper *imageViews)
 {
-    ASSERT(image && image->valid() && imageView && imageView->valid());
-    mImage     = image;
-    mImageView = imageView;
+    ASSERT(image && image->valid() && imageViews);
+    mImage      = image;
+    mImageViews = imageViews;
 }
 
 vk::ImageHelper *RenderTargetVk::getImageForRead(ContextVk *contextVk,

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -44,7 +44,7 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
     RenderTargetVk(RenderTargetVk &&other);
 
     void init(vk::ImageHelper *image,
-              const vk::ImageView *imageView,
+              vk::ImageViewHelper *imageViews,
               uint32_t levelIndex,
               uint32_t layerIndex);
     void reset();
@@ -68,8 +68,8 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
     vk::ImageHelper *getImageForWrite(ContextVk *contextVk,
                                       vk::CommandGraphResource *writingResource) const;
 
-    const vk::ImageView *getDrawImageView() const;
-    const vk::ImageView *getReadImageView() const;
+    // For cube maps we use single-level single-layer 2D array views.
+    angle::Result getImageView(ContextVk *contextVk, const vk::ImageView **imageViewOut) const;
 
     const vk::Format &getImageFormat() const;
     gl::Extents getExtents() const;
@@ -78,15 +78,13 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
 
     // Special mutator for Surface RenderTargets. Allows the Framebuffer to keep a single
     // RenderTargetVk pointer.
-    void updateSwapchainImage(vk::ImageHelper *image, const vk::ImageView *imageView);
+    void updateSwapchainImage(vk::ImageHelper *image, vk::ImageViewHelper *imageViews);
 
     angle::Result flushStagedUpdates(ContextVk *contextVk);
 
   private:
     vk::ImageHelper *mImage;
-    // Note that the draw and read image views are the same, given the requirements of a render
-    // target. Note that for cube maps we use 2D array views.
-    const vk::ImageView *mImageView;
+    vk::ImageViewHelper *mImageViews;
     uint32_t mLevelIndex;
     uint32_t mLayerIndex;
 };

src/libANGLE/renderer/vulkan/RenderbufferVk.cpp

@@ -78,13 +78,10 @@ angle::Result RenderbufferVk::setStorageImpl(const gl::Context *context,
         VkMemoryPropertyFlags flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
         ANGLE_TRY(mImage->initMemory(contextVk, renderer->getMemoryProperties(), flags));
 
-        const vk::ImageView *imageView = nullptr;
-        ANGLE_TRY(mImageViews.getLevelLayerDrawImageView(contextVk, *mImage, 0, 0, &imageView));
-
         // Clear the renderbuffer if it has emulated channels.
         mImage->stageClearIfEmulatedFormat(gl::ImageIndex::Make2D(0), vkFormat);
 
-        mRenderTarget.init(mImage, imageView, 0, 0);
+        mRenderTarget.init(mImage, &mImageViews, 0, 0);
     }
 
     return angle::Result::Continue;
@@ -172,11 +169,7 @@ angle::Result RenderbufferVk::setStorageEGLImageTarget(const gl::Context *contex
                                         imageVk->getImage()->getSamples());
     }
 
-    const vk::ImageView *imageView = nullptr;
-    ANGLE_TRY(mImageViews.getLevelLayerDrawImageView(contextVk, *mImage, imageVk->getImageLevel(),
-                                                     imageVk->getImageLayer(), &imageView));
-
-    mRenderTarget.init(mImage, imageView, imageVk->getImageLevel(), imageVk->getImageLayer());
+    mRenderTarget.init(mImage, &mImageViews, imageVk->getImageLevel(), imageVk->getImageLayer());
 
     return angle::Result::Continue;
 }

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -148,7 +148,6 @@ angle::Result OffscreenSurfaceVk::AttachmentImage::initialize(DisplayVk *display
 
     VkMemoryPropertyFlags flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
     ANGLE_TRY(image.initMemory(displayVk, renderer->getMemoryProperties(), flags));
-    ANGLE_TRY(imageViews.getLevelLayerDrawImageView(displayVk, image, 0, 0, &drawView));
 
     // Clear the image if it has emulated channels.
     image.stageClearIfEmulatedFormat(gl::ImageIndex::Make2D(0), vkFormat);
@@ -195,7 +194,7 @@ angle::Result OffscreenSurfaceVk::initializeImpl(DisplayVk *displayVk)
     {
         ANGLE_TRY(mColorAttachment.initialize(
             displayVk, mWidth, mHeight, renderer->getFormat(config->renderTargetFormat), samples));
-        mColorRenderTarget.init(&mColorAttachment.image, mColorAttachment.drawView, 0, 0);
+        mColorRenderTarget.init(&mColorAttachment.image, &mColorAttachment.imageViews, 0, 0);
     }
 
     if (config->depthStencilFormat != GL_NONE)
@@ -203,7 +202,7 @@ angle::Result OffscreenSurfaceVk::initializeImpl(DisplayVk *displayVk)
         ANGLE_TRY(mDepthStencilAttachment.initialize(
             displayVk, mWidth, mHeight, renderer->getFormat(config->depthStencilFormat), samples));
         mDepthStencilRenderTarget.init(&mDepthStencilAttachment.image,
-                                       mDepthStencilAttachment.drawView, 0, 0);
+                                       &mDepthStencilAttachment.imageViews, 0, 0);
     }
 
     return angle::Result::Continue;
@@ -766,13 +765,9 @@ angle::Result WindowSurfaceVk::createSwapChain(vk::Context *context,
         ANGLE_TRY(mColorImageMS.initMemory(context, renderer->getMemoryProperties(),
                                            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT));
 
-        const vk::ImageView *msDrawView = nullptr;
-        ANGLE_TRY(mColorImageMSViews.getLevelLayerDrawImageView(context, mColorImageMS, 0, 0,
-                                                                &msDrawView));
-
         // Initialize the color render target with the multisampled targets.  If not multisampled,
         // the render target will be updated to refer to a swapchain image on every acquire.
-        mColorRenderTarget.init(&mColorImageMS, msDrawView, 0, 0);
+        mColorRenderTarget.init(&mColorImageMS, &mColorImageMSViews, 0, 0);
 
         // Clear the image if it has emulated channels.
         mColorImageMS.stageClearIfEmulatedFormat(gl::ImageIndex::Make2D(0), format);
@@ -787,12 +782,6 @@ angle::Result WindowSurfaceVk::createSwapChain(vk::Context *context,
 
         if (!mColorImageMS.valid())
         {
-            // If the multisampled image is used, we don't need a view on the swapchain image, as
-            // it's only used as a resolve destination.  This has the added benefit that we can't
-            // accidentally use this image.
-            ANGLE_TRY(member.imageViews.getLevelLayerDrawImageView(context, member.image, 0, 0,
-                                                                   &member.drawView));
-
             // Clear the image if it has emulated channels.  If a multisampled image exists, this
             // image will be unused until a pre-present resolve, at which point it will be fully
             // initialized and wouldn't need a clear.
@@ -812,11 +801,7 @@ angle::Result WindowSurfaceVk::createSwapChain(vk::Context *context,
         ANGLE_TRY(mDepthStencilImage.initMemory(context, renderer->getMemoryProperties(),
                                                 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT));
 
-        const vk::ImageView *dsDrawView = nullptr;
-        ANGLE_TRY(mDepthStencilImageViews.getLevelLayerDrawImageView(context, mDepthStencilImage, 0,
-                                                                     0, &dsDrawView));
-
-        mDepthStencilRenderTarget.init(&mDepthStencilImage, dsDrawView, 0, 0);
+        mDepthStencilRenderTarget.init(&mDepthStencilImage, &mDepthStencilImageViews, 0, 0);
 
         // We will need to pass depth/stencil image views to the RenderTargetVk in the future.
 
@@ -1186,7 +1171,7 @@ VkResult WindowSurfaceVk::nextSwapchainImage(vk::Context *context)
     // multisampling, as the swapchain image is essentially unused until then.
     if (!mColorImageMS.valid())
     {
-        mColorRenderTarget.updateSwapchainImage(&image.image, image.drawView);
+        mColorRenderTarget.updateSwapchainImage(&image.image, &image.imageViews);
     }
 
     return VK_SUCCESS;
@@ -1283,7 +1268,7 @@ EGLint WindowSurfaceVk::getSwapBehavior() const
     return EGL_BUFFER_DESTROYED;
 }
 
-angle::Result WindowSurfaceVk::getCurrentFramebuffer(vk::Context *context,
+angle::Result WindowSurfaceVk::getCurrentFramebuffer(ContextVk *contextVk,
                                                      const vk::RenderPass &compatibleRenderPass,
                                                      vk::Framebuffer **framebufferOut)
 {
@@ -1305,7 +1290,9 @@ angle::Result WindowSurfaceVk::getCurrentFramebuffer(vk::Context *context,
 
     if (mDepthStencilImage.valid())
     {
-        imageViews[1] = mDepthStencilRenderTarget.getDrawImageView()->getHandle();
+        const vk::ImageView *imageView = nullptr;
+        ANGLE_TRY(mDepthStencilRenderTarget.getImageView(contextVk, &imageView));
+        imageViews[1] = imageView->getHandle();
     }
 
     framebufferInfo.sType           = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
@@ -1320,16 +1307,22 @@ angle::Result WindowSurfaceVk::getCurrentFramebuffer(vk::Context *context,
     if (isMultiSampled())
     {
         // If multisampled, there is only a single color image and framebuffer.
-        imageViews[0] = mColorRenderTarget.getDrawImageView()->getHandle();
-        ANGLE_VK_TRY(context, mFramebufferMS.init(context->getDevice(), framebufferInfo));
+        const vk::ImageView *imageView = nullptr;
+        ANGLE_TRY(mColorRenderTarget.getImageView(contextVk, &imageView));
+        imageViews[0] = imageView->getHandle();
+        ANGLE_VK_TRY(contextVk, mFramebufferMS.init(contextVk->getDevice(), framebufferInfo));
     }
     else
     {
         for (SwapchainImage &swapchainImage : mSwapchainImages)
         {
-            imageViews[0] = swapchainImage.drawView->getHandle();
-            ANGLE_VK_TRY(context,
-                         swapchainImage.framebuffer.init(context->getDevice(), framebufferInfo));
+            const vk::ImageView *imageView = nullptr;
+            ANGLE_TRY(swapchainImage.imageViews.getLevelLayerDrawImageView(
+                contextVk, swapchainImage.image, 0, 0, &imageView));
+
+            imageViews[0] = imageView->getHandle();
+            ANGLE_VK_TRY(contextVk,
+                         swapchainImage.framebuffer.init(contextVk->getDevice(), framebufferInfo));
         }
     }
 
@@ -1392,7 +1385,10 @@ angle::Result WindowSurfaceVk::updateAndDrawOverlay(ContextVk *contextVk,
     }
 
     // Draw overlay
-    ANGLE_TRY(overlayVk->onPresent(contextVk, &image->image, image->drawView));
+    const vk::ImageView *imageView = nullptr;
+    ANGLE_TRY(
+        image->imageViews.getLevelLayerDrawImageView(contextVk, image->image, 0, 0, &imageView));
+    ANGLE_TRY(overlayVk->onPresent(contextVk, &image->image, imageView));
 
     overlay->getRunningGraphWidget(gl::WidgetId::VulkanCommandGraphSize)->next();
 

src/libANGLE/renderer/vulkan/SurfaceVk.h

@@ -89,7 +89,6 @@ class OffscreenSurfaceVk : public SurfaceVk
 
         vk::ImageHelper image;
         vk::ImageViewHelper imageViews;
-        const vk::ImageView *drawView = nullptr;
     };
 
     angle::Result initializeImpl(DisplayVk *displayVk);
@@ -164,7 +163,6 @@ struct SwapchainImage : angle::NonCopyable
 
     vk::ImageHelper image;
     vk::ImageViewHelper imageViews;
-    const vk::ImageView *drawView = nullptr;
     vk::Framebuffer framebuffer;
 
     // A circular array of semaphores used for presenting this image.
@@ -213,7 +211,7 @@ class WindowSurfaceVk : public SurfaceVk
     angle::Result initializeContents(const gl::Context *context,
                                      const gl::ImageIndex &imageIndex) override;
 
-    angle::Result getCurrentFramebuffer(vk::Context *context,
+    angle::Result getCurrentFramebuffer(ContextVk *context,
                                         const vk::RenderPass &compatibleRenderPass,
                                         vk::Framebuffer **framebufferOut);
 

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -401,9 +401,12 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,
         // Layer count can only be 1 as the source is a framebuffer.
         ASSERT(offsetImageIndex.getLayerCount() == 1);
 
+        const vk::ImageView *readImageView = nullptr;
+        ANGLE_TRY(colorReadRT->getImageView(contextVk, &readImageView));
+
         return copySubImageImplWithDraw(contextVk, offsetImageIndex, modifiedDestOffset, destFormat,
                                         0, clippedSourceArea, isViewportFlipY, false, false, false,
-                                        &colorReadRT->getImage(), colorReadRT->getReadImageView());
+                                        &colorReadRT->getImage(), readImageView);
     }
 
     // Do a CPU readback that does the conversion, and then stage the change to the pixel buffer.
@@ -1314,10 +1317,8 @@ angle::Result TextureVk::initRenderTargets(ContextVk *contextVk,
 
     for (uint32_t layerIndex = 0; layerIndex < layerCount; ++layerIndex)
     {
-        const vk::ImageView *drawView;
-        ANGLE_TRY(getLevelLayerImageView(contextVk, levelIndex, layerIndex, &drawView));
         mRenderTargets[levelIndex][layerIndex].init(
-            mImage, drawView, getNativeImageLevel(levelIndex), getNativeImageLayer(layerIndex));
+            mImage, &mImageViews, getNativeImageLevel(levelIndex), getNativeImageLayer(layerIndex));
     }
     return angle::Result::Continue;
 }