DirectGLES: gate the replicate blit's stencil pass on ES 3.1

Reading the stencil half of a packed depth/stencil texture goes through
GL_DEPTH_STENCIL_TEXTURE_MODE, which is ES 3.1 state. On an older driver
the pname would raise GL_INVALID_ENUM and the shader would go on sampling
depth bits as if they were stencil, so decline the emulation instead.

MobileGL/MG_Backend/BackendObject.h

@@ -229,6 +229,13 @@ namespace MobileGL {
             // (optional; null = frontend falls back to CPU accounting).
             BackendQueryHandle (*BeginXfbPrimitivesQuery)(Bool generated);
             void (*EndXfbPrimitivesQuery)(BackendQueryHandle query);
+            // Transform feedback capture spans, for backends whose own GL/ES driver
+            // performs the capture (DirectGLES). Both optional; null means the backend
+            // drives capture from its draw recording instead (DirectVulkan). End is
+            // called while the frontend capture state is still active, so the backend
+            // can still see the capture program and buffer bindings.
+            void (*BeginTransformFeedback)(GLenum primitiveMode);
+            void (*EndTransformFeedback)();
             Int64 (*GetGpuTimestampNs)(); // glGetInteger64v(GL_TIMESTAMP); 0 if unsupported
         };
         struct GlobalBackendFunctionsTable {
@@ -317,6 +324,13 @@ namespace MobileGL {
             Float MaxFragmentInterpolationOffset = 0.4375f;
             Int FragmentInterpolationOffsetBits = 4;
             Bool SupportsWideLines = false;
+            // Whether a framebuffer whose depth and stencil attachments are distinct
+            // images can be rendered to. GL only requires support when both refer to the
+            // same image and lets an implementation answer GL_FRAMEBUFFER_UNSUPPORTED
+            // otherwise, which is what DirectVulkan (one combined attachment) and the
+            // real ES drivers behind DirectGLES both do. Defaults to true so a backend
+            // that never sets it keeps the permissive behaviour.
+            Bool SupportsDistinctDepthStencilAttachments = true;
             SizeT MaxShaderStorageBlockSize = 128 * 1024 * 1024;
             Uint32 SubgroupSize = 0;
             Uint32 SubgroupSupportedStages = 0;

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) {
@@ -357,6 +363,42 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return complete;
         }
 
+        // Whether the driver renders to a framebuffer whose depth and stencil come from
+        // two different renderbuffers. GL only requires support when both attachments are
+        // the same image, and ES drivers commonly answer GL_FRAMEBUFFER_UNSUPPORTED here;
+        // reporting COMPLETE from the frontend and then rendering into a framebuffer the
+        // driver refuses leaves the results silently empty.
+        Bool ProbeDistinctDepthStencilAttachments(const MG_External::GLESFunctionsTable& gl) {
+            if (!gl.glGenFramebuffers || !gl.glBindFramebuffer || !gl.glFramebufferRenderbuffer ||
+                !gl.glCheckFramebufferStatus || !gl.glDeleteFramebuffers || !gl.glGenRenderbuffers ||
+                !gl.glBindRenderbuffer || !gl.glRenderbufferStorage || !gl.glDeleteRenderbuffers) {
+                return true;
+            }
+
+            GLint prevFramebuffer = 0, prevRenderbuffer = 0;
+            gl.glGetIntegerv(GL_FRAMEBUFFER_BINDING, &prevFramebuffer);
+            gl.glGetIntegerv(GL_RENDERBUFFER_BINDING, &prevRenderbuffer);
+
+            GLuint framebuffer = 0;
+            GLuint renderbuffers[2] = {0, 0};
+            gl.glGenFramebuffers(1, &framebuffer);
+            gl.glGenRenderbuffers(2, renderbuffers);
+            gl.glBindRenderbuffer(GL_RENDERBUFFER, renderbuffers[0]);
+            gl.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, 4, 4);
+            gl.glBindRenderbuffer(GL_RENDERBUFFER, renderbuffers[1]);
+            gl.glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, 4, 4);
+            gl.glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
+            gl.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, renderbuffers[0]);
+            gl.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, renderbuffers[1]);
+            const Bool supported = gl.glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE;
+
+            gl.glBindFramebuffer(GL_FRAMEBUFFER, static_cast<GLuint>(prevFramebuffer));
+            gl.glBindRenderbuffer(GL_RENDERBUFFER, static_cast<GLuint>(prevRenderbuffer));
+            gl.glDeleteFramebuffers(1, &framebuffer);
+            gl.glDeleteRenderbuffers(2, renderbuffers);
+            return supported;
+        }
+
         Bool ProbeFramebufferCompletenessForRenderbuffer(const MG_External::GLESFunctionsTable& gl,
                                                         GLuint renderbuffer,
                                                         TextureInternalFormat format) {
@@ -520,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,
@@ -548,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,
@@ -564,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) {
@@ -579,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);
                 }
             }
         }
@@ -832,6 +904,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                           E_GL_ARB_multi_draw_indirect, E_GL_ARB_indirect_parameters,
                                           E_GL_ARB_shader_draw_parameters, E_GL_ARB_gpu_shader5, E_GL_ARB_multi_bind,
                                           E_GL_ARB_shading_language_420pack, E_GL_ARB_vertex_attrib_binding,
+                                          // Both are core from GL 3.2/3.3 on and implemented here for
+                                          // every advertised version, but an app targeting 3.0/3.1
+                                          // only reaches them through the extension string - the CTS
+                                          // picks a whole different shader for draw_buffers without
+                                          // explicit_attrib_location. DirectVulkan advertises both.
+                                          E_GL_ARB_explicit_attrib_location, E_GL_ARB_texture_multisample,
                                           E_GL_ARB_shader_image_size};
         // Only advertised when the device driver actually has usable timer queries
         // (GL_EXT_disjoint_timer_query plus its entry points) and the
@@ -942,9 +1020,18 @@ namespace MobileGL::MG_Backend::DirectGLES {
             // when the timer-query group above is disabled.
             funcsTable.GL.BeginOcclusionQuery = BeginOcclusionQuery;
             funcsTable.GL.EndOcclusionQuery = EndOcclusionQuery;
+            // Real driver primitive counters: the frontend's CPU accounting cannot see a
+            // geometry shader's amplification.
+            funcsTable.GL.BeginXfbPrimitivesQuery = BeginXfbPrimitivesQuery;
+            funcsTable.GL.EndXfbPrimitivesQuery = EndXfbPrimitivesQuery;
             funcsTable.GL.IsQueryResultAvailable = IsQueryResultAvailable;
             funcsTable.GL.GetQueryResult64 = GetQueryResult64;
             funcsTable.GL.DeleteBackendQuery = DeleteBackendQuery;
+            // Transform feedback is captured by the real ES driver rather than
+            // reconstructed from the draw recording, so the frontend has to hand the
+            // span boundaries over.
+            funcsTable.GL.BeginTransformFeedback = XfbImpl::BeginTransformFeedback;
+            funcsTable.GL.EndTransformFeedback = XfbImpl::EndTransformFeedback;
             funcsTableInitialized = true;
         }
         return funcsTable;
