[Feat] (DirectVulkan): relax fragment precision where the bound formats allow it

- WIP, parked: measures 80.9 -> 94.8 fps on Adreno 650 / MC 26.2 (same scene,
  device cooled to 38-40C), but is NOT validated. Desktop GLSL carries no
  precision qualifiers, so every fragment value reaches the driver as fp32 while
  Adreno runs fp16 at twice the rate.
- RelaxTextureDerivedPrecisionPass taints the values a fragment shader derives
  from built-in inputs and decorates everything else RelaxedPrecision. The
  taint direction matters: whitelisting outward from texture reads captures
  nothing, because MC multiplies every texel by an interpolated colour and a UBO
  value and one un-relaxed operand vetoes the expression - measured at 80.4 fps,
  i.e. no gain, both with and without varyings seeded. Precision-critical
  sources are few (gl_FragCoord cannot even hold a 3044-pixel x exactly), so
  tainting them and relaxing the rest is what actually pays.
- SPIR-V cannot see the bound formats - sampler2D yields vec4 whether the
  texture is RGBA8 or RGBA32F - so the decision is made per draw and passed in
  as a compile option, the same shape ExplicitLod0Sampling already uses.
  RelaxedFragmentPrecision is only requested when every sampled texture and
  every colour attachment is an 8-bit-or-less normalized format, where fp16's
  11-bit mantissa already carries the value exactly. Shaderpack HDR gbuffers,
  float data textures and 16-bit normalized targets therefore keep full
  precision, as do shaders that write gl_FragDepth or gl_SampleMask.
- LocalMultiStoreElim runs first: glslang emits function-local variables, and a
  load can never be relaxed, so without SSA promotion the analysis dies at the
  first temporary.
- WHY THIS IS PARKED: the retrace correctness gate never ran green. Every
  DirectVulkan retrace on Adreno 650 dies with DEVICE_LOST in
  UploadDirtyMipLevels on unmodified dev (pre-existing, device-gated), and on
  Adreno 830 - where the gate does pass on dev - minecraft-1.21.4-in-world times
  out at 900s with this change, which still needs explaining. Do not merge until
  that is understood and vanilla plus non-Photon shaderpack cases pass.
  (photon-v1.3b is broken on Adreno independently of this work.)
- The /sdcard/MG/exp_relaxed_precision_all and exp_no_relaxed_precision file
  toggles are development scaffolding for A/B measurement; they must go before
  this ships.

CMakeLists.txt

@@ -455,8 +455,21 @@ if (ANDROID)
 endif()
 
 if (APPLE AND NOT MOBILEGL_IOS)
+    # MobileGL statically embeds glslang, SPIRV-Tools, and SPIRV-Cross. When
+    # this dylib is injected with DYLD_INSERT_LIBRARIES, exporting those C++
+    # symbols interposes incompatible copies embedded by host libraries such
+    # as shaderc. Keep only the public GL/EGL/CGL loader surface globally
+    # visible; GetProcAddress can still return pointers to hidden internals.
+    set(MOBILEGL_MACOS_EXPORTED_SYMBOLS
+        "${CMAKE_CURRENT_SOURCE_DIR}/MobileGL/MG_Impl/DyldInterpose/ExportedSymbols.txt")
+    target_link_options(${CMAKE_PROJECT_NAME} PRIVATE
+        "LINKER:-exported_symbols_list,${MOBILEGL_MACOS_EXPORTED_SYMBOLS}")
+    set_property(TARGET ${CMAKE_PROJECT_NAME} APPEND PROPERTY
+        LINK_DEPENDS "${MOBILEGL_MACOS_EXPORTED_SYMBOLS}")
+
     target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC
         "-framework Cocoa"
+        "-framework CoreVideo"
         "-framework QuartzCore"
         "-framework Foundation"
         "-framework OpenGL"
@@ -464,6 +477,7 @@ if (APPLE AND NOT MOBILEGL_IOS)
     if(TARGET ${CMAKE_PROJECT_NAME}_s)
         target_link_libraries(${CMAKE_PROJECT_NAME}_s PUBLIC
             "-framework Cocoa"
+            "-framework CoreVideo"
             "-framework QuartzCore"
             "-framework Foundation"
             "-framework OpenGL"

MobileGL/Init.cpp

@@ -14,6 +14,7 @@
 #include <MG_State/EGLState/Core.h>
 #include <MG_Impl/GLImpl/Texture/ProxyTexture.h>
 #include <MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h>
+#include <MG_Impl/GLImpl/Sync/GL_Sync.h>
 
 #include <atomic>
 #include <mutex>
@@ -37,6 +38,12 @@ namespace MobileGL {
                 MGLOG_I("MobileGL closing...");
             }
             glslang::FinalizeProcess();
+            // GL syncs die with their contexts, and every context is gone by the
+            // time full teardown runs: drain the live-sync registry while the
+            // backend function table can still release the backend handles (and
+            // before a re-initialized library could pair them with the wrong
+            // backend's DeleteSync).
+            MG_Impl::GLImpl::DestroyAllSyncObjects();
             MG_Backend::pActiveBackendObject.reset();
             MG_State::pGLContext.reset();
             MG_State::pEGLContext.reset();
@@ -100,9 +107,11 @@ namespace MobileGL {
     // (EGL/WGL/CGL): initialization happens lazily on the first entry point
     // via EnsureInitialized(), and full teardown happens deterministically
     // when the last EGL display is terminated with nothing current (EGLImpl
-    // calls Destroy()). There is intentionally no static constructor, no
-    // static destructor, and no DllMain: the global singletons use
-    // leak-at-exit storage (see GlobalObjects.cpp), so a process that exits
+    // calls Destroy()). There is intentionally no backend-initializing static
+    // constructor, no static destructor, and no DllMain: the global singletons
+    // use leak-at-exit storage (see GlobalObjects.cpp), so a process that exits
     // without eglTerminate simply leaks them to the OS instead of running
-    // backend destructors during static teardown.
+    // backend destructors during static teardown. macOS has a lightweight
+    // dyld constructor that installs NSOpenGL dispatch hooks only; full backend
+    // initialization still enters here from the first hooked CGL context.
 } // namespace MobileGL

MobileGL/Init.h

@@ -13,9 +13,10 @@ namespace MobileGL {
     void Initialize();
     // Thread-safe, idempotent, and re-entrant wrapper around Initialize().
     // Host layers (EGL/WGL/CGL entry points) call this lazily on first use so
-    // MobileGL's lifecycle never depends on ELF/DLL static constructors, and
-    // so a fresh init can follow a full Destroy() (e.g. after the last
-    // eglTerminate).
+    // full backend initialization never depends on ELF/DLL static constructors,
+    // and so a fresh init can follow a full Destroy() (e.g. after the last
+    // eglTerminate). The macOS dyld bootstrap installs only lightweight
+    // NSOpenGL method hooks.
     void EnsureInitialized();
     void Destroy();
 

MobileGL/MG_Backend/DirectGLES/DirectGLES.cpp

@@ -3435,90 +3435,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         return componentType != 0 ? static_cast<GLenum>(componentType) : GL_UNSIGNED_NORMALIZED;
     }
 
-    // Repacks wide RGBA(_INTEGER) rows into the client's (format, type) layout, honoring the
-    // client-side PACK parameters and the bound pixel-pack buffer. `wide` holds
-    // `sliceHeight * sliceCount` rows of `width` texels (slice-major, tightly stacked),
-    // 4 components x GetReadbackComponentSize(wideType) bytes each.
-    // applyPackImageParams: GL_PACK_IMAGE_HEIGHT / GL_PACK_SKIP_IMAGES apply only to GetTexImage
-    // of 3D/array images; ReadPixels and 2D GetTexImage ignore them (GL 3.3 sections 4.3.1, 6.1.4).
-    // Per the GL addressing rules, slice k row j lands at
-    // SKIP_IMAGES*imageStride + SKIP_ROWS*rowStride + SKIP_PIXELS*pixelBytes
-    //   + k*imageStride + j*rowStride, with imageStride = max(IMAGE_HEIGHT, sliceHeight)*rowStride.
-    static Bool StoreWideRowsToClient(const Uint8* wide, GLenum wideType, GLsizei width, GLsizei sliceHeight,
-                                      GLsizei sliceCount, const ReadbackChannelMapping& mapping, GLenum type,
-                                      void* pixels, Bool applyPackImageParams) {
-        const SizeT dstPixelBytes = GetReadbackDstPixelSize(mapping, type);
-        if (dstPixelBytes == 0) {
-            return false;
-        }
-        ReadbackImpl::PackedReadbackLayout packedLayout{};
-        const Bool isPackedType = ReadbackImpl::GetPackedReadbackLayout(type, packedLayout);
-        const SizeT dstComponentSize = GetReadbackComponentSize(type);
-
-        const auto& pixelPackBufferObject =
-            MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::PixelPack).GetBoundObject();
-
-        // Destination layout is computed from the client-side PACK parameters; only the actual pixel
-        // rows are written so skip regions of the destination stay untouched.
-        const auto packParams = MG_State::pGLContext->GetPixelStoreParameters(false);
-        const SizeT rowPixels = static_cast<SizeT>(packParams.RowLength > 0 ? packParams.RowLength : width);
-        const SizeT dstRowStride = AlignPixelRow(rowPixels * dstPixelBytes, packParams.Alignment);
-        const SizeT imageRows =
-            applyPackImageParams && packParams.ImageHeight > 0
-                ? static_cast<SizeT>(packParams.ImageHeight)
-                : static_cast<SizeT>(sliceHeight);
-        const SizeT dstImageStride = imageRows * dstRowStride;
-        const SizeT skipImages =
-            applyPackImageParams ? static_cast<SizeT>(std::max(packParams.SkipImages, 0)) : SizeT{0};
-        const SizeT dstSkipOffset = skipImages * dstImageStride +
-                                    static_cast<SizeT>(std::max(packParams.SkipRows, 0)) * dstRowStride +
-                                    static_cast<SizeT>(std::max(packParams.SkipPixels, 0)) * dstPixelBytes;
-        const SizeT dstRowBytes = static_cast<SizeT>(width) * dstPixelBytes;
-
-        const SizeT pboBaseOffset = reinterpret_cast<SizeT>(pixels); // with a PBO, `pixels` is an offset
-        if (pixelPackBufferObject) {
-            const SizeT requiredSize = pboBaseOffset + dstSkipOffset +
-                                       static_cast<SizeT>(sliceCount - 1) * dstImageStride +
-                                       static_cast<SizeT>(sliceHeight - 1) * dstRowStride + dstRowBytes;
-            if (requiredSize > pixelPackBufferObject->GetSize()) {
-                MGLOG_E("Readback conversion: pixel pack buffer is too small");
-                return true;
-            }
-        }
-
-        const SizeT srcComponentSize = GetReadbackComponentSize(wideType);
-        const SizeT srcPixelBytes = 4 * srcComponentSize;
-        Vector<Uint8> convertedRow(dstRowBytes);
-
-        for (GLsizei slice = 0; slice < sliceCount; ++slice) {
-            for (GLsizei row = 0; row < sliceHeight; ++row) {
-                const SizeT flatRow = static_cast<SizeT>(slice) * static_cast<SizeT>(sliceHeight) +
-                                      static_cast<SizeT>(row);
-                const Uint8* srcRow = wide + flatRow * static_cast<SizeT>(width) * srcPixelBytes;
-                ReadbackImpl::ConvertWideReadbackRow(srcRow, convertedRow.data(), static_cast<SizeT>(width), wideType,
-                                                     mapping, type);
-
-                if (packParams.SwapBytes) {
-                    const SizeT groupSize = isPackedType ? packedLayout.byteSize : dstComponentSize;
-                    if (groupSize > 1) {
-                        for (SizeT offset = 0; offset + groupSize <= dstRowBytes; offset += groupSize) {
-                            std::reverse(convertedRow.data() + offset, convertedRow.data() + offset + groupSize);
-                        }
-                    }
-                }
-
-                const SizeT dstOffset = dstSkipOffset + static_cast<SizeT>(slice) * dstImageStride +
-                                        static_cast<SizeT>(row) * dstRowStride;
-                if (pixelPackBufferObject) {
-                    pixelPackBufferObject->WritebackFromBackend({convertedRow.data(), dstRowBytes},
-                                                                pboBaseOffset + dstOffset);
-                } else {
-                    Memcpy(static_cast<Uint8*>(pixels) + dstOffset, convertedRow.data(), dstRowBytes);
-                }
-            }
-        }
-        return true;
-    }
 
     // Reads the current READ framebuffer as wide RGBA(_INTEGER) and repacks the pixels into the client's
     // (format, type) layout. Returns false when the combination is not convertible (the caller keeps its
@@ -3651,7 +3567,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             ExpandNarrowWideRead(wide, static_cast<SizeT>(width) * static_cast<SizeT>(height), readChannels, wideType);
         }
 
-        if (!StoreWideRowsToClient(wide.data(), wideType, width, height, /*sliceCount=*/1, mapping, type, pixels,
+        if (!ReadbackImpl::StoreWideRowsToClient(wide.data(), wideType, width, height, /*sliceCount=*/1, mapping, type, pixels,
                                    honorPackImageParams)) {
             return false;
         }
@@ -3705,7 +3621,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return false;
         }
         const GLenum wideType = isInteger ? (isSigned ? GL_INT : GL_UNSIGNED_INT) : GL_FLOAT;
-        if (!StoreWideRowsToClient(wide.data(), wideType, width, sliceHeight, sliceCount, mapping, type, pixels,
+        if (!ReadbackImpl::StoreWideRowsToClient(wide.data(), wideType, width, sliceHeight, sliceCount, mapping, type, pixels,
                                    applyPackImageParams)) {
             return false;
         }

MobileGL/MG_Backend/DirectGLES/Utils.cpp

@@ -764,5 +764,95 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
             }
         }
+
+        static SizeT AlignReadbackRow(SizeT rowBytes, Int alignment) {
+            const SizeT align = alignment > 0 ? static_cast<SizeT>(alignment) : 1;
+            return (rowBytes + align - 1) / align * align;
+        }
+
+    // Repacks wide RGBA(_INTEGER) rows into the client's (format, type) layout, honoring the
+        // client-side PACK parameters and the bound pixel-pack buffer. `wide` holds
+        // `sliceHeight * sliceCount` rows of `width` texels (slice-major, tightly stacked),
+        // 4 components x GetReadbackComponentSize(wideType) bytes each.
+        // applyPackImageParams: GL_PACK_IMAGE_HEIGHT / GL_PACK_SKIP_IMAGES apply only to GetTexImage
+        // of 3D/array images; ReadPixels and 2D GetTexImage ignore them (GL 3.3 sections 4.3.1, 6.1.4).
+        // Per the GL addressing rules, slice k row j lands at
+        // SKIP_IMAGES*imageStride + SKIP_ROWS*rowStride + SKIP_PIXELS*pixelBytes
+        //   + k*imageStride + j*rowStride, with imageStride = max(IMAGE_HEIGHT, sliceHeight)*rowStride.
+        Bool StoreWideRowsToClient(const Uint8* wide, GLenum wideType, GLsizei width, GLsizei sliceHeight,
+                                   GLsizei sliceCount, const ReadbackChannelMapping& mapping, GLenum type,
+                                   void* pixels, Bool applyPackImageParams) {
+        const SizeT dstPixelBytes = GetReadbackDstPixelSize(mapping, type);
+        if (dstPixelBytes == 0) {
+            return false;
+        }
+        PackedReadbackLayout packedLayout{};
+        const Bool isPackedType = GetPackedReadbackLayout(type, packedLayout);
+        const SizeT dstComponentSize = GetReadbackComponentSize(type);
+
+        const auto& pixelPackBufferObject =
+            MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::PixelPack).GetBoundObject();
+
+        // Destination layout is computed from the client-side PACK parameters; only the actual pixel
+        // rows are written so skip regions of the destination stay untouched.
+        const auto packParams = MG_State::pGLContext->GetPixelStoreParameters(false);
+        const SizeT rowPixels = static_cast<SizeT>(packParams.RowLength > 0 ? packParams.RowLength : width);
+        const SizeT dstRowStride = AlignReadbackRow(rowPixels * dstPixelBytes, packParams.Alignment);
+        const SizeT imageRows =
+            applyPackImageParams && packParams.ImageHeight > 0
+                ? static_cast<SizeT>(packParams.ImageHeight)
+                : static_cast<SizeT>(sliceHeight);
+        const SizeT dstImageStride = imageRows * dstRowStride;
+        const SizeT skipImages =
+            applyPackImageParams ? static_cast<SizeT>(std::max(packParams.SkipImages, 0)) : SizeT{0};
+        const SizeT dstSkipOffset = skipImages * dstImageStride +
+                                    static_cast<SizeT>(std::max(packParams.SkipRows, 0)) * dstRowStride +
+                                    static_cast<SizeT>(std::max(packParams.SkipPixels, 0)) * dstPixelBytes;
+        const SizeT dstRowBytes = static_cast<SizeT>(width) * dstPixelBytes;
+
+        const SizeT pboBaseOffset = reinterpret_cast<SizeT>(pixels); // with a PBO, `pixels` is an offset
+        if (pixelPackBufferObject) {
+            const SizeT requiredSize = pboBaseOffset + dstSkipOffset +
+                                    static_cast<SizeT>(sliceCount - 1) * dstImageStride +
+                                    static_cast<SizeT>(sliceHeight - 1) * dstRowStride + dstRowBytes;
+            if (requiredSize > pixelPackBufferObject->GetSize()) {
+                MGLOG_E("Readback conversion: pixel pack buffer is too small");
+                return true;
+            }
+        }
+
+        const SizeT srcComponentSize = GetReadbackComponentSize(wideType);
+        const SizeT srcPixelBytes = 4 * srcComponentSize;
+        Vector<Uint8> convertedRow(dstRowBytes);
+
+        for (GLsizei slice = 0; slice < sliceCount; ++slice) {
+            for (GLsizei row = 0; row < sliceHeight; ++row) {
+                const SizeT flatRow = static_cast<SizeT>(slice) * static_cast<SizeT>(sliceHeight) +
+                                   static_cast<SizeT>(row);
+                const Uint8* srcRow = wide + flatRow * static_cast<SizeT>(width) * srcPixelBytes;
+                ConvertWideReadbackRow(srcRow, convertedRow.data(), static_cast<SizeT>(width), wideType,
+                                                  mapping, type);
+
+                if (packParams.SwapBytes) {
+                    const SizeT groupSize = isPackedType ? packedLayout.byteSize : dstComponentSize;
+                    if (groupSize > 1) {
+                        for (SizeT offset = 0; offset + groupSize <= dstRowBytes; offset += groupSize) {
+                            std::reverse(convertedRow.data() + offset, convertedRow.data() + offset + groupSize);
+                        }
+                    }
+                }
+
+                const SizeT dstOffset = dstSkipOffset + static_cast<SizeT>(slice) * dstImageStride +
+                                     static_cast<SizeT>(row) * dstRowStride;
+                if (pixelPackBufferObject) {
+                    pixelPackBufferObject->WritebackFromBackend({convertedRow.data(), dstRowBytes},
+                                                             pboBaseOffset + dstOffset);
+                } else {
+                    Memcpy(static_cast<Uint8*>(pixels) + dstOffset, convertedRow.data(), dstRowBytes);
+                }
+            }
+        }
+            return true;
+        }
     } // namespace ReadbackImpl
 } // namespace MobileGL::MG_Backend::DirectGLES

MobileGL/MG_Backend/DirectGLES/Utils.h

@@ -88,6 +88,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
         // bytes, dst receives width * GetReadbackDstPixelSize(mapping, type) bytes.
         void ConvertWideReadbackRow(const Uint8* src, Uint8* dst, SizeT width, GLenum wideType,
                                     const ReadbackChannelMapping& mapping, GLenum type);
+
+        // Stores wide RGBA(_INTEGER) rows into the client pointer or the bound PACK pixel buffer,
+        // honoring the client-side PACK pixel-store parameters (row length, alignment, skips,
+        // swap-bytes, and - when applyPackImageParams - image height/skip images). Shared by the
+        // DirectGLES and DirectVulkan readback conversion paths.
+        Bool StoreWideRowsToClient(const Uint8* wide, GLenum wideType, GLsizei width, GLsizei sliceHeight,
+                                   GLsizei sliceCount, const ReadbackChannelMapping& mapping, GLenum type,
+                                   void* pixels, Bool applyPackImageParams);
     } // namespace ReadbackImpl
 
     namespace PrgramImpl {

MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.cpp

@@ -140,6 +140,20 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             case TextureInternalFormat::RGB:
             case TextureInternalFormat::RGB8:
                 return TextureInternalFormat::RGBA8;
+            // Legacy low-bit-depth formats with no (or rarely supported) native Vulkan
+            // encoding; a wider normalized fallback keeps at least the required precision.
+            case TextureInternalFormat::R3G3B2:
+            case TextureInternalFormat::RGB4:
+            case TextureInternalFormat::RGB5:
+            case TextureInternalFormat::RGBA2:
+            case TextureInternalFormat::RGBA4:
+            case TextureInternalFormat::RGB5A1:
+                return TextureInternalFormat::RGBA8;
+            case TextureInternalFormat::RGB10:
+                return TextureInternalFormat::RGB10A2;
+            case TextureInternalFormat::RGB12:
+            case TextureInternalFormat::RGBA12:
+                return TextureInternalFormat::RGBA16;
             case TextureInternalFormat::SRGB8:
                 return TextureInternalFormat::SRGB8Alpha8;
             case TextureInternalFormat::RGB8Snorm:
@@ -455,6 +469,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // treat them as signaled/available with zero results from here on.
         BumpRendererGeneration();
         pVulkanRenderer.reset();
+        // The reflection cache is file-scope, not renderer-owned; without this the
+        // deleted programs' reflection strings survive full context teardown.
+        ClearProgramResourceCaches();
         BackendObject::ReleaseEGLResources();
     }
 
@@ -464,6 +481,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // treat them as signaled/available with zero results from here on.
         BumpRendererGeneration();
         pVulkanRenderer.reset();
+        // The reflection cache is file-scope, not renderer-owned; without this the
+        // deleted programs' reflection strings survive full context teardown.
+        ClearProgramResourceCaches();
     }
 
     const RendererInfo& BackendObject_DirectVulkan::GetRendererInfo() const {

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.cpp

@@ -61,6 +61,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         };
 
         struct ProgramResourceCache {
+            // Lifetime id of the program the cached reflection belongs to. GL names are
+            // recycled (IndexGenerator hands freed indices straight back), and a
+            // recreated program's backendStateVersion restarts at the same small values,
+            // so the version alone can collide; the never-reused lifetime id makes the
+            // slot's ownership unambiguous.
+            Uint64 programLifetimeId = 0;
             Uint32 backendStateVersion = 0;
             Vector<StorageBlockResource> storageBlocks;
             Vector<BufferVariableResource> bufferVariables;
@@ -82,6 +88,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint32 baseInstance = 0;
         };
 
+        // Keyed by GL program name so the freed-name reuse in IndexGenerator bounds the
+        // map at the peak-simultaneous-program high-water mark; each slot's ownership is
+        // checked against the program's lifetime id before it is served (see
+        // GetProgramResourceCache). Cleared wholesale at EGL teardown via
+        // ClearProgramResourceCaches.
         UnorderedMap<GLuint, ProgramResourceCache> g_programResourceCaches;
 
         void ClearReadPixelsOutput(GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) {
@@ -142,13 +153,19 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         ProgramResourceCache& GetProgramResourceCache(const MG_State::GLState::ProgramObject& program) {
             auto& cache = g_programResourceCaches[program.GetExternalIndex()];
+            const Uint64 programLifetimeId = program.GetLifetimeId();
             const Uint32 backendStateVersion = program.GetBackendStateVersion();
-            if (cache.backendStateVersion == backendStateVersion &&
+            // The lifetime id must match too: a new program that reuses a deleted
+            // program's name and happens to land on the same backendStateVersion (both
+            // count from zero) would otherwise be served the dead program's reflection.
+            if (cache.programLifetimeId == programLifetimeId &&
+                cache.backendStateVersion == backendStateVersion &&
                 (!cache.storageBlocks.empty() || !cache.bufferVariables.empty())) {
                 return cache;
             }
 
             cache = {};
+            cache.programLifetimeId = programLifetimeId;
             cache.backendStateVersion = backendStateVersion;
 
             Vector<SpvReflectShaderModule> modules;
@@ -366,6 +383,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
     } // namespace
 
+    void ClearProgramResourceCaches() {
+        // Called from EGL teardown while the backend's m_eglStateMutex is held; GL
+        // calls are serialized in this codebase (contexts migrate threads but never
+        // run concurrently), so no other thread can be inside the unsynchronized map.
+        // Live programs in another context self-heal: their entry rebuilds from the
+        // retained generated SPIR-V on the next resource query.
+        g_programResourceCaches.clear();
+    }
+
     GLuint GetShaderStorageBlockIndex(const MG_State::GLState::ProgramObject& program, const String& name) {
         auto& cache = GetProgramResourceCache(program);
         const auto it = std::find_if(cache.storageBlocks.begin(), cache.storageBlocks.end(),

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.h

@@ -23,6 +23,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     Uint64 GetRendererGeneration();
     void BumpRendererGeneration();
 
+    // Drops every cached program-resource reflection entry (CPU-side strings/vectors
+    // only, no Vulkan handles). Called at EGL teardown next to the renderer reset;
+    // safe because GL calls are serialized in this codebase, and any still-live
+    // program rebuilds its entry from the retained generated SPIR-V on demand.
+    void ClearProgramResourceCaches();
+
     void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
     void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value);
     void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value);

MobileGL/MG_Backend/DirectVulkan/Renderer/FrameContext.cpp

@@ -150,12 +150,30 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     Bool FrameContext::TransitionToPresent(VkImage image, VkImageLayout oldLayout, VkImageLayout presentLayout) {
         auto& frame = GetCurrent();
-        if (frame.hasCommandBufferRecorded || frame.isCommandRecording || oldLayout == presentLayout ||
-            oldLayout == VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR) {
+        if (oldLayout == presentLayout || oldLayout == VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR) {
             return false;
         }
 
-        auto& commandBuffer = BeginCommandRecording();
+        // The barrier belongs in the frame's own recording. Bailing out because
+        // something was already recorded (the previous behaviour) dropped the
+        // transition entirely for every frame that never ran a default-framebuffer
+        // render pass - the only other thing that carries the image to
+        // PRESENT_SRC_KHR, via that pass's finalLayout - so the swapchain image was
+        // handed to the WSI still in the layout it was acquired in.
+        // A closed-but-unsubmitted buffer can only come from a submit that already
+        // failed (SubmitPendingCommandBuffer leaves the flag set on error), and
+        // appending to it is illegal while reopening would reset the frame's own
+        // commands away. The device is gone on that path anyway - stay silent-safe
+        // rather than trade a lost device for a barrier into a closed buffer.
+        if (frame.hasCommandBufferRecorded) {
+            MGLOG_E("TransitionToPresent: command buffer already closed; skipping the present barrier");
+            return false;
+        }
+
+        // Reopening a recording here would vkResetCommandBuffer this frame's own
+        // commands away, so append to the open one and let the caller close it.
+        const Bool openedRecording = !frame.isCommandRecording;
+        VkCommandBuffer commandBuffer = openedRecording ? BeginCommandRecording() : frame.commandBuffer;
 
         VkImageMemoryBarrier presentBarrier{};
         presentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -174,7 +192,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0,
                              nullptr, 0, nullptr, 1, &presentBarrier);
 
-        EndCommandRecording();
+        if (openedRecording) {
+            EndCommandRecording();
+        }
         return true;
     }
 
@@ -227,12 +247,21 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         result = vkAcquireNextImageKHR(device, swapchain, timeout, frame.imageAvailableSemaphore, acquireFence,
                                        &outImageIndex);
-        if (result != VK_SUCCESS) {
+        // VK_SUBOPTIMAL_KHR is a success code: an image *was* acquired and
+        // imageAvailableSemaphore *will* be signaled. Bailing out on it skipped both
+        // the consumed-flag reset (leaving a stale "already consumed", so the next
+        // submit never waited on the pending signal) and the fence reset (leaving
+        // the slot's fence signaled for the next submit to reuse). Only a genuine
+        // failure - VK_ERROR_OUT_OF_DATE_KHR and friends, where nothing is acquired
+        // and nothing is signaled - skips the bookkeeping.
+        if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
             return result;
         }
 
         frame.imageAvailableSemaphoreConsumed = false;
-        return vkResetFences(device, 1, &frame.imageInFlightFence);
+        const VkResult resetResult = vkResetFences(device, 1, &frame.imageInFlightFence);
+        // Hand the acquire's own code back so the caller can schedule a rebuild.
+        return resetResult == VK_SUCCESS ? result : resetResult;
     }
 
     Uint32 FrameContext::GetCurrentFrameIndex() const {
@@ -264,7 +293,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (result != VK_SUCCESS) {
             return result;
         }
-        frame.retiredCommandBuffers.push_back(frame.commandBuffer);
+        // lastSubmitIndex was just written by the renderer for the submission
+        // that carried this command buffer.
+        frame.retiredCommandBuffers.push_back({frame.commandBuffer, frame.lastSubmitIndex});
         frame.commandBuffer = replacement;
         return VK_SUCCESS;
     }
@@ -274,12 +305,40 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return;
         }
         if (m_device != VK_NULL_HANDLE && m_commandPool != VK_NULL_HANDLE) {
-            vkFreeCommandBuffers(m_device, m_commandPool, static_cast<Uint32>(frame.retiredCommandBuffers.size()),
-                                 frame.retiredCommandBuffers.data());
+            for (const auto& retired : frame.retiredCommandBuffers) {
+                vkFreeCommandBuffers(m_device, m_commandPool, 1, &retired.commandBuffer);
+            }
         }
         frame.retiredCommandBuffers.clear();
     }
 
+    void FrameContext::FreeRetiredCommandBuffersCompletedUpTo(Uint64 completedSubmitIndex) {
+        if (m_device == VK_NULL_HANDLE || m_commandPool == VK_NULL_HANDLE) {
+            return;
+        }
+        for (auto& frame : m_frames) {
+            // Retired buffers are appended in submit order, so the completed
+            // ones form a prefix.
+            SizeT completedCount = 0;
+            while (completedCount < frame.retiredCommandBuffers.size() &&
+                   frame.retiredCommandBuffers[completedCount].submitIndex <= completedSubmitIndex) {
+                vkFreeCommandBuffers(m_device, m_commandPool, 1,
+                                     &frame.retiredCommandBuffers[completedCount].commandBuffer);
+                ++completedCount;
+            }
+            if (completedCount > 0) {
+                frame.retiredCommandBuffers.erase(frame.retiredCommandBuffers.begin(),
+                                                  frame.retiredCommandBuffers.begin() + completedCount);
+            }
+        }
+    }
+
+    void FrameContext::FreeAllRetiredCommandBuffers() {
+        for (auto& frame : m_frames) {
+            FreeRetiredCommandBuffers(frame);
+        }
+    }
+
     void FrameContext::AssertValidFrameIndex(Uint32 frameIndex) const {
         MOBILEGL_ASSERT(frameIndex < m_frames.size(), "FrameContext index out of range");
     }

MobileGL/MG_Backend/DirectVulkan/Renderer/FrameContext.h

@@ -40,6 +40,16 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkPresentInfoKHR presentInfo{VK_STRUCTURE_TYPE_PRESENT_INFO_KHR};
         };
 
