[Feat] (MG_Backend, MG_Impl, MG_Util): attach one layer of any layered texture on DirectVulkan

Whether a backend can attach a single layer of a texture to a framebuffer was one
Bool, so it could only give the most conservative answer any target needed.
DirectVulkan therefore declined every layer of every target and
direct_state_access.framebuffers_texture_layer_attachment failed with 542
messages across four targets.

The three ways a GL layer maps onto Vulkan are independent capabilities, so the
flag becomes a per-TextureTarget mask. A 2D or 2D multisample array layer IS a
VkImage array layer and needed nothing but the gate opened. A cube map array is
one 2D image with arrayLayers = 6 * cubeCount and CUBE_COMPATIBLE, which is a
shape VkTextureManager simply did not have - it is declined softly when the depth
is not a whole number of cubes or the level is not square, because that function's
Bool return exists for unrepresentable shapes and asserting there would abort on
ordinary input, GL_PROXY_TEXTURE_CUBE_MAP_ARRAY above all. A 3D texture's layer is
a z slice, which needs a 2D-array-compatible image and a per-slice clear, because
vkCmdClearColorImage cannot address a subset of a 3D image's slices - a render
pass whose only content is its LOAD_OP_CLEAR can, since its attachment is a 2D
view over that one slice.

VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT is asked for per format and withdrawn per
format, mirroring the MUTABLE_FORMAT pattern already in this file: the capability
is per format+usage, so a single global probe answers a different question than
the one the frontend goes on to ask. Losing it costs per-slice attachment for that
format; failing creation would lose the texture.

Three things found on the way that are not the headline:

glFramebufferTextureLayer, the non-DSA twin, had no gate at all and additionally
refused cube map arrays that GL 4.5 requires it to accept. GL 4.6 core 9.2.8 makes
the two entry points equivalent, so they now decline in the same places - leaving
one ungated is what let an unrepresentable attachment reach the renderer.

ComputeFullMipLevelCount takes max(x, y, z), and for every array shape z is the
layer count rather than a mip-able axis, so a 4x4 array with 192 layers asked for
six mip levels on an image whose legal maximum is three
(VUID-VkImageCreateInfo-mipLevels-00958). Only the image's own extent can bound
it. lavapipe had been letting that through.

A layered GL clear queues layerCount = depth, which is illegal for a
VK_IMAGE_TYPE_3D image (VUID-vkCmdClearColorImage-baseArrayLayer-01472 pins it to
0/1, read as the whole mip level) and the old code passed it straight through.

Takes framebuffers_texture_layer_attachment green on DirectVulkan, so the whole
direct_state_access suite is 371/371 there; Espryt stays 370/371, the remaining
case being the fp64 one it declines by design.

Known and deliberately not fixed here, with a FIXME at the site:
KHR-GL44/45/46.geometry_shader.layered_framebuffer.clear_call_support now fails on
DirectVulkan - a layered clear of a 3D texture reads back zeros. Those cases exist
only in the GL44+ lists, above the 4.0 this backend reports. An A/B of a 6935-case
subset (cube map array, texture storage, framebuffer, 3D, the full DSA suite and
the GL33 texture group) is otherwise clean on both backends: 16 cases fixed and
none broken on Espryt, 15 fixed and those 2 broken on Magma, and zero difference
anywhere at GL 4.0 or below. The FIXME records which causes were already ruled out
by bisection so the next reader does not repeat them.

MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.cpp

