Vulkan: Pass in emulated alpha value to ConvertVertex

scripts/code_generation_hashes/Vulkan_internal_shader_programs.json

@@ -74,23 +74,23 @@
   "src/libANGLE/renderer/vulkan/shaders/gen/ConvertIndirectLineLoop.comp.00000000.inc":
     "e1eb4a5fac9fc74ecd3790b2f773dc08",
   "src/libANGLE/renderer/vulkan/shaders/gen/ConvertVertex.comp.00000000.inc":
-    "41cec7c18b88e60252f31e38a93ee8da",
+    "498380556bc1a01e1d3f8fbf5fbcaab0",
   "src/libANGLE/renderer/vulkan/shaders/gen/ConvertVertex.comp.00000001.inc":
-    "4bfbcfbda657a0db2467fd05e8a90ca3",
+    "f7ee2788aa5ec72436476d177062752f",
   "src/libANGLE/renderer/vulkan/shaders/gen/ConvertVertex.comp.00000002.inc":
-    "8f7200e0901cae98e68fef5448055f7d",
+    "8cb4e3453e7839ab19bc97d9bd58b5a3",
   "src/libANGLE/renderer/vulkan/shaders/gen/ConvertVertex.comp.00000003.inc":
-    "473ef011c869f13f49e95d7a5a8ce81e",
+    "c146975e8ec188e994368260a7b5e761",
   "src/libANGLE/renderer/vulkan/shaders/gen/ConvertVertex.comp.00000004.inc":
-    "f97185d954b735753ea4ab93851f03bf",
+    "d05233f650927f0fbc7de3bfe03a9548",
   "src/libANGLE/renderer/vulkan/shaders/gen/ConvertVertex.comp.00000005.inc":
-    "d0e1d3a317688d6d8e7ba2300a9a3434",
+    "04bb8f5760c14448c86ea6ba927cdf25",
   "src/libANGLE/renderer/vulkan/shaders/gen/ConvertVertex.comp.00000006.inc":
-    "df913989b39699e549ba9089190d358c",
+    "46d9a28b7a5c4a8f804e12e77c145104",
   "src/libANGLE/renderer/vulkan/shaders/gen/ConvertVertex.comp.00000007.inc":
-    "c9e0fad17170e97662b0fa0d37919ea3",
+    "2137dcf6b892b98a1cddbff2ff515dfd",
   "src/libANGLE/renderer/vulkan/shaders/gen/ConvertVertex.comp.00000008.inc":
-    "680d2865d4350c8f36fbbdaec1b43682",
+    "a66c0fd5341b7cb353ce2bdf717a430e",
   "src/libANGLE/renderer/vulkan/shaders/gen/FullScreenQuad.vert.00000000.inc":
     "a6f06ce133d1342fafed89305dd99bdd",
   "src/libANGLE/renderer/vulkan/shaders/gen/GenerateMipmap.comp.00000000.inc":
@@ -300,7 +300,7 @@
   "src/libANGLE/renderer/vulkan/shaders/src/ConvertIndirectLineLoop.comp.json":
     "c2c79c40b0fbcb4876637aa06e8aa919",
   "src/libANGLE/renderer/vulkan/shaders/src/ConvertVertex.comp":
-    "537e6cff8f9a0b6acdf1c9be5fdcef7c",
+    "d656da7733a59771d91b0511643cf9f7",
   "src/libANGLE/renderer/vulkan/shaders/src/ConvertVertex.comp.json":
     "f2abd98463e46c0af45e8a1a5e5af88f",
   "src/libANGLE/renderer/vulkan/shaders/src/FullScreenQuad.vert":

src/libANGLE/renderer/vulkan/UtilsVk.cpp

@@ -52,6 +52,19 @@ constexpr uint32_t kOverlayDrawFontBinding                   = 4;
 constexpr uint32_t kGenerateMipmapDestinationBinding         = 0;
 constexpr uint32_t kGenerateMipmapSourceBinding              = 1;
 
