Vulkan: Refactor image dependency commands.

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -4520,13 +4520,6 @@ angle::Result ContextVk::endRenderPass()
     return angle::Result::Continue;
 }
 
-void ContextVk::onRenderPassImageWrite(VkImageAspectFlags aspectFlags,
-                                       vk::ImageLayout imageLayout,
-                                       vk::ImageHelper *image)
-{
-    mRenderPassCommands->imageWrite(&mResourceUseList, aspectFlags, imageLayout, image);
-}
-
 void ContextVk::getNextAvailableCommandBuffer(vk::CommandBufferHelper **commandBuffer,
                                               bool hasRenderPass)
 {

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -503,17 +503,38 @@ class ContextVk : public ContextImpl, public vk::Context
         return onBufferWrite(VK_ACCESS_SHADER_WRITE_BIT, vk::PipelineStage::ComputeShader, buffer);
     }
 
-    angle::Result onImageRead(VkImageAspectFlags aspectFlags,
-                              vk::ImageLayout imageLayout,
-                              vk::ImageHelper *image);
+    angle::Result onImageTransferRead(VkImageAspectFlags aspectFlags, vk::ImageHelper *image)
+    {
+        return onImageRead(aspectFlags, vk::ImageLayout::TransferSrc, image);
+    }
+    angle::Result onImageTransferWrite(VkImageAspectFlags aspectFlags, vk::ImageHelper *image)
+    {
+        return onImageWrite(aspectFlags, vk::ImageLayout::TransferDst, image);
+    }
+    angle::Result onImageComputeShaderRead(VkImageAspectFlags aspectFlags, vk::ImageHelper *image)
+    {
+        return onImageRead(aspectFlags, vk::ImageLayout::ComputeShaderReadOnly, image);
+    }
+    angle::Result onImageComputeShaderWrite(VkImageAspectFlags aspectFlags, vk::ImageHelper *image)
+    {
+        return onImageWrite(aspectFlags, vk::ImageLayout::ComputeShaderWrite, image);
+    }
 
-    angle::Result onImageWrite(VkImageAspectFlags aspectFlags,
+    void onImageRenderPassRead(VkImageAspectFlags aspectFlags,
                                vk::ImageLayout imageLayout,
-                               vk::ImageHelper *image);
+                               vk::ImageHelper *image)
+    {
+        ASSERT(mRenderPassCommands->started());
+        mRenderPassCommands->imageRead(&mResourceUseList, aspectFlags, imageLayout, image);
+    }
 
-    void onRenderPassImageWrite(VkImageAspectFlags aspectFlags,
+    void onImageRenderPassWrite(VkImageAspectFlags aspectFlags,
                                 vk::ImageLayout imageLayout,
-                                vk::ImageHelper *image);
+                                vk::ImageHelper *image)
+    {
+        ASSERT(mRenderPassCommands->started());
+        mRenderPassCommands->imageWrite(&mResourceUseList, aspectFlags, imageLayout, image);
+    }
 
     angle::Result getOutsideRenderPassCommandBuffer(vk::CommandBuffer **commandBufferOut)
     {
@@ -877,6 +898,13 @@ class ContextVk : public ContextImpl, public vk::Context
                                 vk::PipelineStage writeStage,
                                 vk::BufferHelper *buffer);
 
