Vulkan: Shader path for texture-to-texture copy

include/platform/FeaturesVk.h

@@ -57,6 +57,11 @@ struct FeaturesVk
     // Whether the VkDevice supports the VK_KHR_incremental_present extension, on which the
     // EGL_KHR_swap_buffers_with_damage extension can be layered.
     bool supportsIncrementalPresent = false;
+
+    // Whether texture copies on cube map targets should be done on GPU.  This is a workaround for
+    // Intel drivers on windows that have an issue with creating single-layer views on cube map
+    // textures.
+    bool forceCpuPathForCubeMapCopy = false;
 };
 
 }  // namespace angle

scripts/run_code_generation_hashes.json

@@ -102,7 +102,7 @@
   "Vulkan internal shader programs:src/libANGLE/renderer/vulkan/shaders/src/ImageClear.frag":
     "98d490413d20118e92dd2b160c1dfc6e",
   "Vulkan internal shader programs:src/libANGLE/renderer/vulkan/shaders/src/ImageCopy.frag":
-    "096ccb0e3c25067ddd0347556a12d7d6",
+    "9b9fd690321f53163221f1ebba9f006d",
   "Vulkan mandatory format support table:src/libANGLE/renderer/angle_format.py":
     "b18ca0fe4835114a4a2f54977b19e798",
   "Vulkan mandatory format support table:src/libANGLE/renderer/vulkan/gen_vk_mandatory_format_support_table.py":

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -825,6 +825,9 @@ void RendererVk::initFeatures(const std::vector<VkExtensionProperties> &deviceEx
 #ifdef ANGLE_PLATFORM_WINDOWS
     // http://anglebug.com/2838
     mFeatures.extraCopyBufferRegion = IsIntel(mPhysicalDeviceProperties.vendorID);
+
+    // http://anglebug.com/3055
+    mFeatures.forceCpuPathForCubeMapCopy = IsIntel(mPhysicalDeviceProperties.vendorID);
 #endif
 
     angle::PlatformMethods *platform = ANGLEPlatformCurrent();

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -27,6 +27,16 @@ constexpr size_t kStagingBufferSize = 1024 * 16;
 
 constexpr VkFormatFeatureFlags kBlitFeatureFlags =
     VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
+
+bool CanCopyWithDraw(RendererVk *renderer,
+                     const vk::Format &srcFormat,
+                     const vk::Format &destFormat)
+{
+    return renderer->hasTextureFormatFeatureBits(srcFormat.vkTextureFormat,
+                                                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) &&
+           renderer->hasTextureFormatFeatureBits(destFormat.vkTextureFormat,
+                                                 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
+}
 }  // anonymous namespace
 
 // StagingStorage implementation.
@@ -575,21 +585,25 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,
     const vk::Format &destFormat = renderer->getFormat(internalFormat.sizedInternalFormat);
 
     // TODO(syoussefi): Support draw path for when !mImage.valid().  http://anglebug.com/2958
-    bool canDraw = mImage.valid() &&
-                   renderer->hasTextureFormatFeatureBits(srcFormat.vkTextureFormat,
-                                                         VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) &&
-                   renderer->hasTextureFormatFeatureBits(destFormat.vkTextureFormat,
-                                                         VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
+    bool canDraw = mImage.valid() && CanCopyWithDraw(renderer, srcFormat, destFormat);
+    bool forceCpuPath =
+        mImage.getLayerCount() > 1 && renderer->getFeatures().forceCpuPathForCubeMapCopy;
 
     // If it's possible to perform the copy with a draw call, do that.
-    if (canDraw)
+    if (canDraw && !forceCpuPath)
     {
-        ANGLE_TRY(ensureImageInitialized(contextVk));
+        RenderTargetVk *colorReadRT = framebufferVk->getColorReadRenderTarget();
+        bool isViewportFlipY        = contextVk->isViewportFlipEnabledForDrawFBO();
+
+        // Layer count can only be 1 as the source is a framebuffer.
+        ASSERT(index.getLayerCount() == 1);
 
-        return copySubImageImplWithDraw(contextVk, index, modifiedDestOffset,
-                                        gl::Offset(clippedSourceArea.x, clippedSourceArea.y, 0),
-                                        gl::Extents(destArea.width, destArea.height, 1),
-                                        framebufferVk);
+        ANGLE_TRY(copySubImageImplWithDraw(
+            contextVk, index, modifiedDestOffset, 0, clippedSourceArea, isViewportFlipY, false,
+            false, false, &colorReadRT->getImage(), colorReadRT->getReadImageView()));
+
+        framebufferVk->getFramebuffer()->addReadDependency(&mImage);
+        return angle::Result::Continue;
     }
 
     // Do a CPU readback that does the conversion, and then stage the change to the pixel buffer.
@@ -603,51 +617,6 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,
     return angle::Result::Continue;
 }
 
-angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
-                                                  const gl::ImageIndex &index,
-                                                  const gl::Offset &destOffset,
-                                                  const gl::Offset &srcOffset,
-                                                  const gl::Extents &extents,
-                                                  FramebufferVk *source)
-{
-    UtilsVk::CopyImageParameters params;
-    params.srcOffset[0]  = srcOffset.x;
-    params.srcOffset[1]  = srcOffset.y;
-    params.srcExtents[0] = extents.width;
-    params.srcExtents[1] = extents.height;
-    params.destOffset[0] = destOffset.x;
-    params.destOffset[1] = destOffset.y;
-    params.srcMip        = 0;
-    params.srcHeight     = source->getReadImageExtents().height;
-    params.flipY         = contextVk->isViewportFlipEnabledForDrawFBO();
-
-    uint32_t level      = index.getLevelIndex();
-    uint32_t baseLayer  = index.hasLayer() ? index.getLayerIndex() : 0;
-    uint32_t layerCount = index.getLayerCount();
-
-    // TODO(syoussefi): currently this is only called from copy[Sub]Image,
-    // where layer count can only be 1, and source's level and layer are both 0.
-    // Once this code is expanded to cover copy[Sub]Texture, it should be
-    // adapted to get single-layer/level image views of the source as well.
-    // http://anglebug.com/2958
-    ASSERT(layerCount == 1);
-    vk::ImageHelper *srcImage = &source->getColorReadRenderTarget()->getImage();
-    vk::ImageView *srcView    = source->getColorReadRenderTarget()->getReadImageView();
-
-    for (uint32_t i = 0; i < layerCount; ++i)
-    {
-        vk::ImageView *destView;
-        ANGLE_TRY(getLayerLevelDrawImageView(contextVk, baseLayer + i, level, &destView));
-
-        ANGLE_TRY(contextVk->getRenderer()->getUtils().copyImage(contextVk, &mImage, destView,
-                                                                 srcImage, srcView, params));
-    }
-
-    source->getFramebuffer()->addReadDependency(&mImage);
-
-    return angle::Result::Continue;
-}
-
 angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
                                             const gl::ImageIndex &index,
                                             const gl::Offset &destOffset,