@@ -199,6 +199,29 @@ namespace MobileGL::MG_Util::BackendLoader {
         vkGetPhysicalDeviceFeatures(physicalDevice, &supportedFeatures);
         caps.SupportsWideLines = supportedFeatures.wideLines == VK_TRUE;
         caps.SupportsShaderFloat64 = supportedFeatures.shaderFloat64 == VK_TRUE;
+        caps.SupportsImageCubeArray = supportedFeatures.imageCubeArray == VK_TRUE;
+        {
+            // Probe the formats a colour render target actually uses. A driver that refuses the flag
+            // for one of them refuses per-slice attachment for that format only, which
+            // VkTextureManager detects and records at image creation; this field just says whether
+            // the capability is worth offering at all.
+            static constexpr VkFormat k3DSliceProbeFormats[] = {VK_FORMAT_R8G8B8A8_UNORM,
+                                                                VK_FORMAT_R8G8B8A8_SRGB};
+            Bool all2DArrayCompatible = true;
+            for (const VkFormat probeFormat : k3DSliceProbeFormats) {
+                VkImageFormatProperties probeProperties{};
+                const VkResult probeResult = vkGetPhysicalDeviceImageFormatProperties(
+                    physicalDevice, probeFormat, VK_IMAGE_TYPE_3D, VK_IMAGE_TILING_OPTIMAL,
+                    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
+                        VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
+                    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, &probeProperties);
+                if (probeResult != VK_SUCCESS) {
+                    all2DArrayCompatible = false;
+                    break;
+                }
+            }
+            caps.Supports2DArrayCompatible3DImages = all2DArrayCompatible;
+        }
         caps.SupportsVertexPipelineStoresAndAtomics =
             supportedFeatures.vertexPipelineStoresAndAtomics == VK_TRUE;
         caps.SupportsFragmentStoresAndAtomics = supportedFeatures.fragmentStoresAndAtomics == VK_TRUE;
@@ -290,6 +313,8 @@ namespace MobileGL::MG_Util::BackendLoader {
         FillFragmentInterpolationLimits(caps, properties.limits);
         caps.SupportsWideLines = false;
         caps.SupportsShaderFloat64 = false;
+        caps.SupportsImageCubeArray = false;
+        caps.Supports2DArrayCompatible3DImages = false;
         // This helper only receives properties, not VkPhysicalDeviceFeatures. Leave optional
         // stage writes disabled rather than inferring them from descriptor limits alone.
         caps.SupportsVertexPipelineStoresAndAtomics = false;

MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.h

@@ -78,6 +78,18 @@ namespace MobileGL {
             // needs it, which includes every 64-bit vertex attribute: the attribute itself arrives
             // as 32-bit words, but the bitcast result and everything computed from it is Float64.
             Bool SupportsShaderFloat64 = false;
+            // VkPhysicalDeviceFeatures::imageCubeArray. Required before a
+            // VK_IMAGE_VIEW_TYPE_CUBE_ARRAY view may be created at all
+            // (VUID-VkImageViewCreateInfo-viewType-01004), which is every cube map array texture -
+            // both its sampled view and its full view.
+            Bool SupportsImageCubeArray = false;
+            // VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT on a 3D colour image, i.e. whether one z slice
+            // of a GL_TEXTURE_3D texture can be named by a 2D view and attached to a framebuffer.
+            // Vulkan 1.1 core, but per format+usage - this is an OPTIMISTIC summary probed over the
+            // common colour attachment formats. The authoritative answer is taken per format at
+            // image creation in VkTextureManager, which withdraws the flag and remembers the verdict
+            // when a driver refuses it.
+            Bool Supports2DArrayCompatible3DImages = false;
             // Storage-image descriptors are limited per stage by
             // maxPerStageDescriptorStorageImages, but writes/atomics outside compute additionally
             // require these core Vulkan features to be enabled on the logical device.

MobileGL/MG_Util/SelfTest/DriverPost.cpp

@@ -1419,6 +1419,36 @@ namespace MobileGL::MG_Util::SelfTest {
         } else {
             builder.Warn("dualSrcBlend", "unsupported; GL_SRC1_* dual-source blend factors hard-fail at draw");
         }
+        {
+            VkImageFormatProperties sliceProbe{};
+            const Bool sliceCapable =
+                vkGetPhysicalDeviceImageFormatProperties(
+                    physicalDevice, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TYPE_3D, VK_IMAGE_TILING_OPTIMAL,
+                    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
+                        VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
+                    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, &sliceProbe) == VK_SUCCESS;
+            if (sliceCapable) {
+                builder.Pass("2D-array-compatible 3D images",
+                             "supported for the common colour attachment formats (one z slice of a "
+                             "GL_TEXTURE_3D texture can be attached to a framebuffer and cleared and read "
+                             "back on its own; a format that refuses the flag is detected at image "
+                             "creation and declines per-slice attachment)");
+            } else {
+                builder.Warn("2D-array-compatible 3D images",
+                             "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT unavailable for colour attachments; "
+                             "glFramebufferTextureLayer on a GL_TEXTURE_3D texture is declined for every "
+                             "slice past the first");
+            }
+        }
+        if (features.imageCubeArray == VK_TRUE) {
+            builder.Pass("imageCubeArray",
+                         "GL_TEXTURE_CUBE_MAP_ARRAY textures get a Vulkan image and can be sampled and "
+                         "attached to a framebuffer per layer");
+        } else {
+            builder.Warn("imageCubeArray",
+                         "unsupported; a GL_TEXTURE_CUBE_MAP_ARRAY texture gets no image at all, so sampling "
+                         "one reads nothing and glFramebufferTextureLayer on one is declined");
+        }
         if (features.shaderFloat64 == VK_TRUE) {
             builder.Pass("shaderFloat64",
                          "GLSL double/dvec/dmat and 64-bit vertex attributes (glVertexAttribLFormat) supported");