+    angle::Result onImageRead(VkImageAspectFlags aspectFlags,
+                              vk::ImageLayout imageLayout,
+                              vk::ImageHelper *image);
+    angle::Result onImageWrite(VkImageAspectFlags aspectFlags,
+                               vk::ImageLayout imageLayout,
+                               vk::ImageHelper *image);
+
     void initIndexTypeMap();
 
     // Pull an available CBH ptr from the CBH queue and set to specified hasRenderPass state

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -419,8 +419,7 @@ angle::Result FramebufferVk::clearImpl(const gl::Context *context,
         vk::ImageHelper *image         = &depthStencilRT->getImageForWrite();
 
         vk::CommandBuffer *commandBuffer;
-        ANGLE_TRY(
-            contextVk->onImageWrite(image->getAspectFlags(), vk::ImageLayout::TransferDst, image));
+        ANGLE_TRY(contextVk->onImageTransferWrite(image->getAspectFlags(), image));
         ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
         VkImageSubresourceRange range;
@@ -796,8 +795,8 @@ angle::Result FramebufferVk::blitWithCommand(ContextVk *contextVk,
     }
 
     vk::CommandBuffer *commandBuffer = nullptr;
-    ANGLE_TRY(contextVk->onImageRead(imageAspectMask, vk::ImageLayout::TransferSrc, srcImage));
-    ANGLE_TRY(contextVk->onImageWrite(imageAspectMask, vk::ImageLayout::TransferDst, dstImage));
+    ANGLE_TRY(contextVk->onImageTransferRead(imageAspectMask, srcImage));
+    ANGLE_TRY(contextVk->onImageTransferWrite(imageAspectMask, dstImage));
     ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
     VkImageBlit blit                   = {};
@@ -1204,8 +1203,7 @@ angle::Result FramebufferVk::resolveColorWithCommand(ContextVk *contextVk,
                                                      vk::ImageHelper *srcImage)
 {
     vk::CommandBuffer *commandBuffer = nullptr;
-    ANGLE_TRY(
-        contextVk->onImageRead(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferSrc, srcImage));
+    ANGLE_TRY(contextVk->onImageTransferRead(VK_IMAGE_ASPECT_COLOR_BIT, srcImage));
 
     VkImageResolve resolveRegion                = {};
     resolveRegion.srcSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
@@ -1227,8 +1225,8 @@ angle::Result FramebufferVk::resolveColorWithCommand(ContextVk *contextVk,
     for (size_t colorIndexGL : mState.getEnabledDrawBuffers())
     {
         RenderTargetVk *drawRenderTarget = mRenderTargetCache.getColors()[colorIndexGL];
-        ANGLE_TRY(contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferDst,
-                                          &drawRenderTarget->getImageForWrite()));
+        ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT,
+                                                  &drawRenderTarget->getImageForWrite()));
         ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
         resolveRegion.dstSubresource.mipLevel       = drawRenderTarget->getLevelIndex();
@@ -2120,14 +2118,6 @@ angle::Result FramebufferVk::startNewRenderPass(ContextVk *contextVk,
         colorAttachmentCount++;
     }
 
-    // Transition the images to the correct layout (through onColorDraw) after the
-    // resolve-to-multisampled copies are done.
-    for (size_t colorIndexGL : mState.getEnabledDrawBuffers())
-    {
-        RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndexGL];
-        ANGLE_TRY(colorRenderTarget->onColorDraw(contextVk));
-    }
-
     // Depth/stencil attachment.
     uint32_t depthStencilAttachmentIndex     = vk::kInvalidAttachmentIndex;
     RenderTargetVk *depthStencilRenderTarget = getDepthStencilRenderTarget();
@@ -2208,17 +2198,30 @@ angle::Result FramebufferVk::startNewRenderPass(ContextVk *contextVk,
         renderPassAttachmentOps.setOps(depthStencilAttachmentIndex, depthLoadOp, depthStoreOp);
         renderPassAttachmentOps.setStencilOps(depthStencilAttachmentIndex, stencilLoadOp,
                                               stencilStoreOp);
+    }
 
+    ANGLE_TRY(contextVk->flushAndBeginRenderPass(
+        *framebuffer, renderArea, mRenderPassDesc, renderPassAttachmentOps,
+        depthStencilAttachmentIndex, packedClearValues, commandBufferOut));
+
+    // Transition the images to the correct layout (through onColorDraw) after the
+    // resolve-to-multisampled copies are done.
+    for (size_t colorIndexGL : mState.getEnabledDrawBuffers())
+    {
+        RenderTargetVk *colorRenderTarget = colorRenderTargets[colorIndexGL];
+        colorRenderTarget->onColorDraw(contextVk);
+    }
+
+    if (depthStencilRenderTarget)
+    {
         // This must be called after hasDefinedContent() since it will set content to valid. We are
         // tracking content valid very loosely here that as long as it is attached, it assumes will
         // have valid content. The only time it has undefined content is between swap and
         // startNewRenderPass
-        ANGLE_TRY(depthStencilRenderTarget->onDepthStencilDraw(contextVk));
+        depthStencilRenderTarget->onDepthStencilDraw(contextVk);
     }
 