@@ -1031,6 +1118,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
             clampStageImageUniforms(m_GLESCapabilities.MaxFragmentImageUniforms);
         m_dynamicParameters.MaxComputeImageUniforms =
             clampStageImageUniforms(m_GLESCapabilities.MaxComputeImageUniforms);
+        m_dynamicParameters.SupportsDistinctDepthStencilAttachments =
+            ProbeDistinctDepthStencilAttachments(DirectGLES::g_GLESFuncs);
         m_dynamicParameters.MaxDrawBuffers = m_GLESCapabilities.MaxDrawBuffers;
         m_dynamicParameters.MaxColorAttachments = m_GLESCapabilities.MaxColorAttachments;
         m_dynamicParameters.MaxClipDistances = m_GLESCapabilities.MaxClipDistances;

MobileGL/MG_Backend/DirectGLES/DirectGLES.h

@@ -135,6 +135,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
     // flow through GetQueryResult64/DeleteBackendQuery like the timer queries above.
     BackendQueryHandle BeginOcclusionQuery();
     void EndOcclusionQuery(BackendQueryHandle query);
+    // GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN / GL_PRIMITIVES_GENERATED, also core ES
+    // (GL_PRIMITIVES_GENERATED from ES 3.2 on). Null when the target is unavailable, in
+    // which case the frontend falls back to counting primitives from the draw calls.
+    BackendQueryHandle BeginXfbPrimitivesQuery(Bool generated);
+    void EndXfbPrimitivesQuery(BackendQueryHandle query);
     Bool IsQueryResultAvailable(BackendQueryHandle query);
     // Returns true when a final value landed in *outNanoseconds (a zero for
     // null or stale-generation handles IS final: the frontend may cache it
@@ -159,6 +164,18 @@ namespace MobileGL::MG_Backend::DirectGLES {
     void SetGLESCapabilities(const MG_External::GLESCapabilities& capabilities);
     void DestroyEGLContext();
 
+    // Transform feedback capture spans, performed by the real ES driver. The
+    // capture set is declared on the backend program at link time; the driver-side
+    // begin is deferred to the first draw of the span (ES needs the capturing
+    // program current and the capture buffers bound), and the end also mirrors the
+    // captured bytes back into the frontend buffer shadows.
+    namespace XfbImpl {
+        Bool AreTransformFeedbacksSupported();
+        void BeginTransformFeedback(GLenum primitiveMode);
+        void EndTransformFeedback();
+        void OnBackendContextDestroyed();
+    } // namespace XfbImpl
+
     extern MG_External::EGLFunctionsTable g_EGLFuncs;
     extern MG_External::GLESFunctionsTable g_GLESFuncs;
     extern MG_External::GLESCapabilities g_GLESCapabilities;

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) {                                                             \
@@ -2679,6 +2691,31 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return false;
         }
 
+        Bool IsFixedPointFallbackReadAttachment() {
+            const auto& readFBO =
+                MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Read).GetBoundObject();
+            if (!readFBO) {
+                return false;
+            }
+            const auto readBuffer = readFBO->GetReadBuffer();
+            if (readBuffer < FramebufferAttachmentType::Color0 || readBuffer > FramebufferAttachmentType::Color31) {
+                return false;
+            }
+            // Any signed-normalized attachment, not just the ones currently substituted:
+            // ES has no GL_CLAMP_READ_COLOR at all, so even a natively stored SNORM buffer
+            // hands back the negative half that desktop GL clamps away.
+            const auto& attachmentObject = readFBO->GetAttachment(readBuffer);
+            if (attachmentObject.IsTexture()) {
+                const auto& textureObject = attachmentObject.GetTexture();
+                return textureObject && IsSnormFormat(textureObject->GetFormat());
+            }
+            if (attachmentObject.IsRenderbuffer()) {
+                const auto& renderbufferObject = attachmentObject.GetRenderbuffer();
+                return renderbufferObject && IsSnormFormat(renderbufferObject->GetInternalFormat());
+            }
+            return false;
+        }
+
         void BackendFramebufferObject::SyncReadBufferToBackend(
             const SharedPtr<MG_State::GLState::FramebufferObject>& stateFBOObject) {
             if (!stateFBOObject) {
@@ -3181,6 +3218,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
     namespace PrgramImpl {
         Uint32 g_snormFallbackClampOutputMask = 0;
+        Uint g_fragColorBroadcastCount = 1;
         Uint32 g_unormFallbackClampOutputMask = 0;
         Uint g_lastUsedBackendProgramId = 0;
         StateBackendObjectRegistry<MG_State::GLState::ProgramObject, BackendProgramObjectImpl> g_backendProgramObjects;
@@ -3232,8 +3270,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
             MGLOG_D("Syncing program to backend. State program ID: %u, Backend ID: %u",
                     stateProgramObject->GetExternalIndex(), m_backendProgramId);
+            m_backendProgramUsable = true;
             m_snormFallbackClampOutputMask = g_snormFallbackClampOutputMask;
             m_unormFallbackClampOutputMask = g_unormFallbackClampOutputMask;
+            m_fragColorBroadcastCount = g_fragColorBroadcastCount;
 
             // Detach all existing shaders
             GLint attachedCount = 0;
@@ -3316,6 +3356,17 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     effectiveSpirv = &noperspectiveSpirv;
                 }
 
+                // ES has no rectangle sampler, and SPIRV-Cross refuses the whole module rather
+                // than approximating one. Where every use takes integer texel coordinates a
+                // rectangle image is indistinguishable from a 2D one, so rewrite the type and let
+                // it through; the pass declines anything it cannot convert exactly.
+                Vector<unsigned int> rectLoweredSpirv;
+                if (MG_Util::ShaderTranspiler::ShaderCompiler::LowerRectImagesForEssl(*effectiveSpirv,
+                                                                                       rectLoweredSpirv) &&
+                    !rectLoweredSpirv.empty()) {
+                    effectiveSpirv = &rectLoweredSpirv;
+                }
+
                 MG_Util::ShaderTranspiler::SpvcSession spvcSession(*effectiveSpirv,
                     MG_Util::ShaderTranspiler::SessionUsageBit::Transpile);
 
@@ -3338,6 +3389,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     r.log += spvcSession.GetLastErrorString();
                     r.errc = -5;
                     MGLOG_E("%s", r.log.c_str());
+                    m_backendProgramUsable = false;
                     continue;
                 }
 
@@ -3347,6 +3399,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 source = RemoveLayoutBinding(source);
                 source = ProcessOutColorLocations(source);
                 source = ForceFlatIntegerVaryings(source, glShaderType);
+                source = BroadcastLegacyFragColor(std::move(source), glShaderType, m_fragColorBroadcastCount);
+                source = EmulateTextureLodBias(source);
                 source = EmulateBaseInstanceInVertexShader(std::move(source), glShaderType);
                 source = PromoteDrawParameterGlobalsToUniforms(std::move(source), glShaderType);
                 source = ForceSupporterOutput(source);
@@ -3377,6 +3431,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     Vector<GLchar> log(logLength);
                     g_GLESFuncs.glGetShaderInfoLog(backendShaderId, logLength, nullptr, log.data());
                     MGLOG_E("Shader compilation failed for backend ID %u: %s", backendShaderId, log.data());
+                    m_backendProgramUsable = false;
                     continue;
                 }
 