@@ -661,6 +630,28 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
 {
     RendererVk *renderer = contextVk->getRenderer();
 
+    ANGLE_TRY(source->ensureImageInitialized(contextVk));
+
+    const vk::Format &sourceVkFormat = source->getImage().getFormat();
+    const vk::Format &destVkFormat   = renderer->getFormat(destFormat.sizedInternalFormat);
+
+    // TODO(syoussefi): Support draw path for when !mImage.valid().  http://anglebug.com/2958
+    bool canDraw = mImage.valid() && CanCopyWithDraw(renderer, sourceVkFormat, destVkFormat);
+    bool forceCpuPath =
+        mImage.getLayerCount() > 1 && renderer->getFeatures().forceCpuPathForCubeMapCopy;
+
+    // If it's possible to perform the copy with a draw call, do that.
+    if (canDraw && !forceCpuPath)
+    {
+        ANGLE_TRY(copySubImageImplWithDraw(contextVk, index, destOffset, sourceLevel, sourceArea,
+                                           false, unpackFlipY, unpackPremultiplyAlpha,
+                                           unpackUnmultiplyAlpha, &source->getImage(),
+                                           &source->getReadImageView()));
+
+        source->getImage().addReadDependency(&mImage);
+        return angle::Result::Continue;
+    }
+
     if (sourceLevel != 0)
     {
         WARN() << "glCopyTextureCHROMIUM with sourceLevel != 0 not implemented.";
@@ -671,9 +662,6 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
     uint8_t *sourceData = nullptr;
     ANGLE_TRY(source->copyImageDataToBuffer(contextVk, sourceLevel, 1, sourceArea, &sourceData));
 
-    const vk::Format &sourceVkFormat = source->getImage().getFormat();
-    const vk::Format &destVkFormat   = renderer->getFormat(destFormat.sizedInternalFormat);
-
     const angle::Format &sourceTextureFormat = sourceVkFormat.textureFormat();
     const angle::Format &destTextureFormat   = destVkFormat.textureFormat();
     size_t destinationAllocationSize =
@@ -716,6 +704,53 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
     return angle::Result::Continue;
 }
 
+angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
+                                                  const gl::ImageIndex &index,
+                                                  const gl::Offset &destOffset,
+                                                  size_t sourceLevel,
+                                                  const gl::Rectangle &sourceArea,
+                                                  bool isSrcFlipY,
+                                                  bool unpackFlipY,
+                                                  bool unpackPremultiplyAlpha,
+                                                  bool unpackUnmultiplyAlpha,
+                                                  vk::ImageHelper *srcImage,
+                                                  const vk::ImageView *srcView)
+{
+    ANGLE_TRY(ensureImageInitialized(contextVk));
+
+    UtilsVk &utilsVk = contextVk->getRenderer()->getUtils();
+
+    UtilsVk::CopyImageParameters params;
+    params.srcOffset[0]        = sourceArea.x;
+    params.srcOffset[1]        = sourceArea.y;
+    params.srcExtents[0]       = sourceArea.width;
+    params.srcExtents[1]       = sourceArea.height;
+    params.destOffset[0]       = destOffset.x;
+    params.destOffset[1]       = destOffset.y;
+    params.srcMip              = sourceLevel;
+    params.srcHeight           = srcImage->getExtents().height;
+    params.srcPremultiplyAlpha = unpackPremultiplyAlpha && !unpackUnmultiplyAlpha;
+    params.srcUnmultiplyAlpha  = unpackUnmultiplyAlpha && !unpackPremultiplyAlpha;
+    params.srcFlipY            = isSrcFlipY;
+    params.destFlipY           = unpackFlipY;
+
+    uint32_t level      = index.getLevelIndex();
+    uint32_t baseLayer  = index.hasLayer() ? index.getLayerIndex() : 0;
+    uint32_t layerCount = index.getLayerCount();
+
+    for (uint32_t layerIndex = 0; layerIndex < layerCount; ++layerIndex)
+    {
+        params.srcLayer = layerIndex;
+
+        vk::ImageView *destView;
+        ANGLE_TRY(getLayerLevelDrawImageView(contextVk, baseLayer + layerIndex, level, &destView));
+
+        ANGLE_TRY(utilsVk.copyImage(contextVk, &mImage, destView, srcImage, srcView, params));
+    }
+
+    return angle::Result::Continue;
+}
+
 angle::Result TextureVk::setStorage(const gl::Context *context,
                                     gl::TextureType type,
                                     size_t levels,

src/libANGLE/renderer/vulkan/TextureVk.h

@@ -244,13 +244,6 @@ class TextureVk : public TextureImpl
                                    const gl::InternalFormat &internalFormat,
                                    gl::Framebuffer *source);
 