-    return contextVk->flushAndBeginRenderPass(*framebuffer, renderArea, mRenderPassDesc,
-                                              renderPassAttachmentOps, depthStencilAttachmentIndex,
-                                              packedClearValues, commandBufferOut);
+    return angle::Result::Continue;
 }
 
 void FramebufferVk::updateActiveColorMasks(size_t colorIndexGL, bool r, bool g, bool b, bool a)

src/libANGLE/renderer/vulkan/OverlayVk.cpp

@@ -123,8 +123,7 @@ angle::Result OverlayVk::createFont(ContextVk *contextVk)
     // Copy font data from staging buffer.
     vk::CommandBuffer *fontDataUpload;
     ANGLE_TRY(contextVk->onBufferTransferRead(&fontDataBuffer.get()));
-    ANGLE_TRY(contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferDst,
-                                      &mFontImage));
+    ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT, &mFontImage));
     ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&fontDataUpload));
 
     VkBufferImageCopy copy           = {};

src/libANGLE/renderer/vulkan/README.md

@@ -26,25 +26,25 @@ of a front-end OpenGL Context. ContextVk processes state changes and handles act
 
 The back-end records commands into command buffers via the the following `ContextVk` APIs:
 
- * `endRenderPassAndGetCommandBuffer`: returns a secondary command buffer *outside* a RenderPass instance.
+ * `getOutsideRenderPassCommandBuffer`: returns a secondary command buffer *outside* a RenderPass instance.
  * `flushAndBeginRenderPass`: returns a secondary command buffer *inside* a RenderPass instance.
- * `flushAndGetPrimaryCommandBuffer`: returns the primary command buffer. You should rarely need this API.
 
 *Note*: All of these commands may write out (aka flush) prior pending commands into a primary
-command buffer. When a RenderPass is open `endRenderPassAndGetCommandBuffer` will flush the
+command buffer. When a RenderPass is open `getOutsideRenderPassCommandBuffer` will flush the
 pending RenderPass commands. `flushAndBeginRenderPass` will flush out pending commands outside a
 RenderPass to a primary buffer. On submit ANGLE submits the primary command buffer to a `VkQueue`.
 
 If you need to record inside a RenderPass, use `flushAndBeginRenderPass`. Otherwise, use
-`endRenderPassAndGetCommandBuffer`. You should rarely need to call `flushAndGetPrimaryCommandBuffer`.
-It's there for commands like debug labels, barriers and queries that need to be recorded serially on
-the primary command buffer.
+`getOutsideRenderPassCommandBuffer`.
 
-The back-end usually records Image and Buffer barriers through additional `ContextVk` APIs:
+The back-end (mostly) records Image and Buffer barriers through additional `ContextVk` APIs:
 
- * `onBufferTransferRead/onBufferComputeShaderRead` and `onBufferTransferWrite/onBufferComputeShaderWrite` accumulate `VkBuffer` barriers.
- * `onImageRead` and `onImageWrite` accumulate `VkImage` barriers.
- * `onRenderPassImageWrite` is a special API for write barriers inside a RenderPass instance.
+ * `onBufferTransferRead` and `onBufferComputeShaderRead` accumulate `VkBuffer` read barriers.
+ * `onBufferTransferWrite` and `onBufferComputeShaderWrite` accumulate `VkBuffer` write barriers.
+ * `onBuffferSelfCopy` is a special case for `VkBuffer` self copies. It behaves the same as write.
+ * `onImageTransferRead` and `onImageComputerShadeRead` accumulate `VkImage` read barriers.
+ * `onImageTransferWrite` and `onImageComputerShadeWrite` accumulate `VkImage` write barriers.
+ * `onImageRenderPassRead` and `onImageRenderPassWrite` accumulate `VkImage` barriers inside a started RenderPass.
 
 After the back-end records commands to the primary buffer we flush (e.g. on swap) or when we call
 `ContextVk::finishToSerial`.