+constexpr uint32_t kFloatOneAsUint = 0x3F80'0000u;
+
+bool ValidateFloatOneAsUint()
+{
+    union
+    {
+        uint32_t asUint;
+        float asFloat;
+    } one;
+    one.asUint = kFloatOneAsUint;
+    return one.asFloat == 1.0f;
+}
+
 uint32_t GetConvertVertexFlags(const UtilsVk::ConvertVertexParameters &params)
 {
     bool srcIsSint      = params.srcFormat->isSint();
@@ -89,43 +102,43 @@ uint32_t GetConvertVertexFlags(const UtilsVk::ConvertVertexParameters &params)
     if (srcIsHalfFloat && destIsHalfFloat)
     {
         // Note that HalfFloat conversion uses the same shader as Uint.
-        flags |= ConvertVertex_comp::kUintToUint;
+        flags = ConvertVertex_comp::kUintToUint;
     }
     else if (srcIsFloat && destIsHalfFloat)
     {
-        flags |= ConvertVertex_comp::kFloatToHalf;
+        flags = ConvertVertex_comp::kFloatToHalf;
     }
     else if (srcIsSint && destIsSint)
     {
-        flags |= ConvertVertex_comp::kSintToSint;
+        flags = ConvertVertex_comp::kSintToSint;
     }
     else if (srcIsUint && destIsUint)
     {
-        flags |= ConvertVertex_comp::kUintToUint;
+        flags = ConvertVertex_comp::kUintToUint;
     }
     else if (srcIsSint)
     {
-        flags |= ConvertVertex_comp::kSintToFloat;
+        flags = ConvertVertex_comp::kSintToFloat;
     }
     else if (srcIsUint)
     {
-        flags |= ConvertVertex_comp::kUintToFloat;
+        flags = ConvertVertex_comp::kUintToFloat;
     }
     else if (srcIsSnorm)
     {
-        flags |= ConvertVertex_comp::kSnormToFloat;
+        flags = ConvertVertex_comp::kSnormToFloat;
     }
     else if (srcIsUnorm)
     {
-        flags |= ConvertVertex_comp::kUnormToFloat;
+        flags = ConvertVertex_comp::kUnormToFloat;
     }
     else if (srcIsFixed)
     {
-        flags |= ConvertVertex_comp::kFixedToFloat;
+        flags = ConvertVertex_comp::kFixedToFloat;
     }
     else if (srcIsFloat)
     {
-        flags |= ConvertVertex_comp::kFloatToFloat;
+        flags = ConvertVertex_comp::kFloatToFloat;
     }
     else
     {
@@ -1321,6 +1334,47 @@ angle::Result UtilsVk::convertVertexBuffer(ContextVk *contextVk,
 
     uint32_t flags = GetConvertVertexFlags(params);
 
+    // See GLES3.0 section 2.9.1 Transferring Array Elements
+    const uint32_t srcValueBits = shaderParams.isSrcHDR ? 2 : shaderParams.Bs * 8;
+    const uint32_t srcValueMask =
+        srcValueBits == 32 ? 0xFFFFFFFFu : angle::Bit<uint32_t>(srcValueBits) - 1;
+    switch (flags)
+    {
+        case ConvertVertex_comp::kSintToSint:
+        case ConvertVertex_comp::kUintToUint:
+        case ConvertVertex_comp::kSintToFloat:
+        case ConvertVertex_comp::kUintToFloat:
+            // For integers, alpha should take a value of 1.
+            shaderParams.srcEmulatedAlpha = 1;
+            break;
+
+        case ConvertVertex_comp::kSnormToFloat:
+            // The largest signed number with as many bits as the alpha channel of the source is
+            // 0b011...1 which is srcValueMask >> 1
+            shaderParams.srcEmulatedAlpha = srcValueMask >> 1;
+            break;
+
+        case ConvertVertex_comp::kUnormToFloat:
+            // The largest unsigned number with as many bits as the alpha channel of the source is
+            // 0b11...1 which is srcValueMask
+            shaderParams.srcEmulatedAlpha = srcValueMask;
+            break;
+
+        case ConvertVertex_comp::kFixedToFloat:
+            // 1.0 in fixed point is 0x10000
+            shaderParams.srcEmulatedAlpha = 0x10000;
+            break;
+
+        case ConvertVertex_comp::kFloatToHalf:
+        case ConvertVertex_comp::kFloatToFloat:
+            ASSERT(ValidateFloatOneAsUint());
+            shaderParams.srcEmulatedAlpha = kFloatOneAsUint;
+            break;
+
+        default:
+            UNREACHABLE();
+    }
+
     VkDescriptorSet descriptorSet;
     vk::RefCountedDescriptorPoolBinding descriptorPoolBinding;
     ANGLE_TRY(allocateDescriptorSet(contextVk, Function::ConvertVertexBuffer,

src/libANGLE/renderer/vulkan/UtilsVk.h

@@ -309,21 +309,22 @@ class UtilsVk : angle::NonCopyable
         ConvertVertexShaderParams();
 
         // Structure matching PushConstants in ConvertVertex.comp
-        uint32_t outputCount    = 0;
-        uint32_t componentCount = 0;
-        uint32_t srcOffset      = 0;
-        uint32_t destOffset     = 0;
-        uint32_t Ns             = 0;
-        uint32_t Bs             = 0;
-        uint32_t Ss             = 0;
-        uint32_t Es             = 0;
-        uint32_t Nd             = 0;
-        uint32_t Bd             = 0;
-        uint32_t Sd             = 0;
-        uint32_t Ed             = 0;
-        uint32_t isSrcHDR       = 0;
-        uint32_t isSrcA2BGR10   = 0;
-        uint32_t _padding[2]    = {};
+        uint32_t outputCount      = 0;
+        uint32_t componentCount   = 0;
+        uint32_t srcOffset        = 0;
+        uint32_t destOffset       = 0;
+        uint32_t Ns               = 0;
+        uint32_t Bs               = 0;
+        uint32_t Ss               = 0;
+        uint32_t Es               = 0;
+        uint32_t Nd               = 0;
+        uint32_t Bd               = 0;
+        uint32_t Sd               = 0;
+        uint32_t Ed               = 0;
+        uint32_t srcEmulatedAlpha = 0;
+        uint32_t isSrcHDR         = 0;
+        uint32_t isSrcA2BGR10     = 0;
+        uint32_t _padding         = 0;
     };
 
     struct ImageClearShaderParams

src/libANGLE/renderer/vulkan/shaders/src/ConvertVertex.comp

@@ -129,6 +129,11 @@ layout (push_constant) uniform PushConstants
     uint Sd;       // Precalculated Nd*Bd
     uint Ed;       // Precalculated 4/Bd
 
+    // uint representation of src emulated alpha.  If destination has alpha and source doesn't,
+    // this value is used as src alpha, which is then converted to destination format the same way
+    // other data from source is.
+    uint srcEmulatedAlpha;
+
     bool isSrcHDR; // Whether source is either of A2BGR10 or RGB10A2
     bool isSrcA2BGR10;  // Whether source is A2BGR10
 } params;
@@ -245,24 +250,7 @@ SrcType loadSourceComponent(uint cd)
 
     if (component >= Ns && component == 3)
     {
-        // See GLES3.0 section 2.9.1 Transferring Array Elements
-#if SintToSint || SintToFloat || UintToUint || UintToFloat
-        // For integers, alpha should take a value of 1.
-        valueAsUint = 1;
-#elif SnormToFloat
-        // The largest signed number is 0b011...1 which is valueMask >> 1
-        valueAsUint = valueMask >> 1;
-#elif UnormToFloat
-        // The largest unsigned number is 0b11...1 which is valueMask
-        valueAsUint = valueMask;
-#elif FixedToFloat
-        // 1.0 in fixed point is 0x10000
-        valueAsUint = 0x10000;
-#elif FloatToFloat || FloatToHalf
-        valueAsUint = floatBitsToUint(1.0);
-#else
-#error "Not all conversions are accounted for"
-#endif
+        valueAsUint = params.srcEmulatedAlpha;
     }
     else
     {