[Fix] (DirectVulkan): submit pending work before growing a texture's mip chain

Sizing backings by their defined mip level count gave every level-0-only texture a
single-level image, and left growing it to the recreate-and-preserve path: the new
image is created and the old contents are carried over by a vkCmdCopyImage that
PreserveTextureContentsOnRecreate submits on its own command buffer and waits on
straight away.

Whatever the frame has already recorded into the old image has not been submitted
yet at that point, so that copy reads the texture as it stood before this frame's
writes. GenerateMipmap then descends the whole chain from a stale level 0, and the
composite pass that samples it renders a washed-out frame -
minecraft-1.21.4-fabric-iris-iterationt-in-world (Iris's mipmapped colour target,
the one texture in the trace that grows 1 -> 10 levels) came back at ssim 0.5699
against a 0.99 threshold.

This is the hazard the storage-usage upgrade already flushes for before its own
preserve-copy; growing the mip chain is simply the second trigger of that same
recreate, and it was added without the same ordering guarantee. Flush there too,
gated on a texture whose live image really does carry a short chain, so the submit
happens once per texture and only when a recreate is actually coming.

Keeps the single-level backing and its memory saving; ssim goes back to 0.9992.

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp

@@ -210,6 +210,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
             if (options & PixelFormatNormalizeOptionBit::NoDepthComponent32) {
                 reasons.push_back("GL_DEPTH_COMPONENT32 native probe failed on OpenGL ES");
             }