@@ -62,7 +62,7 @@ In this example we'll be recording a buffer copy command:
 
     # Get a pointer to a secondary command buffer for command recording. May "flush" the RP.
     vk::CommandBuffer *commandBuffer;
-    ANGLE_TRY(contextVk->endRenderPassAndGetCommandBuffer(&commandBuffer));
+    ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
     # Record the copy command into the secondary buffer. We're done!
     commandBuffer->copyBuffer(srcBuffer->getBuffer(), destBuffer->getBuffer(), copyCount, copies);

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -91,42 +91,38 @@ vk::ImageViewSubresourceSerial RenderTargetVk::getResolveSubresourceSerial() con
     return getSubresourceSerialImpl(mResolveImageViews);
 }
 
-angle::Result RenderTargetVk::onColorDraw(ContextVk *contextVk)
+void RenderTargetVk::onColorDraw(ContextVk *contextVk)
 {
     ASSERT(!mImage->getFormat().actualImageFormat().hasDepthOrStencilBits());
 
-    contextVk->onRenderPassImageWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::ColorAttachment,
+    contextVk->onImageRenderPassWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::ColorAttachment,
                                       mImage);
     if (mResolveImage)
     {
-        contextVk->onRenderPassImageWrite(VK_IMAGE_ASPECT_COLOR_BIT,
+        contextVk->onImageRenderPassWrite(VK_IMAGE_ASPECT_COLOR_BIT,
                                           vk::ImageLayout::ColorAttachment, mResolveImage);
     }
     retainImageViews(contextVk);
 
     mContentDefined = true;
-
-    return angle::Result::Continue;
 }
 
-angle::Result RenderTargetVk::onDepthStencilDraw(ContextVk *contextVk)
+void RenderTargetVk::onDepthStencilDraw(ContextVk *contextVk)
 {
     ASSERT(mImage->getFormat().actualImageFormat().hasDepthOrStencilBits());
 
     const angle::Format &format    = mImage->getFormat().actualImageFormat();
     VkImageAspectFlags aspectFlags = vk::GetDepthStencilAspectFlags(format);
 
-    contextVk->onRenderPassImageWrite(aspectFlags, vk::ImageLayout::DepthStencilAttachment, mImage);
+    contextVk->onImageRenderPassWrite(aspectFlags, vk::ImageLayout::DepthStencilAttachment, mImage);
     if (mResolveImage)
     {
-        contextVk->onRenderPassImageWrite(aspectFlags, vk::ImageLayout::DepthStencilAttachment,
+        contextVk->onImageRenderPassWrite(aspectFlags, vk::ImageLayout::DepthStencilAttachment,
                                           mResolveImage);
     }
     retainImageViews(contextVk);
 
     mContentDefined = true;
-
-    return angle::Result::Continue;
 }
 
 vk::ImageHelper &RenderTargetVk::getImageForRenderPass()

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -55,8 +55,8 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
     vk::ImageViewSubresourceSerial getResolveSubresourceSerial() const;
 
     // Note: RenderTargets should be called in order, with the depth/stencil onRender last.
-    angle::Result onColorDraw(ContextVk *contextVk);
-    angle::Result onDepthStencilDraw(ContextVk *contextVk);
+    void onColorDraw(ContextVk *contextVk);
+    void onDepthStencilDraw(ContextVk *contextVk);
 
     vk::ImageHelper &getImageForRenderPass();
     const vk::ImageHelper &getImageForRenderPass() const;

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -1170,10 +1170,8 @@ angle::Result WindowSurfaceVk::present(ContextVk *contextVk,
     if (mColorImageMS.valid())
     {
         // Transition the multisampled image to TRANSFER_SRC for resolve.
-        ANGLE_TRY(contextVk->onImageRead(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferSrc,
-                                         &mColorImageMS));
-        ANGLE_TRY(contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferDst,
-                                          &image.image));
+        ANGLE_TRY(contextVk->onImageTransferRead(VK_IMAGE_ASPECT_COLOR_BIT, &mColorImageMS));
+        ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT, &image.image));
         ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
         VkImageResolve resolveRegion                = {};

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -757,8 +757,7 @@ angle::Result TextureVk::copySubImageImplWithTransfer(ContextVk *contextVk,
     gl::Extents extents  = {sourceBox.width, sourceBox.height, sourceBox.depth};
 
     // Change source layout if necessary
-    ANGLE_TRY(
-        contextVk->onImageRead(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferSrc, srcImage));
+    ANGLE_TRY(contextVk->onImageTransferRead(VK_IMAGE_ASPECT_COLOR_BIT, srcImage));
 
     VkImageSubresourceLayers srcSubresource = {};
     srcSubresource.aspectMask               = VK_IMAGE_ASPECT_COLOR_BIT;
@@ -797,8 +796,7 @@ angle::Result TextureVk::copySubImageImplWithTransfer(ContextVk *contextVk,
         ANGLE_TRY(ensureImageInitialized(contextVk, ImageMipLevels::EnabledLevels));
 
         vk::CommandBuffer *commandBuffer;
-        ANGLE_TRY(contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferDst,
-                                          mImage));
+        ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT, mImage));
         ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
         VkImageSubresourceLayers destSubresource = srcSubresource;
