Vulkan: Move image clear functionality to UtilsVk

src/libANGLE/renderer/vulkan/CommandGraph.h

@@ -206,7 +206,7 @@ class RecordableGraphResource : public CommandGraphResource
     angle::Result recordCommands(Context *context, CommandBuffer **commandBufferOut);
 
     // Begins a command buffer on the current graph node for in-RenderPass rendering.
-    // Currently only called from FramebufferVk::getCommandBufferForDraw.
+    // Currently only called from FramebufferVk::startNewRenderPass.
     angle::Result beginRenderPass(Context *context,
                                   const Framebuffer &framebuffer,
                                   const gl::Rectangle &renderArea,

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -287,8 +287,8 @@ angle::Result FramebufferVk::clear(const gl::Context *context, GLbitfield mask)
         VkClearColorValue modifiedClearColorValue = clearColorValue;
         RenderTargetVk *colorRenderTarget         = colorRenderTargets[colorIndex];
 
-        // Its possible we're clearing a render target that has no alpha channel but we represent it
-        // with a texture that has one. We must not affect its alpha channel no matter what the
+        // It's possible we're clearing a render target that has no alpha channel but we represent
+        // it with a texture that has one. We must not affect its alpha channel no matter what the
         // clear value is in that case.
         if (mEmulatedAlphaAttachmentMask[colorIndex])
         {
@@ -1002,78 +1002,26 @@ angle::Result FramebufferVk::clearWithDraw(ContextVk *contextVk,
 {
     RendererVk *renderer = contextVk->getRenderer();
 
-    vk::ShaderProgramHelper *fullScreenClear = nullptr;
-    ANGLE_TRY(renderer->getFullScreenClearShaderProgram(contextVk, &fullScreenClear));
-
-    // Trigger a new command node to ensure overlapping writes happen sequentially.
-    mFramebuffer.finishCurrentCommands(renderer);
-
-    // The shader uses a simple pipeline layout with a push constant range.
-    vk::PipelineLayoutDesc pipelineLayoutDesc;
-    pipelineLayoutDesc.updatePushConstantRange(gl::ShaderType::Fragment, 0,
-                                               sizeof(VkClearColorValue));
-
-    // The shader does not use any descriptor sets.
-    vk::DescriptorSetLayoutPointerArray descriptorSetLayouts;
-
-    vk::BindingPointer<vk::PipelineLayout> pipelineLayout;
-    ANGLE_TRY(renderer->getPipelineLayout(contextVk, pipelineLayoutDesc, descriptorSetLayouts,
-                                          &pipelineLayout));
-
-    vk::RecordingMode recordingMode = vk::RecordingMode::Start;
-    vk::CommandBuffer *drawCommands = nullptr;
-    ANGLE_TRY(getCommandBufferForDraw(contextVk, &drawCommands, &recordingMode));
-
-    const gl::Rectangle &renderArea = mFramebuffer.getRenderPassRenderArea();
-    bool invertViewport             = contextVk->isViewportFlipEnabledForDrawFBO();
-
-    // This pipeline desc could be cached.
-    vk::GraphicsPipelineDesc pipelineDesc;
-    pipelineDesc.initDefaults();
-    pipelineDesc.updateColorWriteMask(colorMaskFlags, getEmulatedAlphaAttachmentMask());
-    pipelineDesc.updateRenderPassDesc(getRenderPassDesc());
-
-    vk::PipelineAndSerial *pipeline = nullptr;
-    ANGLE_TRY(fullScreenClear->getGraphicsPipeline(contextVk, pipelineLayout.get(), pipelineDesc,
-                                                   gl::AttributesMask(), &pipeline));
-    pipeline->updateSerial(renderer->getCurrentQueueSerial());
-
-    vk::CommandBuffer *writeCommands = nullptr;
-    ANGLE_TRY(mFramebuffer.recordCommands(contextVk, &writeCommands));
-
-    // If the format of the framebuffer does not have an alpha channel, we need to make sure we does
+    // If the format of the framebuffer does not have an alpha channel, we need to make sure we do
     // not affect the alpha channel of the type we're using to emulate the format.
     // TODO(jmadill): Implement EXT_draw_buffers http://anglebug.com/2394
     RenderTargetVk *renderTarget = mRenderTargetCache.getColors()[0];
     ASSERT(renderTarget);
 
-    const vk::Format &imageFormat     = renderTarget->getImageFormat();
-    VkClearColorValue clearColorValue = contextVk->getClearColorValue().color;
+    UtilsVk::ClearImageParameters params = {};
+    params.colorMaskFlags                = colorMaskFlags;
+    params.alphaMask                     = &getEmulatedAlphaAttachmentMask();
+    params.renderPassDesc                = &getRenderPassDesc();
+
+    const vk::Format &imageFormat = renderTarget->getImageFormat();
+    params.clearValue             = contextVk->getClearColorValue().color;
     bool overrideAlphaWithOne =
         imageFormat.textureFormat().alphaBits > 0 && imageFormat.angleFormat().alphaBits == 0;
-    clearColorValue.float32[3] = overrideAlphaWithOne ? 1.0f : clearColorValue.float32[3];
-
-    drawCommands->pushConstants(pipelineLayout.get(), VK_SHADER_STAGE_FRAGMENT_BIT, 0,
-                                sizeof(VkClearColorValue), clearColorValue.float32);
+    params.clearValue.float32[3] = overrideAlphaWithOne ? 1.0f : params.clearValue.float32[3];
 
-    // TODO(jmadill): Masked combined color and depth/stencil clear. http://anglebug.com/2455
-    // Any active queries submitted by the user should also be paused here.
-    drawCommands->bindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->get());
+    params.renderAreaHeight = mState.getDimensions().height;
 
-    GLint renderAreaHeight = mState.getDimensions().height;
-
-    VkViewport viewport;
-    gl_vk::GetViewport(renderArea, 0.0f, 1.0f, invertViewport, renderAreaHeight, &viewport);
-    drawCommands->setViewport(0, 1, &viewport);
-
-    VkRect2D scissor;
-    const gl::State &glState = contextVk->getGLState();
-    gl_vk::GetScissor(glState, invertViewport, renderArea, &scissor);
-    drawCommands->setScissor(0, 1, &scissor);
-
-    drawCommands->draw(6, 1, 0, 0);
-
-    return angle::Result::Continue;
+    return renderer->getUtils().clearImage(contextVk, this, params);
 }
 
 angle::Result FramebufferVk::getSamplePosition(const gl::Context *context,
@@ -1149,7 +1097,7 @@ void FramebufferVk::updateActiveColorMasks(size_t colorIndex, bool r, bool g, bo
     mActiveColorComponentMasksForClear[3].set(colorIndex, a);
 }
 
-gl::DrawBufferMask FramebufferVk::getEmulatedAlphaAttachmentMask()
+const gl::DrawBufferMask &FramebufferVk::getEmulatedAlphaAttachmentMask() const
 {
     return mEmulatedAlphaAttachmentMask;
 }

src/libANGLE/renderer/vulkan/FramebufferVk.h

@@ -103,7 +103,7 @@ class FramebufferVk : public FramebufferImpl
 
     const gl::Extents &getReadImageExtents() const;
 
-    gl::DrawBufferMask getEmulatedAlphaAttachmentMask();
+    const gl::DrawBufferMask &getEmulatedAlphaAttachmentMask() const;
     RenderTargetVk *getColorReadRenderTarget() const;
 
     // This will clear the current write operation if it is complete.

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -344,13 +344,11 @@ void RendererVk::onDestroy(vk::Context *context)
         (void)finish(context);
     }
 
-    mDispatchUtils.destroy(mDevice);
+    mUtils.destroy(mDevice);
 
     mPipelineLayoutCache.destroy(mDevice);
     mDescriptorSetLayoutCache.destroy(mDevice);
 
-    mFullScreenClearShaderProgram.destroy(mDevice);
-
     mRenderPassCache.destroy(mDevice);
     mPipelineCache.destroy(mDevice);
     mSubmitSemaphorePool.destroy(mDevice);
@@ -1319,25 +1317,6 @@ const vk::Semaphore *RendererVk::getSubmitLastSignaledSemaphore(vk::Context *con
     return semaphore;
 }
 
-angle::Result RendererVk::getFullScreenClearShaderProgram(vk::Context *context,
-                                                          vk::ShaderProgramHelper **programOut)
-{
-    if (!mFullScreenClearShaderProgram.valid())
-    {
-        vk::RefCounted<vk::ShaderAndSerial> *fullScreenQuad = nullptr;
-        ANGLE_TRY(mShaderLibrary.getFullScreenQuad_vert(context, 0, &fullScreenQuad));
-
-        vk::RefCounted<vk::ShaderAndSerial> *pushConstantColor = nullptr;
-        ANGLE_TRY(mShaderLibrary.getPushConstantColor_frag(context, 0, &pushConstantColor));
-
-        mFullScreenClearShaderProgram.setShader(gl::ShaderType::Vertex, fullScreenQuad);
-        mFullScreenClearShaderProgram.setShader(gl::ShaderType::Fragment, pushConstantColor);
-    }
-
-    *programOut = &mFullScreenClearShaderProgram;
-    return angle::Result::Continue;
-}
-
 angle::Result RendererVk::getTimestamp(vk::Context *context, uint64_t *timestampOut)
 {
     // The intent of this function is to query the timestamp without stalling the GPU.  Currently,

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -17,8 +17,8 @@
 #include "libANGLE/BlobCache.h"
 #include "libANGLE/Caps.h"
 #include "libANGLE/renderer/vulkan/CommandGraph.h"
-#include "libANGLE/renderer/vulkan/DispatchUtilsVk.h"
 #include "libANGLE/renderer/vulkan/QueryVk.h"
+#include "libANGLE/renderer/vulkan/UtilsVk.h"
 #include "libANGLE/renderer/vulkan/vk_format_utils.h"
 #include "libANGLE/renderer/vulkan/vk_helpers.h"
 #include "libANGLE/renderer/vulkan/vk_internal_shaders_autogen.h"
@@ -162,9 +162,7 @@ class RendererVk : angle::NonCopyable
     Serial issueShaderSerial();
 
     vk::ShaderLibrary &getShaderLibrary() { return mShaderLibrary; }
-    angle::Result getFullScreenClearShaderProgram(vk::Context *context,
-                                                  vk::ShaderProgramHelper **programOut);
-    DispatchUtilsVk &getDispatchUtils() { return mDispatchUtils; }
+    UtilsVk &getUtils() { return mUtils; }
     const angle::FeaturesVk &getFeatures() const
     {
         ASSERT(mFeaturesInitialized);
@@ -320,8 +318,7 @@ class RendererVk : angle::NonCopyable
 
     // Internal shader library.
     vk::ShaderLibrary mShaderLibrary;
-    vk::ShaderProgramHelper mFullScreenClearShaderProgram;
-    DispatchUtilsVk mDispatchUtils;
+    UtilsVk mUtils;
 
     // The GpuEventQuery struct holds together a timestamp query and enough data to create a
     // trace event based on that. Use traceGpuEvent to insert such queries.  They will be readback

src/libANGLE/renderer/vulkan/DispatchUtilsVk.h → src/libANGLE/renderer/vulkan/UtilsVk.h

@@ -3,9 +3,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
-// DispatchUtilsVk.h:
-//    Defines the DispatchUtilsVk class, a helper for various internal dispatch utilities such as
-//    buffer clear and copy, texture mip map generation, etc.
+// UtilsVk.h:
+//    Defines the UtilsVk class, a helper for various internal draw/dispatch utilities such as
+//    buffer clear and copy, image clear and copy, texture mip map generation, etc.
 //
 //    - Buffer clear: Implemented, but no current users
 //    - Buffer copy:
@@ -13,11 +13,13 @@
 //    - Convert vertex attribute:
 //      * Used by VertexArrayVk::convertVertexBuffer() to convert vertex attributes from unsupported
 //        formats to their fallbacks.
+//    - Image clear: Used by FramebufferVk::clearWithDraw().
+//    - Image copy: Not yet implemented
 //    - Mipmap generation: Not yet implemented
 //
 
-#ifndef LIBANGLE_RENDERER_VULKAN_DISPATCHUTILSVK_H_
-#define LIBANGLE_RENDERER_VULKAN_DISPATCHUTILSVK_H_
+#ifndef LIBANGLE_RENDERER_VULKAN_UTILSVK_H_
+#define LIBANGLE_RENDERER_VULKAN_UTILSVK_H_
 
 #include "libANGLE/renderer/vulkan/vk_cache_utils.h"
 #include "libANGLE/renderer/vulkan/vk_helpers.h"
@@ -25,11 +27,11 @@
 
 namespace rx
 {
-class DispatchUtilsVk : angle::NonCopyable
+class UtilsVk : angle::NonCopyable
 {
   public:
-    DispatchUtilsVk();
-    ~DispatchUtilsVk();
+    UtilsVk();
+    ~UtilsVk();
 
     void destroy(VkDevice device);
 
@@ -57,6 +59,15 @@ class DispatchUtilsVk : angle::NonCopyable
         size_t destOffset;
     };
 
+    struct ClearImageParameters
+    {
+        VkClearColorValue clearValue;
+        VkColorComponentFlags colorMaskFlags;
+        GLint renderAreaHeight;
+        const gl::DrawBufferMask *alphaMask;
+        const vk::RenderPassDesc *renderPassDesc;
+    };
+
     angle::Result clearBuffer(vk::Context *context,
                               vk::BufferHelper *dest,
                               const ClearParameters &params);
@@ -69,6 +80,13 @@ class DispatchUtilsVk : angle::NonCopyable
                                       vk::BufferHelper *src,
                                       const ConvertVertexParameters &params);
 
+    // Note: this function takes a FramebufferVk instead of ImageHelper, as that's the only user,
+    // which avoids recreating a framebuffer.  An overload taking ImageHelper can be added when
+    // necessary.
+    angle::Result clearImage(ContextVk *contextVk,
+                             FramebufferVk *framebuffer,
+                             const ClearImageParameters &params);
+
   private:
     struct BufferUtilsShaderParams
     {
@@ -97,39 +115,42 @@ class DispatchUtilsVk : angle::NonCopyable
         uint32_t Ed             = 0;
     };
 
+    struct ImageClearShaderParams
+    {
+        // Structure matching PushConstants in ImageClear.frag
+        VkClearColorValue clearValue = {};
+    };
+
     // Functions implemented by the class:
     enum class Function
     {
-        BufferClear         = 0,
-        BufferCopy          = 1,
-        ConvertVertexBuffer = 2,
+        // Functions implemented in graphics
+        ImageClear = 0,
+
+        // Functions implemented in compute
+        ComputeStartIndex   = 1,  // Special value to separate draw and dispatch functions.
+        BufferClear         = 1,
+        BufferCopy          = 2,
+        ConvertVertexBuffer = 3,
 
-        InvalidEnum = 3,
-        EnumCount   = 3,
+        InvalidEnum = 4,
+        EnumCount   = 4,
     };
 
     // Common function that creates the pipeline for the specified function, binds it and prepares
-    // the dispatch call. The possible values of `flags` comes from
-    // vk::InternalShader::* defined in vk_internal_shaders_autogen.h
-    angle::Result setupProgramCommon(vk::Context *context,
-                                     Function function,
-                                     vk::RefCounted<vk::ShaderAndSerial> *shader,
-                                     vk::ShaderProgramHelper *program,
-                                     const VkDescriptorSet descriptorSet,
-                                     const void *pushConstants,
-                                     size_t pushConstantsSize,
-                                     vk::CommandBuffer *commandBuffer);
-
-    using GetShader = angle::Result (vk::ShaderLibrary::*)(vk::Context *,
-                                                           uint32_t,
-                                                           vk::RefCounted<vk::ShaderAndSerial> **);
-
-    template <GetShader getShader, Function function, typename ShaderParams>
+    // the draw/dispatch call.  If function >= ComputeStartIndex, fsCsShader is expected to be a
+    // compute shader, vsShader and pipelineDesc should be nullptr, and this will set up a dispatch
+    // call. Otherwise fsCsShader is expected to be a fragment shader and this will set up a draw
+    // call.
     angle::Result setupProgram(vk::Context *context,
+                               Function function,
+                               vk::RefCounted<vk::ShaderAndSerial> *fsCsShader,
+                               vk::RefCounted<vk::ShaderAndSerial> *vsShader,
                                vk::ShaderProgramHelper *program,
-                               uint32_t flags,
-                               const VkDescriptorSet &descriptorSet,
-                               const ShaderParams &params,
+                               const vk::GraphicsPipelineDesc *pipelineDesc,
+                               const VkDescriptorSet descriptorSet,
+                               const void *pushConstants,
+                               size_t pushConstantsSize,
                                vk::CommandBuffer *commandBuffer);
 
     // Initializes descriptor set layout, pipeline layout and descriptor pool corresponding to given
@@ -145,9 +166,10 @@ class DispatchUtilsVk : angle::NonCopyable
 
     // Initializers corresponding to functions, calling into ensureResourcesInitialized with the
     // appropriate parameters.
-    angle::Result ensureBufferClearInitialized(vk::Context *context);
-    angle::Result ensureBufferCopyInitialized(vk::Context *context);
-    angle::Result ensureConvertVertexInitialized(vk::Context *context);
+    angle::Result ensureBufferClearResourcesInitialized(vk::Context *context);
+    angle::Result ensureBufferCopyResourcesInitialized(vk::Context *context);
+    angle::Result ensureConvertVertexResourcesInitialized(vk::Context *context);
+    angle::Result ensureImageClearResourcesInitialized(vk::Context *context);
 
     angle::PackedEnumMap<Function, vk::DescriptorSetLayoutPointerArray> mDescriptorSetLayouts;
     angle::PackedEnumMap<Function, vk::BindingPointer<vk::PipelineLayout>> mPipelineLayouts;
@@ -160,8 +182,9 @@ class DispatchUtilsVk : angle::NonCopyable
     vk::ShaderProgramHelper
         mConvertVertexPrograms[vk::InternalShader::ConvertVertex_comp::kFlagsMask |
                                vk::InternalShader::ConvertVertex_comp::kConversionMask];
+    vk::ShaderProgramHelper mImageClearProgram;
 };
 
 }  // namespace rx
 
-#endif  // LIBANGLE_RENDERER_VULKAN_DISPATCHUTILSVK_H_
+#endif  // LIBANGLE_RENDERER_VULKAN_UTILSVK_H_

src/libANGLE/renderer/vulkan/VertexArrayVk.cpp

@@ -222,7 +222,7 @@ angle::Result VertexArrayVk::convertVertexBufferGpu(ContextVk *contextVk,
     mCurrentArrayBuffers[attribIndex] =
         mCurrentArrayBufferConversion[attribIndex].getCurrentBuffer();
 
-    DispatchUtilsVk::ConvertVertexParameters params;
+    UtilsVk::ConvertVertexParameters params;
     params.vertexCount = numVertices;
     params.srcFormat   = &srcFormat;
     params.destFormat  = &destFormat;
@@ -230,8 +230,8 @@ angle::Result VertexArrayVk::convertVertexBufferGpu(ContextVk *contextVk,
     params.srcOffset   = binding.getOffset();
     params.destOffset  = static_cast<size_t>(mCurrentArrayBufferOffsets[attribIndex]);
 
-    ANGLE_TRY(renderer->getDispatchUtils().convertVertexBuffer(
-        contextVk, mCurrentArrayBuffers[attribIndex], &srcBuffer->getBuffer(), params));
+    ANGLE_TRY(renderer->getUtils().convertVertexBuffer(contextVk, mCurrentArrayBuffers[attribIndex],
+                                                       &srcBuffer->getBuffer(), params));
 
     mCurrentArrayBufferHandles[attribIndex] =
         mCurrentArrayBuffers[attribIndex]->getBuffer().getHandle();
@@ -670,7 +670,7 @@ angle::Result VertexArrayVk::updateIndexTranslation(ContextVk *contextVk,
         // Copy relevant section of the source into destination at allocated offset.  Note that the
         // offset returned by allocate() above is in bytes, while our allocated array is of
         // GLushorts.
-        DispatchUtilsVk::CopyParameters params = {};
+        UtilsVk::CopyParameters params = {};
         params.destOffset =
             static_cast<size_t>(mCurrentElementArrayBufferOffset) / sizeof(GLushort);
         params.srcOffset = offsetIntoSrcData;
@@ -679,7 +679,7 @@ angle::Result VertexArrayVk::updateIndexTranslation(ContextVk *contextVk,
         // Note: this is a copy, which implicitly converts between formats.  Once support for
         // primitive restart is added, a specialized shader is likely needed to special case 0xFF ->
         // 0xFFFF.
-        ANGLE_TRY(renderer->getDispatchUtils().copyBuffer(contextVk, dest, src, params));
+        ANGLE_TRY(renderer->getUtils().copyBuffer(contextVk, dest, src, params));
     }
     else
     {

src/libANGLE/renderer/vulkan/shaders/gen/ImageClear.frag.00000000.inc

+	// 7.11.3009
+	 #pragma once
+const uint32_t kImageClear_frag_00000000[] = {
+	0x07230203,0x00010000,0x00080007,0x00000012,0x00000000,0x00020011,0x00000001,0x0006000b,
+	0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
+	0x0006000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x00000009,0x00030010,0x00000004,
+	0x00000007,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,0x00000000,
+	0x00050005,0x00000009,0x6f6c6f63,0x74754f72,0x00000000,0x00060005,0x0000000a,0x68737550,
+	0x736e6f43,0x746e6174,0x00000073,0x00060006,0x0000000a,0x00000000,0x61656c63,0x6c6f4372,
+	0x0000726f,0x00040005,0x0000000c,0x61726170,0x0000736d,0x00040047,0x00000009,0x0000001e,
+	0x00000000,0x00050048,0x0000000a,0x00000000,0x00000023,0x00000000,0x00030047,0x0000000a,
+	0x00000002,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,
+	0x00000020,0x00040017,0x00000007,0x00000006,0x00000004,0x00040020,0x00000008,0x00000003,
+	0x00000007,0x0004003b,0x00000008,0x00000009,0x00000003,0x0003001e,0x0000000a,0x00000007,
+	0x00040020,0x0000000b,0x00000009,0x0000000a,0x0004003b,0x0000000b,0x0000000c,0x00000009,
+	0x00040015,0x0000000d,0x00000020,0x00000001,0x0004002b,0x0000000d,0x0000000e,0x00000000,
+	0x00040020,0x0000000f,0x00000009,0x00000007,0x00050036,0x00000002,0x00000004,0x00000000,
+	0x00000003,0x000200f8,0x00000005,0x00050041,0x0000000f,0x00000010,0x0000000c,0x0000000e,
+	0x0004003d,0x00000007,0x00000011,0x00000010,0x0003003e,0x00000009,0x00000011,0x000100fd,
+	0x00010038
+};
+
+#if 0  // Generated from:
+#version 450 core
+
+layout(push_constant)uniform PushConstants {
+    vec4 clearColor;
+} params;
+
+layout(location = 0)out vec4 colorOut;
+
+void main()
+{
+    colorOut = params . clearColor;
+}
+#endif  // Preprocessed code

src/libANGLE/renderer/vulkan/shaders/gen/PushConstantColor.frag.00000000.inc

-	// 7.11.3009
-	 #pragma once
-const uint32_t kPushConstantColor_frag_00000000[] = {
-	0x07230203,0x00010000,0x00080007,0x00000012,0x00000000,0x00020011,0x00000001,0x0006000b,
-	0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
-	0x0006000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x00000009,0x00030010,0x00000004,
-	0x00000007,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,0x00000000,
-	0x00050005,0x00000009,0x6f6c6f63,0x74754f72,0x00000000,0x00040005,0x0000000a,0x636f6c62,
-	0x0000006b,0x00050006,0x0000000a,0x00000000,0x6f6c6f63,0x006e4972,0x00030005,0x0000000c,
-	0x00000000,0x00040047,0x00000009,0x0000001e,0x00000000,0x00050048,0x0000000a,0x00000000,
-	0x00000023,0x00000000,0x00030047,0x0000000a,0x00000002,0x00020013,0x00000002,0x00030021,
-	0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,
-	0x00000004,0x00040020,0x00000008,0x00000003,0x00000007,0x0004003b,0x00000008,0x00000009,
-	0x00000003,0x0003001e,0x0000000a,0x00000007,0x00040020,0x0000000b,0x00000009,0x0000000a,
-	0x0004003b,0x0000000b,0x0000000c,0x00000009,0x00040015,0x0000000d,0x00000020,0x00000001,
-	0x0004002b,0x0000000d,0x0000000e,0x00000000,0x00040020,0x0000000f,0x00000009,0x00000007,
-	0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x00050041,
-	0x0000000f,0x00000010,0x0000000c,0x0000000e,0x0004003d,0x00000007,0x00000011,0x00000010,
-	0x0003003e,0x00000009,0x00000011,0x000100fd,0x00010038
-};
-
-#if 0  // Generated from:
-#version 450 core
-
-layout(push_constant)uniform block {
-    vec4 colorIn;
-};
-
-layout(location = 0)out vec4 colorOut;
-
-void main()
-{
-    colorOut = colorIn;
-}
-#endif  // Preprocessed code

src/libANGLE/renderer/vulkan/shaders/src/PushConstantColor.frag → src/libANGLE/renderer/vulkan/shaders/src/ImageClear.frag

@@ -3,17 +3,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
-// PushConstantColor.frag: Simple solid color fragment shader.
+// ImageClear.frag: Clear image to a solid color.
 
 #version 450 core
 
-layout(push_constant) uniform block {
-    vec4 colorIn;
-};
+layout(push_constant) uniform PushConstants {
+    vec4 clearColor;
+} params;
 
 layout(location = 0) out vec4 colorOut;
 
 void main()
 {
-    colorOut = colorIn;
+    colorOut = params.clearColor;
 }

src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.cpp

@@ -45,7 +45,7 @@ namespace
 #include "libANGLE/renderer/vulkan/shaders/gen/ConvertVertex.comp.0000000E.inc"
 #include "libANGLE/renderer/vulkan/shaders/gen/ConvertVertex.comp.0000000F.inc"
 #include "libANGLE/renderer/vulkan/shaders/gen/FullScreenQuad.vert.00000000.inc"
-#include "libANGLE/renderer/vulkan/shaders/gen/PushConstantColor.frag.00000000.inc"
+#include "libANGLE/renderer/vulkan/shaders/gen/ImageClear.frag.00000000.inc"
 
 // This is SPIR-V binary blob and the size.
 struct ShaderBlob
@@ -89,8 +89,8 @@ constexpr ShaderBlob kConvertVertex_comp_shaders[] = {
 constexpr ShaderBlob kFullScreenQuad_vert_shaders[] = {
     {kFullScreenQuad_vert_00000000, sizeof(kFullScreenQuad_vert_00000000)},
 };
-constexpr ShaderBlob kPushConstantColor_frag_shaders[] = {
-    {kPushConstantColor_frag_00000000, sizeof(kPushConstantColor_frag_00000000)},
+constexpr ShaderBlob kImageClear_frag_shaders[] = {
+    {kImageClear_frag_00000000, sizeof(kImageClear_frag_00000000)},
 };
 
 angle::Result GetShader(Context *context,
@@ -135,7 +135,7 @@ void ShaderLibrary::destroy(VkDevice device)
     {
         shader.get().destroy(device);
     }
-    for (RefCounted<ShaderAndSerial> &shader : mPushConstantColor_frag_shaders)
+    for (RefCounted<ShaderAndSerial> &shader : mImageClear_frag_shaders)
     {
         shader.get().destroy(device);
     }
@@ -165,12 +165,12 @@ angle::Result ShaderLibrary::getFullScreenQuad_vert(Context *context,
                      ArraySize(kFullScreenQuad_vert_shaders), shaderFlags, shaderOut);
 }
 
-angle::Result ShaderLibrary::getPushConstantColor_frag(Context *context,
-                                                       uint32_t shaderFlags,
-                                                       RefCounted<ShaderAndSerial> **shaderOut)
+angle::Result ShaderLibrary::getImageClear_frag(Context *context,
+                                                uint32_t shaderFlags,
+                                                RefCounted<ShaderAndSerial> **shaderOut)
 {
-    return GetShader(context, mPushConstantColor_frag_shaders, kPushConstantColor_frag_shaders,
-                     ArraySize(kPushConstantColor_frag_shaders), shaderFlags, shaderOut);
+    return GetShader(context, mImageClear_frag_shaders, kImageClear_frag_shaders,
+                     ArraySize(kImageClear_frag_shaders), shaderFlags, shaderOut);
 }
 
 }  // namespace vk

src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.gni

@@ -38,5 +38,5 @@ angle_vulkan_internal_shaders = [
   "shaders/gen/ConvertVertex.comp.0000000E.inc",
   "shaders/gen/ConvertVertex.comp.0000000F.inc",
   "shaders/gen/FullScreenQuad.vert.00000000.inc",
-  "shaders/gen/PushConstantColor.frag.00000000.inc",
+  "shaders/gen/ImageClear.frag.00000000.inc",
 ]

src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.h

@@ -65,8 +65,8 @@ enum Conversion
 namespace FullScreenQuad_vert
 {}  // namespace FullScreenQuad_vert
 
-namespace PushConstantColor_frag
-{}  // namespace PushConstantColor_frag
+namespace ImageClear_frag
+{}  // namespace ImageClear_frag
 
 }  // namespace InternalShader
 
@@ -87,9 +87,9 @@ class ShaderLibrary final : angle::NonCopyable
     angle::Result getFullScreenQuad_vert(Context *context,
                                          uint32_t shaderFlags,
                                          RefCounted<ShaderAndSerial> **shaderOut);
-    angle::Result getPushConstantColor_frag(Context *context,
-                                            uint32_t shaderFlags,
-                                            RefCounted<ShaderAndSerial> **shaderOut);
+    angle::Result getImageClear_frag(Context *context,
+                                     uint32_t shaderFlags,
+                                     RefCounted<ShaderAndSerial> **shaderOut);
 
   private:
     RefCounted<ShaderAndSerial>
@@ -100,7 +100,7 @@ class ShaderLibrary final : angle::NonCopyable
         mConvertVertex_comp_shaders[InternalShader::ConvertVertex_comp::kFlagsMask |
                                     InternalShader::ConvertVertex_comp::kConversionMask];
     RefCounted<ShaderAndSerial> mFullScreenQuad_vert_shaders[1];
-    RefCounted<ShaderAndSerial> mPushConstantColor_frag_shaders[1];
+    RefCounted<ShaderAndSerial> mImageClear_frag_shaders[1];
 };
 }  // namespace vk
 }  // namespace rx

src/libGLESv2.gni

@@ -724,8 +724,6 @@ libangle_vulkan_sources = [
   "src/libANGLE/renderer/vulkan/ContextVk.h",
   "src/libANGLE/renderer/vulkan/DeviceVk.cpp",
   "src/libANGLE/renderer/vulkan/DeviceVk.h",
-  "src/libANGLE/renderer/vulkan/DispatchUtilsVk.cpp",
-  "src/libANGLE/renderer/vulkan/DispatchUtilsVk.h",
   "src/libANGLE/renderer/vulkan/DisplayVk.cpp",
   "src/libANGLE/renderer/vulkan/DisplayVk.h",
   "src/libANGLE/renderer/vulkan/FenceNVVk.cpp",
@@ -760,6 +758,8 @@ libangle_vulkan_sources = [
   "src/libANGLE/renderer/vulkan/TextureVk.h",
   "src/libANGLE/renderer/vulkan/TransformFeedbackVk.cpp",
   "src/libANGLE/renderer/vulkan/TransformFeedbackVk.h",
+  "src/libANGLE/renderer/vulkan/UtilsVk.cpp",
+  "src/libANGLE/renderer/vulkan/UtilsVk.h",
   "src/libANGLE/renderer/vulkan/VertexArrayVk.cpp",
   "src/libANGLE/renderer/vulkan/VertexArrayVk.h",
   "src/libANGLE/renderer/vulkan/vk_cache_utils.cpp",