@@ -3386,12 +3441,33 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 MGLOG_D("Processed shader source length: %zu", source.length());
             }
 
+            // Transform feedback capture runs on the real driver (see XfbImpl in
+            // DirectGLES.cpp), so the capture set has to be declared on the backend
+            // program before it links. SPIRV-Cross keeps user output names verbatim in
+            // the transpiled ESSL (`out vec4 result_0;` stays `result_0`), so the
+            // frontend's requested names carry over unchanged.
+            if (stateProgramObject->GetTransformFeedbackVaryingCount() > 0 &&
+                g_GLESFuncs.glTransformFeedbackVaryings != nullptr) {
+                const auto& xfbVaryings = stateProgramObject->GetTransformFeedbackVaryings();
+                Vector<const GLchar*> xfbNames;
+                xfbNames.reserve(xfbVaryings.size());
+                for (const auto& xfbVarying : xfbVaryings) {
+                    xfbNames.push_back(xfbVarying.name.c_str());
+                }
+                MGLOG_D("Declaring %zu transform feedback varyings on program %u", xfbNames.size(),
+                        m_backendProgramId);
+                g_GLESFuncs.glTransformFeedbackVaryings(m_backendProgramId, static_cast<GLsizei>(xfbNames.size()),
+                                                        xfbNames.data(),
+                                                        stateProgramObject->GetTransformFeedbackBufferMode());
+            }
+
             // Link program
             MGLOG_D("Linking program %u", m_backendProgramId);
             g_GLESFuncs.glLinkProgram(m_backendProgramId);
 
             GLint linkStatus;
             g_GLESFuncs.glGetProgramiv(m_backendProgramId, GL_LINK_STATUS, &linkStatus);
+            m_backendProgramUsable = m_backendProgramUsable && linkStatus == GL_TRUE;
             if (linkStatus != GL_TRUE) {
                 GLint logLength;
                 g_GLESFuncs.glGetProgramiv(m_backendProgramId, GL_INFO_LOG_LENGTH, &logLength);
@@ -3504,6 +3580,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 binding.backendLocation = backendLoc;
                 binding.uniformType = uniformType;
                 binding.lastAssignedUnit = -1;
+                // Present only for the samplers EmulateTextureLodBias actually rewrote; the
+                // pass names it after the sampler, which SPIRV-Cross preserves verbatim.
+                binding.lodBiasLocation =
+                    g_GLESFuncs.glGetUniformLocation(m_backendProgramId, (String(LOD_BIAS_UNIFORM_PREFIX) + name).c_str());
+                binding.lastAssignedLodBias = 0.0f;
                 m_samplerUniformBindings.push_back(binding);
             }
         }