@@ -832,8 +830,7 @@ angle::Result TextureVk::copySubImageImplWithTransfer(ContextVk *contextVk,
                                               destFormat, kTransferStagingImageFlags, layerCount));
 
         vk::CommandBuffer *commandBuffer;
-        ANGLE_TRY(contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferDst,
-                                          stagingImage.get()));
+        ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT, stagingImage.get()));
         ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
         VkImageSubresourceLayers destSubresource = srcSubresource;
@@ -1405,8 +1402,7 @@ angle::Result TextureVk::copyBufferDataToImage(ContextVk *contextVk,
 
     vk::CommandBuffer *commandBuffer = nullptr;
     ANGLE_TRY(contextVk->onBufferTransferRead(srcBuffer));
-    ANGLE_TRY(
-        contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferDst, mImage));
+    ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT, mImage));
     ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
     VkBufferImageCopy region               = {};
@@ -1477,8 +1473,7 @@ angle::Result TextureVk::generateMipmapsWithCompute(ContextVk *contextVk)
     for (uint32_t destBaseLevel = 1; destBaseLevel < mImage->getLevelCount();
          destBaseLevel += maxGenerateLevels)
     {
-        ANGLE_TRY(contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT,
-                                          vk::ImageLayout::ComputeShaderWrite, mImage));
+        ANGLE_TRY(contextVk->onImageComputeShaderWrite(VK_IMAGE_ASPECT_COLOR_BIT, mImage));
 
         // Generate mipmaps for every layer separately.
         for (uint32_t layer = 0; layer < mImage->getLayerCount(); ++layer)

src/libANGLE/renderer/vulkan/UtilsVk.cpp