+        // A command buffer submitted mid-frame (FlushPendingCommands), tagged
+        // with the submit-tracker index it was submitted under so it can be
+        // freed as soon as that submission is observed complete - without
+        // waiting for the slot's fence to be waited again (present-less flush
+        // loops never wait it).
+        struct RetiredCommandBuffer {
+            VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
+            Uint64 submitIndex = 0;
+        };
+
         struct FrameData {
             VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
             VkSemaphore imageAvailableSemaphore = VK_NULL_HANDLE;
@@ -47,10 +57,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Bool isCommandRecording = false;
             Bool hasCommandBufferRecorded = false;
             Bool imageAvailableSemaphoreConsumed = false;
-            // Command buffers submitted mid-frame (FlushPendingCommands) whose
-            // execution is only known complete once this slot's fence has been
-            // waited again; freed at that point.
-            Vector<VkCommandBuffer> retiredCommandBuffers;
+            // Command buffers submitted mid-frame (FlushPendingCommands),
+            // appended in submit order; freed once their submission is known
+            // complete (fence wait or completion poll).
+            Vector<RetiredCommandBuffer> retiredCommandBuffers;
             // Submit-tracker index of this slot's most recent queue submission
             // (written by the renderer at submit time).
             Uint64 lastSubmitIndex = 0;
@@ -79,9 +89,19 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // Parks the current (already ended and submitted) command buffer on the
         // slot's retired list and installs a freshly allocated one, so recording
         // can restart while the submitted buffer is still executing. Retired
-        // buffers are freed after the slot's fence is next waited.
+        // buffers are freed after the slot's fence is next waited, or as soon
+        // as their submission is observed complete.
         VkResult RetireCurrentCommandBuffer();
 
+        // Frees every retired command buffer whose tagged submission index is
+        // known complete. Driven by the renderer's submit tracker on completion
+        // events (fence waits and non-blocking polls), so present-less flush
+        // loops reclaim their buffers without any extra wait.
+        void FreeRetiredCommandBuffersCompletedUpTo(Uint64 completedSubmitIndex);
+        // Frees every slot's retired command buffers. Only valid when the
+        // caller has proven every queue submission complete.
+        void FreeAllRetiredCommandBuffers();
+
         Uint32 GetCurrentFrameIndex() const;
         Uint32 GetFrameCount() const;
 

MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.cpp

@@ -8,6 +8,7 @@
 
 #include "PipelineFactory.h"
 
+#include <algorithm>
 
 namespace MobileGL::MG_Backend::DirectVulkan {
     static const char* PrimitiveTopologyToString(VkPrimitiveTopology topology) {
@@ -243,23 +244,108 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const HashType hash = ComputeHash(payload);
         auto it = m_cache.find(hash);
         if (it != m_cache.end()) {
-            return it->second;
+            it->second.lastUsedFrame = m_frameCounter;
+            return it->second.pipeline;
         }
 
         VkPipeline pipeline = CreatePipeline(payload);
-        m_cache.emplace(hash, pipeline);
+        m_cache.emplace(hash, PipelineCacheEntry{pipeline, payload.programHash, payload.renderPass,
+                                                 m_frameCounter});
         return pipeline;
     }
 
     void PipelineFactory::DestroyAll() {
         for (auto& pair : m_cache) {
-            if (pair.second != VK_NULL_HANDLE) {
-                vkDestroyPipeline(m_device, pair.second, nullptr);
+            if (pair.second.pipeline != VK_NULL_HANDLE) {
+                vkDestroyPipeline(m_device, pair.second.pipeline, nullptr);
             }
         }
         m_cache.clear();
     }
 
+    Uint32 PipelineFactory::OnFrameBoundary() {
+        ++m_frameCounter;
+
+        // Sweep cadence and retire age mirror VkRenderPassManager::OnPresent: an entry
+        // idle for more than kRetireAgeFrames frame boundaries cannot be referenced by
+        // any in-flight command buffer (frames-in-flight <= MOBILEGL_MAGMA_FRAMESINFLIGHT),
+        // so immediate vkDestroyPipeline is safe. The caller must drop its "last
+        // pipeline" memo when this returns non-zero: the memo can return a cached
+        // handle without touching this cache, so an evicted pipeline may still be
+        // memoized (present-less flush loops never reset the memo per frame).
+        constexpr Uint64 kSweepInterval = 256;
+        constexpr Uint64 kRetireAgeFrames = 1024;
+        if ((m_frameCounter % kSweepInterval) != 0) {
+            return 0;
+        }
+
+        Uint32 evicted = 0;
+        for (auto it = m_cache.begin(); it != m_cache.end();) {
+            if (m_frameCounter - it->second.lastUsedFrame > kRetireAgeFrames) {
+                if (it->second.pipeline != VK_NULL_HANDLE) {
+                    vkDestroyPipeline(m_device, it->second.pipeline, nullptr);
+                }
+                it = m_cache.erase(it);
+                ++evicted;
+            } else {
+                ++it;
+            }
+        }
+        if (evicted > 0) {
+            MGLOG_D("PipelineFactory::OnFrameBoundary: evicted %u idle pipelines (%zu remain)", evicted,
+                    m_cache.size());
+        }
+        return evicted;
+    }
+
+    Uint32 PipelineFactory::EvictByRenderPasses(const Vector<VkRenderPass>& renderPasses) {
+        if (renderPasses.empty() || m_cache.empty()) {
+            return 0;
+        }
+        // Sorted-batch membership test keeps a mass eviction (shader-pack switch,
+        // dimension exit) at one O(cache * log batch) scan instead of one full scan
+        // per dying pass.
+        Vector<VkRenderPass> sortedPasses = renderPasses;
+        std::sort(sortedPasses.begin(), sortedPasses.end());
+        Uint32 evicted = 0;
+        for (auto it = m_cache.begin(); it != m_cache.end();) {
+            if (std::binary_search(sortedPasses.begin(), sortedPasses.end(), it->second.renderPass)) {
+                if (it->second.pipeline != VK_NULL_HANDLE) {
+                    vkDestroyPipeline(m_device, it->second.pipeline, nullptr);
+                }
+                it = m_cache.erase(it);
+                ++evicted;
+            } else {
+                ++it;
+            }
+        }
+        if (evicted > 0) {
+            MGLOG_D("PipelineFactory::EvictByRenderPasses: evicted %u pipelines for %zu destroyed render passes",
+                    evicted, sortedPasses.size());
+        }
+        return evicted;
+    }
+
+    Uint32 PipelineFactory::EvictByProgramHash(HashType programHash) {
+        Uint32 evicted = 0;
+        for (auto it = m_cache.begin(); it != m_cache.end();) {
+            if (it->second.programHash == programHash) {
+                if (it->second.pipeline != VK_NULL_HANDLE) {
+                    vkDestroyPipeline(m_device, it->second.pipeline, nullptr);
+                }
+                it = m_cache.erase(it);
+                ++evicted;
+            } else {
+                ++it;
+            }
+        }
+        if (evicted > 0) {
+            MGLOG_D("PipelineFactory::EvictByProgramHash: evicted %u pipelines for program hash 0x%llx",
+                    evicted, static_cast<unsigned long long>(programHash));
+        }
+        return evicted;
+    }
+
     VkPipeline PipelineFactory::CreatePipeline(const PipelineCreatePayload& payload) const {
         MOBILEGL_ASSERT(payload.stages != nullptr && !payload.stages->empty(), "PipelineFactory: stages are empty");
         MOBILEGL_ASSERT(payload.vertexInputState != nullptr, "PipelineFactory: vertexInputState is null");

MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.h

@@ -65,6 +65,26 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkPipeline GetOrCreatePipeline(const PipelineCreatePayload& payload);
         void DestroyAll();
 
+        // Frame boundary hook: ages the pipeline cache and destroys long-unused entries
+        // (their command buffers retired many frames ago), mirroring
+        // VkRenderPassManager::OnPresent's sweep. Returns the number of pipelines
+        // destroyed so the caller can drop any memoized VkPipeline handle.
+        Uint32 OnFrameBoundary();
+        // Destroys every cached pipeline hashed on one of `renderPasses`. Only safe
+        // when the caller guarantees GPU idleness for them - the render-pass manager
+        // calls this (via the renderer) for passes its own >1024-boundary-idle sweep
+        // just evicted, and a pipeline hashed on those handles is only ever bound by
+        // draws that also hit the render-pass entries. Also closes the handle-recycling
+        // hazard: a recycled VkRenderPass value must never serve a stale pipeline.
+        // Batched: one cache scan regardless of how many passes died in the sweep.
+        // Returns the number destroyed (callers invalidate memos when non-zero).
+        Uint32 EvictByRenderPasses(const Vector<VkRenderPass>& renderPasses);
+        // Destroys every cached pipeline built from the program with content hash
+        // `programHash`. Called from the ProgramFactory eviction path, which proves the
+        // same >1024-boundary idleness (the program's pipelines are only bound by draws
+        // that stamp its factory entry). Returns the number destroyed.
+        Uint32 EvictByProgramHash(HashType programHash);
+
         // Driver quirk: suppress depth writes on accumulation-blended pipelines. Multi-pass
         // depth-equality rendering (a blended prepass writes depth that later passes re-test
         // with an equality-inclusive compare on the re-rasterized geometry) requires
@@ -87,12 +107,26 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         static Bool ShouldSuppressDepthWrite(const PipelineCreatePayload& payload);
 
     private:
+        struct PipelineCacheEntry {
+            VkPipeline pipeline = VK_NULL_HANDLE;
+            // The hashed inputs the eviction paths key on: programHash ties the entry to
+            // its ProgramFactory entry, renderPass records the exact handle the hash
+            // folded in (the hash is one-way, so targeted eviction needs them verbatim).
+            HashType programHash = 0;
+            VkRenderPass renderPass = VK_NULL_HANDLE;
+            // Frame-boundary counter value of the last GetOrCreatePipeline hit; drives
+            // cache eviction (see OnFrameBoundary).
+            Uint64 lastUsedFrame = 0;
+        };
+
         VkPipeline CreatePipeline(const PipelineCreatePayload& payload) const;
 
         VkDevice m_device = VK_NULL_HANDLE;
         const VulkanRendererConfig& m_config;
         VkPipelineCache m_pipelineCache = VK_NULL_HANDLE;
-        UnorderedMap<HashType, VkPipeline> m_cache;
+        UnorderedMap<HashType, PipelineCacheEntry> m_cache;
+        // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
+        Uint64 m_frameCounter = 0;
         static inline XXH64_state_t* m_hashState = XXH64_createState();
         static inline Bool s_suppressBlendedDepthWrite = false;
     };

MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.cpp

@@ -12,7 +12,10 @@
 #include "MG_Util/ShaderTranspiler/ShaderCompiler.h"
 #include "MG_Util/ShaderTranspiler/SpvcSession.h"
 #include "MG_Util/ShaderTranspiler/Types.h"
+#include <cmath>
+#include <cstdio>
 #include <cstring>
+#include <unordered_set>
 #include <spirv-tools/libspirv.h>
 #include <spirv-tools/optimizer.hpp>
 #include <source/opt/build_module.h>
@@ -923,11 +926,610 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             ProgramFactory::CompileOptionFlags m_transformFlags;
         };
 
+        // Adreno 650 (driver 512.502) faults the GPU on an implicit-LOD sample of a full-screen
+        // colour render target: the texture unit's derivative path reads outside the image's
+        // allocation even though the sampler clamps LOD to 0 and the mapping is 1:1. MobileGL's
+        // own default-framebuffer blit shader works around it with textureLod, but an
+        // application's shader (Minecraft's blit.fsh is `texture(InSampler, texCoord)`) cannot be
+        // edited - so rewrite the sample at the SPIR-V level instead.
+        //
+        // The rewrite is only requested for draws whose every sampler binding is clamped to one
+        // mip level, where explicit LOD 0 is exactly what the implicit form must already produce:
+        // lambda' = clamp(lambda + bias, minLod, maxLod) with minLod = maxLod = 0. Bias and MinLod
+        // operands are therefore dropped rather than translated.
+        class ForceExplicitLod0SamplePass final : public spvtools::opt::Pass {
+        public:
+            const char* name() const override { return "force-explicit-lod0-sample"; }
+
+            Status Process() override {
+                Bool isFragment = false;
+                for (auto& entryPoint : get_module()->entry_points()) {
+                    if (entryPoint.opcode() != spv::Op::OpEntryPoint) continue;
+                    if (static_cast<spv::ExecutionModel>(entryPoint.GetSingleWordInOperand(0)) ==
+                        spv::ExecutionModel::Fragment) {
+                        isFragment = true;
+                        break;
+                    }
+                }
+                if (!isFragment) return Status::SuccessWithoutChange;
+
+                // Plan first, mutate second. Materializing the LOD constant is itself a module
+                // change, so it must not happen unless at least one rewrite is going to follow -
+                // otherwise the pass would grow the binary while reporting SuccessWithoutChange.
+                Vector<RewritePlan> plans;
+                for (auto& function : *get_module()) {
+                    for (auto& block : function) {
+                        for (auto& inst : block) {
+                            RewritePlan plan{};
+                            if (PlanRewrite(&inst, plan)) plans.push_back(Move(plan));
+                        }
+                    }
+                }
+                if (plans.empty()) return Status::SuccessWithoutChange;
+
+                const Uint32 zeroId = GetFloatZeroId();
+                if (zeroId == 0) return Status::SuccessWithoutChange;
+
+                for (auto& plan : plans) {
+                    plan.operands.push_back({SPV_OPERAND_TYPE_ID, {zeroId}});
+                    for (auto& operand : plan.trailingOperands) {
+                        plan.operands.push_back(operand);
+                    }
+                    plan.instruction->SetOpcode(plan.opcode);
+                    plan.instruction->SetInOperands(Move(plan.operands));
+                }
+                // Opcodes and operand lists changed underneath every cached analysis.
+                context()->InvalidateAnalysesExceptFor(spvtools::opt::IRContext::kAnalysisNone);
+                return Status::SuccessWithChange;
+            }
+
+        private:
+            struct RewritePlan {
+                spvtools::opt::Instruction* instruction = nullptr;
+                spv::Op opcode = spv::Op::OpNop;
+                // Everything up to and including the Image Operands mask; the Lod id and the
+                // trailing operand values are appended once the constant exists.
+                Vector<spvtools::opt::Operand> operands;
+                Vector<spvtools::opt::Operand> trailingOperands;
+            };
+
+            // Image Operands bits that may accompany an implicit-LOD sample, in the canonical
+            // ascending order SPIR-V requires the operand values to appear in.
+            static constexpr Uint32 kBias = 0x1;
+            static constexpr Uint32 kLod = 0x2;
+            static constexpr Uint32 kGrad = 0x4;
+            static constexpr Uint32 kConstOffset = 0x8;
+            static constexpr Uint32 kOffset = 0x10;
+            static constexpr Uint32 kConstOffsets = 0x20;
+            static constexpr Uint32 kSample = 0x40;
+            static constexpr Uint32 kMinLod = 0x80;
+            static constexpr Uint32 kKnownMask = 0xFF;
+
+            Uint32 GetFloatZeroId() {
+                // Reuse a 32-bit float type already in the module; a shader that samples always has
+                // one, and looking it up avoids depending on type-creation API details.
+                Uint32 floatTypeId = 0;
+                for (auto& inst : get_module()->types_values()) {
+                    if (inst.opcode() == spv::Op::OpTypeFloat && inst.NumInOperands() >= 1 &&
+                        inst.GetSingleWordInOperand(0) == 32) {
+                        floatTypeId = inst.result_id();
+                        break;
+                    }
+                }
+                if (floatTypeId == 0) return 0;
+
+                const auto* floatType = context()->get_type_mgr()->GetType(floatTypeId);
+                if (floatType == nullptr) return 0;
+                const auto zeroBits = std::bit_cast<Uint32>(0.0f);
+                const auto* zeroConst = context()->get_constant_mgr()->GetConstant(floatType, {zeroBits});
+                if (zeroConst == nullptr) return 0;
+                auto* zeroInst = context()->get_constant_mgr()->GetDefiningInstruction(zeroConst);
+                return zeroInst != nullptr ? zeroInst->result_id() : 0;
+            }
+
+            static Bool MapOpcode(spv::Op op, spv::Op& outOpcode, Uint32& outFixedOperandCount) {
+                switch (op) {
+                case spv::Op::OpImageSampleImplicitLod:
+                    outOpcode = spv::Op::OpImageSampleExplicitLod;
+                    outFixedOperandCount = 2; // sampled image, coordinate
+                    return true;
+                case spv::Op::OpImageSampleProjImplicitLod:
+                    outOpcode = spv::Op::OpImageSampleProjExplicitLod;
+                    outFixedOperandCount = 2;
+                    return true;
+                case spv::Op::OpImageSampleDrefImplicitLod:
+                    outOpcode = spv::Op::OpImageSampleDrefExplicitLod;
+                    outFixedOperandCount = 3; // sampled image, coordinate, Dref
+                    return true;
+                case spv::Op::OpImageSampleProjDrefImplicitLod:
+                    outOpcode = spv::Op::OpImageSampleProjDrefExplicitLod;
+                    outFixedOperandCount = 3;
+                    return true;
+                default:
+                    return false;
+                }
+            }
+
+            static Bool PlanRewrite(spvtools::opt::Instruction* inst, RewritePlan& outPlan) {
+                spv::Op newOpcode = spv::Op::OpNop;
+                Uint32 fixedCount = 0;
+                if (!MapOpcode(inst->opcode(), newOpcode, fixedCount)) return false;
+                if (inst->NumInOperands() < fixedCount) return false;
+
+                Uint32 mask = 0;
+                Uint32 next = fixedCount;
+                if (inst->NumInOperands() > fixedCount) {
+                    mask = inst->GetSingleWordInOperand(fixedCount);
+                    next = fixedCount + 1;
+                }
+                // An operand this pass does not model would be silently reordered or dropped, and
+                // Grad cannot legally accompany an implicit-LOD sample: leave such an instruction be.
+                if ((mask & ~kKnownMask) != 0 || (mask & kGrad) != 0) return false;
+
+                Vector<spvtools::opt::Operand> fixedOperands;
+                fixedOperands.reserve(fixedCount + 1);
+                for (Uint32 i = 0; i < fixedCount; ++i) {
+                    fixedOperands.push_back(inst->GetInOperand(i));
+                }
+
+                // Collect the surviving operand values in the same ascending-bit order they were
+                // encoded in, so the rebuilt list stays canonical.
+                Uint32 keptMask = kLod;
+                Vector<spvtools::opt::Operand> keptOperands;
+                static constexpr Uint32 kOrderedBits[] = {kBias,   kLod,          kGrad,   kConstOffset,
+                                                          kOffset, kConstOffsets, kSample, kMinLod};
+                for (const Uint32 bit : kOrderedBits) {
+                    if ((mask & bit) == 0) continue;
+                    if (next >= inst->NumInOperands()) return false;
+                    const spvtools::opt::Operand value = inst->GetInOperand(next++);
+                    // Bias and MinLod only shift a lambda that is already clamped to 0, and any
+                    // original Lod is replaced by the constant the caller appends.
+                    if (bit == kBias || bit == kMinLod || bit == kLod) continue;
+                    keptMask |= bit;
+                    keptOperands.push_back(value);
+                }
+
+                fixedOperands.push_back({SPV_OPERAND_TYPE_IMAGE, {keptMask}});
+                outPlan.instruction = inst;
+                outPlan.opcode = newOpcode;
+                outPlan.operands = Move(fixedOperands);
+                outPlan.trailingOperands = Move(keptOperands);
+                return true;
+            }
+        };
+
+        spvtools::Optimizer::PassToken CreateForceExplicitLod0SamplePass() {
+            return spvtools::Optimizer::PassToken(MakeUnique<ForceExplicitLod0SamplePass>());
+        }
+
+        // TEMP-PERFDIAG: measure what fragment-stage fp32 costs on this GPU. Desktop GLSL carries
+        // no precision qualifiers, so everything reaches the driver as full fp32 while Adreno runs
+        // fp16 at twice the rate. Decorating every float-typed result in a fragment entry point
+        // with RelaxedPrecision is the blunt "all mediump" upper bound - it changes results, so it
+        // is a probe, not a shipping transform. Toggled by /sdcard/MG/exp_relaxed_precision.
+        class RelaxedPrecisionProbePass final : public spvtools::opt::Pass {
+        public:
+            const char* name() const override { return "relaxed-precision-probe"; }
+
+            Status Process() override {
+                Bool isFragment = false;
+                for (auto& entryPoint : get_module()->entry_points()) {
+                    if (entryPoint.opcode() != spv::Op::OpEntryPoint) continue;
+                    if (static_cast<spv::ExecutionModel>(entryPoint.GetSingleWordInOperand(0)) ==
+                        spv::ExecutionModel::Fragment) {
+                        isFragment = true;
+                        break;
+                    }
+                }
+                if (!isFragment) return Status::SuccessWithoutChange;
+
+                // Every 32-bit-float scalar/vector/matrix type in the module. Anything wider (f64)
+                // or narrower is left alone: RelaxedPrecision only has meaning for 32-bit floats.
+                std::unordered_set<Uint32> relaxableTypes;
+                for (auto& type : get_module()->types_values()) {
+                    const Uint32 typeId = type.result_id();
+                    if (typeId == 0) continue;
+                    switch (type.opcode()) {
+                    case spv::Op::OpTypeFloat:
+                        if (type.GetSingleWordInOperand(0) == 32) relaxableTypes.insert(typeId);
+                        break;
+                    case spv::Op::OpTypeVector:
+                    case spv::Op::OpTypeMatrix:
+                        if (relaxableTypes.count(type.GetSingleWordInOperand(0)) != 0) {
+                            relaxableTypes.insert(typeId);
+                        }
+                        break;
+                    default:
+                        break;
+                    }
+                }
+                if (relaxableTypes.empty()) return Status::SuccessWithoutChange;
+
+                Vector<Uint32> targets;
+                for (auto& function : *get_module()) {
+                    for (auto& block : function) {
+                        for (auto& inst : block) {
+                            const Uint32 resultId = inst.result_id();
+                            if (resultId == 0) continue;
+                            if (relaxableTypes.count(inst.type_id()) == 0) continue;
+                            targets.push_back(resultId);
+                        }
+                    }
+                }
+                if (targets.empty()) return Status::SuccessWithoutChange;
+
+                for (const Uint32 id : targets) {
+                    context()->get_decoration_mgr()->AddDecoration(
+                        id, static_cast<Uint32>(spv::Decoration::RelaxedPrecision));
+                }
+                context()->InvalidateAnalysesExceptFor(spvtools::opt::IRContext::kAnalysisNone);
+                return Status::SuccessWithChange;
+            }
+        };
+
+        // Relax fragment-stage arithmetic that provably came out of a texture read. Desktop GLSL
+        // has no precision qualifiers, so every fragment value reaches the driver as fp32 while
+        // Adreno runs fp16 at twice the rate - and a texel is at most 8 bits per channel, which
+        // fp16's 11-bit mantissa carries exactly. Seeding at image reads and propagating only
+        // through operations whose every input is already relaxed keeps everything the shader
+        // computes from other sources (screen coordinates, depth, wide-range uniforms) at full
+        // precision, which is where fp16 would actually go wrong: fp16 cannot even represent a
+        // 3044-pixel gl_FragCoord.x exactly.
+        class RelaxTextureDerivedPrecisionPass final : public spvtools::opt::Pass {
+        public:
+            const char* name() const override { return "relax-texture-derived-precision"; }
+
+            Status Process() override {
+                if (!IsFragmentEntryPoint()) return Status::SuccessWithoutChange;
+                // A shader that drives depth or coverage itself is out of scope: those values must
+                // stay exact, and proving which computations feed them is not worth it here.
+                if (WritesDepthOrSampleMask()) return Status::SuccessWithoutChange;
+
+                CollectRelaxableFloatTypes();
+                if (m_relaxableTypes.empty()) return Status::SuccessWithoutChange;
+
+                // Whitelisting from texture reads captures nothing in practice: MC's fragment
+                // shaders multiply every texel by an interpolated colour and a UBO value, so one
+                // un-relaxed operand vetoes the whole expression (measured: no fps change).
+                // Taint the few genuinely precision-critical sources instead and relax the rest.
+                std::unordered_set<Uint32> tainted;
+                CollectPrecisionCriticalSeeds(tainted);
+                Bool grew = true;
+                while (grew) {
+                    grew = false;
+                    for (auto& function : *get_module()) {
+                        for (auto& block : function) {
+                            for (auto& inst : block) {
+                                const Uint32 resultId = inst.result_id();
+                                if (resultId == 0 || tainted.count(resultId) != 0) continue;
+                                if (!AnyOperandTainted(inst, tainted)) continue;
+                                tainted.insert(resultId);
+                                grew = true;
+                            }
+                        }
+                    }
+                }
+
+                std::unordered_set<Uint32> relaxed;
+                for (auto& function : *get_module()) {
+                    for (auto& block : function) {
+                        for (auto& inst : block) {
+                            const Uint32 resultId = inst.result_id();
+                            if (resultId == 0 || tainted.count(resultId) != 0) continue;
+                            if (m_relaxableTypes.count(inst.type_id()) == 0) continue;
+                            relaxed.insert(resultId);
+                        }
+                    }
+                }
+                if (relaxed.empty()) return Status::SuccessWithoutChange;
+
+                for (const Uint32 id : relaxed) {
+                    context()->get_decoration_mgr()->AddDecoration(
+                        id, static_cast<Uint32>(spv::Decoration::RelaxedPrecision));
+                }
+                context()->InvalidateAnalysesExceptFor(spvtools::opt::IRContext::kAnalysisNone);
+                return Status::SuccessWithChange;
+            }
+
+        private:
+            std::unordered_set<Uint32> m_relaxableTypes;
+
+            Bool IsFragmentEntryPoint() const {
+                for (auto& entryPoint : get_module()->entry_points()) {
+                    if (entryPoint.opcode() != spv::Op::OpEntryPoint) continue;
+                    if (static_cast<spv::ExecutionModel>(entryPoint.GetSingleWordInOperand(0)) ==
+                        spv::ExecutionModel::Fragment) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            Bool WritesDepthOrSampleMask() const {
+                for (auto& annotation : get_module()->annotations()) {
+                    if (annotation.opcode() != spv::Op::OpDecorate) continue;
+                    if (static_cast<spv::Decoration>(annotation.GetSingleWordInOperand(1)) !=
+                        spv::Decoration::BuiltIn) {
+                        continue;
+                    }
+                    const auto builtIn = static_cast<spv::BuiltIn>(annotation.GetSingleWordInOperand(2));
+                    if (builtIn == spv::BuiltIn::FragDepth || builtIn == spv::BuiltIn::SampleMask) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            void CollectRelaxableFloatTypes() {
+                m_relaxableTypes.clear();
+                for (auto& type : get_module()->types_values()) {
+                    const Uint32 typeId = type.result_id();
+                    if (typeId == 0) continue;
+                    switch (type.opcode()) {
+                    case spv::Op::OpTypeFloat:
+                        if (type.GetSingleWordInOperand(0) == 32) m_relaxableTypes.insert(typeId);
+                        break;
+                    case spv::Op::OpTypeVector:
+                        if (m_relaxableTypes.count(type.GetSingleWordInOperand(0)) != 0) {
+                            m_relaxableTypes.insert(typeId);
+                        }
+                        break;
+                    default:
+                        break;
+                    }
+                }
+            }
+
+            void CollectImageReadSeeds(std::unordered_set<Uint32>& relaxed) const {
+                for (auto& function : *get_module()) {
+                    for (auto& block : function) {
+                        for (auto& inst : block) {
+                            const Uint32 resultId = inst.result_id();
+                            if (resultId == 0 || m_relaxableTypes.count(inst.type_id()) == 0) continue;
+                            // Interpolated user varyings seed too, or propagation dies at the
+                            // first `texel * vertexColour`: the load of an Input can never be
+                            // relaxed by the rule below (its operand is a pointer), so a single
+                            // varying vetoes every downstream operation. This is what ESSL's
+                            // mediump varyings already mean. Built-ins are excluded - gl_FragCoord
+                            // carries pixel coordinates that fp16 cannot represent exactly.
+                            if (inst.opcode() == spv::Op::OpLoad && IsNonBuiltInFragmentInput(inst)) {
+                                relaxed.insert(resultId);
+                                continue;
+                            }
+                            switch (inst.opcode()) {
+                            case spv::Op::OpImageSampleImplicitLod:
+                            case spv::Op::OpImageSampleExplicitLod:
+                            case spv::Op::OpImageSampleProjImplicitLod:
+                            case spv::Op::OpImageSampleProjExplicitLod:
+                            case spv::Op::OpImageSampleDrefImplicitLod:
+                            case spv::Op::OpImageSampleDrefExplicitLod:
+                            case spv::Op::OpImageFetch:
+                            case spv::Op::OpImageRead:
+                            case spv::Op::OpImageGather:
+                                relaxed.insert(resultId);
+                                break;
+                            default:
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            // OpLoad straight out of a fragment Input variable that carries no BuiltIn decoration.
+            // Only a direct load counts: a load through an access chain could be indexing a
+            // structure whose other members are not interpolated colour data.
+            Bool IsNonBuiltInFragmentInput(const spvtools::opt::Instruction& load) const {
+                const Uint32 pointerId = load.GetSingleWordInOperand(0);
+                const auto* pointer = context()->get_def_use_mgr()->GetDef(pointerId);
+                if (pointer == nullptr || pointer->opcode() != spv::Op::OpVariable) return false;
+                if (static_cast<spv::StorageClass>(pointer->GetSingleWordInOperand(0)) !=
+                    spv::StorageClass::Input) {
+                    return false;
+                }
+                Bool isBuiltIn = false;
+                context()->get_decoration_mgr()->ForEachDecoration(
+                    pointerId, static_cast<Uint32>(spv::Decoration::BuiltIn),
+                    [&isBuiltIn](const spvtools::opt::Instruction&) { isBuiltIn = true; });
+                return !isBuiltIn;
+            }
+
+            // A float constant small enough that fp16 represents it without surprise. Colour math
+            // constants (0, 1, 0.5, 255, gamma exponents) all live here; anything larger is
+            // treated as unknown so it stops propagation.
+            Bool IsBoundedFloatConstant(Uint32 id) const {
+                const auto* constant = context()->get_constant_mgr()->FindDeclaredConstant(id);
+                if (constant == nullptr) return false;
+                if (const auto* scalar = constant->AsFloatConstant()) {
+                    const float value = scalar->GetFloat();
+                    return std::isfinite(value) && std::fabs(value) <= 1024.0f;
+                }
+                if (const auto* composite = constant->AsVectorConstant()) {
+                    for (const auto* component : composite->GetComponents()) {
+                        const auto* scalar = component->AsFloatConstant();
+                        if (scalar == nullptr) return false;
+                        const float value = scalar->GetFloat();
+                        if (!std::isfinite(value) || std::fabs(value) > 1024.0f) return false;
+                    }
+                    return true;
+                }
+                return false;
+            }
+
+            // Precision-critical sources: a built-in fragment input. gl_FragCoord is the one that
+            // matters - fp16 cannot represent a 3044-pixel x coordinate exactly, and anything
+            // derived from it (screen-space effects, manual depth reconstruction) would visibly
+            // quantise. Everything else a fragment shader reads is colour-range data.
+            void CollectPrecisionCriticalSeeds(std::unordered_set<Uint32>& tainted) const {
+                for (auto& function : *get_module()) {
+                    for (auto& block : function) {
+                        for (auto& inst : block) {
+                            if (inst.opcode() != spv::Op::OpLoad || inst.result_id() == 0) continue;
+                            if (IsBuiltInInputLoad(inst)) tainted.insert(inst.result_id());
+                        }
+                    }
+                }
+            }
+
+            Bool IsBuiltInInputLoad(const spvtools::opt::Instruction& load) const {
+                const Uint32 pointerId = load.GetSingleWordInOperand(0);
+                const auto* pointer = context()->get_def_use_mgr()->GetDef(pointerId);
+                if (pointer == nullptr || pointer->opcode() != spv::Op::OpVariable) return false;
+                if (static_cast<spv::StorageClass>(pointer->GetSingleWordInOperand(0)) !=
+                    spv::StorageClass::Input) {
+                    return false;
+                }
+                Bool isBuiltIn = false;
+                context()->get_decoration_mgr()->ForEachDecoration(
+                    pointerId, static_cast<Uint32>(spv::Decoration::BuiltIn),
+                    [&isBuiltIn](const spvtools::opt::Instruction&) { isBuiltIn = true; });
+                return isBuiltIn;
+            }
+
+            Bool AnyOperandTainted(const spvtools::opt::Instruction& inst,
+                                   const std::unordered_set<Uint32>& tainted) const {
+                const Uint32 operandCount = inst.NumInOperands();
+                for (Uint32 i = 0; i < operandCount; ++i) {
+                    const auto& operand = inst.GetInOperand(i);
+                    if (!spvIsIdType(operand.type)) continue;
+                    if (IsNonNumericOperand(inst, i)) continue;
+                    if (tainted.count(operand.words[0]) != 0) return true;
+                }
+                return false;
+            }
+
+            Bool AllValueOperandsRelaxed(const spvtools::opt::Instruction& inst,
+                                         const std::unordered_set<Uint32>& relaxed) const {
+                switch (inst.opcode()) {
+                // Pointer-typed plumbing: relaxing the loaded value would say nothing about the
+                // memory it came from, and the pointer operand can never be in the set.
+                case spv::Op::OpLoad:
+                case spv::Op::OpStore:
+                case spv::Op::OpAccessChain:
+                case spv::Op::OpInBoundsAccessChain:
+                case spv::Op::OpFunctionCall:
+                    return false;
+                default:
+                    break;
+                }
+
+                Bool sawValueOperand = false;
+                Bool allRelaxed = true;
+                const Uint32 operandCount = inst.NumInOperands();
+                for (Uint32 i = 0; i < operandCount; ++i) {
+                    const auto& operand = inst.GetInOperand(i);
+                    if (!spvIsIdType(operand.type)) continue; // literals: selectors, swizzle indices
+                    const Uint32 id = operand.words[0];
+                    // OpPhi's block labels, OpSelect's condition and OpExtInst's instruction-set id
+                    // are ids that carry no numeric precision; skip them rather than let them veto.
+                    if (IsNonNumericOperand(inst, i)) continue;
+                    sawValueOperand = true;
+                    if (relaxed.count(id) != 0) continue;
+                    if (IsBoundedFloatConstant(id)) continue;
+                    allRelaxed = false;
+                    break;
+                }
+                return sawValueOperand && allRelaxed;
+            }
+
+            static Bool IsNonNumericOperand(const spvtools::opt::Instruction& inst, Uint32 index) {
+                switch (inst.opcode()) {
+                case spv::Op::OpPhi:
+                    return (index % 2) == 1; // parent block labels
+                case spv::Op::OpSelect:
+                    return index == 0; // condition
+                case spv::Op::OpExtInst:
+                    return index == 0; // extended instruction set
+                default:
+                    return false;
+                }
+            }
+        };
+
+        // TEMP-PERFDIAG: A/B switch between the scoped transform and the all-float upper bound.
+        Bool PerfDiagRelaxAllPrecision() {
+            static const Bool enabled = [] {
+                std::FILE* probe = std::fopen("/sdcard/MG/exp_relaxed_precision_all", "rb");
+                if (probe == nullptr) return false;
+                std::fclose(probe);
+                MGLOG_I("[PERFDIAG] fragment RelaxedPrecision: ALL floats (upper-bound probe)");
+                return true;
+            }();
+            return enabled;
+        }
+
+        // TEMP-PERFDIAG: lets a run turn the transform off entirely for an A/B baseline.
+        Bool PerfDiagRelaxedPrecisionEnabled() {
+            static const Bool disabled = [] {
+                std::FILE* probe = std::fopen("/sdcard/MG/exp_no_relaxed_precision", "rb");
+                if (probe == nullptr) return false;
+                std::fclose(probe);
+                MGLOG_I("[PERFDIAG] fragment RelaxedPrecision DISABLED");
+                return true;
+            }();
+            return !disabled;
+        }
+
+        Bool TransformSpirvForExplicitLod0Sampling(const Vector<Uint>& input, Vector<Uint>& output) {
+            if (input.empty()) {
+                output.clear();
+                return true;
+            }
+            spvtools::Optimizer optimizer(SPV_ENV_VULKAN_1_3);
+            spvtools::OptimizerOptions options;
+            // Matches the position-fix pass: this build of spirv-tools asserts rather than
+            // reporting, so validation stays off in the shipping path.
+            options.set_run_validator(false);
+            optimizer.SetMessageConsumer([](spv_message_level_t, const char*, const spv_position_t&,
+                                            const char* message) {
+                MGLOG_E("Vulkan: explicit-LOD0 pass: %s", message != nullptr ? message : "");
+            });
+            optimizer.RegisterPass(CreateForceExplicitLod0SamplePass());
+
+            const Bool success = optimizer.Run(input.data(), input.size(), &output, options);
+            if (!success) {
+                MGLOG_E("Vulkan: explicit-LOD0 sampling pass failed; keeping the original module");
+                output = input;
+            }
+            return success;
+        }
+
         spvtools::Optimizer::PassToken CreateGlToVulkanPositionFixPass(
             ProgramFactory::CompileOptionFlags transformFlags) {
             return spvtools::Optimizer::PassToken(MakeUnique<GlToVulkanPositionFixPass>(transformFlags));
         }
 
+        // TEMP-PERFDIAG
+        Bool TransformSpirvForRelaxedPrecisionProbe(const Vector<Uint>& input, Vector<Uint>& output) {
+            if (input.empty()) {
+                output.clear();
+                return true;
+            }
+            spvtools::Optimizer optimizer(SPV_ENV_VULKAN_1_3);
+            spvtools::OptimizerOptions options;
+            options.set_run_validator(false);
+            optimizer.SetMessageConsumer([](spv_message_level_t, const char*, const spv_position_t&,
+                                            const char* message) {
+                MGLOG_E("Vulkan: relaxed-precision probe: %s", message != nullptr ? message : "");
+            });
+            // SSA promotion first: glslang emits function-local variables with stores and loads,
+            // and a load can never be relaxed (its operand is a pointer), so without this the
+            // propagation below dies at the first temporary.
+            optimizer.RegisterPass(spvtools::CreateLocalMultiStoreElimPass());
+            if (PerfDiagRelaxAllPrecision()) {
+                optimizer.RegisterPass(spvtools::Optimizer::PassToken(MakeUnique<RelaxedPrecisionProbePass>()));
+            } else {
+                optimizer.RegisterPass(
+                    spvtools::Optimizer::PassToken(MakeUnique<RelaxTextureDerivedPrecisionPass>()));
+            }
+            const Bool success = optimizer.Run(input.data(), input.size(), &output, options);
+            if (!success) {
+                MGLOG_E("Vulkan: relaxed-precision probe failed; keeping the original module");
+                output = input;
+            }
+            return success;
+        }
+
         Bool TransformSpirvForVulkanPositionFix(const Vector<Uint>& input, Vector<Uint>& output,
                                                 ProgramFactory::CompileOptionFlags transformFlags) {
             if (input.empty()) {
@@ -1094,9 +1696,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 for (auto* binding : bindings) {
                     MOBILEGL_ASSERT(binding != nullptr, "ProgramFactory: null descriptor binding reflection record");
                     const auto kind = ReflectDescriptorTypeToBindingKind(binding->descriptor_type);
-                    MOBILEGL_ASSERT(binding->count == 1,
-                                    "ProgramFactory: descriptor arrays are unsupported (name='%s' count=%u)",
-                                    binding->name ? binding->name : "<null>", binding->count);
+                    // UBO instance arrays (uniform Block {...} b[N];) occupy one binding with
+                    // descriptorCount = N; other descriptor arrays stay unsupported and must
+                    // fail program creation cleanly rather than continue with corrupt state.
+                    if (binding->count != 1 && kind != ProgramFactory::DescriptorBindingKind::UniformBufferDynamic) {
+                        MGLOG_E("ProgramFactory: descriptor arrays are unsupported for this descriptor "
+                                "kind (name='%s' count=%u type=%d)",
+                                binding->name ? binding->name : "<null>", binding->count,
+                                static_cast<Int>(binding->descriptor_type));
+                        destroyReflectModules();
+                        return false;
+                    }
 
                     DescriptorKey key{};
                     key.kind = kind;
@@ -1613,6 +2223,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         entry.storageBlockIndexByBinding.assign(m_maxBindings, -1);
         entry.globalUboBinding = -1;
         entry.dynamicBindings.clear();
+        entry.bindingDescriptorCounts.assign(m_maxBindings, 1);
+        entry.arrayedUniformBlockIndicesByBinding.clear();
 
         // Use SpvcSession (Reflection mode) to reflect all SPIR-V modules in a single pass per module
         for (const auto& module : spirv) {
@@ -1628,6 +2240,27 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                             "ProgramFactory::ReflectLayout: failed to create reflection module (result=%d)",
                             static_cast<Int>(createReflectResult));
 
+            // Descriptor counts per binding (UBO instance arrays reflect count > 1).
+            UnorderedMap<Uint32, Uint32> descriptorCountByBinding;
+            {
+                uint32_t countProbe = 0;
+                if (spvReflectEnumerateDescriptorBindings(&reflectModule, &countProbe, nullptr) ==
+                        SPV_REFLECT_RESULT_SUCCESS &&
+                    countProbe > 0) {
+                    Vector<SpvReflectDescriptorBinding*> probeBindings(countProbe);
+                    if (spvReflectEnumerateDescriptorBindings(&reflectModule, &countProbe,
+                                                              probeBindings.data()) ==
+                        SPV_REFLECT_RESULT_SUCCESS) {
+                        for (const auto* probeBinding : probeBindings) {
+                            if (probeBinding != nullptr) {
+                                descriptorCountByBinding[probeBinding->binding] =
+                                    std::max<Uint32>(1, probeBinding->count);
+                            }
+                        }
+                    }
+                }
+            }
+
             // Reflect uniform buffers
             auto ubos = session.GetShaderInterface(SPVC_RESOURCE_TYPE_UNIFORM_BUFFER);
             for (const auto& ubo : ubos) {
@@ -1653,9 +2286,69 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     continue;
                 }
 
-                const Uint blockIndex = program.GetUniformBlockIndex(ubo.name.c_str());
-                if (blockIndex == 0xFFFFFFFFu) {
-                    MGLOG_D("ProgramFactory::ReflectLayout: skipping inactive UBO '%s' at binding %u",
+                const auto countIt = descriptorCountByBinding.find(binding);
+                const Uint32 descriptorCount =
+                    countIt != descriptorCountByBinding.end() ? countIt->second : 1u;
+
+                if (descriptorCount <= 1) {
+                    const Uint blockIndex = program.GetUniformBlockIndex(ubo.name.c_str());
+                    if (blockIndex == 0xFFFFFFFFu) {
+                        MGLOG_D("ProgramFactory::ReflectLayout: skipping inactive UBO '%s' at binding %u",
+                                ubo.name.c_str(), binding);
+                        continue;
+                    }
+
+                    MOBILEGL_ASSERT(entry.bindingKinds[binding] == DescriptorBindingKind::None ||
+                                        entry.bindingKinds[binding] == DescriptorBindingKind::UniformBufferDynamic,
+                                    "ProgramFactory::ReflectLayout: descriptor binding %u has conflicting kinds for UBO '%s'",
+                                    binding, ubo.name.c_str());
+                    entry.bindingKinds[binding] = DescriptorBindingKind::UniformBufferDynamic;
+                    MOBILEGL_ASSERT(entry.globalUboBinding != static_cast<Int>(binding),
+                                    "ProgramFactory::ReflectLayout: regular UBO '%s' collides with global UBO binding %u",
+                                    ubo.name.c_str(), binding);
+                    MOBILEGL_ASSERT(entry.uniformBlockIndexByBinding[binding] < 0 ||
+                                        entry.uniformBlockIndexByBinding[binding] == static_cast<Int>(blockIndex),
+                                    "ProgramFactory::ReflectLayout: descriptor binding %u maps to conflicting UBO blocks (%d vs %u)",
+                                    binding, entry.uniformBlockIndexByBinding[binding], blockIndex);
+                    entry.uniformBlockIndexByBinding[binding] = static_cast<Int>(blockIndex);
+                    continue;
+                }
+
+                // UBO instance array: one binding, descriptorCount elements. GL exposes each
+                // element as its own active block named "Name[i]"; map every element to its
+                // GL block index so the descriptor write can gather per-element buffer ranges.
+                if (descriptorCount > m_maxBindings) {
+                    MGLOG_E("ProgramFactory::ReflectLayout: UBO array '%s' count %u exceeds maxBindings=%u; "
+                            "leaving binding %u unmapped",
+                            ubo.name.c_str(), descriptorCount, m_maxBindings, binding);
+                    continue;
+                }
+                Vector<Int> elementBlockIndices;
+                elementBlockIndices.reserve(descriptorCount);
+                for (Uint32 element = 0; element < descriptorCount; ++element) {
+                    String elementName = ubo.name + "[" + std::to_string(element) + "]";
+                    Uint elementBlockIndex = program.GetUniformBlockIndex(elementName.c_str());
+                    if (elementBlockIndex == 0xFFFFFFFFu && element == 0) {
+                        // Some frontends report the first element under the bare block name.
+                        elementBlockIndex = program.GetUniformBlockIndex(ubo.name.c_str());
+                    }
+                    if (elementBlockIndex == 0xFFFFFFFFu) {
+                        // Degrade rather than corrupt: reuse element 0's block if we have one,
+                        // otherwise give up on the binding (same observable behavior as an
+                        // inactive block: wrong values, but no crash).
+                        MGLOG_E("ProgramFactory::ReflectLayout: UBO array '%s' element %u has no active "
+                                "GL uniform block",
+                                ubo.name.c_str(), element);
+                        if (!elementBlockIndices.empty()) {
+                            elementBlockIndex = static_cast<Uint>(elementBlockIndices.front());
+                        } else {
+                            break;
+                        }
+                    }
+                    elementBlockIndices.push_back(static_cast<Int>(elementBlockIndex));
+                }
+                if (elementBlockIndices.size() != descriptorCount) {
+                    MGLOG_E("ProgramFactory::ReflectLayout: skipping unresolved UBO array '%s' at binding %u",
                             ubo.name.c_str(), binding);
                     continue;
                 }
@@ -1665,14 +2358,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                 "ProgramFactory::ReflectLayout: descriptor binding %u has conflicting kinds for UBO '%s'",
                                 binding, ubo.name.c_str());
                 entry.bindingKinds[binding] = DescriptorBindingKind::UniformBufferDynamic;
-                MOBILEGL_ASSERT(entry.globalUboBinding != static_cast<Int>(binding),
-                                "ProgramFactory::ReflectLayout: regular UBO '%s' collides with global UBO binding %u",
-                                ubo.name.c_str(), binding);
-                MOBILEGL_ASSERT(entry.uniformBlockIndexByBinding[binding] < 0 ||
-                                    entry.uniformBlockIndexByBinding[binding] == static_cast<Int>(blockIndex),
-                                "ProgramFactory::ReflectLayout: descriptor binding %u maps to conflicting UBO blocks (%d vs %u)",
-                                binding, entry.uniformBlockIndexByBinding[binding], blockIndex);
-                entry.uniformBlockIndexByBinding[binding] = static_cast<Int>(blockIndex);
+                entry.bindingDescriptorCounts[binding] = static_cast<Uint16>(descriptorCount);
+                entry.uniformBlockIndexByBinding[binding] = elementBlockIndices[0];
+                entry.arrayedUniformBlockIndicesByBinding[binding] = Move(elementBlockIndices);
             }
 
             // Reflect sampled images, storage images, samplerBuffer uniforms, and SSBOs.
@@ -1819,7 +2507,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
             VkDescriptorSetLayoutBinding layoutBinding{};
             layoutBinding.binding = binding;
-            layoutBinding.descriptorCount = 1;
+            layoutBinding.descriptorCount = entry.bindingDescriptorCounts[binding];
             layoutBinding.stageFlags = VK_SHADER_STAGE_ALL;
             layoutBinding.pImmutableSamplers = nullptr;
             if (kind == DescriptorBindingKind::UniformBufferDynamic) {
@@ -1864,11 +2552,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
         auto it = m_cache.find(hash);
         if (it != m_cache.end()) {
+            // Every draw/dispatch funnels through this lookup (the renderer memos only
+            // skip re-hashing, never the factory lookup), so an actively-used entry is
+            // stamped at least once per frame boundary and can never be aged out while
+            // any in-flight command buffer still references it.
+            it->second.lastUsedFrame = m_frameCounter;
             return it->second;
         }
 
         auto& entry = m_cache[hash];
         entry.hash = hash;
+        entry.lastUsedFrame = m_frameCounter;
         auto& shaders = program.GetAttachedShaders();
         auto& spirv = program.GetGeneratedSpirv();
         Vector<Vector<Uint>> moduleSpirvs(spirv.size());
@@ -1886,6 +2580,23 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 moduleSpirvs[i] = spv;
             }
 
+            if ((flags & ProgramFactory::CompileOptionBit::ExplicitLod0Sampling) && shaders[i] &&
+                shaders[i]->GetShaderStage() == ShaderStage::Fragment) {
+                Vector<Uint> explicitLodSpirv;
+                if (TransformSpirvForExplicitLod0Sampling(moduleSpirvs[i], explicitLodSpirv)) {
+                    moduleSpirvs[i] = Move(explicitLodSpirv);
+                }
+            }
+
+            if ((flags & ProgramFactory::CompileOptionBit::RelaxedFragmentPrecision) &&
+                PerfDiagRelaxedPrecisionEnabled() && shaders[i] &&
+                shaders[i]->GetShaderStage() == ShaderStage::Fragment) {
+                Vector<Uint> relaxedSpirv;
+                if (TransformSpirvForRelaxedPrecisionProbe(moduleSpirvs[i], relaxedSpirv)) {
+                    moduleSpirvs[i] = Move(relaxedSpirv);
+                }
+            }
+
             // GL apps depend on cross-program position invariance for multi-pass equality
             // depth tests (MC 26.3's OIT re-draws the cloud geometry with GEQUAL against the
             // depth its own first pass wrote); decorate Position outputs Invariant so
@@ -1982,4 +2693,42 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         return entry;
     }
+
+    void ProgramFactory::OnFrameBoundary() {
+        ++m_frameCounter;
+
+        // Sweep cadence and retire age mirror VkRenderPassManager::OnPresent: an entry
+        // idle for more than kRetireAgeFrames frame boundaries cannot be referenced by
+        // any in-flight command buffer (frames-in-flight <= MOBILEGL_MAGMA_FRAMESINFLIGHT),
+        // so its shader modules and layouts are destroyed immediately - no deferred-
+        // destroy machinery needed. Eviction is content-based, never tied to
+        // glDeleteProgram: the cache is content-hash-shared across GL programs, so a
+        // delete-driven erase could free an entry another live program still resolves.
+        // An evicted entry self-heals - the frontend program keeps its generated
+        // SPIR-V, so the next GetOrCreateProgram rebuilds it (this also covers the
+        // renderer's internal blit/depth-mipmap programs).
+        constexpr Uint64 kSweepInterval = 256;
+        constexpr Uint64 kRetireAgeFrames = 1024;
+        if ((m_frameCounter % kSweepInterval) != 0) {
+            return;
+        }
+
+        for (auto it = m_cache.begin(); it != m_cache.end();) {
+            if (m_frameCounter - it->second.lastUsedFrame > kRetireAgeFrames) {
+                const HashType hash = it->first;
+                const VkDescriptorSetLayout descriptorSetLayout = it->second.descriptorSetLayout;
+                MGLOG_D("ProgramFactory::OnFrameBoundary: evicting idle program entry hash=0x%llx",
+                        static_cast<unsigned long long>(hash));
+                // erase runs ~VkProgramObject (modules/layouts destroyed); notify after
+                // so an observer never observes a half-destroyed entry through a lookup.
+                // Observers only need the handle values to purge their keyed caches.
+                it = m_cache.erase(it);
+                if (m_evictionObserver != nullptr) {
+                    m_evictionObserver->OnProgramEvicted(hash, descriptorSetLayout);
+                }
+            } else {
+                ++it;
+            }
+        }
+    }
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.h

@@ -42,6 +42,16 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             SurfaceRotate90 = 1 << 2,
             SurfaceRotate180 = 1 << 3,
             SurfaceRotate270 = 1 << 4,
+            // Rewrites the fragment stage's implicit-LOD image samples to explicit LOD 0.
+            // Only ever set for a draw whose every sampler binding is clamped to a single mip
+            // level, which makes the two forms produce identical texels (the implicit lambda is
+            // clamped into [minLod, maxLod] = [0, 0] regardless of derivatives or bias).
+            ExplicitLod0Sampling = 1 << 5,
+            // Fragment arithmetic may run at relaxed (fp16) precision. Only requested for draws
+            // where every sampled texture and every colour attachment is an 8-bit-or-less
+            // normalized format, so nothing the shader reads or writes carries more precision
+            // than fp16 already represents exactly.
+            RelaxedFragmentPrecision = 1 << 6,
         };
         using CompileOptionFlags = Flags<CompileOptionBit>;
         using HashType = Uint64;
@@ -59,6 +69,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Vector<DescriptorBindingKind> bindingKinds;
             Vector<Uint32> dynamicBindings;
             Vector<Int> uniformBlockIndexByBinding;
+            // Descriptor count per binding (1 except for UBO instance arrays, which occupy one
+            // binding with descriptorCount = N).
+            Vector<Uint16> bindingDescriptorCounts;
+            // Per-element GL uniform block indices for arrayed UBO bindings (count > 1);
+            // element 0 of a non-arrayed binding stays in uniformBlockIndexByBinding.
+            UnorderedMap<Uint32, Vector<Int>> arrayedUniformBlockIndicesByBinding;
             Vector<String> samplerNameByBinding;
             Vector<Int> samplerUniformLocationByBinding;
             Vector<TextureTarget> samplerTextureTargetByBinding;
@@ -82,6 +98,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // gl_FragDepth); shader-computed depth is immune to the cross-pipeline
             // position-invariance quirk (see PipelineFactory::ShouldSuppressDepthWrite).
             Bool fragmentReplacesDepth = false;
+            // Frame-boundary counter value of the last GetOrCreateProgram hit; drives
+            // cache eviction (see OnFrameBoundary).
+            Uint64 lastUsedFrame = 0;
 
             static inline VkDevice s_device = VK_NULL_HANDLE;
 
@@ -97,6 +116,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 bindingKinds = std::move(other.bindingKinds);
                 dynamicBindings = std::move(other.dynamicBindings);
                 uniformBlockIndexByBinding = std::move(other.uniformBlockIndexByBinding);
+                bindingDescriptorCounts = std::move(other.bindingDescriptorCounts);
+                arrayedUniformBlockIndicesByBinding = std::move(other.arrayedUniformBlockIndicesByBinding);
                 samplerNameByBinding = std::move(other.samplerNameByBinding);
                 samplerUniformLocationByBinding = std::move(other.samplerUniformLocationByBinding);
                 samplerTextureTargetByBinding = std::move(other.samplerTextureTargetByBinding);
@@ -116,6 +137,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 producerOutputComponentCount = other.producerOutputComponentCount;
                 fragmentInputComponentCount = other.fragmentInputComponentCount;
                 fragmentReplacesDepth = other.fragmentReplacesDepth;
+                lastUsedFrame = other.lastUsedFrame;
                 other.hash = 0;
                 other.descriptorSetLayout = VK_NULL_HANDLE;
                 other.pipelineLayout = VK_NULL_HANDLE;
@@ -127,6 +149,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 other.producerOutputComponentCount = 0;
                 other.fragmentInputComponentCount = 0;
                 other.fragmentReplacesDepth = false;
+                other.lastUsedFrame = 0;
             }
             VkProgramObject& operator=(VkProgramObject&& other) noexcept {
                 if (this == &other) {
@@ -141,6 +164,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 bindingKinds = std::move(other.bindingKinds);
                 dynamicBindings = std::move(other.dynamicBindings);
                 uniformBlockIndexByBinding = std::move(other.uniformBlockIndexByBinding);
+                bindingDescriptorCounts = std::move(other.bindingDescriptorCounts);
+                arrayedUniformBlockIndicesByBinding = std::move(other.arrayedUniformBlockIndicesByBinding);
                 samplerNameByBinding = std::move(other.samplerNameByBinding);
                 samplerUniformLocationByBinding = std::move(other.samplerUniformLocationByBinding);
                 samplerTextureTargetByBinding = std::move(other.samplerTextureTargetByBinding);
@@ -160,6 +185,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 producerOutputComponentCount = other.producerOutputComponentCount;
                 fragmentInputComponentCount = other.fragmentInputComponentCount;
                 fragmentReplacesDepth = other.fragmentReplacesDepth;
+                lastUsedFrame = other.lastUsedFrame;
                 other.hash = 0;
                 other.descriptorSetLayout = VK_NULL_HANDLE;
                 other.pipelineLayout = VK_NULL_HANDLE;
@@ -171,6 +197,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 other.producerOutputComponentCount = 0;
                 other.fragmentInputComponentCount = 0;
                 other.fragmentReplacesDepth = false;
+                other.lastUsedFrame = 0;
                 return *this;
             }
 
@@ -200,6 +227,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         };
 
+        // Notified when the OnFrameBoundary sweep destroys an aged-out cache entry,
+        // carrying the entry's content hash and the VkDescriptorSetLayout it owned.
+        // Dependent caches (compute pipelines, PipelineFactory entries, UniformManager's
+        // per-layout descriptor sets) must purge in the same step: after vkDestroy the
+        // layout handle value may be recycled for an unrelated layout, and the program
+        // hash may be re-inserted by a later rebuild of the same content.
+        class IEvictionObserver {
+        public:
+            virtual ~IEvictionObserver() = default;
+            virtual void OnProgramEvicted(HashType programHash, VkDescriptorSetLayout descriptorSetLayout) = 0;
+        };
+
         explicit ProgramFactory(VkDevice device, const VulkanRendererConfig& config, Uint32 maxBindings = 16,
                                 Bool shaderDrawParametersEnabled = false,
                                 Bool unformattedFloatStorageImagesEnabled = false)
@@ -215,6 +254,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const VkProgramObject& GetOrCreateProgram(
             const MG_State::GLState::ProgramObject& program, CompileOptionFlags flags);
 
+        // Observer may be null (no notifications). Not owned.
+        void SetEvictionObserver(IEvictionObserver* observer) { m_evictionObserver = observer; }
+        // Frame boundary hook: ages the program cache and evicts long-unused entries
+        // (their command buffers retired many frames ago), mirroring
+        // VkRenderPassManager::OnPresent's sweep.
+        void OnFrameBoundary();
+
         static VkShaderStageFlagBits ToVkStage(ShaderStage stage);
         static VkFormat ConvertSpirvImageFormatToVkFormat(SpvImageFormat format);
         static SamplerNumericDomain UniformTypeToSamplerNumericDomain(GLenum glType);
@@ -256,6 +302,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // shaderStorageImageReadWithoutFormat and shaderStorageImageWriteWithoutFormat.
         Bool m_unformattedFloatStorageImagesEnabled = false;
         mutable ProgramLookupCache m_lastLookup;
+        // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
+        Uint64 m_frameCounter = 0;
+        IEvictionObserver* m_evictionObserver = nullptr;
         static inline XXH64_state_t* m_hashState = XXH64_createState();
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/SwapchainObject.cpp

@@ -247,6 +247,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         m_surfaceFormat = {createInfo.imageFormat, createInfo.imageColorSpace};
         m_extent = createInfo.imageExtent;
+        // The surface-space extent this swapchain was built from, i.e. before the
+        // quarter-turn swap above. Out-of-date checks must compare in THIS space: comparing a
+        // freshly queried currentExtent against the swapped m_extent flips axes every rotation
+        // and makes the comparison alternate forever.
+        m_surfaceExtent = defaultFramebufferExtent;
         m_preTransform = createInfo.preTransform;
 
         VK_VERIFY(vkCreateSwapchainKHR(device, &createInfo, nullptr, &m_swapchain));

MobileGL/MG_Backend/DirectVulkan/Renderer/SwapchainObject.h

@@ -35,6 +35,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkSwapchainKHR GetHandle() const { return m_swapchain; }
         const VkSurfaceFormatKHR& GetSurfaceFormat() const { return m_surfaceFormat; }
         VkExtent2D GetExtent() const { return m_extent; }
+        // Surface-space extent (before the pre-rotation quarter-turn swap) this swapchain was
+        // created from - the value to compare a freshly queried currentExtent against.
+        VkExtent2D GetSurfaceExtent() const { return m_surfaceExtent; }
         VkSurfaceTransformFlagBitsKHR GetPreTransform() const { return m_preTransform; }
         const Vector<VkImage>& GetImages() const { return m_images; }
         const Vector<VkImageView>& GetImageViews() const { return m_imageViews; }
@@ -63,6 +66,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkSwapchainKHR m_swapchain = VK_NULL_HANDLE;
         VkSurfaceFormatKHR m_surfaceFormat{};
         VkExtent2D m_extent{};
+        VkExtent2D m_surfaceExtent{};
         VkSurfaceTransformFlagBitsKHR m_preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
         Vector<VkImage> m_images;
         Vector<VkImageView> m_imageViews;

MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.cpp

@@ -16,6 +16,7 @@
 #include "MG_Util/Converters/GLToMG/TextureEnumConverter.h"
 #include "MG_Util/Converters/MGToStr/FramebufferEnumConverter.h"
 #include "MG_Util/Converters/MGToVk/TextureEnumConverter.h"
+#include <vulkan/utility/vk_format_utils.h>
 #include "MG_Util/Metrics/TextureMetrics.h"
 #include <Config.h>
 #include <cstdio>
@@ -211,6 +212,40 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
     }
 
+    void UniformManager::OnDescriptorSetLayoutDestroyed(VkDescriptorSetLayout descriptorSetLayout) {
+        SizeT purgedSets = 0;
+        for (auto& frame : m_frames) {
+            const auto it = frame.descriptorSetCacheByLayout.find(descriptorSetLayout);
+            if (it == frame.descriptorSetCacheByLayout.end()) {
+                continue;
+            }
+            // Free the sets back to their pools and credit the bucket accounting, so
+            // program churn recycles pool capacity instead of abandoning the slots.
+            // GPU-safe: the layout only dies after >1024 idle frame boundaries, so no
+            // in-flight command buffer references these sets.
+            for (const auto& cached : it->second.sets) {
+                if (cached.set == VK_NULL_HANDLE) {
+                    continue;
+                }
+                vkFreeDescriptorSets(m_device, cached.pool, 1, &cached.set);
+                const auto bucket = std::find_if(
+                    frame.descriptorPools.begin(), frame.descriptorPools.end(),
+                    [&cached](const DescriptorPoolBucket& candidate) { return candidate.handle == cached.pool; });
+                if (bucket != frame.descriptorPools.end() && bucket->allocatedSets > 0) {
+                    --bucket->allocatedSets;
+                }
+            }
+            purgedSets += it->second.sets.size();
+            frame.descriptorSetCacheByLayout.erase(it);
+        }
+        if (purgedSets > 0) {
+            // The per-draw reuse memo folds the layout handle into its signature; drop
+            // it so a recycled handle value cannot revive a purged set mid-frame.
+            m_hasLastDescriptor = false;
+            MGLOG_D("UniformDescriptorBinder: freed %zu descriptor sets for destroyed layout", purgedSets);
+        }
+    }
+
     Bool UniformManager::ResolveSamplerDescriptor(VkCommandBuffer commandBuffer,
                                                             const MG_State::GLState::ProgramObject& program,
                                                             const ProgramFactory::VkProgramObject& programObj,
@@ -350,24 +385,28 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             const Uint16 samplerVersion = samplerToUse->GetVersion();
             const Uint64 textureLifetimeId = texture->GetLifetimeId();
             const Uint16 textureParamsVersion = texture->GetTextureParamsVersion();
+            // The sampler's LOD clamp depends on how many levels the sampled view exposes, and that
+            // follows uploads as well as GL parameters - so it belongs in the memo key too.
+            const Uint32 viewLevelCount = resource->sampledLevelCount;
             if (memo.valid && memo.samplerLifetimeId == samplerLifetimeId && memo.samplerVersion == samplerVersion &&
                 memo.textureLifetimeId == textureLifetimeId && memo.textureParamsVersion == textureParamsVersion &&
-                memo.forceNearestFiltering == forceNearestFiltering) {
+                memo.forceNearestFiltering == forceNearestFiltering && memo.viewLevelCount == viewLevelCount) {
                 resolvedSampler = memo.sampler;
             } else {
-                resolvedSampler =
-                    m_samplerManager->GetOrCreateSampler(*samplerToUse, *texture, forceNearestFiltering);
+                resolvedSampler = m_samplerManager->GetOrCreateSampler(*samplerToUse, *texture,
+                                                                       forceNearestFiltering, viewLevelCount);
                 memo.samplerLifetimeId = samplerLifetimeId;
                 memo.samplerVersion = samplerVersion;
                 memo.textureLifetimeId = textureLifetimeId;
                 memo.textureParamsVersion = textureParamsVersion;
                 memo.forceNearestFiltering = forceNearestFiltering;
+                memo.viewLevelCount = viewLevelCount;
                 memo.sampler = resolvedSampler;
                 memo.valid = true;
             }
         } else {
-            resolvedSampler =
-                m_samplerManager->GetOrCreateSampler(*samplerToUse, *texture, forceNearestFiltering);
+            resolvedSampler = m_samplerManager->GetOrCreateSampler(*samplerToUse, *texture, forceNearestFiltering,
+                                                                   resource->sampledLevelCount);
         }
         outImageInfo = {
             .sampler = resolvedSampler,
@@ -408,6 +447,106 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return outImageInfo.sampler != VK_NULL_HANDLE;
     }
 
+    namespace {
+        // fp16 carries an 11-bit mantissa, so an 8-bit normalized channel round-trips exactly.
+        // Anything wider - 16-bit normalized, half float, full float, and every packed HDR
+        // encoding - holds precision or range that relaxing the arithmetic would throw away.
+        Bool IsLowPrecisionNormalizedFormat(VkFormat format) {
+            if (format == VK_FORMAT_UNDEFINED) return false;
+            if (!vkuFormatIsUNORM(format) && !vkuFormatIsSNORM(format) && !vkuFormatIsSRGB(format)) {
+                return false;
+            }
+            const struct VKU_FORMAT_INFO info = vkuGetFormatInfo(format);
+            for (Uint32 i = 0; i < info.component_count; ++i) {
+                if (info.components[i].size > 8) return false;
+            }
+            return info.component_count > 0;
+        }
+    } // namespace
+
+    Bool UniformManager::DrawTargetIsLowPrecision(const MG_State::GLState::FramebufferObject* drawFramebuffer) {
+        // Default framebuffer: the swapchain is an 8-bit normalized surface.
+        if (drawFramebuffer == nullptr) return true;
+
+        Bool sawColour = false;
+        for (Int i = static_cast<Int>(FramebufferAttachmentType::Color0);
+             i < static_cast<Int>(FramebufferAttachmentType::FramebufferAttachmentTypeCount);
+             ++i) {
+            const auto& attachment =
+                drawFramebuffer->GetAttachment(static_cast<FramebufferAttachmentType>(i));
+            VkFormat format = VK_FORMAT_UNDEFINED;
+            if (const auto& texture = attachment.GetTexture()) {
+                format = MG_Util::ConvertTextureInternalFormatToVkEnum(texture->GetFormat());
+            } else if (const auto& renderbuffer = attachment.GetRenderbuffer()) {
+                format = MG_Util::ConvertTextureInternalFormatToVkEnum(
+                    renderbuffer->GetInternalFormat());
+            } else {
+                continue;
+            }
+            if (!IsLowPrecisionNormalizedFormat(format)) return false;
+            sawColour = true;
+        }
+        return sawColour;
+    }
+
+    Bool UniformManager::ProgramSamplesOnlyLowPrecisionTextures(
+        const MG_State::GLState::ProgramObject& program, const ProgramFactory::VkProgramObject& programObj) {
+        for (Uint32 binding = 0; binding < programObj.bindingKinds.size(); ++binding) {
+            if (programObj.bindingKinds[binding] != ProgramFactory::DescriptorBindingKind::CombinedImageSampler) {
+                continue;
+            }
+            const auto* texture = ResolveSamplerTextureRaw(program, programObj, binding);
+            // An unresolvable binding is unknown territory, not licence to relax.
+            if (texture == nullptr) return false;
+            const VkFormat format =
+                MG_Util::ConvertTextureInternalFormatToVkEnum(texture->GetFormat());
+            if (!IsLowPrecisionNormalizedFormat(format)) return false;
+        }
+        return true;
+    }
+
+    Bool UniformManager::ProgramSamplesOnlySingleLevelTextures(
+        const MG_State::GLState::ProgramObject& program, const ProgramFactory::VkProgramObject& programObj) {
+        Bool sawSampler = false;
+        for (Uint32 binding = 0; binding < programObj.bindingKinds.size(); ++binding) {
+            if (programObj.bindingKinds[binding] != ProgramFactory::DescriptorBindingKind::CombinedImageSampler) {
+                continue;
+            }
+            const auto* texture = ResolveSamplerTextureRaw(program, programObj, binding);
+            if (texture == nullptr) return false;
+            const auto& levelRange = texture->GetLevelRange();
+            if (levelRange.x() != levelRange.y()) return false;
+
+            // An explicit-LOD sample is a single filtered tap, so it also gives up anisotropic
+            // filtering - which a single-level view can still have. Resolve the sampler exactly
+            // the way ResolveSamplerDescriptor does and bail if anisotropy would apply.
+            const Int location = programObj.samplerUniformLocationByBinding[binding];
+            const Int unit = ResolveSamplerUnitIndex(program, location, binding);
+            const auto& samplerOverride = MG_State::pGLContext->GetTextureUnitObject(unit).GetSamplerObject();
+            const auto* effectiveSampler =
+                samplerOverride ? samplerOverride.get() : texture->GetSamplerObject().get();
+            if (effectiveSampler == nullptr) return false;
+            if (effectiveSampler->GetMaxAnisotropy() > 1.0f &&
+                effectiveSampler->GetMinFilter() == SamplerFilterMode::Linear &&
+                effectiveSampler->GetMagFilter() == SamplerFilterMode::Linear) {
+                return false;
+            }
+
+            // An explicit LOD 0 makes lambda exactly 0, which is the magnification side of the
+            // min/mag decision. That only matches the implicit form when lambda could not have been
+            // positive anyway (the LOD clamp already pins it at or below 0), or when the two
+            // filters are the same and the choice cannot be observed.
+            const Float effectiveMaxLod = effectiveSampler->GetMipmapMode() == SamplerMipmapMode::None
+                                              ? 0.0f
+                                              : effectiveSampler->GetMaxLod();
+            if (effectiveMaxLod > 0.0f && effectiveSampler->GetMinFilter() != effectiveSampler->GetMagFilter()) {
+                return false;
+            }
+            sawSampler = true;
+        }
+        return sawSampler;
+    }
+
     Bool UniformManager::ResolveSamplerTexture(const MG_State::GLState::ProgramObject& program,
                                                          const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
                                                          SharedPtr<MG_State::GLState::ITextureObject>& outTexture) {
@@ -765,7 +904,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     Bool UniformManager::ResolveUniformBufferPayload(const MG_State::GLState::ProgramObject& program,
                                                      const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                                     UboBindResult& out) const {
+                                                     Uint32 arrayElement, UboBindResult& out) const {
         const void* outData = nullptr;
         VkDeviceSize outSize = 0;
 
@@ -791,7 +930,19 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         MOBILEGL_ASSERT(binding < programObj.uniformBlockIndexByBinding.size(),
                         "ResolveUniformBufferPayload: UBO mapping binding %u out of range", binding);
-        const Int blockIndex = programObj.uniformBlockIndexByBinding[binding];
+        Int blockIndex = programObj.uniformBlockIndexByBinding[binding];
+        if (arrayElement > 0) {
+            const auto arrayIt = programObj.arrayedUniformBlockIndicesByBinding.find(binding);
+            const Bool elementValid = arrayIt != programObj.arrayedUniformBlockIndicesByBinding.end() &&
+                                      arrayElement < arrayIt->second.size();
+            MOBILEGL_ASSERT(elementValid,
+                            "ResolveUniformBufferPayload: UBO binding %u has no array element %u", binding,
+                            arrayElement);
+            if (!elementValid) {
+                return false;
+            }
+            blockIndex = arrayIt->second[arrayElement];
+        }
         MOBILEGL_ASSERT(blockIndex >= 0,
                         "ResolveUniformBufferPayload: no uniform block mapped to descriptor binding %u", binding);
 
@@ -899,6 +1050,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         VkDescriptorPoolCreateInfo poolInfo{};
         poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+        // FREE_DESCRIPTOR_SET_BIT lets a destroyed layout's cached sets be freed back
+        // (OnDescriptorSetLayoutDestroyed) so program churn recycles pool capacity.
+        // The cost is on set allocation only, which happens when a layout's per-frame
+        // cache grows - never on the per-draw reuse path.
+        poolInfo.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
         poolInfo.maxSets = maxSets;
         poolInfo.poolSizeCount = static_cast<Uint32>(std::size(poolSizes));
         poolInfo.pPoolSizes = poolSizes;
@@ -978,7 +1134,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         auto& frame = m_frames[frameIndex];
         auto& cache = frame.descriptorSetCacheByLayout[programObj.descriptorSetLayout];
         if (cache.cursor < cache.sets.size()) {
-            outDescriptorSet = cache.sets[cache.cursor++];
+            outDescriptorSet = cache.sets[cache.cursor++].set;
         } else {
             VkResult allocResult = AllocateDescriptorSetsFromActivePool(frameIndex, programObj, outDescriptorSet);
             if (allocResult == VK_ERROR_OUT_OF_POOL_MEMORY || allocResult == VK_ERROR_FRAGMENTED_POOL) {
@@ -992,7 +1148,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 return allocResult;
             }
 
-            cache.sets.push_back(outDescriptorSet);
+            // The successful allocation came from the bucket the alloc helper left
+            // active; record it so a layout-destroyed purge can free the set back.
+            cache.sets.push_back({outDescriptorSet, frame.descriptorPools[frame.activeDescriptorPoolIndex].handle});
             ++cache.cursor;
             MGLOG_D("UniformDescriptorBinder: cached descriptor set count for frame=%u grew to %zu", frameIndex,
                     cache.sets.size());
@@ -1038,11 +1196,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         imageInfos.clear();
         texelBufferViews.clear();
         dynamicOffsets.clear();
+        // Arrayed UBO bindings contribute extra buffer infos and dynamic offsets; reserve for
+        // the worst case so the pBufferInfo pointers taken below never dangle on reallocation.
+        Uint32 uboArrayExtra = 0;
+        for (const auto& arrayEntry : programObj.arrayedUniformBlockIndicesByBinding) {
+            uboArrayExtra += static_cast<Uint32>(arrayEntry.second.size()) - 1u;
+        }
         writes.reserve(m_maxBindings);
-        bufferInfos.reserve(m_maxBindings);
+        bufferInfos.reserve(m_maxBindings + uboArrayExtra);
         imageInfos.reserve(m_maxBindings);
         texelBufferViews.reserve(m_maxBindings);
-        dynamicOffsets.reserve(programObj.dynamicBindings.size());
+        dynamicOffsets.reserve(programObj.dynamicBindings.size() + uboArrayExtra);
 
         const Uint32 bindingCount =
             std::min<Uint32>(m_maxBindings, static_cast<Uint32>(programObj.bindingKinds.size()));
@@ -1060,40 +1224,51 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             write.descriptorCount = 1;
 
             if (kind == ProgramFactory::DescriptorBindingKind::UniformBufferDynamic) {
-                UboBindResult ubo{};
-                const Bool hasPayload = ResolveUniformBufferPayload(program, programObj, binding, ubo);
-                MOBILEGL_ASSERT(hasPayload && ubo.payload != nullptr && ubo.payloadSize > 0,
-                                "UniformDescriptorBinder::BindProgramUniformBuffers failed: missing UBO payload on binding %u",
-                                binding);
+                const Uint32 descriptorCount =
+                    binding < programObj.bindingDescriptorCounts.size()
+                        ? std::max<Uint32>(1, programObj.bindingDescriptorCounts[binding])
+                        : 1u;
+                const SizeT firstBufferInfoIndex = bufferInfos.size();
+                for (Uint32 element = 0; element < descriptorCount; ++element) {
+                    UboBindResult ubo{};
+                    const Bool hasPayload =
+                        ResolveUniformBufferPayload(program, programObj, binding, element, ubo);
+                    MOBILEGL_ASSERT(hasPayload && ubo.payload != nullptr && ubo.payloadSize > 0,
+                                    "UniformDescriptorBinder::BindProgramUniformBuffers failed: missing UBO payload on binding %u element %u",
+                                    binding, element);
 
-                VkDescriptorBufferInfo bufferInfo{};
-                // Keep offset 0 (sub-range selected via the dynamic offset) so the hashed bufferInfo
-                // is stable across draws and the descriptor-set reuse cache keeps hitting.
-                bufferInfo.offset = 0;
-                Uint32 dynOffset;
-                if (ubo.directBindable) {
-                    // Zero-copy: bind the app's resident VkBuffer directly, no per-draw memcpy.
-                    bufferInfo.buffer = ubo.buffer;
-                    bufferInfo.range = ubo.range;
-                    dynOffset = static_cast<Uint32>(ubo.dynamicOffset);
-                } else {
-                    BufferSlice slice{};
-                    if (!m_bufferManager->UploadTransient(BufferKind::Uniform, frameIndex, ubo.payload,
-                                                          ubo.payloadSize, m_minDynamicOffsetAlignment, slice)) {
-                        MOBILEGL_ASSERT(false, "UniformDescriptorBinder::BindProgramUniformBuffers failed: UBO upload failed on binding %u",
-                                binding);
-                        return false;
+                    VkDescriptorBufferInfo bufferInfo{};
+                    // Keep offset 0 (sub-range selected via the dynamic offset) so the hashed bufferInfo
+                    // is stable across draws and the descriptor-set reuse cache keeps hitting.
+                    bufferInfo.offset = 0;
+                    Uint32 dynOffset;
+                    if (ubo.directBindable) {
+                        // Zero-copy: bind the app's resident VkBuffer directly, no per-draw memcpy.
+                        bufferInfo.buffer = ubo.buffer;
+                        bufferInfo.range = ubo.range;
+                        dynOffset = static_cast<Uint32>(ubo.dynamicOffset);
+                    } else {
+                        BufferSlice slice{};
+                        if (!m_bufferManager->UploadTransient(BufferKind::Uniform, frameIndex, ubo.payload,
+                                                              ubo.payloadSize, m_minDynamicOffsetAlignment, slice)) {
+                            MOBILEGL_ASSERT(false, "UniformDescriptorBinder::BindProgramUniformBuffers failed: UBO upload failed on binding %u element %u",
+                                    binding, element);
+                            return false;
+                        }
+                        bufferInfo.buffer = slice.buffer;
+                        bufferInfo.range = ubo.payloadSize;
+                        dynOffset = static_cast<Uint32>(slice.offset);
                     }
-                    bufferInfo.buffer = slice.buffer;
-                    bufferInfo.range = ubo.payloadSize;
-                    dynOffset = static_cast<Uint32>(slice.offset);
+                    bufferInfos.push_back(bufferInfo);
+                    // Dynamic offsets are consumed in binding order, then array element order,
+                    // matching Vulkan's dynamic-offset consumption rules.
+                    dynamicOffsets.push_back(dynOffset);
                 }
-                bufferInfos.push_back(bufferInfo);
 
                 write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
-                write.pBufferInfo = &bufferInfos.back();
+                write.descriptorCount = descriptorCount;
+                write.pBufferInfo = &bufferInfos[firstBufferInfoIndex];
                 writes.push_back(write);
-                dynamicOffsets.push_back(dynOffset);
             } else if (kind == ProgramFactory::DescriptorBindingKind::UniformTexelBuffer) {
                 VkBufferView bufferView = VK_NULL_HANDLE;
                 if (!ResolveTexelBufferDescriptor(program, programObj, binding, frameIndex, bufferView) ||

MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.h

@@ -39,6 +39,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void Shutdown();
 
         void BeginFrame(Uint32 frameIndex);
+        // A ProgramFactory eviction just destroyed this layout: purge every frame
+        // slot's cached descriptor sets for it, so a recycled handle value can never
+        // stale-hit sets written for the dead layout's bindings. The sets are
+        // vkFreeDescriptorSets'd back to their pools (created with
+        // FREE_DESCRIPTOR_SET_BIT) and the pool accounting is credited, so program
+        // churn recycles pool capacity instead of abandoning it. GPU-safe: the layout
+        // only dies after >1024 idle frame boundaries, so no in-flight command buffer
+        // references its sets. This is the only eviction path for the per-layout
+        // caches - a live layout's entry must never be purged (its sets would be
+        // unreachable pool slots), so there is deliberately no age-based sweep here.
+        void OnDescriptorSetLayoutDestroyed(VkDescriptorSetLayout descriptorSetLayout);
         Bool CollectSampledTextures(const MG_State::GLState::ProgramObject& program,
                                     const ProgramFactory::VkProgramObject& programObj,
                                     Vector<MG_State::GLState::ITextureObject*>& outTextures);
@@ -58,6 +69,25 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         static VkFormat ResolveStorageImageViewFormat(VkFormat reflectedFormat, GLenum bindingFormat,
                                                       VkFormat resourceFormat, Bool useBindingFormat);
 
+        // True when the program reads at least one sampler and every one of them is bound to a
+        // texture whose GL level range is a single level. Such a sampler resolves to
+        // minLod = maxLod = 0 (see VkSamplerManager::GetOrCreateSampler), so an implicit-LOD sample
+        // and an explicit LOD 0 sample must read the same texel - which is what makes the
+        // ExplicitLod0Sampling SPIR-V rewrite safe to request. Deliberately conservative: it reads
+        // only GL state, so a texture that ends up single-level for another reason (one uploaded
+        // level under a wide level range) merely misses the rewrite.
+        // True when every texture this program samples is an 8-bit-or-less normalized format, so
+        // relaxing the fragment stage to fp16 cannot lose a bit the texel ever carried. Says
+        // nothing about the render target - the caller must check that too.
+        static Bool ProgramSamplesOnlyLowPrecisionTextures(const MG_State::GLState::ProgramObject& program,
+                                                          const ProgramFactory::VkProgramObject& programObj);
+        // True when every colour attachment the draw writes is an 8-bit-or-less normalized
+        // format (nullptr = default framebuffer, which is). Blending happens at attachment
+        // precision, so a wider target must keep the fragment stage at full precision.
+        static Bool DrawTargetIsLowPrecision(const MG_State::GLState::FramebufferObject* drawFramebuffer);
+        static Bool ProgramSamplesOnlySingleLevelTextures(const MG_State::GLState::ProgramObject& program,
+                                                          const ProgramFactory::VkProgramObject& programObj);
+
     private:
         struct DescriptorPoolBucket {
             VkDescriptorPool handle = VK_NULL_HANDLE;
@@ -65,8 +95,16 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint32 allocatedSets = 0;
         };
 
+        // A cached descriptor set together with the pool it was allocated from, so a
+        // layout-destroyed purge can vkFreeDescriptorSets it back and credit the
+        // owning bucket's accounting.
+        struct CachedDescriptorSet {
+            VkDescriptorSet set = VK_NULL_HANDLE;
+            VkDescriptorPool pool = VK_NULL_HANDLE;
+        };
+
         struct DescriptorSetCacheEntry {
-            Vector<VkDescriptorSet> sets;
+            Vector<CachedDescriptorSet> sets;
             Uint32 cursor = 0;
         };
 
@@ -116,7 +154,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         };
         Bool ResolveUniformBufferPayload(const MG_State::GLState::ProgramObject& program,
                                          const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                         UboBindResult& out) const;
+                                         Uint32 arrayElement, UboBindResult& out) const;
         Bool CreateDescriptorPool(Uint32 maxSets, VkDescriptorPool& outPool) const;
         Bool GrowFrameDescriptorPool(FrameResources& frame, Uint32 frameIndex);
         VkResult AllocateDescriptorSetsFromActivePool(
@@ -172,6 +210,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint64 samplerLifetimeId = 0;
             Uint64 textureLifetimeId = 0;
             VkSampler sampler = VK_NULL_HANDLE;
+            Uint32 viewLevelCount = 0;
             Uint16 samplerVersion = 0;
             Uint16 textureParamsVersion = 0;
             Bool forceNearestFiltering = false;

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.cpp

@@ -32,6 +32,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.IsBgra, sizeof(attr.IsBgra)));
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.Divisor, sizeof(attr.Divisor)));
 
+            // The buffer's heap address is an identity component of the key: a freed
+            // buffer's reused address can alias an old cache entry, but only under a
+            // byte-identical attribute layout - and the entry payload is a pure function
+            // of the hashed inputs, with the draw path re-resolving bindingBufferKeys
+            // against the live VAO attribute pointers, so an aliased hit returns exactly
+            // what a rebuild would. Address drift only grows the map; the OnFrameBoundary
+            // aging sweep bounds that.
             const SizeT bufferKey = reinterpret_cast<SizeT>(attr.Buffer.get());
             XXHASH_VERIFY(XXH64_update(m_hashState, &bufferKey, sizeof(bufferKey)));
         }
@@ -58,6 +65,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const MG_State::GLState::VertexArrayObject& vao, HashType hash) {
         auto it = m_cache.find(hash);
         if (it != m_cache.end()) {
+            it->second.lastUsedFrameBoundary = m_frameBoundaryCounter;
             return it->second;
         }
 
@@ -166,6 +174,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         auto& entry = m_cache[hash];
         entry.hash = hash;
+        entry.lastUsedFrameBoundary = m_frameBoundaryCounter;
         entry.bindings = builder.GetBindings();
         entry.attributes = builder.GetAttributes();
         entry.bindingBufferKeys = std::move(bindingBufferKeys);
@@ -180,6 +189,30 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return entry;
     }
 
+    void VertexInputStateFactory::OnFrameBoundary() {
+        ++m_frameBoundaryCounter;
+
+        // Sweep occasionally; evict entries whose last hit is far in the past.
+        // Erasure happens only here, never mid-frame: the draw path holds a
+        // reference into the current entry across its setup, and unordered_map
+        // erase would invalidate it. Entries are CPU-side only, so no GPU-idle
+        // proof is needed; an evicted entry that is used again is simply rebuilt
+        // from the VAO state (same hash, same content).
+        constexpr Uint64 kSweepInterval = 256;
+        constexpr Uint64 kRetireAgeBoundaries = 1024;
+        if ((m_frameBoundaryCounter % kSweepInterval) != 0) {
+            return;
+        }
+
+        for (auto it = m_cache.begin(); it != m_cache.end();) {
+            if (m_frameBoundaryCounter - it->second.lastUsedFrameBoundary > kRetireAgeBoundaries) {
+                it = m_cache.erase(it);
+            } else {
+                ++it;
+            }
+        }
+    }
+
     VkFormat VertexInputStateFactory::ToVkVertexFormat(DataType type, Int size, Bool normalized, Bool isInteger,
                                                        Bool isBgra) {
         if (isBgra) {

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.h

@@ -27,6 +27,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         struct BackendVertexInputState {
             HashType hash = 0;
+            // Frame boundary of the last cache hit; entries idle past the
+            // OnFrameBoundary retirement age are evicted (CPU heap only).
+            Uint64 lastUsedFrameBoundary = 0;
             Vector<VkVertexInputBindingDescription> bindings;
             Vector<VkVertexInputAttributeDescription> attributes;
             Vector<SizeT> bindingBufferKeys;
@@ -55,6 +58,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const BackendVertexInputState& GetOrCreateVertexInputState(
             const MG_State::GLState::VertexArrayObject& vao, HashType hash);
         const BackendVertexInputState& GetOrCreateVertexInputState(const MG_State::GLState::VertexArrayObject& vao);
+        // Frame boundary hook: ages the cache and evicts entries not hit for many
+        // frames. The key mixes buffer heap addresses, so buffer/VAO churn keeps
+        // minting fresh keys; without eviction the map grows for the whole session.
+        // Entries hold no Vulkan handles (pipeline creation copies the descriptions)
+        // and the draw path's entry reference never spans a frame boundary, so
+        // eviction here needs no GPU-idle proof. Self-gated: one counter bump and
+        // compare except on sweep boundaries.
+        void OnFrameBoundary();
         static SizeT GetComponentSize(DataType type);
         // Tightly-packed byte size of one vertex element for this attribute: componentSize * size for
         // normal types, and 4 (one packed word) for the 2_10_10_10 types and GL_BGRA. Returns 0 for
@@ -70,6 +81,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const VulkanRendererConfig& m_config;
         VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
         UnorderedMap<HashType, BackendVertexInputState> m_cache;
+        // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
+        Uint64 m_frameBoundaryCounter = 0;
         static inline XXH64_state_t* m_hashState = XXH64_createState();
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.cpp

@@ -141,6 +141,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_transientUploadArena.BeginFrame(frameIndex);
     }
 
+    void VkBufferManager::CollectAllDeferredReleases() {
+        for (Uint32 frameIndex = 0; frameIndex < m_deferredBufferReleases.size(); ++frameIndex) {
+            CollectDeferredReleases(frameIndex);
+        }
+        for (Uint32 frameIndex = 0; frameIndex < m_transientUploadArena.GetFrameCount(); ++frameIndex) {
+            m_transientUploadArena.CollectDeferredReleases(frameIndex);
+        }
+    }
+
     void VkBufferManager::NotifyDeviceIdle() {
         // Everything submitted so far has completed. Work recorded for the
         // current frame has not been submitted yet, so the current serial

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.h

@@ -77,6 +77,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // Recreate all per-frame transient arenas
         Bool RecreateTransientArenas(Uint32 frameCount);
         void BeginFrame(Uint32 frameIndex);
+        // Drains every frame slot's deferred buffer/resource releases (and the
+        // transient arena's parked superseded blocks). Only valid when the
+        // caller has proven every queue submission complete; used by the
+        // present-less frame-boundary drain.
+        void CollectAllDeferredReleases();
         // All previously submitted GPU work has completed (vkDeviceWaitIdle).
         void NotifyDeviceIdle();
         // A frame slot's submission fence has been waited: every serial up to

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.cpp

@@ -180,6 +180,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         sampleCount = VK_SAMPLE_COUNT_1_BIT;
         internalFormat = TextureInternalFormat::Unknown;
         samples = 0;
+        deadSinceFrame = kNeverObservedDead;
     }
 
     VkRenderPassManager::VkRenderPassManager(VkDevice device,
@@ -206,6 +207,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             resource.Destroy(m_device, m_allocator);
         }
         m_renderbufferResources.clear();
+        CollectDeferredRenderbufferReleases(/*destroyAll=*/true); // caller guarantees device idle
         m_pendingRenderbufferClears.clear();
         RenderPassEntry::s_textureResourcesScratch.clear();
         s_activeRenderPass = {};
@@ -213,22 +215,75 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_rpFastValid = false;
     }
 
-    void VkRenderPassManager::CollectRenderbufferGarbage() {
-        Vector<MG_State::GLState::RenderbufferObject*> deadRenderbuffers;
-        deadRenderbuffers.reserve(m_renderbufferResources.size());
-        for (auto& [renderbuffer, resource] : m_renderbufferResources) {
-            const auto liveRenderbuffer = resource.renderbuffer.lock();
-            if (!liveRenderbuffer || liveRenderbuffer.get() != renderbuffer) {
-                deadRenderbuffers.emplace_back(renderbuffer);
-            }
+    Uint64 VkRenderPassManager::RetireAgeFrames() const {
+        // MaxFramesInFlight + 2 covers the frame ring plus one boundary for the
+        // recording-to-submit gap and one because OnPresent runs ahead of Present's
+        // fence wait; the floor of 8 keeps a margin over the default ring of 3 while
+        // still releasing multi-MB attachment memory promptly (the render-pass cache's
+        // 1024-frame retirement would pin it for no additional safety).
+        return std::max<Uint64>(8, static_cast<Uint64>(m_config.MaxFramesInFlight) + 2);
+    }
+
+    void VkRenderPassManager::DeferRenderbufferBackingRelease(RenderbufferResource& resource) {
+        // The superseded backing may still be referenced by in-flight command buffers
+        // (glRenderbufferStorage can respecify a renderbuffer drawn this very frame),
+        // so it is parked and destroyed only after RetireAgeFrames() boundaries.
+        if (resource.image == VK_NULL_HANDLE && resource.view == VK_NULL_HANDLE) {
+            return;
         }
-        for (auto* renderbuffer : deadRenderbuffers) {
-            auto resourceIt = m_renderbufferResources.find(renderbuffer);
-            if (resourceIt != m_renderbufferResources.end()) {
-                resourceIt->second.Destroy(m_device, m_allocator);
-                m_renderbufferResources.erase(resourceIt);
+        m_deferredRenderbufferReleases.push_back({resource.image, resource.allocation, resource.view, m_frameCounter});
+        resource.image = VK_NULL_HANDLE;
+        resource.allocation = nullptr;
+        resource.view = VK_NULL_HANDLE;
+    }
+
+    void VkRenderPassManager::CollectDeferredRenderbufferReleases(Bool destroyAll) {
+        if (m_deferredRenderbufferReleases.empty()) {
+            return;
+        }
+        const Uint64 retireAgeFrames = RetireAgeFrames();
+        std::erase_if(m_deferredRenderbufferReleases, [&](DeferredRenderbufferRelease& release) {
+            if (!destroyAll && m_frameCounter - release.deferredAtFrame < retireAgeFrames) {
+                return false;
             }
-            m_pendingRenderbufferClears.erase(renderbuffer);
+            if (release.view != VK_NULL_HANDLE) {
+                vkDestroyImageView(m_device, release.view, nullptr);
+            }
+            if (release.image != VK_NULL_HANDLE) {
+                vmaDestroyImage(m_allocator, release.image, release.allocation);
+            }
+            return true;
+        });
+    }
+
+    void VkRenderPassManager::CollectRenderbufferGarbage() {
+        // Two-phase reclamation: a dead renderbuffer's VkImage may still be referenced by
+        // command buffers submitted up to frames-in-flight frames ago (it was legally
+        // attached and drawn right up to its deletion), so the first observation of an
+        // expired weak reference only stamps the current frame counter; Destroy runs once
+        // enough frame boundaries have passed that the stamping frame's submission fence
+        // has provably been waited (see RetireAgeFrames).
+        const Uint64 retireAgeFrames = RetireAgeFrames();
+        for (auto it = m_renderbufferResources.begin(); it != m_renderbufferResources.end();) {
+            auto& resource = it->second;
+            const auto liveRenderbuffer = resource.renderbuffer.lock();
+            if (liveRenderbuffer && liveRenderbuffer.get() == it->first) {
+                resource.deadSinceFrame = RenderbufferResource::kNeverObservedDead;
+                ++it;
+                continue;
+            }
+            if (resource.deadSinceFrame == RenderbufferResource::kNeverObservedDead) {
+                resource.deadSinceFrame = m_frameCounter;
+                ++it;
+                continue;
+            }
+            if (m_frameCounter - resource.deadSinceFrame < retireAgeFrames) {
+                ++it;
+                continue;
+            }
+            m_pendingRenderbufferClears.erase(it->first);
+            resource.Destroy(m_device, m_allocator);
+            it = m_renderbufferResources.erase(it);
         }
     }
 
@@ -251,11 +306,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const auto internalFormat = renderbuffer->GetInternalFormat();
         const VkFormat format = MG_Util::ConvertTextureInternalFormatToVkEnum(internalFormat);
         const VkImageAspectFlags aspect = ResolveImageAspectMaskForFormat(format);
-        if ((aspect & VK_IMAGE_ASPECT_COLOR_BIT) != 0) {
-            MGLOG_E("GetOrCreateRenderbufferResource: color renderbuffer %u is not supported by DirectVulkan render passes yet",
-                    renderbuffer->GetExternalIndex());
-            return nullptr;
-        }
+        // Renderbuffers are never sampled (GL has no way to bind one to a sampler), so the
+        // usage set is attachment + transfer: transfer covers readback (vkCmdCopyImageToBuffer),
+        // BlitFramebuffer, CopyTexImage sources, and out-of-render-pass clear materialization.
+        const VkImageUsageFlags imageUsage =
+            ((aspect & VK_IMAGE_ASPECT_COLOR_BIT) != 0 ? VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
+                                                       : VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) |
+            VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
         auto& resource = m_renderbufferResources[renderbuffer.get()];
         const Bool needsCreate =
@@ -268,9 +325,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             resource.samples != renderbuffer->GetSamples();
         if (!needsCreate) {
             resource.renderbuffer = renderbuffer;
+            // A new renderbuffer at a recycled address may adopt a compatible entry that
+            // was already stamped dead; it is alive again, so cancel the aging.
+            resource.deadSinceFrame = RenderbufferResource::kNeverObservedDead;
             return &resource;
         }
 
+        // Respecify: park the old backing for aged destruction instead of destroying
+        // inline - it may still be referenced by in-flight command buffers.
+        DeferRenderbufferBackingRelease(resource);
         resource.Destroy(m_device, m_allocator);
         resource.renderbuffer = renderbuffer;
 
@@ -285,7 +348,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         imageInfo.format = format;
         imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
         imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-        imageInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+        imageInfo.usage = imageUsage;
         imageInfo.samples = sampleCount;
         imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
@@ -386,6 +449,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void VkRenderPassManager::QueueRenderbufferClear(
         GLbitfield mask, const ClearFramebufferPayload& clearPayload,
         const MG_State::GLState::FramebufferObject& drawFbo) {
+        if ((mask & GL_COLOR_BUFFER_BIT) != 0) {
+            // Color renderbuffer draw buffers take the framebuffer-level clear too; texture
+            // attachments are skipped by the per-attachment overload's IsRenderbuffer guard.
+            for (const auto attachmentType : drawFbo.GetDrawBuffers()) {
+                if (attachmentType == FramebufferAttachmentType::None) {
+                    continue;
+                }
+                QueueRenderbufferClear(
+                    ClearAttachmentPayload{.mask = GL_COLOR_BUFFER_BIT, .color = clearPayload.color},
+                    drawFbo.GetAttachment(attachmentType));
+            }
+        }
         if ((mask & GL_DEPTH_BUFFER_BIT) != 0) {
             QueueRenderbufferClear(
                 ClearAttachmentPayload{.mask = GL_DEPTH_BUFFER_BIT, .depth = clearPayload.depth},
@@ -682,6 +757,83 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // assuming default FBO has the right param
         for (Uint32 i = 0; i < colorAttachmentSlotCount; ++i) {
             auto drawbuf = drawbufs[i];
+
+            // Renderbuffer color attachments mirror the texture path below, with the
+            // resource (image/view/format/layout) coming from the render-pass manager's
+            // renderbuffer store instead of the texture manager.
+            if (drawbuf != FramebufferAttachmentType::None && !isDefaultFbo) {
+                const auto& rbAtt = fbo.GetAttachment(drawbuf);
+                if (rbAtt.IsRenderbuffer() && rbAtt.IsComplete()) {
+                    const auto& renderbuffer = rbAtt.GetRenderbuffer();
+                    auto* rbResource = GetOrCreateRenderbufferResource(renderbuffer);
+                    if (rbResource == nullptr || (rbResource->aspect & VK_IMAGE_ASPECT_COLOR_BIT) == 0) {
+                        MGLOG_E("GetOrCreateRenderPass: draw buffer slot %u on FBO %u has an unsupported color "
+                                "renderbuffer %u; using VK_ATTACHMENT_UNUSED",
+                                i, fbo.GetExternalIndex(), renderbuffer->GetExternalIndex());
+                        continue;
+                    }
+
+                    const Uint32 rbAttachmentIndex = static_cast<Uint32>(attachmentDescriptions.size());
+                    attachmentDescriptions.emplace_back();
+                    VkAttachmentDescription& rbDesc = attachmentDescriptions.back();
+
+                    ClearAttachmentPayload rbClearPayload{};
+                    Bool rbHasClear = GetPendingRenderbufferClear(renderbuffer.get(), rbClearPayload) &&
+                                      (rbClearPayload.mask & GL_COLOR_BUFFER_BIT) != 0;
+                    if (rbHasClear &&
+                        MG_Util::GetBaseInternalFormatComponentCount(renderbuffer->GetInternalFormat()) == 3) {
+                        // RGB renderbuffers are backed by an RGBA image; the missing alpha reads as 1.
+                        rbClearPayload.color =
+                            FloatVec4(rbClearPayload.color.x(), rbClearPayload.color.y(),
+                                      rbClearPayload.color.z(), 1.0f);
+                    }
+
+                    const VkImageLayout trackedRbLayout = rbResource->layout;
+                    rbDesc.flags = 0;
+                    rbDesc.format = rbResource->format;
+                    rbDesc.samples = rbResource->sampleCount;
+                    rbDesc.loadOp = rbHasClear ? VK_ATTACHMENT_LOAD_OP_CLEAR :
+                                    (trackedRbLayout == VK_IMAGE_LAYOUT_UNDEFINED ? VK_ATTACHMENT_LOAD_OP_DONT_CARE
+                                                                                  : VK_ATTACHMENT_LOAD_OP_LOAD);
+                    rbDesc.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+                    rbDesc.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+                    rbDesc.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+                    rbDesc.initialLayout = (rbHasClear || trackedRbLayout == VK_IMAGE_LAYOUT_UNDEFINED) ?
+                        VK_IMAGE_LAYOUT_UNDEFINED : trackedRbLayout;
+                    rbDesc.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+                    adoptRenderPassSampleCount(rbResource->sampleCount, "color",
+                                               static_cast<Int>(renderbuffer->GetExternalIndex()));
+
+                    if (rbHasClear) {
+                        pendingClearAttachments.emplace_back(PendingClearAttachmentInfo {
+                            .attachmentIndex = rbAttachmentIndex,
+                            .colorAttachmentSlot = i,
+                            .renderbuffer = renderbuffer.get(),
+                            .hasInlinePayload = true,
+                            .inlinePayload = rbClearPayload,
+                        });
+                    }
+
+                    if (width == 0)
+                        width = static_cast<Int>(rbResource->extent.width);
+                    if (height == 0)
+                        height = static_cast<Int>(rbResource->extent.height);
+
+                    trackedAttachmentLayouts.emplace_back(TrackedAttachmentLayoutInfo {
+                        .target = TrackedAttachmentTarget::Renderbuffer,
+                        .renderbuffer = renderbuffer,
+                        .finalLayout = rbDesc.finalLayout,
+                    });
+                    textureResources.emplace_back(nullptr);
+                    attachmentViews.emplace_back(rbResource->view);
+                    MOBILEGL_ASSERT(attachmentViews.back() != VK_NULL_HANDLE,
+                                    "GetOrCreateRenderPass: renderbuffer view missing at color attachment %d", i);
+
+                    colorAttachmentRefs[i].attachment = rbAttachmentIndex;
+                    continue;
+                }
+            }
+
             auto* texture = ResolveCompleteColorAttachmentTexture(fbo, drawbuf, i);
             if (texture == nullptr)
                 continue;
@@ -700,6 +852,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 case TextureTarget::Texture2D:
                 case TextureTarget::Texture2DArray:
                 case TextureTarget::Texture2DMultisample:
+                case TextureTarget::Texture2DMultisampleArray:
+                case TextureTarget::Texture3D:
+                case TextureTarget::TextureCubeMap:
+                case TextureTarget::TextureCubeMapArray:
                 case TextureTarget::TextureRectangle: {
                     desc.flags = 0;
                     desc.format = isDefaultFbo ?
@@ -1083,6 +1239,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void VkRenderPassManager::OnPresent() {
         ++m_frameCounter;
 
+        // Runs every frame boundary, ahead of the render-pass sweep gate below: the walk
+        // is O(#renderbuffer resources) — single digits in practice — and per-frame
+        // invocation keeps dead-resource reclaim latency at the aging bound instead of
+        // coupling it to renderbuffer *use* (the GetOrCreateRenderbufferResource call
+        // site never runs again once an app stops using renderbuffers).
+        CollectRenderbufferGarbage();
+        CollectDeferredRenderbufferReleases(/*destroyAll=*/false);
+
         // Sweep occasionally; evict entries whose last use is far past every
         // in-flight frame so their VkRenderPass/VkFramebuffer can be destroyed
         // safely (RenderPassEntry's destructor releases the handles).
@@ -1092,6 +1256,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return;
         }
 
+        // Collect the dying handles and notify once after the loop: pipelines hashed
+        // on them share the entries' >kRetireAgeFrames idleness (they are only bound
+        // by draws that hit those entries), so the observer may destroy them
+        // immediately - and a single batched notification costs one pipeline-cache
+        // scan instead of one per evicted pass.
+        Vector<VkRenderPass> destroyedRenderPasses;
         const Uint64 activeHash = s_hasActiveRenderPass ? s_activeRenderPass.hash : 0;
         for (auto it = m_renderPasses.begin(); it != m_renderPasses.end();) {
             const Bool isActive = s_hasActiveRenderPass && it->first == activeHash;
@@ -1099,11 +1269,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 if (m_rpFastValid && m_rpFastRenderPassHash == it->first) {
                     m_rpFastValid = false;
                 }
+                destroyedRenderPasses.push_back(it->second.renderPass);
                 it = m_renderPasses.erase(it);
             } else {
                 ++it;
             }
         }
+        if (!destroyedRenderPasses.empty() && m_evictionObserver != nullptr) {
+            m_evictionObserver->OnRenderPassesDestroyed(destroyedRenderPasses);
+        }
     }
 
     Bool VkRenderPassManager::BeginRenderPass(VkCommandBuffer commandBuffer, RenderPassEntry& renderPassEntry) {

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.h

@@ -157,11 +157,31 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     class VkRenderPassManager {
     public:
         using HashType = Uint64;
+
+        // Notified once per OnPresent sweep with every aged-out entry's VkRenderPass
+        // value: pipelines are hashed on the raw handle, and once destroyed the value
+        // may be recycled for an incompatible pass, so dependent caches must purge
+        // everything keyed on them before any new pass can be created (the sweep and
+        // the notification run back-to-back with no creation in between; observers
+        // compare the values, never dereference them). Batched so a mass-idle cohort
+        // (shader-pack switch, dimension exit) costs the observer one pipeline-cache
+        // scan, not one per dying pass. The wholesale paths
+        // (Shutdown/RecreateSwapchain) do not notify - their callers already drop
+        // every pipeline outright.
+        class IEvictionObserver {
+        public:
+            virtual ~IEvictionObserver() = default;
+            virtual void OnRenderPassesDestroyed(const Vector<VkRenderPass>& renderPasses) = 0;
+        };
+
         VkRenderPassManager(VkDevice device,
             VkPhysicalDevice physicalDevice, VmaAllocator allocator, const VulkanRendererConfig& config,
             VkClearManager& clearManager, VkTextureManager& textureManager, SwapchainObject& swapchainObject);
         ~VkRenderPassManager();
 
+        // Observer may be null (no notifications). Not owned.
+        void SetEvictionObserver(IEvictionObserver* observer) { m_evictionObserver = observer; }
+
         Bool Initialize();
         void Shutdown();
 
@@ -192,6 +212,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         UnorderedMap<Uint64, RenderPassEntry> m_renderPasses;
         // Monotonic frame counter (bumped in OnPresent) for render-pass cache aging.
         Uint64 m_frameCounter = 0;
+        IEvictionObserver* m_evictionObserver = nullptr;
 
         // Bumped whenever a renderbuffer VkImage is (re)created; together with the texture
         // manager's image epoch this invalidates the render-pass fast path on any attachment
@@ -211,7 +232,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint64 m_rpFastRbEpoch = 0;
         Uint64 m_rpFastRenderPassHash = 0;
 
+    public:
         struct RenderbufferResource {
+            // deadSinceFrame sentinel: the owning weak reference has not been observed
+            // expired. Dead resources age past every in-flight frame before Destroy
+            // (see CollectRenderbufferGarbage); the GPU may still reference the image
+            // for frames-in-flight frames after the GL object dies.
+            static constexpr Uint64 kNeverObservedDead = UINT64_MAX;
+
             WeakPtr<MG_State::GLState::RenderbufferObject> renderbuffer;
             VkImage image = VK_NULL_HANDLE;
             VmaAllocation allocation = nullptr;
@@ -223,25 +251,47 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT;
             TextureInternalFormat internalFormat = TextureInternalFormat::Unknown;
             Int samples = 0;
+            // m_frameCounter value at which the weak reference was first seen expired.
+            Uint64 deadSinceFrame = kNeverObservedDead;
 
             void Destroy(VkDevice device, VmaAllocator allocator);
         };
 
+        // Public so the renderer's blit/copy/readback bindings can source renderbuffer
+        // attachments the same way texture attachments go through the texture manager.
+        RenderbufferResource* GetOrCreateRenderbufferResource(
+            const SharedPtr<MG_State::GLState::RenderbufferObject>& renderbuffer);
+        Bool GetPendingRenderbufferClear(MG_State::GLState::RenderbufferObject* renderbuffer,
+                                         ClearAttachmentPayload& outPayload) const;
+
+    private:
         struct PendingRenderbufferClear {
             WeakPtr<MG_State::GLState::RenderbufferObject> renderbuffer;
             ClearAttachmentPayload payload{};
         };
 
+        // A superseded renderbuffer backing (glRenderbufferStorage respecify) parked
+        // until enough frame boundaries have passed that no in-flight command buffer
+        // can still reference it; destroyed in OnPresent (see RetireAgeFrames).
+        struct DeferredRenderbufferRelease {
+            VkImage image = VK_NULL_HANDLE;
+            VmaAllocation allocation = nullptr;
+            VkImageView view = VK_NULL_HANDLE;
+            Uint64 deferredAtFrame = 0;
+        };
+
         UnorderedMap<MG_State::GLState::RenderbufferObject*, RenderbufferResource> m_renderbufferResources;
         UnorderedMap<MG_State::GLState::RenderbufferObject*, PendingRenderbufferClear> m_pendingRenderbufferClears;
+        Vector<DeferredRenderbufferRelease> m_deferredRenderbufferReleases;
 
-        RenderbufferResource* GetOrCreateRenderbufferResource(
-            const SharedPtr<MG_State::GLState::RenderbufferObject>& renderbuffer);
-        Bool GetPendingRenderbufferClear(MG_State::GLState::RenderbufferObject* renderbuffer,
-                                         ClearAttachmentPayload& outPayload) const;
         Bool HasPendingRenderbufferClear(
             const MG_State::GLState::FramebufferAttachmentObject& attachment) const;
         void CollectRenderbufferGarbage();
+        // Frame-boundary margin after which a resource last referenced by a retired
+        // GL object (or superseded backing) is provably past every in-flight frame.
+        Uint64 RetireAgeFrames() const;
+        void DeferRenderbufferBackingRelease(RenderbufferResource& resource);
+        void CollectDeferredRenderbufferReleases(Bool destroyAll);
 
         static inline XXH64_state_t* m_hashState = XXH64_createState();
         static inline ActiveRenderPassInfo s_activeRenderPass{};

MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.cpp

@@ -51,6 +51,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Float ResolveEffectiveMinLod(const MG_State::GLState::SamplerObject& sampler, Float effectiveMaxLod) {
             return std::min(sampler.GetMinLod(), effectiveMaxLod);
         }
+
+        // A single-level view can only ever deliver the base level, but the LOD clamp must not be
+        // collapsed to exactly 0: both GL and Vulkan pick magFilter over minFilter from the
+        // *clamped* lambda, so maxLod = 0 would make every fragment magnify and quietly retire the
+        // min filter. 0.25 is the value VkSamplerCreateInfo's own note prescribes for emulating
+        // GL's non-mipmapped minification - large enough for lambda to stay positive, small enough
+        // that a NEAREST mip mode still rounds down to level 0. Clamped rather than assigned, so a
+        // texture whose GL_TEXTURE_MAX_LOD really is 0 keeps magnifying as GL says it must.
+        Float ResolveSingleLevelMaxLod(const MG_State::GLState::SamplerObject& sampler, Bool singleLevelView) {
+            const Float maxLod = ResolveEffectiveMaxLod(sampler);
+            return singleLevelView ? std::min(maxLod, 0.25f) : maxLod;
+        }
     } // namespace
 
     Bool VkSamplerManager::Initialize(const InitInfo& initInfo) {
@@ -89,15 +101,43 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         m_device = VK_NULL_HANDLE;
         m_config = nullptr;
+        m_frameBoundaryCounter = 0;
+    }
+
+    void VkSamplerManager::OnFrameBoundary() {
+        ++m_frameBoundaryCounter;
+
+        // Sweep occasionally; destroy samplers whose last use is far past every
+        // in-flight frame. Destroy and erase must stay atomic, or Shutdown would
+        // double-free the handle; an evicted key that recurs simply re-creates
+        // its sampler on the next miss.
+        constexpr Uint64 kSweepInterval = 256;
+        constexpr Uint64 kRetireAgeBoundaries = 1024;
+        if ((m_frameBoundaryCounter % kSweepInterval) != 0) {
+            return;
+        }
+
+        for (auto it = m_samplers.begin(); it != m_samplers.end();) {
+            auto& entry = it->second;
+            if (m_frameBoundaryCounter - entry.lastUsedFrameBoundary > kRetireAgeBoundaries) {
+                if (m_device != VK_NULL_HANDLE && entry.handle != VK_NULL_HANDLE) {
+                    vkDestroySampler(m_device, entry.handle, nullptr);
+                }
+                it = m_samplers.erase(it);
+            } else {
+                ++it;
+            }
+        }
     }
 
     Uint64 VkSamplerManager::BuildSamplerKey(const MG_State::GLState::SamplerObject& sampler,
                                              const MG_State::GLState::ITextureObject& texture,
-                                             Bool forceNearestFiltering) const {
+                                             Bool forceNearestFiltering, Bool singleLevelView) const {
         MOBILEGL_ASSERT(m_config != nullptr, "VkSamplerManager::BuildSamplerKey: m_config is null");
         XXHASH_VERIFY(XXH64_reset(m_hashState, m_config->CacheVersion));
 
         XXHASH_VERIFY(XXH64_update(m_hashState, &forceNearestFiltering, sizeof(forceNearestFiltering)));
+        XXHASH_VERIFY(XXH64_update(m_hashState, &singleLevelView, sizeof(singleLevelView)));
 
         const auto minFilter = sampler.GetMinFilter();
         XXHASH_VERIFY(XXH64_update(m_hashState, &minFilter, sizeof(minFilter)));
@@ -111,7 +151,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         XXHASH_VERIFY(XXH64_update(m_hashState, &wrapT, sizeof(wrapT)));
         const auto wrapR = sampler.GetWrapR();
         XXHASH_VERIFY(XXH64_update(m_hashState, &wrapR, sizeof(wrapR)));
-        const auto maxLod = ResolveEffectiveMaxLod(sampler);
+        const auto maxLod = ResolveSingleLevelMaxLod(sampler, singleLevelView);
         const auto minLod = ResolveEffectiveMinLod(sampler, maxLod);
         XXHASH_VERIFY(XXH64_update(m_hashState, &minLod, sizeof(minLod)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &maxLod, sizeof(maxLod)));
@@ -133,10 +173,20 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     VkSampler VkSamplerManager::GetOrCreateSampler(const MG_State::GLState::SamplerObject& sampler,
                                                    const MG_State::GLState::ITextureObject& texture,
-                                                   Bool forceNearestFiltering) {
-        const Uint64 key = BuildSamplerKey(sampler, texture, forceNearestFiltering);
+                                                   Bool forceNearestFiltering, Uint32 viewLevelCount) {
+        // A view that exposes a single mip level has no second level to blend with, so GL's
+        // *_MIPMAP_* minification filters degenerate to plain filtering on the base level -
+        // sampling is unchanged by pinning the Vulkan sampler to NEAREST mip mode at LOD 0.
+        // It is not cosmetic: MobileGL backs such a view with a fully allocated mip chain whose
+        // tail is never written, and a LINEAR mip mode lets the texture unit issue the level+1
+        // fetch anyway. On Adreno that fetch lands in uninitialized UBWC pages (or past the
+        // allocation for a genuinely single-level image) and faults the GPU - the same failure
+        // the default-framebuffer blit shader had to work around with an explicit-LOD sample.
+        const Bool singleLevelView = viewLevelCount == 1;
+        const Uint64 key = BuildSamplerKey(sampler, texture, forceNearestFiltering, singleLevelView);
         auto it = m_samplers.find(key);
         if (it != m_samplers.end()) {
+            it->second.lastUsedFrameBoundary = m_frameBoundaryCounter;
             return it->second.handle;
         }
 
@@ -144,8 +194,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
         samplerInfo.magFilter = forceNearestFiltering ? VK_FILTER_NEAREST : ToVkFilter(sampler.GetMagFilter());
         samplerInfo.minFilter = forceNearestFiltering ? VK_FILTER_NEAREST : ToVkFilter(sampler.GetMinFilter());
-        samplerInfo.mipmapMode = forceNearestFiltering ? VK_SAMPLER_MIPMAP_MODE_NEAREST
-                                                       : ToVkMipmapMode(sampler.GetMipmapMode());
+        samplerInfo.mipmapMode = (forceNearestFiltering || singleLevelView)
+                                     ? VK_SAMPLER_MIPMAP_MODE_NEAREST
+                                     : ToVkMipmapMode(sampler.GetMipmapMode());
         samplerInfo.addressModeU = ToVkAddressMode(sampler.GetWrapS());
         samplerInfo.addressModeV = ToVkAddressMode(sampler.GetWrapT());
         samplerInfo.addressModeW = ToVkAddressMode(sampler.GetWrapR());
@@ -157,7 +208,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         samplerInfo.maxAnisotropy = maxAnisotropy;
         samplerInfo.compareEnable = sampler.GetCompareMode() == SamplerCompareMode::CompareToTexture ? VK_TRUE : VK_FALSE;
         samplerInfo.compareOp = ToVkCompareOp(ResolveCompareFunc(sampler, texture));
-        samplerInfo.maxLod = ResolveEffectiveMaxLod(sampler);
+        // Must match BuildSamplerKey's resolution exactly.
+        samplerInfo.maxLod = ResolveSingleLevelMaxLod(sampler, singleLevelView);
         samplerInfo.minLod = ResolveEffectiveMinLod(sampler, samplerInfo.maxLod);
         samplerInfo.borderColor = ResolveVkBorderColor(sampler, texture);
         samplerInfo.unnormalizedCoordinates = VK_FALSE;
@@ -169,6 +221,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         entry.handle = vkSampler;
         entry.externalIndex = sampler.GetExternalIndex();
         entry.version = sampler.GetVersion();
+        entry.lastUsedFrameBoundary = m_frameBoundaryCounter;
         m_samplers[key] = entry;
         return vkSampler;
     }

MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.h

@@ -33,20 +33,38 @@ public:
     Bool Initialize(const InitInfo& initInfo);
     void Shutdown();
 
+    // viewLevelCount is the mip-level count of the image view this sampler will be paired
+    // with; 0 means "unknown, do not narrow". See GetOrCreateSampler for why it matters.
     VkSampler GetOrCreateSampler(const MG_State::GLState::SamplerObject& sampler,
                                  const MG_State::GLState::ITextureObject& texture,
-                                 Bool forceNearestFiltering = false);
+                                 Bool forceNearestFiltering = false,
+                                 Uint32 viewLevelCount = 0);
+    // Frame boundary hook: ages the sampler cache and destroys samplers not used
+    // for many frames. The key hashes continuous float state (lodBias, LOD clamps,
+    // anisotropy), so an app animating those would otherwise mint an unbounded
+    // stream of never-destroyed VkSamplers and eventually exhaust the device's
+    // maxSamplerAllocationCount. A sampler idle for over a thousand frame
+    // boundaries cannot be referenced by any in-flight command buffer (frames in
+    // flight are single digits), and every descriptor set the GPU consumes is
+    // written that same frame with live handles (the per-binding resolve memo and
+    // descriptor-set reuse are both frame-reset), so destruction here needs no
+    // fence wait. Self-gated: one counter bump and compare except on sweep
+    // boundaries.
+    void OnFrameBoundary();
 
 private:
     struct SamplerCacheEntry {
         VkSampler handle = VK_NULL_HANDLE;
         Uint externalIndex = 0;
         Uint16 version = 0;
+        // Frame boundary of the last cache hit; entries idle past the
+        // OnFrameBoundary retirement age have their VkSampler destroyed.
+        Uint64 lastUsedFrameBoundary = 0;
     };
 
     Uint64 BuildSamplerKey(const MG_State::GLState::SamplerObject& sampler,
                            const MG_State::GLState::ITextureObject& texture,
-                           Bool forceNearestFiltering) const;
+                           Bool forceNearestFiltering, Bool singleLevelView) const;
     static VkFilter ToVkFilter(SamplerFilterMode mode);
     static VkSamplerMipmapMode ToVkMipmapMode(SamplerMipmapMode mode);
     static VkSamplerAddressMode ToVkAddressMode(SamplerWrapMode mode);
@@ -67,6 +85,8 @@ private:
     Bool m_samplerAnisotropySupported = false;
     Float m_maxSamplerAnisotropy = 1.0f;
     UnorderedMap<Uint64, SamplerCacheEntry> m_samplers;
+    // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
+    Uint64 m_frameBoundaryCounter = 0;
     static inline XXH64_state_t* m_hashState = XXH64_createState();
 };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.cpp

@@ -375,7 +375,23 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         switch (format) {
         case TextureInternalFormat::RGB:
         case TextureInternalFormat::RGB8:
+        // Legacy low-bit RGB formats share the UNorm8 canonical shadow layout (see
+        // TextureFormatProcessor), so they upload exactly like RGB8 with an alpha expand.
+        case TextureInternalFormat::R3G3B2:
+        case TextureInternalFormat::RGB4:
+        case TextureInternalFormat::RGB5:
             return {VK_FORMAT_R8G8B8A8_UNORM, true, 1, {0xFF, 0x00, 0x00, 0x00}};
+        // Low-bit RGBA formats: UNorm8x4 canonical shadow, no expansion needed.
+        case TextureInternalFormat::RGBA2:
+        case TextureInternalFormat::RGBA4:
+        case TextureInternalFormat::RGB5A1:
+            return {VK_FORMAT_R8G8B8A8_UNORM, false, 0, {0, 0, 0, 0}};
+        // 10/12-bit RGB(A): UNorm16 canonical shadow.
+        case TextureInternalFormat::RGB10:
+        case TextureInternalFormat::RGB12:
+            return {VK_FORMAT_R16G16B16A16_UNORM, true, 2, {0xFF, 0xFF, 0x00, 0x00}};
+        case TextureInternalFormat::RGBA12:
+            return {VK_FORMAT_R16G16B16A16_UNORM, false, 0, {0, 0, 0, 0}};
         case TextureInternalFormat::SRGB8:
             return {VK_FORMAT_R8G8B8A8_SRGB, true, 1, {0xFF, 0x00, 0x00, 0x00}};
         case TextureInternalFormat::RGB8Snorm:
@@ -571,6 +587,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_allocator = initInfo.allocator;
         m_commandPool = initInfo.commandPool;
         m_graphicsQueue = initInfo.graphicsQueue;
+        m_imageFormatListSupported = initInfo.imageFormatListSupported;
         m_currentFrameIndex = 0;
         m_deferredReleases.clear();
         m_deferredReleases.resize(initInfo.frameCount);
@@ -593,6 +610,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         DestroyDeferredReleases();
         m_textureResources.clear();
         m_aliveObjects.clear();
+        m_storageImageTextures.clear();
 
         m_device = VK_NULL_HANDLE;
         m_physicalDevice = VK_NULL_HANDLE;
@@ -611,6 +629,26 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         frameIndex, m_deferredViewReleases.size());
         m_currentFrameIndex = frameIndex;
         CollectDeferredReleases(frameIndex);
+
+        // Frame-boundary GC: every 64 frame boundaries (~1 s at 60 fps) bounds the reclaim
+        // latency for dead textures regardless of draw traffic — workloads that churn
+        // textures through clears/readbacks alone never reach the draw-gated
+        // CollectGarbage. Must run after CollectDeferredReleases above: the prune defers
+        // its releases into this frame's slot, which was just drained, so they are
+        // destroyed only after the slot's fence has been waited again one full frame-ring
+        // cycle from now (never while an in-flight frame may still reference them).
+        constexpr Uint32 kGcFrameInterval = 64;
+        ++m_gcFrameCounter;
+        if (m_gcFrameCounter % kGcFrameInterval == 0) {
+            PruneDeadTextures();
+        }
+    }
+
+    void VkTextureManager::CollectAllDeferredReleases() {
+        const SizeT frameCount = std::min(m_deferredReleases.size(), m_deferredViewReleases.size());
+        for (SizeT frameIndex = 0; frameIndex < frameCount; ++frameIndex) {
+            CollectDeferredReleases(static_cast<Uint32>(frameIndex));
+        }
     }
 
     void VkTextureManager::EraseTrackedTexture(const TextureIdentity& identity) {
@@ -620,6 +658,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_textureResources.erase(resourceIt);
         }
         m_aliveObjects.erase(identity);
+        m_storageImageTextures.erase(identity);
     }
 
     void VkTextureManager::PruneStaleTextureAliases(MG_State::GLState::ITextureObject* texture) {
@@ -686,9 +725,22 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // construction introduces a new identity. Doing this unconditionally made every
         // sampled-texture sync scan the entire alive-texture map per draw.
         if (aliveIt == m_aliveObjects.end()) {
+            WeakPtr<MG_State::GLState::ITextureObject> aliveTexture;
             const auto& liveTexture = MG_State::pGLContext->GetTextureObject(texture.GetExternalIndex());
             if (liveTexture && liveTexture.get() == &texture) {
-                m_aliveObjects[identity] = WeakPtr<MG_State::GLState::ITextureObject>(liveTexture);
+                aliveTexture = liveTexture;
+            } else {
+                // The name lookup legally fails while the object is alive: the name was
+                // deleted with the texture still attached to an FBO (the attachment's
+                // SharedPtr keeps it alive), or the name was reused by a new texture, or
+                // this is a default texture object (name 0 lives outside the name map).
+                // Register through the object's own control block so the resource created
+                // below still participates in weak-expiry GC instead of becoming an
+                // orphan no reclamation path can reach until Shutdown.
+                aliveTexture = texture.weak_from_this();
+            }
+            if (!aliveTexture.expired()) {
+                m_aliveObjects[identity] = Move(aliveTexture);
                 PruneStaleTextureAliases(&texture);
             }
         }
@@ -1140,8 +1192,25 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return ok;
     }
 
+    void VkTextureManager::MarkStorageImageTexture(MG_State::GLState::ITextureObject& texture) {
+        m_storageImageTextures.insert(MakeTextureIdentity(&texture));
+    }
+
+    Bool VkTextureManager::NeedsStorageUsageUpgrade(MG_State::GLState::ITextureObject& texture) const {
+        const TextureIdentity identity = MakeTextureIdentity(&texture);
+        if (m_storageImageTextures.find(identity) == m_storageImageTextures.end()) {
+            return false;
+        }
+        const auto it = m_textureResources.find(identity);
+        // No image yet: the first sync creates it with STORAGE straight away, so there is nothing
+        // to preserve and nothing to order against.
+        return it != m_textureResources.end() && it->second.image != VK_NULL_HANDLE &&
+               !it->second.storageUsageResolved;
+    }
+
     Bool VkTextureManager::NeedsStorageImagePreparation(MG_State::GLState::ITextureObject& texture) const {
-        const auto it = m_textureResources.find(MakeTextureIdentity(&texture));
+        const TextureIdentity identity = MakeTextureIdentity(&texture);
+        const auto it = m_textureResources.find(identity);
         if (it == m_textureResources.end()) {
             return true;
         }
@@ -1149,6 +1218,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (resource.image == VK_NULL_HANDLE || resource.layout != VK_IMAGE_LAYOUT_GENERAL) {
             return true;
         }
+        // The image predates this texture's first image-unit binding, so it was created without
+        // STORAGE usage and has to be recreated - which is illegal inside a render pass.
+        if (!resource.storageUsageResolved &&
+            m_storageImageTextures.find(identity) != m_storageImageTextures.end()) {
+            return true;
+        }
         // Mirror SyncTexture's cross-draw skip condition: any version drift means the sync
         // path may upload or rebuild, both of which need the render pass ended first.
         const auto* mipTexture = MG_State::GLState::AsMipmapTexture(&texture);
@@ -1196,10 +1271,22 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     SizeT VkTextureManager::CollectGarbage() {
+        // Draw-gated stagger (1 in 256 calls): keeps the per-draw cost at one counter
+        // bump. The guaranteed reclaim path is the frame-boundary prune in BeginFrame;
+        // this remains as a cheap assist so draw-heavy workloads reclaim sooner.
         m_gcCounter++;
         if (m_gcCounter != 0) {
             return 0;
         }
+        return PruneDeadTextures();
+    }
+
+    SizeT VkTextureManager::PruneDeadTextures() {
+        // Erasing entries would dangle the raw TextureResource pointers memoized for the
+        // current draw; every call path (BeginFrame, and CollectGarbage at the top of a
+        // freshly opened draw-sync scope) runs before any memo entry is recorded.
+        MOBILEGL_ASSERT(m_drawSyncedThisDraw.empty(),
+                        "PruneDeadTextures: draw-sync memo holds raw resource pointers an erase would dangle");
 
         Vector<MG_State::GLState::ITextureObject*> expiredTextures;
         expiredTextures.reserve(m_aliveObjects.size());
@@ -1211,7 +1298,25 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         for (auto* texture : expiredTextures) {
             PruneStaleTextureAliases(texture);
         }
-        return expiredTextures.size();
+        SizeT prunedCount = expiredTextures.size();
+
+        // Orphan sweep: after the pass above, m_aliveObjects holds only live entries.
+        // Registration in SyncTextureAndGetDescriptor cannot fail for a SharedPtr-owned
+        // texture (weak_from_this fallback), so a resource whose identity has no alive
+        // entry has no trackable owner: its GL-side object is gone, or was never
+        // shared-owned, in which case recreation on a later sync is the safe fallback.
+        // Destruction goes through the per-frame deferred queues, never immediate.
+        Vector<TextureIdentity> orphanIdentities;
+        for (auto it = m_textureResources.begin(); it != m_textureResources.end(); ++it) {
+            if (m_aliveObjects.find(it->first) == m_aliveObjects.end()) {
+                orphanIdentities.emplace_back(it->first);
+            }
+        }
+        for (const auto& identity : orphanIdentities) {
+            EraseTrackedTexture(identity);
+        }
+        prunedCount += orphanIdentities.size();
+        return prunedCount;
     }
 
     Bool VkTextureManager::SyncTexture(MG_State::GLState::ITextureObject &texture,
@@ -1225,7 +1330,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const auto* syncingMipTexture = MG_State::GLState::AsMipmapTexture(&texture);
         const Uint32 syncingMipLevelCount =
             syncingMipTexture != nullptr ? syncingMipTexture->GetMipmapLevelCount() : 0u;
-        if (outResource.image != VK_NULL_HANDLE &&
+        // A pending storage-usage upgrade also has to bust the skip: nothing about the texture's
+        // content or params changed, but the image itself must be recreated with STORAGE usage
+        // before it can back an image-unit descriptor.
+        const Bool storageUpgradePending =
+            !outResource.storageUsageResolved &&
+            m_storageImageTextures.find(MakeTextureIdentity(&texture)) != m_storageImageTextures.end();
+        if (outResource.image != VK_NULL_HANDLE && !storageUpgradePending &&
             outResource.syncedContentVersion == syncingContentVersion &&
             outResource.syncedTextureParamsVersion == texture.GetTextureParamsVersion() &&
             outResource.syncedMipLevelCount == syncingMipLevelCount) {
@@ -1336,16 +1447,44 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const VkImageAspectFlags aspect = GetAspectMaskForFormat(format);
         VkFormatProperties formatProperties{};
         vkGetPhysicalDeviceFormatProperties(m_physicalDevice, format, &formatProperties);
-        const Bool supportsStorageImage =
+        // Only textures that have actually been bound to a GL image unit get STORAGE usage (and
+        // the MUTABLE_FORMAT it drags in for format-reinterpreting image views). Requesting it
+        // for every storage-capable colour texture costs real bandwidth: Adreno cannot keep UBWC
+        // compression on an image that may be written through a storage descriptor, so the whole
+        // render target - MC's included - runs uncompressed. MarkStorageImageTexture upgrades a
+        // texture before its first image-unit draw, and the usage below feeds the compatibility
+        // check so the upgrade recreates the image.
+        const Bool markedAsStorageImage =
+            m_storageImageTextures.find(MakeTextureIdentity(
+                const_cast<MG_State::GLState::ITextureObject*>(&texture))) != m_storageImageTextures.end();
+        // Storage-image CAPABILITY (does the format allow it at all) is deliberately separate from
+        // whether this texture actually needs the usage. MUTABLE_FORMAT keys off capability, as
+        // before: format-reinterpreting views are not a storage-only concern - the SAMPLED path
+        // needs them too (GetOrCreateSampledImageView bails out without it, see ~line 892), so
+        // tying MUTABLE_FORMAT to the image-unit mark would break sampled format reinterpretation
+        // for every texture that never becomes a storage image.
+        const Bool storageImageCapable =
             !isMultisampleTexture &&
             (aspect & VK_IMAGE_ASPECT_COLOR_BIT) != 0 &&
             (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) != 0;
+        const Bool supportsStorageImage = storageImageCapable && markedAsStorageImage;
         VkImageCreateFlags imageCreateFlags = shapeInfo.imageFlags;
-        if (supportsStorageImage && IsMutableStorageImageFormat(format) &&
+        if (storageImageCapable && IsMutableStorageImageFormat(format) &&
             m_mutableFormatUnsupported.find(format) == m_mutableFormatUnsupported.end()) {
             imageCreateFlags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
         }
 
+        VkImageUsageFlags desiredUsage =
+            VK_IMAGE_USAGE_SAMPLED_BIT |
+            (supportsStorageImage ? VK_IMAGE_USAGE_STORAGE_BIT : 0) |
+            ((aspect & VK_IMAGE_ASPECT_COLOR_BIT) ? VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT : 0) |
+            (((aspect & VK_IMAGE_ASPECT_DEPTH_BIT) || (aspect & VK_IMAGE_ASPECT_STENCIL_BIT)) ?
+                 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT :
+                 0);
+        if (!isMultisampleTexture) {
+            desiredUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+        }
+
         const Bool compatible = resource.image != VK_NULL_HANDLE && resource.format == format &&
                                 resource.extent.width == static_cast<Uint32>(texelSize.x()) &&
                                 resource.extent.height == static_cast<Uint32>(texelSize.y()) &&
@@ -1354,6 +1493,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                 resource.viewType == shapeInfo.viewType &&
                                 resource.sampleCount == resolvedSampleCount &&
                                 resource.imageCreateFlags == imageCreateFlags &&
+                                resource.usageFlags == desiredUsage &&
                                 resource.mipLevels == backingMipLevels;
         if (compatible) {
             if (resource.perMipViews.size() != backingMipLevels) {
@@ -1362,6 +1502,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             if (resource.perMipSampledViews.size() != backingMipLevels) {
                 resource.perMipSampledViews.resize(backingMipLevels, VK_NULL_HANDLE);
             }
+            // Keeping the image is itself the answer to the mark: either it already carries
+            // STORAGE, or this format can never carry it. Either way there is nothing left to
+            // recreate, so stop reporting the texture as needing preparation.
+            resource.storageUsageResolved = markedAsStorageImage;
             return true;
         }
 
@@ -1376,7 +1520,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             resource.sampleCount == resolvedSampleCount &&
             resource.imageCreateFlags == imageCreateFlags &&
             resolvedSampleCount == VK_SAMPLE_COUNT_1_BIT &&
-            resource.mipLevels < backingMipLevels &&
+            // '<=' rather than '<': a storage-usage upgrade recreates the image with an
+            // unchanged mip count, and its contents (a render target's pixels live only on the
+            // GPU) still have to survive. The vkCmdCopyImage below copies min(mipLevels).
+            resource.mipLevels <= backingMipLevels &&
             resource.layout != VK_IMAGE_LAYOUT_UNDEFINED;
 
         std::unique_ptr<TextureResource> preservedResource;
@@ -1398,16 +1545,37 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         imageInfo.format = format;
         imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
         imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-        imageInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT |
-                          (supportsStorageImage ? VK_IMAGE_USAGE_STORAGE_BIT : 0) |
-                          ((aspect & VK_IMAGE_ASPECT_COLOR_BIT) ? VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT : 0) |
-                          (((aspect & VK_IMAGE_ASPECT_DEPTH_BIT) || (aspect & VK_IMAGE_ASPECT_STENCIL_BIT)) ?
-                               VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT :
-                               0);
-        if (!isMultisampleTexture) {
-            imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-        }
+        imageInfo.usage = desiredUsage;
         imageInfo.samples = resolvedSampleCount;
+
+        // Bound the mutability. A blindly-mutable image has to be laid out so that ANY format in
+        // its compatibility class can be viewed, which costs bandwidth compression on tilers;
+        // naming the exact set instead lets the driver keep it. Only safe when that set really is
+        // exhaustive, so it is restricted to textures that are not image-unit bound: sampled views
+        // can only ever ask for ResolveSampledImageViewFormat's output, whereas glBindImageTexture
+        // may name any compatible format, which nothing here can enumerate ahead of time.
+        Vector<VkFormat> viewFormats;
+        VkImageFormatListCreateInfo formatListInfo{};
+        if (m_imageFormatListSupported && !supportsStorageImage &&
+            (imageInfo.flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) != 0) {
+            viewFormats.push_back(format);
+            for (const SamplerNumericDomain domain : {SamplerNumericDomain::Float,
+                                                      SamplerNumericDomain::SignedInteger,
+                                                      SamplerNumericDomain::UnsignedInteger}) {
+                const VkFormat viewFormat = ResolveSampledImageViewFormat(format, domain);
+                if (viewFormat == VK_FORMAT_UNDEFINED) {
+                    continue;
+                }
+                if (std::find(viewFormats.begin(), viewFormats.end(), viewFormat) == viewFormats.end()) {
+                    viewFormats.push_back(viewFormat);
+                }
+            }
+            formatListInfo.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
+            formatListInfo.viewFormatCount = static_cast<Uint32>(viewFormats.size());
+            formatListInfo.pViewFormats = viewFormats.data();
+            imageInfo.pNext = &formatListInfo;
+        }
+
         if (isMultisampleTexture || (imageInfo.flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) != 0) {
             VkImageFormatProperties imageFormatProperties{};
             VkResult imageFormatResult = vkGetPhysicalDeviceImageFormatProperties(
@@ -1464,6 +1632,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         resource.viewType = shapeInfo.viewType;
         resource.sampleCount = resolvedSampleCount;
         resource.imageCreateFlags = imageCreateFlags;
+        resource.usageFlags = imageInfo.usage;
+        resource.storageUsageResolved = markedAsStorageImage;
         resource.syncedTextureParamsVersion = 0;
 
         if (preservedResource) {

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.h

@@ -53,6 +53,9 @@ public:
         VkCommandPool commandPool = VK_NULL_HANDLE;
         VkQueue graphicsQueue = VK_NULL_HANDLE;
         Uint32 frameCount = 0;
+        // VK_KHR_image_format_list is enabled: MUTABLE_FORMAT images can name the exact set of
+        // formats they will be viewed as, which is what lets a tiler keep them compressed.
+        Bool imageFormatListSupported = false;
     };
 
     struct TextureResource {
@@ -157,6 +160,17 @@ public:
         VkImageViewType viewType = VK_IMAGE_VIEW_TYPE_2D;
         VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT;
         VkImageCreateFlags imageCreateFlags = 0;
+        // Usage the live image was created with. STORAGE is only requested for textures that
+        // have actually been bound to a GL image unit, because on Adreno a storage-capable
+        // image loses UBWC bandwidth compression; a later image binding upgrades the usage
+        // and recreates the image, so the resolved usage has to be part of the compatibility
+        // check that decides whether the existing image can be kept.
+        VkImageUsageFlags usageFlags = 0;
+        // True once this image was (re)resolved while the texture was already marked as an
+        // image-unit texture. Distinguishes "not upgraded yet" from "cannot be upgraded"
+        // (a format whose optimalTilingFeatures lack STORAGE_IMAGE never gains the bit), so
+        // NeedsStorageImagePreparation cannot ask for a recreate that will never happen.
+        Bool storageUsageResolved = false;
         Uint16 syncedTextureParamsVersion = 0;
         // Snapshot of ITextureObject::GetContentVersion() at the last successful sync;
         // lets SyncTexture skip the whole re-check/re-upload when content is unchanged.
@@ -190,6 +204,8 @@ public:
             std::swap(this->viewType, that.viewType);
             std::swap(this->sampleCount, that.sampleCount);
             std::swap(this->imageCreateFlags, that.imageCreateFlags);
+            std::swap(this->usageFlags, that.usageFlags);
+            std::swap(this->storageUsageResolved, that.storageUsageResolved);
             std::swap(this->syncedTextureParamsVersion, that.syncedTextureParamsVersion);
             std::swap(this->syncedContentVersion, that.syncedContentVersion);
             std::swap(this->syncedMipLevelCount, that.syncedMipLevelCount);
@@ -251,6 +267,8 @@ public:
             viewType = VK_IMAGE_VIEW_TYPE_2D;
             sampleCount = VK_SAMPLE_COUNT_1_BIT;
             imageCreateFlags = 0;
+            usageFlags = 0;
+            storageUsageResolved = false;
             syncedTextureParamsVersion = 0;
             syncedContentVersion = 0;
             syncedMipLevelCount = 0;
@@ -267,6 +285,10 @@ public:
     Bool Initialize(const InitInfo& initInfo);
     void Shutdown();
     void BeginFrame(Uint32 frameIndex);
+    // Drains every frame slot's deferred image/view releases. Only valid when
+    // the caller has proven every queue submission complete; used by the
+    // present-less frame-boundary drain.
+    void CollectAllDeferredReleases();
 
     TextureResource* SyncTextureAndGetDescriptor(
         MG_State::GLState::ITextureObject& texture);
@@ -285,6 +307,17 @@ public:
                                                       VkImageLayout newLayout);
     Bool TransitionTextureForSampling(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
     Bool TransitionTextureForStorageImage(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
+    // Records that this texture is bound to a GL image unit, so its image must carry
+    // VK_IMAGE_USAGE_STORAGE_BIT. Must be called before NeedsStorageImagePreparation, and
+    // therefore before the render pass is committed: an image that has to be upgraded is
+    // recreated, which is illegal inside a render pass. Sticky for the texture's lifetime -
+    // GL lets an image binding come and go, and re-creating the image every time it does
+    // would cost far more than the compression it wins back.
+    void MarkStorageImageTexture(MG_State::GLState::ITextureObject& texture);
+    // True when this texture is marked but its live image predates the mark, i.e. the next sync
+    // 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;
     // 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
@@ -364,15 +397,20 @@ private:
     static TextureIdentity MakeTextureIdentity(MG_State::GLState::ITextureObject* texture);
     void EraseTrackedTexture(const TextureIdentity& identity);
     void PruneStaleTextureAliases(MG_State::GLState::ITextureObject* texture);
+    SizeT PruneDeadTextures();
 
     VkDevice m_device = VK_NULL_HANDLE;
     VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
     VmaAllocator m_allocator = nullptr;
     VkCommandPool m_commandPool = VK_NULL_HANDLE;
     VkQueue m_graphicsQueue = VK_NULL_HANDLE;
+    Bool m_imageFormatListSupported = false;
     Uint32 m_currentFrameIndex = 0;
 
     Uint8 m_gcCounter = 0;
+    // Frame-boundary GC gate: counts BeginFrame calls, not draws, so texture churn
+    // through non-draw paths (FBO clears, readbacks) still reaches the prune.
+    Uint32 m_gcFrameCounter = 0;
     // Active only between BeginDrawSyncScope/EndDrawSyncScope; identities of
     // textures already fully synced in the current draw (small N -> flat scan).
     Bool m_drawSyncScopeActive = false;
@@ -390,6 +428,8 @@ private:
     std::unordered_set<VkFormat> m_mutableFormatUnsupported;
     std::unordered_map<TextureIdentity, WeakPtr<MG_State::GLState::ITextureObject>, TextureIdentityHash> m_aliveObjects;
     std::unordered_map<TextureIdentity, TextureResource, TextureIdentityHash> m_textureResources;
+    // Textures that have been bound to a GL image unit (see MarkStorageImageTexture).
+    std::unordered_set<TextureIdentity, TextureIdentityHash> m_storageImageTextures;
     Vector<Vector<TextureResource>> m_deferredReleases;
     Vector<Vector<VkImageView>> m_deferredViewReleases;
 };

MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.h

@@ -114,7 +114,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
     };
 
-    class VulkanRenderer : public IBufferCopyCommandProvider, public FrameContext::IRecordingObserver {
+    class VulkanRenderer : public IBufferCopyCommandProvider,
+                           public FrameContext::IRecordingObserver,
+                           public VkRenderPassManager::IEvictionObserver,
+                           public ProgramFactory::IEvictionObserver {
     public:
         VulkanRenderer(NativeWindowType window, const VulkanRendererConfig& cfg = {});
         ~VulkanRenderer();
@@ -131,6 +134,20 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // recording, before any render pass.
         void OnFrameCommandRecordingBegan(VkCommandBuffer commandBuffer) override;
 
+        // VkRenderPassManager::IEvictionObserver: the render-pass aging sweep just
+        // destroyed these VkRenderPasses; evict every graphics pipeline hashed on a
+        // dying handle (they share its >1024-boundary idleness, so immediate
+        // destruction is safe) and drop the last-pipeline memo if any went.
+        void OnRenderPassesDestroyed(const Vector<VkRenderPass>& renderPasses) override;
+
+        // ProgramFactory::IEvictionObserver: an aged-out program entry was
+        // destroyed; evict its compute pipeline and graphics pipelines (same
+        // idleness guarantee - they are only bound through draws/dispatches that
+        // stamp the program entry) and purge the descriptor-set cache entries
+        // keyed by its now-recyclable VkDescriptorSetLayout handle.
+        void OnProgramEvicted(ProgramFactory::HashType programHash,
+                              VkDescriptorSetLayout descriptorSetLayout) override;
+
         Bool SetupDraw(FrameContext::FrameData& frame, GLenum mode, Flags<DrawSetupAspect> aspects,
                        const DrawCmdParam& drawParams,
                        const IndexBufferView* pIndexBufferView = nullptr);
@@ -257,6 +274,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint64 GetTimerQueryTimestampNs(const VkTimerQueryManager::TimestampRecord& record) const;
 
         void RequestSwapchainResize(Uint32 width, Uint32 height);
+        // Re-query the surface and report whether the live swapchain no longer matches it
+        // (size or orientation). This - not a VK_SUBOPTIMAL_KHR result - is what decides a
+        // rebuild, so a surface the driver merely considers suboptimal cannot thrash.
+        Bool SwapchainIsOutOfDate();
         // Returns false when the surface is zero-area (minimized/hidden window):
         // no new swapchain is installed and presentation must stay suspended.
         Bool RecreateSwapchain();
@@ -345,11 +366,26 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkFence AcquirePooledSubmitFence();
         void DestroySubmitFencePool();
         Bool HasPendingRecordedWork() const;
+        // Frame-boundary housekeeping for paths that never reach Present's
+        // tail (present-less readback loops, suspended presentation, blocking
+        // sync waits): runs the same per-frame drains Present performs, but
+        // only when every queue submission has been observed complete AND no
+        // recorded-but-unsubmitted commands exist - i.e. when CPU-GPU overlap
+        // is provably already zero. Never blocks (non-blocking fence poll
+        // only), so the presenting path's frames-in-flight pipelining is
+        // untouched. Returns true when the drain ran.
+        Bool TryDrainFrameTransients();
 
         Vector<SubmitRecord> m_inFlightSubmits;
         Vector<VkFence> m_freeSubmitFences;
         Uint64 m_submitCounter = 0;
         Uint64 m_completedSubmitCounter = 0;
+        // Drains since the last Present, gating the drain's frame-boundary-equivalent
+        // work (arena rewind + cache aging): a presenting app's mid-frame
+        // readbacks/waits must neither churn the transient caches nor accelerate the
+        // aging clocks, while present-less loops still cross a boundary every few
+        // iterations. Reset in Present.
+        Uint32 m_drainsSinceLastPresent = 0;
 
         NativeWindowType m_window = 0;
         void* m_platformDisplay = nullptr;
@@ -367,6 +403,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Vector<VkExtensionProperties> m_extensions;
         VkInstance m_instance = VK_NULL_HANDLE;
         VkDebugUtilsMessengerEXT m_debugMessenger = VK_NULL_HANDLE;
+        // Fallback reporting channel for drivers that ship the validation layers but
+        // only expose the older VK_EXT_debug_report (Adreno 650 / Vulkan 1.1.128).
+        VkDebugReportCallbackEXT m_debugReportCallback = VK_NULL_HANDLE;
         PhysicalDevice m_physicalDevice;
         VkDevice m_device = VK_NULL_HANDLE;
         VmaAllocator m_allocator = nullptr;
@@ -517,6 +556,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void CreateInstance();
         VkResult SetupDebugMessenger();
         VkResult DestroyDebugMessenger();
+        VkResult SetupDebugReportCallback();
+        void DestroyDebugReportCallback();
         VkDebugUtilsMessengerCreateInfoEXT PopulateDebugMessengerCreateInfo();
         void CreateSurface();
         void PickPhysicalDevice();
@@ -535,8 +576,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             const RenderPassEntry& renderPassEntry);
         VkPipeline GetOrCreateComputePipeline(const ProgramFactory::VkProgramObject& programObj);
         void DestroyComputePipelines();
+        // Takes the frame rather than a command buffer: a first-time storage-usage upgrade has to
+        // flush the pending recording (see the body), which retires the current command buffer.
         Bool PrepareStorageImageTextures(
-            VkCommandBuffer commandBuffer,
+            FrameContext::FrameData& frame,
             const MG_State::GLState::ProgramObject& program,
             const ProgramFactory::VkProgramObject& programObj);
 
@@ -561,6 +604,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                    GLenum filter);
         Bool MaterializePendingClearForTexture(VkCommandBuffer commandBuffer,
                                                MG_State::GLState::ITextureObject& texture);
+        Bool MaterializePendingClearForRenderbuffer(
+            VkCommandBuffer commandBuffer,
+            const SharedPtr<MG_State::GLState::RenderbufferObject>& renderbuffer);
         VkPipeline GetOrCreateBlitPipeline(const RenderPassEntry& renderPassEntry);
         Bool GenerateDepthMipmapWithShader(FrameContext::FrameData& frame,
                                            MG_State::GLState::ITextureObject& texture,
@@ -595,6 +641,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                  const PhysicalDevice& compareWithDevice,
                                                  PhysicalDevice& outBetterDevice);
         static constexpr const char* s_validationLayerNames[] = {"VK_LAYER_KHRONOS_validation"};
+        // VK_KHR_image_format_list: lets MUTABLE_FORMAT images declare their exact view-format
+        // set so the driver can keep bandwidth compression (see CreateLogicalDeviceAndQueues).
+        Bool m_imageFormatListExtensionEnabled = false;
+
         static constexpr const char* s_deviceExtensionNames[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
         static Bool CheckValidationLayerSupport();
 

MobileGL/MG_Impl/CGLImpl/CGLImpl.cpp

@@ -24,6 +24,7 @@ namespace MobileGL::MG_Impl::CGLImpl {
             GLint Samples = 0;
             GLint Profile = kCGLOGLPVersion_3_2_Core;
             GLint RendererId = 0x4d474c;
+            GLint DisplayMask = 0;
         };
 
         struct ContextObject {
@@ -134,6 +135,9 @@ namespace MobileGL::MG_Impl::CGLImpl {
             case kCGLPFARendererID:
                 pixelFormat.RendererId = value;
                 break;
+            case kCGLPFADisplayMask:
+                pixelFormat.DisplayMask = value;
+                break;
             default:
                 break;
             }
@@ -343,6 +347,9 @@ namespace MobileGL::MG_Impl::CGLImpl {
         case kCGLPFARendererID:
             *value = pixelFormat->RendererId;
             return kCGLNoError;
+        case kCGLPFADisplayMask:
+            *value = pixelFormat->DisplayMask;
+            return kCGLNoError;
         case kCGLPFAOpenGLProfile:
             *value = pixelFormat->Profile;
             return kCGLNoError;
@@ -481,6 +488,32 @@ namespace MobileGL::MG_Impl::CGLImpl {
         return it == currentContexts.end() ? nullptr : it->second;
     }
 
+    CGLError SetVirtualScreen(CGLContextObj ctx, GLint screen) {
+        const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
+        auto* object = TryGetContext(ctx);
+        if (!object) {
+            return kCGLBadContext;
+        }
+        if (screen != 0) {
+            return kCGLBadValue;
+        }
+        object->VirtualScreen = screen;
+        return kCGLNoError;
+    }
+
+    CGLError GetVirtualScreen(CGLContextObj ctx, GLint* screen) {
+        const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
+        auto* object = TryGetContext(ctx);
+        if (!object) {
+            return kCGLBadContext;
+        }
+        if (!screen) {
+            return kCGLBadAddress;
+        }
+        *screen = object->VirtualScreen;
+        return kCGLNoError;
+    }
+
     CGLError SetParameter(CGLContextObj ctx, CGLContextParameter pname, const GLint* params) {
         const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
         auto* object = TryGetContext(ctx);

MobileGL/MG_Impl/CGLImpl/CGLImpl.h

@@ -32,6 +32,8 @@ namespace MobileGL::MG_Impl::CGLImpl {
 
     CGLError SetCurrentContext(CGLContextObj ctx);
     CGLContextObj GetCurrentContext();
+    CGLError SetVirtualScreen(CGLContextObj ctx, GLint screen);
+    CGLError GetVirtualScreen(CGLContextObj ctx, GLint* screen);
     CGLError SetParameter(CGLContextObj ctx, CGLContextParameter pname, const GLint* params);
     CGLError GetParameter(CGLContextObj ctx, CGLContextParameter pname, GLint* params);
     CGLError UpdateContext(CGLContextObj ctx);

MobileGL/MG_Impl/CGLImpl/Exporting/Definitions.cpp

@@ -71,6 +71,14 @@ MOBILEGL_CGL_API CGLContextObj CGLGetCurrentContext(void) {
     return MobileGL::MG_Impl::CGLImpl::GetCurrentContext();
 }
 
+MOBILEGL_CGL_API CGLError CGLSetVirtualScreen(CGLContextObj ctx, GLint screen) {
+    return MobileGL::MG_Impl::CGLImpl::SetVirtualScreen(ctx, screen);
+}
+
+MOBILEGL_CGL_API CGLError CGLGetVirtualScreen(CGLContextObj ctx, GLint* screen) {
+    return MobileGL::MG_Impl::CGLImpl::GetVirtualScreen(ctx, screen);
+}
+
 MOBILEGL_CGL_API CGLError CGLSetParameter(CGLContextObj ctx, CGLContextParameter pname, const GLint* params) {
     return MobileGL::MG_Impl::CGLImpl::SetParameter(ctx, pname, params);
 }

MobileGL/MG_Impl/DyldInterpose/DyldInterpose.cpp

@@ -10,8 +10,12 @@
 
 #if defined(__APPLE__)
 
+#include "MG_Impl/CGLImpl/CGLImpl.h"
 #include "MG_Impl/GetProcAddress.h"
 
+#include <CoreGraphics/CoreGraphics.h>
+#include <CoreVideo/CVDisplayLink.h>
+#include <cstdint>
 #include <dlfcn.h>
 
 namespace {
@@ -47,10 +51,52 @@ namespace {
         return dlsym(handle, symbol);
     }
 
+    CGDirectDisplayID DisplayForMask(GLint displayMask) {
+        constexpr std::uint32_t MaxDisplays = sizeof(CGOpenGLDisplayMask) * 8;
+        CGDirectDisplayID displays[MaxDisplays] = {};
+        std::uint32_t displayCount = 0;
+        if (displayMask != 0 &&
+            CGGetActiveDisplayList(MaxDisplays, displays, &displayCount) == kCGErrorSuccess) {
+            const auto mask = static_cast<CGOpenGLDisplayMask>(displayMask);
+            for (std::uint32_t i = 0; i < displayCount; ++i) {
+                if ((CGDisplayIDToOpenGLDisplayMask(displays[i]) & mask) != 0) {
+                    return displays[i];
+                }
+            }
+        }
+        return CGMainDisplayID();
+    }
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    CVReturn MobileGLCVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(
+        CVDisplayLinkRef displayLink,
+        CGLContextObj context,
+        CGLPixelFormatObj pixelFormat) {
+        GLint virtualScreen = 0;
+        if (MobileGL::MG_Impl::CGLImpl::GetVirtualScreen(context, &virtualScreen) == kCGLNoError) {
+            GLint displayMask = 0;
+            if (!displayLink ||
+                MobileGL::MG_Impl::CGLImpl::DescribePixelFormat(
+                    pixelFormat, virtualScreen, kCGLPFADisplayMask, &displayMask) != kCGLNoError) {
+                return kCVReturnInvalidArgument;
+            }
+            return CVDisplayLinkSetCurrentCGDisplay(displayLink, DisplayForMask(displayMask));
+        }
+
+        using OriginalFunction = CVReturn (*)(CVDisplayLinkRef, CGLContextObj, CGLPixelFormatObj);
+        static const auto original = reinterpret_cast<OriginalFunction>(
+            dlsym(RTLD_NEXT, "CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext"));
+        return original ? original(displayLink, context, pixelFormat) : kCVReturnError;
+    }
+
     __attribute__((used)) static const DyldInterposeEntry kMobileGLDyldInterpose[]
         __attribute__((section("__DATA,__interpose"))) = {
             {reinterpret_cast<const void*>(MobileGLDlsym), reinterpret_cast<const void*>(dlsym)},
+            {reinterpret_cast<const void*>(MobileGLCVDisplayLinkSetCurrentCGDisplayFromOpenGLContext),
+             reinterpret_cast<const void*>(CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext)},
         };
+#pragma clang diagnostic pop
 } // namespace
 
 #endif

MobileGL/MG_Impl/DyldInterpose/ExportedSymbols.txt

@@ -0,0 +1,10 @@
+# Public CGL entry points.
+_CGL*
+
+# Public EGL entry points.
+_egl*
+
+# Public OpenGL and GLX entry points. OpenGL function names always use an
+# uppercase letter or digit after the "gl" prefix; excluding lowercase here
+# deliberately prevents glslang_* from matching this pattern.
+_gl[A-Z0-9]*

MobileGL/MG_Impl/GLImpl/Sync/GL_Sync.cpp

@@ -133,4 +133,33 @@ namespace MobileGL::MG_Impl::GLImpl {
             values[0] = value;
         }
     }
+
+    void DestroyAllSyncObjects() {
+        // Detach the registry under the lock, release outside it. Entries the app
+        // already deleted were erased by DeleteSync, so nothing here double-frees;
+        // a DeleteSync racing this sweep finds an empty registry and returns. A
+        // thread still blocked inside ClientWaitSync/GetSynciv during teardown
+        // holds a raw SyncObject* these deletes invalidate - the same undefined
+        // race an app-driven DeleteSync already has.
+        UnorderedMap<GLsync, SyncObject*> orphans;
+        {
+            const std::lock_guard<std::mutex> lock(g_syncObjectsMutex);
+            orphans.swap(g_liveSyncObjects);
+        }
+        if (orphans.empty()) {
+            return;
+        }
+        // Both backends' DeleteSync only free the heap wrapper once their GL
+        // context/renderer is gone (generation/current-thread guards), so this is
+        // safe after the backend has released its EGL resources - but not after
+        // the function table itself is cleared.
+        const auto backendDeleteSync = MG_Backend::gBackendFunctionsTable.GL.DeleteSync;
+        for (const auto& [_, syncObject] : orphans) {
+            if (backendDeleteSync && syncObject->backendHandle) {
+                backendDeleteSync(syncObject->backendHandle);
+            }
+            delete syncObject;
+        }
+        MGLOG_D("DestroyAllSyncObjects: reclaimed %zu sync object(s) the app left undeleted", orphans.size());
+    }
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Sync/GL_Sync.h

@@ -16,4 +16,12 @@ namespace MobileGL::MG_Impl::GLImpl {
     void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
     void DeleteSync(GLsync sync);
     void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values);
+    // Destroys every still-registered sync object exactly as DeleteSync would.
+    // GL requires syncs to die with their context; called only from full library
+    // teardown (DestroyImpl), where no context survives on any thread, so the
+    // process-global registry can be drained wholesale. Must run while the
+    // backend function table is still populated: each backend handle has to be
+    // released by the backend that created it, never by a later re-initialized
+    // one.
+    void DestroyAllSyncObjects();
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GetProcAddress.cpp

@@ -85,6 +85,8 @@ namespace MobileGL::MG_Impl {
         GETPROC(CGLGetPixelFormat, name);
         GETPROC(CGLSetCurrentContext, name);
         GETPROC(CGLGetCurrentContext, name);
+        GETPROC(CGLSetVirtualScreen, name);
+        GETPROC(CGLGetVirtualScreen, name);
         GETPROC(CGLSetParameter, name);
         GETPROC(CGLGetParameter, name);
         GETPROC(CGLUpdateContext, name);

MobileGL/MG_Impl/NSOpenGLImpl/NSOpenGLImpl.cpp

@@ -29,10 +29,19 @@ namespace MobileGL::MG_Impl::NSOpenGLImpl {
         char kContextViewKey;
         char kContextLayerKey;
 
-        std::once_flag g_installOnce;
         IMP g_pixelFormatDealloc = nullptr;
         IMP g_contextDealloc = nullptr;
 
+        std::mutex& HookInstallMutex() {
+            static auto* mutex = new std::mutex();
+            return *mutex;
+        }
+
+        Bool& HooksInstalled() {
+            static auto* installed = new Bool(false);
+            return *installed;
+        }
+
         template <typename Fn>
         Fn ObjcMsgSend() {
             return reinterpret_cast<Fn>(objc_msgSend);
@@ -431,12 +440,12 @@ namespace MobileGL::MG_Impl::NSOpenGLImpl {
             method_setImplementation(method, replacement);
         }
 
-        void InstallHooksOnce() {
+        Bool InstallHooksOnce() {
             Class pixelFormatClass = objc_getClass("NSOpenGLPixelFormat");
             Class contextClass = objc_getClass("NSOpenGLContext");
             if (!pixelFormatClass || !contextClass) {
                 MGLOG_W("NSOpenGLImpl: NSOpenGL classes are not loaded; hooks not installed");
-                return;
+                return false;
             }
 
             ReplaceInstanceMethod(pixelFormatClass, "initWithAttributes:",
@@ -471,11 +480,34 @@ namespace MobileGL::MG_Impl::NSOpenGLImpl {
             ReplaceInstanceMethod(contextClass, "dealloc", reinterpret_cast<IMP>(ContextDealloc), &g_contextDealloc);
 
             MGLOG_I("NSOpenGLImpl hooks installed");
+            return true;
         }
     } // namespace
 
     void InstallHooks() {
-        std::call_once(g_installOnce, InstallHooksOnce);
+        const std::lock_guard<std::mutex> lock(HookInstallMutex());
+        if (!HooksInstalled()) {
+            // Do not permanently consume the install attempt when the OpenGL
+            // framework has not registered its Objective-C classes yet. The
+            // dyld bootstrap normally runs after framework dependencies, but
+            // an explicitly loaded/static-linked MobileGL can arrive earlier.
+            HooksInstalled() = InstallHooksOnce();
+        }
     }
 } // namespace MobileGL::MG_Impl::NSOpenGLImpl
+
+namespace {
+    // SDL's Cocoa backend creates NSOpenGLPixelFormat/NSOpenGLContext before
+    // its first dlsym("glGetString") or other MobileGL host-API call. Install
+    // only the lightweight Objective-C dispatch hooks while the injected dylib
+    // is loading so those first Cocoa objects are routed through CGLImpl. The
+    // hooked context constructor reaches EGLImpl::GetDisplay(), which performs
+    // the full, thread-safe MobileGL initialization outside this bootstrap.
+    //
+    // There is intentionally no matching destructor: backend teardown remains
+    // owned by the EGL lifecycle and process-exit globals remain leak-at-exit.
+    __attribute__((constructor)) void BootstrapNSOpenGLHooks() {
+        MobileGL::MG_Impl::NSOpenGLImpl::InstallHooks();
+    }
+} // namespace
 #endif

MobileGL/MG_State/GLState/ProgramState/ProgramObject.h

@@ -334,16 +334,32 @@ namespace MobileGL::MG_State::GLState {
         // draw. The memo is keyed by (backendStateVersion, flags); ResetLinkArtifacts and
         // the binding setters below invalidate it by bumping m_backendStateVersion.
         Bool GetBackendHashMemo(Uint flags, Uint64& outHash) const {
-            if (m_backendHashMemoVersion != m_backendStateVersion || m_backendHashMemoFlags != flags) {
-                return false;
+            if (m_backendHashMemoVersion != m_backendStateVersion) return false;
+            for (const auto& slot : m_backendHashMemoSlots) {
+                if (slot.valid && slot.flags == flags) {
+                    outHash = slot.hash;
+                    return true;
+                }
             }
-            outHash = m_backendHashMemo;
-            return true;
+            return false;
         }
         void SetBackendHashMemo(Uint flags, Uint64 hash) const {
-            m_backendHashMemo = hash;
-            m_backendHashMemoVersion = m_backendStateVersion;
-            m_backendHashMemoFlags = flags;
+            if (m_backendHashMemoVersion != m_backendStateVersion) {
+                for (auto& slot : m_backendHashMemoSlots) slot.valid = false;
+                m_backendHashMemoVersion = m_backendStateVersion;
+                m_backendHashMemoNextSlot = 0;
+            }
+            for (auto& slot : m_backendHashMemoSlots) {
+                if (slot.valid && slot.flags == flags) {
+                    slot.hash = hash;
+                    return;
+                }
+            }
+            auto& slot = m_backendHashMemoSlots[m_backendHashMemoNextSlot];
+            slot.flags = flags;
+            slot.hash = hash;
+            slot.valid = true;
+            m_backendHashMemoNextSlot = (m_backendHashMemoNextSlot + 1) % kBackendHashMemoSlotCount;
         }
 
         void SetUniformSamplerOrImageUnitIndex(Uint location, Int unit) {
@@ -527,10 +543,19 @@ namespace MobileGL::MG_State::GLState {
         Uint32 m_backendStateVersion = 0;
 
         // Backend-owned content-hash memo (see GetBackendHashMemo): valid only while
-        // m_backendStateVersion and the compile flags match the recorded values.
-        mutable Uint64 m_backendHashMemo = 0;
+        // m_backendStateVersion matches. Several slots, not one: a backend may resolve the same
+        // program under more than one compile-flag set within a frame (surface rotation, and the
+        // explicit-LOD sampling variant), and a single slot would then miss on every lookup and
+        // re-hash the program's whole SPIR-V once per draw.
+        static constexpr SizeT kBackendHashMemoSlotCount = 4;
+        struct BackendHashMemoSlot {
+            Uint64 hash = 0;
+            Uint flags = 0;
+            Bool valid = false;
+        };
+        mutable Array<BackendHashMemoSlot, kBackendHashMemoSlotCount> m_backendHashMemoSlots{};
+        mutable SizeT m_backendHashMemoNextSlot = 0;
         mutable Uint32 m_backendHashMemoVersion = ~0u;
-        mutable Uint m_backendHashMemoFlags = 0;
         Uint32 m_uboContentVersion = 0;
         Uint32 m_linkVersion = 0;
     };

MobileGL/MG_State/GLState/TextureState/TextureObject.h

@@ -15,7 +15,11 @@
 #include <MG_Util/Math/VectorTypes.h>
 
 namespace MobileGL::MG_State::GLState {
-    class ITextureObject {
+    // Texture objects are always SharedPtr-owned (TextureState creates every instance via
+    // MakeShared, including the per-target default objects). enable_shared_from_this lets
+    // backends that only receive a reference (e.g. syncing a name-deleted texture kept
+    // alive by an FBO attachment) still register a weak liveness reference for GC.
+    class ITextureObject : public std::enable_shared_from_this<ITextureObject> {
     public:
         using TargetEnum = TextureTarget;
         virtual ~ITextureObject() = default;

MobileGL/MG_Test/SanityTest.cpp

@@ -33,6 +33,7 @@
 #include <MG_Util/ShaderTranspiler/ShaderCompiler.h>
 #include <MG_Util/ShaderTranspiler/ShaderSourceProcessor.h>
 #include <MG_Util/Debug/Log.h>
+#include <FastSTL/UnorderedMap.h>
 
 namespace {
     class DynamicParameterBackend final : public MobileGL::MG_Backend::BackendObject {
@@ -1736,3 +1737,61 @@ TEST(DirectGLESStateGuards, DefaultFramebufferBindGoesThroughShadow) {
     FramebufferImpl::BindFramebufferId(GL_DRAW_FRAMEBUFFER, 7); // must reach the driver again
     EXPECT_EQ(mocks.log.Count("BindFramebuffer:"), 3u);
 }
+
+// FastSTL::unordered_map::erase(iterator) regression coverage. The open-addressing
+// iterator constructor snaps forward from a tombstoned slot to the successor, so
+// erase must NOT advance the rebuilt iterator again: the old double-advance skipped
+// one live element per erase, and erasing the element in the highest occupied
+// bucket pushed the returned index past bucket_count where it never compared equal
+// to end() again - erase-while-iterating sweeps (pipeline/program cache eviction)
+// then ran off the bucket array and fed garbage handles to vkDestroyPipeline
+// (device crash on first mass eviction during world load).
+TEST(FastSTLSanity, EraseWhileIteratingVisitsEveryElementExactlyOnce) {
+    FastSTL::unordered_map<MobileGL::Uint64, MobileGL::Uint64> map;
+    constexpr MobileGL::Uint64 kCount = 1000;
+    for (MobileGL::Uint64 key = 0; key < kCount; ++key) {
+        map.emplace(key * 0x9e3779b97f4a7c15ull, key);
+    }
+    ASSERT_EQ(map.size(), kCount);
+
+    MobileGL::SizeT visited = 0;
+    for (auto it = map.begin(); it != map.end();) {
+        it = map.erase(it);
+        ++visited;
+        ASSERT_LE(visited, kCount); // old code: runaway past end / skipped entries
+    }
+    EXPECT_EQ(visited, kCount);
+    EXPECT_EQ(map.size(), 0u);
+}
+
+TEST(FastSTLSanity, EraseReturnsTheSuccessorElement) {
+    FastSTL::unordered_map<MobileGL::Uint32, MobileGL::Uint32> map;
+    for (MobileGL::Uint32 key = 1; key <= 64; ++key) {
+        map.emplace(key, key);
+    }
+
+    // Erasing every other visited element must still visit all 64 exactly once:
+    // the iterator returned by erase names the very next element, not one past it.
+    MobileGL::SizeT visited = 0;
+    MobileGL::SizeT erased = 0;
+    for (auto it = map.begin(); it != map.end();) {
+        ++visited;
+        if ((visited & 1) != 0) {
+            it = map.erase(it);
+            ++erased;
+        } else {
+            ++it;
+        }
+        ASSERT_LE(visited, 64u);
+    }
+    EXPECT_EQ(visited, 64u);
+    EXPECT_EQ(map.size(), 64u - erased);
+}
+
+TEST(FastSTLSanity, ErasingTheOnlyElementReturnsEnd) {
+    FastSTL::unordered_map<MobileGL::Uint32, MobileGL::Uint32> map;
+    map.emplace(42u, 1u);
+    auto next = map.erase(map.begin());
+    EXPECT_EQ(next, map.end());
+    EXPECT_TRUE(map.empty());
+}

MobileGL/MG_Util/Converters/MGToVk/TextureEnumConverter.cpp

@@ -133,9 +133,11 @@ namespace MobileGL {
             case TextureInternalFormat::RGBA8Snorm:
                 return VK_FORMAT_R8G8B8A8_SNORM;
             case TextureInternalFormat::RGB10A2:
-                return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
+                // GL_UNSIGNED_INT_2_10_10_10_REV puts R in bits 0-9, which is Vulkan's
+                // A2B10G10R10 layout - A2R10G10B10 silently swaps R and B on upload.
+                return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
             case TextureInternalFormat::RGB10A2UI:
-                return VK_FORMAT_A2R10G10B10_UINT_PACK32;
+                return VK_FORMAT_A2B10G10R10_UINT_PACK32;
             case TextureInternalFormat::RGBA16:
                 return VK_FORMAT_R16G16B16A16_UNORM;
             case TextureInternalFormat::RGBA16Snorm:

tools/cts/README.md

@@ -0,0 +1,85 @@
+# Running the OpenGL CTS (VK-GL-CTS / KHR-GL33) against MobileGL on Android
+
+Goal: measure how much of the OpenGL 3.3 core-profile conformance suite MobileGL
+passes, separately for each backend (`DirectGLES`, `DirectVulkan`).
+
+## How MobileGL is reached from a test binary
+
+MobileGL ships its own EGL implementation alongside its desktop-GL implementation
+in a single `libMobileGL.so`. A plain arm64 ELF in `/data/local/tmp` can therefore
+drive it with no APK and no Activity:
+
+1. `setenv("MOBILEGL_BACKEND_TYPE", "DirectGLES"|"DirectVulkan")` **before** the
+   library is mapped — MobileGL parses its configuration from an ELF constructor.
+2. `dlopen("libMobileGL.so")`, then `dlsym` the `egl*` and `gl*` entry points.
+   MobileGL exports 45 EGL symbols and the desktop GL functions directly;
+   `eglGetProcAddress` resolves the same set.
+3. `eglBindAPI(EGL_OPENGL_API)`, choose a config with `EGL_RENDERABLE_TYPE =
+   EGL_OPENGL_BIT`, then `eglCreateContext` with
+   `EGL_CONTEXT_OPENGL_PROFILE_MASK = EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT` and
+   major/minor `3`/`3`.
+
+This yields a genuine GL 3.3 core context (`GL_CONTEXT_PROFILE_MASK == 0x1`).
+
+## Surface type, per backend
+
+| backend | pbuffer (headless) | window |
+|---|---|---|
+| `DirectGLES` | works | works |
+| `DirectVulkan` | **unusable** | works |
+
+`DirectVulkan`'s pbuffer path builds a headless `VkSurfaceKHR` and so requires the
+`VK_EXT_headless_surface` instance extension, which Adreno's Android driver does
+not expose. It fails inside `eglMakeCurrent`, not at surface creation.
+
+The workaround that keeps everything in a shell process: obtain a real
+`ANativeWindow` from **`AImageReader`** (`AImageReader_newWithUsage` +
+`AImageReader_getWindow`). It is an ordinary BufferQueue producer, so
+`vkCreateAndroidSurfaceKHR` accepts it, and no Activity is involved. Register an
+`onImageAvailable` listener that acquires and deletes each image — otherwise the
+producer blocks once `maxImages` buffers are in flight and the next swap hangs.
+
+## Why the suite must render into an FBO
+
+On a window surface, `DirectVulkan`'s `glReadPixels` from the **default
+framebuffer** returns all zeros, with no GL error, both before and after
+`eglSwapBuffers`. `DirectGLES` on the identical window is correct, and readback
+from a **user FBO is correct on both backends**.
+
+Verified on two SoCs and two drivers, so this is MobileGL's behaviour rather than
+a driver quirk:
+
+| device | GPU | driver | default-FB | user FBO |
+|---|---|---|---|---|
+| Xiaomi 24129PN74C | Adreno 830 | Vulkan 1.3.284 / 512.800.46 | zeros | ok |
+| Lenovo TB321FU | Adreno 750 | Vulkan 1.3.128 / 512.762.28 | zeros | ok |
+
+dEQP verifies nearly every case through `glReadPixels`, so running it against the
+default framebuffer would score `DirectVulkan` near zero for a reason unrelated to
+conformance. The runs therefore use `--deqp-surface-type=fbo`, uniformly for both
+backends so the two numbers stay comparable.
+
+## Other constraints the harness must respect
+
+- `eglMakeCurrent` requires **draw == read** and rejects `EGL_NO_SURFACE` with
+  `EGL_BAD_MATCH`. dEQP's `surfaceless` platform is therefore unusable, which is
+  why this port supplies its own `tcu::Platform`.
+- MobileGL aborts during static teardown (`FORTIFY: pthread_mutex_lock called on a
+  destroyed mutex`) *after* all work completes. Flush and `_exit()` so the exit
+  code and the `.qpa` log survive.
+
+## Contents
+
+    probe/mgprobe.c        preflight gate: one backend x one surface type, checks
+                           context version/profile and both readback paths
+    scripts/qpa_report.py  .qpa -> pass rate, status histogram, worst groups
+
+### Preflight
+
+    aarch64-linux-android26-clang -O1 -o mgprobe mgprobe.c -ldl -llog -landroid -lmediandk
+    adb push mgprobe libMobileGL.so /data/local/tmp/mgcts/
+    adb shell 'cd /data/local/tmp/mgcts && LD_LIBRARY_PATH=. ./mgprobe \
+        --backend DirectVulkan --surface imagereader --lib ./libMobileGL.so'
+
+Exit status is 0 when a 3.3 core context came up and FBO readback is correct.
+Default-framebuffer readback is reported but deliberately does not gate.

tools/cts/patches/0001-fbo-color-texture-attachment.patch

@@ -0,0 +1,109 @@
+diff --git a/framework/opengl/gluFboRenderContext.cpp b/framework/opengl/gluFboRenderContext.cpp
+index 588cf7d2a..0721ffee7 100644
+--- a/framework/opengl/gluFboRenderContext.cpp
++++ b/framework/opengl/gluFboRenderContext.cpp
+@@ -132,6 +132,7 @@ FboRenderContext::FboRenderContext(RenderContext *context, const RenderConfig &c
+     : m_context(context)
+     , m_framebuffer(0)
+     , m_colorBuffer(0)
++    , m_colorIsTexture(false)
+     , m_depthStencilBuffer(0)
+     , m_renderTarget()
+ {
+@@ -151,6 +152,7 @@ FboRenderContext::FboRenderContext(const ContextFactory &factory, const RenderCo
+     : m_context(nullptr)
+     , m_framebuffer(0)
+     , m_colorBuffer(0)
++    , m_colorIsTexture(false)
+     , m_depthStencilBuffer(0)
+     , m_renderTarget()
+ {
+@@ -215,19 +217,41 @@ void FboRenderContext::createFramebuffer(const RenderConfig &config)
+         height = (height == glu::RenderConfig::DONT_CARE) ? maxSize : height;
+     }
+ 
++    // MOBILEGL: allow the colour attachment to be a texture instead of a
++    // renderbuffer. MobileGL's DirectVulkan backend returns zeros when reading
++    // back a renderbuffer-attached FBO, which makes every image comparison fail
++    // for one reason and hides everything else. Setting
++    // MOBILEGL_CTS_FBO_COLOR_TEXTURE=1 isolates that single defect so the rest
++    // of the suite can be measured. Off by default: stock behaviour.
+     {
+-        pixelFormat = getPixelFormat(colorFormat);
++        const char *useTexEnv = getenv("MOBILEGL_CTS_FBO_COLOR_TEXTURE");
++        m_colorIsTexture      = (useTexEnv && useTexEnv[0] == '1' && config.numSamples <= 0);
+ 
+-        gl.genRenderbuffers(1, &m_colorBuffer);
+-        gl.bindRenderbuffer(GL_RENDERBUFFER, m_colorBuffer);
++        pixelFormat = getPixelFormat(colorFormat);
+ 
+-        if (config.numSamples > 0)
+-            gl.renderbufferStorageMultisample(GL_RENDERBUFFER, config.numSamples, colorFormat, width, height);
++        if (m_colorIsTexture)
++        {
++            gl.genTextures(1, &m_colorBuffer);
++            gl.bindTexture(GL_TEXTURE_2D, m_colorBuffer);
++            gl.texStorage2D(GL_TEXTURE_2D, 1, colorFormat, width, height);
++            gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
++            gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
++            gl.bindTexture(GL_TEXTURE_2D, 0);
++            GLU_EXPECT_NO_ERROR(gl.getError(), "Creating color texture");
++        }
+         else
+-            gl.renderbufferStorage(GL_RENDERBUFFER, colorFormat, width, height);
+-
+-        gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
+-        GLU_EXPECT_NO_ERROR(gl.getError(), "Creating color renderbuffer");
++        {
++            gl.genRenderbuffers(1, &m_colorBuffer);
++            gl.bindRenderbuffer(GL_RENDERBUFFER, m_colorBuffer);
++
++            if (config.numSamples > 0)
++                gl.renderbufferStorageMultisample(GL_RENDERBUFFER, config.numSamples, colorFormat, width, height);
++            else
++                gl.renderbufferStorage(GL_RENDERBUFFER, colorFormat, width, height);
++
++            gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
++            GLU_EXPECT_NO_ERROR(gl.getError(), "Creating color renderbuffer");
++        }
+     }
+ 
+     if (depthStencilFormat != GL_NONE)
+@@ -250,7 +274,12 @@ void FboRenderContext::createFramebuffer(const RenderConfig &config)
+     gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
+ 
+     if (m_colorBuffer)
+-        gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_colorBuffer);
++    {
++        if (m_colorIsTexture)
++            gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorBuffer, 0);
++        else
++            gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_colorBuffer);
++    }
+ 
+     if (m_depthStencilBuffer)
+     {
+@@ -290,7 +319,10 @@ void FboRenderContext::destroyFramebuffer(void)
+ 
+     if (m_colorBuffer)
+     {
+-        gl.deleteRenderbuffers(1, &m_colorBuffer);
++        if (m_colorIsTexture)
++            gl.deleteTextures(1, &m_colorBuffer);
++        else
++            gl.deleteRenderbuffers(1, &m_colorBuffer);
+         m_colorBuffer = 0;
+     }
+ }
+diff --git a/framework/opengl/gluFboRenderContext.hpp b/framework/opengl/gluFboRenderContext.hpp
+index 75a0ff6b7..09ff1e7a9 100644
+--- a/framework/opengl/gluFboRenderContext.hpp
++++ b/framework/opengl/gluFboRenderContext.hpp
+@@ -80,6 +80,7 @@ private:
+     RenderContext *m_context;
+     uint32_t m_framebuffer;
+     uint32_t m_colorBuffer;
++    bool m_colorIsTexture;
+     uint32_t m_depthStencilBuffer;
+     tcu::RenderTarget m_renderTarget;
+ };

tools/cts/platform/tcuMobileGLPlatform.cpp

@@ -0,0 +1,473 @@
+/*-------------------------------------------------------------------------
+ * dEQP platform port for MobileGL on Android
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief MobileGL platform.
+ *
+ * Modelled on the surfaceless platform, but adapted to MobileGL, which ships
+ * its own EGL implementation inside libMobileGL.so:
+ *
+ *  - Every EGL call goes through the dynamically loaded library. The
+ *    surfaceless port mixes wrapper calls with globally linked egl* symbols;
+ *    doing that here would silently reach Android's system EGL instead.
+ *  - Desktop-GL configs are selected with EGL_OPENGL_BIT. The surfaceless port
+ *    always asks for an ES bit, which cannot satisfy a GL 3.3 core context.
+ *  - A real surface is always created. MobileGL rejects EGL_NO_SURFACE with
+ *    EGL_BAD_MATCH, and --deqp-surface-type=fbo asks the platform for
+ *    SURFACETYPE_DONT_CARE, so "no surface" is not an option.
+ *  - Window surfaces are backed by an AImageReader rather than an Activity,
+ *    which is what lets the suite run as a plain adb-shell binary. DirectVulkan
+ *    needs this: its pbuffer path requires VK_EXT_headless_surface, which
+ *    Adreno's Android driver does not expose.
+ *
+ * Environment:
+ *   MOBILEGL_CTS_LIB      path/soname of the MobileGL library (default libMobileGL.so)
+ *   MOBILEGL_CTS_SURFACE  "window" (default) or "pbuffer"
+ *   MOBILEGL_BACKEND_TYPE read by MobileGL itself; set it before launching
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuMobileGLPlatform.hpp"
+
+#include <cstdlib>
+#include <string>
+#include <vector>
+
+#include "deDynamicLibrary.hpp"
+#include "egluUtil.hpp"
+#include "eglwEnums.hpp"
+#include "eglwLibrary.hpp"
+#include "gluPlatform.hpp"
+#include "gluRenderConfig.hpp"
+#include "gluRenderContext.hpp"
+#include "glwInitFunctions.hpp"
+#include "tcuCommandLine.hpp"
+#include "tcuPixelFormat.hpp"
+#include "tcuPlatform.hpp"
+#include "tcuRenderTarget.hpp"
+
+#include <android/hardware_buffer.h>
+#include <android/native_window.h>
+#include <media/NdkImageReader.h>
+
+using std::string;
+using std::vector;
+
+#if !defined(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR)
+#define EGL_CONTEXT_FLAGS_KHR 0x30FC
+#define EGL_CONTEXT_MAJOR_VERSION_KHR 0x3098
+#define EGL_CONTEXT_MINOR_VERSION_KHR 0x30FB
+#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
+#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
+#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
+#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
+#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30FD
+#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR 0x00000004
+#endif
+
+namespace tcu
+{
+namespace mobilegl
+{
+
+static string getLibraryName(void)
+{
+    const char *env = std::getenv("MOBILEGL_CTS_LIB");
+    return (env && env[0]) ? string(env) : string("libMobileGL.so");
+}
+
+//! Window surfaces default on: they are the only kind DirectVulkan can use.
+static bool useWindowSurface(void)
+{
+    const char *env = std::getenv("MOBILEGL_CTS_SURFACE");
+    return !(env && string(env) == "pbuffer");
+}
+
+/*--------------------------------------------------------------------*//*!
+ * \brief A real ANativeWindow with no Activity behind it.
+ *
+ * AImageReader's window is an ordinary BufferQueue producer, so both
+ * eglCreateWindowSurface and vkCreateAndroidSurfaceKHR accept it. The image
+ * listener must drain the queue: without it the producer blocks once maxImages
+ * buffers are in flight and the next swap deadlocks.
+ *//*--------------------------------------------------------------------*/
+class ImageReaderWindow
+{
+public:
+    ImageReaderWindow(int width, int height) : m_reader(nullptr), m_window(nullptr)
+    {
+        const media_status_t status =
+            AImageReader_newWithUsage(width, height, AIMAGE_FORMAT_RGBA_8888,
+                                      AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
+                                          AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT,
+                                      kMaxImages, &m_reader);
+        if (status != AMEDIA_OK || m_reader == nullptr)
+            throw tcu::ResourceError("AImageReader_newWithUsage() failed");
+
+        AImageReader_ImageListener listener = {this, onImageAvailable};
+        AImageReader_setImageListener(m_reader, &listener);
+
+        if (AImageReader_getWindow(m_reader, &m_window) != AMEDIA_OK || m_window == nullptr)
+        {
+            AImageReader_delete(m_reader);
+            m_reader = nullptr;
+            throw tcu::ResourceError("AImageReader_getWindow() failed");
+        }
+        ANativeWindow_acquire(m_window);
+    }
+
+    ~ImageReaderWindow(void)
+    {
+        if (m_window != nullptr)
+            ANativeWindow_release(m_window);
+        if (m_reader != nullptr)
+        {
+            AImageReader_setImageListener(m_reader, nullptr);
+            AImageReader_delete(m_reader);
+        }
+    }
+
+    ANativeWindow *getWindow(void) const
+    {
+        return m_window;
+    }
+
+private:
+    static const int kMaxImages = 4;
+
+    static void onImageAvailable(void *, AImageReader *reader)
+    {
+        AImage *image = nullptr;
+        if (AImageReader_acquireNextImage(reader, &image) == AMEDIA_OK && image != nullptr)
+            AImage_delete(image);
+    }
+
+    ImageReaderWindow(const ImageReaderWindow &);
+    ImageReaderWindow &operator=(const ImageReaderWindow &);
+
+    AImageReader *m_reader;
+    ANativeWindow *m_window;
+};
+
+class GetProcFuncLoader : public glw::FunctionLoader
+{
+public:
+    GetProcFuncLoader(const eglw::Library &egl) : m_egl(egl)
+    {
+    }
+
+    glw::GenericFuncType get(const char *name) const
+    {
+        return (glw::GenericFuncType)m_egl.getProcAddress(name);
+    }
+
+protected:
+    const eglw::Library &m_egl;
+};
+
+class EglRenderContext : public glu::RenderContext
+{
+public:
+    EglRenderContext(const glu::RenderConfig &config, const tcu::CommandLine &cmdLine,
+                     const glu::RenderContext *sharedContext);
+    ~EglRenderContext(void);
+
+    glu::ContextType getType(void) const
+    {
+        return m_contextType;
+    }
+    eglw::EGLContext getEglContext(void) const
+    {
+        return m_eglContext;
+    }
+    const glw::Functions &getFunctions(void) const
+    {
+        return m_glFunctions;
+    }
+    const tcu::RenderTarget &getRenderTarget(void) const
+    {
+        return m_renderTarget;
+    }
+    void postIterate(void);
+    void makeCurrent(void);
+
+    glw::GenericFuncType getProcAddress(const char *name) const
+    {
+        return (glw::GenericFuncType)m_egl.getProcAddress(name);
+    }
+
+private:
+    const eglw::DefaultLibrary m_egl;
+    const glu::ContextType m_contextType;
+    eglw::EGLDisplay m_eglDisplay;
+    eglw::EGLContext m_eglContext;
+    eglw::EGLSurface m_eglSurface;
+    ImageReaderWindow *m_window;
+    glw::Functions m_glFunctions;
+    tcu::RenderTarget m_renderTarget;
+    eglw::EGLContext m_sharedEglContext;
+};
+
+class ContextFactory : public glu::ContextFactory
+{
+public:
+    ContextFactory(void) : glu::ContextFactory("default", "MobileGL EGL context")
+    {
+    }
+
+    glu::RenderContext *createContext(const glu::RenderConfig &config, const tcu::CommandLine &cmdLine,
+                                      const glu::RenderContext *sharedContext) const
+    {
+        return new EglRenderContext(config, cmdLine, sharedContext);
+    }
+};
+
+class Platform : public tcu::Platform, public glu::Platform
+{
+public:
+    Platform(void)
+    {
+        m_contextFactoryRegistry.registerFactory(new ContextFactory());
+    }
+
+    const glu::Platform &getGLPlatform(void) const
+    {
+        return *this;
+    }
+};
+
+EglRenderContext::EglRenderContext(const glu::RenderConfig &config, const tcu::CommandLine &cmdLine,
+                                   const glu::RenderContext *sharedContext)
+    : m_egl(getLibraryName().c_str())
+    , m_contextType(config.type)
+    , m_eglDisplay(EGL_NO_DISPLAY)
+    , m_eglContext(EGL_NO_CONTEXT)
+    , m_eglSurface(EGL_NO_SURFACE)
+    , m_window(nullptr)
+    , m_renderTarget(config.width, config.height,
+                     tcu::PixelFormat(config.redBits, config.greenBits, config.blueBits, config.alphaBits),
+                     config.depthBits, config.stencilBits, config.numSamples)
+    , m_sharedEglContext(EGL_NO_CONTEXT)
+{
+    DE_UNREF(cmdLine);
+
+    const glu::ContextType &contextType = config.type;
+    const bool isES                     = glu::isContextTypeES(contextType);
+    eglw::EGLint eglMajorVersion        = 0;
+    eglw::EGLint eglMinorVersion        = 0;
+
+    m_eglDisplay = m_egl.getDisplay(EGL_DEFAULT_DISPLAY);
+    EGLU_CHECK_MSG(m_egl, "eglGetDisplay()");
+    if (m_eglDisplay == EGL_NO_DISPLAY)
+        throw tcu::ResourceError("eglGetDisplay() failed");
+
+    EGLU_CHECK_CALL(m_egl, initialize(m_eglDisplay, &eglMajorVersion, &eglMinorVersion));
+
+    // MobileGL cannot make a context current without a surface, so
+    // SURFACETYPE_DONT_CARE (which is what --deqp-surface-type=fbo requests)
+    // still gets a real one.
+    bool wantWindow = false;
+    switch (config.surfaceType)
+    {
+    case glu::RenderConfig::SURFACETYPE_WINDOW:
+        wantWindow = true;
+        break;
+    case glu::RenderConfig::SURFACETYPE_OFFSCREEN_NATIVE:
+    case glu::RenderConfig::SURFACETYPE_OFFSCREEN_GENERIC:
+        wantWindow = false;
+        break;
+    case glu::RenderConfig::SURFACETYPE_DONT_CARE:
+        wantWindow = useWindowSurface();
+        break;
+    default:
+        TCU_CHECK_INTERNAL(false);
+    }
+
+    const int width  = (config.width == glu::RenderConfig::DONT_CARE) ? 256 : config.width;
+    const int height = (config.height == glu::RenderConfig::DONT_CARE) ? 256 : config.height;
+
+    vector<eglw::EGLint> cfgAttribs;
+    cfgAttribs.push_back(EGL_RENDERABLE_TYPE);
+    if (isES)
+    {
+        switch (contextType.getMajorVersion())
+        {
+        case 3:
+            cfgAttribs.push_back(EGL_OPENGL_ES3_BIT);
+            break;
+        case 2:
+            cfgAttribs.push_back(EGL_OPENGL_ES2_BIT);
+            break;
+        default:
+            cfgAttribs.push_back(EGL_OPENGL_ES_BIT);
+        }
+    }
+    else
+    {
+        // Desktop GL, which is the whole point of this port.
+        cfgAttribs.push_back(EGL_OPENGL_BIT);
+    }
+
+    cfgAttribs.push_back(EGL_SURFACE_TYPE);
+    cfgAttribs.push_back(wantWindow ? EGL_WINDOW_BIT : EGL_PBUFFER_BIT);
+
+    static const struct
+    {
+        eglw::EGLint attrib;
+        int glu::RenderConfig::*field;
+    } s_sizeAttribs[] = {
+        {EGL_RED_SIZE, &glu::RenderConfig::redBits},     {EGL_GREEN_SIZE, &glu::RenderConfig::greenBits},
+        {EGL_BLUE_SIZE, &glu::RenderConfig::blueBits},   {EGL_ALPHA_SIZE, &glu::RenderConfig::alphaBits},
+        {EGL_DEPTH_SIZE, &glu::RenderConfig::depthBits}, {EGL_STENCIL_SIZE, &glu::RenderConfig::stencilBits},
+        {EGL_SAMPLES, &glu::RenderConfig::numSamples},
+    };
+    for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_sizeAttribs); ndx++)
+    {
+        const int value = config.*(s_sizeAttribs[ndx].field);
+        if (value != glu::RenderConfig::DONT_CARE)
+        {
+            cfgAttribs.push_back(s_sizeAttribs[ndx].attrib);
+            cfgAttribs.push_back(value);
+        }
+    }
+    cfgAttribs.push_back(EGL_NONE);
+
+    eglw::EGLConfig eglConfig = nullptr;
+    eglw::EGLint numConfigs   = 0;
+    EGLU_CHECK_CALL(m_egl, chooseConfig(m_eglDisplay, &cfgAttribs[0], &eglConfig, 1, &numConfigs));
+    if (numConfigs < 1)
+        throw tcu::NotSupportedError("No matching EGL config for the requested context");
+
+    if (wantWindow)
+    {
+        m_window = new ImageReaderWindow(width, height);
+
+        eglw::EGLint visualId = 0;
+        if (m_egl.getConfigAttrib(m_eglDisplay, eglConfig, EGL_NATIVE_VISUAL_ID, &visualId) && visualId != 0)
+            ANativeWindow_setBuffersGeometry(m_window->getWindow(), width, height, visualId);
+
+        m_eglSurface = m_egl.createWindowSurface(m_eglDisplay, eglConfig,
+                                                 (eglw::EGLNativeWindowType)m_window->getWindow(), nullptr);
+        EGLU_CHECK_MSG(m_egl, "eglCreateWindowSurface()");
+    }
+    else
+    {
+        const eglw::EGLint surfaceAttribs[] = {EGL_WIDTH, width, EGL_HEIGHT, height, EGL_NONE};
+        m_eglSurface                        = m_egl.createPbufferSurface(m_eglDisplay, eglConfig, surfaceAttribs);
+        EGLU_CHECK_MSG(m_egl, "eglCreatePbufferSurface()");
+    }
+
+    if (m_eglSurface == EGL_NO_SURFACE)
+        throw tcu::ResourceError("Failed to create EGL surface");
+
+    vector<eglw::EGLint> ctxAttribs;
+    ctxAttribs.push_back(EGL_CONTEXT_MAJOR_VERSION_KHR);
+    ctxAttribs.push_back(contextType.getMajorVersion());
+    ctxAttribs.push_back(EGL_CONTEXT_MINOR_VERSION_KHR);
+    ctxAttribs.push_back(contextType.getMinorVersion());
+
+    switch (contextType.getProfile())
+    {
+    case glu::PROFILE_ES:
+        EGLU_CHECK_CALL(m_egl, bindAPI(EGL_OPENGL_ES_API));
+        break;
+    case glu::PROFILE_CORE:
+        EGLU_CHECK_CALL(m_egl, bindAPI(EGL_OPENGL_API));
+        ctxAttribs.push_back(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR);
+        ctxAttribs.push_back(EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR);
+        break;
+    case glu::PROFILE_COMPATIBILITY:
+        EGLU_CHECK_CALL(m_egl, bindAPI(EGL_OPENGL_API));
+        ctxAttribs.push_back(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR);
+        ctxAttribs.push_back(EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR);
+        break;
+    default:
+        TCU_CHECK_INTERNAL(false);
+    }
+
+    eglw::EGLint flags = 0;
+    if ((contextType.getFlags() & glu::CONTEXT_DEBUG) != 0)
+        flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
+    if ((contextType.getFlags() & glu::CONTEXT_ROBUST) != 0)
+        flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
+    if ((contextType.getFlags() & glu::CONTEXT_FORWARD_COMPATIBLE) != 0)
+        flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
+    if (flags != 0)
+    {
+        ctxAttribs.push_back(EGL_CONTEXT_FLAGS_KHR);
+        ctxAttribs.push_back(flags);
+    }
+    ctxAttribs.push_back(EGL_NONE);
+
+    const EglRenderContext *sharedEglRenderContext = dynamic_cast<const EglRenderContext *>(sharedContext);
+    m_sharedEglContext = sharedEglRenderContext ? sharedEglRenderContext->getEglContext() : EGL_NO_CONTEXT;
+
+    m_eglContext = m_egl.createContext(m_eglDisplay, eglConfig, m_sharedEglContext, &ctxAttribs[0]);
+    EGLU_CHECK_MSG(m_egl, "eglCreateContext()");
+    if (!m_eglContext)
+        throw tcu::ResourceError("eglCreateContext() failed");
+
+    // MobileGL requires draw == read.
+    EGLU_CHECK_CALL(m_egl, makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext));
+
+    // MobileGL advertises EGL 1.5, so eglGetProcAddress resolves core entry
+    // points too; there is no separate GL library to dlopen.
+    GetProcFuncLoader funcLoader(m_egl);
+    glu::initCoreFunctions(&m_glFunctions, &funcLoader, contextType.getAPI());
+    glu::initExtensionFunctions(&m_glFunctions, &funcLoader, contextType.getAPI());
+}
+
+EglRenderContext::~EglRenderContext(void)
+{
+    try
+    {
+        if (m_eglDisplay != EGL_NO_DISPLAY)
+        {
+            m_egl.makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+
+            if (m_eglContext != EGL_NO_CONTEXT)
+                m_egl.destroyContext(m_eglDisplay, m_eglContext);
+
+            if (m_eglSurface != EGL_NO_SURFACE)
+                m_egl.destroySurface(m_eglDisplay, m_eglSurface);
+
+            if (m_sharedEglContext == EGL_NO_CONTEXT)
+                m_egl.terminate(m_eglDisplay);
+        }
+    }
+    catch (...)
+    {
+    }
+
+    delete m_window;
+}
+
+void EglRenderContext::makeCurrent(void)
+{
+    EGLU_CHECK_CALL(m_egl, makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext));
+}
+
+void EglRenderContext::postIterate(void)
+{
+    m_glFunctions.finish();
+}
+
+} // namespace mobilegl
+} // namespace tcu
+
+tcu::Platform *createPlatform(void)
+{
+    return new tcu::mobilegl::Platform();
+}

tools/cts/platform/tcuMobileGLPlatform.hpp

@@ -0,0 +1,33 @@
+#ifndef _TCUMOBILEGLPLATFORM_HPP
+#define _TCUMOBILEGLPLATFORM_HPP
+/*-------------------------------------------------------------------------
+ * dEQP platform port for MobileGL on Android
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief MobileGL platform - drives libMobileGL.so's own EGL from a bare
+ *        Android process, with no Activity and no system EGL involved.
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+
+namespace tcu
+{
+class Platform;
+}
+
+tcu::Platform *createPlatform(void);
+
+#endif // _TCUMOBILEGLPLATFORM_HPP

tools/cts/probe/.gitignore

@@ -0,0 +1,2 @@
+mgprobe
+*.o

tools/cts/probe/mgprobe.c

@@ -0,0 +1,359 @@
+/* mgprobe - preflight gate for running a GL conformance suite against MobileGL
+ * from a bare adb-shell process (no APK, no Activity).
+ *
+ * Verifies, for one backend and one surface type, that MobileGL can hand out a
+ * GL 3.3 core context and that pixels read back correctly - both from the
+ * default framebuffer and from a user FBO. Run this before burning hours on a
+ * CTS run; it catches a broken device/library pairing in about a second.
+ *
+ *   mgprobe --backend DirectGLES|DirectVulkan --surface pbuffer|imagereader
+ *           [--lib /path/to/libMobileGL.so]
+ *
+ * Exit status: 0 if a context came up and FBO readback is correct, non-zero
+ * otherwise. Default-framebuffer readback is reported but does NOT gate, because
+ * DirectVulkan is known to return zeros there while FBO readback is sound.
+ *
+ * Build (NDK, arm64):
+ *   $NDK/toolchains/llvm/prebuilt/<host>/bin/aarch64-linux-android26-clang \
+ *       -O1 -o mgprobe mgprobe.c -ldl -llog -landroid -lmediandk
+ */
+#include <android/native_window.h>
+#include <dlfcn.h>
+#include <media/NdkImageReader.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+typedef void *EGLDisplay;
+typedef void *EGLConfig;
+typedef void *EGLSurface;
+typedef void *EGLContext;
+typedef int EGLint;
+typedef unsigned int EGLBoolean;
+typedef unsigned int EGLenum;
+typedef void *EGLNativeDisplayType;
+typedef void *EGLNativeWindowType;
+
+#define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0)
+#define EGL_NO_CONTEXT ((EGLContext)0)
+#define EGL_NO_SURFACE ((EGLSurface)0)
+#define EGL_NONE 0x3038
+#define EGL_WIDTH 0x3057
+#define EGL_HEIGHT 0x3056
+#define EGL_RENDERABLE_TYPE 0x3040
+#define EGL_SURFACE_TYPE 0x3033
+#define EGL_WINDOW_BIT 0x0004
+#define EGL_PBUFFER_BIT 0x0001
+#define EGL_OPENGL_BIT 0x0008
+#define EGL_OPENGL_API 0x30A2
+#define EGL_RED_SIZE 0x3024
+#define EGL_GREEN_SIZE 0x3023
+#define EGL_BLUE_SIZE 0x3022
+#define EGL_ALPHA_SIZE 0x3021
+#define EGL_DEPTH_SIZE 0x3025
+#define EGL_STENCIL_SIZE 0x3026
+#define EGL_NATIVE_VISUAL_ID 0x302E
+#define EGL_CONTEXT_MAJOR_VERSION 0x3098
+#define EGL_CONTEXT_MINOR_VERSION 0x30FB
+#define EGL_CONTEXT_OPENGL_PROFILE_MASK 0x30FD
+#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001
+
+#define GL_VENDOR 0x1F00
+#define GL_RENDERER 0x1F01
+#define GL_VERSION 0x1F02
+#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
+#define GL_CONTEXT_PROFILE_MASK 0x9126
+#define GL_MAJOR_VERSION 0x821B
+#define GL_MINOR_VERSION 0x821C
+#define GL_COLOR_BUFFER_BIT 0x00004000
+#define GL_RGBA 0x1908
+#define GL_RGBA8 0x8058
+#define GL_UNSIGNED_BYTE 0x1401
+#define GL_TEXTURE_2D 0x0DE1
+#define GL_FRAMEBUFFER 0x8D40
+#define GL_COLOR_ATTACHMENT0 0x8CE0
+#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
+#define GL_TEXTURE_MIN_FILTER 0x2801
+#define GL_TEXTURE_MAG_FILTER 0x2800
+#define GL_NEAREST 0x2600
+#define GL_RENDERBUFFER 0x8D41
+
+typedef EGLDisplay (*P_getDisplay)(EGLNativeDisplayType);
+typedef EGLBoolean (*P_initialize)(EGLDisplay, EGLint *, EGLint *);
+typedef EGLBoolean (*P_bindAPI)(EGLenum);
+typedef EGLBoolean (*P_chooseConfig)(EGLDisplay, const EGLint *, EGLConfig *, EGLint, EGLint *);
+typedef EGLBoolean (*P_getConfigAttrib)(EGLDisplay, EGLConfig, EGLint, EGLint *);
+typedef EGLSurface (*P_createWindowSurface)(EGLDisplay, EGLConfig, EGLNativeWindowType, const EGLint *);
+typedef EGLSurface (*P_createPbufferSurface)(EGLDisplay, EGLConfig, const EGLint *);
+typedef EGLContext (*P_createContext)(EGLDisplay, EGLConfig, EGLContext, const EGLint *);
+typedef EGLBoolean (*P_makeCurrent)(EGLDisplay, EGLSurface, EGLSurface, EGLContext);
+typedef EGLint (*P_getError)(void);
+
+typedef const unsigned char *(*P_glGetString)(unsigned int);
+typedef void (*P_glGetIntegerv)(unsigned int, int *);
+typedef void (*P_glClearColor)(float, float, float, float);
+typedef void (*P_glClear)(unsigned int);
+typedef void (*P_glFinish)(void);
+typedef void (*P_glReadPixels)(int, int, int, int, unsigned int, unsigned int, void *);
+typedef unsigned int (*P_glGetError)(void);
+typedef void (*P_glGenTextures)(int, unsigned int *);
+typedef void (*P_glBindTexture)(unsigned int, unsigned int);
+typedef void (*P_glTexImage2D)(unsigned int, int, int, int, int, int, unsigned int, unsigned int, const void *);
+typedef void (*P_glTexParameteri)(unsigned int, unsigned int, int);
+typedef void (*P_glGenFramebuffers)(int, unsigned int *);
+typedef void (*P_glBindFramebuffer)(unsigned int, unsigned int);
+typedef void (*P_glFramebufferTexture2D)(unsigned int, unsigned int, unsigned int, unsigned int, int);
+typedef unsigned int (*P_glCheckFramebufferStatus)(unsigned int);
+typedef void (*P_glViewport)(int, int, int, int);
+typedef void (*P_glGenRenderbuffers)(int, unsigned int *);
+typedef void (*P_glBindRenderbuffer)(unsigned int, unsigned int);
+typedef void (*P_glRenderbufferStorage)(unsigned int, unsigned int, int, int);
+typedef void (*P_glFramebufferRenderbuffer)(unsigned int, unsigned int, unsigned int, unsigned int);
+
+static void *g_lib;
+static void *S(const char *n) { return dlsym(g_lib, n); }
+
+static void on_image(void *ctx, AImageReader *r) {
+    (void)ctx;
+    AImage *img = NULL;
+    /* Drain the queue, or the producer blocks once maxImages are in flight. */
+    if (AImageReader_acquireNextImage(r, &img) == AMEDIA_OK && img) AImage_delete(img);
+}
+
+#define DIM 256
+
+static int near8(unsigned got, int want, int tol) {
+    int d = (int)got - want;
+    return d <= tol && d >= -tol;
+}
+
+int main(int argc, char **argv) {
+    const char *backend = "DirectGLES";
+    const char *surface = "pbuffer";
+    const char *libpath = "libMobileGL.so";
+
+    for (int i = 1; i < argc; ++i) {
+        if (!strcmp(argv[i], "--backend") && i + 1 < argc) backend = argv[++i];
+        else if (!strcmp(argv[i], "--surface") && i + 1 < argc) surface = argv[++i];
+        else if (!strcmp(argv[i], "--lib") && i + 1 < argc) libpath = argv[++i];
+        else {
+            fprintf(stderr, "usage: %s [--backend DirectGLES|DirectVulkan]"
+                            " [--surface pbuffer|imagereader] [--lib path]\n", argv[0]);
+            return 2;
+        }
+    }
+    setvbuf(stdout, NULL, _IONBF, 0);
+
+    /* MobileGL parses its config from an ELF constructor, so the backend must be
+     * selected before the library is mapped. */
+    setenv("MOBILEGL_BACKEND_TYPE", backend, 1);
+    printf("mgprobe backend=%s surface=%s lib=%s\n", backend, surface, libpath);
+
+    int useWindow = !strcmp(surface, "imagereader");
+    ANativeWindow *win = NULL;
+    AImageReader *reader = NULL;
+    if (useWindow) {
+        if (AImageReader_newWithUsage(DIM, DIM, AIMAGE_FORMAT_RGBA_8888,
+                                      AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
+                                          AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT,
+                                      4, &reader) != AMEDIA_OK || !reader) {
+            printf("FAIL AImageReader_newWithUsage\n");
+            return 3;
+        }
+        AImageReader_ImageListener l = {NULL, on_image};
+        AImageReader_setImageListener(reader, &l);
+        if (AImageReader_getWindow(reader, &win) != AMEDIA_OK || !win) {
+            printf("FAIL AImageReader_getWindow\n");
+            return 3;
+        }
+    }
+
+    g_lib = dlopen(libpath, RTLD_NOW | RTLD_LOCAL);
+    if (!g_lib) {
+        printf("FAIL dlopen: %s\n", dlerror());
+        return 4;
+    }
+
+    P_getDisplay eglGetDisplay_ = (P_getDisplay)S("eglGetDisplay");
+    P_initialize eglInitialize_ = (P_initialize)S("eglInitialize");
+    P_bindAPI eglBindAPI_ = (P_bindAPI)S("eglBindAPI");
+    P_chooseConfig eglChooseConfig_ = (P_chooseConfig)S("eglChooseConfig");
+    P_getConfigAttrib eglGetConfigAttrib_ = (P_getConfigAttrib)S("eglGetConfigAttrib");
+    P_createWindowSurface eglCreateWindowSurface_ = (P_createWindowSurface)S("eglCreateWindowSurface");
+    P_createPbufferSurface eglCreatePbufferSurface_ = (P_createPbufferSurface)S("eglCreatePbufferSurface");
+    P_createContext eglCreateContext_ = (P_createContext)S("eglCreateContext");
+    P_makeCurrent eglMakeCurrent_ = (P_makeCurrent)S("eglMakeCurrent");
+    P_getError eglGetError_ = (P_getError)S("eglGetError");
+
+    if (!eglGetDisplay_ || !eglInitialize_ || !eglChooseConfig_ || !eglCreateContext_ || !eglMakeCurrent_) {
+        printf("FAIL missing core EGL exports\n");
+        return 5;
+    }
+
+    EGLDisplay dpy = eglGetDisplay_(EGL_DEFAULT_DISPLAY);
+    EGLint vmaj = 0, vmin = 0;
+    if (!eglInitialize_(dpy, &vmaj, &vmin)) {
+        printf("FAIL eglInitialize err=0x%x\n", eglGetError_ ? eglGetError_() : 0);
+        return 6;
+    }
+    if (eglBindAPI_ && !eglBindAPI_(EGL_OPENGL_API)) {
+        printf("FAIL eglBindAPI(EGL_OPENGL_API) err=0x%x\n", eglGetError_ ? eglGetError_() : 0);
+        return 7;
+    }
+
+    const EGLint cfgAttribs[] = {
+        EGL_SURFACE_TYPE, useWindow ? EGL_WINDOW_BIT : EGL_PBUFFER_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
+        EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8,
+        EGL_DEPTH_SIZE, 24, EGL_STENCIL_SIZE, 8,
+        EGL_NONE};
+    EGLConfig cfg = 0;
+    EGLint ncfg = 0;
+    if (!eglChooseConfig_(dpy, cfgAttribs, &cfg, 1, &ncfg) || ncfg < 1) {
+        printf("FAIL eglChooseConfig n=%d err=0x%x\n", ncfg, eglGetError_ ? eglGetError_() : 0);
+        return 8;
+    }
+
+    EGLSurface surf;
+    if (useWindow) {
+        EGLint vis = 0;
+        if (eglGetConfigAttrib_ && eglGetConfigAttrib_(dpy, cfg, EGL_NATIVE_VISUAL_ID, &vis) && vis)
+            ANativeWindow_setBuffersGeometry(win, DIM, DIM, vis);
+        surf = eglCreateWindowSurface_(dpy, cfg, (EGLNativeWindowType)win, NULL);
+    } else {
+        const EGLint sa[] = {EGL_WIDTH, DIM, EGL_HEIGHT, DIM, EGL_NONE};
+        surf = eglCreatePbufferSurface_(dpy, cfg, sa);
+    }
+    if (surf == EGL_NO_SURFACE) {
+        printf("FAIL create%sSurface err=0x%x\n", useWindow ? "Window" : "Pbuffer",
+               eglGetError_ ? eglGetError_() : 0);
+        return 9;
+    }
+
+    const EGLint ctxAttribs[] = {
+        EGL_CONTEXT_MAJOR_VERSION, 3, EGL_CONTEXT_MINOR_VERSION, 3,
+        EGL_CONTEXT_OPENGL_PROFILE_MASK, EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT, EGL_NONE};
+    EGLContext ctx = eglCreateContext_(dpy, cfg, EGL_NO_CONTEXT, ctxAttribs);
+    if (ctx == EGL_NO_CONTEXT) {
+        printf("FAIL eglCreateContext(3.3 core) err=0x%x\n", eglGetError_ ? eglGetError_() : 0);
+        return 10;
+    }
+    /* MobileGL requires draw == read and rejects EGL_NO_SURFACE. */
+    if (!eglMakeCurrent_(dpy, surf, surf, ctx)) {
+        printf("FAIL eglMakeCurrent err=0x%x\n", eglGetError_ ? eglGetError_() : 0);
+        return 11;
+    }
+
+    P_glGetString glGetString_ = (P_glGetString)S("glGetString");
+    P_glGetIntegerv glGetIntegerv_ = (P_glGetIntegerv)S("glGetIntegerv");
+    P_glClearColor glClearColor_ = (P_glClearColor)S("glClearColor");
+    P_glClear glClear_ = (P_glClear)S("glClear");
+    P_glFinish glFinish_ = (P_glFinish)S("glFinish");
+    P_glReadPixels glReadPixels_ = (P_glReadPixels)S("glReadPixels");
+    P_glGetError glGetError_ = (P_glGetError)S("glGetError");
+    P_glGenTextures glGenTextures_ = (P_glGenTextures)S("glGenTextures");
+    P_glBindTexture glBindTexture_ = (P_glBindTexture)S("glBindTexture");
+    P_glTexImage2D glTexImage2D_ = (P_glTexImage2D)S("glTexImage2D");
+    P_glTexParameteri glTexParameteri_ = (P_glTexParameteri)S("glTexParameteri");
+    P_glGenFramebuffers glGenFramebuffers_ = (P_glGenFramebuffers)S("glGenFramebuffers");
+    P_glBindFramebuffer glBindFramebuffer_ = (P_glBindFramebuffer)S("glBindFramebuffer");
+    P_glFramebufferTexture2D glFramebufferTexture2D_ = (P_glFramebufferTexture2D)S("glFramebufferTexture2D");
+    P_glCheckFramebufferStatus glCheckFramebufferStatus_ = (P_glCheckFramebufferStatus)S("glCheckFramebufferStatus");
+    P_glViewport glViewport_ = (P_glViewport)S("glViewport");
+    P_glGenRenderbuffers glGenRenderbuffers_ = (P_glGenRenderbuffers)S("glGenRenderbuffers");
+    P_glBindRenderbuffer glBindRenderbuffer_ = (P_glBindRenderbuffer)S("glBindRenderbuffer");
+    P_glRenderbufferStorage glRenderbufferStorage_ = (P_glRenderbufferStorage)S("glRenderbufferStorage");
+    P_glFramebufferRenderbuffer glFramebufferRenderbuffer_ = (P_glFramebufferRenderbuffer)S("glFramebufferRenderbuffer");
+
+    int major = -1, minor = -1, profile = -1;
+    glGetIntegerv_(GL_MAJOR_VERSION, &major);
+    glGetIntegerv_(GL_MINOR_VERSION, &minor);
+    glGetIntegerv_(GL_CONTEXT_PROFILE_MASK, &profile);
+    printf("  GL_VENDOR   %s\n", (const char *)glGetString_(GL_VENDOR));
+    printf("  GL_RENDERER %s\n", (const char *)glGetString_(GL_RENDERER));
+    printf("  GL_VERSION  %s\n", (const char *)glGetString_(GL_VERSION));
+    printf("  GLSL        %s\n", (const char *)glGetString_(GL_SHADING_LANGUAGE_VERSION));
+    printf("  version %d.%d profile_mask 0x%x %s\n", major, minor, profile,
+           (profile & 1) ? "(core)" : "(NOT CORE)");
+
+    unsigned char px[4];
+
+    /* Default framebuffer. */
+    glClearColor_(0.25f, 0.5f, 0.75f, 1.0f);
+    glClear_(GL_COLOR_BUFFER_BIT);
+    if (glFinish_) glFinish_();
+    memset(px, 0, sizeof px);
+    glReadPixels_(DIM / 2, DIM / 2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, px);
+    int defOk = near8(px[0], 64, 10) && near8(px[1], 128, 10) && near8(px[2], 191, 10);
+    printf("  default-FB readback (%u,%u,%u,%u) %s\n", px[0], px[1], px[2], px[3],
+           defOk ? "ok" : "BROKEN");
+
+    /* User FBO - this is what dEQP uses with --deqp-surface-type=fbo. */
+    unsigned int tex = 0, fbo = 0;
+    glGenTextures_(1, &tex);
+    glBindTexture_(GL_TEXTURE_2D, tex);
+    glTexImage2D_(GL_TEXTURE_2D, 0, GL_RGBA8, DIM, DIM, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+    glTexParameteri_(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri_(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glGenFramebuffers_(1, &fbo);
+    glBindFramebuffer_(GL_FRAMEBUFFER, fbo);
+    glFramebufferTexture2D_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
+    unsigned int fbst = glCheckFramebufferStatus_(GL_FRAMEBUFFER);
+    int fboOk = 0;
+    if (fbst == GL_FRAMEBUFFER_COMPLETE) {
+        glViewport_(0, 0, DIM, DIM);
+        glClearColor_(0.9f, 0.2f, 0.4f, 1.0f);
+        glClear_(GL_COLOR_BUFFER_BIT);
+        if (glFinish_) glFinish_();
+        memset(px, 0, sizeof px);
+        glReadPixels_(DIM / 2, DIM / 2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, px);
+        fboOk = near8(px[0], 230, 10) && near8(px[1], 51, 10) && near8(px[2], 102, 10);
+        printf("  user-FBO readback   (%u,%u,%u,%u) %s\n", px[0], px[1], px[2], px[3],
+               fboOk ? "ok" : "BROKEN");
+    } else {
+        printf("  user-FBO incomplete status=0x%x\n", fbst);
+    }
+
+    /* FBO with a RENDERBUFFER colour attachment. This is what dEQP's
+     * FboRenderContext allocates for --deqp-surface-type=fbo, so it is the path
+     * that actually decides a conformance run - a texture-attached FBO working
+     * says nothing about it. */
+    unsigned int rbo = 0, rfbo = 0;
+    int rboOk = 0;
+    if (glGenRenderbuffers_ && glBindRenderbuffer_ && glRenderbufferStorage_ && glFramebufferRenderbuffer_) {
+        glGenRenderbuffers_(1, &rbo);
+        glBindRenderbuffer_(GL_RENDERBUFFER, rbo);
+        glRenderbufferStorage_(GL_RENDERBUFFER, GL_RGBA8, DIM, DIM);
+        glBindRenderbuffer_(GL_RENDERBUFFER, 0);
+        glGenFramebuffers_(1, &rfbo);
+        glBindFramebuffer_(GL_FRAMEBUFFER, rfbo);
+        glFramebufferRenderbuffer_(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);
+        unsigned int rst = glCheckFramebufferStatus_(GL_FRAMEBUFFER);
+        if (rst == GL_FRAMEBUFFER_COMPLETE) {
+            glViewport_(0, 0, DIM, DIM);
+            glClearColor_(0.1f, 0.7f, 0.3f, 1.0f);
+            glClear_(GL_COLOR_BUFFER_BIT);
+            if (glFinish_) glFinish_();
+            memset(px, 0, sizeof px);
+            glReadPixels_(DIM / 2, DIM / 2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, px);
+            rboOk = near8(px[0], 26, 10) && near8(px[1], 179, 10) && near8(px[2], 77, 10);
+            printf("  rbo-FBO readback    (%u,%u,%u,%u) %s\n", px[0], px[1], px[2], px[3],
+                   rboOk ? "ok" : "BROKEN");
+        } else {
+            printf("  rbo-FBO incomplete status=0x%x\n", rst);
+        }
+    } else {
+        printf("  rbo-FBO skipped (renderbuffer entry points unavailable)\n");
+    }
+
+    unsigned glerr = glGetError_ ? glGetError_() : 0;
+    int ok = fboOk && rboOk && (major > 3 || (major == 3 && minor >= 3)) && (profile & 1) && glerr == 0;
+    printf("%s backend=%s surface=%s default_fb=%s user_fbo=%s rbo_fbo=%s glerr=0x%x\n",
+           ok ? "PASS" : "FAIL", backend, surface, defOk ? "ok" : "broken",
+           fboOk ? "ok" : "broken", rboOk ? "ok" : "broken", glerr);
+
+    fflush(stdout);
+    /* MobileGL aborts in static teardown; leave before that runs. */
+    _exit(ok ? 0 : 1);
+}

tools/cts/scripts/qpa_report.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python
+"""Summarise dEQP/glcts .qpa logs into a conformance pass rate.
+
+Handles the two ways a case can end in a .qpa: a normal
+``#beginTestCaseResult``/``#endTestCaseResult`` pair carrying a
+``<Result StatusCode="...">`` element, and ``#terminateTestCaseResult <reason>``,
+which is what the log contains when the process died partway through a case.
+Cases that were started but never terminated (the run was killed) are reported
+separately so a truncated chunk is never silently scored as a pass.
+
+Usage:
+    python qpa_report.py <file-or-dir> [<file-or-dir> ...] [--json out.json] [--top N]
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+from collections import Counter, defaultdict
+
+# Khronos conformance treats these as non-failures: the test either passed or
+# the implementation legitimately does not expose the feature under test.
+NON_FAILURE = {
+    "Pass",
+    "NotSupported",
+    "QualityWarning",
+    "CompatibilityWarning",
+    "Waiver",
+}
+
+# Statuses that indicate the case did not merely fail but destabilised the run.
+HARD = {"Crash", "Timeout", "InternalError", "ResourceError", "DeviceHang"}
+
+CASE_START = re.compile(r"^#beginTestCaseResult\s+(\S+)")
+CASE_END = re.compile(r"^#endTestCaseResult")
+CASE_TERM = re.compile(r"^#terminateTestCaseResult\s+(.*)")
+RESULT = re.compile(r'<Result\s+StatusCode="([^"]+)"')
+
+
+def parse_qpa(path):
+    """Yield (case_name, status) for every case recorded in one .qpa file."""
+    current = None
+    status = None
+    with open(path, "r", encoding="utf-8", errors="replace") as fh:
+        for line in fh:
+            m = CASE_START.match(line)
+            if m:
+                if current is not None:
+                    # A new case started before the previous one closed.
+                    yield current, status or "Incomplete"
+                current, status = m.group(1), None
+                continue
+            if current is None:
+                continue
+            m = RESULT.search(line)
+            if m:
+                status = m.group(1)
+                continue
+            m = CASE_TERM.match(line)
+            if m:
+                reason = m.group(1).strip() or "Terminated"
+                # dEQP writes e.g. "Crash" / "Timeout" here.
+                yield current, reason if reason in HARD else "Crash"
+                current, status = None, None
+                continue
+            if CASE_END.match(line):
+                yield current, status or "Incomplete"
+                current, status = None, None
+    if current is not None:
+        # File ended mid-case: the runner was killed.
+        yield current, "Incomplete"
+
+
+def collect(paths):
+    files = []
+    for p in paths:
+        if os.path.isdir(p):
+            for root, _dirs, names in os.walk(p):
+                files.extend(os.path.join(root, n) for n in sorted(names) if n.endswith(".qpa"))
+        else:
+            files.append(p)
+    return files
+
+
+def group_of(case):
+    """The case's parent group, e.g. KHR-GL33.shaders.arrays for ...arrays.foo."""
+    parts = case.split(".")
+    return ".".join(parts[:-1]) if len(parts) > 1 else case
+
+
+def load_sidecar(paths, name):
+    """Case names run_cts.py recorded in one of its sidecar lists."""
+    out = set()
+    for p in paths:
+        d = p if os.path.isdir(p) else os.path.dirname(p)
+        f = os.path.join(d, name)
+        if os.path.isfile(f):
+            with open(f, "r", encoding="utf-8") as fh:
+                out.update(l.strip() for l in fh if l.strip() and not l.strip().startswith("#"))
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("paths", nargs="+")
+    ap.add_argument("--json", dest="json_out")
+    ap.add_argument("--top", type=int, default=25)
+    ap.add_argument("--label", default="")
+    args = ap.parse_args()
+
+    files = collect(args.paths)
+    if not files:
+        print("no .qpa files found", file=sys.stderr)
+        return 2
+
+    # Later chunks may re-run a case; last result wins.
+    results = {}
+    for f in files:
+        for case, status in parse_qpa(f):
+            results[case] = status
+
+    # A case the runner saw take the process down is a Crash, not merely an
+    # unterminated log entry - but a real result from a later retry wins.
+    for case in load_sidecar(args.paths, "crashed.txt"):
+        if results.get(case, "Incomplete") == "Incomplete":
+            results[case] = "Crash"
+    # Worse than a crash: these rebooted the device.
+    for case in load_sidecar(args.paths, "hung.txt"):
+        if results.get(case, "Incomplete") in ("Incomplete", "Crash"):
+            results[case] = "DeviceHang"
+
+    # Cases excluded up front, and cases the run never reached, are not results.
+    # Report them separately so a partial run is never read as a complete one.
+    skipped = load_sidecar(args.paths, "skipped.txt")
+    unrun = load_sidecar(args.paths, "unrun.txt") - set(results)
+
+    counts = Counter(results.values())
+    total = len(results)
+    non_fail = sum(counts[s] for s in NON_FAILURE)
+    strict_pass = counts["Pass"]
+    failures = total - non_fail
+
+    by_group_fail = defaultdict(int)
+    by_group_total = defaultdict(int)
+    for case, status in results.items():
+        g = group_of(case)
+        by_group_total[g] += 1
+        if status not in NON_FAILURE:
+            by_group_fail[g] += 1
+
+    label = f" [{args.label}]" if args.label else ""
+    print(f"=== glcts conformance summary{label} ===")
+    print(f"files parsed      : {len(files)}")
+    print(f"cases with result : {total}")
+    print()
+    for status, n in counts.most_common():
+        mark = "   " if status in NON_FAILURE else " ! "
+        print(f"{mark}{status:<22} {n:>7}  {100.0 * n / total:6.2f}%")
+    print()
+    if total:
+        print(f"conformance pass rate (Pass+NotSupported+warnings) : {100.0 * non_fail / total:6.2f}%  ({non_fail}/{total})")
+        print(f"strict pass rate      (Pass only)                  : {100.0 * strict_pass / total:6.2f}%  ({strict_pass}/{total})")
+        print(f"failures                                           : {failures}")
+
+    if skipped or unrun:
+        print("\n--- NOT MEASURED (excluded from the rates above) ---")
+        if skipped:
+            print(f"  quarantined up front : {len(skipped)}")
+        if unrun:
+            print(f"  never reached        : {len(unrun)}")
+        print("  The rates above cover only cases that produced a result.")
+
+    if failures:
+        print(f"\n--- worst groups (of {len(by_group_total)}) ---")
+        worst = sorted(by_group_fail.items(), key=lambda kv: -kv[1])[: args.top]
+        for g, nf in worst:
+            nt = by_group_total[g]
+            print(f"  {g:<52} {nf:>6}/{nt:<6} fail  ({100.0 * nf / nt:5.1f}%)")
+
+    if args.json_out:
+        with open(args.json_out, "w", encoding="utf-8") as fh:
+            json.dump(
+                {
+                    "label": args.label,
+                    "files": len(files),
+                    "total": total,
+                    "counts": dict(counts),
+                    "non_failure": non_fail,
+                    "strict_pass": strict_pass,
+                    "failures": failures,
+                    "pass_rate": (non_fail / total) if total else 0.0,
+                    "strict_pass_rate": (strict_pass / total) if total else 0.0,
+                    "results": results,
+                },
+                fh,
+                indent=1,
+            )
+        print(f"\nwrote {args.json_out}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tools/cts/scripts/run_cts.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python
+"""Drive a glcts run on a device, resuming across crashes.
+
+MobileGL crashes on some cases, and glcts takes the whole process down with it.
+A single invocation would therefore stop at the first crash and leave most of
+the suite unmeasured. This runner re-invokes glcts with only the cases that have
+not produced a result yet, records each crashed case as "Crash", and repeats
+until the list is exhausted, so one bad case costs one case rather than the run.
+
+Usage:
+  python run_cts.py --serial <adb-serial> --backend DirectGLES|DirectVulkan \\
+      --caselist <host-path-to-mustpass.txt> --outdir <host-dir> [--device-dir /data/local/tmp/mgcts]
+"""
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+import time
+
+CASE_START = re.compile(r"^#beginTestCaseResult\s+(\S+)")
+CASE_END = re.compile(r"^#endTestCaseResult")
+CASE_TERM = re.compile(r"^#terminateTestCaseResult\s+(.*)")
+
+
+def adb(serial, *args, timeout=None):
+    try:
+        return subprocess.run(["adb", "-s", serial, *args], capture_output=True, text=True, timeout=timeout)
+    except subprocess.TimeoutExpired:
+        return subprocess.CompletedProcess(args, returncode=124, stdout="", stderr="adb timeout")
+
+
+def device_alive(serial, timeout=30):
+    """True only if the device answers a trivial shell command.
+
+    Distinguishes "glcts crashed" from "the device fell over". Without this a
+    dead device looks like every remaining case crashing, which silently turns a
+    broken run into a plausible-looking conformance number.
+    """
+    r = adb(serial, "shell", "echo alive", timeout=timeout)
+    return r.returncode == 0 and "alive" in (r.stdout or "")
+
+
+def wait_for_device(serial, attempts=20, delay=15):
+    for i in range(attempts):
+        if device_alive(serial):
+            return True
+        print(f"[run_cts] device {serial} unresponsive, waiting ({i + 1}/{attempts})")
+        time.sleep(delay)
+    return False
+
+
+def mem_available_kb(serial):
+    r = adb(serial, "shell", "grep MemAvailable /proc/meminfo", timeout=30)
+    m = re.search(r"(\d+)", r.stdout or "")
+    return int(m.group(1)) if m else None
+
+
+def completed_cases(qpa_path):
+    """Return (finished_case_names, last_started_case_or_None).
+
+    A case that was started but never closed is the one the process died in.
+    """
+    finished = []
+    current = None
+    if not os.path.exists(qpa_path):
+        return finished, None
+    with open(qpa_path, "r", encoding="utf-8", errors="replace") as fh:
+        for line in fh:
+            m = CASE_START.match(line)
+            if m:
+                current = m.group(1)
+                continue
+            if current is not None and (CASE_END.match(line) or CASE_TERM.match(line)):
+                finished.append(current)
+                current = None
+    return finished, current
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--serial", required=True)
+    ap.add_argument("--backend", required=True, choices=["DirectGLES", "DirectVulkan"])
+    ap.add_argument("--caselist", required=True)
+    ap.add_argument("--outdir", required=True)
+    ap.add_argument("--device-dir", default="/data/local/tmp/mgcts")
+    ap.add_argument("--surface", default="fbo", help="--deqp-surface-type value")
+    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("--min-mem-kb", type=int, default=400000,
+                    help="pause when the device drops below this much available memory")
+    ap.add_argument("--chunk-timeout", type=int, default=900,
+                    help="seconds before giving up on one glcts invocation (a GPU hang never returns)")
+    ap.add_argument("--skip-file", default=None,
+                    help="file of case names to exclude, e.g. cases known to hang the device")
+    ap.add_argument("--env", action="append", default=[], metavar="K=V",
+                    help="extra environment variable for glcts (repeatable)")
+    args = ap.parse_args()
+
+    os.makedirs(args.outdir, exist_ok=True)
+
+    with open(args.caselist, "r", encoding="utf-8") as fh:
+        remaining = [l.strip() for l in fh if l.strip() and not l.strip().startswith("#")]
+
+    skipped = []
+    if args.skip_file and os.path.isfile(args.skip_file):
+        with open(args.skip_file, "r", encoding="utf-8") as fh:
+            skip = {l.strip() for l in fh if l.strip() and not l.strip().startswith("#")}
+        skipped = [c for c in remaining if c in skip]
+        remaining = [c for c in remaining if c not in skip]
+        print(f"[run_cts] skipping {len(skipped)} case(s) from {args.skip_file}")
+
+    total = len(remaining)
+    print(f"[run_cts] {args.backend} on {args.serial}: {total} cases")
+
+    crashed = []
+    hung = []
+    done = set()
+    chunk = 0
+    started = time.time()
+    empty_streak = 0
+
+    if not wait_for_device(args.serial):
+        print("[run_cts] device not responding before start; aborting", file=sys.stderr)
+        return 3
+
+    while remaining and chunk < args.max_rounds:
+        listfile = os.path.join(args.outdir, "remaining.txt")
+        with open(listfile, "w", encoding="utf-8", newline="\n") as fh:
+            fh.write("\n".join(remaining) + "\n")
+
+        # Repeated process launches plus crash tombstones can drive the device
+        # into memory pressure; give it room rather than pushing it over.
+        mem = mem_available_kb(args.serial)
+        if mem is not None and mem < args.min_mem_kb:
+            print(f"[run_cts] low memory ({mem} kB available); pausing 30 s")
+            time.sleep(30)
+
+        dev_list = f"{args.device_dir}/remaining.txt"
+        dev_qpa = f"{args.device_dir}/chunk.qpa"
+        push = adb(args.serial, "push", listfile, dev_list, timeout=120)
+        if push.returncode != 0:
+            print(f"[run_cts] push failed ({push.stderr.strip()}); treating as device trouble",
+                  file=sys.stderr)
+            if not wait_for_device(args.serial):
+                print("[run_cts] ABORTING: device unreachable.", file=sys.stderr)
+                break
+            continue
+        adb(args.serial, "shell", f"rm -f {dev_qpa}", timeout=60)
+
+        extra_env = "".join(f"{kv} " for kv in args.env)
+        cmd = (
+            f"cd {args.device_dir} && "
+            f"MOBILEGL_BACKEND_TYPE={args.backend} LD_LIBRARY_PATH=. {extra_env}"
+            f"./glcts --deqp-caselist-file={dev_list} "
+            f"--deqp-surface-type={args.surface} "
+            f"--deqp-terminate-on-device-lost=disable "
+            f"--deqp-log-images=disable --deqp-log-shader-sources=disable "
+            f"--deqp-log-filename={dev_qpa} > /dev/null 2>&1; echo RC=$?"
+        )
+        run = adb(args.serial, "shell", cmd, timeout=args.chunk_timeout)
+        if run.returncode == 124:
+            print(f"[run_cts] chunk {chunk:04d} timed out after {args.chunk_timeout}s "
+                  f"(likely a GPU hang)", file=sys.stderr)
+
+        # Some cases hang the GPU hard enough to reboot the device. The log on
+        # /data/local/tmp survives that, so wait for the device to come back and
+        # pull it anyway rather than losing the whole chunk.
+        rebooted = False
+        if not device_alive(args.serial, timeout=30):
+            print(f"[run_cts] device went away during chunk {chunk:04d}; waiting for it",
+                  file=sys.stderr)
+            if not wait_for_device(args.serial, attempts=40, delay=15):
+                print("[run_cts] ABORTING: device never came back. Results are incomplete; "
+                      "do NOT treat the remaining cases as failures.", file=sys.stderr)
+                break
+            rebooted = True
+            print("[run_cts] device is back")
+
+        local_qpa = os.path.join(args.outdir, f"chunk{chunk:04d}.qpa")
+        pull = adb(args.serial, "pull", dev_qpa, local_qpa, timeout=300)
+        if pull.returncode != 0 and rebooted:
+            time.sleep(10)
+            adb(args.serial, "pull", dev_qpa, local_qpa, timeout=300)
+
+        finished, in_flight = completed_cases(local_qpa)
+        for c in finished:
+            done.add(c)
+
+        progressed = len(finished)
+        if progressed > 0:
+            empty_streak = 0
+        if in_flight is not None:
+            # The case that was open when the process (or the device) died.
+            if rebooted:
+                # It took the whole device down: quarantine it, or the next
+                # invocation walks straight back into it.
+                print(f"[run_cts] DEVICE HANG in {in_flight} - quarantining it")
+                hung.append(in_flight)
+            else:
+                crashed.append(in_flight)
+            done.add(in_flight)
+            progressed += 1
+        elif progressed == 0:
+            # Nothing at all came back. Either the first remaining case takes
+            # the process down before the log is flushed, or the device died.
+            # Those look identical from here, so confirm the device is alive
+            # before blaming the test.
+            if not device_alive(args.serial):
+                print(f"[run_cts] device went away during chunk {chunk:04d}", file=sys.stderr)
+                if not wait_for_device(args.serial):
+                    print("[run_cts] ABORTING: device never came back. Results are "
+                          "incomplete; do NOT treat the remaining cases as crashes.", file=sys.stderr)
+                    break
+                print("[run_cts] device recovered; retrying the same chunk")
+                continue
+
+            empty_streak += 1
+            if empty_streak >= args.max_empty_streak:
+                print(f"[run_cts] ABORTING: {empty_streak} consecutive chunks produced no output "
+                      f"while the device stayed reachable. Something systemic is wrong; refusing "
+                      f"to label the rest of the suite as crashes.", file=sys.stderr)
+                break
+
+            victim = remaining[0]
+            print(f"[run_cts] no output at all; recording {victim} as Crash")
+            crashed.append(victim)
+            done.add(victim)
+            progressed = 1
+
+        remaining = [c for c in remaining if c not in done]
+        elapsed = time.time() - started
+        print(
+            f"[run_cts] chunk {chunk:04d}: +{progressed} (done {len(done)}/{total}, "
+            f"crashes {len(crashed)}, {elapsed / 60:.1f} min)"
+        )
+        chunk += 1
+
+    with open(os.path.join(args.outdir, "crashed.txt"), "w", encoding="utf-8", newline="\n") as fh:
+        fh.write("\n".join(crashed) + ("\n" if crashed else ""))
+
+    # Cases that rebooted the device. Feed this back in via --skip-file to avoid
+    # paying for the same reboot on the next run.
+    with open(os.path.join(args.outdir, "hung.txt"), "w", encoding="utf-8", newline="\n") as fh:
+        fh.write("\n".join(hung) + ("\n" if hung else ""))
+    if hung:
+        print(f"[run_cts] {len(hung)} case(s) hung the device (see hung.txt):")
+        for c in hung:
+            print(f"    {c}")
+
+    # Anything still in `remaining` was never measured. Record it so the report
+    # cannot quietly present a partial run as a complete one.
+    with open(os.path.join(args.outdir, "unrun.txt"), "w", encoding="utf-8", newline="\n") as fh:
+        fh.write("\n".join(remaining) + ("\n" if remaining else ""))
+    if skipped:
+        with open(os.path.join(args.outdir, "skipped.txt"), "w", encoding="utf-8", newline="\n") as fh:
+            fh.write("\n".join(skipped) + "\n")
+
+    if remaining:
+        print(f"[run_cts] WARNING: {len(remaining)} cases were never run (see unrun.txt)", file=sys.stderr)
+    print(f"[run_cts] finished: {len(done)}/{total} cases, {len(crashed)} crashes, {chunk} invocations")
+    print(f"[run_cts] qpa chunks in {args.outdir}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tools/cts/scripts/sync_to_cts.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+"""Copy the MobileGL dEQP platform port into a VK-GL-CTS checkout.
+
+The port is version-controlled here, in the MobileGL repo, so it survives a
+throwaway CTS clone. This drops it into the places VK-GL-CTS expects:
+
+    framework/platform/mobilegl/     <- platform sources
+    targets/mobilegl/mobilegl.cmake  <- target definition (-DDEQP_TARGET=mobilegl)
+
+Usage:
+    python sync_to_cts.py <path-to-VK-GL-CTS>
+"""
+
+import os
+import shutil
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+CTS_TOOLS = os.path.dirname(HERE)
+
+COPIES = [
+    (os.path.join(CTS_TOOLS, "platform"), "framework/platform/mobilegl", None),
+    (os.path.join(CTS_TOOLS, "targets"), "targets/mobilegl", ["mobilegl.cmake", "ndk-modern.cmake"]),
+]
+
+
+def main():
+    if len(sys.argv) != 2:
+        print(__doc__)
+        return 2
+    cts = sys.argv[1]
+    if not os.path.isfile(os.path.join(cts, "CMakeLists.txt")):
+        print(f"error: {cts} does not look like a VK-GL-CTS checkout", file=sys.stderr)
+        return 1
+
+    for src, reldst, only in COPIES:
+        dst = os.path.join(cts, reldst)
+        os.makedirs(dst, exist_ok=True)
+        for name in sorted(os.listdir(src)):
+            if only is not None and name not in only:
+                continue
+            s = os.path.join(src, name)
+            if not os.path.isfile(s):
+                continue
+            shutil.copy2(s, os.path.join(dst, name))
+            print(f"  {reldst}/{name}")
+
+    print("\nsynced. configure with -DDEQP_TARGET=mobilegl")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tools/cts/skills/README.md

@@ -0,0 +1,18 @@
+# MobileGL conformance-suite skills
+
+Task-focused skills for running Khronos conformance suites against MobileGL.
+Each skill is a self-contained package, matching the layout used by
+`tools/trace_replay/skills/`:
+
+- `SKILL.md` — the skill (frontmatter `name` + `description`, then the body). The
+  directory name equals the frontmatter `name`.
+- `agents/openai.yaml` — OpenAI agent descriptor (`display_name`,
+  `short_description`, `default_prompt`).
+- `scripts/` and/or `references/` — bundled tooling and supporting docs, when the
+  skill has them.
+
+## Skills
+
+| Skill | What it does |
+| --- | --- |
+| [gl-cts-on-mobilegl](gl-cts-on-mobilegl/SKILL.md) | Build VK-GL-CTS `glcts` as a standalone Android arm64 binary against MobileGL's own EGL, run KHR-GL33, and report a per-backend OpenGL 3.3 core conformance rate. |

tools/cts/skills/gl-cts-on-mobilegl/SKILL.md

@@ -0,0 +1,214 @@
+---
+name: gl-cts-on-mobilegl
+description: Run the Khronos OpenGL CTS (VK-GL-CTS glcts, KHR-GL33) against MobileGL on an Android device and compute a per-backend conformance rate. Use when measuring OpenGL 3.3 core conformance for DirectGLES or DirectVulkan, building glcts for Android arm64, porting a dEQP tcu::Platform onto MobileGL, or triaging CTS failures, crashes, and cases that hang the device.
+---
+
+# OpenGL CTS on MobileGL (Android)
+
+## Overview
+
+`glcts` from VK-GL-CTS is built as a **standalone arm64 executable** and run from
+`adb shell`. It reaches OpenGL only through `libMobileGL.so`, which supplies both
+EGL and desktop GL, so a result is unambiguously MobileGL's and never the system
+GL stack's. No APK and no Activity are involved.
+
+The port lives in this repository under `MobileGL/tools/cts/` and is copied into
+a VK-GL-CTS checkout by `scripts/sync_to_cts.py`, so it survives a throwaway CTS
+clone.
+
+Set up paths first:
+
+```sh
+export MG=<path-to-MobileGL-worktree>          # do builds in a worktree, not the shared tree
+export CTS=<path-to-VK-GL-CTS-checkout>
+export NDK="$ANDROID_HOME/ndk/27.3.13750724"
+export SERIAL=<adb-device-serial>
+```
+
+## Prerequisites
+
+- Android NDK r27 (the repo builds MobileGL with 27.3.13750724), CMake, Ninja, Python 3.
+- A rooted-or-not Android device with `adb`; ~600 MB free under `/data/local/tmp`.
+- **A device you can physically power-cycle.** Some cases hang the GPU hard
+  enough to reboot it — see "Cases that take the device down".
+- On Windows, invoke `python`, not `python3`: the latter resolves to the
+  Microsoft Store alias stub and exits 49.
+
+## Step 1 — build libMobileGL.so
+
+Build in a git worktree (other agents share the main tree). A fresh worktree is
+missing glslang's bundled SPIR-V Tools, which is a hard configure blocker
+because `ENABLE_OPT` is forced on:
+
+```sh
+cp -r <main-tree>/3rdparty/glslang/External/* "$MG/3rdparty/glslang/External/"
+./gradlew -p "$MG/android-plugin" :app:assembleTraceRelease
+```
+
+The stripped library lands in
+`android-plugin/app/build/intermediates/stripped_native_libs/traceRelease/.../arm64-v8a/libMobileGL.so`.
+
+## Step 2 — get VK-GL-CTS and its externals
+
+Use a **release tag**, not `main`, so the mustpass list — and therefore the
+reported rate — is citable:
+
+```sh
+git -C "$CTS" checkout opengl-cts-4.6.8.1
+cd "$CTS" && python external/fetch_sources.py
+```
+
+## Step 3 — build glcts for Android arm64
+
+```sh
+python "$MG/tools/cts/scripts/sync_to_cts.py" "$CTS"
+
+cmake -S "$CTS" -B build-cts-a64 -G Ninja \
+  -DDEQP_TARGET=mobilegl -DDEQP_TARGET_TOOLCHAIN=ndk-modern \
+  -DANDROID_NDK_PATH="$NDK" -DDE_ANDROID_API=26 -DANDROID_ABI=arm64-v8a \
+  -DCMAKE_BUILD_TYPE=Release
+ninja -C build-cts-a64 glcts
+"$NDK"/toolchains/llvm/prebuilt/*/bin/llvm-strip build-cts-a64/external/openglcts/modules/glcts
+```
+
+Confirm the configure output says `DE_OS = DE_OS_ANDROID`, `DE_CPU =
+DE_CPU_ARM_64` and `DEQP_ANDROID_BUILD = EXE`. Two things make that work and
+both are easy to get wrong:
+
+- `DEQP_TARGET_TOOLCHAIN=ndk-modern` is required. dEQP includes `Defs.cmake`
+  *before* the target file, so a target cannot set `DE_OS` itself. Without the
+  toolchain hook the build mis-detects as `DE_OS_UNIX`/`x86_64` and dies on
+  `__assert_fail` (bionic has `__assert2`).
+- The target sets `DEQP_ANDROID_EXE ON`. Otherwise dEQP builds the modules into
+  the `libdeqp.so` an APK would load and no `glcts` executable exists.
+
+`KHR-GL33` needs no ungating — the package registry registers it unconditionally;
+only the `dEQP-*` packages are `#if DE_OS != DE_OS_ANDROID`.
+
+## Step 4 — deploy
+
+```sh
+adb -s $SERIAL shell mkdir -p /data/local/tmp/mgcts
+adb -s $SERIAL push build-cts-a64/external/openglcts/modules/glcts /data/local/tmp/mgcts/
+adb -s $SERIAL push build-cts-a64/external/openglcts/modules/gl_cts /data/local/tmp/mgcts/
+adb -s $SERIAL push <libMobileGL.so> /data/local/tmp/mgcts/
+adb -s $SERIAL shell chmod 755 /data/local/tmp/mgcts/glcts
+```
+
+## Step 5 — preflight
+
+Never start a multi-hour run without this. It proves the device/library pair
+yields a 3.3 core context and that FBO readback is correct, in about a second:
+
+```sh
+adb -s $SERIAL shell 'cd /data/local/tmp/mgcts && LD_LIBRARY_PATH=. ./mgprobe \
+    --backend DirectVulkan --surface imagereader --lib ./libMobileGL.so'
+```
+
+Expect `PASS ... user_fbo=ok`. `default_fb=broken` on DirectVulkan is expected
+and does not gate — see below.
+
+## Step 6 — run
+
+```sh
+python "$MG/tools/cts/scripts/run_cts.py" \
+    --serial $SERIAL --backend DirectGLES \
+    --caselist .../mustpass/gl/khronos_mustpass/main/gl33-main.txt \
+    --outdir runs/gles --skip-file runs/skip.txt
+```
+
+The runner re-invokes `glcts` with only the cases that have no result yet, so a
+crash costs one case rather than the run. It distinguishes a crashed *case* from
+a dead *device* by checking the device still answers a shell command — without
+that check a dead device looks like every remaining case crashing, which yields
+a completely bogus but plausible-looking conformance number. On a device reboot
+it waits, re-pulls the partial `.qpa` (which survives on `/data/local/tmp`),
+records the case that was open as `DeviceHang`, and quarantines it.
+
+## Step 7 — report
+
+```sh
+python "$MG/tools/cts/scripts/qpa_report.py" runs/gles --label DirectGLES
+```
+
+Pass rate counts `Pass`, `NotSupported`, `QualityWarning`, `CompatibilityWarning`
+and `Waiver` as non-failures, matching how Khronos scores a submission; the
+strict rate counts only `Pass`. Quarantined and never-reached cases are reported
+separately and excluded from the rates, so a partial run cannot read as a
+complete one.
+
+## Required flags, and why
+
+| Flag | Why it is not optional |
+| --- | --- |
+| `--deqp-surface-type=fbo` | On DirectVulkan, `glReadPixels` from the **default framebuffer returns all zeros** with no GL error. dEQP verifies nearly everything through `glReadPixels`, so rendering to the surface scores DirectVulkan near zero for a reason unrelated to conformance. Use it for **both** backends so the two numbers stay comparable. |
+| `MOBILEGL_CTS_FBO_COLOR_TEXTURE=1` | **`--deqp-surface-type=fbo` alone is not enough.** dEQP's `FboRenderContext` allocates a *renderbuffer* colour attachment, and DirectVulkan returns zeros from a renderbuffer-attached FBO too — only a *texture*-attached FBO reads back correctly. This env var (a patch to `framework/opengl/gluFboRenderContext.cpp`, off by default) switches the attachment to a texture and isolates that single defect. Measured effect: `KHR-GL33.shaders.loops.for_constant_iterations.*` goes 0/62 → 62/62, and the whole-suite DirectVulkan conformance rate goes 46.15% → 72.74%. DirectGLES is bit-identical either way (93.05%), which is the control proving the switch is neutral where readback works. |
+| `--deqp-terminate-on-device-lost=disable` | Defaults to *enable*, which calls `glGetGraphicsResetStatus()` after every case. That is GL 4.5 / `KHR_robustness`, absent from GL 3.3 core, so the pointer is null and the process segfaults on the first case. Desktop drivers expose the extension, which is why upstream never trips on it. |
+
+## Cases that take the device down
+
+Some cases hang the GPU hard enough that the device reboots or stops answering
+adb entirely. Keep them in a `--skip-file`, and expect to find more:
+
+- `KHR-GL33.clip_distance.functional` — wedged an Adreno 750 tablet; it rebooted
+  and then stopped responding to adb altogether.
+- `KHR-GL33.framebuffer_blit.multisampled_to_singlesampled_blit_color_config_test`
+  — rebooted an Adreno 830 phone after 862 cases, on DirectGLES.
+- `KHR-GL33.framebuffer_blit.multisampled_to_singlesampled_blit_depth_config_test`
+  — same, on both backends (found and quarantined automatically by the runner).
+- `KHR-GL33.texture_repeat_mode.rgb565_11x131_0_clamp_to_edge` — on DirectVulkan.
+
+The whole `framebuffer_blit.multisampled_to_singlesampled_*` family is suspect;
+treat a new variant as a device-hang candidate rather than a normal failure.
+
+When a run dies, pull `/data/local/tmp/mgcts/chunk.qpa` — it survives the reboot,
+and the last `#beginTestCaseResult` with no matching `#endTestCaseResult` names
+the case that did it.
+
+## Reference results
+
+`opengl-cts-4.6.8.1`, KHR-GL33 mustpass (`gl33-main.txt`, 9886 cases), Adreno 830
+/ Android 15, MobileGL `dev`@199164c2, 9884 measured / 0 unrun / 2 quarantined.
+Conformance rate = Pass + NotSupported, as Khronos scores a submission.
+
+| backend | conformance | strict Pass | Fail | Crash | InternalError | DeviceHang |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| DirectGLES | **93.05%** | 85.94% | 679 | 1 | 6 | 1 |
+| DirectVulkan (texture FBO) | **72.74%** | 65.71% | 2394 | 294 | 5 | 1 |
+| DirectVulkan (stock renderbuffer FBO) | 46.15% | 39.11% | 5024 | 292 | 5 | 2 |
+
+The third row is what stock dEQP reports; the gap to the second row is entirely
+the renderbuffer-FBO readback defect.
+
+## MobileGL constraints the port works around
+
+- **DirectVulkan cannot use an EGL pbuffer.** That path needs
+  `VK_EXT_headless_surface`, which Adreno's Android driver does not expose; it
+  fails inside `eglMakeCurrent`. The platform therefore gets a real
+  `ANativeWindow` from **`AImageReader`** — an ordinary BufferQueue producer that
+  `vkCreateAndroidSurfaceKHR` accepts, with no Activity. An `onImageAvailable`
+  listener must drain the queue or the producer blocks once `maxImages` buffers
+  are in flight and the next swap deadlocks.
+- **`eglMakeCurrent` requires draw == read** and rejects `EGL_NO_SURFACE` with
+  `EGL_BAD_MATCH`, so dEQP's `surfaceless` platform cannot be used at all, and
+  `--deqp-surface-type=fbo` (which asks the platform for `SURFACETYPE_DONT_CARE`)
+  must still be given a real surface.
+- **Every EGL call must go through the dynamically loaded library.** dEQP's
+  `surfaceless` platform mixes wrapper calls with globally linked `egl*` symbols;
+  copying that on Android silently reaches the system EGL and invalidates the
+  measurement. The `mobilegl` target links no `libEGL`/`libGLESv*` at all.
+- **Desktop-GL configs need `EGL_OPENGL_BIT`.** The surfaceless port always asks
+  for an ES bit, which can never satisfy a GL 3.3 core context.
+- MobileGL aborts during static teardown (`FORTIFY: pthread_mutex_lock called on
+  a destroyed mutex`) *after* the work is done; flush and `_exit()` in any small
+  tool, or its exit code and output are lost.
+
+## Contents
+
+    platform/tcuMobileGLPlatform.{cpp,hpp}   dEQP tcu::Platform for MobileGL
+    targets/mobilegl.cmake                   VK-GL-CTS target (-DDEQP_TARGET=mobilegl)
+    targets/ndk-modern.cmake                 NDK toolchain hook (sets DE_OS/DE_CPU)
+    probe/mgprobe.c                          preflight gate
+    scripts/sync_to_cts.py                   inject the port into a CTS checkout
+    scripts/run_cts.py                       crash- and reboot-resuming runner
+    scripts/qpa_report.py                    .qpa -> conformance rate

tools/cts/skills/gl-cts-on-mobilegl/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "OpenGL CTS on MobileGL (Android)"
+  short_description: "Build and run VK-GL-CTS KHR-GL33 against MobileGL and report per-backend conformance"
+  default_prompt: "Use $gl-cts-on-mobilegl to run the OpenGL 3.3 core CTS against MobileGL on my Android device and report the conformance rate for DirectGLES and DirectVulkan."

tools/cts/targets/mobilegl.cmake

@@ -0,0 +1,36 @@
+#-------------------------------------------------------------------------
+# VK-GL-CTS target: MobileGL on Android
+#
+# Builds a standalone arm64 ELF that reaches OpenGL exclusively through
+# libMobileGL.so, loaded at runtime. Nothing here links libEGL or libGLESv*:
+# the whole point is that the system GL stack must not be reachable, so that a
+# conformance result is unambiguously MobileGL's.
+#-------------------------------------------------------------------------
+
+message("*** Using MobileGL target")
+
+set(DEQP_TARGET_NAME "MobileGL")
+
+# Build the modules as standalone executables instead of the libdeqp.so an APK
+# would load. The suite runs from adb shell, with no Activity.
+set(DEQP_ANDROID_EXE ON)
+
+# EGL comes from libMobileGL.so via the eglw dynamic wrapper, so the support
+# flag is on but no import library is supplied.
+set(DEQP_SUPPORT_EGL ON)
+set(DEQP_EGL_LIBRARIES)
+set(DEQP_GLES2_LIBRARIES)
+set(DEQP_GLES3_LIBRARIES)
+
+set(TCUTIL_PLATFORM_SRCS
+	mobilegl/tcuMobileGLPlatform.cpp
+	mobilegl/tcuMobileGLPlatform.hpp
+	)
+
+find_library(LOG_LIBRARY NAMES log)
+find_library(ANDROID_LIBRARY NAMES android)
+find_library(MEDIANDK_LIBRARY NAMES mediandk)
+
+# libmediandk supplies AImageReader, which is how a process with no Activity
+# gets a real ANativeWindow.
+list(APPEND TCUTIL_PLATFORM_LIBS ${ANDROID_LIBRARY} ${MEDIANDK_LIBRARY} ${LOG_LIBRARY})

tools/cts/targets/ndk-modern.cmake

@@ -0,0 +1,61 @@
+#-------------------------------------------------------------------------
+# drawElements CMake utilities
+# ----------------------------
+#
+# Copyright 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#-------------------------------------------------------------------------
+
+# Delegate most things to the NDK's cmake toolchain script
+
+if (NOT DEFINED ANDROID_NDK_PATH)
+	message(FATAL_ERROR "Please provide ANDROID_NDK_PATH")
+endif ()
+
+set(ANDROID_PLATFORM "android-${DE_ANDROID_API}")
+set(ANDROID_STL c++_static)
+set(ANDROID_CPP_FEATURES "rtti exceptions")
+
+include(${ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake)
+
+# The try_compile() used to verify the C/C++ compilers are sane tries to
+# generate an executable, but doesn't seem to use the right compiler/linker
+# options when cross-compiling, so it fails even when building an actual
+# shared library or executable succeeds.
+#
+# I don't know why this doesn't affect simpler projects that use the NDK
+# toolchain.
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+# Set variables used by other parts of dEQP's build scripts
+
+set(DE_OS "DE_OS_ANDROID")
+
+if (NOT DEFINED DE_COMPILER)
+	set(DE_COMPILER	"DE_COMPILER_CLANG")
+endif ()
+
+if (ANDROID_ABI STREQUAL "x86")
+	set(DE_CPU "DE_CPU_X86")
+elseif (ANDROID_ABI STREQUAL "armeabi" OR
+		ANDROID_ABI STREQUAL "armeabi-v7a")
+	set(DE_CPU "DE_CPU_ARM")
+elseif (ANDROID_ABI STREQUAL "arm64-v8a")
+	set(DE_CPU "DE_CPU_ARM_64")
+elseif (ANDROID_ABI STREQUAL "x86_64")
+	set(DE_CPU "DE_CPU_X86_64")
+else ()
+	message(FATAL_ERROR "Unknown ABI \"${ANDROID_ABI}\"")
+endif ()