@@ -3512,12 +3593,18 @@ namespace MobileGL::MG_Backend::DirectGLES {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
 #endif
-            if (g_lastUsedBackendProgramId == m_backendProgramId) {
+            // glUseProgram on a program that did not link is an INVALID_OPERATION and
+            // leaves the *previous* program current, so the draw would silently render
+            // with an unrelated shader (KHR-GL3x.texture_size_promotion read another
+            // test case's alpha that way once a sampler2DRect stage failed to
+            // transpile). Bind nothing instead: the draw is then a visible no-op.
+            const Uint programToBind = m_backendProgramUsable ? m_backendProgramId : 0;
+            if (g_lastUsedBackendProgramId == programToBind) {
                 return;
             }
-            MGLOG_D("Using program %u", m_backendProgramId);
-            g_GLESFuncs.glUseProgram(m_backendProgramId);
-            g_lastUsedBackendProgramId = m_backendProgramId;
+            MGLOG_D("Using program %u", programToBind);
+            g_GLESFuncs.glUseProgram(programToBind);
+            g_lastUsedBackendProgramId = programToBind;
         }
 
         void BackendProgramObjectImpl::SetBaseInstance(Uint32 baseInstance) const {

MobileGL/MG_Backend/DirectGLES/Managers.h

@@ -270,18 +270,21 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
     namespace TextureImpl {
         inline Bool IsSupportedTextureTarget(TextureTarget target) {
-            // Rectangle textures need non-normalized sampling ES cannot express; everything else is
-            // either native or emulated (1D -> 2D with height 1, 1D array -> 2D array, see
-            // MapToBackendTextureTarget). SPIRV-Cross already emits the matching ESSL samplers and
-            // coordinate padding for 1D/1D-array shaders.
-            return target != TextureTarget::TextureRectangle;
+            // Every desktop-only target is stored on an ES one; see MapToBackendTextureTarget.
+            (void)target;
+            return true;
         }
 
-        // ES has no 1D targets: 1D textures are stored as 2D (height 1) and 1D arrays as 2D arrays
-        // (height 1, layers in depth). Must match SPIRV-Cross's ES 1D-as-2D shader emulation.
+        // ES has none of the desktop-only targets: 1D textures are stored as 2D (height 1), 1D
+        // arrays as 2D arrays (height 1, layers in depth), and rectangle textures as plain 2D -
+        // they are single-level and already clamp, so only the non-normalized coordinates differ.
+        // Must match the shader-side emulation: SPIRV-Cross handles 1D/1D-array itself, and
+        // ShaderCompiler::LowerRectImagesForEssl rewrites rectangle images (declining any module
+        // whose lookups are not integer-coordinate, which SPIRV-Cross then still rejects).
         inline TextureTarget MapToBackendTextureTarget(TextureTarget target) {
             switch (target) {
             case TextureTarget::Texture1D:
+            case TextureTarget::TextureRectangle:
                 return TextureTarget::Texture2D;
             case TextureTarget::Texture1DArray:
                 return TextureTarget::Texture2DArray;
@@ -297,6 +300,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         inline GLenum ConvertTextureUploadTargetToBackendGLEnum(TextureUploadTarget uploadTarget) {
             switch (uploadTarget) {
             case TextureUploadTarget::Texture1D:
+            case TextureUploadTarget::TextureRectangle:
                 return GL_TEXTURE_2D;
             case TextureUploadTarget::Texture1DArray:
                 return GL_TEXTURE_2D_ARRAY;
@@ -438,6 +442,13 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
         extern StateBackendObjectRegistry<MG_State::GLState::FramebufferObject, BackendFramebufferObject>
             g_backendFramebufferObjects;
+        // True when the read buffer names a fixed-point (norm/snorm) attachment that the
+        // backend actually stores in a floating-point format. GL clamps a read from a
+        // fixed-point colour buffer to [0,1] (GL_CLAMP_READ_COLOR defaults to
+        // GL_FIXED_ONLY); the substituted float storage would not, so the readback path
+        // has to apply the clamp itself.
+        Bool IsFixedPointFallbackReadAttachment();
+
         extern Array<Uint16, SizeT(FramebufferTarget::FramebufferTargetCount)> g_fboBindVersions;
         // Tracks the bound FBO's object version (bumped on any attachment/drawbuffer change)
         // per target: re-attaching textures or changing draw buffers on an already-bound FBO
@@ -576,6 +587,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 Int backendLocation = -1;
                 GLenum uniformType = 0;
                 Int lastAssignedUnit = -1;
+                // Location of this sampler's emulated GL_TEXTURE_LOD_BIAS uniform
+                // (PrgramImpl::EmulateTextureLodBias), -1 when the shader has none.
+                // lastAssignedLodBias mirrors the value the program currently holds,
+                // so an unbiased shader issues no per-draw glUniform1f at all.
+                Int lodBiasLocation = -1;
+                Float lastAssignedLodBias = 0.0f;
             };
 
             BackendProgramObjectImpl();
@@ -587,9 +604,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
             void SetDrawID(Uint32 drawId) const;
             Int GetIndirectParamsBinding() const { return m_indirectParamsBinding; }
             Uint GetBackendProgramId() const { return m_backendProgramId; }
+            // False when the last SyncToBackend could not produce a usable program (a
+            // shader failed to transpile or compile, or the link itself failed). Use()
+            // must not leave the previously bound program current in that case.
+            Bool IsBackendProgramUsable() const { return m_backendProgramUsable; }
             Uint GetBackendGlobalUBOId() const { return m_backendGlobalUBOId; }
             Uint32 GetSnormFallbackClampOutputMask() const { return m_snormFallbackClampOutputMask; }
             Uint32 GetUnormFallbackClampOutputMask() const { return m_unormFallbackClampOutputMask; }
+            Uint GetFragColorBroadcastCount() const { return m_fragColorBroadcastCount; }
 
             Bool HasGlobalUboBlock() const { return m_globalUboBackendBlockIndex >= 0; }
             const Vector<Int>& GetUniformBlockBackendIndices() const { return m_uniformBlockBackendIndices; }
@@ -616,7 +638,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
             Int m_indirectParamsBinding = -1;
             Uint32 m_snormFallbackClampOutputMask = 0;
             Uint32 m_unormFallbackClampOutputMask = 0;
+            // Draw buffers a legacy gl_FragColor write has to reach (see
+            // PrgramImpl::BroadcastLegacyFragColor); 1 keeps the plain single-output shader.
+            Uint m_fragColorBroadcastCount = 1;
             Bool m_isInitialized = false;
+            Bool m_backendProgramUsable = false;
 
             Int m_globalUboBackendBlockIndex = -1;
             Int m_globalUboBackendBlockSize = 0;
@@ -629,6 +655,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
         extern Uint32 g_snormFallbackClampOutputMask;
         extern Uint32 g_unormFallbackClampOutputMask;
+        // Draw buffers the current draw framebuffer enables. Like the clamp masks above it
+        // is framebuffer state that the shader has to be compiled against, so a program
+        // whose snapshot no longer matches is relinked.
+        extern Uint g_fragColorBroadcastCount;
         // Backend id of the last glUseProgram issued through this backend; lets Use()
         // skip redundant rebinds. Reset to 0 wherever glUseProgram(0) is issued or the
         // ES context is recreated.

MobileGL/MG_Backend/DirectGLES/Utils.cpp

@@ -22,6 +22,9 @@
 #include <MG_Util/Math/SmallFloat.h>
 
 #include <cmath>
+#include <cctype>
+#include <cstring>
+#include <regex>
 
 namespace MobileGL::MG_Backend::DirectGLES {
     namespace {
@@ -45,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,
@@ -113,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);
         }
@@ -148,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) {
@@ -276,6 +321,55 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return glslCode;
         }
 
+        String BroadcastLegacyFragColor(String glslCode, GLenum shaderType, Uint drawBufferCount) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
+            // The name is the marker: ShaderSourceProcessor only emits it when the source
+            // wrote gl_FragColor, and such a shader can have no other output.
+            static const char* const kLoweredName = "mg_FragColor";
+            if (shaderType != GL_FRAGMENT_SHADER || drawBufferCount <= 1) {
+                return glslCode;
+            }
+            static const std::regex declRegex(
+                R"(layout\s*\(\s*location\s*=\s*0\s*\)\s*out\s+((?:lowp|mediump|highp)\s+)?vec4\s+mg_FragColor\s*;)");
+            std::smatch declMatch;
+            if (!std::regex_search(glslCode, declMatch, declRegex)) {
+                return glslCode;
+            }
+            const String precision = declMatch[1].matched ? declMatch[1].str() : String();
+
+            String replicaDecls;
+            String replicaCopies;
+            for (Uint location = 1; location < drawBufferCount; ++location) {
+                const String name = String(kLoweredName) + "_" + std::to_string(location);
+                replicaDecls += "\nlayout(location = " + std::to_string(location) + ") out " + precision + "vec4 " +
+                                name + ";";
+                replicaCopies += "\n    " + name + " = " + kLoweredName + ";";
+            }
+
+            static const std::regex mainRegex(R"(void\s+main\s*\([^)]*\)\s*\{)");
+            std::smatch mainMatch;
+            if (!std::regex_search(glslCode, mainMatch, mainRegex)) {
+                return glslCode;
+            }
+            SizeT bracePos = static_cast<SizeT>(mainMatch.position(0) + mainMatch.length(0) - 1);
+            Int depth = 0;
+            for (SizeT pos = bracePos; pos < glslCode.size(); ++pos) {
+                if (glslCode[pos] == '{') {
+                    ++depth;
+                } else if (glslCode[pos] == '}') {
+                    --depth;
+                    if (depth == 0) {
+                        glslCode.insert(pos, replicaCopies + "\n");
+                        break;
+                    }
+                }
+            }
+            glslCode.insert(static_cast<SizeT>(declMatch.position(0)) + declMatch[0].str().size(), replicaDecls);
+            return glslCode;
+        }
+
         String ForceFlatIntegerVaryings(const String& glslCode, GLenum shaderType) {
 #ifdef TRACY_ENABLE
             ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
@@ -342,6 +436,166 @@ namespace MobileGL::MG_Backend::DirectGLES {
             }
             return result;
         }
+
+        namespace {
+            // How a lookup carries its level of detail, and how many arguments it takes
+            // before the optional bias.
+            struct LodLookupForm {
+                const char* name;
+                Int requiredArgs; // arguments before the optional bias (implicit form)
+                Int explicitLodArg; // index of the explicit LOD argument, -1 for implicit
+            };
+
+            // texelFetch* is deliberately absent: an integer fetch names its level directly
+            // and takes no LOD bias. textureGather has no bias either. textureGrad* derives
+            // the LOD from gradients and offers no argument to fold a bias into, so it is
+            // left alone rather than rewritten incorrectly.
+            constexpr LodLookupForm LOD_LOOKUP_FORMS[] = {
+                {"textureProjLodOffset", 0, 2}, {"textureProjOffset", 4, -1}, {"textureProjLod", 0, 2},
+                {"textureLodOffset", 0, 2},     {"textureOffset", 3, -1},     {"textureProj", 2, -1},
+                {"textureLod", 0, 2},           {"texture", 2, -1},
+            };
+
+            // Sampler types with no mip chain, or whose GLSL lookups have no bias overload
+            // at all (the array-shadow forms), so nothing can or should be folded in.
+            Bool IsBiasableSamplerType(const String& samplerType) {
+                if (samplerType.find("MS") != String::npos) return false;      // multisample
+                if (samplerType.find("Buffer") != String::npos) return false;  // texture buffer
+                if (samplerType.find("Rect") != String::npos) return false;    // rectangle: no mips
+                if (samplerType == "sampler2DArrayShadow") return false;
+                if (samplerType == "samplerCubeArrayShadow") return false;
+                return true;
+            }
+
+            Bool IsIdentifierChar(char c) { return std::isalnum(static_cast<unsigned char>(c)) || c == '_'; }
+
+            // Byte offsets of the top-level argument separators and of the closing paren,
+            // starting from the '(' at openParen. Empty when the parentheses do not balance.
+            Vector<SizeT> SplitCallArguments(const String& code, SizeT openParen) {
+                Vector<SizeT> marks;
+                Int depth = 0;
+                for (SizeT i = openParen; i < code.size(); ++i) {
+                    const char c = code[i];
+                    if (c == '(' || c == '[') {
+                        ++depth;
+                    } else if (c == ']') {
+                        --depth;
+                    } else if (c == ')') {
+                        --depth;
+                        if (depth == 0) {
+                            marks.push_back(i);
+                            return marks;
+                        }
+                    } else if (c == ',' && depth == 1) {
+                        marks.push_back(i);
+                    }
+                }
+                return {};
+            }
+        } // namespace
+
+        String EmulateTextureLodBias(const String& glslCode) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
+            if (glslCode.find("sampler") == String::npos || glslCode.find("texture") == String::npos) {
+                return glslCode;
+            }
+
+            // Collect the mip-capable sampler uniforms this shader declares.
+            static const std::regex samplerDeclRegex(
+                R"(uniform\s+(?:(?:highp|mediump|lowp)\s+)?([iu]?sampler[A-Za-z0-9]*)\s+([A-Za-z_][A-Za-z0-9_]*)\s*;)");
+            UnorderedMap<String, String> samplerNames; // name -> bias uniform name
+            for (std::sregex_iterator it(glslCode.begin(), glslCode.end(), samplerDeclRegex), end; it != end; ++it) {
+                const String samplerType = (*it)[1].str();
+                if (!IsBiasableSamplerType(samplerType)) continue;
+                const String name = (*it)[2].str();
+                samplerNames.emplace(name, String(LOD_BIAS_UNIFORM_PREFIX) + name);
+            }
+            if (samplerNames.empty()) {
+                return glslCode;
+            }
+
+            // Rewrite the lookups. Right-to-left so earlier offsets stay valid, and only for
+            // samplers named directly as the first argument (SPIRV-Cross never produces an
+            // expression there for ES output, which has no separate sampler objects).
+            String result = glslCode;
+            Vector<String> usedSamplers;
+            for (SizeT scan = result.size(); scan-- > 0;) {
+                if (result[scan] != 't') continue;
+                if (scan > 0 && IsIdentifierChar(result[scan - 1])) continue;
+
+                const LodLookupForm* form = nullptr;
+                SizeT openParen = 0;
+                for (const auto& candidate : LOD_LOOKUP_FORMS) {
+                    const SizeT nameLength = std::strlen(candidate.name);
+                    if (result.compare(scan, nameLength, candidate.name) != 0) continue;
+                    SizeT after = result.find_first_not_of(" \t", scan + nameLength);
+                    if (after == String::npos || result[after] != '(') continue;
+                    form = &candidate;
+                    openParen = after;
+                    break;
+                }
+                if (form == nullptr) continue;
+
+                const Vector<SizeT> marks = SplitCallArguments(result, openParen);
+                if (marks.empty()) continue;
+                const SizeT argCount = marks.size();
+                const SizeT closeParen = marks.back();
+
+                // First argument must be one of our samplers.
+                const SizeT firstArgStart = result.find_first_not_of(" \t", openParen + 1);
+                SizeT firstArgEnd = marks.front();
+                while (firstArgEnd > firstArgStart && (result[firstArgEnd - 1] == ' ' || result[firstArgEnd - 1] == '\t')) {
+                    --firstArgEnd;
+                }
+                if (firstArgStart == String::npos || firstArgEnd <= firstArgStart) continue;
+                const String samplerName = result.substr(firstArgStart, firstArgEnd - firstArgStart);
+                const auto samplerIt = samplerNames.find(samplerName);
+                if (samplerIt == samplerNames.end()) continue;
+
+                const String& biasName = samplerIt->second;
+                if (form->explicitLodArg >= 0) {
+                    // Explicit LOD: the bias adds to it, as Vulkan does for
+                    // OpImageSampleExplicitLod and as the CTS reference expects.
+                    const SizeT lodIndex = static_cast<SizeT>(form->explicitLodArg);
+                    if (argCount <= lodIndex) continue;
+                    const SizeT lodStart = marks[lodIndex - 1] + 1;
+                    const SizeT lodEnd = marks[lodIndex];
+                    result.insert(lodEnd, String(") + ") + biasName + ")");
+                    result.insert(lodStart, "((");
+                } else {
+                    const SizeT required = static_cast<SizeT>(form->requiredArgs);
+                    if (argCount == required) {
+                        result.insert(closeParen, String(", ") + biasName);
+                    } else if (argCount == required + 1) {
+                        const SizeT biasStart = marks[argCount - 2] + 1;
+                        result.insert(closeParen, String(") + ") + biasName + ")");
+                        result.insert(biasStart, "((");
+                    } else {
+                        continue;
+                    }
+                }
+                usedSamplers.push_back(samplerName);
+            }
+            if (usedSamplers.empty()) {
+                return glslCode;
+            }
+
+            // Declare the bias uniforms that were actually referenced, right after the
+            // sampler declaration line they belong to.
+            for (const auto& samplerName : usedSamplers) {
+                const String& biasName = samplerNames[samplerName];
+                if (result.find(String("float ") + biasName + ";") != String::npos) continue;
+                const std::regex declRegex(
+                    R"(uniform\s+(?:(?:highp|mediump|lowp)\s+)?[iu]?sampler[A-Za-z0-9]*\s+)" + samplerName + R"(\s*;)");
+                std::smatch match;
+                if (!std::regex_search(result, match, declRegex)) continue;
+                const SizeT declEnd = static_cast<SizeT>(match.position(0)) + match[0].str().size();
+                result.insert(declEnd, String("\nuniform highp float ") + biasName + ";");
+            }
+            return result;
+        }
     } // namespace PrgramImpl
 
     namespace Utils {

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
 
@@ -104,7 +109,26 @@ namespace MobileGL::MG_Backend::DirectGLES {
         String ClampNormFallbackOutputs(String glslCode, GLenum shaderType, Uint32 snormOutputMask,
                                         Uint32 unormOutputMask);
         String ForceFlatIntegerVaryings(const String& glslCode, GLenum shaderType);
+        // Legacy GLSL's gl_FragColor is broadcast to every enabled draw buffer (GL 4.6
+        // 15.2.3), but ShaderSourceProcessor lowers it to the single output mg_FragColor,
+        // which only ever reaches draw buffer 0. Replicates it across `drawBufferCount`
+        // outputs and copies the value into them at the end of main. A no-op for
+        // drawBufferCount <= 1, i.e. for everything but a framebuffer that actually
+        // enables several draw buffers, so the ordinary single-target shader is untouched.
+        String BroadcastLegacyFragColor(String glslCode, GLenum shaderType, Uint drawBufferCount);
         String RemoveLayoutBinding(const String& glslCode);
+        // Prefix of the per-sampler float uniform that carries GL_TEXTURE_LOD_BIAS into
+        // the shader (see EmulateTextureLodBias); the suffix is the sampler's own name.
+        constexpr const char* LOD_BIAS_UNIFORM_PREFIX = "mg_lodBias_";
+        // ES has no per-texture/sampler LOD bias at all (GL_TEXTURE_LOD_BIAS is desktop
+        // only; Vulkan spells it VkSamplerCreateInfo::mipLodBias), so it has to reach the
+        // shader as a uniform and be folded into every lookup's level of detail. Declares
+        // one `uniform highp float mg_lodBias_<sampler>;` per mip-capable sampler and adds
+        // it to the bias / explicit-LOD argument of every lookup that takes one. Draws push
+        // the bound texture's (or sampler object's) value into it; a shader whose samplers
+        // all have a zero bias is therefore unaffected. Returns the source unchanged when
+        // there is nothing to rewrite.
+        String EmulateTextureLodBias(const String& glslCode);
     } // namespace PrgramImpl
 
     namespace Utils {

MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.cpp

@@ -578,6 +578,9 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
         }
         MG_State::pGLContext->BeginTransformFeedback(primitiveMode, program);
+        if (const auto beginXfb = MG_Backend::gBackendFunctionsTable.GL.BeginTransformFeedback) {
+            beginXfb(primitiveMode);
+        }
     }
 
     // Vulkan transform feedback captures triangle strips in plain (i, i+1, i+2)
@@ -587,6 +590,12 @@ namespace MobileGL::MG_Impl::GLImpl {
     // vertex records of every odd triangle within each emitted strip.
     static void FixupGsStripCaptureOrder(const SharedPtr<MG_State::GLState::ProgramObject>& program,
                                          Uint64 inputPrimitives) {
+        // Only Vulkan-order captures need this. A backend that runs the capture on its
+        // own GL/ES driver (it owns the span, hence the EndTransformFeedback entry) has
+        // already produced GL's vertex order, and reordering it again would corrupt it.
+        if (MG_Backend::gBackendFunctionsTable.GL.EndTransformFeedback != nullptr) {
+            return;
+        }
         if (program == nullptr || !program->HasGsTriangleStripCaptureFixup() || inputPrimitives == 0) {
             return;
         }
@@ -649,6 +658,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
         const auto capturedProgram = MG_State::pGLContext->GetTransformFeedbackProgram();
         const Uint64 inputPrimitives = MG_State::pGLContext->GetTransformFeedbackInputPrimitives();
+        // Closed while the capture state is still active: a backend that captures
+        // through its own driver reads the capture program and buffer bindings here.
+        if (const auto endXfb = MG_Backend::gBackendFunctionsTable.GL.EndTransformFeedback) {
+            endXfb();
+        }
         MG_State::pGLContext->EndTransformFeedback();
         // Captured results must be visible to MapBuffer/GetBufferSubData after
         // End; the capture targets are host-coherent GPU memory, so completing

MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp

@@ -22,9 +22,21 @@
 
 namespace MobileGL::MG_Impl::GLImpl {
     namespace {
-        Bool IsActiveBackendDirectVulkan() {
+        // GL only requires support for framebuffers whose depth and stencil attachments
+        // are the same image; anything else may be reported GL_FRAMEBUFFER_UNSUPPORTED.
+        // DirectVulkan cannot form two separate attachments at all, and the real ES
+        // drivers behind DirectGLES answer UNSUPPORTED for it too - so saying COMPLETE
+        // and then rendering into a framebuffer the driver refuses produced silently
+        // empty results (KHR-GL3x.packed_depth_stencil.verify_mixed_attachments).
+        Bool ActiveBackendRejectsDistinctDepthStencil() {
             auto* activeBackend = MG_Backend::pActiveBackendObject.get();
-            return activeBackend != nullptr && activeBackend->GetBackendType() == BackendType::DirectVulkan;
+            if (activeBackend == nullptr) {
+                return false;
+            }
+            if (activeBackend->GetBackendType() == BackendType::DirectVulkan) {
+                return true;
+            }
+            return !activeBackend->GetDynamicParameters().SupportsDistinctDepthStencilAttachments;
         }
 
         Bool HasDistinctCompleteDepthStencilTextureAttachments(
@@ -66,7 +78,7 @@ namespace MobileGL::MG_Impl::GLImpl {
                    (depthAttachment.IsTexture() || stencilAttachment.IsTexture());
         }
 
-        Bool IsUnsupportedFramebufferForDirectVulkan(
+        Bool HasUnsupportedDistinctDepthStencilAttachments(
             const MG_State::GLState::FramebufferObject& framebufferObject) {
             // TODO: Keep this in sync with DirectVulkan renderbuffer support as color renderbuffer rendering lands.
             return HasDistinctCompleteDepthStencilTextureAttachments(framebufferObject) ||
@@ -89,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();
@@ -101,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],
@@ -151,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;
                 }
             }
@@ -1631,8 +1658,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (HasNonRenderableColorAttachment(*framebufferObject)) {
             return GL_FRAMEBUFFER_UNSUPPORTED;
         }
-        if (IsActiveBackendDirectVulkan() &&
-            IsUnsupportedFramebufferForDirectVulkan(*framebufferObject)) {
+        if (ActiveBackendRejectsDistinctDepthStencil() &&
+            HasUnsupportedDistinctDepthStencilAttachments(*framebufferObject)) {
             return GL_FRAMEBUFFER_UNSUPPORTED;
         }
         return GL_FRAMEBUFFER_COMPLETE;
@@ -1659,8 +1686,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (HasNonRenderableColorAttachment(*framebufferObject)) {
             return GL_FRAMEBUFFER_UNSUPPORTED;
         }
-        if (IsActiveBackendDirectVulkan() &&
-            IsUnsupportedFramebufferForDirectVulkan(*framebufferObject)) {
+        if (ActiveBackendRejectsDistinctDepthStencil() &&
+            HasUnsupportedDistinctDepthStencilAttachments(*framebufferObject)) {
             return GL_FRAMEBUFFER_UNSUPPORTED;
         }
         return GL_FRAMEBUFFER_COMPLETE;

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/ShaderTranspiler/ShaderCompiler.cpp

@@ -363,6 +363,86 @@ namespace MobileGL {
                 return optimizer.Run(inputBinary.data(), inputBinary.size(), &outputBinary, options);
             }
 
+            bool ShaderCompiler::LowerRectImagesForEssl(const Vector<Uint32>& inputBinary,
+                                                        Vector<uint32_t>& outputBinary) {
+                constexpr SizeT kSpirvHeaderWordCount = 5;
+                // OpTypeImage: [0] opcode/wordcount, [1] result id, [2] sampled type, [3] Dim, ...
+                constexpr SizeT kTypeImageDimWordIndex = 3;
+                constexpr SizeT kTypeImageMinWordCount = 9;
+                outputBinary.clear();
+                if (inputBinary.size() < kSpirvHeaderWordCount || inputBinary[0] != spv::MagicNumber) {
+                    return false;
+                }
+
+                Vector<SizeT> rectDimWordOffsets;
+                Vector<SizeT> rectCapabilityWordOffsets;
+                Bool hasNormalizedCoordinateLookup = false;
+                for (SizeT offset = kSpirvHeaderWordCount; offset < inputBinary.size();) {
+                    const Uint32 instructionWord = inputBinary[offset];
+                    const SizeT wordCount = instructionWord >> 16u;
+                    const auto opcode = static_cast<spv::Op>(instructionWord & 0xffffu);
+                    if (wordCount == 0 || offset + wordCount > inputBinary.size()) {
+                        return false;
+                    }
+
+                    if (opcode == spv::Op::OpTypeImage && wordCount >= kTypeImageMinWordCount) {
+                        if (static_cast<spv::Dim>(inputBinary[offset + kTypeImageDimWordIndex]) == spv::Dim::Rect) {
+                            rectDimWordOffsets.push_back(offset + kTypeImageDimWordIndex);
+                        }
+                    } else if (opcode == spv::Op::OpCapability && wordCount >= 2) {
+                        const auto capability = static_cast<spv::Capability>(inputBinary[offset + 1]);
+                        if (capability == spv::Capability::SampledRect ||
+                            capability == spv::Capability::ImageRect) {
+                            rectCapabilityWordOffsets.push_back(offset + 1);
+                        }
+                    } else {
+                        switch (opcode) {
+                        // Everything that takes normalized coordinates. Tracing each one back to
+                        // its image type would let a module mix a normalized 2D lookup with a
+                        // rectangle fetch, but the extra reach is not worth the risk of getting
+                        // the trace wrong: decline the whole module instead.
+                        case spv::Op::OpImageSampleImplicitLod:
+                        case spv::Op::OpImageSampleExplicitLod:
+                        case spv::Op::OpImageSampleDrefImplicitLod:
+                        case spv::Op::OpImageSampleDrefExplicitLod:
+                        case spv::Op::OpImageSampleProjImplicitLod:
+                        case spv::Op::OpImageSampleProjExplicitLod:
+                        case spv::Op::OpImageSampleProjDrefImplicitLod:
+                        case spv::Op::OpImageSampleProjDrefExplicitLod:
+                        case spv::Op::OpImageGather:
+                        case spv::Op::OpImageDrefGather:
+                        case spv::Op::OpImageSparseSampleImplicitLod:
+                        case spv::Op::OpImageSparseSampleExplicitLod:
+                        case spv::Op::OpImageSparseSampleDrefImplicitLod:
+                        case spv::Op::OpImageSparseSampleDrefExplicitLod:
+                        case spv::Op::OpImageSparseGather:
+                        case spv::Op::OpImageSparseDrefGather:
+                            hasNormalizedCoordinateLookup = true;
+                            break;
+                        default:
+                            break;
+                        }
+                    }
+                    offset += wordCount;
+                }
+
+                if (rectDimWordOffsets.empty() || hasNormalizedCoordinateLookup) {
+                    return false;
+                }
+
+                outputBinary.assign(inputBinary.begin(), inputBinary.end());
+                for (const SizeT dimWordOffset : rectDimWordOffsets) {
+                    outputBinary[dimWordOffset] = static_cast<Uint32>(spv::Dim::Dim2D);
+                }
+                // The rectangle capabilities describe types that no longer exist. Shader is always
+                // declared by a graphics module, so restating it keeps the word count intact
+                // without leaving a capability SPIRV-Cross would key off.
+                for (const SizeT capabilityWordOffset : rectCapabilityWordOffsets) {
+                    outputBinary[capabilityWordOffset] = static_cast<Uint32>(spv::Capability::Shader);
+                }
+                return true;
+            }
+
             bool ShaderCompiler::RebaseInstanceIndexForVulkan(const Vector<Uint32>& inputBinary,
                                                               Vector<uint32_t>& outputBinary) {
                 using namespace spvtools;

MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.h

@@ -43,6 +43,16 @@ namespace MobileGL {
                 // devices lacking GL_NV_shader_noperspective_interpolation. See EmulateNoPerspectivePass.
                 static bool EmulateNoPerspectiveForEssl(const Vector<Uint32>& inputBinary,
                                                         Vector<uint32_t>& outputBinary);
+                // Rewrites rectangle images (Dim::Rect) to plain 2D so SPIRV-Cross can emit ESSL
+                // for them at all - it refuses outright ("Rectangle textures are not supported on
+                // OpenGL ES"), which left the whole program unlinkable. Only valid while every use
+                // of the image takes integer texel coordinates (texelFetch / textureSize), where a
+                // rectangle target and a 2D target are indistinguishable; a normalized-coordinate
+                // lookup would also need its coordinates divided by the texture size, so the pass
+                // declines those modules instead of emitting something subtly wrong. Returns false
+                // when it changed nothing or cannot safely convert. DirectGLES only.
+                static bool LowerRectImagesForEssl(const Vector<Uint32>& inputBinary,
+                                                   Vector<uint32_t>& outputBinary);
                 // Rebases loads of the InstanceIndex builtin to (InstanceIndex - BaseInstance) so
                 // shaders see GL's zero-based gl_InstanceID. Vertex shaders only; DirectVulkan
                 // backend only (glslang's relaxed mode aliases gl_InstanceID to gl_InstanceIndex,

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;
@@ -66,7 +74,15 @@ namespace MobileGL::MG_Util::TextureFormatProcessor {
             switch (internalFormat) {
             case GL_DEPTH_COMPONENT32:
                 if (options & PixelFormatNormalizeOptionBit::NoDepthComponent32) {
-                    *outInternalFormat = GL_DEPTH_COMPONENT;
+                    // The unsized GL_DEPTH_COMPONENT base format is not a legal
+                    // glTexStorage/glRenderbufferStorage internal format on ES, which left
+                    // the attachment with no storage at all (KHR-GL3x.framebuffer_blit's
+                    // GL_DEPTH_COMPONENT32 config then read an incomplete framebuffer).
+                    // GL_DEPTH_COMPONENT24 is the nearest sized ES format that keeps the
+                    // same fixed-point encoding, so the GL_UNSIGNED_INT transfer type below
+                    // still describes the data; GL_DEPTH_COMPONENT32F would need a float
+                    // conversion the upload path does not apply.
+                    *outInternalFormat = GL_DEPTH_COMPONENT24;
                     break;
                 }
                 *outInternalFormat = internalFormat;
@@ -79,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;
@@ -109,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)) {
@@ -142,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;
@@ -552,6 +587,8 @@ namespace MobileGL::MG_Util::TextureFormatProcessor {
                 *outType = GL_UNSIGNED_INT;
                 break;
             case GL_DEPTH_COMPONENT32:
+                // Follows the internal-format normalization above: ES only accepts
+                // GL_FLOAT data for a GL_DEPTH_COMPONENT32F store.
                 *outType = GL_UNSIGNED_INT;
                 break;
             case GL_DEPTH_COMPONENT32F:

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 {

MobileGL/MG_Util/Types.h

@@ -181,7 +181,19 @@ namespace MobileGL {
         explicit BindingSlotRange1D(TargetEnum target, const Range1D& range = Range1D())
             : BindingSlot<ObjectType>(target), m_range(range) {}
 
-        Range1D GetRange() const { return m_range; }
+        // The range the binding actually covers right now. A whole-buffer binding
+        // (glBindBufferBase) does not freeze anything: GL resolves it against the
+        // object's size at every use, so a glBufferData issued after the bind has to
+        // be visible here - binding an empty buffer and giving it storage afterwards
+        // is ordinary application code. Only glBindBufferRange pins a fixed window.
+        Range1D GetRange() const {
+            if (!m_hasExplicitRange) {
+                if (const auto& object = this->GetBoundObject()) {
+                    return Range1D(0, object->GetSize());
+                }
+            }
+            return m_range;
+        }
 
         Bool HasExplicitRange() const { return m_hasExplicitRange; }
 

tools/cts/scripts/run_cts_local.py

@@ -58,11 +58,26 @@ def main():
     # explode (a 4-sample 16K depth texture alone is 4 GiB).
     ap.add_argument("--surface-size", type=int, default=256,
                     help="--deqp-surface-width/height value")
+    # With DONT_CARE depth/stencil bits dEQP's FboRenderContext picks the first entry of
+    # its own format list, GL_DEPTH32F_STENCIL8. framebuffer_blit meanwhile hardcodes
+    # GL_DEPTH24_STENCIL8 for its own buffers whenever it detects an FBO surface, then
+    # blits depth between the two - which the spec forbids for mismatched formats, so a
+    # conformant driver has to fail it. Asking for a config the test agrees with avoids
+    # the contradiction instead of papering over it.
+    ap.add_argument("--gl-config-name", default="rgba8888d24s8",
+                    help="--deqp-gl-config-name value (empty string to leave it unset)")
     ap.add_argument("--max-rounds", type=int, default=4000)
     ap.add_argument("--max-empty-streak", type=int, default=64,
                     help="abort after this many consecutive chunks that produce no log at all")
     ap.add_argument("--chunk-timeout", type=int, default=1800,
                     help="seconds before killing one glcts invocation (a wedged case never returns)")
+    # dEQP's watchdog aborts the process when a single case exceeds a hardcoded 30s
+    # (framework/common/tcuApp.hpp), which is not a hang on a CPU rasterizer - some
+    # texture_swizzle cases legitimately take ~17s each and cross it once the process is
+    # warm, so they came back as spurious Timeouts. dEQP's own default is off; the
+    # chunk-timeout above is what actually rescues a genuinely wedged case.
+    ap.add_argument("--watchdog", default="disable", choices=["enable", "disable"],
+                    help="--deqp-watchdog value")
     ap.add_argument("--skip-file", default=None,
                     help="file of case names to exclude, e.g. cases known to wedge the host")
     ap.add_argument("--waiver-file", default=None,
@@ -130,13 +145,13 @@ def main():
             f"--deqp-surface-width={args.surface_size}",
             f"--deqp-surface-height={args.surface_size}",
             "--deqp-terminate-on-device-lost=disable",
-            # A wedged case aborts the process instead of stalling the chunk;
-            # the runner then records it as Crash and resumes past it.
-            "--deqp-watchdog=enable",
+            f"--deqp-watchdog={args.watchdog}",
             "--deqp-log-images=disable",
             "--deqp-log-shader-sources=disable",
             f"--deqp-log-filename={qpa}",
         ]
+        if args.gl_config_name:
+            cmd.append(f"--deqp-gl-config-name={args.gl_config_name}")
         if args.waiver_file:
             cmd.append(f"--deqp-waiver-file={os.path.abspath(args.waiver_file)}")
         timed_out = False