@@ -1401,12 +1401,10 @@ angle::Result UtilsVk::blitResolveImpl(ContextVk *contextVk,
 
     pipelineDesc.setScissor(gl_vk::GetRect(params.blitArea));
 
-    // Change source layout outside render pass
-    ANGLE_TRY(contextVk->onImageRead(src->getAspectFlags(), vk::ImageLayout::FragmentShaderReadOnly,
-                                     src));
-
     vk::CommandBuffer *commandBuffer;
     ANGLE_TRY(framebuffer->startNewRenderPass(contextVk, params.blitArea, &commandBuffer));
+    contextVk->onImageRenderPassRead(src->getAspectFlags(), vk::ImageLayout::FragmentShaderReadOnly,
+                                     src);
 
     VkDescriptorImageInfo imageInfos[2] = {};
 
@@ -1589,10 +1587,9 @@ angle::Result UtilsVk::stencilBlitResolveNoShaderExport(ContextVk *contextVk,
 
     vk::CommandBuffer *commandBuffer;
     // Change source layout prior to computation.
+    ANGLE_TRY(contextVk->onImageComputeShaderRead(src->getAspectFlags(), src));
     ANGLE_TRY(
-        contextVk->onImageRead(src->getAspectFlags(), vk::ImageLayout::ComputeShaderReadOnly, src));
-    ANGLE_TRY(contextVk->onImageWrite(depthStencilImage->getAspectFlags(),
-                                      vk::ImageLayout::TransferDst, depthStencilImage));
+        contextVk->onImageTransferWrite(depthStencilImage->getAspectFlags(), depthStencilImage));
     ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
     // Blit/resolve stencil into the buffer.
@@ -1819,16 +1816,16 @@ angle::Result UtilsVk::copyImage(ContextVk *contextVk,
     VkRect2D scissor = gl_vk::GetRect(renderArea);
     pipelineDesc.setScissor(scissor);
 
-    // Change source layout outside render pass
-    ANGLE_TRY(contextVk->onImageRead(VK_IMAGE_ASPECT_COLOR_BIT,
-                                     vk::ImageLayout::FragmentShaderReadOnly, src));
-    ANGLE_TRY(
-        contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::ColorAttachment, dest));
-
     vk::CommandBuffer *commandBuffer;
     ANGLE_TRY(
         startRenderPass(contextVk, dest, destView, renderPassDesc, renderArea, &commandBuffer));
 
+    // Change source layout inside render pass.
+    contextVk->onImageRenderPassRead(VK_IMAGE_ASPECT_COLOR_BIT,
+                                     vk::ImageLayout::FragmentShaderReadOnly, src);
+    contextVk->onImageRenderPassWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::ColorAttachment,
+                                      dest);
+
     VkDescriptorImageInfo imageInfo = {};
     imageInfo.imageView             = srcView->getHandle();
     imageInfo.imageLayout           = src->getCurrentLayout();
@@ -1971,8 +1968,7 @@ angle::Result UtilsVk::cullOverlayWidgets(ContextVk *contextVk,
 
     vk::CommandBuffer *commandBuffer;
     ANGLE_TRY(contextVk->onBufferComputeShaderRead(enabledWidgetsBuffer));
-    ANGLE_TRY(contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT,
-                                      vk::ImageLayout::ComputeShaderWrite, dest));
+    ANGLE_TRY(contextVk->onImageComputeShaderWrite(VK_IMAGE_ASPECT_COLOR_BIT, dest));
     ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
     VkDescriptorImageInfo imageInfo = {};
@@ -2041,12 +2037,9 @@ angle::Result UtilsVk::drawOverlay(ContextVk *contextVk,
                                     &descriptorSet));
 
     vk::CommandBuffer *commandBuffer;