-    angle::Result copySubImageImplWithDraw(ContextVk *contextVk,
-                                           const gl::ImageIndex &index,
-                                           const gl::Offset &destOffset,
-                                           const gl::Offset &srcOffset,
-                                           const gl::Extents &extents,
-                                           FramebufferVk *source);
-
     angle::Result copySubTextureImpl(ContextVk *contextVk,
                                      const gl::ImageIndex &index,
                                      const gl::Offset &destOffset,
@@ -262,6 +255,18 @@ class TextureVk : public TextureImpl
                                      bool unpackUnmultiplyAlpha,
                                      TextureVk *source);
 
+    angle::Result copySubImageImplWithDraw(ContextVk *contextVk,
+                                           const gl::ImageIndex &index,
+                                           const gl::Offset &destOffset,
+                                           size_t sourceLevel,
+                                           const gl::Rectangle &sourceArea,
+                                           bool isSrcFlipY,
+                                           bool unpackFlipY,
+                                           bool unpackPremultiplyAlpha,
+                                           bool unpackUnmultiplyAlpha,
+                                           vk::ImageHelper *srcImage,
+                                           const vk::ImageView *srcView);
+
     angle::Result initImage(ContextVk *contextVk,
                             const vk::Format &format,
                             const gl::Extents &extents,

src/libANGLE/renderer/vulkan/UtilsVk.cpp

@@ -133,6 +133,23 @@ uint32_t GetImageCopyFlags(const vk::Format &srcFormat, const vk::Format &destFo
 
     return flags;
 }
+
+uint32_t GetFormatDefaultChannelMask(const vk::Format &format)
+{
+    uint32_t mask = 0;
+
+    const angle::Format &angleFormat   = format.angleFormat();
+    const angle::Format &textureFormat = format.textureFormat();
+
+    // Red can never be introduced due to format emulation (except for luma which is handled
+    // especially)
+    ASSERT(((angleFormat.redBits > 0) == (textureFormat.redBits > 0)) || angleFormat.isLUMA());
+    mask |= angleFormat.greenBits == 0 && textureFormat.greenBits > 0 ? 2 : 0;
+    mask |= angleFormat.blueBits == 0 && textureFormat.blueBits > 0 ? 4 : 0;
+    mask |= angleFormat.alphaBits == 0 && textureFormat.alphaBits > 0 ? 8 : 0;
+
+    return mask;
+}
 }  // namespace
 
 UtilsVk::UtilsVk() = default;