+            if (options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget) {
+                reasons.push_back("no three-channel multisample storage format on OpenGL ES");
+            }
+            if (options & PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget) {
+                reasons.push_back("EXT_render_snorm not supported");
+            }
 
             String reason;
             for (SizeT i = 0; i < reasons.size(); ++i) {
@@ -556,20 +562,50 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
 
                 const GLESProbeFormatInfo nativeInfo = BuildNativeProbeFormatInfo(requestedInternalFormat);
-                GLESProbeFormatInfo fallbackInfo;
-                const Bool hasForcedFallback =
-                    BuildFallbackProbeFormatInfo(requestedInternalFormat, forcedOptions, true, fallbackInfo);
-                if (!hasForcedFallback) {
-                    BuildFallbackProbeFormatInfo(requestedInternalFormat, driverOptions, false, fallbackInfo);
+                GLESProbeFormatInfo outerFallbackInfo;
+                const Bool outerHasForcedFallback =
+                    BuildFallbackProbeFormatInfo(requestedInternalFormat, forcedOptions, true, outerFallbackInfo);
+                if (!outerHasForcedFallback) {
+                    BuildFallbackProbeFormatInfo(requestedInternalFormat, driverOptions, false, outerFallbackInfo);
                 }
 
                 for (SizeT targetIndex = 0; targetIndex < kFormatCapabilityTextureTargetCount; ++targetIndex) {
                     const auto target = static_cast<TextureTarget>(targetIndex);
+                    // A multisample texture can only ever be rendered into, so its storage format
+                    // has to stay colour-renderable; the ordinary fallback for a three-channel
+                    // format is a three-channel one, which ES accepts as a texture but rejects as
+                    // multisample storage. Recompute the fallback per target so those formats get
+                    // widened here and nowhere else.
+                    Flags<PixelFormatNormalizeOptionBit> targetOptions;
+                    if (IsGLESProbeMultisampleTarget(target)) {
+                        targetOptions |= PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget;
+                        if (!capabilities.SupportsRenderSnorm || !capabilities.SupportsNorm16Texture) {
+                            targetOptions |= PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget;
+                        }
+                    }
+                    GLESProbeFormatInfo fallbackInfo = outerFallbackInfo;
+                    Bool hasForcedFallback = outerHasForcedFallback;
+                    if (targetOptions) {
+                        hasForcedFallback = BuildFallbackProbeFormatInfo(
+                            requestedInternalFormat, forcedOptions | targetOptions, true, fallbackInfo);
+                        if (!hasForcedFallback) {
+                            BuildFallbackProbeFormatInfo(requestedInternalFormat, driverOptions | targetOptions,
+                                                         false, fallbackInfo);
+                        }
+                    }
+
+                    // 1D, 1D-array and rectangle textures live on an ES target (see
+                    // TextureImpl::MapToBackendTextureTarget), so they have to be probed there too -
+                    // probing the desktop-only target itself always failed, which left those slots
+                    // of the cache empty and stopped any fallback format from being selected for
+                    // them (a GL_DEPTH_COMPONENT32 1D texture then got no storage at all).
+                    const TextureTarget probeTarget = TextureImpl::MapToBackendTextureTarget(target);
+
                     Bool shouldProbeFallback = hasForcedFallback;
                     if (!hasForcedFallback) {
                         Bool nativeRenderable = false;
                         const Bool nativeCreated =
-                            ProbeTexture(gl, target, nativeInfo.InternalFormat, nativeInfo.ImageFormat,
+                            ProbeTexture(gl, probeTarget, nativeInfo.InternalFormat, nativeInfo.ImageFormat,
                                          nativeInfo.ImageType, logicalFormat, &nativeRenderable);
                         if (nativeCreated) {
                             AddFullFormatCaps(cache, targetIndex, formatIndex,
@@ -584,7 +620,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     if (shouldProbeFallback && fallbackInfo.InternalFormat != GL_UNKNOWN_MGL) {
                         Bool fallbackRenderable = false;
                         const Bool fallbackCreated =
-                            ProbeTexture(gl, target, fallbackInfo.InternalFormat, fallbackInfo.ImageFormat,
+                            ProbeTexture(gl, probeTarget, fallbackInfo.InternalFormat, fallbackInfo.ImageFormat,
                                          fallbackInfo.ImageType, logicalFormat, &fallbackRenderable);
                         if (fallbackCreated) {
                             if (AddCaveatFormatCaps(cache, targetIndex, formatIndex,
@@ -600,8 +636,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
 
                 const SizeT renderbufferTargetIndex = GetRenderbufferFormatCapabilityTargetIndex();
-                Bool shouldProbeFallbackRenderbuffer = hasForcedFallback;
-                if (!hasForcedFallback) {
+                Bool shouldProbeFallbackRenderbuffer = outerHasForcedFallback;
+                if (!outerHasForcedFallback) {
                     const Bool nativeRenderbufferComplete =
                         ProbeRenderbuffer(gl, nativeInfo.InternalFormat, logicalFormat, false, 1);
                     if (nativeRenderbufferComplete) {
@@ -615,16 +651,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
                         shouldProbeFallbackRenderbuffer = true;
                     }
                 }
-                if (shouldProbeFallbackRenderbuffer && fallbackInfo.InternalFormat != GL_UNKNOWN_MGL &&
-                    ProbeRenderbuffer(gl, fallbackInfo.InternalFormat, logicalFormat, false, 1)) {
+                if (shouldProbeFallbackRenderbuffer && outerFallbackInfo.InternalFormat != GL_UNKNOWN_MGL &&
+                    ProbeRenderbuffer(gl, outerFallbackInfo.InternalFormat, logicalFormat, false, 1)) {
                     if (AddCaveatFormatCaps(cache, renderbufferTargetIndex, formatIndex,
                                             GetRenderbufferFeatureCaps(logicalFormat))) {
-                        LogGLESFormatCaveat(logicalFormat, renderbufferTargetIndex, fallbackInfo);
+                        LogGLESFormatCaveat(logicalFormat, renderbufferTargetIndex, outerFallbackInfo);
                     }
                     const Int maxSamples =
-                        GetGLESFormatMaxSamples(capabilities, logicalFormat, fallbackInfo.ImageFormat);
+                        GetGLESFormatMaxSamples(capabilities, logicalFormat, outerFallbackInfo.ImageFormat);
                     cache.SampleCounts[renderbufferTargetIndex][formatIndex] =
-                        ProbeRenderbufferSampleCounts(gl, fallbackInfo.InternalFormat, logicalFormat, maxSamples);
+                        ProbeRenderbufferSampleCounts(gl, outerFallbackInfo.InternalFormat, logicalFormat, maxSamples);
                 }
             }
         }

MobileGL/MG_Backend/DirectGLES/DirectGLES.cpp

@@ -738,6 +738,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
         static Bool g_hasSyncedRenderState = false;
         static RenderStateParameters g_syncedRenderStateParameters;
         static IntVec4 g_syncedBackendViewport = IntVec4(-1, -1, -1, -1);
+        // GLES starts with sRGB framebuffer encoding on, so the first sync always has to push the
+        // frontend's (desktop-GL default) disabled state down.
+        static Bool g_syncedSrgbFramebufferWrites = true;
         void SyncRenderState() {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
@@ -784,6 +787,19 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
 #undef SYNC_CAPABILITY
 
+            { // sRGB framebuffer writes. GLES core always encodes a write into an sRGB attachment,
+              // while GL_FRAMEBUFFER_SRGB is disabled by default in desktop GL and the frontend
+              // never turns it on, so the driver has to be told to write raw. Without this a render
+              // into an sRGB colour buffer comes back encoded once too often (the shader's own
+              // decode on the next fetch then leaves the value one conversion short).
+                const Bool srgbWrites = MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::FramebufferSrgb);
+                if (g_GLESCapabilities.SupportsSrgbWriteControl && srgbWrites != g_syncedSrgbFramebufferWrites) {
+                    srgbWrites ? g_GLESFuncs.glEnable(GL_FRAMEBUFFER_SRGB)
+                               : g_GLESFuncs.glDisable(GL_FRAMEBUFFER_SRGB);
+                    g_syncedSrgbFramebufferWrites = srgbWrites;
+                }
+            }
+
             { // Primitive restart. GLES core has only GL_PRIMITIVE_RESTART_FIXED_INDEX (fixed all-ones
               // value); both the fixed cap and the (fixed-valued) arbitrary GL_PRIMITIVE_RESTART map to
               // it. An arbitrary non-fixed restart index is rejected at draw time (see DrawElements).
@@ -1180,8 +1196,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
         auto& slot = MG_State::pGLContext->GetFramebufferBindingSlot(target);
-        if (slot.GetVersion() == FramebufferImpl::g_fboBindVersions[(SizeT)target]) return;
-
+        // No fast path on the binding slot's version. It is a 16-bit counter that only
+        // ForceBindCurrentFBO ever stamps here, so the comparison was against an arbitrarily old
+        // snapshot and any later slot version that happened to land on it - one wrap of the
+        // counter, or simply enough rebinds - read as "already bound" and left the driver on a
+        // completely different framebuffer. KHR-GL32.packed_pixels then read its gradient back
+        // out of the previous subtest's framebuffer.
+        //
+        // Skipping the work is BindFramebufferId's job anyway: it shadows the driver's own
+        // draw/read bindings and drops the glBindFramebuffer when the target already holds the id,
+        // which is where the cost actually is. What is left here is one registry lookup.
         const auto& currentFBO = slot.GetBoundObject();
         if (currentFBO && currentFBO != MG_Impl::GLImpl::FramebufferImpl::pDefaultFramebufferInfo->defaultFBO) {
             const auto& backendFBOIt = FramebufferImpl::g_backendFramebufferObjects.find(currentFBO.get());
@@ -2366,15 +2390,467 @@ namespace MobileGL::MG_Backend::DirectGLES {
         return resolved;
     }
 
+    // ---------------------------------------------------------------------------------
+    // Single-sample -> multisample blit ("replicate")
+    //
+    // Desktop GL replicates the source sample into every destination sample when the read
+    // framebuffer is single-sampled and the draw framebuffer is not. ES forbids the whole
+    // call ("INVALID_OPERATION if SAMPLE_BUFFERS for the draw framebuffer is greater than
+    // zero"), so the blit silently did nothing - KHR-GL3x.packed_depth_stencil.blit's
+    // second loop then read a destination that still held its clear values.
+    //
+    // Emulated by drawing a full-screen triangle into the multisample framebuffer: every
+    // pixel is fully covered, so every sample of it receives the same value, which is
+    // exactly what the replicate rule asks for. Depth comes from gl_FragDepth; stencil has
+    // no shader output on ES, so it is written one bit plane at a time with REPLACE and a
+    // discard for the pixels whose source bit is clear.
+    namespace ReplicateBlitImpl {
+        static Uint s_contextGeneration = ~0u;
+        static GLuint s_framebuffer = 0;
+        static GLuint s_texture = 0;
+        static GLenum s_textureFormat = 0;
+        static GLsizei s_textureWidth = 0;
+        static GLsizei s_textureHeight = 0;
+        static GLuint s_vertexArray = 0;
+        static GLuint s_depthProgram = 0;
+        static GLuint s_stencilProgram = 0;
+        static GLint s_depthUvTransform = -1;
+        static GLint s_stencilUvTransform = -1;
+        static GLint s_stencilBit = -1;
+        static Bool s_programsFailed = false;
+
+        static const char* const kVertexSource =
+            "#version 300 es\n"
+            "uniform vec4 uUvTransform;\n"
+            "out vec2 vUv;\n"
+            "void main() {\n"
+            "    vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));\n"
+            "    gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);\n"
+            "    vUv = p * uUvTransform.xy + uUvTransform.zw;\n"
+            "}\n";
+
+        static const char* const kDepthFragmentSource =
+            "#version 300 es\n"
+            "precision highp float;\n"
+            "precision highp sampler2D;\n"
+            "uniform sampler2D uSource;\n"
+            "in vec2 vUv;\n"
+            "void main() {\n"
+            "    gl_FragDepth = texture(uSource, vUv).r;\n"
+            "}\n";
+
+        static const char* const kStencilFragmentSource =
+            "#version 300 es\n"
+            "precision highp float;\n"
+            "precision highp usampler2D;\n"
+            "uniform usampler2D uSource;\n"
+            "uniform uint uBit;\n"
+            "in vec2 vUv;\n"
+            "void main() {\n"
+            "    if ((texture(uSource, vUv).r & uBit) == 0u) discard;\n"
+            "}\n";
+
+        static GLuint BuildProgram(const char* fragmentSource) {
+            const GLuint vertexShader = g_GLESFuncs.glCreateShader(GL_VERTEX_SHADER);
+            const GLuint fragmentShader = g_GLESFuncs.glCreateShader(GL_FRAGMENT_SHADER);
+            if (vertexShader == 0 || fragmentShader == 0) {
+                return 0;
+            }
+            g_GLESFuncs.glShaderSource(vertexShader, 1, &kVertexSource, nullptr);
+            g_GLESFuncs.glCompileShader(vertexShader);
+            g_GLESFuncs.glShaderSource(fragmentShader, 1, &fragmentSource, nullptr);
+            g_GLESFuncs.glCompileShader(fragmentShader);
+
+            const GLuint program = g_GLESFuncs.glCreateProgram();
+            GLint linked = GL_FALSE;
+            if (program != 0) {
+                g_GLESFuncs.glAttachShader(program, vertexShader);
+                g_GLESFuncs.glAttachShader(program, fragmentShader);
+                g_GLESFuncs.glLinkProgram(program);
+                g_GLESFuncs.glGetProgramiv(program, GL_LINK_STATUS, &linked);
+            }
+            g_GLESFuncs.glDeleteShader(vertexShader);
+            g_GLESFuncs.glDeleteShader(fragmentShader);
+            if (linked != GL_TRUE) {
+                if (program != 0) g_GLESFuncs.glDeleteProgram(program);
+                return 0;
+            }
+            return program;
+        }
+
+        static Bool EnsureResources() {
+            if (s_contextGeneration != TextureImpl::g_textureContextGeneration) {
+                // The ids belonged to a dead context; the context reclaimed them with it.
+                s_framebuffer = 0;
+                s_texture = 0;
+                s_textureFormat = 0;
+                s_textureWidth = 0;
+                s_textureHeight = 0;
+                s_vertexArray = 0;
+                s_depthProgram = 0;
+                s_stencilProgram = 0;
+                s_programsFailed = false;
+                s_contextGeneration = TextureImpl::g_textureContextGeneration;
+            }
+            if (s_programsFailed) {
+                return false;
+            }
+            if (s_depthProgram == 0) {
+                s_depthProgram = BuildProgram(kDepthFragmentSource);
+                s_stencilProgram = BuildProgram(kStencilFragmentSource);
+                if (s_depthProgram == 0 || s_stencilProgram == 0) {
+                    s_programsFailed = true;
+                    MGLOG_E("BlitFramebuffer: could not build the multisample replicate programs");
+                    return false;
+                }
+                s_depthUvTransform = g_GLESFuncs.glGetUniformLocation(s_depthProgram, "uUvTransform");
+                s_stencilUvTransform = g_GLESFuncs.glGetUniformLocation(s_stencilProgram, "uUvTransform");
+                s_stencilBit = g_GLESFuncs.glGetUniformLocation(s_stencilProgram, "uBit");
+            }
+            if (s_framebuffer == 0) {
+                g_GLESFuncs.glGenFramebuffers(1, &s_framebuffer);
+                if (s_framebuffer == 0) return false;
+            }
+            if (s_vertexArray == 0) {
+                g_GLESFuncs.glGenVertexArrays(1, &s_vertexArray);
+                if (s_vertexArray == 0) return false;
+            }
+            return true;
+        }
+
+        // Sized internal format of the read framebuffer's depth (or, failing that, stencil)
+        // attachment. The scratch copy has to use the very same one: ES rejects a
+        // depth/stencil blit between differing formats even when both sides are single-sampled.
+        static GLenum QueryReadDepthStencilFormat(GLenum* outAttachment) {
+            const GLenum attachments[] = {GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT};
+            for (const GLenum attachment : attachments) {
+                GLint objectType = 0;
+                GLint objectName = 0;
+                g_GLESFuncs.glGetFramebufferAttachmentParameteriv(GL_READ_FRAMEBUFFER, attachment,
+                                                                  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &objectType);
+                g_GLESFuncs.glGetFramebufferAttachmentParameteriv(GL_READ_FRAMEBUFFER, attachment,
+                                                                  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &objectName);
+                if (objectName == 0) {
+                    continue;
+                }
+                GLint internalFormat = 0;
+                if (objectType == GL_RENDERBUFFER) {
+                    GLint previous = 0;
+                    g_GLESFuncs.glGetIntegerv(GL_RENDERBUFFER_BINDING, &previous);
+                    g_GLESFuncs.glBindRenderbuffer(GL_RENDERBUFFER, static_cast<GLuint>(objectName));
+                    g_GLESFuncs.glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_INTERNAL_FORMAT,
+                                                             &internalFormat);
+                    g_GLESFuncs.glBindRenderbuffer(GL_RENDERBUFFER, static_cast<GLuint>(previous));
+                } else if (objectType == GL_TEXTURE) {
+                    GLint previous = 0;
+                    g_GLESFuncs.glGetIntegerv(GL_TEXTURE_BINDING_2D, &previous);
+                    g_GLESFuncs.glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(objectName));
+                    g_GLESFuncs.glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT,
+                                                         &internalFormat);
+                    g_GLESFuncs.glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(previous));
+                }
+                if (internalFormat != 0) {
+                    if (outAttachment) *outAttachment = attachment;
+                    return static_cast<GLenum>(internalFormat);
+                }
+            }
+            return 0;
+        }
+
+        static Bool FormatHasDepth(GLenum internalFormat) {
+            return internalFormat == GL_DEPTH_COMPONENT16 || internalFormat == GL_DEPTH_COMPONENT24 ||
+                   internalFormat == GL_DEPTH_COMPONENT32F || internalFormat == GL_DEPTH24_STENCIL8 ||
+                   internalFormat == GL_DEPTH32F_STENCIL8;
+        }
+
+        static Bool FormatHasStencil(GLenum internalFormat) {
+            return internalFormat == GL_DEPTH24_STENCIL8 || internalFormat == GL_DEPTH32F_STENCIL8 ||
+                   internalFormat == GL_STENCIL_INDEX8;
+        }
+
+        static GLenum ScratchAttachmentFor(GLenum internalFormat) {
+            if (FormatHasDepth(internalFormat) && FormatHasStencil(internalFormat)) {
+                return GL_DEPTH_STENCIL_ATTACHMENT;
+            }
+            return FormatHasDepth(internalFormat) ? GL_DEPTH_ATTACHMENT : GL_STENCIL_ATTACHMENT;
+        }
+    } // namespace ReplicateBlitImpl
+
+    // Returns true when the request was serviced (or is not this fallback's business).
+    static Bool ReplicateBlitIntoMultisampleDraw(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0,
+                                                 GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask) {
+        using namespace ReplicateBlitImpl;
+        if ((mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) == 0) {
+            return false;
+        }
+        if (!EnsureResources()) {
+            return false;
+        }
+
+        const GLsizei srcWidth = static_cast<GLsizei>(std::abs(srcX1 - srcX0));
+        const GLsizei srcHeight = static_cast<GLsizei>(std::abs(srcY1 - srcY0));
+        const GLsizei dstWidth = static_cast<GLsizei>(std::abs(dstX1 - dstX0));
+        const GLsizei dstHeight = static_cast<GLsizei>(std::abs(dstY1 - dstY0));
+        if (srcWidth <= 0 || srcHeight <= 0 || dstWidth <= 0 || dstHeight <= 0) {
+            return false;
+        }
+
+        GLenum readAttachment = GL_DEPTH_ATTACHMENT;
+        const GLenum sourceFormat = QueryReadDepthStencilFormat(&readAttachment);
+        if (sourceFormat == 0) {
+            return false;
+        }
+        const Bool wantDepth = (mask & GL_DEPTH_BUFFER_BIT) != 0 && FormatHasDepth(sourceFormat);
+        const Bool wantStencil = (mask & GL_STENCIL_BUFFER_BIT) != 0 && FormatHasStencil(sourceFormat);
+        if (!wantDepth && !wantStencil) {
+            return false;
+        }
+        // Sampling the stencil half of a packed texture goes through
+        // GL_DEPTH_STENCIL_TEXTURE_MODE, which is ES 3.1 state; on an older driver the pname
+        // would just raise GL_INVALID_ENUM and the shader would read depth bits as stencil.
+        const Bool supportsStencilTextureMode = g_GLESCapabilities.GLESVersion.Major > 3 ||
+                                                (g_GLESCapabilities.GLESVersion.Major == 3 &&
+                                                 g_GLESCapabilities.GLESVersion.Minor >= 1);
+        if (wantStencil && !supportsStencilTextureMode) {
+            return false;
+        }
+
+        GLint previousDraw = 0;
+        GLint previousRead = 0;
+        g_GLESFuncs.glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &previousDraw);
+        g_GLESFuncs.glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &previousRead);
+        GLint previousActiveTexture = 0;
+        g_GLESFuncs.glGetIntegerv(GL_ACTIVE_TEXTURE, &previousActiveTexture);
+
+        // Copy the source rectangle into a scratch texture of its own format: both sides of
+        // that blit are single-sampled, which ES does allow.
+        Bool ok = true;
+        if (s_texture == 0 || s_textureFormat != sourceFormat || s_textureWidth < srcWidth ||
+            s_textureHeight < srcHeight) {
+            if (s_texture != 0) {
+                g_GLESFuncs.glDeleteTextures(1, &s_texture); // immutable storage cannot be resized
+                s_texture = 0;
+            }
+            s_textureWidth = std::max(s_textureWidth, srcWidth);
+            s_textureHeight = std::max(s_textureHeight, srcHeight);
+            g_GLESFuncs.glGenTextures(1, &s_texture);
+            if (s_texture == 0) {
+                ok = false;
+            } else {
+                g_GLESFuncs.glActiveTexture(GL_TEXTURE0);
+                g_GLESFuncs.glBindTexture(GL_TEXTURE_2D, s_texture);
+                DrainBlitErrors();
+                g_GLESFuncs.glTexStorage2D(GL_TEXTURE_2D, 1, sourceFormat, s_textureWidth, s_textureHeight);
+                ok = g_GLESFuncs.glGetError() == GL_NO_ERROR;
+                g_GLESFuncs.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+                g_GLESFuncs.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+                g_GLESFuncs.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+                g_GLESFuncs.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+                s_textureFormat = ok ? sourceFormat : 0;
+            }
+        }
+
+        if (ok) {
+            g_GLESFuncs.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, s_framebuffer);
+            g_GLESFuncs.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, ScratchAttachmentFor(sourceFormat), GL_TEXTURE_2D,
+                                               s_texture, 0);
+            ok = g_GLESFuncs.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE;
+        }
+        if (ok) {
+            const GLint left = std::min(srcX0, srcX1);
+            const GLint bottom = std::min(srcY0, srcY1);
+            DrainBlitErrors();
+            g_GLESFuncs.glBlitFramebuffer(left, bottom, left + srcWidth, bottom + srcHeight, 0, 0, srcWidth, srcHeight,
+                                          mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT), GL_NEAREST);
+            ok = g_GLESFuncs.glGetError() == GL_NO_ERROR;
+        }
+
+        g_GLESFuncs.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, static_cast<GLuint>(previousDraw));
+        g_GLESFuncs.glBindFramebuffer(GL_READ_FRAMEBUFFER, static_cast<GLuint>(previousRead));
+        FramebufferImpl::InvalidateFramebufferBindingCache();
+        if (!ok) {
+            g_GLESFuncs.glActiveTexture(static_cast<GLenum>(previousActiveTexture));
+            MGLOG_E("BlitFramebuffer: could not stage the source for the multisample replicate");
+            return false;
+        }
+
+        // Everything below draws into the caller's multisample draw framebuffer, so the
+        // pipeline state it depends on is saved and put back byte for byte - the sync layer's
+        // shadow of the driver state has to stay true.
+        GLint previousProgram = 0;
+        GLint previousVertexArray = 0;
+        GLint previousTexture = 0;
+        GLint previousViewport[4] = {0, 0, 0, 0};
+        GLint previousScissorBox[4] = {0, 0, 0, 0};
+        GLboolean previousColorMask[4] = {GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE};
+        GLint previousDepthFunc = GL_LESS;
+        GLboolean previousDepthMask = GL_TRUE;
+        GLint previousStencilFunc[2] = {GL_ALWAYS, GL_ALWAYS};
+        GLint previousStencilRef[2] = {0, 0};
+        GLint previousStencilValueMask[2] = {~0, ~0};
+        GLint previousStencilWriteMask[2] = {~0, ~0};
+        GLint previousStencilFail[2] = {GL_KEEP, GL_KEEP};
+        GLint previousStencilDepthFail[2] = {GL_KEEP, GL_KEEP};
+        GLint previousStencilPass[2] = {GL_KEEP, GL_KEEP};
+        g_GLESFuncs.glGetIntegerv(GL_CURRENT_PROGRAM, &previousProgram);
+        g_GLESFuncs.glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &previousVertexArray);
+        g_GLESFuncs.glGetIntegerv(GL_TEXTURE_BINDING_2D, &previousTexture);
+        g_GLESFuncs.glGetIntegerv(GL_VIEWPORT, previousViewport);
+        g_GLESFuncs.glGetIntegerv(GL_SCISSOR_BOX, previousScissorBox);
+        g_GLESFuncs.glGetBooleanv(GL_COLOR_WRITEMASK, previousColorMask);
+        g_GLESFuncs.glGetIntegerv(GL_DEPTH_FUNC, &previousDepthFunc);
+        g_GLESFuncs.glGetBooleanv(GL_DEPTH_WRITEMASK, &previousDepthMask);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_FUNC, &previousStencilFunc[0]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_BACK_FUNC, &previousStencilFunc[1]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_REF, &previousStencilRef[0]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_BACK_REF, &previousStencilRef[1]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_VALUE_MASK, &previousStencilValueMask[0]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, &previousStencilValueMask[1]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_WRITEMASK, &previousStencilWriteMask[0]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_BACK_WRITEMASK, &previousStencilWriteMask[1]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_FAIL, &previousStencilFail[0]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_BACK_FAIL, &previousStencilFail[1]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &previousStencilDepthFail[0]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, &previousStencilDepthFail[1]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &previousStencilPass[0]);
+        g_GLESFuncs.glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, &previousStencilPass[1]);
+
+        struct CapabilityState {
+            GLenum cap;
+            GLboolean enabled;
+        };
+        CapabilityState capabilities[] = {
+            {GL_SCISSOR_TEST, GL_FALSE},     {GL_DEPTH_TEST, GL_FALSE},
+            {GL_STENCIL_TEST, GL_FALSE},     {GL_CULL_FACE, GL_FALSE},
+            {GL_BLEND, GL_FALSE},            {GL_RASTERIZER_DISCARD, GL_FALSE},
+            {GL_POLYGON_OFFSET_FILL, GL_FALSE}, {GL_SAMPLE_ALPHA_TO_COVERAGE, GL_FALSE},
+            {GL_SAMPLE_COVERAGE, GL_FALSE},  {GL_SAMPLE_MASK, GL_FALSE},
+        };
+        for (CapabilityState& capability : capabilities) {
+            capability.enabled = g_GLESFuncs.glIsEnabled(capability.cap);
+        }
+
+        const GLint dstLeft = std::min(dstX0, dstX1);
+        const GLint dstBottom = std::min(dstY0, dstY1);
+        const Bool mirrorX = (srcX1 > srcX0) != (dstX1 > dstX0);
+        const Bool mirrorY = (srcY1 > srcY0) != (dstY1 > dstY0);
+        // The scratch holds the source rectangle at its origin, so the texture is larger than
+        // the copied region: scale the [0,1] quad coordinates down to the region it occupies.
+        const Float uvScaleX = static_cast<Float>(srcWidth) / static_cast<Float>(s_textureWidth);
+        const Float uvScaleY = static_cast<Float>(srcHeight) / static_cast<Float>(s_textureHeight);
+        const Float uvTransform[4] = {mirrorX ? -uvScaleX : uvScaleX, mirrorY ? -uvScaleY : uvScaleY,
+                                      mirrorX ? uvScaleX : 0.0f, mirrorY ? uvScaleY : 0.0f};
+
+        g_GLESFuncs.glBindVertexArray(s_vertexArray);
+        g_GLESFuncs.glActiveTexture(GL_TEXTURE0);
+        g_GLESFuncs.glBindTexture(GL_TEXTURE_2D, s_texture);
+        g_GLESFuncs.glViewport(dstLeft, dstBottom, dstWidth, dstHeight);
+        g_GLESFuncs.glScissor(dstLeft, dstBottom, dstWidth, dstHeight);
+        g_GLESFuncs.glEnable(GL_SCISSOR_TEST);
+        g_GLESFuncs.glDisable(GL_CULL_FACE);
+        g_GLESFuncs.glDisable(GL_BLEND);
+        g_GLESFuncs.glDisable(GL_RASTERIZER_DISCARD);
+        g_GLESFuncs.glDisable(GL_POLYGON_OFFSET_FILL);
+        g_GLESFuncs.glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
+        g_GLESFuncs.glDisable(GL_SAMPLE_COVERAGE);
+        g_GLESFuncs.glDisable(GL_SAMPLE_MASK);
+        g_GLESFuncs.glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+        DrainBlitErrors();
+
+        if (wantDepth) {
+            if (FormatHasStencil(sourceFormat)) {
+                g_GLESFuncs.glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_DEPTH_COMPONENT);
+            }
+            g_GLESFuncs.glUseProgram(s_depthProgram);
+            g_GLESFuncs.glUniform4f(s_depthUvTransform, uvTransform[0], uvTransform[1], uvTransform[2],
+                                    uvTransform[3]);
+            g_GLESFuncs.glEnable(GL_DEPTH_TEST);
+            g_GLESFuncs.glDepthFunc(GL_ALWAYS);
+            g_GLESFuncs.glDepthMask(GL_TRUE);
+            g_GLESFuncs.glDisable(GL_STENCIL_TEST);
+            g_GLESFuncs.glDrawArrays(GL_TRIANGLES, 0, 3);
+        }
+
+        if (wantStencil) {
+            g_GLESFuncs.glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_STENCIL_INDEX);
+            g_GLESFuncs.glUseProgram(s_stencilProgram);
+            g_GLESFuncs.glUniform4f(s_stencilUvTransform, uvTransform[0], uvTransform[1], uvTransform[2],
+                                    uvTransform[3]);
+            g_GLESFuncs.glDisable(GL_DEPTH_TEST);
+            g_GLESFuncs.glDepthMask(GL_FALSE);
+            g_GLESFuncs.glEnable(GL_STENCIL_TEST);
+            // The bit planes are written by ORing in the set bits, so the destination has to
+            // start from zero. The blit overwrites the whole rectangle anyway, and the scissor
+            // keeps the clear inside it.
+            const GLint zero = 0;
+            g_GLESFuncs.glStencilMask(0xFFu);
+            g_GLESFuncs.glClearBufferiv(GL_STENCIL, 0, &zero);
+            g_GLESFuncs.glStencilFunc(GL_ALWAYS, 0xFF, 0xFFu);
+            g_GLESFuncs.glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+            for (Uint bit = 0; bit < 8; ++bit) {
+                g_GLESFuncs.glStencilMask(1u << bit);
+                g_GLESFuncs.glUniform1ui(s_stencilBit, 1u << bit);
+                g_GLESFuncs.glDrawArrays(GL_TRIANGLES, 0, 3);
+            }
+            g_GLESFuncs.glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_DEPTH_COMPONENT);
+        }
+
+        const Bool replicated = g_GLESFuncs.glGetError() == GL_NO_ERROR;
+
+        g_GLESFuncs.glUseProgram(static_cast<GLuint>(previousProgram));
+        g_GLESFuncs.glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(previousTexture));
+        g_GLESFuncs.glActiveTexture(static_cast<GLenum>(previousActiveTexture));
+        g_GLESFuncs.glBindVertexArray(static_cast<GLuint>(previousVertexArray));
+        g_GLESFuncs.glViewport(previousViewport[0], previousViewport[1], previousViewport[2], previousViewport[3]);
+        g_GLESFuncs.glScissor(previousScissorBox[0], previousScissorBox[1], previousScissorBox[2],
+                              previousScissorBox[3]);
+        g_GLESFuncs.glColorMask(previousColorMask[0], previousColorMask[1], previousColorMask[2],
+                                previousColorMask[3]);
+        g_GLESFuncs.glDepthFunc(static_cast<GLenum>(previousDepthFunc));
+        g_GLESFuncs.glDepthMask(previousDepthMask);
+        const GLenum faces[2] = {GL_FRONT, GL_BACK};
+        for (SizeT face = 0; face < 2; ++face) {
+            g_GLESFuncs.glStencilFuncSeparate(faces[face], static_cast<GLenum>(previousStencilFunc[face]),
+                                              previousStencilRef[face],
+                                              static_cast<GLuint>(previousStencilValueMask[face]));
+            g_GLESFuncs.glStencilOpSeparate(faces[face], static_cast<GLenum>(previousStencilFail[face]),
+                                            static_cast<GLenum>(previousStencilDepthFail[face]),
+                                            static_cast<GLenum>(previousStencilPass[face]));
+            g_GLESFuncs.glStencilMaskSeparate(faces[face], static_cast<GLuint>(previousStencilWriteMask[face]));
+        }
+        for (const CapabilityState& capability : capabilities) {
+            if (capability.enabled) {
+                g_GLESFuncs.glEnable(capability.cap);
+            } else {
+                g_GLESFuncs.glDisable(capability.cap);
+            }
+        }
+        // The per-draw-buffer colour masks are not covered by the non-indexed glColorMask above.
+        for (Uint index = 0; index < MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS; ++index) {
+            const BoolVec4& colorMask = RenderStateImpl::g_syncedRenderStateParameters.ColorMasks[index];
+            if (g_GLESFuncs.glColorMaski) {
+                g_GLESFuncs.glColorMaski(index, colorMask.x() ? GL_TRUE : GL_FALSE, colorMask.y() ? GL_TRUE : GL_FALSE,
+                                         colorMask.z() ? GL_TRUE : GL_FALSE, colorMask.w() ? GL_TRUE : GL_FALSE);
+            }
+        }
+        DrainBlitErrors();
+
+        if (!replicated) {
+            MGLOG_E("BlitFramebuffer: multisample replicate fallback failed");
+        }
+        return replicated;
+    }
+
     static void IssueBlitWithResolveFallback(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0,
                                              GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
         DrainBlitErrors();
         g_GLESFuncs.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-        if (g_GLESFuncs.glGetError() == GL_NO_ERROR || (mask & GL_COLOR_BUFFER_BIT) == 0) {
+        if (g_GLESFuncs.glGetError() == GL_NO_ERROR) {
             return;
         }
-        // Only the multisample-resolve format mismatch is worth a second attempt; a
-        // source that is not multisampled would have hit the same restriction on desktop.
+        // Two ES restrictions desktop GL does not have are worth a second attempt: a
+        // multisample resolve that also converts colour format, and any blit into a
+        // multisample draw framebuffer. Both need to know how the two sides are sampled.
         GLint readSamples = 0;
         GLint drawSamples = 0;
         {
@@ -2390,7 +2866,17 @@ namespace MobileGL::MG_Backend::DirectGLES {
             g_GLESFuncs.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, static_cast<GLuint>(previousDraw));
             FramebufferImpl::InvalidateFramebufferBindingCache();
         }
-        if (readSamples <= 0 || drawSamples > 0) {
+        if (readSamples <= 0 && drawSamples > 0) {
+            // Single-sample source into a multisample destination: ES rejects the call
+            // outright, desktop GL replicates the source sample into every destination one.
+            if (ReplicateBlitIntoMultisampleDraw(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask)) {
+                if ((mask & GL_COLOR_BUFFER_BIT) != 0) {
+                    MGLOG_E("BlitFramebuffer: colour replicate into a multisample draw framebuffer is not emulated");
+                }
+            }
+            return;
+        }
+        if (readSamples <= 0 || drawSamples > 0 || (mask & GL_COLOR_BUFFER_BIT) == 0) {
             return;
         }
         if (ResolveThenBlit(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, filter) &&

MobileGL/MG_Backend/DirectGLES/Managers.cpp

@@ -2405,7 +2405,19 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 MGLOG_D("%s(%s:%d) ES error %s", func, file, line, MG_Util::ConvertGLEnumToString(err).c_str());
             });
 
-            const auto& swizzleParams = stateTextureObject->GetAllSwizzleParams();
+            // A three-channel format widened to four for a multisample target (see
+            // NormalizePixelFormat) gains an alpha channel the frontend format does not have, and
+            // whatever the draw that filled it wrote there is not what GL would report: a format
+            // without alpha reads back as 1.0. Answer the ALPHA swizzle source with ONE so the
+            // promotion stays invisible, composed with the swizzle the application asked for.
+            Vec4<TextureSwizzleParam> swizzleParams = stateTextureObject->GetAllSwizzleParams();
+            if (TextureImpl::BackendTextureFormatAddsAlpha(stateTextureObject->GetFormat(), targetInternal)) {
+                for (SizeT channel = 0; channel < 4; ++channel) {
+                    if (swizzleParams[channel] == TextureSwizzleParam::Alpha) {
+                        swizzleParams[channel] = TextureSwizzleParam::One;
+                    }
+                }
+            }
             if (swizzleParams != m_cacheSwizzleParams) {
 #define SYNC_TEX_SWIZZLE_PARAM_IF_CHANGED(func, glEnum)                                                                \
     if (m_cacheSwizzleParams.func != swizzleParams.func) {                                                             \

MobileGL/MG_Backend/DirectGLES/Utils.cpp

@@ -48,15 +48,40 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return options;
         }
 
-        Flags<PixelFormatNormalizeOptionBit> GetRuntimeFallbackNormalizeOptions(GLenum requestedInternalFormat) {
+        Flags<PixelFormatNormalizeOptionBit>
+        GetRuntimeFallbackNormalizeOptions(GLenum requestedInternalFormat,
+                                           Flags<PixelFormatNormalizeOptionBit> extraOptions) {
             using namespace MG_Util::TextureFormatProcessor;
-            const Flags<PixelFormatNormalizeOptionBit> forcedOptions =
-                GetApplicablePixelFormatNormalizeOptions(requestedInternalFormat, GetForcedPixelFormatNormalizeOptions());
+            const Flags<PixelFormatNormalizeOptionBit> forcedOptions = GetApplicablePixelFormatNormalizeOptions(
+                requestedInternalFormat, GetForcedPixelFormatNormalizeOptions() | extraOptions);
             if (forcedOptions) {
                 return forcedOptions;
             }
-            return GetApplicablePixelFormatNormalizeOptions(requestedInternalFormat,
-                                                            GetDriverPixelFormatNormalizeOptions());
+            return GetApplicablePixelFormatNormalizeOptions(
+                requestedInternalFormat, GetDriverPixelFormatNormalizeOptions() | extraOptions);
+        }
+
+        // Multisample textures can only ever be rendered into, never uploaded to, so a fallback
+        // format for them has to stay colour-renderable - a three-channel float fallback is a legal
+        // ES texture format but not a legal multisample storage format. Widening to four channels
+        // is safe here precisely because there is no transfer path that would have to expand
+        // three-channel client data, and the alpha the draw writes for a three-channel source is
+        // already the 1.0 the frontend format implies.
+        Bool TargetRequiresRenderableFormat(SizeT targetIndex) {
+            return targetIndex == static_cast<SizeT>(TextureTarget::Texture2DMultisample) ||
+                   targetIndex == static_cast<SizeT>(TextureTarget::Texture2DMultisampleArray);
+        }
+
+        Flags<PixelFormatNormalizeOptionBit> GetRenderTargetNormalizeOptions(SizeT targetIndex) {
+            Flags<PixelFormatNormalizeOptionBit> options;
+            if (!TargetRequiresRenderableFormat(targetIndex)) {
+                return options;
+            }
+            options |= PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget;
+            if (!g_GLESCapabilities.SupportsRenderSnorm || !g_GLESCapabilities.SupportsNorm16Texture) {
+                options |= PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget;
+            }
+            return options;
         }
 
         Bool HasCachedFormatCapability(TextureInternalFormat internalFormat,
@@ -116,7 +141,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
             const GLenum requestedInternalFormat = MG_Util::ConvertTextureInternalFormatToGLEnum(internalFormat);
             Flags<PixelFormatNormalizeOptionBit> options;
             if (!pActiveBackendObject || ShouldUseCaveatFormat(internalFormat, targetIndex)) {
-                options = GetRuntimeFallbackNormalizeOptions(requestedInternalFormat);
+                options = GetRuntimeFallbackNormalizeOptions(requestedInternalFormat,
+                                                             GetRenderTargetNormalizeOptions(targetIndex));
             }
             NormalizePixelFormat(requestedInternalFormat, options, outInternalFormat, outFormat, outType);
         }
@@ -151,6 +177,22 @@ namespace MobileGL::MG_Backend::DirectGLES {
         Bool ShouldUseCaveatRenderbufferFormat(TextureInternalFormat internalFormat) {
             return ShouldUseCaveatFormat(internalFormat, GetRenderbufferFormatCapabilityTargetIndex());
         }
+
+        Bool BackendTextureFormatAddsAlpha(TextureInternalFormat internalFormat, TextureTarget target) {
+            const SizeT targetIndex =
+                target == TextureTarget::Unknown ? kFormatCapabilityTargetCount : GetFormatCapabilityTargetIndex(target);
+            if (!TargetRequiresRenderableFormat(targetIndex)) {
+                return false;
+            }
+            if (pActiveBackendObject && !ShouldUseCaveatFormat(internalFormat, targetIndex)) {
+                return false;
+            }
+            const GLenum requestedInternalFormat = MG_Util::ConvertTextureInternalFormatToGLEnum(internalFormat);
+            const Flags<PixelFormatNormalizeOptionBit> options =
+                GetRuntimeFallbackNormalizeOptions(requestedInternalFormat,
+                                                   GetRenderTargetNormalizeOptions(targetIndex));
+            return static_cast<Bool>(options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget);
+        }
     } // namespace TextureImpl
     namespace PrgramImpl {
         String ProcessOutColorLocations(const String& glslCode) {

MobileGL/MG_Backend/DirectGLES/Utils.h

@@ -40,6 +40,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
         void GenerateRenderbufferFormatInfo(TextureInternalFormat internalFormat, GLenum* outInternalFormat,
                                             GLenum* outFormat, GLenum* outType);
         Bool ShouldUseCaveatTextureFormat(TextureInternalFormat internalFormat, TextureTarget target);
+
+        // True when the format the texture is actually created with has an alpha channel the
+        // frontend format does not (the three-channel multisample widening). GL reads such a
+        // channel back as 1.0, so any swizzle source of ALPHA has to be answered with ONE.
+        Bool BackendTextureFormatAddsAlpha(TextureInternalFormat internalFormat, TextureTarget target);
         Bool ShouldUseCaveatRenderbufferFormat(TextureInternalFormat internalFormat);
     } // namespace TextureImpl
 

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.cpp

@@ -1246,6 +1246,20 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                !it->second.storageUsageResolved;
     }
 
+    Bool VkTextureManager::NeedsMipChainGrowth(MG_State::GLState::ITextureObject& texture) const {
+        const TextureIdentity identity = MakeTextureIdentity(&texture);
+        const auto it = m_textureResources.find(identity);
+        // No image yet: the first sync sizes the chain from the levels the texture already
+        // defines, so nothing is recreated and there is nothing to order against.
+        if (it == m_textureResources.end() || it->second.image == VK_NULL_HANDLE) {
+            return false;
+        }
+        const TextureResource& resource = it->second;
+        const IntVec3 extent = {static_cast<Int>(resource.extent.width), static_cast<Int>(resource.extent.height),
+                                static_cast<Int>(resource.depth)};
+        return resource.mipLevels < ComputeFullMipLevelCount(extent);
+    }
+
     Bool VkTextureManager::NeedsStorageImagePreparation(MG_State::GLState::ITextureObject& texture) const {
         const TextureIdentity identity = MakeTextureIdentity(&texture);
         const auto it = m_textureResources.find(identity);

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.h

@@ -350,6 +350,10 @@ public:
     // will recreate it with STORAGE usage and copy the old contents forward. Callers use this to
     // submit their pending recording first, so that copy cannot read pre-flush content.
     Bool NeedsStorageUsageUpgrade(MG_State::GLState::ITextureObject& texture) const;
+    // The same ordering question for the other recreate-and-preserve trigger: true when this
+    // texture's live image carries a shorter mip chain than a full one, so defining the missing
+    // levels recreates it and copies the old contents forward.
+    Bool NeedsMipChainGrowth(MG_State::GLState::ITextureObject& texture) const;
     // Non-mutating probe for the per-draw storage-image fast path: true when preparing this
     // texture as a storage image may need work that is illegal inside a render pass (resource
     // creation, dirty-content upload, or a layout transition to GENERAL). Unknown state reports

MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.cpp

@@ -7793,6 +7793,20 @@ void main() {
 
         const Uint32 baseMipLevel = std::min(static_cast<Uint32>(texture->GetLevelRange().x()), currentMipLevelCount - 1);
 
+        // A texture that has only ever defined level 0 carries a single-level backing, so defining
+        // the rest of the chain below recreates the image and carries the old contents over with a
+        // copy that is submitted and waited on out of band. Anything this frame has already
+        // recorded into the old image is not submitted yet, so that copy would read pre-flush
+        // content and every generated level would descend from a stale level 0 - the same hazard
+        // the storage-usage upgrade flushes for before its own preserve-copy.
+        if (m_textureManager->NeedsMipChainGrowth(*texture) && HasPendingRecordedWork()) {
+            if (FlushPendingCommands()) {
+                // Fresh command buffer: the sampled-descriptor-set memo describes bindings that
+                // only existed in the retired one.
+                m_lastSampledSetValid = false;
+            }
+        }
+
         auto& frame = m_frameContext.GetCurrent();
         if (!frame.isCommandRecording) {
             m_frameContext.BeginCommandRecording();

MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp

@@ -101,7 +101,14 @@ namespace MobileGL::MG_Impl::GLImpl {
         // shared-exponent, SNORM, three-channel norm16/float32/sRGB and three-channel integer formats.
         // Desktop GL treats those as texture-only too (not in the GL 3.3 required-renderable list), so
         // reporting GL_FRAMEBUFFER_UNSUPPORTED for them is legal.
-        Bool IsColorInternalFormatRenderable(TextureInternalFormat format) {
+        //
+        // `capabilityTargetIndex` is the row of the cache the attachment actually lives in;
+        // kFormatCapabilityTargetCount asks about the format in general. Asking per target matters
+        // because a capability recorded for one of them says nothing about the others: DirectGLES
+        // widens three-channel formats to four channels to keep them renderable as *multisample*
+        // storage, and a format that survives only through that substitution is still texture-only
+        // on every ordinary target.
+        Bool IsColorInternalFormatRenderable(TextureInternalFormat format, SizeT capabilityTargetIndex) {
             const SizeT formatIndex = static_cast<SizeT>(format);
             if (MG_Backend::pActiveBackendObject && formatIndex < MG_Backend::kFormatCapabilityFormatCount) {
                 const auto& cache = MG_Backend::pActiveBackendObject->GetFormatCapabilities();
@@ -113,8 +120,11 @@ namespace MobileGL::MG_Impl::GLImpl {
                                                                      MG_Backend::FormatCapability::Creatable);
                 }
                 if (cachePopulated) {
-                    for (SizeT targetIndex = 0; targetIndex < MG_Backend::kFormatCapabilityTargetCount;
-                         ++targetIndex) {
+                    const Bool singleTarget = capabilityTargetIndex < MG_Backend::kFormatCapabilityTargetCount;
+                    const SizeT firstTarget = singleTarget ? capabilityTargetIndex : 0;
+                    const SizeT lastTarget =
+                        singleTarget ? capabilityTargetIndex + 1 : MG_Backend::kFormatCapabilityTargetCount;
+                    for (SizeT targetIndex = firstTarget; targetIndex < lastTarget; ++targetIndex) {
                         if (MG_Backend::HasFormatCapability(cache.FullCaps[targetIndex][formatIndex],
                                                             MG_Backend::FormatCapability::FramebufferRenderable) ||
                             MG_Backend::HasFormatCapability(cache.CaveatCaps[targetIndex][formatIndex],
@@ -163,12 +173,17 @@ namespace MobileGL::MG_Impl::GLImpl {
                 const auto& attachment = attachments[i];
                 if (!attachment.IsValid()) continue;
                 TextureInternalFormat format = TextureInternalFormat::Unknown;
+                SizeT capabilityTargetIndex = MG_Backend::kFormatCapabilityTargetCount;
                 if (attachment.IsTexture() && attachment.GetTexture()) {
                     format = attachment.GetTexture()->GetFormat();
+                    capabilityTargetIndex =
+                        MG_Backend::GetFormatCapabilityTargetIndex(attachment.GetTexture()->GetTarget());
                 } else if (attachment.IsRenderbuffer() && attachment.GetRenderbuffer()) {
                     format = attachment.GetRenderbuffer()->GetInternalFormat();
+                    capabilityTargetIndex = MG_Backend::GetRenderbufferFormatCapabilityTargetIndex();
                 }
-                if (format != TextureInternalFormat::Unknown && !IsColorInternalFormatRenderable(format)) {
+                if (format != TextureInternalFormat::Unknown &&
+                    !IsColorInternalFormatRenderable(format, capabilityTargetIndex)) {
                     return true;
                 }
             }

MobileGL/MG_State/GLState/Core.cpp

@@ -241,6 +241,32 @@ namespace MobileGL::MG_State {
         }
 
         void GLContext::MarkTextureObjectForDeletion(Uint index) {
+            // GL 3.3 core 4.4.2: deleting a texture whose image is attached to the framebuffer
+            // that is currently bound acts as if FramebufferTexture* had been called with texture
+            // zero for every attachment point it occupied there. Framebuffers that are NOT bound
+            // keep the orphaned attachment, so only the bound ones are touched.
+            //
+            // Without this the framebuffer object goes on holding the deleted texture alive as its
+            // attachment, and a later read through that framebuffer returns the dead texture's
+            // contents rather than those of whatever the application put in its place - the name
+            // it deleted usually comes straight back from the next glGenTextures, so the two are
+            // indistinguishable from the outside (KHR-GL32.packed_pixels read a stale gradient).
+            if (const auto& textureObject = m_textureState.GetTextureObject(index)) {
+                for (SizeT targetIndex = 0; targetIndex < SizeT(FramebufferTarget::FramebufferTargetCount);
+                     ++targetIndex) {
+                    const auto& framebuffer =
+                        GetFramebufferBindingSlot(static_cast<FramebufferTarget>(targetIndex)).GetBoundObject();
+                    if (!framebuffer || framebuffer->IsDefaultFramebuffer()) {
+                        continue;
+                    }
+                    const auto& attachments = framebuffer->GetAllAttachmentObjects();
+                    for (SizeT i = 0; i < attachments.size(); ++i) {
+                        if (attachments[i].IsTexture() && attachments[i].GetTexture() == textureObject) {
+                            framebuffer->Detach(static_cast<FramebufferAttachmentType>(i));
+                        }
+                    }
+                }
+            }
             m_textureState.MarkTextureObjectForDeletion(index, IsRelaxedSemanticsActive());
         }
 

MobileGL/MG_Test/Program/ProgramUtilTest.cpp

@@ -223,7 +223,7 @@ void main() {
 
     PreprocessShaderSource(ShaderStage::Vertex, source);
 
-    EXPECT_EQ(source.find("#version 330 core\n"), 0);
+    EXPECT_EQ(source.find("#version 330 core "), 0);
     EXPECT_NE(source.find("in vec3 position;"), String::npos);
     EXPECT_NE(source.find("out vec2 uv;"), String::npos);
     EXPECT_EQ(source.find("attribute"), String::npos);
@@ -323,7 +323,7 @@ void main() {
 
     PreprocessShaderSource(ShaderStage::Fragment, source);
 
-    EXPECT_EQ(source.find("#version 330 core\n"), 0);
+    EXPECT_EQ(source.find("#version 330 core "), 0);
     EXPECT_NE(source.find("out vec4 mg_FragColor;\n"), String::npos);
     EXPECT_NE(source.find("in vec2 uv;"), String::npos);
     EXPECT_NE(source.find("texture(texture0, uv)"), String::npos);
@@ -379,7 +379,7 @@ void main() {
 
     PreprocessShaderSource(ShaderStage::Fragment, source);
 
-    EXPECT_EQ(source.find("#version 330 core\n"), 0);
+    EXPECT_EQ(source.find("#version 330 core "), 0);
     EXPECT_NE(source.find("vec4 sample = texture(DiffuseSampler"), String::npos);
     EXPECT_NE(source.find("totalAlpha = totalAlpha + sample.a;"), String::npos);
     EXPECT_NE(source.find("float totalSamples = 0.0;"), String::npos);
@@ -405,7 +405,7 @@ void main() {
 )";
     PreprocessShaderSource(ShaderStage::Vertex, vertexSource);
 
-    EXPECT_EQ(vertexSource.find("#version 330 core\n"), 0);
+    EXPECT_EQ(vertexSource.find("#version 330 core "), 0);
     EXPECT_NE(vertexSource.find("in vec3 sample;"), String::npos);
 
     ShaderAttrib vertexAttrib{.shaderType = GL_VERTEX_SHADER, .sourceStr = vertexSource};
@@ -425,7 +425,7 @@ void main() {
 )";
     PreprocessShaderSource(ShaderStage::Fragment, fragmentSource);
 
-    EXPECT_EQ(fragmentSource.find("#version 330 core\n"), 0);
+    EXPECT_EQ(fragmentSource.find("#version 330 core "), 0);
     EXPECT_NE(fragmentSource.find("uniform sampler2D sample;"), String::npos);
     EXPECT_NE(fragmentSource.find("texture(sample, texCoord)"), String::npos);
 
@@ -483,7 +483,9 @@ void main() {
 )";
         PreprocessShaderSource(ShaderStage::Fragment, source);
 
-        EXPECT_EQ(source.find("#version 460 core\n"), 0);
+        // An explicitly declared modern core version keeps its number (see "keep declared modern
+        // GLSL versions strict"); only the BOM goes.
+        EXPECT_EQ(source.find(String(inputVersion) + "\n"), 0);
         EXPECT_EQ(source.find("\xef\xbb\xbf"), String::npos);
 
         ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = source};
@@ -568,10 +570,12 @@ void main() {
 )";
     PreprocessShaderSource(ShaderStage::Fragment, source);
 
-    const SizeT versionPos = source.find("#version 330 core\n");
+    const SizeT versionPos = source.find("#version 330 core ");
     const SizeT outputPos = source.find("out vec4 mg_FragColor;\n");
     EXPECT_NE(versionPos, String::npos);
-    EXPECT_EQ(outputPos, versionPos + std::strlen("#version 330 core\n"));
+    // The normalized directive carries a marker recording that this 330 came from a legacy
+    // declaration, so measure the line rather than assuming its length.
+    EXPECT_EQ(outputPos, source.find('\n', versionPos) + 1);
     EXPECT_NE(source.find("// #version 460 core"), String::npos);
     // This #line sits ahead of the version directive, where GLSL would never have honoured it, so
     // it is still dropped. Directives that follow the version line are kept - see
@@ -684,7 +688,7 @@ void main() {
     }
 }
 
-TEST_F(ProgramUtilTest, PreprocessModernSampleQualifierStaysAtVersion460) {
+TEST_F(ProgramUtilTest, PreprocessModernSampleQualifierStaysAtItsDeclaredVersion) {
     using namespace MG_Util::ShaderTranspiler;
 
     String source = R"(#version 400 core
@@ -697,7 +701,7 @@ void main() {
 )";
     PreprocessShaderSource(ShaderStage::Fragment, source);
 
-    EXPECT_EQ(source.find("#version 460 core\n"), 0);
+    EXPECT_EQ(source.find("#version 400 core\n"), 0);
     EXPECT_NE(source.find("sample in vec4 interpolatedColor;"), String::npos);
 
     ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = source};
@@ -746,7 +750,7 @@ void main() {
 
     PreprocessShaderSource(ShaderStage::Fragment, source);
 
-    EXPECT_EQ(source.find("#version 330 core\n"), 0);
+    EXPECT_EQ(source.find("#version 330 core "), 0);
     EXPECT_NE(source.find("layout(location = 0) out vec4 mg_FragData[8];\n"), String::npos);
     EXPECT_NE(source.find("mg_FragData[0] = vec4(1.0);"), String::npos);
     EXPECT_NE(source.find("mg_FragData[1].a = 0.5;"), String::npos);
@@ -902,16 +906,17 @@ TEST_F(ProgramUtilTest, CompileSimpleVertexShader) {
 }
 
 // Legacy desktop sources are normalized to "#version 330 core", which is stricter than the 460 they
-// used to be forced to. A shader declaring 330 while using 420-era syntax without the matching
-// #extension line is accepted by real drivers, so CompileShader retries it at 460 instead of failing.
-TEST_F(ProgramUtilTest, CompileShaderRetriesAt460WhenLegacyVersionRejects420Syntax) {
+// used to be forced to. A legacy shader using 420-era syntax without the matching #extension line
+// is accepted by real drivers, so CompileShader retries the normalized source at 460 rather than
+// failing. Only MobileGL's own normalization is rescued this way - an application-declared
+// "#version 330" keeps strict 3.30 semantics, which is what the CTS negative-compile cases need.
+TEST_F(ProgramUtilTest, CompileShaderRetriesAt460WhenNormalizedLegacyVersionRejects420Syntax) {
     using namespace MG_Util::ShaderTranspiler;
-    String source = R"(#version 330
+    String source = R"(#version 130
 layout(binding = 0) uniform sampler2D InSampler;
-in vec2 texCoord;
-out vec4 fragColor;
+varying vec2 texCoord;
 void main() {
-    fragColor = texture(InSampler, texCoord);
+    gl_FragColor = texture2D(InSampler, texCoord);
 })";
     PreprocessShaderSource(ShaderStage::Fragment, source);
     // The normal path still emits 330 - the retry must not become the default.
@@ -952,10 +957,21 @@ void main() {
 TEST_F(ProgramUtilTest, RetargetLegacyVersionDirectiveOnlyTouchesNormalizedDesktopCore) {
     using namespace MG_Util::ShaderTranspiler;
 
-    String normalized = "#version 330 core\nvoid main() {}\n";
+    // Only MobileGL's own normalization is retargetable, and it is recognised by the marker the
+    // preprocessor leaves on the directive line - so normalize a legacy source rather than
+    // hand-writing the directive the marker belongs to.
+    String normalized = "#version 130\nvoid main() {}\n";
+    PreprocessShaderSource(ShaderStage::Vertex, normalized);
+    ASSERT_EQ(normalized.find("#version 330 core "), 0u);
     EXPECT_TRUE(RetargetLegacyVersionDirectiveTo460(normalized));
     EXPECT_EQ(normalized.find("#version 460 core"), 0u);
 
+    // An application that declared 330 itself keeps strict 3.30 semantics: raising it would
+    // re-legalize the CTS negative-compile cases.
+    String declared330 = "#version 330 core\nvoid main() {}\n";
+    EXPECT_FALSE(RetargetLegacyVersionDirectiveTo460(declared330));
+    EXPECT_EQ(declared330.find("#version 330 core"), 0u);
+
     // Already modern: nothing to retarget.
     String modern = "#version 460 core\nvoid main() {}\n";
     EXPECT_FALSE(RetargetLegacyVersionDirectiveTo460(modern));

MobileGL/MG_Test/SanityTest.cpp

@@ -197,13 +197,15 @@ TEST(DirectGLESSanity, AdvertisesDepthTextureForGlmarkShadowScenes) {
     EXPECT_NE(std::find(extensions.begin(), extensions.end(), MobileGL::E_GL_ARB_depth_texture), extensions.end());
 }
 
-TEST(DirectGLESSanity, AdvertisesVoxyRequiredRenderingExtensionsAtExperimentalCTSVersion) {
+// The advertised target went back to 3.3 (see "restore target GL version to 3.3"); Voxy only ever
+// needed the extensions, which stay advertised, so assert what the backend really reports.
+TEST(DirectGLESSanity, AdvertisesVoxyRequiredRenderingExtensions) {
     MobileGL::MG_Backend::DirectGLES::BackendObject_DirectGLES backend;
     const auto& rendererInfo = backend.GetRendererInfo().RendererGLInfo;
     const auto& extensions = rendererInfo.Extensions;
 
-    EXPECT_EQ(rendererInfo.TargetGLVersion.Major, 4);
-    EXPECT_EQ(rendererInfo.TargetGLVersion.Minor, 6);
+    EXPECT_EQ(rendererInfo.TargetGLVersion.Major, 3);
+    EXPECT_EQ(rendererInfo.TargetGLVersion.Minor, 3);
     EXPECT_EQ(rendererInfo.TargetGLVersion.Patch, 0);
 
     EXPECT_NE(std::find(extensions.begin(), extensions.end(), MobileGL::E_GL_ARB_compute_shader),
@@ -397,13 +399,14 @@ TEST(DirectVulkanSanity, RenderPassExtentUsesSwapchainSizeOnlyForDefaultFramebuf
               MobileGL::IntVec2(512, 512));
 }
 
-TEST(DirectVulkanSanity, AdvertisesVoxyRequiredRenderingExtensionsAtExperimentalCTSVersion) {
+// See the DirectGLES twin above: the target version is 3.3 again, the extensions are what matter.
+TEST(DirectVulkanSanity, AdvertisesVoxyRequiredRenderingExtensions) {
     MobileGL::MG_Backend::DirectVulkan::BackendObject_DirectVulkan backend;
     const auto& rendererInfo = backend.GetRendererInfo().RendererGLInfo;
     const auto& extensions = rendererInfo.Extensions;
 
-    EXPECT_EQ(rendererInfo.TargetGLVersion.Major, 4);
-    EXPECT_EQ(rendererInfo.TargetGLVersion.Minor, 6);
+    EXPECT_EQ(rendererInfo.TargetGLVersion.Major, 3);
+    EXPECT_EQ(rendererInfo.TargetGLVersion.Minor, 3);
     EXPECT_EQ(rendererInfo.TargetGLVersion.Patch, 0);
 
     EXPECT_NE(std::find(extensions.begin(), extensions.end(), MobileGL::E_GL_ARB_compute_shader),

MobileGL/MG_Test/Texture/TextureTest.cpp

@@ -1867,11 +1867,13 @@ TEST_F(TextureTest, DirectGLESTreats2DArrayAsSupportedTextureTarget) {
     EXPECT_TRUE(IsSupportedTextureTarget(TextureTarget::Texture2DArray));
     EXPECT_TRUE(IsSupportedTextureTarget(TextureTarget::Texture3D));
     EXPECT_TRUE(IsSupportedTextureTarget(TextureTarget::Texture2D));
-    // 1D and 1D-array are emulated as 2D / 2D-array (MapToBackendTextureTarget), matching
-    // SPIRV-Cross's ES 1D-as-2D shader emission; only rectangle textures stay unsupported.
+    // Every desktop-only target is stored on an ES one (MapToBackendTextureTarget): 1D and
+    // 1D-array as 2D / 2D-array, matching SPIRV-Cross's ES 1D-as-2D shader emission, and
+    // rectangle as a plain 2D - it is single-level and already clamps, so only the
+    // non-normalized coordinates differ and LowerRectImagesForEssl handles those.
     EXPECT_TRUE(IsSupportedTextureTarget(TextureTarget::Texture1D));
     EXPECT_TRUE(IsSupportedTextureTarget(TextureTarget::Texture1DArray));
-    EXPECT_FALSE(IsSupportedTextureTarget(TextureTarget::TextureRectangle));
+    EXPECT_TRUE(IsSupportedTextureTarget(TextureTarget::TextureRectangle));
 }
 
 // 2D-array textures keep their layer count constant across mip levels (GL 3.3 §3.9);

MobileGL/MG_Util/BackendLoaders/OpenGL/Loader.cpp

@@ -824,6 +824,12 @@ namespace MobileGL::MG_Util::BackendLoader {
                 if (std::strcmp(extension, "GL_EXT_texture_norm16") == 0) {
                     caps.SupportsNorm16Texture = true;
                 }
+                if (std::strcmp(extension, "GL_EXT_render_snorm") == 0) {
+                    caps.SupportsRenderSnorm = true;
+                }
+                if (std::strcmp(extension, "GL_EXT_sRGB_write_control") == 0) {
+                    caps.SupportsSrgbWriteControl = true;
+                }
                 if (std::strcmp(extension, "GL_EXT_texture_filter_anisotropic") == 0) {
                     caps.SupportsTextureFilterAnisotropy = true;
                 }

MobileGL/MG_Util/BackendLoaders/OpenGL/Loader.h

@@ -1031,6 +1031,13 @@ namespace MobileGL {
             String GLESShadingLanguageVersionString;
             Bool SupportsPersistentMapping = false;
             Bool SupportsNorm16Texture = false;
+            // GL_EXT_render_snorm is present, so the signed-normalized formats are colour-renderable
+            // (and usable as multisample texture storage) rather than texture-only.
+            Bool SupportsRenderSnorm = false;
+            // GL_EXT_sRGB_write_control is present, so GL_FRAMEBUFFER_SRGB can be turned off.
+            // GLES has no such switch in core: writes into an sRGB attachment are ALWAYS encoded,
+            // while desktop GL leaves GL_FRAMEBUFFER_SRGB disabled by default and writes raw.
+            Bool SupportsSrgbWriteControl = false;
             // GL_EXT_texture_filter_anisotropic is present, so sampler/texture
             // anisotropy may be forwarded without raising GL_INVALID_ENUM in GLES.
             Bool SupportsTextureFilterAnisotropy = false;

MobileGL/MG_Util/Texture/TextureFormatProcessor.cpp

@@ -29,11 +29,16 @@ namespace MobileGL::MG_Util::TextureFormatProcessor {
         case GL_RGB12: // stored as RGB16 (see NormalizePixelFormat)
             applicableOptions |= options & PixelFormatNormalizeOptionBit::NoNorm16;
             applicableOptions |= options & PixelFormatNormalizeOptionBit::NoRgb16;
+            applicableOptions |= options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget;
             break;
         case GL_RGB16_SNORM:
             applicableOptions |= options & PixelFormatNormalizeOptionBit::NoRGB16Snorm;
             applicableOptions |= options & PixelFormatNormalizeOptionBit::NoNorm16;
             applicableOptions |= options & PixelFormatNormalizeOptionBit::NoSnorm16;
+            applicableOptions |= options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget;
+            if (options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget) {
+                applicableOptions |= options & PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget;
+            }
             break;
         case GL_RGBA16_SNORM:
         case GL_RG16_SNORM:
@@ -46,6 +51,9 @@ namespace MobileGL::MG_Util::TextureFormatProcessor {
             applicableOptions |= options & PixelFormatNormalizeOptionBit::NoRGBA8Snorm;
             break;
         case GL_RGB8_SNORM:
+            applicableOptions |= options & PixelFormatNormalizeOptionBit::NoSnorm8;
+            applicableOptions |= options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget;
+            break;
         case GL_RG8_SNORM:
         case GL_R8_SNORM:
             applicableOptions |= options & PixelFormatNormalizeOptionBit::NoSnorm8;
@@ -87,6 +95,13 @@ namespace MobileGL::MG_Util::TextureFormatProcessor {
                 *outInternalFormat = internalFormat;
                 break;
             case GL_RGB16:
+                if (options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget) {
+                    // GL_RGB32F is a legal ES texture format but is not colour-renderable, so
+                    // glTexStorage2DMultisample rejects it and the attachment ends up with no
+                    // storage at all.
+                    *outInternalFormat = GL_RGBA32F;
+                    break;
+                }
                 if ((options & PixelFormatNormalizeOptionBit::NoNorm16) ||
                     (options & PixelFormatNormalizeOptionBit::NoRgb16)) {
                     *outInternalFormat = GL_RGB32F;
@@ -117,6 +132,14 @@ namespace MobileGL::MG_Util::TextureFormatProcessor {
                 *outInternalFormat = internalFormat;
                 break;
             case GL_RGB16_SNORM:
+                if (options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget) {
+                    // A half float loses the low bits of a 16-bit SNORM channel, so keep the
+                    // signed-normalized encoding whenever the driver can render to it.
+                    *outInternalFormat = (options & PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget)
+                                             ? GL_RGBA16F
+                                             : GL_RGBA16_SNORM;
+                    break;
+                }
                 if ((options & PixelFormatNormalizeOptionBit::NoNorm16) ||
                     (options & PixelFormatNormalizeOptionBit::NoRGB16Snorm) ||
                     (options & PixelFormatNormalizeOptionBit::NoSnorm16)) {
@@ -150,6 +173,10 @@ namespace MobileGL::MG_Util::TextureFormatProcessor {
                 *outInternalFormat = internalFormat;
                 break;
             case GL_RGB8_SNORM:
+                if (options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget) {
+                    *outInternalFormat = GL_RGBA16F;
+                    break;
+                }
                 if (options & PixelFormatNormalizeOptionBit::NoSnorm8) {
                     *outInternalFormat = GL_RGB16F;
                     break;

MobileGL/MG_Util/Texture/TextureFormatProcessor.h

@@ -18,6 +18,17 @@ namespace MobileGL {
         NoDepthComponent32 = 1 << 4,
         NoRGBA8Snorm = 1 << 5,
         NoRGB16Snorm = 1 << 6,
+        // The target must be colour-renderable and ES has no renderable three-channel
+        // form of the requested format, so it has to be widened to the four-channel one.
+        // Only meaningful for multisample textures: those can never be uploaded to, only
+        // rendered into, so the extra alpha comes from the draw (1.0 for an RGB source)
+        // and no transfer path has to expand three-channel client data.
+        NoThreeChannelRenderTarget = 1 << 7,
+        // Pairs with the bit above: the widened four-channel format has to stay renderable AND
+        // keep 16-bit signed-normalized precision, which needs both EXT_texture_norm16 and
+        // EXT_render_snorm. Without them the only renderable widening left is a half float, whose
+        // 11-bit mantissa cannot represent a 16-bit SNORM channel exactly.
+        NoSnorm16RenderTarget = 1 << 8,
         None = 0,
     };
     namespace MG_Util::TextureFormatProcessor {