-    ANGLE_TRY(contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT,
-                                      vk::ImageLayout::ComputeShaderWrite, dest));
-    ANGLE_TRY(contextVk->onImageRead(VK_IMAGE_ASPECT_COLOR_BIT,
-                                     vk::ImageLayout::ComputeShaderReadOnly, culledWidgets));
-    ANGLE_TRY(contextVk->onImageRead(VK_IMAGE_ASPECT_COLOR_BIT,
-                                     vk::ImageLayout::ComputeShaderReadOnly, font));
+    ANGLE_TRY(contextVk->onImageComputeShaderWrite(VK_IMAGE_ASPECT_COLOR_BIT, dest));
+    ANGLE_TRY(contextVk->onImageComputeShaderRead(VK_IMAGE_ASPECT_COLOR_BIT, culledWidgets));
+    ANGLE_TRY(contextVk->onImageComputeShaderRead(VK_IMAGE_ASPECT_COLOR_BIT, font));
     ANGLE_TRY(contextVk->onBufferComputeShaderRead(textWidgetsBuffer));
     ANGLE_TRY(contextVk->onBufferComputeShaderRead(graphWidgetsBuffer));
 

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -3400,7 +3400,7 @@ void ImageHelper::Copy(ImageHelper *srcImage,
 angle::Result ImageHelper::generateMipmapsWithBlit(ContextVk *contextVk, GLuint maxLevel)
 {
     CommandBuffer *commandBuffer = nullptr;
-    ANGLE_TRY(contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT, ImageLayout::TransferDst, this));
+    ANGLE_TRY(contextVk->onImageTransferWrite(VK_IMAGE_ASPECT_COLOR_BIT, this));
     ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
     // We are able to use blitImage since the image format we are using supports it.
@@ -4244,7 +4244,7 @@ angle::Result ImageHelper::flushStagedUpdates(ContextVk *contextVk,
     uint64_t subresourceUploadsInProgress            = 0;
 
     // Start in TransferDst.
-    ANGLE_TRY(contextVk->onImageWrite(aspectFlags, ImageLayout::TransferDst, this));
+    ANGLE_TRY(contextVk->onImageTransferWrite(aspectFlags, this));
 
     for (SubresourceUpdate &update : mSubresourceUpdates)
     {
@@ -4342,8 +4342,7 @@ angle::Result ImageHelper::flushStagedUpdates(ContextVk *contextVk,
         }
         else
         {
-            ANGLE_TRY(
-                contextVk->onImageRead(aspectFlags, ImageLayout::TransferSrc, update.image.image));
+            ANGLE_TRY(contextVk->onImageTransferRead(aspectFlags, update.image.image));
 
             commandBuffer->copyImage(update.image.image->getImage(),
                                      update.image.image->getCurrentLayout(), mImage,
@@ -4545,7 +4544,7 @@ angle::Result ImageHelper::copyImageDataToBuffer(ContextVk *contextVk,
                                     nullptr));
 
     CommandBuffer *commandBuffer = nullptr;
-    ANGLE_TRY(contextVk->onImageRead(aspectFlags, ImageLayout::TransferSrc, this));
+    ANGLE_TRY(contextVk->onImageTransferRead(aspectFlags, this));
     ANGLE_TRY(contextVk->onBufferTransferWrite(*bufferOut));
     ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
@@ -4749,10 +4748,9 @@ angle::Result ImageHelper::readPixels(ContextVk *contextVk,
     CommandBuffer *commandBuffer;
     if (isMultisampled)
     {
-        ANGLE_TRY(contextVk->onImageWrite(layoutChangeAspectFlags, ImageLayout::TransferDst,
-                                          &resolvedImage.get()));
+        ANGLE_TRY(contextVk->onImageTransferWrite(layoutChangeAspectFlags, &resolvedImage.get()));
     }
-    ANGLE_TRY(contextVk->onImageRead(layoutChangeAspectFlags, ImageLayout::TransferSrc, this));
+    ANGLE_TRY(contextVk->onImageTransferRead(layoutChangeAspectFlags, this));
     ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
 
     const angle::Format *readFormat = &mFormat->actualImageFormat();
@@ -4800,8 +4798,7 @@ angle::Result ImageHelper::readPixels(ContextVk *contextVk,
 
         resolve(&resolvedImage.get(), resolveRegion, commandBuffer);
 
-        ANGLE_TRY(contextVk->onImageRead(layoutChangeAspectFlags, ImageLayout::TransferSrc,
-                                         &resolvedImage.get()));
+        ANGLE_TRY(contextVk->onImageTransferRead(layoutChangeAspectFlags, &resolvedImage.get()));
 
         // Make the resolved image the target of buffer copy.
         src                           = &resolvedImage.get();