@@ -547,7 +564,7 @@ angle::Result UtilsVk::convertVertexBuffer(vk::Context *context,
 
 angle::Result UtilsVk::startRenderPass(vk::Context *context,
                                        vk::ImageHelper *image,
-                                       vk::ImageView *imageView,
+                                       const vk::ImageView *imageView,
                                        const vk::RenderPassDesc &renderPassDesc,
                                        const gl::Rectangle &renderArea,
                                        vk::CommandBuffer **commandBufferOut)
@@ -633,9 +650,9 @@ angle::Result UtilsVk::clearImage(ContextVk *contextVk,
 
 angle::Result UtilsVk::copyImage(vk::Context *context,
                                  vk::ImageHelper *dest,
-                                 vk::ImageView *destView,
+                                 const vk::ImageView *destView,
                                  vk::ImageHelper *src,
-                                 vk::ImageView *srcView,
+                                 const vk::ImageView *srcView,
                                  const CopyImageParameters &params)
 {
     RendererVk *renderer = context->getRenderer();
@@ -646,24 +663,36 @@ angle::Result UtilsVk::copyImage(vk::Context *context,
     const vk::Format &destFormat = dest->getFormat();
 
     ImageCopyShaderParams shaderParams;
-    shaderParams.flipY            = params.flipY;
+    shaderParams.flipY            = params.srcFlipY || params.destFlipY;
+    shaderParams.premultiplyAlpha = params.srcPremultiplyAlpha;
+    shaderParams.unmultiplyAlpha  = params.srcUnmultiplyAlpha;
     shaderParams.destHasLuminance = destFormat.angleFormat().luminanceBits > 0;
     shaderParams.destIsAlpha =
         destFormat.angleFormat().isLUMA() && destFormat.angleFormat().alphaBits > 0;
+    shaderParams.destDefaultChannelsMask = GetFormatDefaultChannelMask(destFormat);
     shaderParams.srcMip                  = params.srcMip;
+    shaderParams.srcLayer                = params.srcLayer;
     shaderParams.srcOffset[0]            = params.srcOffset[0];
     shaderParams.srcOffset[1]            = params.srcOffset[1];
     shaderParams.destOffset[0]           = params.destOffset[0];
     shaderParams.destOffset[1]           = params.destOffset[1];
 
-    if (params.flipY)
+    ASSERT(!(params.srcFlipY && params.destFlipY));
+    if (params.srcFlipY)
     {
         // If viewport is flipped, the shader expects srcOffset[1] to have the
         // last row's index instead of the first's.
-        shaderParams.srcOffset[1] = params.srcHeight - shaderParams.srcOffset[1] - 1;
+        shaderParams.srcOffset[1] = params.srcHeight - params.srcOffset[1] - 1;
+    }
+    else if (params.destFlipY)
+    {
+        // If image is flipped during copy, the shader uses the same code path as above,
+        // with srcOffset being set to the last row's index instead of the first's.
+        shaderParams.srcOffset[1] = params.srcOffset[1] + params.srcExtents[1] - 1;
     }
 
     uint32_t flags = GetImageCopyFlags(srcFormat, destFormat);
+    flags |= src->getLayerCount() > 1 ? ImageCopy_frag::kSrcIsArray : 0;
 
     VkDescriptorSet descriptorSet;
     vk::SharedDescriptorPoolBinding descriptorPoolBinding;

src/libANGLE/renderer/vulkan/UtilsVk.h

@@ -74,8 +74,12 @@ class UtilsVk : angle::NonCopyable
         int srcExtents[2];
         int destOffset[2];
         int srcMip;
+        int srcLayer;
         int srcHeight;
-        bool flipY;
+        bool srcPremultiplyAlpha;
+        bool srcUnmultiplyAlpha;
+        bool srcFlipY;
+        bool destFlipY;
     };
 
     angle::Result clearBuffer(vk::Context *context,
@@ -99,9 +103,9 @@ class UtilsVk : angle::NonCopyable
 
     angle::Result copyImage(vk::Context *context,
                             vk::ImageHelper *dest,
-                            vk::ImageView *destView,
+                            const vk::ImageView *destView,
                             vk::ImageHelper *src,
-                            vk::ImageView *srcView,
+                            const vk::ImageView *srcView,
                             const CopyImageParameters &params);
 
   private:
@@ -141,12 +145,16 @@ class UtilsVk : angle::NonCopyable
     struct ImageCopyShaderParams
     {
         // Structure matching PushConstants in ImageCopy.frag
+        int32_t srcOffset[2]             = {};
+        int32_t destOffset[2]            = {};
+        int32_t srcMip                   = 0;
+        int32_t srcLayer                 = 0;
         uint32_t flipY                   = 0;
+        uint32_t premultiplyAlpha        = 0;
+        uint32_t unmultiplyAlpha         = 0;
         uint32_t destHasLuminance        = 0;
         uint32_t destIsAlpha             = 0;
-        int32_t srcMip            = 0;
-        int32_t srcOffset[2]      = {};
-        int32_t destOffset[2]     = {};
+        uint32_t destDefaultChannelsMask = 0;
     };
 
     // Functions implemented by the class:
@@ -203,7 +211,7 @@ class UtilsVk : angle::NonCopyable
 
     angle::Result startRenderPass(vk::Context *context,
                                   vk::ImageHelper *image,
-                                  vk::ImageView *imageView,
+                                  const vk::ImageView *imageView,
                                   const vk::RenderPassDesc &renderPassDesc,
                                   const gl::Rectangle &renderArea,
                                   vk::CommandBuffer **commandBufferOut);
@@ -220,7 +228,8 @@ class UtilsVk : angle::NonCopyable
         mConvertVertexPrograms[vk::InternalShader::ConvertVertex_comp::kFlagsMask |
                                vk::InternalShader::ConvertVertex_comp::kConversionMask];
     vk::ShaderProgramHelper mImageClearProgram;
-    vk::ShaderProgramHelper mImageCopyPrograms[vk::InternalShader::ImageCopy_frag::kSrcFormatMask |
+    vk::ShaderProgramHelper mImageCopyPrograms[vk::InternalShader::ImageCopy_frag::kFlagsMask |
+                                               vk::InternalShader::ImageCopy_frag::kSrcFormatMask |
                                                vk::InternalShader::ImageCopy_frag::kDestFormatMask];
 };
 

src/libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000006.inc

-	// 7.11.3009
-	 #pragma once
-const uint32_t kImageCopy_frag_00000006[] = {
-	0x07230203,0x00010000,0x00080007,0x0000005a,0x00000000,0x00020011,0x00000001,0x0006000b,
-	0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
-	0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x0000000d,0x00000058,0x00030010,
-	0x00000004,0x00000007,0x00030003,0x00000002,0x000001c2,0x000b0004,0x455f4c47,0x735f5458,
-	0x6c706d61,0x656c7265,0x745f7373,0x75747865,0x665f6572,0x74636e75,0x736e6f69,0x00000000,
-	0x00040005,0x00000004,0x6e69616d,0x00000000,0x00070005,0x00000009,0x74736564,0x49627553,
-	0x6567616d,0x726f6f43,0x00007364,0x00060005,0x0000000d,0x465f6c67,0x43676172,0x64726f6f,
-	0x00000000,0x00060005,0x00000013,0x68737550,0x736e6f43,0x746e6174,0x00000073,0x00050006,
-	0x00000013,0x00000000,0x70696c66,0x00000059,0x00080006,0x00000013,0x00000001,0x74736564,
-	0x4c736148,0x6e696d75,0x65636e61,0x00000000,0x00060006,0x00000013,0x00000002,0x74736564,
-	0x6c417349,0x00616870,0x00050006,0x00000013,0x00000003,0x4d637273,0x00007069,0x00060006,
-	0x00000013,0x00000004,0x4f637273,0x65736666,0x00000074,0x00060006,0x00000013,0x00000005,
-	0x74736564,0x7366664f,0x00007465,0x00040005,0x00000015,0x61726170,0x0000736d,0x00070005,
-	0x0000001b,0x53637273,0x6d496275,0x43656761,0x64726f6f,0x00000073,0x00050005,0x0000002e,
-	0x56637273,0x65756c61,0x00000000,0x00030005,0x00000031,0x00637273,0x00050005,0x0000003f,
-	0x74736564,0x756c6156,0x00000065,0x00040005,0x00000058,0x74736564,0x00000000,0x00040047,
-	0x0000000d,0x0000000b,0x0000000f,0x00050048,0x00000013,0x00000000,0x00000023,0x00000000,
-	0x00050048,0x00000013,0x00000001,0x00000023,0x00000004,0x00050048,0x00000013,0x00000002,
-	0x00000023,0x00000008,0x00050048,0x00000013,0x00000003,0x00000023,0x0000000c,0x00050048,
-	0x00000013,0x00000004,0x00000023,0x00000010,0x00050048,0x00000013,0x00000005,0x00000023,
-	0x00000018,0x00030047,0x00000013,0x00000002,0x00040047,0x00000031,0x00000022,0x00000000,
-	0x00040047,0x00000031,0x00000021,0x00000000,0x00040047,0x00000058,0x0000001e,0x00000000,
-	0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00040015,0x00000006,0x00000020,
-	0x00000001,0x00040017,0x00000007,0x00000006,0x00000002,0x00040020,0x00000008,0x00000007,
-	0x00000007,0x00030016,0x0000000a,0x00000020,0x00040017,0x0000000b,0x0000000a,0x00000004,
-	0x00040020,0x0000000c,0x00000001,0x0000000b,0x0004003b,0x0000000c,0x0000000d,0x00000001,
-	0x00040017,0x0000000e,0x0000000a,0x00000002,0x00040015,0x00000012,0x00000020,0x00000000,
-	0x0008001e,0x00000013,0x00000012,0x00000012,0x00000012,0x00000006,0x00000007,0x00000007,
-	0x00040020,0x00000014,0x00000009,0x00000013,0x0004003b,0x00000014,0x00000015,0x00000009,
-	0x0004002b,0x00000006,0x00000016,0x00000005,0x00040020,0x00000017,0x00000009,0x00000007,
-	0x0004002b,0x00000006,0x0000001d,0x00000000,0x00040020,0x0000001e,0x00000009,0x00000012,
-	0x00020014,0x00000021,0x0004002b,0x00000012,0x00000022,0x00000000,0x0004002b,0x00000012,
-	0x00000026,0x00000001,0x00040020,0x00000027,0x00000007,0x00000006,0x00040017,0x0000002c,
-	0x00000012,0x00000004,0x00040020,0x0000002d,0x00000007,0x0000002c,0x00090019,0x0000002f,
-	0x00000012,0x00000001,0x00000000,0x00000000,0x00000000,0x00000001,0x00000000,0x00040020,
-	0x00000030,0x00000000,0x0000002f,0x0004003b,0x00000030,0x00000031,0x00000000,0x0004002b,
-	0x00000006,0x00000033,0x00000004,0x0004002b,0x00000006,0x00000038,0x00000003,0x00040020,
-	0x00000039,0x00000009,0x00000006,0x00040017,0x0000003d,0x00000006,0x00000004,0x00040020,
-	0x0000003e,0x00000007,0x0000003d,0x0004002b,0x00000006,0x00000042,0x00000001,0x0004002b,
-	0x00000006,0x0000004d,0x00000002,0x0004002b,0x00000012,0x00000053,0x00000003,0x00040020,
-	0x00000057,0x00000003,0x0000003d,0x0004003b,0x00000057,0x00000058,0x00000003,0x00050036,
-	0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000008,
-	0x00000009,0x00000007,0x0004003b,0x00000008,0x0000001b,0x00000007,0x0004003b,0x0000002d,
-	0x0000002e,0x00000007,0x0004003b,0x0000003e,0x0000003f,0x00000007,0x0004003d,0x0000000b,
-	0x0000000f,0x0000000d,0x0007004f,0x0000000e,0x00000010,0x0000000f,0x0000000f,0x00000000,
-	0x00000001,0x0004006e,0x00000007,0x00000011,0x00000010,0x00050041,0x00000017,0x00000018,
-	0x00000015,0x00000016,0x0004003d,0x00000007,0x00000019,0x00000018,0x00050082,0x00000007,
-	0x0000001a,0x00000011,0x00000019,0x0003003e,0x00000009,0x0000001a,0x0004003d,0x00000007,
-	0x0000001c,0x00000009,0x0003003e,0x0000001b,0x0000001c,0x00050041,0x0000001e,0x0000001f,
-	0x00000015,0x0000001d,0x0004003d,0x00000012,0x00000020,0x0000001f,0x000500ab,0x00000021,
-	0x00000023,0x00000020,0x00000022,0x000300f7,0x00000025,0x00000000,0x000400fa,0x00000023,
-	0x00000024,0x00000025,0x000200f8,0x00000024,0x00050041,0x00000027,0x00000028,0x0000001b,
-	0x00000026,0x0004003d,0x00000006,0x00000029,0x00000028,0x0004007e,0x00000006,0x0000002a,
-	0x00000029,0x00050041,0x00000027,0x0000002b,0x0000001b,0x00000026,0x0003003e,0x0000002b,
-	0x0000002a,0x000200f9,0x00000025,0x000200f8,0x00000025,0x0004003d,0x0000002f,0x00000032,
-	0x00000031,0x00050041,0x00000017,0x00000034,0x00000015,0x00000033,0x0004003d,0x00000007,
-	0x00000035,0x00000034,0x0004003d,0x00000007,0x00000036,0x0000001b,0x00050080,0x00000007,
-	0x00000037,0x00000035,0x00000036,0x00050041,0x00000039,0x0000003a,0x00000015,0x00000038,
-	0x0004003d,0x00000006,0x0000003b,0x0000003a,0x0007005f,0x0000002c,0x0000003c,0x00000032,
-	0x00000037,0x00000002,0x0000003b,0x0003003e,0x0000002e,0x0000003c,0x0004003d,0x0000002c,
-	0x00000040,0x0000002e,0x0004007c,0x0000003d,0x00000041,0x00000040,0x0003003e,0x0000003f,
-	0x00000041,0x00050041,0x0000001e,0x00000043,0x00000015,0x00000042,0x0004003d,0x00000012,
-	0x00000044,0x00000043,0x000500ab,0x00000021,0x00000045,0x00000044,0x00000022,0x000300f7,
-	0x00000047,0x00000000,0x000400fa,0x00000045,0x00000046,0x0000004c,0x000200f8,0x00000046,
-	0x0004003d,0x0000003d,0x00000048,0x0000003f,0x0007004f,0x00000007,0x00000049,0x00000048,
-	0x00000048,0x00000000,0x00000003,0x0004003d,0x0000003d,0x0000004a,0x0000003f,0x0009004f,
-	0x0000003d,0x0000004b,0x0000004a,0x00000049,0x00000004,0x00000005,0x00000002,0x00000003,
-	0x0003003e,0x0000003f,0x0000004b,0x000200f9,0x00000047,0x000200f8,0x0000004c,0x00050041,
-	0x0000001e,0x0000004e,0x00000015,0x0000004d,0x0004003d,0x00000012,0x0000004f,0x0000004e,
-	0x000500ab,0x00000021,0x00000050,0x0000004f,0x00000022,0x000300f7,0x00000052,0x00000000,
-	0x000400fa,0x00000050,0x00000051,0x00000052,0x000200f8,0x00000051,0x00050041,0x00000027,
-	0x00000054,0x0000003f,0x00000053,0x0004003d,0x00000006,0x00000055,0x00000054,0x00050041,
-	0x00000027,0x00000056,0x0000003f,0x00000022,0x0003003e,0x00000056,0x00000055,0x000200f9,
-	0x00000052,0x000200f8,0x00000052,0x000200f9,0x00000047,0x000200f8,0x00000047,0x0004003d,
-	0x0000003d,0x00000059,0x0000003f,0x0003003e,0x00000058,0x00000059,0x000100fd,0x00010038
-};
-
-#if 0  // Generated from:
-#version 450 core
-
-#extension GL_EXT_samplerless_texture_functions : require
-
-layout(set = 0, binding = 0)uniform utexture2D src;
-layout(location = 0)out ivec4 dest;
-
-layout(push_constant)uniform PushConstants {
-
-    bool flipY;
-
-    bool destHasLuminance;
-    bool destIsAlpha;
-
-    int srcMip;
-    ivec2 srcOffset;
-    ivec2 destOffset;
-} params;
-
-void main()
-{
-    ivec2 destSubImageCoords = ivec2(gl_FragCoord . xy)- params . destOffset;
-
-    ivec2 srcSubImageCoords = destSubImageCoords;
-
-    if(params . flipY)
-        srcSubImageCoords . y = - srcSubImageCoords . y;
-
-          uvec4 srcValue = texelFetch(src, params . srcOffset + srcSubImageCoords, params . srcMip);
-
-           ivec4 destValue = ivec4(srcValue);
-
-    if(params . destHasLuminance)
-    {
-        destValue . rg = destValue . ra;
-    }
-    else if(params . destIsAlpha)
-    {
-        destValue . r = destValue . a;
-    }
-
-    dest = destValue;
-}
-#endif  // Preprocessed code

src/libANGLE/renderer/vulkan/shaders/src/ImageCopy.frag

@@ -9,19 +9,27 @@
 
 #extension GL_EXT_samplerless_texture_functions : require
 
+#define MAKE_SRC_RESOURCE(prefix, type) prefix ## type
+
 #if SrcIsFloat
 #define SRC_RESOURCE(type) type
 #define SrcType vec4
 #elif SrcIsInt
-#define SRC_RESOURCE(type) i ## type
+#define SRC_RESOURCE(type) MAKE_SRC_RESOURCE(i, type)
 #define SrcType ivec4
 #elif SrcIsUint
-#define SRC_RESOURCE(type) u ## type
+#define SRC_RESOURCE(type) MAKE_SRC_RESOURCE(u, type)
 #define SrcType uvec4
 #else
 #error "Not all source formats are accounted for"
 #endif
 
+#if SrcIsArray
+#define SRC_RESOURCE_NAME texture2DArray
+#else
+#define SRC_RESOURCE_NAME texture2D
+#endif
+
 #if DestIsFloat
 #define DestType vec4
 #elif DestIsInt
@@ -32,19 +40,27 @@
 #error "Not all destinatoin formats are accounted for"
 #endif
 
-layout(set = 0, binding = 0) uniform SRC_RESOURCE(texture2D) src;
+layout(set = 0, binding = 0) uniform SRC_RESOURCE(SRC_RESOURCE_NAME) src;
 layout(location = 0) out DestType dest;
 
 layout(push_constant) uniform PushConstants {
+    // Translation from source to destination coordinates.
+    ivec2 srcOffset;
+    ivec2 destOffset;
+    int srcMip;
+    int srcLayer;
     // Whether y needs to be flipped
     bool flipY;
+    // Premultiplied alpha conversions
+    bool premultiplyAlpha;
+    bool unmultiplyAlpha;
     // Whether destination is emulated luminance/alpha.
     bool destHasLuminance;
     bool destIsAlpha;
-    // Translation from source to destination coordinates.
-    int srcMip;
-    ivec2 srcOffset;
-    ivec2 destOffset;
+    // Bits 0~3 tell whether R,G,B or A exist in destination, but as a result of format emulation.
+    // Bit 0 is ignored, because R is always present.  For B and G, the result is set to 0 and for
+    // A, the result is set to 1.
+    int destDefaultChannelsMask;
 } params;
 
 void main()
@@ -58,7 +74,20 @@ void main()
     if (params.flipY)
         srcSubImageCoords.y = -srcSubImageCoords.y;
 
+#if SrcIsArray
+    SrcType srcValue = texelFetch(src, ivec3(params.srcOffset + srcSubImageCoords, params.srcLayer), params.srcMip);
+#else
     SrcType srcValue = texelFetch(src, params.srcOffset + srcSubImageCoords, params.srcMip);
+#endif
+
+    if (params.premultiplyAlpha)
+    {
+        srcValue.rgb *= srcValue.a;
+    }
+    else if (params.unmultiplyAlpha && srcValue.a > 0)
+    {
+        srcValue.rgb /= srcValue.a;
+    }
 
     // Convert value to destination type.
     DestType destValue = DestType(srcValue);
@@ -72,6 +101,22 @@ void main()
     {
         destValue.r = destValue.a;
     }
+    else
+    {
+        int defaultChannelsMask = params.destDefaultChannelsMask;
+        if ((defaultChannelsMask & 2) != 0)
+        {
+            destValue.g = 0;
+        }
+        if ((defaultChannelsMask & 4) != 0)
+        {
+            destValue.b = 0;
+        }
+        if ((defaultChannelsMask & 8) != 0)
+        {
+            destValue.a = 1;
+        }
+    }
 
     dest = destValue;
 }

src/libANGLE/renderer/vulkan/shaders/src/ImageCopy.frag.json

@@ -6,6 +6,9 @@
         "",
         "ImageCopy.frag.json: Build parameters for ImageCopy.frag."
     ],
+    "Flags": [
+        "SrcIsArray"
+    ],
     "SrcFormat": [
         "SrcIsFloat",
         "SrcIsInt",

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -458,8 +458,6 @@ angle::Result DynamicDescriptorPool::allocateNewPool(Context *context)
         if (!mDescriptorPools[poolIndex]->isReferenced() &&
             !renderer->isSerialInUse(mDescriptorPools[poolIndex]->get().getSerial()))
         {
-            // The newly allocated pool must be a different index from the current pool.
-            ASSERT(poolIndex != mCurrentPoolIndex);
             mCurrentPoolIndex = poolIndex;
             found             = true;
             break;

src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.cpp

@@ -49,12 +49,21 @@ namespace
 #include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000000.inc"
 #include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000001.inc"
 #include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000002.inc"
+#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000003.inc"
 #include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000004.inc"
 #include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000005.inc"
-#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000006.inc"
 #include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000008.inc"
 #include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000009.inc"
 #include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.0000000A.inc"
+#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.0000000B.inc"
+#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.0000000C.inc"
+#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.0000000D.inc"
+#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000010.inc"
+#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000011.inc"
+#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000012.inc"
+#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000013.inc"
+#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000014.inc"
+#include "libANGLE/renderer/vulkan/shaders/gen/ImageCopy.frag.00000015.inc"
 
 // This is SPIR-V binary blob and the size.
 struct ShaderBlob
@@ -105,14 +114,25 @@ constexpr ShaderBlob kImageCopy_frag_shaders[] = {
     {kImageCopy_frag_00000000, sizeof(kImageCopy_frag_00000000)},
     {kImageCopy_frag_00000001, sizeof(kImageCopy_frag_00000001)},
     {kImageCopy_frag_00000002, sizeof(kImageCopy_frag_00000002)},
-    {nullptr, 0},  // 0x00000003
+    {kImageCopy_frag_00000003, sizeof(kImageCopy_frag_00000003)},
     {kImageCopy_frag_00000004, sizeof(kImageCopy_frag_00000004)},
     {kImageCopy_frag_00000005, sizeof(kImageCopy_frag_00000005)},
-    {kImageCopy_frag_00000006, sizeof(kImageCopy_frag_00000006)},
+    {nullptr, 0},  // 0x00000006
     {nullptr, 0},  // 0x00000007
     {kImageCopy_frag_00000008, sizeof(kImageCopy_frag_00000008)},
     {kImageCopy_frag_00000009, sizeof(kImageCopy_frag_00000009)},
     {kImageCopy_frag_0000000A, sizeof(kImageCopy_frag_0000000A)},
+    {kImageCopy_frag_0000000B, sizeof(kImageCopy_frag_0000000B)},
+    {kImageCopy_frag_0000000C, sizeof(kImageCopy_frag_0000000C)},
+    {kImageCopy_frag_0000000D, sizeof(kImageCopy_frag_0000000D)},
+    {nullptr, 0},  // 0x0000000E
+    {nullptr, 0},  // 0x0000000F
+    {kImageCopy_frag_00000010, sizeof(kImageCopy_frag_00000010)},
+    {kImageCopy_frag_00000011, sizeof(kImageCopy_frag_00000011)},
+    {kImageCopy_frag_00000012, sizeof(kImageCopy_frag_00000012)},
+    {kImageCopy_frag_00000013, sizeof(kImageCopy_frag_00000013)},
+    {kImageCopy_frag_00000014, sizeof(kImageCopy_frag_00000014)},
+    {kImageCopy_frag_00000015, sizeof(kImageCopy_frag_00000015)},
 };
 
 angle::Result GetShader(Context *context,

src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.gni

@@ -42,10 +42,19 @@ angle_vulkan_internal_shaders = [
   "shaders/gen/ImageCopy.frag.00000000.inc",
   "shaders/gen/ImageCopy.frag.00000001.inc",
   "shaders/gen/ImageCopy.frag.00000002.inc",
+  "shaders/gen/ImageCopy.frag.00000003.inc",
   "shaders/gen/ImageCopy.frag.00000004.inc",
   "shaders/gen/ImageCopy.frag.00000005.inc",
-  "shaders/gen/ImageCopy.frag.00000006.inc",
   "shaders/gen/ImageCopy.frag.00000008.inc",
   "shaders/gen/ImageCopy.frag.00000009.inc",
   "shaders/gen/ImageCopy.frag.0000000A.inc",
+  "shaders/gen/ImageCopy.frag.0000000B.inc",
+  "shaders/gen/ImageCopy.frag.0000000C.inc",
+  "shaders/gen/ImageCopy.frag.0000000D.inc",
+  "shaders/gen/ImageCopy.frag.00000010.inc",
+  "shaders/gen/ImageCopy.frag.00000011.inc",
+  "shaders/gen/ImageCopy.frag.00000012.inc",
+  "shaders/gen/ImageCopy.frag.00000013.inc",
+  "shaders/gen/ImageCopy.frag.00000014.inc",
+  "shaders/gen/ImageCopy.frag.00000015.inc",
 ]

src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.h

@@ -70,19 +70,24 @@ namespace ImageClear_frag
 
 namespace ImageCopy_frag
 {
+enum flags
+{
+    kSrcIsArray = 0x00000001,
+    kFlagsMask  = 0x00000001,
+};
 enum SrcFormat
 {
     kSrcIsFloat    = 0x00000000,
-    kSrcIsInt      = 0x00000001,
-    kSrcIsUint     = 0x00000002,
-    kSrcFormatMask = 0x00000003,
+    kSrcIsInt      = 0x00000002,
+    kSrcIsUint     = 0x00000004,
+    kSrcFormatMask = 0x00000006,
 };
 enum DestFormat
 {
     kDestIsFloat    = 0x00000000,
-    kDestIsInt      = 0x00000004,
-    kDestIsUint     = 0x00000008,
-    kDestFormatMask = 0x0000000C,
+    kDestIsInt      = 0x00000008,
+    kDestIsUint     = 0x00000010,
+    kDestFormatMask = 0x00000018,
 };
 }  // namespace ImageCopy_frag
 
@@ -123,7 +128,8 @@ class ShaderLibrary final : angle::NonCopyable
     RefCounted<ShaderAndSerial> mFullScreenQuad_vert_shaders[1];
     RefCounted<ShaderAndSerial> mImageClear_frag_shaders[1];
     RefCounted<ShaderAndSerial>
-        mImageCopy_frag_shaders[InternalShader::ImageCopy_frag::kSrcFormatMask |
+        mImageCopy_frag_shaders[InternalShader::ImageCopy_frag::kFlagsMask |
+                                InternalShader::ImageCopy_frag::kSrcFormatMask |
                                 InternalShader::ImageCopy_frag::kDestFormatMask];
 };
 }  // namespace vk