[Chore] (Version): bump version to 26.8 for android plugin

DirectGLES never registered BeginOcclusionQuery/EndOcclusionQuery, so
the frontend rejected the occlusion query targets entirely; the CTS
tests that use them (e.g. packed_depth_stencil.verify_partial/mixed_
attachments) left a stray GL_INVALID_ENUM that a later, unrelated
glGetError() check would report as its own failure
("Uploading buffer data failed" at gluDrawUtil.cpp:363).

Occlusion queries are core ES3 (glGenQueries/glBeginQuery(GL_ANY_
SAMPLES_PASSED, ...)/glEndQuery/glGetQueryObjectuiv), unlike the timer
queries which need GL_EXT_disjoint_timer_query, so they're wired up
unconditionally (independent of MOBILEGL_DISABLE_TIMERQUERY) using the
same handle-based GetQueryResult64/DeleteBackendQuery plumbing already
shared with timer queries. GetQueryResult64 now reads the 0/1 result
through the core 32-bit glGetQueryObjectuiv getter for occlusion
handles instead of the timer-only 64-bit GL_EXT_disjoint_timer_query
getter, since a driver can fully support core occlusion queries while
lacking that extension entirely.

.gitignore

@@ -25,3 +25,5 @@ MobileGL/MG*/cmake-build*
 /android-plugin/app/src/trace/jniLibs
 /android-plugin/local.properties
 tools/trace_replay/work/
+__pycache__/
+*.py[cod]

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/Config.h

@@ -14,7 +14,7 @@ namespace MobileGL::MG_Config {
     inline const String ProjectName = "MobileGL";
     inline const String CoreName = "MobileGL Core";
     inline const String CoreVendor = "MobileGL-Dev (BZLZHH, Swung0x48, Tungsten)";
-    inline const Version CoreVersion = {26, 7, 0, "-dev", VersionType::Development};
+    inline const Version CoreVersion = {26, 8, 0, "-dev", VersionType::Development};
     inline const VersionStringFormatAttrib DefaultVersionStringFormatAttrib = {2, 2, 0, true, true};
     inline const Uint64 CacheVersion = 0;
 

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/BackendObject.h

@@ -220,6 +220,15 @@ namespace MobileGL {
             // and leave the query readable later.
             Bool (*GetQueryResult64)(BackendQueryHandle query, Bool wait, Uint64* outNanoseconds);
             void (*DeleteBackendQuery)(BackendQueryHandle query);
+            // GL_SAMPLES_PASSED occlusion queries (optional; null = unsupported,
+            // the frontend then rejects the target). Results/deletion flow through
+            // GetQueryResult64 / DeleteBackendQuery like timer queries.
+            BackendQueryHandle (*BeginOcclusionQuery)();
+            void (*EndOcclusionQuery)(BackendQueryHandle query);
+            // Transform feedback primitive queries backed by real GPU query pools
+            // (optional; null = frontend falls back to CPU accounting).
+            BackendQueryHandle (*BeginXfbPrimitivesQuery)(Bool generated);
+            void (*EndXfbPrimitivesQuery)(BackendQueryHandle query);
             Int64 (*GetGpuTimestampNs)(); // glGetInteger64v(GL_TIMESTAMP); 0 if unsupported
         };
         struct GlobalBackendFunctionsTable {
@@ -300,6 +309,13 @@ namespace MobileGL {
             Float ViewportBoundsRangeMin = 0.0f;
             Float ViewportBoundsRangeMax = 0.0f;
             Int ViewportSubpixelBits = 0;
+            // GL 4.x fragment-interpolation offset limits. These defaults are the
+            // core minimums and are replaced by live GLES/Vulkan device limits.
+            Float MinFragmentInterpolationOffset = -0.5f;
+            // For four fractional bits the greatest required legal offset is
+            // 0.5 - 2^-4 = 0.4375 (GL 4.6 table 23.70).
+            Float MaxFragmentInterpolationOffset = 0.4375f;
+            Int FragmentInterpolationOffsetBits = 4;
             Bool SupportsWideLines = false;
             SizeT MaxShaderStorageBlockSize = 128 * 1024 * 1024;
             Uint32 SubgroupSize = 0;

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp

@@ -20,6 +20,7 @@
 #include <MG_Util/Texture/TextureFormatProcessor.h>
 #include <Config.h>
 #include <algorithm>
+#include <cmath>
 #include <format>
 
 namespace MobileGL::MG_Backend::DirectGLES {
@@ -603,7 +604,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 .ExtraVendor = Nullopt,              // Extra vendor
                 .RendererGLInfo =
                     {
-                        .TargetGLVersion = {3, 3, 0},   // Target OpenGL Version
+                        .TargetGLVersion = {3, 3, 0},   // GL target version
                         .TargetGLSLVersion = {4, 6, 0}, // Target Shading Language Version
                         // Baseline advertisement (no timer queries / anisotropy yet); reconciled
                         // once the ES capabilities exist, see UpdateAdvertisedCapabilityExtensions.
@@ -934,11 +935,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 funcsTable.GL.BeginTimeElapsedQuery = BeginTimeElapsedQuery;
                 funcsTable.GL.EndTimeElapsedQuery = EndTimeElapsedQuery;
                 funcsTable.GL.QueryCounterTimestamp = QueryCounterTimestamp;
-                funcsTable.GL.IsQueryResultAvailable = IsQueryResultAvailable;
-                funcsTable.GL.GetQueryResult64 = GetQueryResult64;
-                funcsTable.GL.DeleteBackendQuery = DeleteBackendQuery;
                 funcsTable.GL.GetGpuTimestampNs = GetGpuTimestampNs;
             }
+            // Occlusion queries are core ES3 (independent of MOBILEGL_DISABLE_TIMERQUERY)
+            // and share the handle-based result/delete entries, which must exist even
+            // when the timer-query group above is disabled.
+            funcsTable.GL.BeginOcclusionQuery = BeginOcclusionQuery;
+            funcsTable.GL.EndOcclusionQuery = EndOcclusionQuery;
+            funcsTable.GL.IsQueryResultAvailable = IsQueryResultAvailable;
+            funcsTable.GL.GetQueryResult64 = GetQueryResult64;
+            funcsTable.GL.DeleteBackendQuery = DeleteBackendQuery;
             funcsTableInitialized = true;
         }
         return funcsTable;
@@ -1034,6 +1040,24 @@ namespace MobileGL::MG_Backend::DirectGLES {
         m_dynamicParameters.ViewportBoundsRangeMin = m_GLESCapabilities.ViewportBoundsRangeMin;
         m_dynamicParameters.ViewportBoundsRangeMax = m_GLESCapabilities.ViewportBoundsRangeMax;
         m_dynamicParameters.ViewportSubpixelBits = m_GLESCapabilities.ViewportSubpixelBits;
+        m_dynamicParameters.MinFragmentInterpolationOffset =
+            std::isfinite(m_GLESCapabilities.MinFragmentInterpolationOffset) &&
+                    m_GLESCapabilities.MinFragmentInterpolationOffset <= -0.5f
+                ? m_GLESCapabilities.MinFragmentInterpolationOffset
+                : -0.5f;
+        m_dynamicParameters.MaxFragmentInterpolationOffset = 0.4375f;
+        m_dynamicParameters.FragmentInterpolationOffsetBits = 4;
+        if (m_GLESCapabilities.FragmentInterpolationOffsetBits >= 4 &&
+            std::isfinite(m_GLESCapabilities.MaxFragmentInterpolationOffset)) {
+            const Float requiredMaxOffset =
+                0.5f - std::ldexp(1.0f, -m_GLESCapabilities.FragmentInterpolationOffsetBits);
+            if (m_GLESCapabilities.MaxFragmentInterpolationOffset >= requiredMaxOffset) {
+                m_dynamicParameters.MaxFragmentInterpolationOffset =
+                    m_GLESCapabilities.MaxFragmentInterpolationOffset;
+                m_dynamicParameters.FragmentInterpolationOffsetBits =
+                    m_GLESCapabilities.FragmentInterpolationOffsetBits;
+            }
+        }
         m_dynamicParameters.SupportsWideLines =
             m_GLESCapabilities.AliasedLineWidthRangeMax > 1.0f || m_GLESCapabilities.SmoothLineWidthRangeMax > 1.0f;
 

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;
         }
@@ -3716,12 +3632,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
     static Bool IsLegacyNativeReadPixelsFormat(GLenum format) {
         return format == GL_RGBA || format == GL_RGBA_INTEGER || format == GL_RED || format == GL_RED_INTEGER ||
-               format == GL_DEPTH_COMPONENT || format == GL_STENCIL_INDEX;
+               format == GL_DEPTH_COMPONENT || format == GL_STENCIL_INDEX || format == GL_DEPTH_STENCIL;
     }
 
     static Bool IsLegacyNativeReadPixelsType(GLenum type) {
+        // GL_UNSIGNED_INT_24_8 / GL_FLOAT_32_UNSIGNED_INT_24_8_REV are only ever valid
+        // paired with GL_DEPTH_STENCIL (packed_depth_stencil.verify_read_pixels); the real
+        // driver already implements this readback natively.
         return type == GL_UNSIGNED_BYTE || type == GL_UNSIGNED_INT || type == GL_UNSIGNED_INT_2_10_10_10_REV ||
-               type == GL_INT || type == GL_FLOAT;
+               type == GL_INT || type == GL_FLOAT || type == GL_UNSIGNED_INT_24_8 ||
+               type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV;
     }
 
     void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) {
@@ -3866,6 +3786,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
         if (format == GL_RGBA_INTEGER) {
             return type == GL_INT || type == GL_UNSIGNED_INT || type == GL_UNSIGNED_INT_2_10_10_10_REV;
         }
+        if (format == GL_DEPTH_STENCIL) {
+            return type == GL_UNSIGNED_INT_24_8 || type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV;
+        }
         return false;
     }
 
@@ -3934,7 +3857,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
         MGLOG_D("GetTexImage: attaching level %d to the scratch FBO", level);
         const GLenum backendAttachTarget = TextureImpl::ConvertTextureUploadTargetToBackendGLEnum(
             MG_Util::ConvertGLEnumToTextureUploadTarget(target));
-        if (backendAttachTarget == GL_TEXTURE_3D || backendAttachTarget == GL_TEXTURE_2D_ARRAY) {
+        // GL_DEPTH_STENCIL can't be attached as a color attachment (glCheckFramebufferStatus
+        // would report it incomplete); it has its own combined depth+stencil attachment point.
+        // glReadBuffer only selects among color attachments, so it does not apply here.
+        if (format == GL_DEPTH_STENCIL) {
+            ScratchFBOImpl::EnsureDepthAttachment2D(
+                tempFB, GL_READ_FRAMEBUFFER, backendTexId,
+                backendAttachTarget == GL_UNKNOWN_MGL ? target : backendAttachTarget, level, /*withStencil=*/true);
+        } else if (backendAttachTarget == GL_TEXTURE_3D || backendAttachTarget == GL_TEXTURE_2D_ARRAY) {
             // ES cannot attach 3D/array textures through glFramebufferTexture2D; read layer 0. Reads
             // of deeper slices are served from the CPU shadow instead (see the shadow-first branch).
             ScratchFBOImpl::EnsureColorAttachmentLayer(tempFB, GL_READ_FRAMEBUFFER, backendTexId, level, 0);
@@ -3943,8 +3873,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 tempFB, GL_READ_FRAMEBUFFER, backendTexId,
                 backendAttachTarget == GL_UNKNOWN_MGL ? target : backendAttachTarget, level);
         }
-        MGLOG_D("GetTexImage: glReadBuffer(GL_COLOR_ATTACHMENT0)");
-        ScratchFBOImpl::EnsureReadBuffer(tempFB, GL_COLOR_ATTACHMENT0);
+        if (format != GL_DEPTH_STENCIL) {
+            MGLOG_D("GetTexImage: glReadBuffer(GL_COLOR_ATTACHMENT0)");
+            ScratchFBOImpl::EnsureReadBuffer(tempFB, GL_COLOR_ATTACHMENT0);
+        }
 
         GLenum fbStatus = g_GLESFuncs.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
         MGLOG_D("GetTexImage: GL_READ_FRAMEBUFFER status = %s", MG_Util::ConvertGLEnumToString(fbStatus).c_str());
@@ -4428,6 +4360,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
         struct GLESQueryObject {
             GLuint queryId = 0;
             Uint contextGeneration = 0;
+            // GL_ANY_SAMPLES_PASSED result is 0/1 and only ever reachable through the
+            // core (non-extension) glGetQueryObjectuiv getter - GL_EXT_disjoint_timer_query's
+            // 64-bit glGetQueryObjectui64vEXT is timer-specific and may be entirely absent
+            // on drivers that otherwise fully support core ES3 occlusion queries.
+            Bool isOcclusion = false;
         };
     }
 
@@ -4620,6 +4557,38 @@ namespace MobileGL::MG_Backend::DirectGLES {
         return new GLESQueryObject{queryId, g_syncContextGeneration};
     }
 
+    // GL_SAMPLES_PASSED/GL_ANY_SAMPLES_PASSED(_CONSERVATIVE) occlusion queries. Unlike the
+    // timer queries above, these are core ES 3.0 (no GL_EXT_disjoint_timer_query needed).
+    Bool AreOcclusionQueriesSupported() {
+        return g_GLESFuncs.glGenQueries && g_GLESFuncs.glDeleteQueries && g_GLESFuncs.glBeginQuery &&
+               g_GLESFuncs.glEndQuery && g_GLESFuncs.glGetQueryObjectuiv;
+    }
+
+    BackendQueryHandle BeginOcclusionQuery() {
+        if (!IsBackendContextCurrentOnThisThread() || !AreOcclusionQueriesSupported()) {
+            return nullptr;
+        }
+        GLuint queryId = 0;
+        g_GLESFuncs.glGenQueries(1, &queryId);
+        if (queryId == 0) {
+            return nullptr;
+        }
+        // ES only implements the boolean ANY_SAMPLES_PASSED variant, not an exact
+        // GL_SAMPLES_PASSED count; the frontend already coerces ANY_SAMPLES_PASSED*
+        // targets to boolean, and desktop GL_SAMPLES_PASSED reads a 0/1 approximation.
+        g_GLESFuncs.glBeginQuery(GL_ANY_SAMPLES_PASSED, queryId);
+        return new GLESQueryObject{queryId, g_syncContextGeneration, /*isOcclusion=*/true};
+    }
+
+    void EndOcclusionQuery(BackendQueryHandle handle) {
+        const auto* query = static_cast<GLESQueryObject*>(handle);
+        if (query == nullptr || query->contextGeneration != g_syncContextGeneration ||
+            !IsBackendContextCurrentOnThisThread() || !g_GLESFuncs.glEndQuery) {
+            return;
+        }
+        g_GLESFuncs.glEndQuery(GL_ANY_SAMPLES_PASSED);
+    }
+
     Bool IsQueryResultAvailable(BackendQueryHandle handle) {
         const auto* query = static_cast<GLESQueryObject*>(handle);
         // Null/stale handles report available so the frontend proceeds to
@@ -4646,7 +4615,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
         // report it as produced and let the frontend cache it and release
         // the handle.
         if (query == nullptr || query->contextGeneration != g_syncContextGeneration ||
-            !g_GLESFuncs.glGetQueryObjectuiv || !g_GLESFuncs.glGetQueryObjectui64vEXT) {
+            !g_GLESFuncs.glGetQueryObjectuiv ||
+            (!query->isOcclusion && !g_GLESFuncs.glGetQueryObjectui64vEXT)) {
             return true;
         }
         // A thread that does not own the ES context cannot issue GL calls,
@@ -4684,6 +4654,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
         // context switch) the result may be garbage, which is tolerable for
         // an F3 GPU% readout, and consuming the latched flag here could hide
         // the event from another observer.
+        if (query->isOcclusion) {
+            GLuint result32 = 0;
+            g_GLESFuncs.glGetQueryObjectuiv(query->queryId, GL_QUERY_RESULT, &result32);
+            *outNanoseconds = static_cast<Uint64>(result32);
+            return true;
+        }
         GLuint64 result = 0;
         g_GLESFuncs.glGetQueryObjectui64vEXT(query->queryId, GL_QUERY_RESULT, &result);
         *outNanoseconds = static_cast<Uint64>(result);

MobileGL/MG_Backend/DirectGLES/DirectGLES.h

@@ -130,6 +130,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
     BackendQueryHandle BeginTimeElapsedQuery();
     void EndTimeElapsedQuery(BackendQueryHandle query);
     BackendQueryHandle QueryCounterTimestamp();
+    // GL_ANY_SAMPLES_PASSED(_CONSERVATIVE) occlusion queries: core ES3, independent of
+    // GL_EXT_disjoint_timer_query and of MOBILEGL_DISABLE_TIMERQUERY. Results/deletion
+    // flow through GetQueryResult64/DeleteBackendQuery like the timer queries above.
+    BackendQueryHandle BeginOcclusionQuery();
+    void EndOcclusionQuery(BackendQueryHandle query);
     Bool IsQueryResultAvailable(BackendQueryHandle query);
     // Returns true when a final value landed in *outNanoseconds (a zero for
     // null or stale-generation handles IS final: the frontend may cache it

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

@@ -18,6 +18,7 @@
 #include "MG_Util/Texture/TextureFormatProcessor.h"
 
 #include <Config.h>
+#include <cmath>
 #include <cstdlib>
 #include <cstring>
 
@@ -140,6 +141,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 +470,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 +482,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 {
@@ -505,10 +526,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                           E_GL_ARB_multi_draw_indirect, E_GL_ARB_indirect_parameters,
                                           E_GL_EXT_framebuffer_object, E_GL_ARB_depth_texture, E_GL_ARB_buffer_storage,
                                           E_GL_ARB_texture_storage, E_GL_ARB_texture_storage_multisample,
-                                          E_GL_ARB_clear_texture, E_GL_ARB_direct_state_access,
+                                          E_GL_ARB_texture_multisample, E_GL_ARB_clear_texture, E_GL_ARB_direct_state_access,
                                           E_GL_ARB_shader_draw_parameters, E_GL_ARB_gpu_shader_int64, E_GL_KHR_debug,
                                           E_GL_ARB_gpu_shader5, E_GL_ARB_multi_bind, E_GL_ARB_shading_language_420pack,
-                                          E_GL_ARB_vertex_attrib_binding, E_GL_ARB_shader_image_size};
+                                          E_GL_ARB_vertex_attrib_binding, E_GL_ARB_shader_image_size,
+                                          E_GL_ARB_explicit_attrib_location};
         if (shaderSubgroupSupported && !MG_Config::Features.DisableSubgroup) {
             extensions.push_back(E_GL_KHR_shader_subgroup);
         }
@@ -614,6 +636,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 funcsTable.GL.DeleteBackendQuery = DeleteBackendQuery;
                 funcsTable.GL.GetGpuTimestampNs = GetGpuTimestampNs;
             }
+            // Occlusion queries share the handle-based result/delete entries, which must
+            // exist even when timer queries are disabled.
+            funcsTable.GL.BeginOcclusionQuery = BeginOcclusionQuery;
+            funcsTable.GL.EndOcclusionQuery = EndOcclusionQuery;
+            funcsTable.GL.BeginXfbPrimitivesQuery = BeginXfbPrimitivesQuery;
+            funcsTable.GL.EndXfbPrimitivesQuery = EndXfbPrimitivesQuery;
+            funcsTable.GL.IsQueryResultAvailable = IsQueryResultAvailable;
+            funcsTable.GL.GetQueryResult64 = GetQueryResult64;
+            funcsTable.GL.DeleteBackendQuery = DeleteBackendQuery;
             funcsTableInitialized = true;
         }
         return funcsTable;
@@ -776,6 +807,23 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_dynamicParameters.ViewportBoundsRangeMin = m_vulkanCaps.ViewportBoundsRangeMin;
         m_dynamicParameters.ViewportBoundsRangeMax = m_vulkanCaps.ViewportBoundsRangeMax;
         m_dynamicParameters.ViewportSubpixelBits = m_vulkanCaps.ViewportSubpixelBits;
+        m_dynamicParameters.MinFragmentInterpolationOffset =
+            std::isfinite(m_vulkanCaps.MinFragmentInterpolationOffset) &&
+                    m_vulkanCaps.MinFragmentInterpolationOffset <= -0.5f
+                ? m_vulkanCaps.MinFragmentInterpolationOffset
+                : -0.5f;
+        m_dynamicParameters.MaxFragmentInterpolationOffset = 0.4375f;
+        m_dynamicParameters.FragmentInterpolationOffsetBits = 4;
+        if (m_vulkanCaps.FragmentInterpolationOffsetBits >= 4 &&
+            std::isfinite(m_vulkanCaps.MaxFragmentInterpolationOffset)) {
+            const Float requiredMaxOffset =
+                0.5f - std::ldexp(1.0f, -m_vulkanCaps.FragmentInterpolationOffsetBits);
+            if (m_vulkanCaps.MaxFragmentInterpolationOffset >= requiredMaxOffset) {
+                m_dynamicParameters.MaxFragmentInterpolationOffset = m_vulkanCaps.MaxFragmentInterpolationOffset;
+                m_dynamicParameters.FragmentInterpolationOffsetBits =
+                    m_vulkanCaps.FragmentInterpolationOffsetBits;
+            }
+        }
         m_dynamicParameters.SupportsWideLines = m_vulkanCaps.SupportsWideLines;
         m_dynamicParameters.MaxShaderStorageBlockSize =
             std::min(m_vulkanCaps.MaxShaderStorageBlockSize, kMaxAdvertisedShaderStorageBlockSize);

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(),
@@ -1224,10 +1250,76 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         pVulkanRenderer->Clear(mask);
     }
 
+    // Vulkan has no LINE_LOOP topology; rewrite the draw as an indexed LINE_STRIP
+    // whose synthesized index list revisits the first vertex at the end.
+    static void DrawLineLoopAsIndexedStrip(const Vector<Uint32>& closedIndices, GLint basevertex) {
+        DrawIndexedCmd payload{};
+        payload.mode = GL_LINE_STRIP;
+        payload.indexBufferView.indexType = GL_UNSIGNED_INT;
+        payload.indexBufferView.indexByteOffset = reinterpret_cast<SizeT>(closedIndices.data());
+        payload.indexBufferView.indexByteSize = closedIndices.size() * sizeof(Uint32);
+        payload.indexBufferView.forceClientMemory = true;
+        payload.params.indexCount = static_cast<Uint32>(closedIndices.size());
+        payload.params.instanceCount = 1;
+        payload.params.vertexOffset = basevertex;
+        pVulkanRenderer->DrawElements(payload);
+    }
+
+    // Resolve a DrawElements index list (bound element-array buffer or client
+    // memory) into uint32 values with the loop-closing first index appended.
+    static Bool BuildClosedLineLoopIndices(GLsizei count, GLenum type, const void* indices,
+                                           Vector<Uint32>& outIndices) {
+        const SizeT indexSize = MG_Util::GetGLTypeSize(type);
+        if (indexSize == 0 || count < 2) {
+            return false;
+        }
+        const Uint8* indexBytes = nullptr;
+        const auto& vao = *MG_State::pGLContext->GetBoundVertexArray();
+        const auto& indexBufferShared = vao.GetIndexBufferBindingSlot().GetBoundObject();
+        if (indexBufferShared != nullptr) {
+            const SizeT offset = reinterpret_cast<SizeT>(indices);
+            const SizeT bufferSize = indexBufferShared->GetSize();
+            if (indexBufferShared->MappedData() == nullptr || offset > bufferSize ||
+                static_cast<SizeT>(count) * indexSize > bufferSize - offset) {
+                return false;
+            }
+            indexBufferShared->SyncPersistentMappedRange();
+            indexBytes = indexBufferShared->MappedData() + offset;
+        } else {
+            indexBytes = static_cast<const Uint8*>(indices);
+            if (indexBytes == nullptr) {
+                return false;
+            }
+        }
+        outIndices.resize(static_cast<SizeT>(count) + 1);
+        for (GLsizei i = 0; i < count; ++i) {
+            switch (indexSize) {
+            case 1: outIndices[i] = indexBytes[i]; break;
+            case 2: outIndices[i] = reinterpret_cast<const Uint16*>(indexBytes)[i]; break;
+            default: outIndices[i] = reinterpret_cast<const Uint32*>(indexBytes)[i]; break;
+            }
+        }
+        outIndices[count] = outIndices[0];
+        return true;
+    }
+
     void DrawArrays(GLenum mode, GLint first, GLsizei count) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DrawArrays called with null VulkanRenderer");
         MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DrawArrays called with null GL context");
 
+        if (mode == GL_LINE_LOOP) {
+            if (count < 2) {
+                return;
+            }
+            Vector<Uint32> closedIndices(static_cast<SizeT>(count) + 1);
+            for (GLsizei i = 0; i < count; ++i) {
+                closedIndices[i] = static_cast<Uint32>(first + i);
+            }
+            closedIndices[count] = static_cast<Uint32>(first);
+            DrawLineLoopAsIndexedStrip(closedIndices, 0);
+            return;
+        }
+
         DrawCmd payload{};
         payload.mode = mode;
         payload.params.firstVertex = first;
@@ -1240,6 +1332,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DrawElements called with null VulkanRenderer");
         MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DrawElements called with null GL context");
 
+        if (mode == GL_LINE_LOOP) {
+            Vector<Uint32> closedIndices;
+            if (BuildClosedLineLoopIndices(count, type, indices, closedIndices)) {
+                DrawLineLoopAsIndexedStrip(closedIndices, 0);
+            }
+            return;
+        }
+
         DrawIndexedCmd payload{};
         payload.mode = mode;
         payload.indexBufferView.indexType = type;
@@ -1308,6 +1408,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLint basevertex) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DrawElementsBaseVertex called with null VulkanRenderer");
         MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DrawElementsBaseVertex called with null GL context");
+        if (mode == GL_LINE_LOOP) {
+            Vector<Uint32> closedIndices;
+            if (BuildClosedLineLoopIndices(count, type, indices, closedIndices)) {
+                DrawLineLoopAsIndexedStrip(closedIndices, basevertex);
+            }
+            return;
+        }
         DrawIndexedCmd payload{};
         payload.mode = mode;
         payload.indexBufferView.indexType = type;
@@ -1457,8 +1564,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // records are shared (SharedPtr) with the owning pool's pending list,
         // so deleting the query while results are still in flight is safe.
         struct VulkanTimerQuery {
+            enum class Kind : Uint8 { Timer, Occlusion, XfbWritten, XfbGenerated };
+            Kind kind = Kind::Timer;
             SharedPtr<VkTimerQueryManager::TimestampRecord> begin;
             SharedPtr<VkTimerQueryManager::TimestampRecord> end;
+            // Kind::Occlusion - pool slots recorded between Begin/End; summed at result time.
+            Vector<Uint32> occlusionSlots;
             // Renderer generation the records were written under (see
             // g_rendererGeneration). A stale generation resolves as available
             // with a final zero result: the records' pool indices and frame
@@ -1548,6 +1659,26 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // ever be produced, so resolve with a final 0.
             return true;
         }
+        if (query->kind == VulkanTimerQuery::Kind::Occlusion) {
+            Uint64 samples = 0;
+            if (!pVulkanRenderer->ResolveOcclusionQueryResult(query->occlusionSlots, samples)) {
+                return false;
+            }
+            query->occlusionSlots.clear(); // slots are recycled by the resolve
+            *outNanoseconds = samples;
+            return true;
+        }
+        if (query->kind == VulkanTimerQuery::Kind::XfbWritten ||
+            query->kind == VulkanTimerQuery::Kind::XfbGenerated) {
+            Uint64 primitives = 0;
+            if (!pVulkanRenderer->ResolveXfbQueryResult(query->occlusionSlots,
+                                                        query->kind == VulkanTimerQuery::Kind::XfbGenerated,
+                                                        primitives)) {
+                return false;
+            }
+            *outNanoseconds = primitives;
+            return true;
+        }
         // With wait, mirrors ClientWaitSync: a query ended this frame cannot
         // complete until Present submits the commands, so the wait refuses to
         // block on the current unsubmitted serial. Returning false keeps the
@@ -1580,6 +1711,47 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         delete static_cast<VulkanTimerQuery*>(handle);
     }
 
+    BackendQueryHandle BeginXfbPrimitivesQuery(Bool generated) {
+        MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::BeginXfbPrimitivesQuery called with null VulkanRenderer");
+        if (!pVulkanRenderer->StartXfbQueryCapture(generated ? 1u : 0u)) {
+            return nullptr;
+        }
+        auto* query = new VulkanTimerQuery{};
+        query->kind = generated ? VulkanTimerQuery::Kind::XfbGenerated : VulkanTimerQuery::Kind::XfbWritten;
+        query->rendererGeneration = GetRendererGeneration();
+        return query;
+    }
+
+    void EndXfbPrimitivesQuery(BackendQueryHandle handle) {
+        auto* query = static_cast<VulkanTimerQuery*>(handle);
+        MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::EndXfbPrimitivesQuery called with null VulkanRenderer");
+        if (query == nullptr || query->rendererGeneration != GetRendererGeneration()) {
+            return;
+        }
+        pVulkanRenderer->StopXfbQueryCapture(
+            query->kind == VulkanTimerQuery::Kind::XfbGenerated ? 1u : 0u, query->occlusionSlots);
+    }
+
+    BackendQueryHandle BeginOcclusionQuery() {
+        MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::BeginOcclusionQuery called with null VulkanRenderer");
+        if (!pVulkanRenderer->StartOcclusionQueryCapture()) {
+            return nullptr;
+        }
+        auto* query = new VulkanTimerQuery{};
+        query->kind = VulkanTimerQuery::Kind::Occlusion;
+        query->rendererGeneration = GetRendererGeneration();
+        return query;
+    }
+
+    void EndOcclusionQuery(BackendQueryHandle handle) {
+        auto* query = static_cast<VulkanTimerQuery*>(handle);
+        MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::EndOcclusionQuery called with null VulkanRenderer");
+        if (query == nullptr || query->rendererGeneration != GetRendererGeneration()) {
+            return;
+        }
+        pVulkanRenderer->StopOcclusionQueryCapture(query->occlusionSlots);
+    }
+
     Int64 GetGpuTimestampNs() {
         // Vulkan cannot synchronously sample the GPU clock: timestamps only
         // exist as vkCmdWriteTimestamp results read back later, and

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);
@@ -117,6 +123,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     // only while a live renderer exists whose device can actually time.
     Bool IsTimerQuerySupported();
     BackendQueryHandle BeginTimeElapsedQuery();
+    BackendQueryHandle BeginXfbPrimitivesQuery(Bool generated);
+    void EndXfbPrimitivesQuery(BackendQueryHandle query);
+    BackendQueryHandle BeginOcclusionQuery();
+    void EndOcclusionQuery(BackendQueryHandle query);
     void EndTimeElapsedQuery(BackendQueryHandle query);
     BackendQueryHandle QueryCounterTimestamp();
     Bool IsQueryResultAvailable(BackendQueryHandle query);

MobileGL/MG_Backend/DirectVulkan/Renderer/FrameContext.cpp

@@ -16,18 +16,19 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_device = device;
         m_commandPool = commandPool;
 
-        Vector<VkCommandBuffer> commandBuffers(frameCount, VK_NULL_HANDLE);
+        Vector<VkCommandBuffer> commandBuffers(frameCount * 2, VK_NULL_HANDLE);
         VkCommandBufferAllocateInfo allocInfo{};
         allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
         allocInfo.commandPool = commandPool;
         allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-        allocInfo.commandBufferCount = frameCount;
+        allocInfo.commandBufferCount = frameCount * 2;
         VkResult result = vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data());
         if (result != VK_SUCCESS) {
             return result;
         }
         for (Uint32 i = 0; i < frameCount; ++i) {
             m_frames[i].commandBuffer = commandBuffers[i];
+            m_frames[i].preCommandBuffer = commandBuffers[frameCount + i];
         }
 
         VkSemaphoreCreateInfo semaphoreInfo{VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO};
@@ -47,9 +48,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     void FrameContext::Destroy(VkDevice device, VkCommandPool commandPool) {
         const Uint32 frameCount = static_cast<Uint32>(m_frames.size());
-        Vector<VkCommandBuffer> commandBuffers(frameCount, VK_NULL_HANDLE);
+        Vector<VkCommandBuffer> commandBuffers(frameCount * 2, VK_NULL_HANDLE);
         for (Uint32 i = 0; i < frameCount; ++i) {
             commandBuffers[i] = m_frames[i].commandBuffer;
+            commandBuffers[frameCount + i] = m_frames[i].preCommandBuffer;
         }
 
         for (Uint32 i = 0; i < frameCount; ++i) {
@@ -60,7 +62,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             for (auto& frame : m_frames) {
                 FreeRetiredCommandBuffers(frame);
             }
-            vkFreeCommandBuffers(device, commandPool, frameCount, commandBuffers.data());
+            vkFreeCommandBuffers(device, commandPool, frameCount * 2, commandBuffers.data());
         }
         m_frames.clear();
         currentFrameIndex = 0;
@@ -87,6 +89,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         currentFrameIndex = (currentFrameIndex + 1) % static_cast<Uint32>(m_frames.size());
         GetCurrent().isCommandRecording = false;
         GetCurrent().hasCommandBufferRecorded = false;
+        GetCurrent().isPreCommandRecording = false;
+        GetCurrent().hasPreCommandBufferRecorded = false;
     }
 
     VkCommandBuffer& FrameContext::BeginCommandRecording(VkCommandBufferUsageFlags flags,
@@ -118,6 +122,41 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         frame.hasCommandBufferRecorded = true;
     }
 
+    VkCommandBuffer FrameContext::BeginPreCommandRecording() {
+        auto& frame = GetCurrent();
+        if (frame.isPreCommandRecording) {
+            return frame.preCommandBuffer;
+        }
+        MOBILEGL_ASSERT(!frame.hasPreCommandBufferRecorded,
+                        "BeginPreCommandRecording: a recorded pre stream is still awaiting submission");
+        VK_VERIFY(vkResetCommandBuffer(frame.preCommandBuffer, 0), "BeginPreCommandRecording, vkResetCommandBuffer");
+        VkCommandBufferBeginInfo beginInfo{};
+        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+        VK_VERIFY(vkBeginCommandBuffer(frame.preCommandBuffer, &beginInfo),
+                  "BeginPreCommandRecording, vkBeginCommandBuffer");
+        frame.isPreCommandRecording = true;
+        return frame.preCommandBuffer;
+    }
+
+    void FrameContext::EndPreCommandRecordingIfOpen() {
+        auto& frame = GetCurrent();
+        if (!frame.isPreCommandRecording) {
+            return;
+        }
+        VK_VERIFY(vkEndCommandBuffer(frame.preCommandBuffer), "EndPreCommandRecordingIfOpen, vkEndCommandBuffer");
+        frame.isPreCommandRecording = false;
+        frame.hasPreCommandBufferRecorded = true;
+    }
+
+    void FrameContext::AbandonPreCommandRecording() {
+        auto& frame = GetCurrent();
+        if (frame.isPreCommandRecording) {
+            VK_VERIFY(vkEndCommandBuffer(frame.preCommandBuffer), "AbandonPreCommandRecording, vkEndCommandBuffer");
+        }
+        frame.isPreCommandRecording = false;
+        frame.hasPreCommandBufferRecorded = false;
+    }
+
     VkResult FrameContext::InitializeSwapchainSemaphores(VkDevice device, Uint32 swapchainImageCount) {
         DestroySwapchainSemaphores(device);
         if (swapchainImageCount == 0) {
@@ -150,12 +189,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 +231,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;
     }
 
@@ -182,17 +241,27 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                                Uint32 swapchainImageIndex) const {
         const auto& frame = GetCurrent();
         MOBILEGL_ASSERT(!frame.isCommandRecording, "GetSubmitInfo called while command buffer recording is still active");
+        MOBILEGL_ASSERT(!frame.isPreCommandRecording,
+                        "GetSubmitInfo called while the pre-pass stream is still recording");
         AssertValidSwapchainImageIndex(swapchainImageIndex);
         SubmitInfoPacket packet{};
         packet.waitSemaphore = frame.imageAvailableSemaphore;
         packet.signalSemaphore = m_swapchainImageRenderFinishedSemaphores[swapchainImageIndex];
-        packet.commandBuffer = frame.commandBuffer;
+
+        Uint32 commandBufferCount = 0;
+        // The pre-pass stream executes strictly before the frame's commands.
+        if (frame.hasPreCommandBufferRecorded) {
+            packet.commandBuffers[commandBufferCount++] = frame.preCommandBuffer;
+        }
+        if (shouldSubmitCommandBuffer) {
+            packet.commandBuffers[commandBufferCount++] = frame.commandBuffer;
+        }
 
         packet.submitInfo.waitSemaphoreCount = frame.imageAvailableSemaphoreConsumed ? 0U : 1U;
         packet.submitInfo.pWaitSemaphores = frame.imageAvailableSemaphoreConsumed ? nullptr : &packet.waitSemaphore;
         packet.submitInfo.pWaitDstStageMask = frame.imageAvailableSemaphoreConsumed ? nullptr : &packet.waitDstStageMask;
-        packet.submitInfo.commandBufferCount = shouldSubmitCommandBuffer ? 1U : 0U;
-        packet.submitInfo.pCommandBuffers = shouldSubmitCommandBuffer ? &packet.commandBuffer : nullptr;
+        packet.submitInfo.commandBufferCount = commandBufferCount;
+        packet.submitInfo.pCommandBuffers = commandBufferCount > 0 ? packet.commandBuffers : nullptr;
         packet.submitInfo.signalSemaphoreCount = 1;
         packet.submitInfo.pSignalSemaphores = &packet.signalSemaphore;
         return packet;
@@ -227,12 +296,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 {
@@ -247,12 +325,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_recordingObserver = observer;
     }
 
-    VkResult FrameContext::RetireCurrentCommandBuffer() {
+    VkResult FrameContext::RetireCurrentCommandBuffer(Bool retirePreCommandBuffer) {
         MOBILEGL_ASSERT(m_device != VK_NULL_HANDLE && m_commandPool != VK_NULL_HANDLE,
                         "RetireCurrentCommandBuffer requires an initialized FrameContext");
         auto& frame = GetCurrent();
         MOBILEGL_ASSERT(!frame.isCommandRecording,
                         "RetireCurrentCommandBuffer called while the command buffer is still recording");
+        MOBILEGL_ASSERT(!frame.isPreCommandRecording,
+                        "RetireCurrentCommandBuffer called while the pre-pass stream is still recording");
 
         VkCommandBufferAllocateInfo allocInfo{};
         allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
@@ -260,11 +340,23 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
         allocInfo.commandBufferCount = 1;
         VkCommandBuffer replacement = VK_NULL_HANDLE;
-        const VkResult result = vkAllocateCommandBuffers(m_device, &allocInfo, &replacement);
+        VkResult result = vkAllocateCommandBuffers(m_device, &allocInfo, &replacement);
         if (result != VK_SUCCESS) {
             return result;
         }
-        frame.retiredCommandBuffers.push_back(frame.commandBuffer);
+        if (retirePreCommandBuffer) {
+            VkCommandBuffer preReplacement = VK_NULL_HANDLE;
+            result = vkAllocateCommandBuffers(m_device, &allocInfo, &preReplacement);
+            if (result != VK_SUCCESS) {
+                vkFreeCommandBuffers(m_device, m_commandPool, 1, &replacement);
+                return result;
+            }
+            frame.retiredCommandBuffers.push_back({frame.preCommandBuffer, frame.lastSubmitIndex});
+            frame.preCommandBuffer = preReplacement;
+        }
+        // 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 +366,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

@@ -29,7 +29,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkPipelineStageFlags waitDstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
             VkSemaphore waitSemaphore = VK_NULL_HANDLE;
             VkSemaphore signalSemaphore = VK_NULL_HANDLE;
-            VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
+            // [0] = pre-pass command buffer (when recorded), then the frame
+            // command buffer; submitInfo.pCommandBuffers points here.
+            VkCommandBuffer commandBuffers[2] = {VK_NULL_HANDLE, VK_NULL_HANDLE};
             VkSubmitInfo submitInfo{VK_STRUCTURE_TYPE_SUBMIT_INFO};
         };
 
@@ -40,17 +42,35 @@ 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;
+            // Pre-pass work stream: out-of-pass commands (deferred clear
+            // materialization, sampled-layout transitions) for resources the
+            // frame's recording has not touched yet. Submitted immediately
+            // BEFORE commandBuffer in the same vkQueueSubmit, so recording
+            // into it never has to split the frame's active render pass.
+            VkCommandBuffer preCommandBuffer = VK_NULL_HANDLE;
             VkSemaphore imageAvailableSemaphore = VK_NULL_HANDLE;
             VkFence imageInFlightFence = VK_NULL_HANDLE;
             Bool isCommandRecording = false;
             Bool hasCommandBufferRecorded = false;
+            Bool isPreCommandRecording = false;
+            Bool hasPreCommandBufferRecorded = 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;
@@ -67,6 +87,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkCommandBuffer& BeginCommandRecording(VkCommandBufferUsageFlags flags = 0,
                                                const VkCommandBufferInheritanceInfo* pInheritanceInfo = nullptr);
         void EndCommandRecording();
+        // Lazily opens the pre-pass work stream (see FrameData::preCommandBuffer).
+        VkCommandBuffer BeginPreCommandRecording();
+        // Closes the pre stream if open, marking it for submission ahead of the
+        // frame command buffer. Safe to call when it never opened.
+        void EndPreCommandRecordingIfOpen();
+        // Drops an in-progress or recorded-but-unsubmitted pre stream (dropped
+        // frame recordings, swapchain recreation).
+        void AbandonPreCommandRecording();
         VkResult InitializeSwapchainSemaphores(VkDevice device, Uint32 swapchainImageCount);
         void DestroySwapchainSemaphores(VkDevice device);
         Bool TransitionToPresent(VkImage image, VkImageLayout oldLayout,
@@ -79,8 +107,18 @@ 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.
-        VkResult RetireCurrentCommandBuffer();
+        // buffers are freed after the slot's fence is next waited, or as soon
+        // as their submission is observed complete.
+        VkResult RetireCurrentCommandBuffer(Bool retirePreCommandBuffer = false);
+
+        // 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

@@ -923,11 +923,403 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             ProgramFactory::CompileOptionFlags m_transformFlags;
         };
 
+        // Decorates the module's captured varyings for VK_EXT_transform_feedback:
+        // user outputs get XfbBuffer/XfbStride/Offset directly; a captured
+        // gl_Position (a gl_PerVertex member) is mirrored into a dedicated output
+        // variable copied before every OpReturn, BEFORE the position fixup runs,
+        // so the captured value is the shader's own (pre-remap) gl_Position.
+        class XfbCaptureDecoratePass final : public spvtools::opt::Pass {
+        public:
+            struct CapturedVarying {
+                std::string name;
+                Uint32 bufferIndex = 0;
+                Uint32 offsetBytes = 0;
+            };
+            const char* name() const override { return "mobilegl-xfb-capture-decorate"; }
+            XfbCaptureDecoratePass(Vector<CapturedVarying> varyings, Vector<Uint32> strides)
+                : m_varyings(Move(varyings)), m_strides(Move(strides)) {}
+
+            Status Process() override {
+                using namespace spvtools::opt;
+                if (m_varyings.empty()) return Status::SuccessWithoutChange;
+
+                auto entryPointIter = get_module()->entry_points().begin();
+                if (entryPointIter == get_module()->entry_points().end()) return Status::SuccessWithoutChange;
+                spvtools::opt::Instruction* entryPoint = &*entryPointIter;
+                const Uint32 entryFunctionId = entryPoint->GetSingleWordInOperand(1);
+
+                // Name -> result id map from the debug section.
+                std::unordered_map<std::string, Uint32> idsByName;
+                for (auto& debugInst : get_module()->debugs2()) {
+                    if (debugInst.opcode() != spv::Op::OpName) continue;
+                    idsByName[debugInst.GetInOperand(1).AsString()] = debugInst.GetSingleWordInOperand(0);
+                }
+
+                auto* decorationManager = context()->get_decoration_mgr();
+                const auto decorateForXfb = [&](Uint32 targetId, Uint32 bufferIndex, Uint32 offsetBytes) {
+                    const Uint32 stride = bufferIndex < m_strides.size() ? m_strides[bufferIndex] : 0;
+                    decorationManager->AddDecorationVal(targetId, static_cast<Uint32>(spv::Decoration::XfbBuffer),
+                                                        bufferIndex);
+                    decorationManager->AddDecorationVal(targetId, static_cast<Uint32>(spv::Decoration::XfbStride),
+                                                        stride);
+                    decorationManager->AddDecorationVal(targetId, static_cast<Uint32>(spv::Decoration::Offset),
+                                                        offsetBytes);
+                };
+
+                Bool modified = false;
+                Bool needsPositionMirror = false;
+                Uint32 positionBufferIndex = 0;
+                Uint32 positionOffset = 0;
+                for (const auto& varying : m_varyings) {
+                    if (varying.name == "gl_Position") {
+                        needsPositionMirror = true;
+                        positionBufferIndex = varying.bufferIndex;
+                        positionOffset = varying.offsetBytes;
+                        continue;
+                    }
+                    const auto idIt = idsByName.find(varying.name);
+                    if (idIt == idsByName.end()) {
+                        MGLOG_E("XfbCaptureDecoratePass: no SPIR-V variable named '%s'", varying.name.c_str());
+                        continue;
+                    }
+                    decorateForXfb(idIt->second, varying.bufferIndex, varying.offsetBytes);
+                    modified = true;
+                }
+
+                if (needsPositionMirror) {
+                    modified |= MirrorPositionForCapture(entryFunctionId, *entryPoint, positionBufferIndex,
+                                                         positionOffset, decorateForXfb);
+                }
+
+                if (!modified) return Status::SuccessWithoutChange;
+
+                context()->AddCapability(spv::Capability::TransformFeedback);
+                {
+                    auto executionMode = MakeUnique<spvtools::opt::Instruction>(
+                        context(), spv::Op::OpExecutionMode, 0, 0,
+                        std::initializer_list<spvtools::opt::Operand>{
+                            {SPV_OPERAND_TYPE_ID, {entryPoint->GetSingleWordInOperand(1)}},
+                            {SPV_OPERAND_TYPE_EXECUTION_MODE, {static_cast<Uint32>(spv::ExecutionMode::Xfb)}}});
+                    get_module()->AddExecutionMode(Move(executionMode));
+                }
+                context()->InvalidateAnalysesExceptFor(spvtools::opt::IRContext::kAnalysisNone);
+                return Status::SuccessWithChange;
+            }
+
+        private:
+            template <typename DecorateFn>
+            Bool MirrorPositionForCapture(Uint32 entryFunctionId, spvtools::opt::Instruction& entryPoint,
+                                          Uint32 bufferIndex, Uint32 offsetBytes, const DecorateFn& decorateForXfb) {
+                const Uint32 entryPointModel = entryPoint.GetSingleWordInOperand(0);
+                using namespace spvtools::opt;
+                PositionTargetInfo target{};
+                if (!FindPositionTarget(context(), &target)) {
+                    MGLOG_E("XfbCaptureDecoratePass: gl_Position capture requested but no position output found");
+                    return false;
+                }
+                if (!target.isMember) {
+                    // Standalone gl_Position variable: decorate it directly.
+                    decorateForXfb(target.variableId, bufferIndex, offsetBytes);
+                    return true;
+                }
+
+                auto* typeManager = context()->get_type_mgr();
+                const Uint32 mirrorPointerTypeId =
+                    typeManager->FindPointerToType(target.vectorTypeId, spv::StorageClass::Output);
+                if (mirrorPointerTypeId == 0) return false;
+
+                const Uint32 mirrorVariableId = context()->TakeNextId();
+                auto mirrorVariable = MakeUnique<Instruction>(
+                    context(), spv::Op::OpVariable, mirrorPointerTypeId, mirrorVariableId,
+                    std::initializer_list<Operand>{
+                        {SPV_OPERAND_TYPE_STORAGE_CLASS, {static_cast<Uint32>(spv::StorageClass::Output)}}});
+                get_module()->AddGlobalValue(Move(mirrorVariable));
+
+                // A free output location: past every explicitly decorated output.
+                Uint32 mirrorLocation = 0;
+                for (auto& annotation : get_module()->annotations()) {
+                    if (annotation.opcode() != spv::Op::OpDecorate ||
+                        annotation.GetSingleWordInOperand(1) != static_cast<Uint32>(spv::Decoration::Location)) {
+                        continue;
+                    }
+                    mirrorLocation = std::max(mirrorLocation, annotation.GetSingleWordInOperand(2) + 1);
+                }
+                auto* decorationManager = context()->get_decoration_mgr();
+                decorationManager->AddDecorationVal(mirrorVariableId,
+                                                    static_cast<Uint32>(spv::Decoration::Location), mirrorLocation);
+                decorateForXfb(mirrorVariableId, bufferIndex, offsetBytes);
+                entryPoint.AddOperand({SPV_OPERAND_TYPE_ID, {mirrorVariableId}});
+
+                auto* function = context()->GetFunction(entryFunctionId);
+                if (function == nullptr) return false;
+                const auto model = static_cast<spv::ExecutionModel>(entryPointModel);
+                Bool injected = false;
+                for (auto& block : *function) {
+                    for (auto instIter = block.begin(); instIter != block.end(); ++instIter) {
+                        // Geometry stages capture per emitted vertex; other stages at return.
+                        const Bool isInjectionSite =
+                            model == spv::ExecutionModel::Geometry
+                                ? instIter->opcode() == spv::Op::OpEmitVertex
+                                : instIter->opcode() == spv::Op::OpReturn;
+                        if (!isInjectionSite) continue;
+                        InstructionBuilder builder(context(), &*instIter, IRContext::kAnalysisNone);
+                        const Uint32 memberIndexId = builder.GetUintConstantId(target.memberIndex);
+                        auto* access =
+                            builder.AddAccessChain(target.vectorPtrTypeId, target.variableId, {memberIndexId});
+                        if (access == nullptr) return injected;
+                        auto* value = builder.AddLoad(target.vectorTypeId, access->result_id());
+                        if (value == nullptr) return injected;
+                        builder.AddStore(mirrorVariableId, value->result_id());
+                        injected = true;
+                    }
+                }
+                return injected;
+            }
+
+            Vector<CapturedVarying> m_varyings;
+            Vector<Uint32> m_strides;
+        };
+
+        // 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>());
+        }
+
+        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));
         }
 
+        Bool TransformSpirvForXfbCapture(const Vector<Uint>& input, Vector<Uint>& output,
+                                         const MG_State::GLState::ProgramObject& program) {
+            if (input.empty()) {
+                output.clear();
+                return true;
+            }
+            Vector<XfbCaptureDecoratePass::CapturedVarying> varyings;
+            varyings.reserve(program.GetTransformFeedbackVaryingCount());
+            for (const auto& varying : program.GetTransformFeedbackVaryings()) {
+                varyings.push_back({varying.name, varying.bufferIndex, varying.offsetBytes});
+            }
+            Vector<Uint32> strides;
+            strides.reserve(program.GetTransformFeedbackBufferCount());
+            for (SizeT i = 0; i < program.GetTransformFeedbackBufferCount(); ++i) {
+                strides.push_back(program.GetTransformFeedbackStride(static_cast<Uint32>(i)));
+            }
+
+            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: xfb capture pass: %s", message != nullptr ? message : "");
+            });
+            optimizer.RegisterPass(spvtools::Optimizer::PassToken(
+                MakeUnique<XfbCaptureDecoratePass>(Move(varyings), Move(strides))));
+
+            const Bool success = optimizer.Run(input.data(), input.size(), &output, options);
+            if (!success) {
+                MGLOG_E("Vulkan: xfb capture decoration pass 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 +1486,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 +2013,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 +2030,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 +2076,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 +2148,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 +2297,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 +2342,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());
@@ -1881,11 +2365,29 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
             // Apply position fixup if needed
             if (fixupStage != ShaderStage::Unknown && shaders[i] && shaders[i]->GetShaderStage() == fixupStage) {
-                TransformSpirvForVulkanPositionFix(spv, moduleSpirvs[i], flags);
+                const Vector<Uint>* fixupInput = &spv;
+                Vector<Uint> xfbSpirv;
+                if ((flags & ProgramFactory::CompileOptionBit::XfbCapture) &&
+                    program.GetTransformFeedbackVaryingCount() > 0) {
+                    // Decorate BEFORE the position fixup so a captured gl_Position
+                    // mirror copies the shader's own (pre-remap) value.
+                    if (TransformSpirvForXfbCapture(spv, xfbSpirv, program)) {
+                        fixupInput = &xfbSpirv;
+                    }
+                }
+                TransformSpirvForVulkanPositionFix(*fixupInput, moduleSpirvs[i], flags);
             } else {
                 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);
+                }
+            }
+
             // 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 +2484,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,
+            // Decorates the last vertex-processing stage's captured varyings with
+            // XfbBuffer/XfbStride/Offset (VK_EXT_transform_feedback). Set only for draws
+            // recorded while GL transform feedback is active, so plain draws keep the
+            // undecorated variant.
+            XfbCapture = 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));
@@ -257,6 +262,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_images.resize(imageCount, VK_NULL_HANDLE);
         VK_VERIFY(vkGetSwapchainImagesKHR(device, m_swapchain, &imageCount, m_images.data()));
         m_imageLayouts.assign(imageCount, VK_IMAGE_LAYOUT_UNDEFINED);
+        // Fresh swapchain images hold garbage until a render pass stores into them.
+        m_imageContentDefined.assign(imageCount, false);
+        m_depthStencilContentDefined.assign(imageCount, false);
 
         CreateImageViews(device);
         CreateDepthStencilResources(device, physicalDevice);
@@ -428,9 +436,39 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         m_images.clear();
         m_imageLayouts.clear();
+        m_imageContentDefined.clear();
+        m_depthStencilContentDefined.clear();
         m_preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
     }
 
+    Bool SwapchainObject::IsImageContentDefined(Uint32 index) const {
+        MOBILEGL_ASSERT(index < m_imageContentDefined.size(), "Swapchain image content index out of range");
+        return m_imageContentDefined[index];
+    }
+
+    void SwapchainObject::SetImageContentDefined(Uint32 index, Bool defined) {
+        MOBILEGL_ASSERT(index < m_imageContentDefined.size(), "Swapchain image content index out of range");
+        m_imageContentDefined[index] = defined;
+    }
+
+    Bool SwapchainObject::IsDepthStencilContentDefined(Uint32 index) const {
+        MOBILEGL_ASSERT(index < m_depthStencilContentDefined.size(),
+                        "Swapchain depth/stencil content index out of range");
+        return m_depthStencilContentDefined[index];
+    }
+
+    void SwapchainObject::SetDepthStencilContentDefined(Uint32 index, Bool defined) {
+        MOBILEGL_ASSERT(index < m_depthStencilContentDefined.size(),
+                        "Swapchain depth/stencil content index out of range");
+        m_depthStencilContentDefined[index] = defined;
+    }
+
+    void SwapchainObject::SetAllDepthStencilContentUndefined() {
+        for (SizeT i = 0; i < m_depthStencilContentDefined.size(); ++i) {
+            m_depthStencilContentDefined[i] = false;
+        }
+    }
+
     VkImage SwapchainObject::GetImage(Uint32 index) const {
         MOBILEGL_ASSERT(index < m_images.size(), "Swapchain image index out of range");
         return m_images[index];

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; }
@@ -49,6 +52,21 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void SetImageLayout(Uint32 index, VkImageLayout layout);
         SizeT GetImageCount() const { return m_images.size(); }
 
+        // EGL content-validity tracking for the default framebuffer. A color
+        // buffer's content is undefined once its image has been presented
+        // (EGL_BUFFER_DESTROYED swap behaviour, the implementation default),
+        // and every ancillary (depth/stencil) buffer's content is undefined
+        // after ANY swap regardless of swap behaviour (EGL 1.5 §3.10.1). The
+        // render-pass manager turns an undefined attachment's tile load into
+        // LOAD_OP_DONT_CARE. Flags start false (a fresh swapchain image holds
+        // garbage) and a render pass storing into an attachment sets it back
+        // to defined.
+        Bool IsImageContentDefined(Uint32 index) const;
+        void SetImageContentDefined(Uint32 index, Bool defined);
+        Bool IsDepthStencilContentDefined(Uint32 index) const;
+        void SetDepthStencilContentDefined(Uint32 index, Bool defined);
+        void SetAllDepthStencilContentUndefined();
+
     private:
         void CreateImageViews(VkDevice device);
         void CreateDepthStencilResources(VkDevice device, VkPhysicalDevice physicalDevice);
@@ -63,6 +81,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;
@@ -73,5 +92,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Vector<VkDeviceMemory> m_depthStencilImageMemories;
         Vector<VkImageView> m_depthStencilImageViews;
         Vector<VkImageLayout> m_depthStencilImageLayouts;
+        Vector<Bool> m_imageContentDefined;
+        Vector<Bool> m_depthStencilContentDefined;
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.cpp

@@ -18,6 +18,7 @@
 #include "MG_Util/Converters/MGToVk/TextureEnumConverter.h"
 #include "MG_Util/Metrics/TextureMetrics.h"
 #include <Config.h>
+#include <algorithm>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
@@ -204,6 +205,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // The frame's descriptor sets are recycled above, so last frame's reuse target
         // is gone: start the per-draw descriptor-reuse cache fresh this frame.
         m_hasLastDescriptor = false;
+        m_lastBindValid = false;
         // Re-fingerprint the bound sampler set fresh this frame so any GL object address
         // reuse cannot outlive a single frame (see SamplerResolveMemo).
         for (auto& memo : m_samplerResolveMemo) {
@@ -211,6 +213,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 +386,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 +448,48 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return outImageInfo.sampler != VK_NULL_HANDLE;
     }
 
+    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 +847,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 +873,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 +993,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 +1077,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 +1091,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 +1139,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 +1167,82 @@ 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 {
+                        // Global-UBO slice reuse (see GlobalUboSliceMemo): unchanged
+                        // uniform bytes re-use the slice already uploaded this frame.
+                        const Bool isGlobalUbo =
+                            programObj.globalUboBinding == static_cast<Int>(binding) && element == 0;
+                        const Uint64 uboFrameSerial = m_bufferManager->GetFrameSerial();
+                        const Uint64 uboProgramLifetimeId = program.GetLifetimeId();
+                        const Uint32 uboContentVersion = program.GetUBOContentVersion();
+                        Bool reusedSlice = false;
+                        if (isGlobalUbo) {
+                            for (const auto& memo : m_globalUboMemo) {
+                                if (memo.buffer != VK_NULL_HANDLE &&
+                                    memo.programLifetimeId == uboProgramLifetimeId &&
+                                    memo.frameSerial == uboFrameSerial &&
+                                    memo.uboContentVersion == uboContentVersion &&
+                                    memo.range == static_cast<VkDeviceSize>(ubo.payloadSize)) {
+                                    bufferInfo.buffer = memo.buffer;
+                                    bufferInfo.range = memo.range;
+                                    dynOffset = static_cast<Uint32>(memo.offset);
+                                    reusedSlice = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!reusedSlice) {
+                            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);
+                            if (isGlobalUbo) {
+                                m_globalUboMemo[m_globalUboMemoNext] = GlobalUboSliceMemo{
+                                    uboProgramLifetimeId, uboFrameSerial, uboContentVersion,
+                                    slice.buffer, slice.offset, static_cast<VkDeviceSize>(ubo.payloadSize)};
+                                m_globalUboMemoNext = (m_globalUboMemoNext + 1) % kGlobalUboMemoSize;
+                            }
+                        }
                     }
-                    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) ||
@@ -1221,8 +1370,34 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_hasLastDescriptor = cacheable;
         }
 
-        vkCmdBindDescriptorSets(commandBuffer, bindPoint, programObj.pipelineLayout, 0, 1,
-                                &descriptorSet, static_cast<Uint32>(dynamicOffsets.size()), dynamicOffsets.data());
+        // Skip the driver call when this exact binding is already live on the
+        // command buffer (see the bind-dedup shadow in the header).
+        const Uint32 offsetCount = static_cast<Uint32>(dynamicOffsets.size());
+        Bool identicalBind = m_lastBindValid && m_lastBindSet == descriptorSet &&
+                             m_lastBindLayout == programObj.pipelineLayout && m_lastBindPoint == bindPoint &&
+                             m_lastBindOffsetCount == offsetCount && offsetCount <= kMaxShadowedDynamicOffsets;
+        if (identicalBind) {
+            for (Uint32 i = 0; i < offsetCount; ++i) {
+                if (m_lastBindOffsets[i] != dynamicOffsets[i]) {
+                    identicalBind = false;
+                    break;
+                }
+            }
+        }
+        if (!identicalBind) {
+            vkCmdBindDescriptorSets(commandBuffer, bindPoint, programObj.pipelineLayout, 0, 1,
+                                    &descriptorSet, offsetCount, dynamicOffsets.data());
+            if (offsetCount <= kMaxShadowedDynamicOffsets) {
+                m_lastBindValid = true;
+                m_lastBindSet = descriptorSet;
+                m_lastBindLayout = programObj.pipelineLayout;
+                m_lastBindPoint = bindPoint;
+                m_lastBindOffsetCount = offsetCount;
+                std::copy_n(dynamicOffsets.data(), offsetCount, m_lastBindOffsets);
+            } else {
+                m_lastBindValid = false;
+            }
+        }
         return true;
     }
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.h

@@ -39,6 +39,20 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void Shutdown();
 
         void BeginFrame(Uint32 frameIndex);
+        // A command buffer (re)began recording: descriptor bindings recorded into
+        // the previous buffer do not carry over, so drop the bind-dedup shadow.
+        void OnCommandBufferBoundary() { m_lastBindValid = false; }
+        // 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 +72,16 @@ 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.
+        static Bool ProgramSamplesOnlySingleLevelTextures(const MG_State::GLState::ProgramObject& program,
+                                                          const ProgramFactory::VkProgramObject& programObj);
+
     private:
         struct DescriptorPoolBucket {
             VkDescriptorPool handle = VK_NULL_HANDLE;
@@ -65,8 +89,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 +148,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(
@@ -156,6 +188,35 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint64 m_lastDescriptorSignature = 0;
         Bool m_hasLastDescriptor = false;
 
+        // vkCmdBindDescriptorSets dedup: consecutive draws with a static uniform
+        // block resolve to the same set AND the same dynamic offsets, so the
+        // driver call can be skipped outright. Command-buffer-scope state; reset
+        // via OnCommandBufferBoundary whenever a recording (re)begins. Keyed on
+        // layout+bind point, so a pipeline-layout switch always rebinds.
+        static constexpr Uint32 kMaxShadowedDynamicOffsets = 8;
+        Bool m_lastBindValid = false;
+        VkDescriptorSet m_lastBindSet = VK_NULL_HANDLE;
+        VkPipelineLayout m_lastBindLayout = VK_NULL_HANDLE;
+        VkPipelineBindPoint m_lastBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+        Uint32 m_lastBindOffsetCount = 0;
+        Uint32 m_lastBindOffsets[kMaxShadowedDynamicOffsets] = {};
+
+        // Global-UBO transient-slice reuse: MC leaves the default uniform block
+        // untouched across long GUI/terrain runs, so the per-draw re-upload of
+        // the same bytes can reuse the slice uploaded earlier THIS frame (frame
+        // serial guards arena recycling; the content version guards writes).
+        struct GlobalUboSliceMemo {
+            Uint64 programLifetimeId = 0;
+            Uint64 frameSerial = 0;
+            Uint32 uboContentVersion = 0;
+            VkBuffer buffer = VK_NULL_HANDLE;
+            VkDeviceSize offset = 0;
+            VkDeviceSize range = 0;
+        };
+        static constexpr Uint32 kGlobalUboMemoSize = 4;
+        GlobalUboSliceMemo m_globalUboMemo[kGlobalUboMemoSize];
+        Uint32 m_globalUboMemoNext = 0;
+
         // Per-binding fast path over VkSamplerManager's content-hashed sampler cache, which
         // stays the source of truth: its key hashes all sampler+texture state, so two distinct
         // sampler objects with identical state still resolve to one VkSampler. This memo only
@@ -172,6 +233,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)));
         }
@@ -51,14 +58,27 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     const VertexInputStateFactory::BackendVertexInputState& VertexInputStateFactory::GetOrCreateVertexInputState(
         const MG_State::GLState::VertexArrayObject& vao) {
-        return GetOrCreateVertexInputState(vao, GetOrComputeHash(vao));
+        // Per-draw fast path: the VAO carries a pointer to its resolved entry,
+        // valid while its config version and the cache's eviction epoch both
+        // match - no re-hash, no map lookup.
+        const void* memoState = nullptr;
+        Uint64 memoEpoch = 0;
+        if (vao.GetBackendStateMemo(memoState, memoEpoch) && memoEpoch == m_evictionEpoch) {
+            const auto* entry = static_cast<const BackendVertexInputState*>(memoState);
+            entry->lastUsedFrameBoundary = m_frameBoundaryCounter;
+            return *entry;
+        }
+        const BackendVertexInputState& entry = GetOrCreateVertexInputState(vao, GetOrComputeHash(vao));
+        vao.SetBackendStateMemo(&entry, m_evictionEpoch);
+        return entry;
     }
 
     const VertexInputStateFactory::BackendVertexInputState& VertexInputStateFactory::GetOrCreateVertexInputState(
         const MG_State::GLState::VertexArrayObject& vao, HashType hash) {
         auto it = m_cache.find(hash);
         if (it != m_cache.end()) {
-            return it->second;
+            it->second->lastUsedFrameBoundary = m_frameBoundaryCounter;
+            return *it->second;
         }
 
         VertexInputStateBuilder builder;
@@ -164,10 +184,37 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         const auto& state = builder.Build();
 
-        auto& entry = m_cache[hash];
+        auto& slot = m_cache[hash];
+        if (!slot) {
+            slot = MakeUnique<BackendVertexInputState>();
+        }
+        BackendVertexInputState& entry = *slot;
         entry.hash = hash;
+        entry.lastUsedFrameBoundary = m_frameBoundaryCounter;
         entry.bindings = builder.GetBindings();
         entry.attributes = builder.GetAttributes();
+        // See the layoutHash declaration: hash only the resolved layout, never
+        // buffer identities, so identical layouts across VAOs/buffers agree.
+        XXHASH_VERIFY(XXH64_reset(m_hashState, 0));
+        for (const auto& binding : entry.bindings) {
+            XXHASH_VERIFY(XXH64_update(m_hashState, &binding.binding, sizeof(binding.binding)));
+            XXHASH_VERIFY(XXH64_update(m_hashState, &binding.stride, sizeof(binding.stride)));
+            XXHASH_VERIFY(XXH64_update(m_hashState, &binding.inputRate, sizeof(binding.inputRate)));
+        }
+        for (const auto& attribute : entry.attributes) {
+            XXHASH_VERIFY(XXH64_update(m_hashState, &attribute.location, sizeof(attribute.location)));
+            XXHASH_VERIFY(XXH64_update(m_hashState, &attribute.binding, sizeof(attribute.binding)));
+            XXHASH_VERIFY(XXH64_update(m_hashState, &attribute.format, sizeof(attribute.format)));
+            XXHASH_VERIFY(XXH64_update(m_hashState, &attribute.offset, sizeof(attribute.offset)));
+        }
+        XXHASH_VERIFY(XXH64_update(m_hashState, &unsupportedAttribMask, sizeof(unsupportedAttribMask)));
+        entry.layoutHash = XXH64_digest(m_hashState);
+        entry.attributeLocationMask = 0;
+        for (const auto& attribute : entry.attributes) {
+            if (attribute.location < 32u) {
+                entry.attributeLocationMask |= (1u << attribute.location);
+            }
+        }
         entry.bindingBufferKeys = std::move(bindingBufferKeys);
         entry.bindingBaseOffsets = std::move(bindingBaseOffsets);
         entry.bindingAttributeLocations = std::move(bindingAttributeLocations);
@@ -180,6 +227,33 @@ 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);
+                // Invalidate every VAO's state-pointer memo: the erased node's
+                // address may be reused by a future insert.
+                ++m_evictionEpoch;
+            } 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,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         struct BackendVertexInputState {
             HashType hash = 0;
+            // Hash of the resolved Vulkan vertex layout only (bindings, attributes,
+            // unsupported mask) - NO buffer identities. `hash` mixes buffer heap
+            // addresses so per-chunk VBOs mint a fresh identity per buffer; keying
+            // pipelines on that minted one VkPipeline per chunk section for an
+            // identical layout, defeating pipeline reuse and the per-draw memo.
+            // Pipelines depend only on the layout, so they key on this instead.
+            HashType layoutHash = 0;
+            // Frame boundary of the last cache hit; entries idle past the
+            // OnFrameBoundary retirement age are evicted (CPU heap only).
+            // Mutable: the VAO's state-pointer memo fast path stamps it through
+            // a const entry reference.
+            mutable Uint64 lastUsedFrameBoundary = 0;
             Vector<VkVertexInputBindingDescription> bindings;
             Vector<VkVertexInputAttributeDescription> attributes;
             Vector<SizeT> bindingBufferKeys;
@@ -38,6 +50,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // absent from `attributes`, so without this mask the draw path cannot tell them apart from
             // a genuinely disabled array and would silently feed the shader the current attribute value.
             Uint32 unsupportedAttribMask = 0;
+            // Bitmask of `attributes[i].location` - the draw path needs it up to
+            // three times per draw, so it is baked once at build time.
+            Uint32 attributeLocationMask = 0;
             VkPipelineVertexInputStateCreateInfo state{
                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
             };
@@ -55,6 +70,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
@@ -69,7 +92,19 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         const VulkanRendererConfig& m_config;
         VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
-        UnorderedMap<HashType, BackendVertexInputState> m_cache;
+        // Values are heap-allocated: FastSTL::unordered_map is open-addressing,
+        // so INSERT invalidates references to stored values. The draw path (and
+        // the VAOs' state-pointer memos) hold entry pointers across inserts;
+        // only the unique_ptr cell moves, never the pointee.
+        UnorderedMap<HashType, UniquePtr<BackendVertexInputState>> m_cache;
+        // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
+        Uint64 m_frameBoundaryCounter = 0;
+        // Bumped whenever any cache entry is erased. VAOs memo a raw pointer to
+        // their heap-allocated entry (stable across map insert/rehash by
+        // construction); a memo is honored only while its recorded epoch
+        // matches, so an evicted entry can never be dereferenced through a
+        // stale memo.
+        Uint64 m_evictionEpoch = 1;
         static inline XXH64_state_t* m_hashState = XXH64_createState();
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.cpp

@@ -22,6 +22,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
             VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
             VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+        // Appended to kPersistentBackedUsage when VK_EXT_transform_feedback is enabled
+        // (see VkBufferManagerInitInfo::transformFeedbackUsageEnabled).
+        constexpr VkBufferUsageFlags kTransformFeedbackUsage =
+            VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
         // The app writes into the persistent map with no explicit flush, so its memory must
         // be host-coherent (Adreno host-visible memory is; requiring it keeps us portable).
         constexpr VkMemoryPropertyFlags kPersistentBackedRequiredFlags =
@@ -141,6 +145,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
@@ -456,7 +469,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // it from the current shadow - MappedData() is still the shadow here because the
         // frontend adopts (and drops) the shadow only after this returns.
         DeferRelease(std::move(resource->buffer));
-        if (!CreateResidentStorage(*resource, size, kPersistentBackedUsage, kPersistentBackedRequiredFlags)) {
+        const VkBufferUsageFlags persistentUsage =
+            kPersistentBackedUsage |
+            (m_initInfo.transformFeedbackUsageEnabled ? kTransformFeedbackUsage : 0);
+        if (!CreateResidentStorage(*resource, size, persistentUsage, kPersistentBackedRequiredFlags)) {
             resource->persistentMapped = false;
             resource->storageSize = 0;
             resource->usageFlags = 0;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.h

@@ -31,6 +31,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VmaMemoryUsage transientMemoryUsage = VMA_MEMORY_USAGE_AUTO;
         VmaAllocationCreateFlags transientAllocationFlags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
         Bool transientPersistentMapping = false;
+        // VK_EXT_transform_feedback is enabled: persistent-map storage additionally
+        // carries the transform feedback usage so capture targets can bind directly.
+        Bool transformFeedbackUsageEnabled = false;
     };
 
     // The DirectVulkan storage behind one frontend buffer (pipe_resource analogue).
@@ -77,6 +80,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/VkClearManager.cpp

@@ -93,6 +93,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const std::lock_guard<std::mutex> lock(m_mutex);
         m_pendingClears.clear();
         m_aliveObjects.clear();
+        m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
     }
 
     TextureIdentity VkClearManager::MakeTextureIdentity(MG_State::GLState::ITextureObject* texture) {
@@ -127,6 +128,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_pendingClears.erase(key);
         }
         m_aliveObjects.erase(identity);
+        m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
     }
 
     Bool VkClearManager::LockTextureIdentityLocked(const TextureIdentity& identity,
@@ -221,6 +223,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_aliveObjects[MakeTextureIdentity(texture.get())] = texture;
         auto& pending = m_pendingClears[key];
         MergeClearPayload(pending, clearPayload);
+        m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
     }
 
     void VkClearManager::QueueClear(const ClearAttachmentPayload& clearPayload,
@@ -238,6 +241,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_aliveObjects[MakeTextureIdentity(texture.get())] = texture;
         auto& pending = m_pendingClears[key];
         MergeClearPayload(pending, clearPayload);
+        m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
     }
 
     Bool VkClearManager::HasPendingClear(MG_State::GLState::ITextureObject* texture) {
@@ -245,6 +249,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return false;
         }
 
+        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
+            return false;  // per-draw hot path: nothing pending anywhere
+        }
+
         const Uint64 lifetimeId = texture->GetLifetimeId();
         const std::lock_guard<std::mutex> lock(m_mutex);
         for (auto it = m_pendingClears.begin(); it != m_pendingClears.end(); ++it) {
@@ -260,6 +268,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (key.texture == nullptr) {
             return false;
         }
+        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
+            return false;  // per-draw hot path: nothing pending anywhere
+        }
 
         const std::lock_guard<std::mutex> lock(m_mutex);
         if (m_pendingClears.find(key) == m_pendingClears.end()) {
@@ -287,6 +298,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (key.texture == nullptr) {
             return false;
         }
+        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
+            return false;  // per-draw hot path: nothing pending anywhere
+        }
 
         const std::lock_guard<std::mutex> lock(m_mutex);
         if (!LockTextureLocked(key, outTexture)) {
@@ -325,6 +339,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (texture == nullptr) {
             return false;
         }
+        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
+            return false;  // per-draw hot path: nothing pending anywhere
+        }
 
         const Uint64 lifetimeId = texture->GetLifetimeId();
         const std::lock_guard<std::mutex> lock(m_mutex);
@@ -345,6 +362,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return;
         }
 
+        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
+            return;  // per-draw hot path: nothing pending anywhere
+        }
         const TextureIdentity identity = MakeTextureIdentity(texture);
         MGLOG_D("%s: Pop all pending clears for texture %d", __func__, texture->GetExternalIndex());
         const std::lock_guard<std::mutex> lock(m_mutex);
@@ -361,6 +381,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             auto it = m_pendingClears.find(key);
             if (it != m_pendingClears.end()) {
                 m_pendingClears.erase(it);
+            m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
             }
         }
 

MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.h

@@ -14,6 +14,7 @@
 #include "MG_Util/Math/VectorTypes.h"
 
 #include <Includes.h>
+#include <atomic>
 #include <unordered_map>
 
 namespace MobileGL::MG_Backend::DirectVulkan {
@@ -120,7 +121,19 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                SharedPtr<MG_State::GLState::ITextureObject>& outTexture);
 
         Uint8 m_gcCounter = 0;
+    public:
+        // Lock-free probe for the consecutive-draw fast path: any pending clear
+        // forces the full SetupDraw path (which materializes/consumes it).
+        Bool HasAnyPendingClears() const { return m_pendingCount.load(std::memory_order_relaxed) != 0; }
+
+    private:
         mutable std::mutex m_mutex;
+        // Lock-free mirror of m_pendingClears.size(), maintained under m_mutex
+        // by every mutation. The per-draw probes (HasPendingClear/GetPending*)
+        // read it before taking the lock: during draw batches the pending set
+        // is almost always empty, so this turns several locked map probes per
+        // draw into one relaxed load.
+        std::atomic<Uint32> m_pendingCount{0};
         std::unordered_map<PendingClearKey, ClearAttachmentPayload, PendingClearKeyHash> m_pendingClears;
         std::unordered_map<TextureIdentity, WeakPtr<MG_State::GLState::ITextureObject>, TextureIdentityHash> m_aliveObjects;
     };

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.cpp

@@ -16,31 +16,21 @@
 
 namespace MobileGL::MG_Backend::DirectVulkan {
     static Bool TryResolveSampleCountFlagBits(Int requestedSamples, VkSampleCountFlagBits& outSampleCount) {
-        switch (requestedSamples <= 0 ? 1 : requestedSamples) {
-        case 1:
+        // GL promises "at least the requested samples", so a non-power-of-two
+        // request (legal in GL, e.g. 3) rounds up to the next Vulkan bit.
+        if (requestedSamples <= 1) {
             outSampleCount = VK_SAMPLE_COUNT_1_BIT;
             return true;
-        case 2:
-            outSampleCount = VK_SAMPLE_COUNT_2_BIT;
-            return true;
-        case 4:
-            outSampleCount = VK_SAMPLE_COUNT_4_BIT;
-            return true;
-        case 8:
-            outSampleCount = VK_SAMPLE_COUNT_8_BIT;
-            return true;
-        case 16:
-            outSampleCount = VK_SAMPLE_COUNT_16_BIT;
-            return true;
-        case 32:
-            outSampleCount = VK_SAMPLE_COUNT_32_BIT;
-            return true;
-        case 64:
-            outSampleCount = VK_SAMPLE_COUNT_64_BIT;
-            return true;
-        default:
+        }
+        if (requestedSamples > 64) {
             return false;
         }
+        Uint32 bit = 1;
+        while (bit < static_cast<Uint32>(requestedSamples)) {
+            bit <<= 1;
+        }
+        outSampleCount = static_cast<VkSampleCountFlagBits>(bit);
+        return true;
     }
 
     static VkImageAspectFlags ResolveImageAspectMaskForFormat(VkFormat format) {
@@ -166,6 +156,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (view != VK_NULL_HANDLE) {
             vkDestroyImageView(device, view, nullptr);
         }
+        if (unormTwinView != VK_NULL_HANDLE) {
+            vkDestroyImageView(device, unormTwinView, nullptr);
+        }
         if (image != VK_NULL_HANDLE && allocation != nullptr) {
             vmaDestroyImage(allocator, image, allocation);
         }
@@ -173,6 +166,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         image = VK_NULL_HANDLE;
         allocation = nullptr;
         view = VK_NULL_HANDLE;
+        unormTwinView = VK_NULL_HANDLE;
         layout = VK_IMAGE_LAYOUT_UNDEFINED;
         format = VK_FORMAT_UNDEFINED;
         aspect = VK_IMAGE_ASPECT_NONE;
@@ -180,6 +174,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 +201,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 +209,80 @@ 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, resource.unormTwinView, m_frameCounter});
+        resource.image = VK_NULL_HANDLE;
+        resource.allocation = nullptr;
+        resource.view = VK_NULL_HANDLE;
+        resource.unormTwinView = 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.unormTwinView != VK_NULL_HANDLE) {
+                vkDestroyImageView(m_device, release.unormTwinView, 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);
         }
     }
 
@@ -249,12 +303,94 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
 
         const auto internalFormat = renderbuffer->GetInternalFormat();
-        const VkFormat format = MG_Util::ConvertTextureInternalFormatToVkEnum(internalFormat);
+        // Three-channel color formats widen to their RGBA twin exactly like textures do
+        // (VkTextureManager::ResolveTextureFormatInfo): blits/resolves between a
+        // renderbuffer and a texture of the same GL format then see one VkFormat.
+        const VkFormat format = [&]() -> VkFormat {
+            switch (internalFormat) {
+            case TextureInternalFormat::RGB:
+            case TextureInternalFormat::RGB8:
+            case TextureInternalFormat::R3G3B2:
+            case TextureInternalFormat::RGB4:
+            case TextureInternalFormat::RGB5:
+                return VK_FORMAT_R8G8B8A8_UNORM;
+            case TextureInternalFormat::SRGB8:
+                return VK_FORMAT_R8G8B8A8_SRGB;
+            case TextureInternalFormat::RGB8Snorm:
+                return VK_FORMAT_R8G8B8A8_SNORM;
+            case TextureInternalFormat::RGB10:
+            case TextureInternalFormat::RGB12:
+            case TextureInternalFormat::RGB16:
+                return VK_FORMAT_R16G16B16A16_UNORM;
+            case TextureInternalFormat::RGB16Snorm:
+                return VK_FORMAT_R16G16B16A16_SNORM;
+            case TextureInternalFormat::RGB16F:
+                return VK_FORMAT_R16G16B16A16_SFLOAT;
+            case TextureInternalFormat::RGB32F:
+                return VK_FORMAT_R32G32B32A32_SFLOAT;
+            case TextureInternalFormat::RGB8I:
+                return VK_FORMAT_R8G8B8A8_SINT;
+            case TextureInternalFormat::RGB8UI:
+                return VK_FORMAT_R8G8B8A8_UINT;
+            case TextureInternalFormat::RGB16I:
+                return VK_FORMAT_R16G16B16A16_SINT;
+            case TextureInternalFormat::RGB16UI:
+                return VK_FORMAT_R16G16B16A16_UINT;
+            case TextureInternalFormat::RGB32I:
+                return VK_FORMAT_R32G32B32A32_SINT;
+            case TextureInternalFormat::RGB32UI:
+                return VK_FORMAT_R32G32B32A32_UINT;
+            default:
+                return 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;
+
+        // GL allows the implementation to allocate more samples than requested
+        // (glRenderbufferStorageMultisample only promises "at least"), and devices
+        // like llvmpipe expose 1x/4x but not 2x. Round the request up to the
+        // nearest supported count for this format.
+        if (renderbuffer->GetSamples() > 0) {
+            auto supportedIt = m_attachmentSampleCountsByFormat.find(format);
+            if (supportedIt == m_attachmentSampleCountsByFormat.end()) {
+                VkImageFormatProperties formatProperties{};
+                VkSampleCountFlags supported = VK_SAMPLE_COUNT_1_BIT;
+                if (vkGetPhysicalDeviceImageFormatProperties(m_physicalDevice, format, VK_IMAGE_TYPE_2D,
+                                                             VK_IMAGE_TILING_OPTIMAL, imageUsage, 0,
+                                                             &formatProperties) == VK_SUCCESS) {
+                    supported = formatProperties.sampleCounts;
+                }
+                supportedIt = m_attachmentSampleCountsByFormat.emplace(format, supported).first;
+            }
+            const VkSampleCountFlags supported = supportedIt->second;
+            if ((supported & sampleCount) == 0) {
+                // Smallest supported count above the request, else the largest below it.
+                Uint32 rounded = 0;
+                for (Uint32 bit = static_cast<Uint32>(sampleCount) << 1; bit <= VK_SAMPLE_COUNT_64_BIT; bit <<= 1) {
+                    if ((supported & bit) != 0) {
+                        rounded = bit;
+                        break;
+                    }
+                }
+                if (rounded == 0) {
+                    for (Uint32 bit = static_cast<Uint32>(sampleCount) >> 1; bit != 0; bit >>= 1) {
+                        if ((supported & bit) != 0) {
+                            rounded = bit;
+                            break;
+                        }
+                    }
+                }
+                if (rounded != 0) {
+                    sampleCount = static_cast<VkSampleCountFlagBits>(rounded);
+                }
+            }
         }
 
         auto& resource = m_renderbufferResources[renderbuffer.get()];
@@ -268,9 +404,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,9 +427,15 @@ 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;
+        // sRGB renderbuffers attach through their UNORM twin while GL_FRAMEBUFFER_SRGB
+        // is disabled, which needs a format-reinterpreting second view.
+        const Bool hasUnormTwin = ResolveSrgbAttachmentWriteFormat(format, false) != format;
+        if (hasUnormTwin) {
+            imageInfo.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
+        }
 
         VkImageFormatProperties imageFormatProperties{};
         const VkResult imageFormatResult = vkGetPhysicalDeviceImageFormatProperties(
@@ -322,6 +470,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         viewInfo.subresourceRange.layerCount = 1;
         VK_VERIFY(vkCreateImageView(m_device, &viewInfo, nullptr, &resource.view),
                   "vkCreateImageView(renderbuffer)");
+        if (hasUnormTwin) {
+            viewInfo.format = ResolveSrgbAttachmentWriteFormat(format, false);
+            VK_VERIFY(vkCreateImageView(m_device, &viewInfo, nullptr, &resource.unormTwinView),
+                      "vkCreateImageView(renderbuffer unorm twin)");
+        }
 
         resource.layout = VK_IMAGE_LAYOUT_UNDEFINED;
         resource.format = format;
@@ -386,6 +539,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},
@@ -406,12 +571,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     VkRenderPassManager::HashType VkRenderPassManager::ComputeHash(
-        const MG_State::GLState::FramebufferObject& fbo, Uint32 swapchainImageIndex, Bool includePendingClear) {
+        const MG_State::GLState::FramebufferObject& fbo, Uint32 swapchainImageIndex, Bool includePendingClear,
+        Bool includeDefaultFboDepthStencil) {
         XXHASH_VERIFY(XXH64_reset(m_hashState, m_config.CacheVersion));
         const Bool isDefaultFbo = fbo.IsDefaultFramebuffer();
         if (isDefaultFbo) {
             XXHASH_VERIFY(XXH64_update(m_hashState, &swapchainImageIndex, sizeof(swapchainImageIndex)));
         }
+        // sRGB attachments switch between their sRGB and UNORM-twin views with this
+        // capability (ResolveSrgbAttachmentWriteFormat), changing the render pass formats.
+        const Bool framebufferSrgbEnabled =
+            MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb);
+        XXHASH_VERIFY(XXH64_update(m_hashState, &framebufferSrgbEnabled, sizeof(framebufferSrgbEnabled)));
         auto& drawBuffers = fbo.GetDrawBuffers();
         XXHASH_VERIFY(XXH64_update(m_hashState, drawBuffers.data(), drawBuffers.size() * sizeof(drawBuffers[0])));
         auto readBuffer = fbo.GetReadBuffer();
@@ -485,9 +656,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                          attachment <= FramebufferAttachmentType::BackRight);
                     if (isDefaultColorAttachment) {
                         currentLayout = m_swapchainObject.GetImageLayout(swapchainImageIndex);
+                        // Content validity feeds the attachment's loadOp (see the
+                        // creation path), so it must key the cache as well.
+                        if (!m_swapchainObject.IsImageContentDefined(swapchainImageIndex)) {
+                            currentLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+                        }
                     } else if (attachment == FramebufferAttachmentType::Depth ||
                                attachment == FramebufferAttachmentType::Stencil) {
                         currentLayout = m_swapchainObject.GetDepthStencilImageLayout(swapchainImageIndex);
+                        if (!m_swapchainObject.IsDepthStencilContentDefined(swapchainImageIndex)) {
+                            currentLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+                        }
                     }
                 } else {
                     auto* textureResource = m_textureManager.SyncTextureAndGetDescriptor(*texture);
@@ -542,14 +721,49 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             combineFramebufferAttachmentObjHash(drawbuf);
         }
 
-        combineFramebufferAttachmentObjHash(FramebufferAttachmentType::Depth);
-        combineFramebufferAttachmentObjHash(FramebufferAttachmentType::Stencil);
+        // The depth-less default-FBO flavor omits the depth/stencil attachment
+        // entirely, so it must hash differently from the depth-full flavor.
+        const Bool depthStencilIncluded = !isDefaultFbo || includeDefaultFboDepthStencil;
+        XXHASH_VERIFY(XXH64_update(m_hashState, &depthStencilIncluded, sizeof(depthStencilIncluded)));
+        if (depthStencilIncluded) {
+            combineFramebufferAttachmentObjHash(FramebufferAttachmentType::Depth);
+            combineFramebufferAttachmentObjHash(FramebufferAttachmentType::Stencil);
+        }
 
         return XXH64_digest(m_hashState);
     }
 
     RenderPassEntry& VkRenderPassManager::GetOrCreateRenderPass(const MG_State::GLState::FramebufferObject& fbo,
-                                                                Uint32 swapchainImageIndex) {
+                                                                Uint32 swapchainImageIndex,
+                                                                Bool drawUsesDepthStencil) {
+        // Resolve the default-FBO depth flavor (see the header comment): keep the
+        // depth attachment when the caller needs it, when a depth/stencil clear is
+        // pending, or when the active pass already carries it (escalate-only, so
+        // alternating depth-less draws never split an established depth pass).
+        Bool includeDefaultFboDepthStencil = true;
+        if (fbo.IsDefaultFramebuffer()) {
+            Bool activeDefaultHasDepthStencil = false;
+            if (const auto* active = GetActiveRenderPass()) {
+                Bool activeIsSwapchainPass = false;
+                Bool activeHasSwapchainDepthStencil = false;
+                for (const auto& tracked : active->trackedAttachmentLayouts) {
+                    activeIsSwapchainPass |= tracked.target == TrackedAttachmentTarget::SwapchainColor;
+                    activeHasSwapchainDepthStencil |=
+                        tracked.target == TrackedAttachmentTarget::SwapchainDepthStencil;
+                }
+                activeDefaultHasDepthStencil = activeIsSwapchainPass && activeHasSwapchainDepthStencil;
+            }
+            const auto& defaultDepthAtt = fbo.GetAttachment(FramebufferAttachmentType::Depth);
+            const auto& defaultStencilAtt = fbo.GetAttachment(FramebufferAttachmentType::Stencil);
+            const Bool pendingDepthStencilClear =
+                (defaultDepthAtt.IsTexture() && m_clearManager.HasPendingClear(defaultDepthAtt)) ||
+                HasPendingRenderbufferClear(defaultDepthAtt) ||
+                (defaultStencilAtt.IsTexture() && m_clearManager.HasPendingClear(defaultStencilAtt)) ||
+                HasPendingRenderbufferClear(defaultStencilAtt);
+            includeDefaultFboDepthStencil =
+                drawUsesDepthStencil || activeDefaultHasDepthStencil || pendingDepthStencilClear;
+        }
+
         auto hasPendingClearOnFramebuffer = [&]() -> Bool {
             const auto& drawBuffers = fbo.GetDrawBuffers();
             for (auto attachment : drawBuffers) {
@@ -599,6 +813,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_rpFastFboVersion == fbo.GetObjectVersion() && m_rpFastSwapchainIndex == swapchainImageIndex &&
             m_rpFastTexEpoch == m_textureManager.GetTextureImageEpoch() &&
             m_rpFastRbEpoch == m_renderbufferImageEpoch &&
+            (!fbo.IsDefaultFramebuffer() || m_rpFastHadDepthStencil == includeDefaultFboDepthStencil) &&
             m_rpFastRenderPassHash == activeRenderPass->hash && !hasPendingClearOnFramebuffer()) {
             auto activeIt = m_renderPasses.find(activeRenderPass->hash);
             if (activeIt != m_renderPasses.end()) {
@@ -607,7 +822,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         }
 
-        auto compatibilityHash = ComputeHash(fbo, swapchainImageIndex, false);
+        auto compatibilityHash = ComputeHash(fbo, swapchainImageIndex, false, includeDefaultFboDepthStencil);
         if (activeRenderPass != nullptr &&
             activeRenderPass->CompatibleWith(compatibilityHash) &&
             !hasPendingClearOnFramebuffer()) {
@@ -624,10 +839,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_rpFastTexEpoch = m_textureManager.GetTextureImageEpoch();
             m_rpFastRbEpoch = m_renderbufferImageEpoch;
             m_rpFastRenderPassHash = activeRenderPass->hash;
+            m_rpFastHadDepthStencil = activeIt->second.hasDepthStencilAttachment;
             activeIt->second.lastUsedFrame = m_frameCounter;
             return activeIt->second;
         }
-        auto hash = ComputeHash(fbo, swapchainImageIndex, true);
+        auto hash = ComputeHash(fbo, swapchainImageIndex, true, includeDefaultFboDepthStencil);
         auto it = m_renderPasses.find(hash);
         if (it != m_renderPasses.end()) {
             it->second.lastUsedFrame = m_frameCounter;
@@ -682,6 +898,88 @@ 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;
+                    const Bool rbFramebufferSrgb =
+                        MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb);
+                    const VkFormat rbAttachmentFormat =
+                        ResolveSrgbAttachmentWriteFormat(rbResource->format, rbFramebufferSrgb);
+                    rbDesc.flags = 0;
+                    rbDesc.format = rbAttachmentFormat;
+                    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(rbAttachmentFormat != rbResource->format ? rbResource->unormTwinView
+                                                                                          : 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 +998,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 ?
@@ -738,6 +1040,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         MOBILEGL_ASSERT(swapchainImageIndex < swapchainViews.size(),
                                         "GetOrCreateRenderPass: swapchain image index out of range");
                         trackedColorLayout = m_swapchainObject.GetImageLayout(swapchainImageIndex);
+                        // EGL: a presented color buffer's content is undefined when its
+                        // image comes back around (EGL_BUFFER_DESTROYED, the default
+                        // swap behaviour) - skip the tile load instead of reloading
+                        // stale pixels nobody may rely on.
+                        if (!hasClear && !m_swapchainObject.IsImageContentDefined(swapchainImageIndex)) {
+                            trackedColorLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+                        }
                         trackedAttachmentLayouts.emplace_back(TrackedAttachmentLayoutInfo {
                             .target = TrackedAttachmentTarget::SwapchainColor,
                             .swapchainImageIndex = swapchainImageIndex,
@@ -751,12 +1060,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         MOBILEGL_ASSERT(textureResource,
                                         "GetOrCreateRenderPass: SyncTextureAndGetDescriptor failed at color attachment %d", i);
                         textureResources.emplace_back(textureResource);
-                        desc.format = textureResource->format;
+                        desc.format = ResolveSrgbAttachmentWriteFormat(
+                            textureResource->format,
+                            MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb));
                         attachmentSampleCount = textureResource->sampleCount;
                         trackedColorLayout = textureResource->layout;
                         trackedAttachmentLayouts.emplace_back(TrackedAttachmentLayoutInfo {
                             .target = TrackedAttachmentTarget::Texture,
                             .texture = att.GetTexture(),
+                            .textureRaw = att.GetTexture().get(),
                             .textureMipLevel = attachmentMipLevel,
                             .finalLayout = desc.finalLayout,
                         });
@@ -820,6 +1132,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         };
         const auto* selectedDepthStencilAttachment = isUsableDepthStencilAttachment(depthAtt) ? &depthAtt :
                                                      (isUsableDepthStencilAttachment(stencilAtt) ? &stencilAtt : nullptr);
+        // Depth-less default-FBO flavor: nothing in this pass touches depth/stencil
+        // and their content is undefined anyway (EGL swap), so drop the attachment
+        // and its whole tile load + store.
+        if (isDefaultFbo && !includeDefaultFboDepthStencil) {
+            selectedDepthStencilAttachment = nullptr;
+        }
         const Bool hasDistinctDepthAndStencilAttachments =
             isUsableDepthStencilAttachment(depthAtt) && isUsableDepthStencilAttachment(stencilAtt) &&
             !sameDepthStencilAttachmentObject(depthAtt, stencilAtt);
@@ -838,6 +1156,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkImageLayout trackedDepthLayout = isDefaultFbo ?
                 m_swapchainObject.GetDepthStencilImageLayout(swapchainImageIndex) :
                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+            // EGL 1.5 §3.10.1: every ancillary (depth/stencil) buffer's content is
+            // undefined after a swap, so the first default-FBO pass of a frame can
+            // skip the depth/stencil tile load outright.
+            if (isDefaultFbo && !m_swapchainObject.IsDepthStencilContentDefined(swapchainImageIndex)) {
+                trackedDepthLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+            }
             depthAttachmentDescription.flags = 0;
             VkSampleCountFlagBits depthAttachmentSampleCount = VK_SAMPLE_COUNT_1_BIT;
             Int depthAttachmentId = 0;
@@ -921,6 +1245,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 trackedAttachmentLayouts.emplace_back(TrackedAttachmentLayoutInfo {
                     .target = TrackedAttachmentTarget::Texture,
                     .texture = selectedDepthStencilAttachment->GetTexture(),
+                    .textureRaw = selectedDepthStencilAttachment->GetTexture().get(),
                     .textureMipLevel = attachmentMipLevel,
                     .finalLayout = depthAttachmentDescription.finalLayout,
                 });
@@ -966,6 +1291,22 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
         const Bool hasDepthStencilAttachment = depthAttachmentRef.attachment != VK_ATTACHMENT_UNUSED;
 
+        // Declare only the used colour-reference span. The GL draw-buffer array
+        // always spans 8 slots, so passes used to declare colorAttachmentCount=8
+        // with trailing VK_ATTACHMENT_UNUSED holes - and Adreno configures its
+        // per-pixel render-backend/export path from the DECLARED count, so every
+        // fragment of every pass paid the 8-target export cost (measured on
+        // Adreno 650 / MC 26.2: 11.9 -> 7.5 ms of GPU time per frame, with the
+        // single-quad swapchain blit pass alone dropping 1.26 -> 0.40 ms).
+        // Interior GL_NONE holes keep their slots so fragment-output locations
+        // still line up; a fragment output at a location past the trimmed count
+        // is discarded, which is exactly GL's semantic for writing to a draw
+        // buffer set to GL_NONE.
+        while (!colorAttachmentRefs.empty() &&
+               colorAttachmentRefs.back().attachment == VK_ATTACHMENT_UNUSED) {
+            colorAttachmentRefs.pop_back();
+        }
+
         // Subpass
         VkSubpassDescription subpassDesc;
         subpassDesc.flags = 0;
@@ -1083,6 +1424,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 +1441,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 +1454,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) {
@@ -1156,6 +1515,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         renderPassBeginInfo.pClearValues = clearValues.data();
 
         vkCmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+        // Pre-pass stream bookkeeping: this pass's attachment images are now
+        // referenced by the open frame recording.
+        if (s_textureManager != nullptr) {
+            for (const auto& tracked : renderPassEntry.trackedAttachmentLayouts) {
+                if (tracked.target == TrackedAttachmentTarget::Texture) {
+                    if (const auto texture = tracked.texture.lock()) {
+                        s_textureManager->StampTextureRecordingUse(texture.get());
+                    }
+                }
+            }
+        }
         for (const auto& pending: renderPassEntry.pendingClearAttachments) {
             if (pending.hasInlinePayload) {
                 if (s_renderPassManager != nullptr) {
@@ -1208,11 +1578,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     case TrackedAttachmentTarget::SwapchainColor:
                         MOBILEGL_ASSERT(s_swapchainObject != nullptr, "EndRenderPass: swapchain object is null");
                         s_swapchainObject->SetImageLayout(trackedAttachment.swapchainImageIndex, trackedAttachment.finalLayout);
+                        // The pass stored into the attachment: its content is defined
+                        // until the image is next presented.
+                        s_swapchainObject->SetImageContentDefined(trackedAttachment.swapchainImageIndex, true);
                         break;
                     case TrackedAttachmentTarget::SwapchainDepthStencil:
                         MOBILEGL_ASSERT(s_swapchainObject != nullptr, "EndRenderPass: swapchain object is null");
                         s_swapchainObject->SetDepthStencilImageLayout(trackedAttachment.swapchainImageIndex,
                                                                       trackedAttachment.finalLayout);
+                        s_swapchainObject->SetDepthStencilContentDefined(trackedAttachment.swapchainImageIndex, true);
                         break;
                     default:
                         MOBILEGL_ASSERT(false, "EndRenderPass: unsupported tracked attachment target=%d",

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.h

@@ -42,6 +42,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     struct TrackedAttachmentLayoutInfo {
         TrackedAttachmentTarget target = TrackedAttachmentTarget::Texture;
         WeakPtr<MG_State::GLState::ITextureObject> texture;
+        // Identity-compare shortcut for the per-draw "does the active pass use
+        // this sampled texture" probe: comparing this against a LIVE texture's
+        // address needs no weak_ptr::lock (two refcount atomics per probe).
+        // May dangle once the texture dies - compare only, never dereference.
+        MG_State::GLState::ITextureObject* textureRaw = nullptr;
         WeakPtr<MG_State::GLState::RenderbufferObject> renderbuffer;
         Uint32 textureMipLevel = 0;
         Uint32 swapchainImageIndex = 0;
@@ -157,19 +162,53 @@ 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();
 
         HashType ComputeHash(
             const MG_State::GLState::FramebufferObject& fbo,
             Uint32 swapchainImageIndex,
-            Bool includePendingClear = true);
-        RenderPassEntry& GetOrCreateRenderPass(const MG_State::GLState::FramebufferObject& fbo, Uint32 swapchainImageIndex);
+            Bool includePendingClear = true,
+            Bool includeDefaultFboDepthStencil = true);
+        // drawUsesDepthStencil: whether the operation about to run inside the pass
+        // reads or writes the depth/stencil buffer (depth test or stencil test
+        // enabled, or a depth/stencil clear). Only consulted for the DEFAULT
+        // framebuffer: EGL undefines its ancillary buffers at every swap, so a
+        // default-FBO pass whose draws provably never touch depth/stencil is
+        // created WITHOUT the depth attachment - on a tiler that skips the whole
+        // depth tile load AND store. The flavor only escalates: once a pass with
+        // depth is active, later depth-less draws keep using it, and a depth-using
+        // draw against a depth-less active pass resolves to a new (incompatible)
+        // entry, which the caller's compatibility check turns into a pass split;
+        // the new pass's depth loads DONT_CARE (content was undefined all along).
+        RenderPassEntry& GetOrCreateRenderPass(const MG_State::GLState::FramebufferObject& fbo,
+                                               Uint32 swapchainImageIndex,
+                                               Bool drawUsesDepthStencil = true);
         void QueueRenderbufferClear(GLbitfield mask, const ClearFramebufferPayload& clearPayload,
                                     const MG_State::GLState::FramebufferObject& drawFbo);
         void QueueRenderbufferClear(const ClearAttachmentPayload& clearPayload,
@@ -192,12 +231,20 @@ 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
         // image recreation.
         Uint64 m_renderbufferImageEpoch = 1;
 
+    public:
+        // Bumped whenever a renderbuffer backing is (re)created; consecutive-draw
+        // snapshots include it so an attachment respecify forces a re-resolve.
+        Uint64 GetRenderbufferImageEpoch() const { return m_renderbufferImageEpoch; }
+
+    private:
+
         // Per-draw fast-path memo for GetOrCreateRenderPass (dirty-flag state tracking): when the
         // framebuffer state is provably unchanged since the last resolution, the active render pass
         // is reused WITHOUT recomputing the expensive per-draw hash. Invalidated by FBO switch /
@@ -210,12 +257,26 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint64 m_rpFastTexEpoch = 0;
         Uint64 m_rpFastRbEpoch = 0;
         Uint64 m_rpFastRenderPassHash = 0;
+        // Whether the memoized entry carries a depth/stencil attachment; a
+        // default-FBO resolution whose effective depth request differs must
+        // miss the memo (the depth-less/depth-full flavors hash differently).
+        Bool m_rpFastHadDepthStencil = false;
 
+    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;
             VkImageView view = VK_NULL_HANDLE;
+            // UNORM reinterpretation of an sRGB image, used as the attachment view while
+            // GL_FRAMEBUFFER_SRGB is disabled (raw writes). Null for non-sRGB formats.
+            VkImageView unormTwinView = VK_NULL_HANDLE;
             VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
             VkFormat format = VK_FORMAT_UNDEFINED;
             VkImageAspectFlags aspect = VK_IMAGE_ASPECT_NONE;
@@ -223,25 +284,51 @@ 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;
+            VkImageView unormTwinView = 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;
+        // Supported sample counts per attachment format, so per-draw resource lookups
+        // do not repeat vkGetPhysicalDeviceImageFormatProperties.
+        UnorderedMap<VkFormat, VkSampleCountFlags> m_attachmentSampleCountsByFormat;
 
-        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

@@ -120,31 +120,21 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     static Bool TryResolveSampleCountFlagBits(Int requestedSamples, VkSampleCountFlagBits& outSampleCount) {
-        switch (requestedSamples) {
-        case 1:
+        // GL promises "at least the requested samples", so a non-power-of-two
+        // request (legal in GL, e.g. 3) rounds up to the next Vulkan bit.
+        if (requestedSamples <= 1) {
             outSampleCount = VK_SAMPLE_COUNT_1_BIT;
             return true;
-        case 2:
-            outSampleCount = VK_SAMPLE_COUNT_2_BIT;
-            return true;
-        case 4:
-            outSampleCount = VK_SAMPLE_COUNT_4_BIT;
-            return true;
-        case 8:
-            outSampleCount = VK_SAMPLE_COUNT_8_BIT;
-            return true;
-        case 16:
-            outSampleCount = VK_SAMPLE_COUNT_16_BIT;
-            return true;
-        case 32:
-            outSampleCount = VK_SAMPLE_COUNT_32_BIT;
-            return true;
-        case 64:
-            outSampleCount = VK_SAMPLE_COUNT_64_BIT;
-            return true;
-        default:
+        }
+        if (requestedSamples > 64) {
             return false;
         }
+        Uint32 bit = 1;
+        while (bit < static_cast<Uint32>(requestedSamples)) {
+            bit <<= 1;
+        }
+        outSampleCount = static_cast<VkSampleCountFlagBits>(bit);
+        return true;
     }
 
     static Bool IsCubeMapFaceUploadTarget(TextureUploadTarget target) {
@@ -375,7 +365,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 +577,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);
@@ -590,9 +597,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     void VkTextureManager::Shutdown() {
+        if (m_device != VK_NULL_HANDLE) {
+            ReclaimCompletedUploads(/*waitAll=*/true);
+        }
         DestroyDeferredReleases();
+        ++m_resourceEraseEpoch;  // every memoized resource pointer dies with the map
         m_textureResources.clear();
         m_aliveObjects.clear();
+        m_storageImageTextures.clear();
 
         m_device = VK_NULL_HANDLE;
         m_physicalDevice = VK_NULL_HANDLE;
@@ -611,6 +623,27 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         frameIndex, m_deferredViewReleases.size());
         m_currentFrameIndex = frameIndex;
         CollectDeferredReleases(frameIndex);
+        ReclaimCompletedUploads();
+
+        // 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 +653,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_textureResources.erase(resourceIt);
         }
         m_aliveObjects.erase(identity);
+        m_storageImageTextures.erase(identity);
+        // Invalidate every cross-draw sampled-texture memo: the erased
+        // resource's address may be reused by a future emplace.
+        ++m_resourceEraseEpoch;
     }
 
     void VkTextureManager::PruneStaleTextureAliases(MG_State::GLState::ITextureObject* texture) {
@@ -675,32 +712,63 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         }
 
-        auto aliveIt = m_aliveObjects.find(identity);
-        if (aliveIt != m_aliveObjects.end() && aliveIt->second.expired()) {
-            EraseTrackedTexture(aliveIt->first);
-            aliveIt = m_aliveObjects.end();
-        }
-
-        // Only (re)register and prune when this (texture, lifetime) pair is new: stale
-        // aliases can only come into existence through an address reuse, which by
-        // 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()) {
-            const auto& liveTexture = MG_State::pGLContext->GetTextureObject(texture.GetExternalIndex());
-            if (liveTexture && liveTexture.get() == &texture) {
-                m_aliveObjects[identity] = WeakPtr<MG_State::GLState::ITextureObject>(liveTexture);
-                PruneStaleTextureAliases(&texture);
+        // Cross-draw memo probe (see SyncedTextureMemoEntry): skips both map
+        // lookups and the (re)registration path for repeat-bound textures.
+        TextureResource* resourcePtr = nullptr;
+        for (Uint32 i = 0; i < kSyncedTextureMemoSize; ++i) {
+            const SyncedTextureMemoEntry& memo = m_syncedTextureMemo[i];
+            if (memo.texture == &texture && memo.lifetimeId == identity.lifetimeId &&
+                memo.eraseEpoch == m_resourceEraseEpoch) {
+                resourcePtr = memo.resource;
+                break;
             }
         }
 
-        auto it = m_textureResources.find(identity);
-        if (it == m_textureResources.end()) {
-            TextureResource initial{};
-            auto [insertIt, _] = m_textureResources.emplace(identity, Move(initial));
-            it = insertIt;
+        if (resourcePtr == nullptr) {
+            auto aliveIt = m_aliveObjects.find(identity);
+            if (aliveIt != m_aliveObjects.end() && aliveIt->second.expired()) {
+                EraseTrackedTexture(aliveIt->first);
+                aliveIt = m_aliveObjects.end();
+            }
+
+            // Only (re)register and prune when this (texture, lifetime) pair is new: stale
+            // aliases can only come into existence through an address reuse, which by
+            // 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) {
+                    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);
+                }
+            }
+
+            auto it = m_textureResources.find(identity);
+            if (it == m_textureResources.end()) {
+                TextureResource initial{};
+                auto [insertIt, _] = m_textureResources.emplace(identity, Move(initial));
+                it = insertIt;
+            }
+            resourcePtr = &(it->second);
+            m_syncedTextureMemo[m_syncedTextureMemoNext] =
+                SyncedTextureMemoEntry{&texture, identity.lifetimeId, m_resourceEraseEpoch, resourcePtr};
+            m_syncedTextureMemoNext = (m_syncedTextureMemoNext + 1) % kSyncedTextureMemoSize;
         }
 
-        if (!SyncTexture(texture, it->second)) {
+        if (!SyncTexture(texture, *resourcePtr)) {
             MGLOG_D("%s: Syncing texture %d failed", __func__, texture.GetExternalIndex());
             return nullptr;
         }
@@ -714,11 +782,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 }
             }
             if (!recorded) {
-                m_drawSyncedThisDraw.push_back({identity, &(it->second)});
+                m_drawSyncedThisDraw.push_back({identity, resourcePtr});
             }
         }
 
-        return &(it->second);
+        return resourcePtr;
     }
 
     VkImageView VkTextureManager::GetOrCreateViewAtMipLevel(MG_State::GLState::ITextureObject& texture, Uint32 mipLevel) {
@@ -762,7 +830,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return VK_NULL_HANDLE;
         }
 
-        if (baseArrayLayer == 0 && layerCount == resource->arrayLayers && viewType == resource->viewType) {
+        const Bool framebufferSrgbEnabled =
+            MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb);
+        const VkFormat attachmentFormat = ResolveSrgbAttachmentWriteFormat(resource->format, framebufferSrgbEnabled);
+
+        if (attachmentFormat == resource->format && baseArrayLayer == 0 && layerCount == resource->arrayLayers &&
+            viewType == resource->viewType) {
             return GetOrCreateViewAtMipLevel(texture, mipLevel);
         }
 
@@ -771,6 +844,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             .baseArrayLayer = baseArrayLayer,
             .layerCount = layerCount,
             .viewType = viewType,
+            .viewFormat = attachmentFormat,
         };
         auto it = resource->attachmentViews.find(key);
         if (it == resource->attachmentViews.end()) {
@@ -781,7 +855,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return attachmentView;
         }
 
-        attachmentView = CreateImageView(resource->image, resource->format, resource->aspect, viewType,
+        attachmentView = CreateImageView(resource->image, attachmentFormat, resource->aspect, viewType,
                                          mipLevel, 1, baseArrayLayer, layerCount);
         if (attachmentView == VK_NULL_HANDLE) {
             MGLOG_D("%s: CreateImageView failed for textureId=%d mipLevel=%u baseArrayLayer=%u layerCount=%u viewType=%d",
@@ -997,6 +1071,16 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return view;
     }
 
+    void VkTextureManager::StampTextureRecordingUse(MG_State::GLState::ITextureObject* texture) {
+        if (texture == nullptr) {
+            return;
+        }
+        auto it = m_textureResources.find(MakeTextureIdentity(texture));
+        if (it != m_textureResources.end()) {
+            it->second.lastRecordingGeneration = m_recordingGeneration;
+        }
+    }
+
     void VkTextureManager::UpdateTrackedImageLayout(MG_State::GLState::ITextureObject* texture, VkImageLayout newLayout) {
         MOBILEGL_ASSERT(texture != nullptr, "UpdateTrackedImageLayout: texture is null");
         auto it = m_textureResources.find(MakeTextureIdentity(texture));
@@ -1024,6 +1108,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         MOBILEGL_ASSERT(writtenMipLevel < resource.mipLevels,
                         "UpdateTrackedImageLayoutAfterAttachmentWrite: textureId=%d mipLevel=%u out of range %u",
                         texture->GetExternalIndex(), writtenMipLevel, resource.mipLevels);
+        // Pre-pass stream bookkeeping: the render pass that just ended wrote this image.
+        StampResourceRecordingUse(resource);
 
         if (resource.layout != newLayout && resource.mipLevels > 1) {
             VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
@@ -1108,6 +1194,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                               VK_ACCESS_SHADER_READ_BIT, resource->aspect, 0, resource->mipLevels,
                                               resource->arrayLayers);
         MOBILEGL_ASSERT(ok, "TransitionTextureForSampling: transition failed for textureId=%d", texture.GetExternalIndex());
+        // Pre-pass stream bookkeeping: a command referencing the image was recorded.
+        StampResourceRecordingUse(*resource);
         return ok;
     }
 
@@ -1137,11 +1225,30 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                               resource->aspect, 0, resource->mipLevels, resource->arrayLayers);
         MOBILEGL_ASSERT(ok, "TransitionTextureForStorageImage: transition failed for textureId=%d",
                         texture.GetExternalIndex());
+        // Pre-pass stream bookkeeping: a command referencing the image was recorded.
+        StampResourceRecordingUse(*resource);
         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 +1256,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 +1309,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 +1336,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 +1368,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) {
@@ -1295,11 +1444,23 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                const IntVec3 &texelSize, SizeT byteSize, Uint32 mipLevels,
                                                TextureResource &resource) {
         const TextureFormatInfo formatInfo = ResolveTextureFormatInfo(texture.GetFormat());
-        const VkFormat format = formatInfo.format;
+        VkFormat format = formatInfo.format;
         if (format == VK_FORMAT_UNDEFINED) {
             MGLOG_D("%s: format == VK_FORMAT_UNDEFINED", __func__);
             return false;
         }
+        // X8_D24 lacks optimal-tiling support on several drivers (lavapipe included);
+        // D32_SFLOAT holds every 24-bit depth value exactly, and the upload path
+        // converts the shadow words to float (see the pure-depth branch below).
+        if (format == VK_FORMAT_X8_D24_UNORM_PACK32) {
+            VkFormatProperties formatProperties{};
+            vkGetPhysicalDeviceFormatProperties(m_physicalDevice, format, &formatProperties);
+            constexpr VkFormatFeatureFlags kDepthAttachmentAndSample =
+                VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
+            if ((formatProperties.optimalTilingFeatures & kDepthAttachmentAndSample) != kDepthAttachmentAndSample) {
+                format = VK_FORMAT_D32_SFLOAT;
+            }
+        }
         if (texelSize.x() <= 0 || texelSize.y() <= 0 /*|| byteSize == 0*/) {
             MGLOG_D("%s: texelSize or byteSize is zero", __func__);
             return false;
@@ -1309,8 +1470,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return false;
         }
         const Bool isMultisampleTexture = IsMultisampleTextureUploadTarget(uploadTarget);
+        // A texture that has only ever defined level 0 gets a single-level backing
+        // (ANGLE's model). Preallocating the full chain put every render target
+        // onto Adreno's multi-mip image layout and grew each texture by a third
+        // for levels most textures never define. Once a second level is defined
+        // the backing is recreated ONE time with the full chain (the
+        // preserve-copy path below carries the pixels over), so sequentially-
+        // defined atlas mips do not recreate per level, and glGenerateMipmap -
+        // which defines every level before syncing - works unchanged.
         const Uint32 backingMipLevels =
-            isMultisampleTexture ? 1u : std::max(mipLevels, ComputeFullMipLevelCount(texelSize));
+            isMultisampleTexture ? 1u
+            : (mipLevels > 1 ? std::max(mipLevels, ComputeFullMipLevelCount(texelSize)) : 1u);
         TextureShapeInfo shapeInfo{};
         const Bool supportedShape = TryResolveTextureShapeInfo(texture, uploadTarget, texelSize, shapeInfo);
         MOBILEGL_ASSERT(supportedShape,
@@ -1336,15 +1506,89 @@ 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;
         }
+        // sRGB color images attach through their UNORM twin while GL_FRAMEBUFFER_SRGB is
+        // disabled (see ResolveSrgbAttachmentWriteFormat), which needs format-reinterpreting
+        // views - multisample sRGB render targets included.
+        if (ResolveSrgbAttachmentWriteFormat(format, false) != format &&
+            (aspect & VK_IMAGE_ASPECT_COLOR_BIT) != 0 &&
+            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;
+        }
+
+        // Round a multisample request up to a count the device supports for this
+        // format (GL only promises "at least"), mirroring the renderbuffer path.
+        if (isMultisampleTexture && resolvedSampleCount != VK_SAMPLE_COUNT_1_BIT) {
+            auto supportedIt = m_multisampleCountsByFormat.find(format);
+            if (supportedIt == m_multisampleCountsByFormat.end()) {
+                VkImageFormatProperties imageFormatProperties{};
+                VkSampleCountFlags supported = VK_SAMPLE_COUNT_1_BIT;
+                if (vkGetPhysicalDeviceImageFormatProperties(m_physicalDevice, format, shapeInfo.imageType,
+                                                             VK_IMAGE_TILING_OPTIMAL, desiredUsage, imageCreateFlags,
+                                                             &imageFormatProperties) == VK_SUCCESS) {
+                    supported = imageFormatProperties.sampleCounts;
+                }
+                supportedIt = m_multisampleCountsByFormat.emplace(format, supported).first;
+            }
+            const VkSampleCountFlags supported = supportedIt->second;
+            if ((supported & resolvedSampleCount) == 0) {
+                Uint32 rounded = 0;
+                for (Uint32 bit = static_cast<Uint32>(resolvedSampleCount) << 1; bit <= VK_SAMPLE_COUNT_64_BIT;
+                     bit <<= 1) {
+                    if ((supported & bit) != 0) {
+                        rounded = bit;
+                        break;
+                    }
+                }
+                if (rounded == 0) {
+                    for (Uint32 bit = static_cast<Uint32>(resolvedSampleCount) >> 1; bit != 0; bit >>= 1) {
+                        if ((supported & bit) != 0) {
+                            rounded = bit;
+                            break;
+                        }
+                    }
+                }
+                if (rounded != 0) {
+                    resolvedSampleCount = static_cast<VkSampleCountFlagBits>(rounded);
+                }
+            }
+        }
 
         const Bool compatible = resource.image != VK_NULL_HANDLE && resource.format == format &&
                                 resource.extent.width == static_cast<Uint32>(texelSize.x()) &&
@@ -1354,6 +1598,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 +1607,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 +1625,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 +1650,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(
@@ -1446,8 +1719,21 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VmaAllocationCreateInfo allocationInfo{};
         allocationInfo.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
         allocationInfo.requiredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
-        VK_VERIFY(vmaCreateImage(m_allocator, &imageInfo, &allocationInfo, &resource.image, &resource.allocation, nullptr),
-                  "vmaCreateImage(texture)");
+        // Soft failure like the unsupported-sample-count path above: a driver can pass the
+        // vkGetPhysicalDeviceImageFormatProperties pre-check yet still refuse the creation
+        // (e.g. multisampled depth on lavapipe); the texture simply stays unbacked.
+        const VkResult createImageResult =
+            vmaCreateImage(m_allocator, &imageInfo, &allocationInfo, &resource.image, &resource.allocation, nullptr);
+        if (createImageResult != VK_SUCCESS) {
+            MGLOG_F("SyncTextureResource: vmaCreateImage failed (%d) textureId=%d extent=%ux%u depth=%u layers=%u "
+                    "mips=%u samples=%d format=%d",
+                    createImageResult, texture.GetExternalIndex(), imageInfo.extent.width, imageInfo.extent.height,
+                    imageInfo.extent.depth, imageInfo.arrayLayers, imageInfo.mipLevels,
+                    static_cast<Int>(imageInfo.samples), static_cast<Int>(imageInfo.format));
+            resource.image = VK_NULL_HANDLE;
+            resource.allocation = nullptr;
+            return false;
+        }
         ++m_textureImageEpoch; // a new attachment image invalidates cached render passes
 
         resource.layout = VK_IMAGE_LAYOUT_UNDEFINED;
@@ -1464,6 +1750,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) {
@@ -1513,6 +1801,28 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_deferredViewReleases[frameIndex].clear();
     }
 
+    void VkTextureManager::ReclaimCompletedUploads(Bool waitAll) {
+        if (m_pendingUploadReclaims.empty()) {
+            return;
+        }
+
+        SizeT completed = 0;
+        for (; completed < m_pendingUploadReclaims.size(); ++completed) {
+            PendingUploadReclaim& entry = m_pendingUploadReclaims[completed];
+            if (waitAll) {
+                VK_VERIFY(vkWaitForFences(m_device, 1, &entry.fence, VK_TRUE, UINT64_MAX),
+                          "vkWaitForFences(texture upload reclaim)");
+            } else if (vkGetFenceStatus(m_device, entry.fence) != VK_SUCCESS) {
+                break;
+            }
+            vkDestroyFence(m_device, entry.fence, nullptr);
+            vkFreeCommandBuffers(m_device, m_commandPool, 1, &entry.commandBuffer);
+            vmaDestroyBuffer(m_allocator, entry.stagingBuffer, entry.stagingAllocation);
+        }
+        m_pendingUploadReclaims.erase(m_pendingUploadReclaims.begin(),
+                                      m_pendingUploadReclaims.begin() + static_cast<std::ptrdiff_t>(completed));
+    }
+
     void VkTextureManager::DestroyDeferredReleases() {
         for (auto& deferredReleases : m_deferredReleases) {
             deferredReleases.clear();
@@ -1714,17 +2024,119 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return true;
         }
 
-        // Combined depth-stencil images need per-aspect de-interleaved copies (VkBufferImageCopy
-        // aspectMask must have exactly one bit set). Until that is implemented, skip the upload
-        // instead of recording an invalid command buffer that kills the process.
+        // Combined depth-stencil images need per-aspect copies (VkBufferImageCopy aspectMask
+        // must have exactly one bit set), so de-interleave the shadow's GL wire format into
+        // a depth plane followed by a stencil plane per upload item.
         const VkImageAspectFlags uploadAspectMask = GetAspectMaskForFormat(outResource.format);
-        if ((uploadAspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) && (uploadAspectMask & VK_IMAGE_ASPECT_STENCIL_BIT)) {
-            MGLOG_E("UploadDirtyMipLevels: skipping unimplemented depth-stencil data upload for textureId=%d",
-                    mipmapTexture.GetExternalIndex());
-            for (const auto& item : uploadItems) {
-                mipmapTexture.MarkStorageDirty(item.target, item.level, false);
+        const Bool isCombinedDepthStencil =
+            (uploadAspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) && (uploadAspectMask & VK_IMAGE_ASPECT_STENCIL_BIT);
+        if (isCombinedDepthStencil) {
+            const Bool srcIsD24S8 = outResource.format == VK_FORMAT_D24_UNORM_S8_UINT;
+            const Bool srcIsD32FS8 = outResource.format == VK_FORMAT_D32_SFLOAT_S8_UINT;
+            if (!srcIsD24S8 && !srcIsD32FS8) {
+                MGLOG_E("UploadDirtyMipLevels: unsupported combined depth-stencil format %d for textureId=%d",
+                        static_cast<Int>(outResource.format), mipmapTexture.GetExternalIndex());
+                for (const auto& item : uploadItems) {
+                    mipmapTexture.MarkStorageDirty(item.target, item.level, false);
+                }
+                return true;
+            }
+            stagingSize = 0;
+            for (auto& item : uploadItems) {
+                const SizeT texelCount = static_cast<SizeT>(item.texelSize.x()) *
+                                         static_cast<SizeT>(item.texelSize.y()) *
+                                         static_cast<SizeT>(std::max(item.texelSize.z(), 1));
+                const SizeT shadowTexelSize = item.uploadByteSize / std::max<SizeT>(texelCount, 1);
+                MOBILEGL_ASSERT(shadowTexelSize == 4 || shadowTexelSize == 8,
+                                "UploadDirtyMipLevels: unexpected depth-stencil shadow texel size %zu for textureId=%d",
+                                shadowTexelSize, mipmapTexture.GetExternalIndex());
+                // Depth plane as the aspect's buffer-copy format (32-bit word for
+                // D24: low 24 bits; float for D32F), then one stencil byte per texel.
+                Vector<Uint8> deinterleaved(texelCount * 4 + texelCount);
+                Uint8* depthPlane = deinterleaved.data();
+                Uint8* stencilPlane = deinterleaved.data() + texelCount * 4;
+                const Uint8* shadow = static_cast<const Uint8*>(item.source);
+                for (SizeT t = 0; t < texelCount; ++t) {
+                    if (shadowTexelSize == 8) {
+                        // GL_FLOAT_32_UNSIGNED_INT_24_8_REV: float depth, then a word
+                        // with stencil in its low 8 bits.
+                        float depthValue;
+                        Uint32 stencilWord;
+                        std::memcpy(&depthValue, shadow + t * 8, sizeof(depthValue));
+                        std::memcpy(&stencilWord, shadow + t * 8 + 4, sizeof(stencilWord));
+                        if (srcIsD32FS8) {
+                            std::memcpy(depthPlane + t * 4, &depthValue, sizeof(depthValue));
+                        } else {
+                            const float clamped = std::min(std::max(depthValue, 0.0f), 1.0f);
+                            const Uint32 depthWord = static_cast<Uint32>(clamped * 16777215.0f + 0.5f);
+                            std::memcpy(depthPlane + t * 4, &depthWord, sizeof(depthWord));
+                        }
+                        stencilPlane[t] = static_cast<Uint8>(stencilWord & 0xFFu);
+                    } else {
+                        // GL_UNSIGNED_INT_24_8: depth in the high 24 bits, stencil low 8.
+                        Uint32 packed;
+                        std::memcpy(&packed, shadow + t * 4, sizeof(packed));
+                        if (srcIsD24S8) {
+                            const Uint32 depthWord = packed >> 8;
+                            std::memcpy(depthPlane + t * 4, &depthWord, sizeof(depthWord));
+                        } else {
+                            const float depthValue = static_cast<float>(packed >> 8) / 16777215.0f;
+                            std::memcpy(depthPlane + t * 4, &depthValue, sizeof(depthValue));
+                        }
+                        stencilPlane[t] = static_cast<Uint8>(packed & 0xFFu);
+                    }
+                }
+                item.expandedData = Move(deinterleaved);
+                item.source = item.expandedData.data();
+                item.uploadByteSize = item.expandedData.size();
+                item.offset = stagingSize;
+                stagingSize += static_cast<VkDeviceSize>(item.uploadByteSize);
+            }
+        }
+
+        // Pure-depth images whose canonical shadow layout differs from the image texel
+        // layout (the shadow keeps a full-scale 16/32-bit unorm word or a float; the
+        // image may be X8_D24 or a D32_SFLOAT fallback) convert per texel here.
+        if (uploadAspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) {
+            const TextureInternalFormat depthInternal = mipmapTexture.GetFormat();
+            const Bool shadowIsFloat = depthInternal == TextureInternalFormat::DepthComponent32F;
+            const Bool dstIsFloat = outResource.format == VK_FORMAT_D32_SFLOAT;
+            const Bool dstIsD24Word = outResource.format == VK_FORMAT_X8_D24_UNORM_PACK32;
+            stagingSize = 0;
+            for (auto& item : uploadItems) {
+                const SizeT texelCount = static_cast<SizeT>(item.texelSize.x()) *
+                                         static_cast<SizeT>(item.texelSize.y()) *
+                                         static_cast<SizeT>(std::max(item.texelSize.z(), 1));
+                const SizeT shadowTexelSize = item.uploadByteSize / std::max<SizeT>(texelCount, 1);
+                const Bool needsConversion =
+                    (dstIsFloat && !shadowIsFloat) || (dstIsD24Word && shadowTexelSize == 4 && !shadowIsFloat);
+                if (needsConversion) {
+                    Vector<Uint8> converted(texelCount * 4);
+                    const Uint8* shadow = static_cast<const Uint8*>(item.source);
+                    for (SizeT t = 0; t < texelCount; ++t) {
+                        Uint32 wide = 0;
+                        if (shadowTexelSize == 2) {
+                            Uint16 raw = 0;
+                            std::memcpy(&raw, shadow + t * 2, sizeof(raw));
+                            wide = (static_cast<Uint32>(raw) << 16) | raw;
+                        } else {
+                            std::memcpy(&wide, shadow + t * 4, sizeof(wide));
+                        }
+                        if (dstIsFloat) {
+                            const float value = static_cast<float>(static_cast<double>(wide) / 4294967295.0);
+                            std::memcpy(converted.data() + t * 4, &value, sizeof(value));
+                        } else { // X8_D24: depth in the low 24 bits of a 32-bit word
+                            const Uint32 word = wide >> 8;
+                            std::memcpy(converted.data() + t * 4, &word, sizeof(word));
+                        }
+                    }
+                    item.expandedData = Move(converted);
+                    item.source = item.expandedData.data();
+                    item.uploadByteSize = item.expandedData.size();
+                }
+                item.offset = stagingSize;
+                stagingSize += static_cast<VkDeviceSize>(item.uploadByteSize);
             }
-            return true;
         }
 
         VkBuffer stagingBuffer = VK_NULL_HANDLE;
@@ -1777,7 +2189,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                         aspectMask, 0, outResource.mipLevels, outResource.arrayLayers);
         MOBILEGL_ASSERT(ok, "TransitionImageLayout to VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL failed");
 
+        // Array textures keep their GL "depth" in VkImage array layers, so the
+        // copy must address layerCount, not imageExtent.depth (which is invalid
+        // for 2D images and silently dropped every layer past the first).
+        const Bool depthSelectsArrayLayer = outResource.viewType == VK_IMAGE_VIEW_TYPE_1D_ARRAY ||
+                                            outResource.viewType == VK_IMAGE_VIEW_TYPE_2D_ARRAY ||
+                                            outResource.viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
         for (const auto& item : uploadItems) {
+            const Uint32 depthOrLayers = item.texelSize.z() > 0 ? static_cast<Uint32>(item.texelSize.z()) : 1u;
             VkBufferImageCopy copy{};
             copy.bufferOffset = item.offset;
             copy.bufferRowLength = 0;
@@ -1785,10 +2204,24 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             copy.imageSubresource.aspectMask = aspectMask;
             copy.imageSubresource.mipLevel = item.level;
             copy.imageSubresource.baseArrayLayer = item.baseArrayLayer;
-            copy.imageSubresource.layerCount = 1;
+            copy.imageSubresource.layerCount = depthSelectsArrayLayer ? depthOrLayers : 1;
             copy.imageOffset = {0, 0, 0};
             copy.imageExtent = {static_cast<Uint32>(item.texelSize.x()), static_cast<Uint32>(item.texelSize.y()),
-                                item.texelSize.z() > 0 ? static_cast<Uint32>(item.texelSize.z()) : 1u};
+                                depthSelectsArrayLayer ? 1u : depthOrLayers};
+            if (isCombinedDepthStencil) {
+                const SizeT texelCount = static_cast<SizeT>(item.texelSize.x()) *
+                                         static_cast<SizeT>(item.texelSize.y()) *
+                                         static_cast<SizeT>(std::max(item.texelSize.z(), 1));
+                VkBufferImageCopy depthCopy = copy;
+                depthCopy.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+                VkBufferImageCopy stencilCopy = copy;
+                stencilCopy.imageSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
+                stencilCopy.bufferOffset = item.offset + static_cast<VkDeviceSize>(texelCount) * 4;
+                const VkBufferImageCopy copies[2] = {depthCopy, stencilCopy};
+                vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, outResource.image,
+                                       VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 2, copies);
+                continue;
+            }
             vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, outResource.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                    1, &copy);
         }
@@ -1819,11 +2252,23 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VK_VERIFY(vkCreateFence(m_device, &fenceInfo, nullptr, &uploadFence), "vkCreateFence(texture upload)");
 
         VK_VERIFY(vkQueueSubmit(m_graphicsQueue, 1, &submitInfo, uploadFence), "vkQueueSubmit(texture)");
-        VK_VERIFY(vkWaitForFences(m_device, 1, &uploadFence, VK_TRUE, UINT64_MAX), "vkWaitForFences(texture upload)");
-        vkDestroyFence(m_device, uploadFence, nullptr);
-        vkFreeCommandBuffers(m_device, m_commandPool, 1, &commandBuffer);
-
-        vmaDestroyBuffer(m_allocator, stagingBuffer, stagingAllocation);
+        // Do NOT wait the fence here: this submit sits behind the previous
+        // frame's rendering on the queue, so a synchronous wait stalls the CPU
+        // until the GPU drains - a per-frame vkQueueWaitIdle for any workload
+        // with animated textures. Ordering against the current frame's draws is
+        // already guaranteed (its command buffer is submitted later, at
+        // present), so only the transient objects need to survive execution;
+        // park them until the fence signals.
+        m_pendingUploadReclaims.push_back({uploadFence, commandBuffer, stagingBuffer, stagingAllocation});
+        ReclaimCompletedUploads();
+        // Backstop for pathological upload storms: bound in-flight staging
+        // memory by blocking on the oldest upload only once the list is deep.
+        constexpr SizeT kMaxPendingTextureUploads = 16;
+        if (m_pendingUploadReclaims.size() > kMaxPendingTextureUploads) {
+            VK_VERIFY(vkWaitForFences(m_device, 1, &m_pendingUploadReclaims.front().fence, VK_TRUE, UINT64_MAX),
+                      "vkWaitForFences(texture upload backstop)");
+            ReclaimCompletedUploads();
+        }
 
         if (!ok) {
             MGLOG_D("%s: texture upload cmd failed", __func__);

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.h

@@ -28,6 +28,9 @@ public:
     // manager keys its per-draw fast path on this so an attachment's image recreation
     // invalidates the cached render pass (dirty-flag tracking; portable to Vulkan 1.1).
     Uint64 GetTextureImageEpoch() const { return m_textureImageEpoch; }
+    // Bumped whenever any tracked texture resource is erased; cached
+    // TextureResource pointers are valid only while this is unchanged.
+    Uint64 GetResourceEraseEpoch() const { return m_resourceEraseEpoch; }
 
     struct TextureIdentity {
         MG_State::GLState::ITextureObject* texture = nullptr;
@@ -53,6 +56,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 {
@@ -61,12 +67,16 @@ public:
             Uint32 baseArrayLayer = 0;
             Uint32 layerCount = 1;
             VkImageViewType viewType = VK_IMAGE_VIEW_TYPE_2D;
+            // May differ from the image format: sRGB images attach through their UNORM
+            // twin while GL_FRAMEBUFFER_SRGB is disabled.
+            VkFormat viewFormat = VK_FORMAT_UNDEFINED;
 
             Bool operator==(const AttachmentViewKey& other) const {
                 return mipLevel == other.mipLevel &&
                        baseArrayLayer == other.baseArrayLayer &&
                        layerCount == other.layerCount &&
-                       viewType == other.viewType;
+                       viewType == other.viewType &&
+                       viewFormat == other.viewFormat;
             }
         };
 
@@ -77,6 +87,8 @@ public:
                 hash ^= std::hash<Uint32>{}(key.layerCount) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
                 hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.viewType)) +
                         0x9e3779b9u + (hash << 6) + (hash >> 2);
+                hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.viewFormat)) +
+                        0x9e3779b9u + (hash << 6) + (hash >> 2);
                 return hash;
             }
         };
@@ -157,7 +169,25 @@ 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;
+        // Recording generation (VkTextureManager::GetRecordingGeneration) of the last
+        // command referencing this image that was recorded into the CURRENT frame
+        // command buffer. An image untouched by the open recording may have its
+        // out-of-pass work (deferred clears, sampled-layout transitions) recorded
+        // into the frame's PRE command buffer - which executes strictly before the
+        // frame's commands - instead of splitting the active render pass.
+        Uint64 lastRecordingGeneration = 0;
         // Snapshot of ITextureObject::GetContentVersion() at the last successful sync;
         // lets SyncTexture skip the whole re-check/re-upload when content is unchanged.
         Uint64 syncedContentVersion = 0;
@@ -190,7 +220,10 @@ 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->lastRecordingGeneration, that.lastRecordingGeneration);
             std::swap(this->syncedContentVersion, that.syncedContentVersion);
             std::swap(this->syncedMipLevelCount, that.syncedMipLevelCount);
         }
@@ -251,6 +284,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 +302,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 +324,32 @@ public:
                                                       VkImageLayout newLayout);
     Bool TransitionTextureForSampling(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
     Bool TransitionTextureForStorageImage(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
+
+    // Recording-generation bookkeeping for the pre-pass command stream. The
+    // generation advances every time the frame command buffer (re)begins
+    // recording; a resource whose stamp does not match was not referenced by
+    // any command in the open recording, so its out-of-pass work may safely
+    // execute ahead of the whole recording (in the pre command buffer).
+    void AdvanceRecordingGeneration() { ++m_recordingGeneration; }
+    void StampResourceRecordingUse(TextureResource& resource) const {
+        resource.lastRecordingGeneration = m_recordingGeneration;
+    }
+    // Map-lookup variant for callers that only hold the GL texture object.
+    void StampTextureRecordingUse(MG_State::GLState::ITextureObject* texture);
+    Bool WasTouchedThisRecording(const TextureResource& resource) const {
+        return resource.lastRecordingGeneration == m_recordingGeneration;
+    }
+    // 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
@@ -331,6 +396,9 @@ public:
 private:
     // Bumped in SyncTextureResource right after vmaCreateImage(texture). See GetTextureImageEpoch().
     Uint64 m_textureImageEpoch = 1;
+    // See AdvanceRecordingGeneration. Starts above every resource's default
+    // stamp of 0 so a fresh resource counts as untouched.
+    Uint64 m_recordingGeneration = 1;
 
     Bool SyncTexture(MG_State::GLState::ITextureObject &texture,
                      TextureResource &outResource);
@@ -361,18 +429,28 @@ private:
     void DeferViewRelease(VkImageView view);
     void CollectDeferredReleases(Uint32 frameIndex);
     void DestroyDeferredReleases();
+    // Frees the fence/command buffer/staging buffer of every in-flight texture
+    // upload whose fence has signaled (submission order = completion order on
+    // the single queue, so the scan stops at the first still-pending entry).
+    // waitAll blocks on every entry - Shutdown's drain.
+    void ReclaimCompletedUploads(Bool waitAll = false);
     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;
@@ -385,12 +463,45 @@ private:
         TextureResource* resource = nullptr;
     };
     Vector<DrawSyncedTexture> m_drawSyncedThisDraw;
+    // Cross-draw sampled-texture memo: the same few textures (atlas, lightmap)
+    // are resolved on every draw, so cache their resource pointers and skip the
+    // alive/resource map lookups. Node-based std::unordered_map keeps the
+    // pointees stable across inserts; erases bump m_resourceEraseEpoch, which
+    // every memo entry must match. SyncTexture still runs on memo hits, so
+    // content/param freshness is unaffected. A dead-then-reused texture address
+    // cannot false-hit: the new object carries a new lifetime id.
+    struct SyncedTextureMemoEntry {
+        const MG_State::GLState::ITextureObject* texture = nullptr;
+        Uint64 lifetimeId = 0;
+        Uint64 eraseEpoch = 0;
+        TextureResource* resource = nullptr;
+    };
+    static constexpr Uint32 kSyncedTextureMemoSize = 8;
+    SyncedTextureMemoEntry m_syncedTextureMemo[kSyncedTextureMemoSize];
+    Uint32 m_syncedTextureMemoNext = 0;
+    Uint64 m_resourceEraseEpoch = 1;
     // Formats whose mutable-image probe failed on this device; their images are created
     // without MUTABLE_FORMAT_BIT so repeat syncs neither re-probe nor flag-mismatch.
     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;
+    // Supported multisample counts per format, so repeat texture syncs do not
+    // re-query vkGetPhysicalDeviceImageFormatProperties.
+    std::unordered_map<VkFormat, VkSampleCountFlags> m_multisampleCountsByFormat;
     Vector<Vector<TextureResource>> m_deferredReleases;
     Vector<Vector<VkImageView>> m_deferredViewReleases;
+    // Texture uploads are submitted out-of-band but NOT waited on (waiting
+    // behind the queue serialized the CPU against the previous frame's GPU
+    // work every time an animated atlas re-uploaded). Their transient objects
+    // are parked here and reclaimed once the upload fence signals.
+    struct PendingUploadReclaim {
+        VkFence fence = VK_NULL_HANDLE;
+        VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
+        VkBuffer stagingBuffer = VK_NULL_HANDLE;
+        VmaAllocation stagingAllocation = nullptr;
+    };
+    Vector<PendingUploadReclaim> m_pendingUploadReclaims;
 };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.h

@@ -76,6 +76,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         GLenum indexType = GL_UNSIGNED_SHORT;
         SizeT indexByteOffset = 0;
         SizeT indexByteSize = 0;
+        // Interpret indexByteOffset as a raw client pointer even when an element
+        // array buffer is bound (backend-synthesized index lists, e.g. the
+        // GL_LINE_LOOP -> LINE_STRIP rewrite).
+        Bool forceClientMemory = false;
     };
 
     struct DrawIndexedCmd {
@@ -114,7 +118,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,9 +138,31 @@ 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);
+        // ANGLE-style consecutive-draw fast path: SetupDraw snapshots the fully
+        // resolved draw configuration; the next draw whose cheap version/identity
+        // checks all match skips the resolution half (LOD probe, sampled-set
+        // walk, render-pass and pipeline resolution) and jumps straight to the
+        // per-draw tail. Returns false (leaving no side effects that the full
+        // path cannot redo idempotently) whenever anything might have changed.
+        Bool TrySetupDrawFastPath(FrameContext::FrameData& frame, GLenum mode, Flags<DrawSetupAspect> aspects,
+                                  const DrawCmdParam& drawParams, const IndexBufferView* pIndexBufferView);
         void ClearAttachmentsOnActiveRenderPass(VkCommandBuffer commandBuffer,
                                                 const RenderPassEntry& compatibleRenderPassEntry);
 
@@ -171,6 +200,25 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                               GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
         void GenerateMipmap(GLenum target);
         void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
+        // GL_DEPTH_COMPONENT / GL_DEPTH_STENCIL / GL_STENCIL_INDEX readback from the
+        // read framebuffer's depth/stencil attachment (per-aspect buffer copies with
+        // CPU repacking into the requested client layout).
+        void ReadDepthStencilPixels(MG_State::GLState::FramebufferObject& readFbo, GLint x, GLint y, GLsizei width,
+                                    GLsizei height, GLenum format, GLenum type, void* pixels);
+        // Copy-and-repack core shared by depth-stencil ReadPixels and GetTexImage;
+        // expects command recording to be active and any render pass already ended.
+        void ReadDepthStencilImageToClient(VkImage image, VkFormat vkFormat, VkImageLayout* trackedLayout,
+                                           VkImageAspectFlags imageAspect, Uint32 mipLevel, Uint32 baseArrayLayer,
+                                           GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
+                                           void* pixels);
+        // Same-extent depth blit between images of different depth formats: host
+        // round-trip with a per-texel re-encode (see BlitNamedFramebuffer).
+        Bool BlitDepthAcrossFormats(FrameContext::FrameData& frame, VkImage srcImage, VkFormat srcFormat,
+                                    VkImageLayout* srcTrackedLayout, Uint32 srcMipLevel, Uint32 srcBaseArrayLayer,
+                                    VkImage dstImage, VkFormat dstFormat, VkImageLayout* dstTrackedLayout,
+                                    Uint32 dstMipLevel, Uint32 dstBaseArrayLayer, GLint srcX, GLint srcY, GLint dstX,
+                                    GLint dstY, GLint width, GLint height, VkImageLayout srcRestoreLayout,
+                                    VkImageLayout dstRestoreLayout, Bool stencilAspect);
         static SizeT GetReadbackTexelSize(VkFormat sourceFormat);
         static Bool ConvertReadbackPixels(const Uint8* sourcePixels, VkFormat sourceFormat,
                                           GLsizei width, GLsizei height, GLenum destinationFormat,
@@ -256,7 +304,20 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                       const VkTimerQueryManager::TimestampRecord& end) const;
         Uint64 GetTimerQueryTimestampNs(const VkTimerQueryManager::TimestampRecord& record) const;
 
+        // GL_SAMPLES_PASSED occlusion queries: every app draw between Start and Stop is
+        // wrapped in a Vulkan occlusion query slot; the result is the slot sum. Requires
+        // hostQueryReset for slot recycling - Start fails (frontend keeps the query
+        // unsupported) when the device lacks it.
+        Bool StartOcclusionQueryCapture();
+        void StopOcclusionQueryCapture(Vector<Uint32>& outSlots);
+        // Flushes pending commands, waits, sums the slots, and recycles them.
+        Bool ResolveOcclusionQueryResult(const Vector<Uint32>& slots, Uint64& outSamples);
+
         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,16 +406,40 @@ 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;
         void* m_platformLibrary = nullptr;
         void* m_platformCloseDisplay = nullptr;
+        // Some real ICDs (e.g. NVIDIA's proprietary Linux driver) don't implement
+        // VK_EXT_headless_surface at all. Detected once in CreateInstance() from the
+        // enumerated instance extensions; when false, CreateSurface() falls back to a
+        // hidden Xlib window instead of vkCreateHeadlessSurfaceEXT.
+        Bool m_headlessSurfaceSupported = true;
+        // Set when CreateSurface() had to create its own Xlib window for the fallback
+        // above (rather than being handed one by the caller), so Shutdown() knows it
+        // owns that window and must destroy it.
+        Bool m_ownsFallbackXlibWindow = false;
         VulkanRendererConfig m_config;
         Bool m_swapchainResizeRequested = false;
         // Presentation is suspended while the window is zero-area (minimized): the
@@ -367,6 +452,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;
@@ -404,6 +492,59 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                                  Uint32 stride);
         static inline PFNDrawIndexedIndirectCountFunc s_vkCmdDrawIndexedIndirectCount = nullptr;
 
+        // VK_EXT_transform_feedback (GL transform feedback capture)
+        Bool m_transformFeedbackFeatureEnabled = false;
+        static inline PFN_vkCmdBindTransformFeedbackBuffersEXT s_vkCmdBindTransformFeedbackBuffersEXT = nullptr;
+        static inline PFN_vkCmdBeginTransformFeedbackEXT s_vkCmdBeginTransformFeedbackEXT = nullptr;
+        static inline PFN_vkCmdEndTransformFeedbackEXT s_vkCmdEndTransformFeedbackEXT = nullptr;
+        // Counter buffers (one 4-byte slot per capture binding) let consecutive
+        // draws within one glBeginTransformFeedback append GL-style.
+        VkBufferObject m_xfbCounterBuffer;
+        // Non-zero while inside a GL Begin/End with at least one captured draw
+        // recorded; selects counter-buffer resume on the next captured draw.
+        Bool m_xfbCountersValid = false;
+        Uint64 m_xfbLastSeenGeneration = 0;
+        // Wraps a recorded draw with BeginTransformFeedbackEXT/EndTransformFeedbackEXT
+        // when GL transform feedback is active; binds capture buffers on demand.
+        Bool BeginXfbCaptureForDraw(FrameContext::FrameData& frame);
+        void EndXfbCaptureForDraw(FrameContext::FrameData& frame, Bool began);
+        // Wrap one app draw in an occlusion-query slot while a GL_SAMPLES_PASSED
+        // query is active. Returns whether a slot was begun (End must mirror it).
+        Bool BeginOcclusionForDraw(VkCommandBuffer commandBuffer);
+        void EndOcclusionForDraw(VkCommandBuffer commandBuffer, Bool began);
+        Bool m_occlusionQueryPreciseEnabled = false;
+        Bool m_hostQueryResetEnabled = false;
+        PFN_vkResetQueryPool s_vkResetQueryPool = nullptr;
+        VkQueryPool m_occlusionQueryPool = VK_NULL_HANDLE;
+        static constexpr Uint32 kOcclusionQuerySlots = 8192;
+        Uint32 m_occlusionSlotCursor = 0;
+        Bool m_occlusionCaptureActive = false;
+        Vector<Uint32> m_occlusionActiveSlots;
+        // Transform feedback primitive queries: one pool slot per captured draw yields
+        // the (written, needed) pair; GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN sums the
+        // first, GL_PRIMITIVES_GENERATED the second - exact with geometry shaders,
+        // unlike the CPU fallback accounting.
+        Bool m_xfbQueriesSupported = false;
+        PFN_vkCmdBeginQueryIndexedEXT s_vkCmdBeginQueryIndexedEXT = nullptr;
+        PFN_vkCmdEndQueryIndexedEXT s_vkCmdEndQueryIndexedEXT = nullptr;
+        VkQueryPool m_xfbQueryPool = VK_NULL_HANDLE;
+        static constexpr Uint32 kXfbQuerySlots = 8192;
+        Uint32 m_xfbQuerySlotCursor = 0;
+        Bool m_xfbQueryCaptureActive[2] = {false, false}; // [0]=written, [1]=generated
+        Vector<Uint32> m_xfbQueryActiveSlots[2];
+        Bool m_xfbQuerySlotOpen = false;
+        Uint32 m_xfbQueryOpenSlot = 0;
+
+    public:
+        // kind: 0 = PRIMITIVES_WRITTEN, 1 = PRIMITIVES_GENERATED.
+        Bool StartXfbQueryCapture(Uint32 kind);
+        void StopXfbQueryCapture(Uint32 kind, Vector<Uint32>& outSlots);
+        Bool ResolveXfbQueryResult(const Vector<Uint32>& slots, Bool wantGenerated, Uint64& outPrimitives);
+
+    private:
+        void BeginXfbQueryForDraw(VkCommandBuffer commandBuffer);
+        void EndXfbQueryForDraw(VkCommandBuffer commandBuffer);
+
         VkCommandPool m_commandPool = VK_NULL_HANDLE;
 
         VkBufferManager m_bufferManager;
@@ -416,14 +557,30 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // gather + synthetic vertex-input rebuild + payload hash + lookup) when the full pipeline
         // state is unchanged from the previous draw. The key provably covers every pipeline field.
         // Reset per-frame and on pipeline destruction so the cached handle can never dangle.
-        Bool m_lastPipelineValid = false;
-        GLenum m_lastPipelineMode = 0;
-        Uint64 m_lastPipelineProgramHash = 0;
-        Uint64 m_lastPipelineVertexInputHash = 0;
-        Uint64 m_lastPipelineRenderPassHash = 0;
-        Uint m_lastPipelineRenderStateVersion = 0;
-        ProgramFactory::CompileOptionFlags m_lastPipelineTransformFlags = {};
-        VkPipeline m_lastPipelineResult = VK_NULL_HANDLE;
+        // Small N-way pipeline-resolution memo (round-robin replacement). A
+        // single-entry memo thrashed on draw sequences that alternate a few
+        // pipelines (GUI text/quad program ping-pong), paying the full
+        // payload-hash lookup per draw; eight entries cover such working sets
+        // while keeping the hit path a trivial linear scan.
+        struct PipelineMemoEntry {
+            GLenum mode = 0;
+            Uint64 programHash = 0;
+            Uint64 vertexInputHash = 0;
+            Uint64 renderPassHash = 0;
+            Uint renderStateVersion = 0;
+            ProgramFactory::CompileOptionFlags transformFlags = {};
+            VkPipeline pipeline = VK_NULL_HANDLE;
+        };
+        static constexpr Uint32 kPipelineMemoSize = 8;
+        PipelineMemoEntry m_pipelineMemo[kPipelineMemoSize];
+        Uint32 m_pipelineMemoCount = 0;
+        Uint32 m_pipelineMemoNext = 0;
+        // Drops every memoized pipeline handle. Required at command-buffer
+        // boundaries and whenever any pipeline may have been destroyed.
+        void InvalidatePipelineMemo() {
+            m_pipelineMemoCount = 0;
+            m_pipelineMemoNext = 0;
+        }
         UnorderedMap<ProgramFactory::HashType, VkPipeline> m_computePipelines;
         UniquePtr<ProgramFactory> m_programFactory;
         UniquePtr<UniformManager> m_uniformManager;
@@ -452,9 +609,61 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         ProgramFactory::CompileOptionFlags m_lastSampledSetTransformFlags = {};
         Uint64 m_lastSampledSetBindGeneration = 0;
 
+        // Memo for the per-draw explicit-LOD-0 eligibility probe
+        // (ProgramSamplesOnlySingleLevelTextures): same key family as the
+        // sampled-set memo, plus the sampled textures' params-version sum so a
+        // level-range or filter change re-probes. On a hit the resolved
+        // transform flags are reused, which also collapses the two
+        // GetOrCreateProgram lookups into one.
+        Bool m_lastLodDecisionValid = false;
+        Uint64 m_lastLodProgramLifetimeId = 0;
+        Uint32 m_lastLodProgramVersion = 0;
+        Uint64 m_lastLodBindGeneration = 0;
+        Uint64 m_lastLodParamsSum = 0;
+        ProgramFactory::CompileOptionFlags m_lastLodBaseFlags = {};
+        ProgramFactory::CompileOptionFlags m_lastLodResultFlags = {};
+
+        // Snapshot behind TrySetupDrawFastPath. Values only: the program and
+        // render-pass caches are open-addressing maps whose entries move on
+        // insert, so no pointers into them are cached; the pipeline handle is
+        // protected by the command-buffer-boundary reset plus the mid-frame
+        // pipeline-destruction resets, and monotonic epochs guard everything
+        // that can be destroyed or recreated between draws.
+        struct SetupDrawSnapshot {
+            Bool valid = false;
+            Uint8 aspects = 0;
+            GLenum mode = 0;
+            Uint64 programLifetimeId = 0;
+            Uint32 programVersion = 0;
+            const void* vao = nullptr;
+            Uint32 vaoConfigVersion = 0;
+            const void* drawFbo = nullptr;
+            Uint16 fboVersion = 0;
+            Bool drawFboIsDefault = false;
+            Uint renderStateVersion = 0;
+            Uint64 bindGeneration = 0;
+            Uint32 baseTransformFlags = 0;
+            Uint32 resolvedTransformFlags = 0;
+            Uint64 renderPassHash = 0;
+            Uint32 imageIndex = 0;
+            Uint64 textureEraseEpoch = 0;
+            Uint64 textureImageEpoch = 0;
+            Uint64 renderbufferImageEpoch = 0;
+            Uint64 sampledContentSum = 0;
+            Uint64 sampledParamsSum = 0;
+            IntVec2 renderPassExtent = {0, 0};
+            VkPipeline pipeline = VK_NULL_HANDLE;
+        };
+        SetupDrawSnapshot m_setupDrawSnapshot;
+
         // Per-draw scratch buffers (clear keeps capacity) — these paths run for every
         // draw call and must not allocate.
         Vector<MG_State::GLState::ITextureObject*> m_sampledTexturesScratch;
+        // Parallel to m_sampledTexturesScratch, refilled by every SetupDraw's
+        // first sampled-texture loop: the resolved backend resources, so the
+        // post-transition loop can skip re-resolving textures whose layout is
+        // already sampleable.
+        Vector<VkTextureManager::TextureResource*> m_sampledResourcesScratch;
         Vector<MG_State::GLState::ITextureObject*> m_storageImageTexturesScratch;
         Vector<VkBuffer> m_vertexBuffersScratch;
         Vector<VkDeviceSize> m_vertexOffsetsScratch;
@@ -517,6 +726,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void CreateInstance();
         VkResult SetupDebugMessenger();
         VkResult DestroyDebugMessenger();
+        VkResult SetupDebugReportCallback();
+        void DestroyDebugReportCallback();
         VkDebugUtilsMessengerCreateInfoEXT PopulateDebugMessengerCreateInfo();
         void CreateSurface();
         void PickPhysicalDevice();
@@ -535,8 +746,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 +774,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 +811,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_Backend/DirectVulkan/VkIncludes.h

@@ -52,19 +52,48 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 } // namespace MobileGL::MG_Backend::DirectVulkan
 
+namespace MobileGL::MG_Backend::DirectVulkan {
+    // GL renders into sRGB color attachments RAW while GL_FRAMEBUFFER_SRGB is disabled
+    // (the core-profile default); Vulkan sRGB attachments always encode on write. The
+    // attachment view (and render pass format) therefore drops to the UNORM twin
+    // whenever the capability is off. Sampled views keep the sRGB format (decode on
+    // sample is unconditional in GL).
+    inline VkFormat ResolveSrgbAttachmentWriteFormat(VkFormat format, bool framebufferSrgbEnabled) {
+        if (framebufferSrgbEnabled) return format;
+        switch (format) {
+        case VK_FORMAT_R8G8B8A8_SRGB:
+            return VK_FORMAT_R8G8B8A8_UNORM;
+        case VK_FORMAT_B8G8R8A8_SRGB:
+            return VK_FORMAT_B8G8R8A8_UNORM;
+        default:
+            return format;
+        }
+    }
+} // namespace MobileGL::MG_Backend::DirectVulkan
+
+// The context line (__VA_ARGS__ = its own format string + args) must be a SEPARATE log
+// call: appending its format to the base format while its arguments precede the base
+// arguments makes every conversion read the wrong slot (a %s pulling an int crashes).
 #define VK_VERIFY(expr, ...)                                                                                           \
     do {                                                                                                               \
         VkResult _vk_verify_result = (expr);                                                                           \
         if (_vk_verify_result != VK_SUCCESS) {                                                                         \
-            MGLOG_F("Vulkan error %s (%d) at %s:%d" __VA_OPT__(" - ") __VA_ARGS__,                                  \
+            __VA_OPT__(MGLOG_F(__VA_ARGS__);)                                                                          \
+            MGLOG_F("Vulkan error %s (%d) at %s:%d",                                                                   \
                     MobileGL::MG_Backend::DirectVulkan::VkResultToString(_vk_verify_result),                          \
                     _vk_verify_result, __FILE__, __LINE__);                                                            \
         }                                                                                                              \
-        MOBILEGL_ASSERT(_vk_verify_result == VK_SUCCESS, "Vulkan error %s (%d) at %s:%d" __VA_OPT__(" - ") __VA_ARGS__, MobileGL::MG_Backend::DirectVulkan::VkResultToString(_vk_verify_result), _vk_verify_result, __FILE__, __LINE__);  \
+        MOBILEGL_ASSERT(_vk_verify_result == VK_SUCCESS, "Vulkan error %s (%d) at %s:%d",                              \
+                        MobileGL::MG_Backend::DirectVulkan::VkResultToString(_vk_verify_result),                       \
+                        _vk_verify_result, __FILE__, __LINE__);                                                        \
     } while (0)
 
 #define XXHASH_VERIFY(expr, ...)                                                                                       \
     do {                                                                                                               \
         XXH_errorcode _xxh_verify_result = (expr);                                                                     \
-        MOBILEGL_ASSERT(_xxh_verify_result == XXH_OK, "XXHash error %d at %s:%d" __VA_OPT__(" - ") __VA_ARGS__, _xxh_verify_result, __FILE__, __LINE__);  \
+        if (_xxh_verify_result != XXH_OK) {                                                                            \
+            __VA_OPT__(MGLOG_F(__VA_ARGS__);)                                                                          \
+        }                                                                                                              \
+        MOBILEGL_ASSERT(_xxh_verify_result == XXH_OK, "XXHash error %d at %s:%d", _xxh_verify_result, __FILE__,        \
+                        __LINE__);                                                                                     \
     } while (0)

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/Buffer/GL_Buffer.cpp

@@ -1351,6 +1351,14 @@ namespace MobileGL::MG_Impl::GLImpl {
         BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
         if (!BufferImpl::ValidateBufferBindingPointTarget(bufferTarget)) return;
         if (!BufferImpl::ValidateBufferBindingPointIndex(bufferTarget, pointIndex)) return;
+        if (bufferTarget == BufferTarget::TransformFeedback && MG_State::pGLContext->IsTransformFeedbackActive()) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                                             "Transform feedback buffer bindings cannot change while transform "
+                                             "feedback is active."));
+            return;
+        }
         MG_State::pGLContext->TouchBufferBindingPoint(bufferTarget, pointIndex);
 
         auto& point = MG_State::pGLContext->GetBufferBindingPoint(bufferTarget, pointIndex);
@@ -1384,6 +1392,14 @@ namespace MobileGL::MG_Impl::GLImpl {
         BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
         if (!BufferImpl::ValidateBufferBindingPointTarget(bufferTarget)) return;
         if (!BufferImpl::ValidateBufferBindingPointIndex(bufferTarget, index)) return;
+        if (bufferTarget == BufferTarget::TransformFeedback && MG_State::pGLContext->IsTransformFeedbackActive()) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                                             "Transform feedback buffer bindings cannot change while transform "
+                                             "feedback is active."));
+            return;
+        }
         MG_State::pGLContext->TouchBufferBindingPoint(bufferTarget, index);
 
         auto& point = MG_State::pGLContext->GetBufferBindingPoint(bufferTarget, index);

MobileGL/MG_Impl/GLImpl/Buffer/Validators.cpp

@@ -60,6 +60,11 @@ namespace MobileGL::MG_Impl::GLImpl::BufferImpl {
                 MG_Backend::pActiveBackendObject->GetDynamicParameters().MaxShaderStorageBufferBindings;
             pointCount = std::min(pointCount, static_cast<SizeT>(std::max(backendCount, 0)));
         }
+        if (target == BufferTarget::TransformFeedback) {
+            // GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS bounds the indexed capture
+            // binding points in GL 3.3 (no ARB_transform_feedback3).
+            pointCount = std::min<SizeT>(pointCount, 4);
+        }
 
         if (index < pointCount) {
             return true;

MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.cpp

@@ -48,6 +48,73 @@ namespace MobileGL::MG_Impl::GLImpl {
         return true;
     }
 
+    // Primitives a draw of `count` vertices in `mode` assembles (0 for
+    // incomplete primitives). Used for the CPU-side transform feedback
+    // primitive accounting.
+    static Uint64 CountPrimitivesForDraw(GLenum mode, GLsizei count) {
+        if (count <= 0) return 0;
+        switch (mode) {
+        case GL_POINTS: return static_cast<Uint64>(count);
+        case GL_LINES: return static_cast<Uint64>(count / 2);
+        case GL_LINE_STRIP: return count >= 2 ? static_cast<Uint64>(count - 1) : 0;
+        case GL_LINE_LOOP: return count >= 2 ? static_cast<Uint64>(count) : 0;
+        case GL_TRIANGLES: return static_cast<Uint64>(count / 3);
+        case GL_TRIANGLE_STRIP:
+        case GL_TRIANGLE_FAN: return count >= 3 ? static_cast<Uint64>(count - 2) : 0;
+        default: return 0;
+        }
+    }
+
+    // Accumulate the transform feedback primitive counter for a captured draw.
+    // Draws without a geometry stage write exactly the primitives they assemble,
+    // clamped by the capture buffers' remaining capacity (a full buffer stops
+    // recording whole primitives, which is what PRIMITIVES_WRITTEN reports).
+    // Geometry amplification is not modelled here.
+    static void AccountTransformFeedbackPrimitives(GLenum mode, GLsizei count) {
+        if (!MG_State::pGLContext->IsTransformFeedbackActive()) return;
+        Uint64 primitives = CountPrimitivesForDraw(mode, count);
+        if (primitives == 0) return;
+        MG_State::pGLContext->AddTransformFeedbackInputPrimitives(primitives);
+
+        Uint64 verticesPerPrimitive = 1;
+        switch (mode) {
+        case GL_LINES:
+        case GL_LINE_STRIP:
+        case GL_LINE_LOOP:
+            verticesPerPrimitive = 2;
+            break;
+        case GL_TRIANGLES:
+        case GL_TRIANGLE_STRIP:
+        case GL_TRIANGLE_FAN:
+            verticesPerPrimitive = 3;
+            break;
+        default:
+            break;
+        }
+
+        const auto& program = MG_State::pGLContext->GetTransformFeedbackProgram();
+        if (program != nullptr) {
+            // Capacity in captured vertices = the tightest bound buffer.
+            Uint64 capacityVertices = ~0ull;
+            for (SizeT i = 0; i < program->GetTransformFeedbackBufferCount(); ++i) {
+                const Uint32 stride = program->GetTransformFeedbackStride(static_cast<Uint32>(i));
+                if (stride == 0) continue;
+                const auto& point = MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::TransformFeedback,
+                                                                                static_cast<Uint>(i));
+                const Range1D range = point.GetRange();
+                const Uint64 bytes = range.end > range.start ? static_cast<Uint64>(range.end - range.start) : 0;
+                capacityVertices = std::min<Uint64>(capacityVertices, bytes / stride);
+            }
+            if (capacityVertices != ~0ull) {
+                const Uint64 usedVertices = MG_State::pGLContext->GetTransformFeedbackCapturedVertices();
+                const Uint64 remainingVertices = capacityVertices > usedVertices ? capacityVertices - usedVertices : 0;
+                primitives = std::min<Uint64>(primitives, remainingVertices / verticesPerPrimitive);
+            }
+        }
+        MG_State::pGLContext->AddTransformFeedbackPrimitives(primitives);
+        MG_State::pGLContext->AddTransformFeedbackCapturedVertices(primitives * verticesPerPrimitive);
+    }
+
     static Bool ValidatePrimitiveModeForBackend(const char* functionName, GLenum mode) {
         const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
         if (!activeBackendObject) {
@@ -57,15 +124,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return false;
         }
 
-        if (activeBackendObject->GetBackendType() == BackendType::DirectVulkan && mode == GL_LINE_LOOP) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl", functionName,
-                    "Primitive mode GL_LINE_LOOP is not supported by the DirectVulkan backend."));
-            return false;
-        }
-
         const auto& vao = MG_State::pGLContext->GetBoundVertexArray();
         if (vao && vao->GetExternalIndex() == 0 && !MG_State::IsRelaxedSemanticsActive()) {
             MG_State::pGLContext->RecordError(
@@ -75,6 +133,38 @@ namespace MobileGL::MG_Impl::GLImpl {
             return false;
         }
 
+        // While transform feedback is active the draw's primitive type must match
+        // the feedback primitive mode (GL 3.3 core 13.2.2). With a geometry shader
+        // the constraint moves to the shader's output primitive type instead, so
+        // the draw mode itself is unconstrained here.
+        if (MG_State::pGLContext->IsTransformFeedbackActive() &&
+            !(MG_State::pGLContext->GetTransformFeedbackProgram() &&
+              MG_State::pGLContext->GetTransformFeedbackProgram()->GetShaderIndexByStage(ShaderStage::Geometry) >= 0)) {
+            const GLenum feedbackMode = MG_State::pGLContext->GetTransformFeedbackPrimitiveMode();
+            Bool compatible = false;
+            switch (feedbackMode) {
+            case GL_POINTS:
+                compatible = mode == GL_POINTS;
+                break;
+            case GL_LINES:
+                compatible = mode == GL_LINES || mode == GL_LINE_STRIP || mode == GL_LINE_LOOP;
+                break;
+            case GL_TRIANGLES:
+                compatible = mode == GL_TRIANGLES || mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN;
+                break;
+            default:
+                break;
+            }
+            if (!compatible) {
+                MG_State::pGLContext->RecordError(
+                    ErrorCode::InvalidOperation,
+                    MakeUnique<GenericErrorInfo>(
+                        "MG_Impl/GLImpl", functionName,
+                        "Primitive mode is incompatible with the active transform feedback primitive mode."));
+                return false;
+            }
+        }
+
         return true;
     }
 
@@ -402,12 +492,14 @@ namespace MobileGL::MG_Impl::GLImpl {
     void DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void* indices, GLint basevertex) {
         if (!ValidateCurrentProgramForExecution(__func__)) return;
         if (!ValidatePrimitiveModeForBackend(__func__, mode)) return;
+        AccountTransformFeedbackPrimitives(mode, count);
         DrawElementsBaseVertex_Backend(mode, count, type, indices, basevertex);
     }
 
     void DrawArrays(GLenum mode, GLint first, GLsizei count) {
         if (!ValidateCurrentProgramForExecution(__func__)) return;
         if (!ValidatePrimitiveModeForBackend(__func__, mode)) return;
+        AccountTransformFeedbackPrimitives(mode, count);
         DrawArrays_Backend(mode, first, count);
     }
 
@@ -444,7 +536,133 @@ namespace MobileGL::MG_Impl::GLImpl {
     void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) {
         if (!ValidateCurrentProgramForExecution(__func__)) return;
         if (!ValidatePrimitiveModeForBackend(__func__, mode)) return;
+        AccountTransformFeedbackPrimitives(mode, count);
         DrawElements_Backend(mode, count, type, indices);
     }
 
+    void BeginTransformFeedback(GLenum primitiveMode) {
+        if (primitiveMode != GL_POINTS && primitiveMode != GL_LINES && primitiveMode != GL_TRIANGLES) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                                             "primitiveMode must be GL_POINTS, GL_LINES or GL_TRIANGLES."));
+            return;
+        }
+        if (MG_State::pGLContext->IsTransformFeedbackActive()) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "Transform feedback is already active."));
+            return;
+        }
+        const auto& program = MG_State::pGLContext->GetCurrentProgram();
+        if (!program || !program->GetLinkStatus() || program->GetTransformFeedbackVaryingCount() == 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl", __func__,
+                    "No program with transform feedback varyings is active."));
+            return;
+        }
+        // Every capture buffer slot the program's mode uses must have a buffer bound.
+        const SizeT usedBufferCount = program->GetTransformFeedbackBufferCount();
+        for (SizeT i = 0; i < usedBufferCount; ++i) {
+            const auto& point = MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::TransformFeedback,
+                                                                            static_cast<Uint>(i));
+            if (point.GetBoundObject() == nullptr) {
+                MG_State::pGLContext->RecordError(
+                    ErrorCode::InvalidOperation,
+                    MakeUnique<GenericErrorInfo>(
+                        "MG_Impl/GLImpl", __func__,
+                        "Transform feedback buffer binding point " + std::to_string(i) + " has no buffer bound."));
+                return;
+            }
+        }
+        MG_State::pGLContext->BeginTransformFeedback(primitiveMode, program);
+    }
+
+    // Vulkan transform feedback captures triangle strips in plain (i, i+1, i+2)
+    // vertex order, but GL decomposes odd strip triangles as (i+1, i, i+2)
+    // (GL 4.6 table 10.1). With the geometry stage's statically-known strip
+    // lengths the captured records are reordered in place: swap the first two
+    // vertex records of every odd triangle within each emitted strip.
+    static void FixupGsStripCaptureOrder(const SharedPtr<MG_State::GLState::ProgramObject>& program,
+                                         Uint64 inputPrimitives) {
+        if (program == nullptr || !program->HasGsTriangleStripCaptureFixup() || inputPrimitives == 0) {
+            return;
+        }
+        const auto& stripTriangles = program->GetGsStripTriangles();
+
+        // Global triangle indices whose leading vertex pair must swap.
+        Vector<Uint64> swapTriangles;
+        Uint64 triangleBase = 0;
+        for (Uint64 input = 0; input < inputPrimitives; ++input) {
+            for (const Uint32 stripLength : stripTriangles) {
+                for (Uint32 t = 1; t < stripLength; t += 2) {
+                    swapTriangles.push_back(triangleBase + t);
+                }
+                triangleBase += stripLength;
+            }
+        }
+        if (swapTriangles.empty()) {
+            return;
+        }
+
+        for (SizeT bufferIndex = 0; bufferIndex < program->GetTransformFeedbackBufferCount(); ++bufferIndex) {
+            const Uint32 stride = program->GetTransformFeedbackStride(static_cast<Uint32>(bufferIndex));
+            if (stride == 0) continue;
+            const auto& bindingPoint =
+                MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::TransformFeedback,
+                                                            static_cast<Uint>(bufferIndex));
+            const auto& buffer = bindingPoint.GetBoundObject();
+            if (buffer == nullptr) continue;
+            const Range1D range = bindingPoint.GetRange();
+            const Uint8* mapped = buffer->MappedData();
+            if (mapped == nullptr) continue;
+            // The geometry stage amplifies, so the CPU vertex counter does not bound
+            // the capture; the binding range's whole-triangle capacity does.
+            const Uint64 rangeBytes = range.end > range.start ? static_cast<Uint64>(range.end - range.start) : 0;
+            const Uint64 capturedTriangles = std::min<Uint64>(triangleBase, (rangeBytes / stride) / 3);
+
+            // Observed Vulkan capture order for odd strip triangles is (i, i+2, i+1)
+            // (winding preserved by swapping the trailing pair); GL wants
+            // (i+1, i, i+2), which is one rotation away: (a,b,c) -> (c,a,b).
+            Vector<Uint8> scratch(stride);
+            for (const Uint64 triangle : swapTriangles) {
+                if (triangle >= capturedTriangles) break;
+                const SizeT v0Offset = static_cast<SizeT>(range.start) + static_cast<SizeT>(triangle * 3) * stride;
+                const SizeT v1Offset = v0Offset + stride;
+                const SizeT v2Offset = v1Offset + stride;
+                Memcpy(scratch.data(), mapped + v2Offset, stride);
+                buffer->WritebackFromBackend({const_cast<Uint8*>(mapped) + v1Offset, stride}, v2Offset);
+                buffer->WritebackFromBackend({const_cast<Uint8*>(mapped) + v0Offset, stride}, v1Offset);
+                buffer->WritebackFromBackend({scratch.data(), stride}, v0Offset);
+            }
+        }
+    }
+
+    void EndTransformFeedback(void) {
+        if (!MG_State::pGLContext->IsTransformFeedbackActive()) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "Transform feedback is not active."));
+            return;
+        }
+        const auto capturedProgram = MG_State::pGLContext->GetTransformFeedbackProgram();
+        const Uint64 inputPrimitives = MG_State::pGLContext->GetTransformFeedbackInputPrimitives();
+        MG_State::pGLContext->EndTransformFeedback();
+        // Captured results must be visible to MapBuffer/GetBufferSubData after
+        // End; the capture targets are host-coherent GPU memory, so completing
+        // the GPU work is all that is required.
+        auto& backendGL = MG_Backend::gBackendFunctionsTable.GL;
+        if (backendGL.FenceSync && backendGL.ClientWaitSync) {
+            if (auto sync = backendGL.FenceSync()) {
+                backendGL.ClientWaitSync(sync, GL_SYNC_FLUSH_COMMANDS_BIT, ~0ull);
+                if (backendGL.DeleteSync) {
+                    backendGL.DeleteSync(sync);
+                }
+            }
+        }
+        FixupGsStripCaptureOrder(capturedProgram, inputPrimitives);
+    }
+
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.h

@@ -11,6 +11,8 @@
 
 namespace MobileGL::MG_Impl::GLImpl {
     /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
+    void BeginTransformFeedback(GLenum primitiveMode);
+    void EndTransformFeedback(void);
     void DispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ);
     void DispatchComputeIndirect(GLintptr indirect);
     void MemoryBarrier(GLbitfield barriers);

MobileGL/MG_Impl/GLImpl/Exporting/Definitions.cpp

@@ -236,12 +236,12 @@ DECLARE_GL_FUNCTION_HEAD(void, DeleteVertexArrays, GLsizei n, const GLuint* arra
 DECLARE_GL_FUNCTION_HEAD(void, GenVertexArrays, GLsizei n, GLuint* arrays) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GenVertexArrays, n, arrays)
 DECLARE_GL_FUNCTION_HEAD(GLboolean, IsVertexArray, GLuint array) DECLARE_GL_FUNCTION_END(GLboolean, IsVertexArray, array)
 DECLARE_GL_FUNCTION_HEAD(void, GetIntegeri_v, GLenum target, GLuint index, GLint* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetIntegeri_v, target, index, data)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, BeginTransformFeedback, GLenum primitiveMode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BeginTransformFeedback, primitiveMode)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, EndTransformFeedback) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EndTransformFeedback)
+DECLARE_GL_FUNCTION_HEAD(void, BeginTransformFeedback, GLenum primitiveMode) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BeginTransformFeedback, primitiveMode)
+DECLARE_GL_FUNCTION_HEAD(void, EndTransformFeedback) DECLARE_GL_FUNCTION_END_NO_RETURN(void, EndTransformFeedback)
 DECLARE_GL_FUNCTION_HEAD(void, BindBufferRange, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindBufferRange, target, index, buffer, offset, size)
 DECLARE_GL_FUNCTION_HEAD(void, BindBufferBase, GLenum target, GLuint index, GLuint buffer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindBufferBase, target, index, buffer)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, TransformFeedbackVaryings, GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TransformFeedbackVaryings, program, count, varyings, bufferMode)
-DECLARE_GL_FUNCTION_STUB_HEAD(void, GetTransformFeedbackVarying, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetTransformFeedbackVarying, program, index, bufSize, length, size, type, name)
+DECLARE_GL_FUNCTION_HEAD(void, TransformFeedbackVaryings, GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TransformFeedbackVaryings, program, count, varyings, bufferMode)
+DECLARE_GL_FUNCTION_HEAD(void, GetTransformFeedbackVarying, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTransformFeedbackVarying, program, index, bufSize, length, size, type, name)
 DECLARE_GL_FUNCTION_HEAD(void, VertexAttribIPointer, GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexAttribIPointer, index, size, type, stride, pointer)
 DECLARE_GL_FUNCTION_HEAD(void, GetVertexAttribIiv, GLuint index, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetVertexAttribIiv, index, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetVertexAttribIuiv, GLuint index, GLenum pname, GLuint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetVertexAttribIuiv, index, pname, params)

MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp

@@ -45,10 +45,32 @@ namespace MobileGL::MG_Impl::GLImpl {
                    depthAttachment.GetTextureLevel() != stencilAttachment.GetTextureLevel();
         }
 
+        // Mirrors the renderer-side gate: distinct depth/stencil renderbuffers (or a
+        // renderbuffer paired with a texture) cannot form one Vulkan depth-stencil
+        // attachment, and GL permits reporting such framebuffers as UNSUPPORTED.
+        Bool HasDistinctCompleteDepthStencilRenderbufferAttachments(
+            const MG_State::GLState::FramebufferObject& framebufferObject) {
+            if (framebufferObject.GetExternalIndex() == 0) {
+                return false;
+            }
+
+            const auto& depthAttachment = framebufferObject.GetAttachment(FramebufferAttachmentType::Depth);
+            const auto& stencilAttachment = framebufferObject.GetAttachment(FramebufferAttachmentType::Stencil);
+            if (!depthAttachment.IsComplete() || !stencilAttachment.IsComplete()) {
+                return false;
+            }
+            if (depthAttachment.IsRenderbuffer() && stencilAttachment.IsRenderbuffer()) {
+                return depthAttachment.GetRenderbuffer().get() != stencilAttachment.GetRenderbuffer().get();
+            }
+            return (depthAttachment.IsRenderbuffer() || stencilAttachment.IsRenderbuffer()) &&
+                   (depthAttachment.IsTexture() || stencilAttachment.IsTexture());
+        }
+
         Bool IsUnsupportedFramebufferForDirectVulkan(
             const MG_State::GLState::FramebufferObject& framebufferObject) {
             // TODO: Keep this in sync with DirectVulkan renderbuffer support as color renderbuffer rendering lands.
-            return HasDistinctCompleteDepthStencilTextureAttachments(framebufferObject);
+            return HasDistinctCompleteDepthStencilTextureAttachments(framebufferObject) ||
+                   HasDistinctCompleteDepthStencilRenderbufferAttachments(framebufferObject);
         }
 
         Bool HasDefinedAttachment(const MG_State::GLState::FramebufferObject& framebufferObject) {
@@ -147,6 +169,148 @@ namespace MobileGL::MG_Impl::GLImpl {
                 MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName, detail));
         }
 
+        GLint ClassifyAttachmentComponentType(TextureInternalFormat internalFormat,
+                                              FramebufferAttachmentType attachmentType) {
+            // A stencil value is an unsigned integer index regardless of the depth half
+            // of a packed format.
+            if (attachmentType == FramebufferAttachmentType::Stencil) return GL_UNSIGNED_INT;
+            switch (internalFormat) {
+            case TextureInternalFormat::R16F:
+            case TextureInternalFormat::RG16F:
+            case TextureInternalFormat::RGB16F:
+            case TextureInternalFormat::RGBA16F:
+            case TextureInternalFormat::R32F:
+            case TextureInternalFormat::RG32F:
+            case TextureInternalFormat::RGB32F:
+            case TextureInternalFormat::RGBA32F:
+            case TextureInternalFormat::R11FG11FB10F:
+            case TextureInternalFormat::RGB9E5:
+            case TextureInternalFormat::DepthComponent32F:
+            case TextureInternalFormat::Depth32FStencil8:
+                return GL_FLOAT;
+            case TextureInternalFormat::R8I:
+            case TextureInternalFormat::R16I:
+            case TextureInternalFormat::R32I:
+            case TextureInternalFormat::RG8I:
+            case TextureInternalFormat::RG16I:
+            case TextureInternalFormat::RG32I:
+            case TextureInternalFormat::RGB8I:
+            case TextureInternalFormat::RGB16I:
+            case TextureInternalFormat::RGB32I:
+            case TextureInternalFormat::RGBA8I:
+            case TextureInternalFormat::RGBA16I:
+            case TextureInternalFormat::RGBA32I:
+                return GL_INT;
+            case TextureInternalFormat::R8UI:
+            case TextureInternalFormat::R16UI:
+            case TextureInternalFormat::R32UI:
+            case TextureInternalFormat::RG8UI:
+            case TextureInternalFormat::RG16UI:
+            case TextureInternalFormat::RG32UI:
+            case TextureInternalFormat::RGB8UI:
+            case TextureInternalFormat::RGB16UI:
+            case TextureInternalFormat::RGB32UI:
+            case TextureInternalFormat::RGBA8UI:
+            case TextureInternalFormat::RGBA16UI:
+            case TextureInternalFormat::RGBA32UI:
+            case TextureInternalFormat::RGB10A2UI:
+                return GL_UNSIGNED_INT;
+            case TextureInternalFormat::R8Snorm:
+            case TextureInternalFormat::R16Snorm:
+            case TextureInternalFormat::RG8Snorm:
+            case TextureInternalFormat::RG16Snorm:
+            case TextureInternalFormat::RGB8Snorm:
+            case TextureInternalFormat::RGB16Snorm:
+            case TextureInternalFormat::RGBA8Snorm:
+            case TextureInternalFormat::RGBA16Snorm:
+                return GL_SIGNED_NORMALIZED;
+            case TextureInternalFormat::Unknown:
+                return GL_NONE;
+            default:
+                return GL_UNSIGNED_NORMALIZED;
+            }
+        }
+
+        // Handles the format-derived pnames shared by GetFramebufferAttachmentParameteriv
+        // and its DSA variant. Returns true when pname was one of them.
+        Bool TryAnswerAttachmentFormatQuery(const MG_State::GLState::FramebufferAttachmentObject* attachmentObject,
+                                            FramebufferAttachmentType attachmentType, Bool depthStencilAlias,
+                                            GLenum pname, GLint* params, const char* caller) {
+            switch (pname) {
+            case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
+            case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
+            case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
+            case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
+            case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
+            case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
+            case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
+            case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
+                break;
+            default:
+                return false;
+            }
+
+            if (pname == GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE && depthStencilAlias) {
+                // The depth and stencil components have different types, so the combined
+                // attachment name has no single answer.
+                MG_State::pGLContext->RecordError(
+                    ErrorCode::InvalidOperation,
+                    MakeUnique<GenericErrorInfo>(
+                        "MG_Impl/GLImpl", caller,
+                        "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE cannot be queried on "
+                        "GL_DEPTH_STENCIL_ATTACHMENT."));
+                return true;
+            }
+
+            if (attachmentObject == nullptr || attachmentObject->IsEmpty() || !attachmentObject->IsValid()) {
+                // With OBJECT_TYPE == GL_NONE only OBJECT_TYPE and OBJECT_NAME may be queried.
+                MG_State::pGLContext->RecordError(
+                    ErrorCode::InvalidOperation,
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", caller,
+                                                 "No image is attached to the queried attachment point."));
+                return true;
+            }
+
+            TextureInternalFormat internalFormat = TextureInternalFormat::Unknown;
+            if (attachmentObject->IsTexture() && attachmentObject->GetTexture()) {
+                internalFormat = attachmentObject->GetTexture()->GetFormat();
+            } else if (attachmentObject->IsRenderbuffer() && attachmentObject->GetRenderbuffer()) {
+                internalFormat = attachmentObject->GetRenderbuffer()->GetInternalFormat();
+            }
+            const auto sizes = MG_Util::GetComponentSizesForInternalFormat(internalFormat);
+
+            switch (pname) {
+            case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
+                *params = sizes.Red;
+                break;
+            case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
+                *params = sizes.Green;
+                break;
+            case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
+                *params = sizes.Blue;
+                break;
+            case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
+                *params = sizes.Alpha;
+                break;
+            case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
+                *params = sizes.Depth;
+                break;
+            case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
+                *params = sizes.Stencil;
+                break;
+            case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
+                *params = (internalFormat == TextureInternalFormat::SRGB8 ||
+                           internalFormat == TextureInternalFormat::SRGB8Alpha8)
+                    ? GL_SRGB
+                    : GL_LINEAR;
+                break;
+            case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
+                *params = ClassifyAttachmentComponentType(internalFormat, attachmentType);
+                break;
+            }
+            return true;
+        }
+
         Bool ResolveRepresentableFramebufferTextureUploadTarget(const MG_State::GLState::ITextureObject& textureObject,
                                                                 TextureUploadTarget& outUploadTarget,
                                                                 Bool& outLayered) {
@@ -412,6 +576,27 @@ namespace MobileGL::MG_Impl::GLImpl {
         FramebufferTarget framebufferTarget = MG_Util::ConvertGLEnumToFramebufferTarget(target);
         if (!FramebufferImpl::ValidateFramebufferTarget(framebufferTarget)) return;
 
+        // Default-framebuffer attachment names (GL_DEPTH, GL_STENCIL, GL_FRONT/GL_BACK
+        // variants) alias onto the equivalent attachment points.
+        switch (attachment) {
+        case GL_DEPTH:
+            attachment = GL_DEPTH_ATTACHMENT;
+            break;
+        case GL_STENCIL:
+            attachment = GL_STENCIL_ATTACHMENT;
+            break;
+        case GL_FRONT:
+        case GL_FRONT_LEFT:
+        case GL_FRONT_RIGHT:
+        case GL_BACK:
+        case GL_BACK_LEFT:
+        case GL_BACK_RIGHT:
+            attachment = GL_COLOR_ATTACHMENT0;
+            break;
+        default:
+            break;
+        }
+
         const Bool depthStencilAlias = attachment == GL_DEPTH_STENCIL_ATTACHMENT;
         FramebufferAttachmentType attachmentType = depthStencilAlias
             ? FramebufferAttachmentType::Depth
@@ -428,20 +613,40 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
+        Bool depthStencilMismatch = false;
         const auto* attachmentObject = [&]() -> const MG_State::GLState::FramebufferAttachmentObject* {
             if (!depthStencilAlias) {
                 return &framebufferObject->GetAttachment(attachmentType);
             }
 
             const auto& depthAttachment = framebufferObject->GetAttachment(FramebufferAttachmentType::Depth);
-            if (depthAttachment.IsValid() && !depthAttachment.IsEmpty()) return &depthAttachment;
-
             const auto& stencilAttachment = framebufferObject->GetAttachment(FramebufferAttachmentType::Stencil);
-            if (stencilAttachment.IsValid() && !stencilAttachment.IsEmpty()) return &stencilAttachment;
-
+            const Bool depthLive = depthAttachment.IsValid() && !depthAttachment.IsEmpty();
+            const Bool stencilLive = stencilAttachment.IsValid() && !stencilAttachment.IsEmpty();
+            if (depthLive && stencilLive) {
+                const Bool sameObject = depthAttachment.IsTexture() == stencilAttachment.IsTexture() &&
+                    (!depthAttachment.IsTexture() || depthAttachment.GetTexture() == stencilAttachment.GetTexture()) &&
+                    (!depthAttachment.IsRenderbuffer() ||
+                     depthAttachment.GetRenderbuffer() == stencilAttachment.GetRenderbuffer());
+                depthStencilMismatch = !sameObject;
+            } else {
+                // GL_DEPTH_STENCIL_ATTACHMENT means "both halves"; a lone half does not answer it.
+                depthStencilMismatch = depthLive != stencilLive;
+            }
+            if (depthLive) return &depthAttachment;
+            if (stencilLive) return &stencilAttachment;
             return nullptr;
         }();
 
+        if (depthStencilMismatch) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetFramebufferAttachmentParameteriv_State",
+                                             "GL_DEPTH_STENCIL_ATTACHMENT query with different depth and stencil "
+                                             "attachment images."));
+            return;
+        }
+
         switch (pname) {
         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
             if (attachmentObject == nullptr || attachmentObject->IsEmpty() || !attachmentObject->IsValid()) {
@@ -505,6 +710,10 @@ namespace MobileGL::MG_Impl::GLImpl {
                 : GL_FALSE;
             break;
         default:
+            if (TryAnswerAttachmentFormatQuery(attachmentObject, attachmentType, depthStencilAlias, pname, params,
+                                               "GetFramebufferAttachmentParameteriv_State")) {
+                return;
+            }
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
                 MakeUnique<GenericErrorInfo>(
@@ -1468,20 +1677,40 @@ namespace MobileGL::MG_Impl::GLImpl {
             : MG_Util::ConvertGLEnumToFramebufferAttachmentType(attachment);
         if (!FramebufferImpl::ValidateFramebufferAttachmentType(attachmentType)) return;
 
+        Bool depthStencilMismatch = false;
         const auto* attachmentObject = [&]() -> const MG_State::GLState::FramebufferAttachmentObject* {
             if (!depthStencilAlias) {
                 return &framebufferObject->GetAttachment(attachmentType);
             }
 
             const auto& depthAttachment = framebufferObject->GetAttachment(FramebufferAttachmentType::Depth);
-            if (depthAttachment.IsValid() && !depthAttachment.IsEmpty()) return &depthAttachment;
-
             const auto& stencilAttachment = framebufferObject->GetAttachment(FramebufferAttachmentType::Stencil);
-            if (stencilAttachment.IsValid() && !stencilAttachment.IsEmpty()) return &stencilAttachment;
-
+            const Bool depthLive = depthAttachment.IsValid() && !depthAttachment.IsEmpty();
+            const Bool stencilLive = stencilAttachment.IsValid() && !stencilAttachment.IsEmpty();
+            if (depthLive && stencilLive) {
+                const Bool sameObject = depthAttachment.IsTexture() == stencilAttachment.IsTexture() &&
+                    (!depthAttachment.IsTexture() || depthAttachment.GetTexture() == stencilAttachment.GetTexture()) &&
+                    (!depthAttachment.IsRenderbuffer() ||
+                     depthAttachment.GetRenderbuffer() == stencilAttachment.GetRenderbuffer());
+                depthStencilMismatch = !sameObject;
+            } else {
+                // GL_DEPTH_STENCIL_ATTACHMENT means "both halves"; a lone half does not answer it.
+                depthStencilMismatch = depthLive != stencilLive;
+            }
+            if (depthLive) return &depthAttachment;
+            if (stencilLive) return &stencilAttachment;
             return nullptr;
         }();
 
+        if (depthStencilMismatch) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", caller,
+                                             "GL_DEPTH_STENCIL_ATTACHMENT query with different depth and stencil "
+                                             "attachment images."));
+            return;
+        }
+
         switch (pname) {
         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
             if (attachmentObject == nullptr || attachmentObject->IsEmpty() || !attachmentObject->IsValid()) {
@@ -1527,6 +1756,10 @@ namespace MobileGL::MG_Impl::GLImpl {
                 : GL_FALSE;
             break;
         default:
+            if (TryAnswerAttachmentFormatQuery(attachmentObject, attachmentType, depthStencilAlias, pname, params,
+                                               caller)) {
+                return;
+            }
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
                 MakeUnique<GenericErrorInfo>(

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.cpp

@@ -213,8 +213,13 @@ namespace MobileGL::MG_Impl::GLImpl {
 
             GLint maxSamples = 0;
             for (const auto& attachment : drawFbo->GetAllAttachmentObjects()) {
-                if (!attachment.IsRenderbuffer() || !attachment.GetRenderbuffer()) continue;
-                maxSamples = std::max(maxSamples, static_cast<GLint>(attachment.GetRenderbuffer()->GetSamples()));
+                if (attachment.IsRenderbuffer() && attachment.GetRenderbuffer()) {
+                    maxSamples = std::max(maxSamples, static_cast<GLint>(attachment.GetRenderbuffer()->GetSamples()));
+                } else if (attachment.IsTexture() && attachment.GetTexture()) {
+                    // Multisample texture attachments count too (GL_SAMPLE_BUFFERS must
+                    // report 1 for any multisampled draw framebuffer).
+                    maxSamples = std::max(maxSamples, static_cast<GLint>(attachment.GetTexture()->GetSamples()));
+                }
             }
             return maxSamples;
         }
@@ -465,6 +470,14 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_STENCIL_TEST:
             *params = MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::StencilTest) ? GL_TRUE : GL_FALSE;
             return;
+        case GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
+        case GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
+        case GL_FRAGMENT_INTERPOLATION_OFFSET_BITS: {
+            GLfloat value = 0.0f;
+            GetFloatv(pname, &value);
+            *params = value != 0.0f ? GL_TRUE : GL_FALSE;
+            return;
+        }
         default:
             break;
         }
@@ -520,6 +533,19 @@ namespace MobileGL::MG_Impl::GLImpl {
             params[1] = dynamicParameters.ViewportBoundsRangeMax;
             return;
         }
+        case GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
+        case GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
+        case GL_FRAGMENT_INTERPOLATION_OFFSET_BITS: {
+            const auto& dynamicParameters = MG_Backend::pActiveBackendObject->GetDynamicParameters();
+            if (pname == GL_MIN_FRAGMENT_INTERPOLATION_OFFSET) {
+                params[0] = dynamicParameters.MinFragmentInterpolationOffset;
+            } else if (pname == GL_MAX_FRAGMENT_INTERPOLATION_OFFSET) {
+                params[0] = dynamicParameters.MaxFragmentInterpolationOffset;
+            } else {
+                params[0] = static_cast<GLfloat>(dynamicParameters.FragmentInterpolationOffsetBits);
+            }
+            return;
+        }
         case GL_DEPTH_CLEAR_VALUE:
             params[0] = MG_State::pGLContext->GetClearDepth();
             return;
@@ -1901,6 +1927,22 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
             *params = kFrontendMaxTransformFeedbackSeparateComponents;
             break;
+        // ARB_transform_feedback3 limits. The GL CTS queries these before checking
+        // whether the extension is advertised and requires no GL error; desktop
+        // drivers all accept them, so answer with the separate-attrib capacity and
+        // the single vertex stream the backends provide.
+        case GL_MAX_TRANSFORM_FEEDBACK_BUFFERS:
+            *params = kFrontendMaxTransformFeedbackSeparateAttribs;
+            break;
+        case GL_MAX_VERTEX_STREAMS:
+            *params = 1;
+            break;
+        case GL_TRANSFORM_FEEDBACK_ACTIVE:
+            *params = MG_State::pGLContext->IsTransformFeedbackActive() ? 1 : 0;
+            break;
+        case GL_TRANSFORM_FEEDBACK_PAUSED:
+            *params = 0;
+            break;
         case GL_MAX_TEXTURE_IMAGE_UNITS:
             *params = dynamicParameters.MaxTextureImageUnits;
             break;
@@ -1957,6 +1999,15 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_SUBPIXEL_BITS:
             *params = std::max(dynamicParameters.ViewportSubpixelBits, kFrontendSubpixelBits);
             break;
+        case GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
+            *params = static_cast<GLint>(std::lround(dynamicParameters.MinFragmentInterpolationOffset));
+            break;
+        case GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
+            *params = static_cast<GLint>(std::lround(dynamicParameters.MaxFragmentInterpolationOffset));
+            break;
+        case GL_FRAGMENT_INTERPOLATION_OFFSET_BITS:
+            *params = dynamicParameters.FragmentInterpolationOffsetBits;
+            break;
         case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
             *params = static_cast<Int>(dynamicParameters.UniformBufferOffsetAlignment);
             break;

MobileGL/MG_Impl/GLImpl/Program/GL_Program.cpp

@@ -49,10 +49,18 @@ namespace MobileGL::MG_Impl::GLImpl {
 
     static bool CheckProgramNameValidity(GLuint program) {
         if (!MG_State::pGLContext->ValidateProgramName(program)) {
+            // Programs and shaders share one name space: a name that exists but
+            // belongs to a shader is INVALID_OPERATION, a name GL never handed
+            // out is INVALID_VALUE (GL 3.3 core 2.11.x).
+            const ErrorCode error = MG_State::pGLContext->ValidateShaderName(program)
+                ? ErrorCode::InvalidOperation
+                : ErrorCode::InvalidValue;
             MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
+                error,
                 MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             std::to_string(program) + " is not a valid name."));
+                                             std::to_string(program) +
+                                                 (error == ErrorCode::InvalidOperation ? " is not a program object."
+                                                                                       : " is not a valid name.")));
             return false;
         }
         return true;
@@ -605,6 +613,18 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = programObject->GetActiveUniformBlocksMaxNameLength() + 1;
             MGLOG_D("%s: %s = %d", __func__, MG_Util::ConvertGLEnumToString(pname).c_str(), *params);
             break;
+        case GL_TRANSFORM_FEEDBACK_VARYINGS:
+            *params = static_cast<GLint>(programObject->GetTransformFeedbackVaryingCount());
+            MGLOG_D("%s: %s = %d", __func__, MG_Util::ConvertGLEnumToString(pname).c_str(), *params);
+            break;
+        case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
+            *params = static_cast<GLint>(programObject->GetTransformFeedbackBufferMode());
+            MGLOG_D("%s: %s = %d", __func__, MG_Util::ConvertGLEnumToString(pname).c_str(), *params);
+            break;
+        case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
+            *params = programObject->GetTransformFeedbackVaryingMaxLength();
+            MGLOG_D("%s: %s = %d", __func__, MG_Util::ConvertGLEnumToString(pname).c_str(), *params);
+            break;
         case GL_COMPUTE_WORK_GROUP_SIZE: { // GL >= 4.3
             if (!programObject->GetLinkStatus() || programObject->GetShaderIndexByStage(ShaderStage::Compute) < 0) {
                 MG_State::pGLContext->RecordError(
@@ -624,9 +644,6 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         case GL_PROGRAM_BINARY_LENGTH:
 
-        case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
-        case GL_TRANSFORM_FEEDBACK_VARYINGS:
-        case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
         case GL_GEOMETRY_VERTICES_OUT:
         case GL_GEOMETRY_INPUT_TYPE:
         case GL_GEOMETRY_OUTPUT_TYPE:
@@ -827,19 +844,13 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     GLboolean IsProgram_State(GLuint program) {
-        /* FIXME: Handle situations that:
-         * A program object marked for deletion with glDeleteProgram but still in use as part of current
-         * rendering state is still considered a program object and glIsProgram will return GL_TRUE.
-         */
+        // Deletion-flagged names stay valid while the object is still GL-visible (program in
+        // use, shader attached), so name validity is exactly the Is* answer.
         if (program == 0) return GL_FALSE;
         return MG_State::pGLContext->ValidateProgramName(program) ? GL_TRUE : GL_FALSE;
     }
 
     GLboolean IsShader_State(GLuint shader) {
-        /* FIXME: Handle situations that:
-         * A shader object marked for deletion with glDeleteShader but still attached to a program object is still
-         * considered a shader object and glIsShader will return GL_TRUE.
-         */
         if (shader == 0) return GL_FALSE;
         return MG_State::pGLContext->ValidateShaderName(shader) ? GL_TRUE : GL_FALSE;
     }
@@ -849,6 +860,18 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!programObject) return;
         MGLOG_D("%s: linking program %d", __func__, program);
 
+        // Relinking the program an active transform feedback captures from would
+        // invalidate its varyings mid-capture (GL 3.3 core 2.11.3).
+        if (MG_State::pGLContext->IsTransformFeedbackActive() &&
+            MG_State::pGLContext->GetTransformFeedbackProgram().get() == programObject.get()) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl", __func__,
+                    "The program used by active transform feedback cannot be relinked."));
+            return;
+        }
+
         static Bool allowVSOnlyPrograms;
         static Bool initialized = false;
         if (!initialized) {
@@ -892,6 +915,16 @@ namespace MobileGL::MG_Impl::GLImpl {
     void UseProgram_State(GLuint program) {
         MGLOG_D("UseProgram_State: program=%u", program);
 
+        // GL 3.3 core 2.11.3: the program in use may not change while transform
+        // feedback is active (there is no pause in 3.3).
+        if (MG_State::pGLContext->IsTransformFeedbackActive()) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                                             "The current program cannot change while transform feedback is active."));
+            return;
+        }
+
         if (program == 0) {
             MG_State::pGLContext->UseProgram(0);
             return;
@@ -2217,4 +2250,66 @@ namespace MobileGL::MG_Impl::GLImpl {
     void ValidateProgram(GLuint program) {
         ValidateProgram_State(program);
     }
+
+    void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) {
+        auto& programObject = TryToGetProgramObject(program);
+        if (!programObject) return;
+        if (bufferMode != GL_INTERLEAVED_ATTRIBS && bufferMode != GL_SEPARATE_ATTRIBS) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "bufferMode is not a valid capture mode."));
+            return;
+        }
+        if (count < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "count must be non-negative."));
+            return;
+        }
+        // GL 3.3 core: SEPARATE_ATTRIBS count may not exceed the separate-attrib limit.
+        if (bufferMode == GL_SEPARATE_ATTRIBS && count > 4) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                                             "count exceeds GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS."));
+            return;
+        }
+        Vector<String> names;
+        names.reserve(static_cast<SizeT>(count));
+        for (GLsizei i = 0; i < count; ++i) {
+            names.emplace_back(varyings != nullptr && varyings[i] != nullptr ? varyings[i] : "");
+        }
+        programObject->SetTransformFeedbackVaryings(Move(names), bufferMode);
+    }
+
+    void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size,
+                                     GLenum* type, GLchar* name) {
+        auto& programObject = TryToGetProgramObject(program);
+        if (!programObject) return;
+        if (!programObject->GetLinkStatus()) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                                             std::to_string(program) + " has not been successfully linked."));
+            return;
+        }
+        const auto* varying = programObject->GetTransformFeedbackVarying(index);
+        if (varying == nullptr) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl", __func__,
+                    "index is not an active transform feedback varying of the program."));
+            return;
+        }
+        if (size != nullptr) *size = varying->size;
+        if (type != nullptr) *type = varying->type;
+        GLsizei written = 0;
+        if (name != nullptr && bufSize > 0) {
+            written = std::min<GLsizei>(bufSize - 1, static_cast<GLsizei>(varying->name.size()));
+            Memcpy(name, varying->name.data(), static_cast<SizeT>(written));
+            name[written] = '\0';
+        }
+        if (length != nullptr) *length = written;
+    }
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Program/GL_Program.h

@@ -138,4 +138,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     GLint GetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar* name);
     void ShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
     void ValidateProgram(GLuint program);
+    void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode);
+    void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size,
+                                     GLenum* type, GLchar* name);
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Query/GL_Query.cpp

@@ -27,6 +27,8 @@ namespace MobileGL::MG_Impl::GLImpl {
             Bool ended = false;
             Bool resultCached = false;
             Uint64 cachedResult = 0;
+            // Transform feedback primitive counter at BeginQuery time.
+            Uint64 counterSnapshot = 0;
         };
 
         // Query calls may arrive from any thread (launchers migrate the context
@@ -41,6 +43,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         GLuint g_nextQueryId = 1;
         // Id of the query currently active on GL_TIME_ELAPSED (0 = none).
         GLuint g_activeTimeElapsedQueryId = 0;
+        // Ids of the queries active on the transform feedback targets (0 = none).
+        GLuint g_activePrimitivesWrittenQueryId = 0;
+        GLuint g_activePrimitivesGeneratedQueryId = 0;
+        // Id of the query active on GL_SAMPLES_PASSED (0 = none).
+        GLuint g_activeSamplesPassedQueryId = 0;
 
         Bool TimerQueryDisabled() {
             return MG_Config::Features.DisableTimerQuery;
@@ -126,6 +133,11 @@ namespace MobileGL::MG_Impl::GLImpl {
                         outValue = 0;
                         return true;
                     }
+                    // ANY_SAMPLES_PASSED* report a boolean.
+                    if (queryObject->target == GL_ANY_SAMPLES_PASSED ||
+                        queryObject->target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
+                        result = result != 0 ? 1 : 0;
+                    }
                     // Final value produced (or no GetQueryResult64 hook: the
                     // query degrades to a zero result); the backend handle is
                     // consumed and the value cached for later reads.
@@ -180,7 +192,24 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
             QueryObject* queryObject = it->second;
             if (queryObject->active) {
-                EndTimeElapsedQueryLocked(queryObject); // implicitly end before deletion
+                // Implicitly end before deletion, releasing the matching active slot.
+                if (queryObject->target == GL_SAMPLES_PASSED || queryObject->target == GL_ANY_SAMPLES_PASSED ||
+                    queryObject->target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
+                    if (const auto endOcclusionQuery = MG_Backend::gBackendFunctionsTable.GL.EndOcclusionQuery;
+                        endOcclusionQuery && queryObject->backendHandle) {
+                        endOcclusionQuery(queryObject->backendHandle);
+                    }
+                    queryObject->active = false;
+                    g_activeSamplesPassedQueryId = 0;
+                } else if (queryObject->target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ||
+                           queryObject->target == GL_PRIMITIVES_GENERATED) {
+                    queryObject->active = false;
+                    (queryObject->target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
+                         ? g_activePrimitivesWrittenQueryId
+                         : g_activePrimitivesGeneratedQueryId) = 0;
+                } else {
+                    EndTimeElapsedQueryLocked(queryObject);
+                }
             }
             if (queryObject->backendHandle) {
                 if (const auto deleteBackendQuery = MG_Backend::gBackendFunctionsTable.GL.DeleteBackendQuery) {
@@ -204,10 +233,15 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void BeginQuery(GLenum target, GLuint id) {
-        if (target != GL_TIME_ELAPSED) {
-            // Only GL_TIME_ELAPSED timer queries are implemented (occlusion and
-            // primitive queries remain stubs); GL_TIMESTAMP is not a valid
-            // BeginQuery target either.
+        const Bool isTransformFeedbackQuery =
+            target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN || target == GL_PRIMITIVES_GENERATED;
+        const Bool isOcclusionQuery =
+            (target == GL_SAMPLES_PASSED || target == GL_ANY_SAMPLES_PASSED ||
+             target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) &&
+            MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery != nullptr;
+        if (target != GL_TIME_ELAPSED && !isTransformFeedbackQuery && !isOcclusionQuery) {
+            // GL_TIMESTAMP is not a valid BeginQuery target; the occlusion targets
+            // need backend support.
             RecordQueryError(ErrorCode::InvalidEnum, __FUNCTION__, "Query target is not supported.");
             return;
         }
@@ -221,9 +255,13 @@ namespace MobileGL::MG_Impl::GLImpl {
             RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__, "Query object does not exist.");
             return;
         }
-        if (g_activeTimeElapsedQueryId != 0) {
+        GLuint& activeQueryId = isTransformFeedbackQuery
+            ? (target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ? g_activePrimitivesWrittenQueryId
+                                                                  : g_activePrimitivesGeneratedQueryId)
+            : (isOcclusionQuery ? g_activeSamplesPassedQueryId : g_activeTimeElapsedQueryId);
+        if (activeQueryId != 0) {
             RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__,
-                             "A query is already active on GL_TIME_ELAPSED.");
+                             "A query is already active on this target.");
             return;
         }
         if (queryObject->active) {
@@ -239,25 +277,72 @@ namespace MobileGL::MG_Impl::GLImpl {
         ResetQueryObjectLocked(queryObject); // discard any previous result
         queryObject->target = target;
         queryObject->active = true;
-        const auto beginTimeElapsedQuery = MG_Backend::gBackendFunctionsTable.GL.BeginTimeElapsedQuery;
-        queryObject->backendHandle =
-            (!TimerQueryDisabled() && beginTimeElapsedQuery) ? beginTimeElapsedQuery() : nullptr;
-        g_activeTimeElapsedQueryId = id;
+        if (isTransformFeedbackQuery) {
+            // Prefer real GPU transform-feedback queries (exact with geometry shaders);
+            // the CPU accounting delta stays as the fallback when the backend lacks them.
+            const auto beginXfbPrimitivesQuery = MG_Backend::gBackendFunctionsTable.GL.BeginXfbPrimitivesQuery;
+            queryObject->backendHandle =
+                beginXfbPrimitivesQuery ? beginXfbPrimitivesQuery(target == GL_PRIMITIVES_GENERATED) : nullptr;
+            queryObject->counterSnapshot = MG_State::pGLContext->GetTransformFeedbackPrimitiveCounter();
+        } else if (isOcclusionQuery) {
+            queryObject->backendHandle = MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery();
+        } else {
+            const auto beginTimeElapsedQuery = MG_Backend::gBackendFunctionsTable.GL.BeginTimeElapsedQuery;
+            queryObject->backendHandle =
+                (!TimerQueryDisabled() && beginTimeElapsedQuery) ? beginTimeElapsedQuery() : nullptr;
+        }
+        activeQueryId = id;
     }
 
     void EndQuery(GLenum target) {
-        if (target != GL_TIME_ELAPSED) {
+        const Bool isTransformFeedbackQuery =
+            target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN || target == GL_PRIMITIVES_GENERATED;
+        const Bool isOcclusionQuery =
+            (target == GL_SAMPLES_PASSED || target == GL_ANY_SAMPLES_PASSED ||
+             target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) &&
+            MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery != nullptr;
+        if (target != GL_TIME_ELAPSED && !isTransformFeedbackQuery && !isOcclusionQuery) {
             RecordQueryError(ErrorCode::InvalidEnum, __FUNCTION__, "Query target is not supported.");
             return;
         }
         const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
-        if (g_activeTimeElapsedQueryId == 0) {
-            RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__, "No query is active on GL_TIME_ELAPSED.");
+        GLuint& activeQueryId = isTransformFeedbackQuery
+            ? (target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ? g_activePrimitivesWrittenQueryId
+                                                                  : g_activePrimitivesGeneratedQueryId)
+            : (isOcclusionQuery ? g_activeSamplesPassedQueryId : g_activeTimeElapsedQueryId);
+        if (activeQueryId == 0) {
+            RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__, "No query is active on this target.");
             return;
         }
-        auto* queryObject = FindQueryObjectLocked(g_activeTimeElapsedQueryId);
+        auto* queryObject = FindQueryObjectLocked(activeQueryId);
         if (!queryObject) {
-            g_activeTimeElapsedQueryId = 0; // should not happen; keep state consistent
+            activeQueryId = 0; // should not happen; keep state consistent
+            return;
+        }
+        if (isTransformFeedbackQuery) {
+            if (queryObject->backendHandle) {
+                if (const auto endXfbPrimitivesQuery = MG_Backend::gBackendFunctionsTable.GL.EndXfbPrimitivesQuery) {
+                    endXfbPrimitivesQuery(queryObject->backendHandle);
+                }
+                // Result comes from the GPU query at read time.
+            } else {
+                queryObject->cachedResult =
+                    MG_State::pGLContext->GetTransformFeedbackPrimitiveCounter() - queryObject->counterSnapshot;
+                queryObject->resultCached = true;
+            }
+            queryObject->active = false;
+            queryObject->ended = true;
+            activeQueryId = 0;
+            return;
+        }
+        if (isOcclusionQuery) {
+            if (const auto endOcclusionQuery = MG_Backend::gBackendFunctionsTable.GL.EndOcclusionQuery;
+                endOcclusionQuery && queryObject->backendHandle) {
+                endOcclusionQuery(queryObject->backendHandle);
+            }
+            queryObject->active = false;
+            queryObject->ended = true;
+            activeQueryId = 0;
             return;
         }
         EndTimeElapsedQueryLocked(queryObject);
@@ -303,9 +388,25 @@ namespace MobileGL::MG_Impl::GLImpl {
         switch (pname) {
         case GL_CURRENT_QUERY: {
             const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
-            // Only GL_TIME_ELAPSED queries can be active; GL_TIMESTAMP queries
-            // never are, and other targets remain unimplemented.
-            *params = target == GL_TIME_ELAPSED ? static_cast<GLint>(g_activeTimeElapsedQueryId) : 0;
+            switch (target) {
+            case GL_TIME_ELAPSED:
+                *params = static_cast<GLint>(g_activeTimeElapsedQueryId);
+                break;
+            case GL_SAMPLES_PASSED:
+            case GL_ANY_SAMPLES_PASSED:
+            case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
+                *params = static_cast<GLint>(g_activeSamplesPassedQueryId);
+                break;
+            case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
+                *params = static_cast<GLint>(g_activePrimitivesWrittenQueryId);
+                break;
+            case GL_PRIMITIVES_GENERATED:
+                *params = static_cast<GLint>(g_activePrimitivesGeneratedQueryId);
+                break;
+            default:
+                *params = 0;
+                break;
+            }
             return;
         }
         case GL_QUERY_COUNTER_BITS: {
@@ -313,7 +414,13 @@ namespace MobileGL::MG_Impl::GLImpl {
             // time: IsTimerQuerySupported is the dynamic truth (extension /
             // entry points / timestamp valid bits at call time, not at table
             // init), and the MOBILEGL_DISABLE_TIMERQUERY kill switch always
-            // wins. Non-timer targets remain unimplemented and report 0.
+            // wins.
+            if (target == GL_SAMPLES_PASSED || target == GL_ANY_SAMPLES_PASSED ||
+                target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
+                const Bool occlusionSupported = MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery != nullptr;
+                *params = occlusionSupported ? (target == GL_SAMPLES_PASSED ? 32 : 1) : 0;
+                return;
+            }
             const Bool timerTarget = target == GL_TIME_ELAPSED || target == GL_TIMESTAMP;
             const auto isTimerQuerySupported = MG_Backend::gBackendFunctionsTable.GL.IsTimerQuerySupported;
             const Bool supported =

MobileGL/MG_Impl/GLImpl/Sampler/GL_Sampler.cpp

@@ -185,6 +185,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         static thread_local Vector<GLuint> names;
         MG_State::pGLContext->GenSamplerNames(count, names);
         Memcpy(samplers, names.data(), count * sizeof(GLuint));
+        // Unlike textures/buffers, glGenSamplers CREATES the sampler objects: each name
+        // is immediately a sampler (glIsSampler == GL_TRUE before any bind).
+        for (GLsizei i = 0; i < count; ++i) {
+            MG_State::pGLContext->CreateSamplerObject(names[i]);
+        }
     }
 
     void DeleteSamplers_State(GLsizei count, const GLuint* samplers) {

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/GLImpl/Texture/GL_Texture.cpp

@@ -2820,7 +2820,22 @@ namespace MobileGL::MG_Impl::GLImpl {
                                          "The attachment specified by the read buffer is incomplete."));               \
         return false;                                                                                                  \
     }
-        if (isDepth) {
+        if (isDepth && isStencil) {
+            // A combined internalformat copies both halves, so the read framebuffer
+            // must populate both attachment points.
+            const auto& stencilAttachment = currentReadFBO->GetAttachment(FramebufferAttachmentType::Stencil);
+            const auto& depthAttachment = currentReadFBO->GetAttachment(FramebufferAttachmentType::Depth);
+            if (!depthAttachment.IsValid() || depthAttachment.IsEmpty() || !stencilAttachment.IsValid() ||
+                stencilAttachment.IsEmpty()) {
+                MG_State::pGLContext->RecordError(
+                    ErrorCode::InvalidOperation,
+                    MakeUnique<GenericErrorInfo>(
+                        "MG_Impl/GLImpl", "CopyTexImage2D_State",
+                        "DEPTH_STENCIL copy requires both depth and stencil attachments in the read framebuffer."));
+                return false;
+            }
+            GET_SRC_INTERNAL_FORMAT(FramebufferAttachmentType::Depth);
+        } else if (isDepth) {
             GET_SRC_INTERNAL_FORMAT(FramebufferAttachmentType::Depth);
         } else if (isStencil) {
             GET_SRC_INTERNAL_FORMAT(FramebufferAttachmentType::Stencil);

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/BufferState/BufferObject.cpp

@@ -231,6 +231,21 @@ namespace MobileGL::MG_State::GLState {
         return m_resource.Bytes();
     }
 
+    Bool BufferObject::EnsureGpuResidentStorage() {
+        if (m_resource.IsGpuResident()) {
+            return true;
+        }
+        if (m_size == 0 || g_bufferBackendOps == nullptr || g_bufferBackendOps->AcquirePersistentMap == nullptr) {
+            return false;
+        }
+        void* base = g_bufferBackendOps->AcquirePersistentMap(*this);
+        if (base == nullptr) {
+            return false;
+        }
+        m_resource.AdoptPersistentMap(base);
+        return true;
+    }
+
     void* BufferObject::AcquireMemoryRange(Range1D range, Flags<BufferMappingAccessBit> access) {
         MOBILEGL_ASSERT(range.end <= m_size && range.start <= range.end,
                         "AcquireMemoryRange out of bounds: range (%zu, %zu) exceeds m_size (%zu)", range.start,

MobileGL/MG_State/GLState/BufferState/BufferObject.h

@@ -133,6 +133,11 @@ namespace MobileGL {
 
             void* AcquireMemory(Bool markMapped, Bool read, Bool write);
             void* AcquireMemoryRange(Range1D range, Flags<BufferMappingAccessBit> access);
+            // Adopt backend host-visible coherent GPU storage as the source of truth
+            // (used for GPU-written targets like transform feedback capture, so
+            // MapBuffer/GetBufferSubData read real GPU results). No-op when already
+            // resident or when the backend declines.
+            Bool EnsureGpuResidentStorage();
             void ReleaseMemory();
             void FlushMemoryRange(SizeT offset, SizeT length);
 

MobileGL/MG_State/GLState/Core.h

@@ -211,6 +211,47 @@ namespace MobileGL {
                 void SetScissorBox(IntVec4 box);      // x, y, width, height
                 const IntVec4& GetScissorBox() const; // x, y, width, height
 
+                // Transform feedback (GL 3.0 core Begin/End; no feedback objects yet)
+                void BeginTransformFeedback(GLenum primitiveMode, const SharedPtr<ProgramObject>& program) {
+                    m_transformFeedbackActive = true;
+                    m_transformFeedbackPrimitiveMode = primitiveMode;
+                    m_transformFeedbackProgram = program;
+                    ++m_transformFeedbackGeneration;
+                    m_transformFeedbackCapturedVertices = 0;
+                    m_transformFeedbackInputPrimitives = 0;
+                }
+                void EndTransformFeedback() {
+                    m_transformFeedbackActive = false;
+                    m_transformFeedbackProgram.reset();
+                }
+                Bool IsTransformFeedbackActive() const { return m_transformFeedbackActive; }
+                GLenum GetTransformFeedbackPrimitiveMode() const { return m_transformFeedbackPrimitiveMode; }
+                const SharedPtr<ProgramObject>& GetTransformFeedbackProgram() const {
+                    return m_transformFeedbackProgram;
+                }
+                // Bumped on every BeginTransformFeedback; the backend uses it to
+                // distinguish "resume appending" from "fresh capture".
+                Uint64 GetTransformFeedbackGeneration() const { return m_transformFeedbackGeneration; }
+                // CPU-side primitive accounting for the transform feedback queries:
+                // every captured draw adds its primitive count (draws without a
+                // geometry stage write exactly what they generate).
+                void AddTransformFeedbackPrimitives(Uint64 primitives) {
+                    m_transformFeedbackPrimitiveCounter += primitives;
+                }
+                Uint64 GetTransformFeedbackPrimitiveCounter() const { return m_transformFeedbackPrimitiveCounter; }
+                // Vertices already captured since BeginTransformFeedback (drives the
+                // buffer-capacity clamp on the primitives-written accounting).
+                void AddTransformFeedbackCapturedVertices(Uint64 vertices) {
+                    m_transformFeedbackCapturedVertices += vertices;
+                }
+                Uint64 GetTransformFeedbackCapturedVertices() const { return m_transformFeedbackCapturedVertices; }
+                // Raw assembled input primitives fed to the capture stage since Begin
+                // (pre-clamp; drives the GS strip capture-order fixup at EndTF).
+                void AddTransformFeedbackInputPrimitives(Uint64 primitives) {
+                    m_transformFeedbackInputPrimitives += primitives;
+                }
+                Uint64 GetTransformFeedbackInputPrimitives() const { return m_transformFeedbackInputPrimitives; }
+
                 // Framebuffer
                 void GenFramebufferNames(Uint number, Vector<Uint>& framebuffers);
                 const SharedPtr<FramebufferObject>& GetFramebufferObject(Uint index);
@@ -243,6 +284,13 @@ namespace MobileGL {
                 BufferState m_bufferState;
                 VertexArrayState m_vertexArrayState;
                 Array<CurrentVertexAttributeValue, VertexArrayObject::MAX_VERTEX_ATTRIBS> m_currentVertexAttributes{};
+                Bool m_transformFeedbackActive = false;
+                GLenum m_transformFeedbackPrimitiveMode = GL_POINTS;
+                SharedPtr<ProgramObject> m_transformFeedbackProgram;
+                Uint64 m_transformFeedbackGeneration = 0;
+                Uint64 m_transformFeedbackPrimitiveCounter = 0;
+                Uint64 m_transformFeedbackCapturedVertices = 0;
+                Uint64 m_transformFeedbackInputPrimitives = 0;
                 TextureState m_textureState;
                 ProgramState m_programState;
                 RenderState m_renderState;

MobileGL/MG_State/GLState/ProgramState/ProgramObject.cpp

@@ -170,9 +170,230 @@ namespace MobileGL::MG_State::GLState {
         m_uniformNameMaxLength = 0;
         m_attribInNameMaxLength = 0;
         m_uniformBlockNameMaxLength = 0;
+        m_xfbVaryings.clear();
+        m_xfbStrides.clear();
+        m_xfbBufferMode = GL_INTERLEAVED_ATTRIBS;
+        m_xfbVaryingNameMaxLength = 0;
         m_linkStatus = false;
     }
 
+    namespace {
+        // GL type enum for a vertex-stage output symbol captured by transform
+        // feedback. Covers the scalar/vector/matrix float+integer types transform
+        // feedback may legally capture in GL 3.3.
+        Bool ResolveXfbSymbolType(const glslang::TType& type, GLenum& outType, GLint& outArraySize,
+                                  Uint32& outBytesPerElement) {
+            outArraySize = type.isArray() ? type.getOuterArraySize() : 1;
+            const Int columns = type.isMatrix() ? type.getMatrixCols() : 1;
+            const Int components = type.isMatrix() ? type.getMatrixRows()
+                                                   : (type.isVector() ? type.getVectorSize() : 1);
+            const glslang::TBasicType basic = type.getBasicType();
+            static constexpr GLenum kFloatTypes[5] = {0, GL_FLOAT, GL_FLOAT_VEC2, GL_FLOAT_VEC3, GL_FLOAT_VEC4};
+            static constexpr GLenum kIntTypes[5] = {0, GL_INT, GL_INT_VEC2, GL_INT_VEC3, GL_INT_VEC4};
+            static constexpr GLenum kUintTypes[5] = {0, GL_UNSIGNED_INT, GL_UNSIGNED_INT_VEC2, GL_UNSIGNED_INT_VEC3,
+                                                     GL_UNSIGNED_INT_VEC4};
+            if (type.isMatrix()) {
+                if (basic != glslang::EbtFloat) return false;
+                static constexpr GLenum kMatTypes[5][5] = {
+                    {}, {},
+                    {0, 0, GL_FLOAT_MAT2, GL_FLOAT_MAT2x3, GL_FLOAT_MAT2x4},
+                    {0, 0, GL_FLOAT_MAT3x2, GL_FLOAT_MAT3, GL_FLOAT_MAT3x4},
+                    {0, 0, GL_FLOAT_MAT4x2, GL_FLOAT_MAT4x3, GL_FLOAT_MAT4},
+                };
+                if (columns < 2 || columns > 4 || components < 2 || components > 4) return false;
+                outType = kMatTypes[columns][components];
+            } else if (components >= 1 && components <= 4) {
+                switch (basic) {
+                case glslang::EbtFloat: outType = kFloatTypes[components]; break;
+                case glslang::EbtInt: outType = kIntTypes[components]; break;
+                case glslang::EbtUint: outType = kUintTypes[components]; break;
+                default: return false;
+                }
+            } else {
+                return false;
+            }
+            outBytesPerElement = static_cast<Uint32>(columns * components) * 4u;
+            return true;
+        }
+    } // namespace
+
+    Bool ProgramObject::ResolveTransformFeedbackVaryings() {
+        m_xfbVaryings.clear();
+        m_xfbStrides.clear();
+        m_xfbBufferMode = m_requestedXfbBufferMode;
+        m_xfbVaryingNameMaxLength = 0;
+        if (m_requestedXfbVaryings.empty()) {
+            return true;
+        }
+
+        // Capture happens at the last vertex-processing stage (geometry, then
+        // tessellation evaluation, then vertex).
+        const glslang::TIntermediate* captureIntermediate = nullptr;
+        for (EShLanguage stage : {EShLangGeometry, EShLangTessEvaluation, EShLangVertex}) {
+            captureIntermediate = m_program->getIntermediate(stage);
+            if (captureIntermediate != nullptr) {
+                break;
+            }
+        }
+        if (captureIntermediate == nullptr) {
+            m_infoLog = "Transform feedback varyings requested but the program has no vertex-processing stage.";
+            return false;
+        }
+        const glslang::TIntermAggregate* linkerObjects = captureIntermediate->findLinkerObjects();
+
+        const Bool interleaved = m_xfbBufferMode == GL_INTERLEAVED_ATTRIBS;
+        Uint32 interleavedOffset = 0;
+        for (SizeT i = 0; i < m_requestedXfbVaryings.size(); ++i) {
+            const String& name = m_requestedXfbVaryings[i];
+            for (SizeT j = 0; j < i; ++j) {
+                if (m_requestedXfbVaryings[j] == name) {
+                    m_infoLog = "Transform feedback varying '" + name + "' is specified more than once.";
+                    return false;
+                }
+            }
+
+            XfbVarying varying;
+            varying.name = name;
+            Uint32 bytesPerElement = 0;
+            Bool resolved = false;
+            if (name == "gl_Position") {
+                varying.type = GL_FLOAT_VEC4;
+                varying.size = 1;
+                bytesPerElement = 16;
+                resolved = true;
+            } else if (name == "gl_PointSize") {
+                varying.type = GL_FLOAT;
+                varying.size = 1;
+                bytesPerElement = 4;
+                resolved = true;
+            } else if (linkerObjects != nullptr) {
+                for (const auto* node : linkerObjects->getSequence()) {
+                    const glslang::TIntermSymbol* symbol = node->getAsSymbolNode();
+                    if (symbol == nullptr || symbol->getType().getQualifier().storage != glslang::EvqVaryingOut) {
+                        continue;
+                    }
+                    if (symbol->getName() != name.c_str()) {
+                        continue;
+                    }
+                    resolved = ResolveXfbSymbolType(symbol->getType(), varying.type, varying.size, bytesPerElement);
+                    break;
+                }
+            }
+            if (!resolved) {
+                m_infoLog = "Transform feedback varying '" + name + "' is not an output of the vertex stage.";
+                return false;
+            }
+
+            varying.byteSize = bytesPerElement * static_cast<Uint32>(varying.size);
+            if (interleaved) {
+                varying.bufferIndex = 0;
+                varying.offsetBytes = interleavedOffset;
+                interleavedOffset += varying.byteSize;
+            } else {
+                varying.bufferIndex = static_cast<Uint32>(i);
+                varying.offsetBytes = 0;
+            }
+            m_xfbVaryingNameMaxLength =
+                std::max(m_xfbVaryingNameMaxLength, static_cast<Int>(name.size()) + 1);
+            m_xfbVaryings.push_back(Move(varying));
+        }
+
+        constexpr Uint32 kMaxSeparateAttribs = 4;
+        constexpr Uint32 kMaxSeparateComponents = 4;
+        constexpr Uint32 kMaxInterleavedComponents = 64;
+        if (interleaved) {
+            if (interleavedOffset > kMaxInterleavedComponents * 4) {
+                m_infoLog = "Transform feedback interleaved capture exceeds "
+                            "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS.";
+                return false;
+            }
+            m_xfbStrides.assign(1, interleavedOffset);
+        } else {
+            if (m_xfbVaryings.size() > kMaxSeparateAttribs) {
+                m_infoLog = "Transform feedback separate capture exceeds "
+                            "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS.";
+                return false;
+            }
+            m_xfbStrides.resize(m_xfbVaryings.size());
+            for (SizeT i = 0; i < m_xfbVaryings.size(); ++i) {
+                if (m_xfbVaryings[i].byteSize > kMaxSeparateComponents * 4) {
+                    m_infoLog = "Transform feedback varying '" + m_xfbVaryings[i].name +
+                                "' exceeds GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS.";
+                    return false;
+                }
+                m_xfbStrides[i] = m_xfbVaryings[i].byteSize;
+            }
+        }
+
+        ResolveGsTriangleStripCapture(captureIntermediate);
+        return true;
+    }
+
+    namespace {
+        // Extracts a geometry shader's per-invocation EmitVertex/EndPrimitive sequence
+        // when it is statically knowable (no emit inside selection/loop/switch). Vulkan
+        // transform feedback captures triangle strips in plain (i, i+1, i+2) order while
+        // GL decomposes odd strip triangles as (i+1, i, i+2) (GL 4.6 table 10.1); with
+        // the static strip lengths the capture buffer can be reordered after EndTF.
+        class GsEmitSequenceTraverser final : public glslang::TIntermTraverser {
+        public:
+            bool visitAggregate(glslang::TVisit, glslang::TIntermAggregate* node) override {
+                if (node->getOp() == glslang::EOpEmitVertex) {
+                    ++emitCount;
+                    hasEmit = true;
+                } else if (node->getOp() == glslang::EOpEndPrimitive) {
+                    FlushStrip();
+                }
+                return true;
+            }
+            bool visitSelection(glslang::TVisit, glslang::TIntermSelection*) override {
+                inControlFlow = true;
+                return true;
+            }
+            bool visitLoop(glslang::TVisit, glslang::TIntermLoop*) override {
+                inControlFlow = true;
+                return true;
+            }
+            bool visitSwitch(glslang::TVisit, glslang::TIntermSwitch*) override {
+                inControlFlow = true;
+                return true;
+            }
+            void FlushStrip() {
+                if (emitCount >= 3) {
+                    stripTriangles.push_back(static_cast<Uint32>(emitCount - 2));
+                }
+                emitCount = 0;
+            }
+
+            Vector<Uint32> stripTriangles;
+            Uint32 emitCount = 0;
+            Bool hasEmit = false;
+            Bool inControlFlow = false;
+        };
+    } // namespace
+
+    void ProgramObject::ResolveGsTriangleStripCapture(const glslang::TIntermediate* captureIntermediate) {
+        m_gsStripTriangles.clear();
+        m_gsStripCaptureFixup = false;
+        if (captureIntermediate == nullptr || m_program == nullptr) {
+            return;
+        }
+        if (m_program->getIntermediate(EShLangGeometry) != captureIntermediate) {
+            return;
+        }
+        if (captureIntermediate->getOutputPrimitive() != glslang::ElgTriangleStrip) {
+            return;
+        }
+        GsEmitSequenceTraverser traverser;
+        const_cast<glslang::TIntermediate*>(captureIntermediate)->getTreeRoot()->traverse(&traverser);
+        traverser.FlushStrip(); // the invocation end acts as an implicit EndPrimitive
+        if (!traverser.hasEmit || traverser.inControlFlow || traverser.stripTriangles.empty()) {
+            return;
+        }
+        m_gsStripTriangles = Move(traverser.stripTriangles);
+        m_gsStripCaptureFixup = true;
+    }
+
     bool ProgramObject::ShaderIsAttached(const SharedPtr<ShaderObject>& shader) {
         MGLOG_D("ProgramObject %u: ShaderIsAttached check for shader %p", m_externalIndex, shader.get());
         auto it = std::find_if(m_shaders.begin(), m_shaders.end(),
@@ -327,6 +548,12 @@ namespace MobileGL::MG_State::GLState {
         if (!ValidateFragmentOutputLocations()) {
             return;
         }
+        if (!ResolveTransformFeedbackVaryings()) {
+            m_linkStatus = false;
+            MGLOG_E("ProgramObject %u: transform feedback varying resolution failed: %s", m_externalIndex,
+                    m_infoLog.c_str());
+            return;
+        }
 
         MGLOG_D("ProgramObject %u: Starting binary generation", m_externalIndex);
         GenerateBinary();

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) {
@@ -449,6 +465,39 @@ namespace MobileGL::MG_State::GLState {
             return it == m_shaders.end() ? -1 : (Int)std::distance(m_shaders.begin(), it);
         }
 
+        // Transform feedback (GL 3.0 core: glTransformFeedbackVaryings applies on
+        // the NEXT link; the linked snapshot below is what draws and queries see).
+        struct XfbVarying {
+            String name;
+            GLenum type = GL_FLOAT;
+            GLint size = 1;           // array element count
+            Uint32 bufferIndex = 0;   // capture buffer slot
+            Uint32 offsetBytes = 0;   // offset within the capture buffer
+            Uint32 byteSize = 0;      // bytes captured per vertex for this varying
+        };
+        void SetTransformFeedbackVaryings(Vector<String>&& names, GLenum bufferMode) {
+            m_requestedXfbVaryings = Move(names);
+            m_requestedXfbBufferMode = bufferMode;
+        }
+        GLenum GetTransformFeedbackBufferMode() const { return m_xfbBufferMode; }
+        SizeT GetTransformFeedbackVaryingCount() const { return m_xfbVaryings.size(); }
+        const XfbVarying* GetTransformFeedbackVarying(SizeT index) const {
+            return index < m_xfbVaryings.size() ? &m_xfbVaryings[index] : nullptr;
+        }
+        const Vector<XfbVarying>& GetTransformFeedbackVaryings() const { return m_xfbVaryings; }
+        // Stride of one captured vertex in the given capture buffer slot.
+        Uint32 GetTransformFeedbackStride(Uint32 bufferIndex) const {
+            return bufferIndex < m_xfbStrides.size() ? m_xfbStrides[bufferIndex] : 0;
+        }
+        SizeT GetTransformFeedbackBufferCount() const { return m_xfbStrides.size(); }
+        Int GetTransformFeedbackVaryingMaxLength() const { return m_xfbVaryingNameMaxLength; }
+        // True when the capture stage is a triangle-strip geometry shader with a
+        // statically-known emit sequence: the Vulkan capture order then needs the GL
+        // odd-triangle vertex swap after EndTransformFeedback.
+        Bool HasGsTriangleStripCaptureFixup() const { return m_gsStripCaptureFixup; }
+        // Triangles per strip, in emission order, for ONE geometry invocation.
+        const Vector<Uint32>& GetGsStripTriangles() const { return m_gsStripTriangles; }
+
         Uint GetExternalIndex() const { return m_externalIndex; }
         // Globally-unique, never-reused id for this program object's lifetime. Unlike the GL
         // name (external index), which is freed to a LIFO list and immediately handed back by
@@ -459,6 +508,11 @@ namespace MobileGL::MG_State::GLState {
     private:
         void ResetLinkArtifacts();
         void DoReflection();
+        // Resolves the requested transform feedback varyings against the linked
+        // vertex stage; fails the link (GL semantics) on unknown or duplicate
+        // names or exceeded capture limits.
+        Bool ResolveTransformFeedbackVaryings();
+        void ResolveGsTriangleStripCapture(const glslang::TIntermediate* captureIntermediate);
         void GenerateBinary();
         void WaitUntilGenerationCompleted() const;
         void AddDefaultFragmentShaderIfMissing();
@@ -527,11 +581,30 @@ 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;
+
+        // Transform feedback: request (applies at next link) and linked snapshot.
+        Vector<String> m_requestedXfbVaryings;
+        GLenum m_requestedXfbBufferMode = GL_INTERLEAVED_ATTRIBS;
+        Vector<XfbVarying> m_xfbVaryings;
+        Vector<Uint32> m_xfbStrides;
+        Vector<Uint32> m_gsStripTriangles;
+        Bool m_gsStripCaptureFixup = false;
+        GLenum m_xfbBufferMode = GL_INTERLEAVED_ATTRIBS;
+        Int m_xfbVaryingNameMaxLength = 0;
     };
 } // namespace MobileGL::MG_State::GLState

MobileGL/MG_State/GLState/ProgramState/ProgramState.cpp

@@ -29,17 +29,25 @@ namespace MobileGL::MG_State::GLState {
         if (!CheckIndexAvail(program, m_programObjects)) return; // FIXME: add error reporting here
         auto& programObject = m_programObjects[program];
         if (programObject != nullptr) {
-            // Snapshot the attachments: deleting the program is a detach point for shaders
-            // that were flagged with glDeleteShader while still attached.
-            const Vector<SharedPtr<ShaderObject>> attachedShaders = programObject->GetAttachedShaders();
             programObject->MarkAsDeleted();
-            programObject.reset();
-            m_programIndexGenerator.Delete(program);
-            for (const auto& shader : attachedShaders) {
-                const Uint shaderName = shader->GetExternalIndex();
-                if (CheckIndexAvail(shaderName, m_shaderObjects) && m_shaderObjects[shaderName] == shader) {
-                    ReleaseShaderNameIfOrphaned(shaderName);
-                }
+            // A program in use is only FLAGGED: its name (and every program query) stays
+            // valid until it stops being current, at which point UseProgram finishes the job.
+            if (programObject == m_currentProgram) return;
+            DestroyProgramSlot(program);
+        }
+    }
+
+    void ProgramState::DestroyProgramSlot(const Uint program) {
+        auto& programObject = m_programObjects[program];
+        // Snapshot the attachments: deleting the program is a detach point for shaders
+        // that were flagged with glDeleteShader while still attached.
+        const Vector<SharedPtr<ShaderObject>> attachedShaders = programObject->GetAttachedShaders();
+        programObject.reset();
+        m_programIndexGenerator.Delete(program);
+        for (const auto& shader : attachedShaders) {
+            const Uint shaderName = shader->GetExternalIndex();
+            if (CheckIndexAvail(shaderName, m_shaderObjects) && m_shaderObjects[shaderName] == shader) {
+                ReleaseShaderNameIfOrphaned(shaderName);
             }
         }
     }
@@ -49,10 +57,22 @@ namespace MobileGL::MG_State::GLState {
     }
 
     void ProgramState::UseProgram(Uint program) {
+        const SharedPtr<ProgramObject> previous = m_currentProgram;
+
         if (program == 0) m_currentProgram.reset();
 
-        if (!CheckIndexAvail(program, m_programObjects)) return;
-        m_currentProgram = m_programObjects[program];
+        if (CheckIndexAvail(program, m_programObjects)) {
+            m_currentProgram = m_programObjects[program];
+        }
+
+        // A deletion flagged while the program was current takes effect the moment it
+        // stops being current.
+        if (previous != nullptr && previous != m_currentProgram && previous->GetDeleteStatus()) {
+            const Uint previousName = previous->GetExternalIndex();
+            if (CheckIndexAvail(previousName, m_programObjects) && m_programObjects[previousName] == previous) {
+                DestroyProgramSlot(previousName);
+            }
+        }
     }
 
     Uint ProgramState::CreateShader(ShaderStage stage) {

MobileGL/MG_State/GLState/ProgramState/ProgramState.h

@@ -35,6 +35,9 @@ namespace MobileGL::MG_State::GLState {
 
     private:
         Bool ShaderHasGLVisibleAttachment(const SharedPtr<ShaderObject>& shaderObject) const;
+        // Frees the name slot and releases orphaned attached shaders; the immediate half
+        // of glDeleteProgram (deferred while the program is current).
+        void DestroyProgramSlot(Uint program);
 
         template <typename T>
         static Bool CheckIndexAvail(const SizeT idx, const Vector<T>& vec) {

MobileGL/MG_State/GLState/ProgramState/ShaderObject.cpp

@@ -169,6 +169,15 @@ namespace MobileGL::MG_State::GLState {
             }
         }
 
+        const std::optional<String> reservedError =
+            MG_Util::ShaderTranspiler::FindReservedIdentifierViolation(compileSource);
+        if (reservedError) {
+            m_compileStatus = false;
+            m_shader.reset();
+            m_infoLog = *reservedError;
+            return;
+        }
+
         // Compile for OpenGL here, so that we can do validation and link
         // like a real OpenGL driver at linking stage
         // Will compile for other backends later.

MobileGL/MG_State/GLState/TextureState/TextureEnum.h

@@ -162,6 +162,7 @@ namespace MobileGL {
         DepthComponent32F,
         Depth24Stencil8,
         Depth32FStencil8,
+        StencilIndex8,
 
         DepthComponent,
         DepthStencil,

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_State/GLState/VertexArrayState/VertexArrayObject.h

@@ -104,6 +104,23 @@ namespace MobileGL {
                     m_backendHashMemoVersion = m_configVersion;
                 }
 
+                // Backend-owned resolved-state memo: an opaque pointer into the
+                // backend's vertex-input-state cache plus the cache's eviction
+                // epoch, valid while the config version matches. Lets the
+                // per-draw path skip the content hash AND the cache lookup; the
+                // epoch guards against the cache evicting the pointee.
+                Bool GetBackendStateMemo(const void*& outState, Uint64& outEpoch) const {
+                    if (m_backendStateMemoVersion != m_configVersion) return false;
+                    outState = m_backendStateMemo;
+                    outEpoch = m_backendStateMemoEpoch;
+                    return true;
+                }
+                void SetBackendStateMemo(const void* state, Uint64 epoch) const {
+                    m_backendStateMemo = state;
+                    m_backendStateMemoEpoch = epoch;
+                    m_backendStateMemoVersion = m_configVersion;
+                }
+
             private:
                 void BumpAttributeFormatVersion(Uint index);
                 void BumpAttributeBufferVersion(Uint index);
@@ -137,6 +154,9 @@ namespace MobileGL {
                 Uint32 m_configVersion = 0;
                 mutable Uint64 m_backendHashMemo = 0;
                 mutable Uint32 m_backendHashMemoVersion = ~0u;
+                mutable const void* m_backendStateMemo = nullptr;
+                mutable Uint64 m_backendStateMemoEpoch = 0;
+                mutable Uint32 m_backendStateMemoVersion = ~0u;
             };
         } // namespace GLState
     } // namespace MG_State

MobileGL/MG_Test/BackendLoader/BackendLoaderTest.cpp

@@ -34,6 +34,11 @@ namespace {
         GLint maxFragmentImageUniforms = 4;
         GLint maxComputeImageUniforms = 5;
         bool maxGeometryImageUniformsQueried = false;
+        GLfloat minFragmentInterpolationOffset = -0.75f;
+        GLfloat maxFragmentInterpolationOffset = 0.625f;
+        GLint fragmentInterpolationOffsetBits = 6;
+        bool fragmentInterpolationLimitsQueried = false;
+        bool fragmentInterpolationQueryRaisesError = false;
         // Emulates ANGLE-on-Vulkan: the draw reads the indirect command's
         // baseInstance word and exposes it through gl_InstanceID.
         bool drawLeaksBaseInstanceWord = false;
@@ -108,6 +113,14 @@ namespace {
             case GL_MAX_COMPUTE_IMAGE_UNIFORMS:
                 *data = g_fake.maxComputeImageUniforms;
                 break;
+            case GL_FRAGMENT_INTERPOLATION_OFFSET_BITS:
+                g_fake.fragmentInterpolationLimitsQueried = true;
+                if (g_fake.fragmentInterpolationQueryRaisesError) {
+                    g_fake.pendingError = GL_INVALID_ENUM;
+                } else {
+                    *data = g_fake.fragmentInterpolationOffsetBits;
+                }
+                break;
             // FillInGLESCapabilities reads the context version before running the
             // baseInstance probe, which requires ES >= 3.1.
             case GL_MAJOR_VERSION:
@@ -155,6 +168,22 @@ namespace {
                 g_fake.maxTextureMaxAnisotropyQueried = true;
                 data[0] = g_fake.maxTextureMaxAnisotropy;
                 break;
+            case GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
+                g_fake.fragmentInterpolationLimitsQueried = true;
+                if (g_fake.fragmentInterpolationQueryRaisesError) {
+                    g_fake.pendingError = GL_INVALID_ENUM;
+                } else {
+                    data[0] = g_fake.minFragmentInterpolationOffset;
+                }
+                break;
+            case GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
+                g_fake.fragmentInterpolationLimitsQueried = true;
+                if (g_fake.fragmentInterpolationQueryRaisesError) {
+                    g_fake.pendingError = GL_INVALID_ENUM;
+                } else {
+                    data[0] = g_fake.maxFragmentInterpolationOffset;
+                }
+                break;
             // Two-component range queries.
             case GL_ALIASED_LINE_WIDTH_RANGE:
             case GL_SMOOTH_LINE_WIDTH_RANGE:
@@ -462,6 +491,52 @@ TEST(ImageUniformCapabilities, QueriesRealPerStageLimitsAndConservativelyGatesGe
     EXPECT_TRUE(g_fake.maxGeometryImageUniformsQueried);
 }
 
+TEST(FragmentInterpolationCapabilities, QueriesOnlyWhenSupportedAndPreservesDriverLimits) {
+    const auto funcs = MakeFakeGLESFunctions();
+
+    ResetFakeDriver();
+    g_fake.maxVertexSsboBlocks = 0;
+    MobileGL::MG_External::GLESCapabilities unsupportedCaps;
+    ASSERT_TRUE(MobileGL::MG_Util::BackendLoader::FillInGLESCapabilities(unsupportedCaps, funcs));
+    EXPECT_FALSE(unsupportedCaps.SupportsShaderMultisampleInterpolation);
+    EXPECT_FALSE(g_fake.fragmentInterpolationLimitsQueried);
+    EXPECT_FLOAT_EQ(unsupportedCaps.MinFragmentInterpolationOffset, -0.5f);
+    EXPECT_FLOAT_EQ(unsupportedCaps.MaxFragmentInterpolationOffset, 0.4375f);
+    EXPECT_EQ(unsupportedCaps.FragmentInterpolationOffsetBits, 4);
+
+    ResetFakeDriver();
+    g_fake.maxVertexSsboBlocks = 0;
+    g_fake.extensions.emplace_back("GL_OES_shader_multisample_interpolation");
+    // A stale error from an earlier capability probe must not make the optional
+    // interpolation query look like it failed.
+    g_fake.pendingError = GL_INVALID_OPERATION;
+    MobileGL::MG_External::GLESCapabilities supportedCaps;
+    ASSERT_TRUE(MobileGL::MG_Util::BackendLoader::FillInGLESCapabilities(supportedCaps, funcs));
+    EXPECT_TRUE(supportedCaps.SupportsShaderMultisampleInterpolation);
+    EXPECT_TRUE(g_fake.fragmentInterpolationLimitsQueried);
+    EXPECT_FLOAT_EQ(supportedCaps.MinFragmentInterpolationOffset, g_fake.minFragmentInterpolationOffset);
+    EXPECT_FLOAT_EQ(supportedCaps.MaxFragmentInterpolationOffset, g_fake.maxFragmentInterpolationOffset);
+    EXPECT_EQ(supportedCaps.FragmentInterpolationOffsetBits, g_fake.fragmentInterpolationOffsetBits);
+    EXPECT_EQ(funcs.glGetError(), GL_NO_ERROR);
+}
+
+TEST(FragmentInterpolationCapabilities, QueryErrorIsDrainedAndFallsBackToCoreMinimums) {
+    ResetFakeDriver();
+    g_fake.maxVertexSsboBlocks = 0;
+    g_fake.extensions.emplace_back("GL_OES_shader_multisample_interpolation");
+    g_fake.fragmentInterpolationQueryRaisesError = true;
+    const auto funcs = MakeFakeGLESFunctions();
+
+    MobileGL::MG_External::GLESCapabilities caps;
+    ASSERT_TRUE(MobileGL::MG_Util::BackendLoader::FillInGLESCapabilities(caps, funcs));
+
+    EXPECT_TRUE(g_fake.fragmentInterpolationLimitsQueried);
+    EXPECT_FLOAT_EQ(caps.MinFragmentInterpolationOffset, -0.5f);
+    EXPECT_FLOAT_EQ(caps.MaxFragmentInterpolationOffset, 0.4375f);
+    EXPECT_EQ(caps.FragmentInterpolationOffsetBits, 4);
+    EXPECT_EQ(funcs.glGetError(), GL_NO_ERROR);
+}
+
 // The extension string is what apps gate on (LWJGL builds GLCapabilities from it), so advertising
 // it on a driver that cannot filter anisotropically would leave them silently on trilinear.
 TEST(TextureAnisotropyCapabilities, ExtensionIsAdvertisedOnlyWhenTheHostDriverSupportsIt) {

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 {
@@ -196,13 +197,13 @@ TEST(DirectGLESSanity, AdvertisesDepthTextureForGlmarkShadowScenes) {
     EXPECT_NE(std::find(extensions.begin(), extensions.end(), MobileGL::E_GL_ARB_depth_texture), extensions.end());
 }
 
-TEST(DirectGLESSanity, AdvertisesVoxyRequiredRenderingExtensionsWithoutRaisingGLVersion) {
+TEST(DirectGLESSanity, AdvertisesVoxyRequiredRenderingExtensionsAtExperimentalCTSVersion) {
     MobileGL::MG_Backend::DirectGLES::BackendObject_DirectGLES backend;
     const auto& rendererInfo = backend.GetRendererInfo().RendererGLInfo;
     const auto& extensions = rendererInfo.Extensions;
 
-    EXPECT_EQ(rendererInfo.TargetGLVersion.Major, 3);
-    EXPECT_EQ(rendererInfo.TargetGLVersion.Minor, 3);
+    EXPECT_EQ(rendererInfo.TargetGLVersion.Major, 4);
+    EXPECT_EQ(rendererInfo.TargetGLVersion.Minor, 6);
     EXPECT_EQ(rendererInfo.TargetGLVersion.Patch, 0);
 
     EXPECT_NE(std::find(extensions.begin(), extensions.end(), MobileGL::E_GL_ARB_compute_shader),
@@ -396,13 +397,13 @@ TEST(DirectVulkanSanity, RenderPassExtentUsesSwapchainSizeOnlyForDefaultFramebuf
               MobileGL::IntVec2(512, 512));
 }
 
-TEST(DirectVulkanSanity, AdvertisesVoxyRequiredRenderingExtensionsWithoutRaisingGLVersion) {
+TEST(DirectVulkanSanity, AdvertisesVoxyRequiredRenderingExtensionsAtExperimentalCTSVersion) {
     MobileGL::MG_Backend::DirectVulkan::BackendObject_DirectVulkan backend;
     const auto& rendererInfo = backend.GetRendererInfo().RendererGLInfo;
     const auto& extensions = rendererInfo.Extensions;
 
-    EXPECT_EQ(rendererInfo.TargetGLVersion.Major, 3);
-    EXPECT_EQ(rendererInfo.TargetGLVersion.Minor, 3);
+    EXPECT_EQ(rendererInfo.TargetGLVersion.Major, 4);
+    EXPECT_EQ(rendererInfo.TargetGLVersion.Minor, 6);
     EXPECT_EQ(rendererInfo.TargetGLVersion.Patch, 0);
 
     EXPECT_NE(std::find(extensions.begin(), extensions.end(), MobileGL::E_GL_ARB_compute_shader),
@@ -515,6 +516,50 @@ TEST(DirectGLESSanity, PreservesHostPerStageImageUniformLimits) {
     EXPECT_EQ(params.MaxComputeImageUniforms, 5);
 }
 
+TEST(FragmentInterpolationCapabilities, PlumbsGLESAndBothVulkanPropertyPaths) {
+    using namespace MobileGL;
+
+    MG_External::GLESCapabilities glesCaps;
+    glesCaps.MinFragmentInterpolationOffset = -0.75f;
+    glesCaps.MaxFragmentInterpolationOffset = 0.625f;
+    glesCaps.FragmentInterpolationOffsetBits = 6;
+    MG_Backend::DirectGLES::BackendObject_DirectGLES glesBackend;
+    glesBackend.ApplyGLESCapabilitiesForTesting(glesCaps);
+    EXPECT_FLOAT_EQ(glesBackend.GetDynamicParameters().MinFragmentInterpolationOffset, -0.75f);
+    EXPECT_FLOAT_EQ(glesBackend.GetDynamicParameters().MaxFragmentInterpolationOffset, 0.625f);
+    EXPECT_EQ(glesBackend.GetDynamicParameters().FragmentInterpolationOffsetBits, 6);
+
+    VkPhysicalDeviceProperties properties{};
+    // A common Vulkan limit pair: max is one representable 4-bit step below 0.5.
+    properties.limits.minInterpolationOffset = -0.5f;
+    properties.limits.maxInterpolationOffset = 0.4375f;
+    properties.limits.subPixelInterpolationOffsetBits = 4;
+    MG_External::VulkanCapabilities vkCaps;
+    MG_Util::BackendLoader::FillInVulkanCapabilities(vkCaps, properties);
+    EXPECT_FLOAT_EQ(vkCaps.MinFragmentInterpolationOffset, -0.5f);
+    EXPECT_FLOAT_EQ(vkCaps.MaxFragmentInterpolationOffset, 0.4375f);
+    EXPECT_EQ(vkCaps.FragmentInterpolationOffsetBits, 4);
+
+    vkCaps.MinFragmentInterpolationOffset = -0.875f;
+    vkCaps.MaxFragmentInterpolationOffset = 0.75f;
+    vkCaps.FragmentInterpolationOffsetBits = 7;
+    MG_Backend::DirectVulkan::BackendObject_DirectVulkan vkBackend;
+    vkBackend.ApplyVulkanCapabilitiesForTesting(vkCaps);
+    EXPECT_FLOAT_EQ(vkBackend.GetDynamicParameters().MinFragmentInterpolationOffset, -0.875f);
+    EXPECT_FLOAT_EQ(vkBackend.GetDynamicParameters().MaxFragmentInterpolationOffset, 0.75f);
+    EXPECT_EQ(vkBackend.GetDynamicParameters().FragmentInterpolationOffsetBits, 7);
+
+    // Invalid/zero host data cannot under-advertise the OpenGL 4 minimums.
+    MG_External::VulkanCapabilities invalidCaps;
+    invalidCaps.MinFragmentInterpolationOffset = 0.0f;
+    invalidCaps.MaxFragmentInterpolationOffset = 0.0f;
+    invalidCaps.FragmentInterpolationOffsetBits = 0;
+    vkBackend.ApplyVulkanCapabilitiesForTesting(invalidCaps);
+    EXPECT_LE(vkBackend.GetDynamicParameters().MinFragmentInterpolationOffset, -0.5f);
+    EXPECT_FLOAT_EQ(vkBackend.GetDynamicParameters().MaxFragmentInterpolationOffset, 0.4375f);
+    EXPECT_EQ(vkBackend.GetDynamicParameters().FragmentInterpolationOffsetBits, 4);
+}
+
 TEST(DirectVulkanSanity, AdvertisesSubgroupOnlyWhenVulkanReportsUsableSupport) {
     using namespace MobileGL;
 
@@ -637,6 +682,48 @@ TEST(GetterSanity, ClampsMaxVertexAttribsToCurrentValueStorageCapacity) {
     MG_State::pGLContext.reset();
 }
 
+TEST(GetterSanity, ReportsFragmentInterpolationLimitsForFloatAndIntegerQueries) {
+    using namespace MobileGL;
+
+    auto previousContext = Move(MG_State::pGLContext);
+    auto previousBackend = Move(MG_Backend::pActiveBackendObject);
+    MG_State::pGLContext = MakeUnique<MG_State::GLState::GLContext>();
+
+    MG_Backend::DynamicBackendParameters params;
+    params.MinFragmentInterpolationOffset = -0.75f;
+    params.MaxFragmentInterpolationOffset = 0.4375f;
+    params.FragmentInterpolationOffsetBits = 6;
+    MG_Backend::pActiveBackendObject = MakeUnique<DynamicParameterBackend>(params);
+
+    GLfloat floatValue = 0.0f;
+    MG_Impl::GLImpl::GetFloatv(GL_MIN_FRAGMENT_INTERPOLATION_OFFSET, &floatValue);
+    EXPECT_FLOAT_EQ(floatValue, -0.75f);
+    MG_Impl::GLImpl::GetFloatv(GL_MAX_FRAGMENT_INTERPOLATION_OFFSET, &floatValue);
+    EXPECT_FLOAT_EQ(floatValue, 0.4375f);
+    MG_Impl::GLImpl::GetFloatv(GL_FRAGMENT_INTERPOLATION_OFFSET_BITS, &floatValue);
+    EXPECT_FLOAT_EQ(floatValue, 6.0f);
+
+    GLint intValue = 0;
+    MG_Impl::GLImpl::GetIntegerv(GL_MIN_FRAGMENT_INTERPOLATION_OFFSET, &intValue);
+    EXPECT_EQ(intValue, -1);
+    MG_Impl::GLImpl::GetIntegerv(GL_MAX_FRAGMENT_INTERPOLATION_OFFSET, &intValue);
+    EXPECT_EQ(intValue, 0);
+    MG_Impl::GLImpl::GetIntegerv(GL_FRAGMENT_INTERPOLATION_OFFSET_BITS, &intValue);
+    EXPECT_EQ(intValue, 6);
+
+    GLboolean boolValue = GL_FALSE;
+    MG_Impl::GLImpl::GetBooleanv(GL_MIN_FRAGMENT_INTERPOLATION_OFFSET, &boolValue);
+    EXPECT_EQ(boolValue, GL_TRUE);
+    MG_Impl::GLImpl::GetBooleanv(GL_MAX_FRAGMENT_INTERPOLATION_OFFSET, &boolValue);
+    EXPECT_EQ(boolValue, GL_TRUE);
+    MG_Impl::GLImpl::GetBooleanv(GL_FRAGMENT_INTERPOLATION_OFFSET_BITS, &boolValue);
+    EXPECT_EQ(boolValue, GL_TRUE);
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), GL_NO_ERROR);
+
+    MG_Backend::pActiveBackendObject = Move(previousBackend);
+    MG_State::pGLContext = Move(previousContext);
+}
+
 TEST(GetterSanity, PerStageImageUniformQueriesMatchShaderCompilerLimits) {
     using namespace MobileGL;
 
@@ -1736,3 +1823,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/BackendLoaders/OpenGL/Loader.cpp

@@ -9,6 +9,7 @@
 #include "Loader.h"
 #include "MG_Util/Types.h"
 #include <Config.h>
+#include <cmath>
 #if defined(_WIN32)
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN 1
@@ -838,8 +839,14 @@ namespace MobileGL::MG_Util::BackendLoader {
                 if (std::strcmp(extension, "GL_NV_shader_noperspective_interpolation") == 0) {
                     caps.SupportsNoperspectiveInterpolation = true;
                 }
+                if (std::strcmp(extension, "GL_OES_shader_multisample_interpolation") == 0) {
+                    caps.SupportsShaderMultisampleInterpolation = true;
+                }
             }
         }
+        caps.SupportsShaderMultisampleInterpolation =
+            caps.SupportsShaderMultisampleInterpolation || caps.GLESVersion.Major > 3 ||
+            (caps.GLESVersion.Major == 3 && caps.GLESVersion.Minor >= 2);
 
         // Detect optional raster/color-mask entry points by whether they loaded. glColorMaski is GLES
         // 3.2 core (no extension string), so pointer presence is the reliable signal for all of these.
@@ -900,6 +907,9 @@ namespace MobileGL::MG_Util::BackendLoader {
         GLint maxColorAttachments = 8;
         GLint maxClipDistances = 8;
         GLint maxViewports = 16;
+        GLfloat minFragmentInterpolationOffset = -0.5f;
+        GLfloat maxFragmentInterpolationOffset = 0.4375f;
+        GLint fragmentInterpolationOffsetBits = 4;
         glesFuncs.glGetFloatv(GL_ALIASED_LINE_WIDTH_RANGE, aliasedLineWidthRange);
         glesFuncs.glGetFloatv(GL_SMOOTH_LINE_WIDTH_RANGE, smoothLineWidthRange);
         glesFuncs.glGetFloatv(GL_SMOOTH_LINE_WIDTH_GRANULARITY, &smoothLineWidthGranularity);
@@ -919,6 +929,15 @@ namespace MobileGL::MG_Util::BackendLoader {
         glesFuncs.glGetIntegerv(GL_MAX_INTEGER_SAMPLES, &maxIntegerSamples);
         glesFuncs.glGetIntegerv(GL_MAX_SAMPLES, &maxSamples);
         glesFuncs.glGetIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &maxSampleMaskWords);
+        // MobileGL's sample-mask state only stores a single 32-bit word (see
+        // RenderState::SampleMaskValue) and SampleMaski_State() rejects any
+        // maskNumber other than 0. Advertising the real driver's value here (e.g.
+        // NVIDIA's GLES driver reports 2) makes glSampleMaski(1, ...) - which
+        // dEQP's per-case gluStateReset always issues up to GL_MAX_SAMPLE_MASK_WORDS -
+        // raise GL_INVALID_VALUE and aborts the whole glcts process after every
+        // single test case. 1 is a spec-legal value (the minimum required), so cap
+        // to what is actually implemented instead of forwarding the raw driver limit.
+        maxSampleMaskWords = std::min(maxSampleMaskWords, 1);
         glesFuncs.glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureImageUnits);
         glesFuncs.glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &maxVertexTextureImageUnits);
         glesFuncs.glGetIntegerv(GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS, &maxComputeTextureImageUnits);
@@ -950,6 +969,29 @@ namespace MobileGL::MG_Util::BackendLoader {
         glesFuncs.glGetIntegerv(GL_MAX_VIEWPORTS, &maxViewports);
         glesFuncs.glGetIntegerv(GL_MAX_VIEWPORT_DIMS, maxViewportDims);
         glesFuncs.glGetIntegerv(GL_VIEWPORT_SUBPIXEL_BITS, &viewportSubpixelBits);
+        if (caps.SupportsShaderMultisampleInterpolation && glesFuncs.glGetFloatv) {
+            const auto drainErrors = [&glesFuncs]() {
+                Bool hadError = false;
+                if (glesFuncs.glGetError) {
+                    while (glesFuncs.glGetError() != GL_NO_ERROR) hadError = true;
+                }
+                return hadError;
+            };
+
+            // Isolate these optional queries from errors raised by preceding capability
+            // probes, then consume any query error so initialization never leaks it into
+            // the application's first glGetError call.
+            drainErrors();
+            glesFuncs.glGetFloatv(GL_MIN_FRAGMENT_INTERPOLATION_OFFSET, &minFragmentInterpolationOffset);
+            glesFuncs.glGetFloatv(GL_MAX_FRAGMENT_INTERPOLATION_OFFSET, &maxFragmentInterpolationOffset);
+            glesFuncs.glGetIntegerv(GL_FRAGMENT_INTERPOLATION_OFFSET_BITS, &fragmentInterpolationOffsetBits);
+            if (drainErrors()) {
+                MGLOG_W("Fragment interpolation limit query failed; using OpenGL minimums");
+                minFragmentInterpolationOffset = -0.5f;
+                maxFragmentInterpolationOffset = 0.4375f;
+                fragmentInterpolationOffsetBits = 4;
+            }
+        }
         // Only legal to query once the extension has been seen in the loop above, hence not batched
         // with the unconditional probes: on a driver without it this raises GL_INVALID_ENUM.
         if (caps.SupportsTextureFilterAnisotropy) {
@@ -1007,6 +1049,19 @@ namespace MobileGL::MG_Util::BackendLoader {
         caps.ViewportBoundsRangeMin = viewportBoundsRange[0];
         caps.ViewportBoundsRangeMax = viewportBoundsRange[1];
         caps.ViewportSubpixelBits = viewportSubpixelBits;
+        caps.MinFragmentInterpolationOffset =
+            std::isfinite(minFragmentInterpolationOffset) && minFragmentInterpolationOffset <= -0.5f
+                ? minFragmentInterpolationOffset
+                : -0.5f;
+        caps.MaxFragmentInterpolationOffset = 0.4375f;
+        caps.FragmentInterpolationOffsetBits = 4;
+        if (fragmentInterpolationOffsetBits >= 4 && std::isfinite(maxFragmentInterpolationOffset)) {
+            const Float requiredMaxOffset = 0.5f - std::ldexp(1.0f, -fragmentInterpolationOffsetBits);
+            if (maxFragmentInterpolationOffset >= requiredMaxOffset) {
+                caps.MaxFragmentInterpolationOffset = maxFragmentInterpolationOffset;
+                caps.FragmentInterpolationOffsetBits = fragmentInterpolationOffsetBits;
+            }
+        }
         MGLOG_I("    GL_ALIASED_LINE_WIDTH_RANGE: [%.3f, %.3f]", caps.AliasedLineWidthRangeMin,
                 caps.AliasedLineWidthRangeMax);
         MGLOG_I("    GL_SMOOTH_LINE_WIDTH_RANGE: [%.3f, %.3f]", caps.SmoothLineWidthRangeMin,

MobileGL/MG_Util/BackendLoaders/OpenGL/Loader.h

@@ -1055,6 +1055,9 @@ namespace MobileGL {
             // SPIRV-Cross's `#extension ... : require` would fail to compile and MobileGL falls back
             // to stripping the NoPerspective decoration (smooth interpolation) via StripNoPerspectivePass.
             Bool SupportsNoperspectiveInterpolation = false;
+            // GLES 3.2 core or GL_OES_shader_multisample_interpolation exposes
+            // interpolateAtOffset and the three fragment-offset limit queries.
+            Bool SupportsShaderMultisampleInterpolation = false;
             // GL_RENDERER contains "ANGLE".
             Bool IsAngleRenderer = false;
             // GL_RENDERER contains both "ANGLE" and "llvmpipe".
@@ -1120,6 +1123,9 @@ namespace MobileGL {
             Float ViewportBoundsRangeMin = 0.0f;
             Float ViewportBoundsRangeMax = 0.0f;
             Int ViewportSubpixelBits = 0;
+            Float MinFragmentInterpolationOffset = -0.5f;
+            Float MaxFragmentInterpolationOffset = 0.4375f;
+            Int FragmentInterpolationOffsetBits = 4;
         };
     } // namespace MG_External
 

MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.cpp

@@ -9,6 +9,7 @@
 #include "Loader.h"
 
 #include <Config.h>
+#include <cmath>
 
 namespace MobileGL::MG_Util::BackendLoader {
     namespace {
@@ -40,6 +41,25 @@ namespace MobileGL::MG_Util::BackendLoader {
             return MaxSampleCountFromFlags(commonFlags);
         }
 
+        void FillFragmentInterpolationLimits(MG_External::VulkanCapabilities& caps,
+                                             const VkPhysicalDeviceLimits& limits) {
+            caps.MinFragmentInterpolationOffset =
+                std::isfinite(limits.minInterpolationOffset) && limits.minInterpolationOffset <= -0.5f
+                    ? limits.minInterpolationOffset
+                    : -0.5f;
+
+            caps.MaxFragmentInterpolationOffset = 0.4375f;
+            caps.FragmentInterpolationOffsetBits = 4;
+            const Int bits = static_cast<Int>(limits.subPixelInterpolationOffsetBits);
+            if (bits >= 4 && std::isfinite(limits.maxInterpolationOffset)) {
+                const Float requiredMaxOffset = 0.5f - std::ldexp(1.0f, -bits);
+                if (limits.maxInterpolationOffset >= requiredMaxOffset) {
+                    caps.MaxFragmentInterpolationOffset = limits.maxInterpolationOffset;
+                    caps.FragmentInterpolationOffsetBits = bits;
+                }
+            }
+        }
+
         VulkanDynamicFunctions LoadVulkanDynamicFunctions(VkInstance instance) {
             VulkanDynamicFunctions loaded{};
             if (instance == VK_NULL_HANDLE) {
@@ -171,6 +191,7 @@ namespace MobileGL::MG_Util::BackendLoader {
         caps.ViewportBoundsRangeMin = p.limits.viewportBoundsRange[0];
         caps.ViewportBoundsRangeMax = p.limits.viewportBoundsRange[1];
         caps.ViewportSubpixelBits = static_cast<Int>(p.limits.viewportSubPixelBits);
+        FillFragmentInterpolationLimits(caps, p.limits);
 
         VkPhysicalDeviceFeatures supportedFeatures{};
         vkGetPhysicalDeviceFeatures(physicalDevice, &supportedFeatures);
@@ -261,6 +282,7 @@ namespace MobileGL::MG_Util::BackendLoader {
         caps.ViewportBoundsRangeMin = properties.limits.viewportBoundsRange[0];
         caps.ViewportBoundsRangeMax = properties.limits.viewportBoundsRange[1];
         caps.ViewportSubpixelBits = static_cast<Int>(properties.limits.viewportSubPixelBits);
+        FillFragmentInterpolationLimits(caps, properties.limits);
         caps.SupportsWideLines = false;
         // This helper only receives properties, not VkPhysicalDeviceFeatures. Leave optional
         // stage writes disabled rather than inferring them from descriptor limits alone.

MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.h

@@ -68,6 +68,9 @@ namespace MobileGL {
             Float ViewportBoundsRangeMin = 0.0f;
             Float ViewportBoundsRangeMax = 0.0f;
             Int ViewportSubpixelBits = 0;
+            Float MinFragmentInterpolationOffset = -0.5f;
+            Float MaxFragmentInterpolationOffset = 0.4375f;
+            Int FragmentInterpolationOffsetBits = 4;
             Bool SupportsWideLines = false;
             // Storage-image descriptors are limited per stage by
             // maxPerStageDescriptorStorageImages, but writes/atomics outside compute additionally

MobileGL/MG_Util/Classifiers/TextureEnumClassifier.cpp

@@ -28,6 +28,7 @@ namespace MobileGL {
 
         bool IsStencilFormatInternalFormat(TextureInternalFormat internalformat) {
             switch (internalformat) {
+            case TextureInternalFormat::StencilIndex8:
             case TextureInternalFormat::Depth24Stencil8:
             case TextureInternalFormat::Depth32FStencil8:
             case TextureInternalFormat::DepthStencil:

MobileGL/MG_Util/Converters/GLToMG/TextureEnumConverter.cpp

@@ -251,6 +251,8 @@ namespace MobileGL {
                 return TextureInternalFormat::Depth24Stencil8;
             case GL_DEPTH32F_STENCIL8:
                 return TextureInternalFormat::Depth32FStencil8;
+            case GL_STENCIL_INDEX8:
+                return TextureInternalFormat::StencilIndex8;
             case GL_DEPTH_COMPONENT:
                 return TextureInternalFormat::DepthComponent;
             case GL_DEPTH_STENCIL:

MobileGL/MG_Util/Converters/MGToGL/TextureEnumConverter.cpp

@@ -233,6 +233,8 @@ namespace MobileGL {
                 return GL_DEPTH24_STENCIL8;
             case TextureInternalFormat::Depth32FStencil8:
                 return GL_DEPTH32F_STENCIL8;
+            case TextureInternalFormat::StencilIndex8:
+                return GL_STENCIL_INDEX8;
             case TextureInternalFormat::DepthComponent32:
                 return GL_DEPTH_COMPONENT32;
             case TextureInternalFormat::DepthStencil:

MobileGL/MG_Util/Converters/MGToStr/TextureEnumConverter.cpp

@@ -234,6 +234,8 @@ namespace MobileGL {
                 return "Depth24Stencil8";
             case TextureInternalFormat::Depth32FStencil8:
                 return "Depth32FStencil8";
+            case TextureInternalFormat::StencilIndex8:
+                return "StencilIndex8";
             case TextureInternalFormat::Red:
                 return "Red";
             case TextureInternalFormat::RG:

MobileGL/MG_Util/Converters/MGToVk/RenderStateEnumConverter.cpp

@@ -25,6 +25,19 @@ namespace MobileGL {
             case GL_TRIANGLE_FAN:
                 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
             case GL_LINE_LOOP:
+                // DrawArrays/DrawElements rewrite line loops into closed indexed
+                // strips; entry points without that rewrite (instanced/indirect)
+                // degrade to an open strip, which only misses the closing segment.
+                MGLOG_W("GL_LINE_LOOP without index rewrite; drawing as LINE_STRIP");
+                return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
+            case GL_LINES_ADJACENCY:
+                return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
+            case GL_LINE_STRIP_ADJACENCY:
+                return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
+            case GL_TRIANGLES_ADJACENCY:
+                return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
+            case GL_TRIANGLE_STRIP_ADJACENCY:
+                return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
             default:
                 MGLOG_W("Unrecognized primitive topology");
                 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;

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:
@@ -224,6 +226,8 @@ namespace MobileGL {
                 return VK_FORMAT_D24_UNORM_S8_UINT;
             case TextureInternalFormat::Depth32FStencil8:
                 return VK_FORMAT_D32_SFLOAT_S8_UINT;
+            case TextureInternalFormat::StencilIndex8:
+                return VK_FORMAT_S8_UINT;
             case TextureInternalFormat::DepthComponent32:
                 return VK_FORMAT_D32_SFLOAT;
             case TextureInternalFormat::DepthStencil:

MobileGL/MG_Util/Metrics/TextureMetrics.cpp

@@ -18,6 +18,7 @@ namespace MobileGL {
             case TextureInternalFormat::Red: // UNorm8 shadow layout
             case TextureInternalFormat::R8Snorm:
             case TextureInternalFormat::R8I:
+            case TextureInternalFormat::StencilIndex8:
             case TextureInternalFormat::R8UI:
                 return 1;
 
@@ -43,8 +44,11 @@ namespace MobileGL {
             case TextureInternalFormat::SRGB8:
             case TextureInternalFormat::RGB8I:
             case TextureInternalFormat::RGB8UI:
-            case TextureInternalFormat::DepthComponent24:
                 return 3;
+            // Canonical depth shadow is a full 32-bit unorm word (see PixelStoreProcessor),
+            // converted at upload to the image's own 24/32-bit layout.
+            case TextureInternalFormat::DepthComponent24:
+                return 4;
 
             case TextureInternalFormat::RGBA2:
             case TextureInternalFormat::RGBA4:
@@ -91,6 +95,9 @@ namespace MobileGL {
             case TextureInternalFormat::RG32F:
             case TextureInternalFormat::RG32I:
             case TextureInternalFormat::RG32UI:
+            // Shadow bytes hold the GL_FLOAT_32_UNSIGNED_INT_24_8_REV wire format
+            // (float depth + a word whose low 8 bits are stencil), 8 bytes/texel.
+            case TextureInternalFormat::Depth32FStencil8:
                 return 8;
 
             case TextureInternalFormat::RGB32F:
@@ -101,7 +108,6 @@ namespace MobileGL {
             case TextureInternalFormat::RGBA32F:
             case TextureInternalFormat::RGBA32I:
             case TextureInternalFormat::RGBA32UI:
-            case TextureInternalFormat::Depth32FStencil8:
                 return 16;
 
             case TextureInternalFormat::R11FG11FB10F:
@@ -253,8 +259,10 @@ namespace MobileGL {
             case TexturePixelDataType::UnsignedInt101111Rev:
             case TexturePixelDataType::UnsignedInt5999Rev:
             case TexturePixelDataType::UnsignedInt248:
-            case TexturePixelDataType::Float32UnsignedInt248Rev:
                 return 4;
+            case TexturePixelDataType::Float32UnsignedInt248Rev:
+                // A 32-bit float depth word followed by a 32-bit word holding stencil.
+                return 8;
             default:
                 return 0;
             }
@@ -501,9 +509,16 @@ namespace MobileGL {
                 s.Depth = 32;
                 s.Stencil = 8;
                 break;
+            case TextureInternalFormat::StencilIndex8:
+                s.Stencil = 8;
+                break;
+            case TextureInternalFormat::Unknown:
+                // Queried for attachments that have no storage yet (e.g. framebuffer
+                // parameter queries on the initial state); every size stays 0.
+                break;
             default:
-                MOBILEGL_ASSERT(false, "Unimplemented internal format in GetComponentSizesForInternalFormat: %d",
-                                static_cast<Int>(internal));
+                MGLOG_W("Unimplemented internal format in GetComponentSizesForInternalFormat: %d",
+                        static_cast<Int>(internal));
                 break;
             }
 

MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp

@@ -220,11 +220,14 @@ namespace MobileGL {
                 auto result = ParseShaderSource(lang, shaderType, source, attrib.flags);
                 if (result) return result;
 
-                // Legacy desktop sources are normalized to "#version 330 core", which parses under
-                // stricter rules than the 460 they used to be forced to: a shader declaring 330 while
-                // using e.g. layout(binding=...) without the matching #extension line compiles on real
-                // drivers but is rejected here. Retry once at 460 before reporting failure; a genuinely
-                // broken shader fails both attempts and keeps its original diagnostics.
+                // Legacy desktop sources are normalized to "#version 330 core" (with a marker on the
+                // directive), which parses under stricter rules than the 460 they used to be forced
+                // to: a shader declaring 110-150 while using e.g. layout(binding=...) without the
+                // matching #extension line compiles on real drivers but is rejected here. Retry once
+                // at 460 before reporting failure; a genuinely broken shader fails both attempts and
+                // keeps its original diagnostics. Application-declared 330+ sources carry no marker
+                // and keep their declared version's strict rules (the GL CTS negative-compile cases
+                // depend on that).
                 String retrySource = source;
                 if (!MG_Util::ShaderTranspiler::RetargetLegacyVersionDirectiveTo460(retrySource)) {
                     return result;

MobileGL/MG_Util/ShaderTranspiler/ShaderSourceProcessor.cpp

@@ -688,6 +688,10 @@ namespace {
         return info;
     }
 
+    // Stamped onto the normalized directive when a legacy (or absent) desktop
+    // version was rewritten to 330; consumed by RetargetLegacyVersionDirectiveTo460.
+    constexpr const char* kNormalizedLegacyMarker = "/*mobilegl-normalized-legacy*/";
+
     MobileGL::String GetNormalizedVersionDirective(const ShaderLanguageInfo& info) {
         if (info.profile == MobileGL::ShaderProfile::ES) {
             // Preserve the pre-existing behavior for standard lowercase "es" directives. MobileGL's Vulkan
@@ -702,9 +706,23 @@ namespace {
             return "#version 460 compatibility\n";
         }
 
+        // An explicitly declared modern core version keeps its number: the GL CTS
+        // negative-compile cases (reserved names, layout-qualifier forms, missing
+        // overloads) rely on the declared version's rules, and raising it would
+        // silently legalize them. gpu_shader5 opt-ins keep the 460 escalation -
+        // Vulkan glslang's ARB_gpu_shader5 support is not complete enough alone.
+        if (info.hasValidVersionDirective && info.version >= 330 && !info.enablesGpuShader5) {
+            return "#version " + std::to_string(info.version) + " core\n";
+        }
+
         const bool useLegacyDesktopVersion =
             info.version < 400 && !info.enablesGpuShader5;
-        return useLegacyDesktopVersion ? "#version 330 core\n" : "#version 460 core\n";
+        // The trailing marker records that this 330 came from a legacy declaration
+        // (or none at all), so the compile-failure retry may re-raise it to 460.
+        // An application's own "#version 330" never carries it and keeps strict
+        // 3.30 semantics.
+        return useLegacyDesktopVersion ? MobileGL::String("#version 330 core ") + kNormalizedLegacyMarker + "\n"
+                                       : "#version 460 core\n";
     }
 
     void NormalizeVersionDirective(MobileGL::String& source, const ShaderLanguageInfo& info) {
@@ -1306,12 +1324,123 @@ namespace MobileGL {
                 // Only the set NormalizeVersionDirective downgraded: desktop core below 400. ES and
                 // compatibility shaders keep whatever they declared.
                 if (info.profile != ShaderProfile::Core || info.version >= 400) return false;
+                // Only rescue MobileGL's own legacy normalization (marked on the directive line).
+                // An application-declared "#version 330" keeps strict 3.30 semantics: raising it
+                // would re-legalize the CTS negative-compile cases (reserved names, arrays of
+                // arrays, missing overloads).
+                SizeT lineEnd = source.find('\n', info.versionDirectiveStart);
+                if (lineEnd == MobileGL::String::npos) {
+                    lineEnd = source.size();
+                }
+                const SizeT markerPos = source.find(kNormalizedLegacyMarker, info.versionDirectiveStart);
+                if (markerPos == MobileGL::String::npos || markerPos > lineEnd) {
+                    return false;
+                }
 
                 source.replace(info.versionDirectiveStart, info.versionDirectiveEnd - info.versionDirectiveStart,
                                "#version 460 core\n");
                 return true;
             }
 
+            std::optional<String> FindReservedIdentifierViolation(const String& source) {
+                // Reserved anywhere; glslang accepts them as plain identifiers.
+                static constexpr const char* kAlwaysReserved[] = {
+                    "image1DShadow",
+                    "image2DShadow",
+                    "image1DArrayShadow",
+                    "image2DArrayShadow",
+                };
+                // Keywords legal only inside a layout(...) qualifier list.
+                static constexpr const char* kLayoutOnlyKeywords[] = {
+                    "packed",
+                    "row_major",
+                };
+
+                const auto isIdentChar = [](char c) {
+                    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
+                };
+
+                const SizeT length = source.size();
+                SizeT i = 0;
+                Int layoutParenDepth = 0;   // >0 while inside layout(...)
+                Bool pendingLayoutParen = false; // saw "layout", awaiting its '('
+                while (i < length) {
+                    const char c = source[i];
+                    // Comments.
+                    if (c == '/' && i + 1 < length && source[i + 1] == '/') {
+                        while (i < length && source[i] != '\n') ++i;
+                        continue;
+                    }
+                    if (c == '/' && i + 1 < length && source[i + 1] == '*') {
+                        i += 2;
+                        while (i + 1 < length && !(source[i] == '*' && source[i + 1] == '/')) ++i;
+                        i = (i + 1 < length) ? i + 2 : length;
+                        continue;
+                    }
+                    // Preprocessor lines stay out of scope (macro names may shadow anything).
+                    if (c == '#' && (i == 0 || source[i - 1] == '\n' ||
+                                     source.find_last_not_of(" \t", i - 1) == MobileGL::String::npos ||
+                                     source[source.find_last_not_of(" \t", i - 1)] == '\n')) {
+                        while (i < length && source[i] != '\n') {
+                            if (source[i] == '\\' && i + 1 < length && source[i + 1] == '\n') ++i;
+                            ++i;
+                        }
+                        continue;
+                    }
+                    if (c == '(') {
+                        if (pendingLayoutParen) {
+                            layoutParenDepth = 1;
+                            pendingLayoutParen = false;
+                        } else if (layoutParenDepth > 0) {
+                            ++layoutParenDepth;
+                        }
+                        ++i;
+                        continue;
+                    }
+                    if (c == ')') {
+                        if (layoutParenDepth > 0) --layoutParenDepth;
+                        ++i;
+                        continue;
+                    }
+                    if (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
+                        ++i;
+                        continue;
+                    }
+                    if (isIdentChar(c) && !(c >= '0' && c <= '9')) {
+                        const SizeT start = i;
+                        while (i < length && isIdentChar(source[i])) ++i;
+                        const StringView word(source.data() + start, i - start);
+                        if (word == "layout") {
+                            pendingLayoutParen = true;
+                            continue;
+                        }
+                        pendingLayoutParen = false;
+                        for (const char* reserved : kAlwaysReserved) {
+                            if (word == reserved) {
+                                return String("ERROR: reserved identifier '") + reserved + "' may not be used.";
+                            }
+                        }
+                        if (layoutParenDepth == 0) {
+                            for (const char* keyword : kLayoutOnlyKeywords) {
+                                if (word == keyword) {
+                                    return String("ERROR: '") + keyword +
+                                        "' is a keyword and may not be used as an identifier.";
+                                }
+                            }
+                        }
+                        continue;
+                    }
+                    if (isIdentChar(c)) { // digit-led token: skip the whole number/identifier tail
+                        while (i < length && isIdentChar(source[i])) ++i;
+                        pendingLayoutParen = false;
+                        continue;
+                    }
+                    pendingLayoutParen = false;
+                    ++i;
+                }
+                return std::nullopt;
+            }
+
         } // namespace ShaderTranspiler
     } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/ShaderSourceProcessor.h

@@ -40,6 +40,11 @@ namespace MobileGL {
             // uses 420-era syntax without the matching #extension line, which real drivers tend to
             // accept - can be retried instead of failing to compile.
             Bool RetargetLegacyVersionDirectiveTo460(String& source);
+
+            // GLSL reserves a few names glslang happily accepts as identifiers ("packed",
+            // "row_major" outside a layout(...) list, the image*Shadow family). Returns the
+            // compile-error text for the first violation, or nullopt for a clean source.
+            std::optional<String> FindReservedIdentifierViolation(const String& source);
         } // namespace ShaderTranspiler
     } // namespace MG_Util
 } // namespace MobileGL

MobileGL/MG_Util/Texture/PixelStoreProcessor.cpp

@@ -95,6 +95,7 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
             Int32,
             Half,
             Float32,
+            UNorm32, // 32-bit fixed-point depth shadow
         };
 
         struct InternalShadowLayout {
@@ -123,6 +124,21 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
 
         Bool GetInternalShadowLayout(TextureInternalFormat internal, InternalShadowLayout& out) {
             switch (internal) {
+            // Depth shadows follow TextureFormatProcessor::NormalizePixelFormat: 16-bit
+            // unorm for DEPTH_COMPONENT16, 32-bit unorm for the 24/32-bit fixed-point
+            // depths, float for DEPTH_COMPONENT32F.
+            case TextureInternalFormat::DepthComponent16:
+                out = {1, ShadowComponent::UNorm16, false};
+                return true;
+            case TextureInternalFormat::DepthComponent24:
+            case TextureInternalFormat::DepthComponent32:
+            case TextureInternalFormat::DepthComponent:
+                out = {1, ShadowComponent::UNorm32, false};
+                return true;
+            case TextureInternalFormat::DepthComponent32F:
+                out = {1, ShadowComponent::Float32, false};
+                return true;
+
             case TextureInternalFormat::R8:
             case TextureInternalFormat::Red:     out = {1, ShadowComponent::UNorm8, false}; return true;
             case TextureInternalFormat::RG8:
@@ -299,8 +315,10 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
             case TextureInputFormat::RGBAInteger:  out = {{0, 1, 2, 3}, 4, true};     return true;
             case TextureInputFormat::BGRA:         out = {{2, 1, 0, 3}, 4, false};    return true;
             case TextureInputFormat::BGRAInteger:  out = {{2, 1, 0, 3}, 4, true};     return true;
+            // A depth value converts like a single normalized/float channel.
+            case TextureInputFormat::DepthComponent: out = {{0, -1, -1, -1}, 1, false}; return true;
             default:
-                return false; // depth / stencil / unknown
+                return false; // stencil / packed depth-stencil / unknown
             }
         }
 
@@ -346,8 +364,7 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
                 out = isInteger ? ShadowComponent::Int16 : ShadowComponent::SNorm16;
                 return true;
             case TexturePixelDataType::UnsignedInt:
-                if (!isInteger) return false; // no 32-bit normalized shadow layout
-                out = ShadowComponent::UInt32;
+                out = isInteger ? ShadowComponent::UInt32 : ShadowComponent::UNorm32;
                 return true;
             case TexturePixelDataType::Int:
                 if (!isInteger) return false;
@@ -617,6 +634,12 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
             case ShadowComponent::Float32:
                 Memcpy(dst, &v, sizeof(v));
                 break;
+            case ShadowComponent::UNorm32: {
+                const auto out = static_cast<Uint32>(
+                    std::llround(static_cast<double>(std::clamp(v, 0.0f, 1.0f)) * 4294967295.0));
+                Memcpy(dst, &out, sizeof(out));
+                break;
+            }
             default:
                 break; // integer components never reach the float encoder
             }
@@ -771,6 +794,64 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
         const Int effectiveHeight = (params.ImageHeight > 0) ? params.ImageHeight : height;
         const SizeT inputRowStride = CalculateRowStride(effectiveWidth, pixelSize, params.Alignment);
 
+        // GL_DEPTH_COMPONENT client data may populate a packed depth-stencil internal
+        // format (the stencil half becomes zero); the generic channel converter cannot
+        // express the packed shadow words, so convert here.
+        const Bool packedDepthStencilInternal = targetInternalFormat == TextureInternalFormat::Depth24Stencil8 ||
+            targetInternalFormat == TextureInternalFormat::DepthStencil ||
+            targetInternalFormat == TextureInternalFormat::Depth32FStencil8;
+        if (!isBitmap && packedDepthStencilInternal && textureInputFormat == TextureInputFormat::DepthComponent &&
+            (inputDataType == TexturePixelDataType::Float || inputDataType == TexturePixelDataType::UnsignedInt ||
+             inputDataType == TexturePixelDataType::UnsignedShort)) {
+            const Bool floatShadow = targetInternalFormat == TextureInternalFormat::Depth32FStencil8;
+            const SizeT outPixelSize = floatShadow ? 8 : 4;
+            outSize = static_cast<SizeT>(width) * height * std::max(depth, 1) * outPixelSize;
+            Uint8* outputPixels = static_cast<Uint8*>(malloc(outSize));
+            if (!outputPixels) {
+                outSize = 0;
+                return nullptr;
+            }
+            const Uint8* srcBase = static_cast<const Uint8*>(inputPixels) +
+                static_cast<SizeT>(params.SkipImages) * static_cast<SizeT>(effectiveHeight) * inputRowStride +
+                static_cast<SizeT>(params.SkipRows) * inputRowStride +
+                static_cast<SizeT>(params.SkipPixels) * pixelSize;
+            Uint8* dst = outputPixels;
+            for (Int z = 0; z < std::max(depth, 1); ++z) {
+                for (Int y = 0; y < height; ++y) {
+                    const Uint8* srcRow = srcBase +
+                        static_cast<SizeT>(z) * static_cast<SizeT>(effectiveHeight) * inputRowStride +
+                        static_cast<SizeT>(y) * inputRowStride;
+                    for (Int x = 0; x < width; ++x) {
+                        Float depthValue = 0.0f;
+                        if (inputDataType == TexturePixelDataType::Float) {
+                            Memcpy(&depthValue, srcRow + static_cast<SizeT>(x) * 4, sizeof(depthValue));
+                        } else if (inputDataType == TexturePixelDataType::UnsignedInt) {
+                            Uint32 raw = 0;
+                            Memcpy(&raw, srcRow + static_cast<SizeT>(x) * 4, sizeof(raw));
+                            depthValue = static_cast<Float>(static_cast<double>(raw) / 4294967295.0);
+                        } else {
+                            Uint16 raw = 0;
+                            Memcpy(&raw, srcRow + static_cast<SizeT>(x) * 2, sizeof(raw));
+                            depthValue = static_cast<Float>(raw) / 65535.0f;
+                        }
+                        if (floatShadow) {
+                            const Uint32 stencilWord = 0;
+                            Memcpy(dst, &depthValue, sizeof(depthValue));
+                            Memcpy(dst + 4, &stencilWord, sizeof(stencilWord));
+                            dst += 8;
+                        } else {
+                            const Uint32 depth24 = static_cast<Uint32>(
+                                std::llround(static_cast<double>(std::clamp(depthValue, 0.0f, 1.0f)) * 16777215.0));
+                            const Uint32 word = depth24 << 8;
+                            Memcpy(dst, &word, sizeof(word));
+                            dst += 4;
+                        }
+                    }
+                }
+            }
+            return outputPixels;
+        }
+
         UnpackConversionSpec conversion{};
         const Bool needConversion =
             !isBitmap && GetUnpackConversionSpec(targetInternalFormat, textureInputFormat, inputDataType, conversion);
@@ -972,6 +1053,11 @@ namespace MobileGL::MG_Util::PixelStoreProcessor {
                 Memcpy(&v, p, sizeof(v));
                 return v;
             }
+            case ShadowComponent::UNorm32: {
+                Uint32 v;
+                Memcpy(&v, p, sizeof(v));
+                return static_cast<Float>(static_cast<double>(v) / 4294967295.0);
+            }
             default:
                 return 0.0f;
             }

android-plugin/app/build.gradle.kts

@@ -55,7 +55,7 @@ val releaseSigningReady = signingStoreFile.exists()
 val debuggableRelease = (findProperty("mobilegl.debuggableRelease") ?: "false").toString().toBoolean()
 
 val mobileGlVersionMajor = 26
-val mobileGlVersionMinor = 7
+val mobileGlVersionMinor = 8
 val mobileGlGitShortHash = runGit("rev-parse", "--short=7", "HEAD") ?: "nogit"
 val mobileGlMonthlyRevision = runGit(
     "rev-list",

docs/superpowers/specs/2026-07-15-mobilegl-post-format-capability-tables-design.md

@@ -1,78 +0,0 @@
-# MobileGL POST Format Capability Tables
-
-## Goal
-
-Expose the format-capability results used during MobileGL backend startup in the Android plugin's driver POST screen. The screen must show the exact `Full`, `Caveat`, or `None` result for every backend, target, internal format, and capability without duplicating the backend's detection rules.
-
-## Existing Architecture
-
-- `DriverPost.cpp` probes the device GLES and Vulkan drivers before `MobileGL::Initialize()` and returns a `BackendPostReport` for each backend.
-- `DriverPostJni.cpp` serializes those reports to JSON for `PostActivity`.
-- `PostActivity` uses platform Android views and already supports collapsible check details and a collapsible raw report.
-- Backend startup fills a `FormatCapabilityCache` in the DirectGLES and DirectVulkan `InitCapabilities()` paths. `FullCaps` takes precedence over `CaveatCaps`; an absent bit means `None`.
-- The capability matrix contains 12 targets, 75 internal formats, and 14 capability columns per backend.
-
-## Selected Approach
-
-Extract callable format-probe entry points from the existing DirectGLES and DirectVulkan implementations. Backend startup and the POST will call these same functions, so their results cannot drift.
-
-The POST will run each probe while its temporary driver resources are still valid:
-
-- DirectGLES: after the GLES function table and capabilities have been populated, while the 1x1 pbuffer context is current.
-- DirectVulkan: after selecting the physical device, while the Vulkan instance and physical device handles remain valid.
-
-The resulting optional `FormatCapabilityCache` will be stored in each `BackendPostReport`. Failure to obtain a format table will not discard the existing POST checks or change their verdict; the UI will instead report that the format table is unavailable.
-
-## JSON Contract
-
-The JNI report will add an optional `formatCapabilities` object to each backend. To avoid repeating tens of thousands of status strings, the object will contain:
-
-- one ordered capability-name array;
-- one entry per target;
-- one compact row per internal format containing the format name, a Full bitmask, and a Caveat bitmask.
-
-Java resolves each cell in this order:
-
-1. Full bit present: `Full`.
-2. Otherwise Caveat bit present: `Caveat`.
-3. Otherwise: `None`.
-
-This preserves the backend's current precedence and keeps the raw JSON reasonably small.
-
-## Android UI
-
-Each backend section keeps its existing verdict, renderer string, and check table. A new `Format capabilities` subsection follows it.
-
-- Each of the 11 texture targets and `Renderbuffer` is a separate, initially collapsed table.
-- Target headers can be expanded independently.
-- Table content is created on expansion and removed when collapsed, preventing the activity from retaining roughly 27,000 status views.
-- Each expanded table is placed in a horizontal scroll container.
-- The first column contains internal-format names. The remaining columns use the ordered capability names from the JSON report.
-- Every status cell displays its status text and uses the conventional color mapping:
-  - `Full`: green background with white text.
-  - `Caveat`: yellow background with black text.
-  - `None`: red background with white text.
-- Header and format-name cells use neutral dark backgrounds consistent with the existing POST theme.
-- The existing raw-report toggle remains available at the end of the screen.
-
-## Performance and Lifecycle
-
-- The existing single-flight native POST and cached JSON behavior remains unchanged.
-- Format tables are lazily materialized and discarded on collapse.
-- The JSON carries bitmasks rather than repeated `Full`, `Caveat`, and `None` strings.
-- Existing configuration-change handling remains unchanged.
-
-## Validation
-
-1. Run focused source checks and `git diff --check`.
-2. Build the Android plugin APK with the repository's current Gradle workflow.
-3. If an Android target is connected, install the APK and open `PostActivity`.
-4. Verify both backend sections, all target toggles, horizontal scrolling, visible cell text, and the green/yellow/red mapping.
-5. Confirm collapsing a table removes its generated content and expanding it recreates the same values.
-
-## Non-Goals
-
-- Changing the meanings of `Full`, `Caveat`, or `None`.
-- Changing POST verdict rules.
-- Displaying sample-count vectors in this iteration.
-- Replacing the existing platform-view UI with Compose, AppCompat, or WebView.

tools/cts/README.md

@@ -0,0 +1,112 @@
+# Running the OpenGL CTS against MobileGL
+
+This directory contains two supported paths:
+
+- Android arm64 / MobileGL EGL: the KHR-GL33 workflow documented below and in
+  `skills/gl-cts-on-mobilegl/SKILL.md`.
+- Windows x64 / MobileGL WGL: the GL30-GL46 pipeline in
+  `scripts/wgl_glcts_pipeline.py`, documented by
+  `skills/wgl-gl-cts-on-mobilegl/SKILL.md`.
+
+Windows prerequisites are Git, Python 3.9+, CMake, Visual Studio 2022's Desktop
+C++ workload, and a Vulkan SDK visible to CMake. DirectVulkan also needs a
+working Vulkan loader plus a GPU-vendor ICD and driver; the SDK alone is not a
+GPU driver.
+
+For Windows, start with:
+
+```powershell
+python tools\cts\scripts\wgl_glcts_pipeline.py --help
+```
+
+The pipeline builds MobileGL as a drop-in `opengl32.dll`, builds or reuses
+`glcts.exe`, checks that WGL loaded MobileGL rather than the system driver,
+resumes individual suites after crashes/timeouts, and writes Markdown plus JSON
+reports below the printed `runs/<first-16-of-run-fingerprint>` directory. Its
+manifest records provenance and the runner settings used to validate a resume.
+
+## Android KHR-GL33 workflow
+
+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,499 @@
+/*-------------------------------------------------------------------------
+ * dEQP platform port for MobileGL (Android and desktop Linux)
+ *
+ * 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.
+ *  - On Android, 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.
+ *  - On desktop Linux, only pbuffer surfaces are offered. DirectVulkan's
+ *    pbuffer path works there because desktop Vulkan loaders expose
+ *    VK_EXT_headless_surface.
+ *
+ * Environment:
+ *   MOBILEGL_CTS_LIB      path/soname of the MobileGL library (default libMobileGL.so)
+ *   MOBILEGL_CTS_SURFACE  "window" (Android default) or "pbuffer" (desktop default/only)
+ *   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"
+
+#if defined(__ANDROID__)
+#include <android/hardware_buffer.h>
+#include <android/native_window.h>
+#include <media/NdkImageReader.h>
+#endif
+
+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");
+}
+
+#if defined(__ANDROID__)
+//! Window surfaces default on: they are the only kind DirectVulkan can use
+//! on Android (its pbuffer path needs VK_EXT_headless_surface).
+static bool useWindowSurface(void)
+{
+    const char *env = std::getenv("MOBILEGL_CTS_SURFACE");
+    return !(env && string(env) == "pbuffer");
+}
+#else
+//! Desktop: pbuffer only. VK_EXT_headless_surface is available there and no
+//! Activity-free native window abstraction exists.
+static bool useWindowSurface(void)
+{
+    return false;
+}
+#endif
+
+#if defined(__ANDROID__)
+/*--------------------------------------------------------------------*//*!
+ * \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;
+};
+#else
+//! Never instantiated on desktop; keeps EglRenderContext's member deletable.
+class ImageReaderWindow
+{
+};
+#endif
+
+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)
+    {
+#if defined(__ANDROID__)
+        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
+        throw tcu::NotSupportedError("Window surfaces are not supported by the desktop MobileGL platform");
+#endif
+    }
+    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/cts_matrix_report.py

@@ -0,0 +1,545 @@
+#!/usr/bin/env python
+"""Build a GL 3.0--3.3 CTS conformance matrix from dEQP QPA logs.
+
+The report deliberately scores against the unique cases in each supplied
+caselist.  A case that has not produced a result therefore cannot disappear
+from the denominator and make a partial run look conformant.
+
+QPA parsing and crash/hang sidecar handling follow :mod:`qpa_report`:
+
+* a later QPA observation of a case wins;
+* ``crashed.txt`` upgrades a missing/incomplete result to ``Crash``;
+* ``hung.txt`` upgrades a missing/incomplete/crash result to ``DeviceHang``.
+
+Example::
+
+    python cts_matrix_report.py \
+      --gl30-caselist gl30-main.txt --gl30-results runs/gl30 \
+      --gl31-caselist gl31-main.txt --gl31-results runs/gl31 \
+      --gl32-caselist gl32-main.txt --gl32-results runs/gl32 \
+      --gl33-caselist gl33-main.txt --gl33-results runs/gl33 \
+      --json runs/cts-matrix.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from typing import Iterable, Optional, Sequence
+
+try:  # Works both as a directly executed script and as a package import.
+    from . import qpa_report
+except ImportError:  # pragma: no cover - exercised by the command-line tests
+    import qpa_report
+
+
+VERSIONS = ("gl30", "gl31", "gl32", "gl33")
+ACCEPTED_STATUSES = (
+    "Pass",
+    "NotSupported",
+    "QualityWarning",
+    "CompatibilityWarning",
+    "Waiver",
+)
+ACCEPTED = frozenset(ACCEPTED_STATUSES)
+CHUNK_QPA = re.compile(r"^chunk(\d+)\.qpa$", re.IGNORECASE)
+
+
+class ReportInputError(ValueError):
+    """An input path cannot be used to construct a meaningful report."""
+
+
+def _read_non_comment_lines(path: str) -> list[str]:
+    try:
+        # Match run_cts_windows.py: Khronos lists are UTF-8 and may carry a BOM.
+        with open(path, "r", encoding="utf-8-sig", errors="strict") as fh:
+            return [
+                line.strip()
+                for line in fh
+                if line.strip() and not line.lstrip().startswith("#")
+            ]
+    except (OSError, UnicodeError) as exc:
+        raise ReportInputError(f"cannot read {path}: {exc}") from exc
+
+
+def read_caselist(path: str) -> tuple[list[str], dict[str, int]]:
+    """Return unique cases in file order and repeated caselist entries.
+
+    The mustpass files consumed by glcts and ``run_cts.py`` are one case per
+    non-empty, non-comment line, so this intentionally uses the same syntax.
+    """
+
+    entries = _read_non_comment_lines(path)
+    counts = Counter(entries)
+    unique = list(dict.fromkeys(entries))
+    duplicates = {case: count for case, count in counts.items() if count > 1}
+    return unique, duplicates
+
+
+def _collect_qpa_files(paths: Sequence[str]) -> list[str]:
+    missing = [path for path in paths if not os.path.exists(path)]
+    if missing:
+        raise ReportInputError(
+            "result path(s) do not exist: " + ", ".join(sorted(missing))
+        )
+
+    # qpa_report.collect provides the established directory-recursion rules.
+    # De-duplicate aliases so specifying the same directory twice does not
+    # manufacture duplicate observations.
+    files = qpa_report.collect(paths)
+    by_identity: dict[str, str] = {}
+    for path in files:
+        if not os.path.isfile(path):
+            raise ReportInputError(f"QPA input is not a file: {path}")
+        absolute = os.path.abspath(path)
+        by_identity.setdefault(os.path.normcase(absolute), absolute)
+    def order_key(value: str) -> tuple[str, str, int, str]:
+        absolute = os.path.abspath(value)
+        directory = os.path.normcase(os.path.dirname(absolute))
+        filename = os.path.normcase(os.path.basename(absolute))
+        match = CHUNK_QPA.fullmatch(filename)
+        if match:
+            # run_cts_windows.py uses a minimum width of four digits, not a
+            # fixed width.  Numeric ordering is therefore required once a run
+            # reaches chunk10000; lexical ordering would put it before
+            # chunk9999 and break the later-observation-wins rule.
+            return directory, "chunk", int(match.group(1)), filename
+        # Preserve a deterministic, name-based position for foreign/legacy
+        # QPA files while grouping numeric runner chunks at the lexical
+        # position occupied by the "chunk" basename.
+        return directory, filename, -1, filename
+
+    return sorted(by_identity.values(), key=order_key)
+
+
+def _ratio(numerator: int, denominator: int) -> float:
+    return numerator / denominator if denominator else 0.0
+
+
+def _sidecar(paths: Sequence[str], name: str) -> set[str]:
+    """Load a run_cts.py sidecar with qpa_report-compatible lookup rules."""
+
+    return qpa_report.load_sidecar(paths, name)
+
+
+def build_version_report(
+    version: str, caselist: str, result_paths: Sequence[str]
+) -> dict:
+    """Build the serialisable report for one GL mustpass version."""
+
+    expected_cases, expected_duplicates = read_caselist(caselist)
+    expected = set(expected_cases)
+    qpa_files = _collect_qpa_files(result_paths)
+
+    results: dict[str, str] = {}
+    observation_history: dict[str, list[dict[str, str]]] = defaultdict(list)
+    for qpa_file in qpa_files:
+        for case, status in qpa_report.parse_qpa(qpa_file):
+            observation_history[case].append(
+                {"file": qpa_file, "status": status}
+            )
+            results[case] = status
+
+    crashed = _sidecar(result_paths, "crashed.txt")
+    hung = _sidecar(result_paths, "hung.txt")
+    explicit_unrun = _sidecar(result_paths, "unrun.txt")
+    skipped = _sidecar(result_paths, "skipped.txt")
+
+    # Keep this order and these guards in lock-step with qpa_report.py.
+    for case in crashed:
+        if results.get(case, "Incomplete") == "Incomplete":
+            results[case] = "Crash"
+    for case in hung:
+        if results.get(case, "Incomplete") in ("Incomplete", "Crash"):
+            results[case] = "DeviceHang"
+
+    # A begin/end pair without <Result>, or a QPA truncated mid-case, is not a
+    # completed observation.  Sidecars above may upgrade it to Crash/Hang;
+    # anything still Incomplete must stay in the expected denominator as unrun.
+    incomplete_results = {
+        case for case, status in results.items() if status == "Incomplete"
+    }
+    for case in incomplete_results:
+        del results[case]
+
+    expected_results = {
+        case: status for case, status in results.items() if case in expected
+    }
+    unexpected_results = {
+        case: status for case, status in results.items() if case not in expected
+    }
+
+    # Missing cases are inferred from the caselist even if unrun.txt itself is
+    # missing or stale.  This is the invariant that prevents partial-run rate
+    # inflation.
+    unrun_cases = expected - set(expected_results)
+    declared_not_measured = explicit_unrun | skipped
+    undeclared_unrun = unrun_cases - declared_not_measured
+    stale_unrun = (explicit_unrun | skipped) & set(expected_results)
+
+    counts = Counter(expected_results.values())
+    strict_pass = counts["Pass"]
+    accepted = sum(counts[status] for status in ACCEPTED)
+    result_count = len(expected_results)
+    expected_count = len(expected)
+    crash_count = counts["Crash"]
+    hang_count = counts["DeviceHang"]
+
+    duplicate_cases = {
+        case: {
+            "observations": len(history),
+            "extra_observations": len(history) - 1,
+            "final_status": results.get(case, "Incomplete"),
+            "history": history,
+        }
+        for case, history in sorted(observation_history.items())
+        if len(history) > 1
+    }
+    duplicate_observations = sum(
+        item["extra_observations"] for item in duplicate_cases.values()
+    )
+
+    sidecar_unknown = {
+        name: sorted(cases - expected)
+        for name, cases in (
+            ("crashed.txt", crashed),
+            ("hung.txt", hung),
+            ("unrun.txt", explicit_unrun),
+            ("skipped.txt", skipped),
+        )
+        if cases - expected
+    }
+
+    errors: list[str] = []
+    warnings: list[str] = []
+    if not expected_count:
+        errors.append("caselist has no cases")
+    if expected_duplicates:
+        errors.append(
+            f"caselist has {sum(n - 1 for n in expected_duplicates.values())} "
+            "duplicate entry/entries"
+        )
+    if not qpa_files:
+        errors.append("no .qpa files found")
+    if unexpected_results:
+        errors.append(
+            f"{len(unexpected_results)} result case(s) are absent from the caselist"
+        )
+    if sidecar_unknown:
+        errors.append("one or more sidecars name cases absent from the caselist")
+    if undeclared_unrun:
+        errors.append(
+            f"{len(undeclared_unrun)} missing result case(s) are not declared by "
+            "unrun.txt/skipped.txt"
+        )
+    if stale_unrun:
+        warnings.append(
+            f"{len(stale_unrun)} case(s) declared unrun/skipped also have a result"
+        )
+    if duplicate_observations:
+        warnings.append(
+            f"{duplicate_observations} duplicate QPA observation(s); last result wins"
+        )
+    if incomplete_results:
+        warnings.append(
+            f"{len(incomplete_results)} QPA case(s) ended without a final result and were treated as unrun"
+        )
+
+    if errors:
+        state = "ERROR"
+    elif unrun_cases:
+        state = "INCOMPLETE"
+    else:
+        state = "OK"
+
+    return {
+        "version": version,
+        "inputs": {
+            "caselist": os.path.abspath(caselist),
+            "result_paths": [os.path.abspath(path) for path in result_paths],
+            "qpa_files": qpa_files,
+        },
+        "expected": expected_count,
+        "result": result_count,
+        "pass": strict_pass,
+        "accepted": accepted,
+        "crash": crash_count,
+        "hang": hang_count,
+        "unrun": len(unrun_cases),
+        "duplicate": duplicate_observations,
+        "counts": dict(sorted(counts.items())),
+        "coverage": {
+            "numerator": result_count,
+            "denominator": expected_count,
+            "rate": _ratio(result_count, expected_count),
+        },
+        "rates": {
+            # These are the report's conformance rates.  Expected, not merely
+            # measured results, is the denominator.
+            "denominator": "expected",
+            "strict_pass_only": _ratio(strict_pass, expected_count),
+            "conformance_accepted": _ratio(accepted, expected_count),
+            # Useful for comparison with qpa_report.py, whose denominator is
+            # cases with a result.  Never presented as the conformance rate.
+            "measured_only_strict_pass": _ratio(strict_pass, result_count),
+            "measured_only_conformance_accepted": _ratio(
+                accepted, result_count
+            ),
+        },
+        "strict_pass_rate": _ratio(strict_pass, expected_count),
+        "conformance_accepted_rate": _ratio(accepted, expected_count),
+        "validation": {
+            "state": state,
+            "ok": state == "OK",
+            "errors": errors,
+            "warnings": warnings,
+            "invariant_expected_equals_result_plus_unrun": (
+                expected_count == result_count + len(unrun_cases)
+            ),
+            "undeclared_unrun": sorted(undeclared_unrun),
+            "stale_unrun_or_skipped": sorted(stale_unrun),
+            "sidecar_cases_absent_from_caselist": sidecar_unknown,
+        },
+        "cases": {
+            "results": dict(sorted(expected_results.items())),
+            "unrun": sorted(unrun_cases),
+            "unexpected_results": dict(sorted(unexpected_results.items())),
+            "incomplete_results": sorted(incomplete_results),
+            "duplicate_results": duplicate_cases,
+            "duplicate_caselist_entries": dict(sorted(expected_duplicates.items())),
+        },
+    }
+
+
+def build_matrix(suites: dict[str, tuple[str, Sequence[str]]]) -> dict:
+    """Build all four version reports and their case-weighted aggregate."""
+
+    version_reports = {
+        version: build_version_report(version, *suites[version])
+        for version in VERSIONS
+    }
+
+    totals = {
+        key: sum(report[key] for report in version_reports.values())
+        for key in (
+            "expected",
+            "result",
+            "pass",
+            "accepted",
+            "crash",
+            "hang",
+            "unrun",
+            "duplicate",
+        )
+    }
+    status_counts: Counter[str] = Counter()
+    for report in version_reports.values():
+        status_counts.update(report["counts"])
+
+    states = {report["validation"]["state"] for report in version_reports.values()}
+    if "ERROR" in states:
+        overall_state = "ERROR"
+    elif "INCOMPLETE" in states:
+        overall_state = "INCOMPLETE"
+    else:
+        overall_state = "OK"
+
+    overall = {
+        **totals,
+        "counts": dict(sorted(status_counts.items())),
+        "aggregation": "weighted_by_expected_cases",
+        "coverage": {
+            "numerator": totals["result"],
+            "denominator": totals["expected"],
+            "rate": _ratio(totals["result"], totals["expected"]),
+        },
+        "rates": {
+            "denominator": "expected",
+            "strict_pass_only": _ratio(totals["pass"], totals["expected"]),
+            "conformance_accepted": _ratio(
+                totals["accepted"], totals["expected"]
+            ),
+            "measured_only_strict_pass": _ratio(
+                totals["pass"], totals["result"]
+            ),
+            "measured_only_conformance_accepted": _ratio(
+                totals["accepted"], totals["result"]
+            ),
+        },
+        "strict_pass_rate": _ratio(totals["pass"], totals["expected"]),
+        "conformance_accepted_rate": _ratio(
+            totals["accepted"], totals["expected"]
+        ),
+        "validation": {
+            "state": overall_state,
+            "ok": overall_state == "OK",
+            "invariant_expected_equals_result_plus_unrun": (
+                totals["expected"] == totals["result"] + totals["unrun"]
+            ),
+        },
+    }
+
+    return {
+        "schema_version": 1,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "accepted_statuses": list(ACCEPTED_STATUSES),
+        "rate_policy": {
+            "denominator": "unique expected cases from each caselist",
+            "unrun_cases": "included in the denominator and never accepted",
+            "duplicate_results": "last QPA result wins, matching qpa_report.py",
+        },
+        "versions": version_reports,
+        "overall": overall,
+    }
+
+
+def _percent(numerator: int, denominator: int) -> str:
+    if not denominator:
+        return "n/a"
+    return f"{100.0 * numerator / denominator:.2f}% ({numerator}/{denominator})"
+
+
+def render_markdown(report: dict) -> str:
+    """Render the compact terminal-facing conformance table."""
+
+    header = (
+        "| Suite | Expected | Result | Pass | Accepted | Crash | Hang | Unrun | "
+        "Duplicate | Coverage | Strict Pass-only | Conformance-accepted | Validation |"
+    )
+    separator = (
+        "|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|:---:|"
+    )
+    rows = [header, separator]
+    for version in VERSIONS:
+        item = report["versions"][version]
+        rows.append(
+            "| {version} | {expected} | {result} | {pass_count} | {accepted} | "
+            "{crash} | {hang} | {unrun} | {duplicate} | {coverage} | {strict} | "
+            "{accepted_rate} | {state} |".format(
+                version=version.upper(),
+                expected=item["expected"],
+                result=item["result"],
+                pass_count=item["pass"],
+                accepted=item["accepted"],
+                crash=item["crash"],
+                hang=item["hang"],
+                unrun=item["unrun"],
+                duplicate=item["duplicate"],
+                coverage=_percent(item["result"], item["expected"]),
+                strict=_percent(item["pass"], item["expected"]),
+                accepted_rate=_percent(item["accepted"], item["expected"]),
+                state=item["validation"]["state"],
+            )
+        )
+
+    overall = report["overall"]
+    rows.append(
+        "| **Overall (weighted)** | **{expected}** | **{result}** | **{pass_count}** | "
+        "**{accepted}** | **{crash}** | **{hang}** | **{unrun}** | **{duplicate}** | "
+        "**{coverage}** | **{strict}** | **{accepted_rate}** | **{state}** |".format(
+            expected=overall["expected"],
+            result=overall["result"],
+            pass_count=overall["pass"],
+            accepted=overall["accepted"],
+            crash=overall["crash"],
+            hang=overall["hang"],
+            unrun=overall["unrun"],
+            duplicate=overall["duplicate"],
+            coverage=_percent(overall["result"], overall["expected"]),
+            strict=_percent(overall["pass"], overall["expected"]),
+            accepted_rate=_percent(overall["accepted"], overall["expected"]),
+            state=overall["validation"]["state"],
+        )
+    )
+    rows.extend(
+        (
+            "",
+            "Rates use unique **Expected** caselist cases as the denominator; unrun cases "
+            "remain in that denominator and are not accepted.",
+            "Accepted statuses: " + ", ".join(f"`{s}`" for s in ACCEPTED_STATUSES) + ".",
+            "Duplicate is the number of extra QPA observations; the last observation wins.",
+        )
+    )
+
+    details: list[str] = []
+    for version in VERSIONS:
+        validation = report["versions"][version]["validation"]
+        messages = validation["errors"] + validation["warnings"]
+        if messages:
+            details.append(
+                f"- **{version.upper()} {validation['state']}**: " + "; ".join(messages)
+            )
+    if details:
+        rows.extend(("", "Validation details:", "", *details))
+    return "\n".join(rows)
+
+
+def _write_json(path: str, report: dict) -> None:
+    parent = os.path.dirname(os.path.abspath(path))
+    os.makedirs(parent, exist_ok=True)
+    with open(path, "w", encoding="utf-8", newline="\n") as fh:
+        json.dump(report, fh, indent=2, sort_keys=True)
+        fh.write("\n")
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    for version in VERSIONS:
+        parser.add_argument(
+            f"--{version}-caselist",
+            f"--{version}-case-list",
+            required=True,
+            help=f"{version.upper()} mustpass caselist",
+        )
+        parser.add_argument(
+            f"--{version}-results",
+            f"--{version}-result-dir",
+            f"--{version}-results-dir",
+            action="append",
+            required=True,
+            help=f"{version.upper()} result directory or QPA file (repeatable)",
+        )
+    parser.add_argument(
+        "--json",
+        dest="json_out",
+        default="cts_matrix_report.json",
+        help="JSON output path (default: ./cts_matrix_report.json)",
+    )
+    parser.add_argument(
+        "--allow-incomplete",
+        action="store_true",
+        help="return success even when validation is ERROR/INCOMPLETE",
+    )
+    return parser
+
+
+def main(argv: Optional[Iterable[str]] = None) -> int:
+    args = _parser().parse_args(argv)
+    suites = {
+        version: (
+            getattr(args, f"{version}_caselist"),
+            getattr(args, f"{version}_results"),
+        )
+        for version in VERSIONS
+    }
+    try:
+        report = build_matrix(suites)
+        _write_json(args.json_out, report)
+    except (OSError, ReportInputError) as exc:
+        print(f"cts_matrix_report: {exc}", file=sys.stderr)
+        return 2
+
+    print(render_markdown(report))
+    print(f"\nJSON: {os.path.abspath(args.json_out)}")
+    if not args.allow_incomplete and not report["overall"]["validation"]["ok"]:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tools/cts/scripts/cts_multi_report.py

@@ -0,0 +1,540 @@
+#!/usr/bin/env python
+"""Summarise any number of GL CTS suites and MobileGL backends.
+
+Each repeatable suite specification consists of four values: backend, label,
+caselist, and result directory.  For example::
+
+    python cts_multi_report.py \
+      --suite DirectGLES gl30 gl30-main.txt runs/gles/gl30 \
+      --suite DirectVulkan gl30 gl30-main.txt runs/vulkan/gl30 \
+      --markdown cts-summary.md --json cts-summary.json
+
+A compact comma form is accepted as well::
+
+    --suite=DirectGLES,gl31,gl31-main.txt,runs/gles/gl31
+
+Per-suite parsing and validation deliberately delegate to
+``cts_matrix_report`` so QPA ordering, sidecar upgrades, accepted statuses,
+unrun handling, and duplicate-result semantics cannot drift between reports.
+All conformance rates use unique expected caselist cases as their denominator.
+Backend subtotals and the overall total are therefore case-weighted, not an
+unweighted average of suite percentages.
+"""
+
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+from dataclasses import dataclass
+from datetime import datetime, timezone
+import hashlib
+import json
+import os
+import sys
+from typing import Iterable, Optional, Sequence
+
+try:  # Direct script execution and package imports are both supported.
+    from . import cts_matrix_report
+except ImportError:  # pragma: no cover - covered through CLI-style tests
+    import cts_matrix_report
+
+
+SUPPORTED_BACKENDS = ("DirectGLES", "DirectVulkan")
+SUM_FIELDS = (
+    "expected",
+    "result",
+    "pass",
+    "accepted",
+    "crash",
+    "hang",
+    "unrun",
+    "duplicate",
+)
+
+
+class MultiReportInputError(ValueError):
+    """Suite specifications cannot produce an unambiguous report."""
+
+
+@dataclass(frozen=True)
+class SuiteSpec:
+    backend: str
+    label: str
+    caselist: str
+    result_dir: str
+
+    @property
+    def suite_id(self) -> str:
+        return f"{self.backend}/{self.label}"
+
+
+def _ratio(numerator: int, denominator: int) -> float:
+    return numerator / denominator if denominator else 0.0
+
+
+def _validation_state(items: Sequence[dict]) -> str:
+    states = {item["validation"]["state"] for item in items}
+    if "ERROR" in states:
+        return "ERROR"
+    if "INCOMPLETE" in states:
+        return "INCOMPLETE"
+    return "OK"
+
+
+def aggregate_reports(items: Sequence[dict], suite_state_keys: Sequence[str]) -> dict:
+    """Return an expected-case-weighted aggregate for suite reports."""
+
+    if len(items) != len(suite_state_keys):
+        raise MultiReportInputError("internal suite/state key count mismatch")
+
+    totals = {
+        field: sum(int(item[field]) for item in items)
+        for field in SUM_FIELDS
+    }
+    status_counts: Counter[str] = Counter()
+    for item in items:
+        status_counts.update(item["counts"])
+
+    state = _validation_state(items)
+    expected = totals["expected"]
+    result = totals["result"]
+    suite_states = {
+        key: item["validation"]["state"]
+        for key, item in zip(suite_state_keys, items)
+    }
+    return {
+        **totals,
+        "suite_count": len(items),
+        "counts": dict(sorted(status_counts.items())),
+        "aggregation": "weighted_by_expected_cases",
+        "coverage": {
+            "numerator": result,
+            "denominator": expected,
+            "rate": _ratio(result, expected),
+        },
+        "rates": {
+            "denominator": "expected",
+            "strict_pass_only": _ratio(totals["pass"], expected),
+            "conformance_accepted": _ratio(totals["accepted"], expected),
+            "measured_only_strict_pass": _ratio(totals["pass"], result),
+            "measured_only_conformance_accepted": _ratio(
+                totals["accepted"], result
+            ),
+        },
+        # Keep the convenient aliases used by cts_matrix_report consumers.
+        "strict_pass_rate": _ratio(totals["pass"], expected),
+        "conformance_accepted_rate": _ratio(totals["accepted"], expected),
+        "validation": {
+            "state": state,
+            "ok": state == "OK",
+            "suite_states": suite_states,
+            "invariant_expected_equals_result_plus_unrun": (
+                expected == result + totals["unrun"]
+            ),
+        },
+    }
+
+
+def _caselist_fingerprint(path: str) -> tuple[str, int]:
+    cases, _duplicates = cts_matrix_report.read_caselist(path)
+    payload = "\n".join(cases).encode("utf-8") + b"\n"
+    return hashlib.sha256(payload).hexdigest(), len(cases)
+
+
+def _read_provenance(
+    spec: SuiteSpec,
+    require_run_state: bool,
+    expected_run_identity: Optional[str],
+) -> dict:
+    path = os.path.join(spec.result_dir, "run_state.json")
+    if not os.path.isfile(path):
+        if require_run_state or expected_run_identity is not None:
+            raise MultiReportInputError(
+                "suite result directory has no run_state.json; invocation provenance "
+                f"cannot be verified: {spec.result_dir}"
+            )
+        return {"state": "UNVERIFIED", "run_state": None}
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            state = json.load(handle)
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise MultiReportInputError(f"cannot read suite run identity {path}: {exc}") from exc
+    if not isinstance(state, dict):
+        raise MultiReportInputError(f"suite run identity must be a JSON object: {path}")
+    if state.get("backend") != spec.backend:
+        raise MultiReportInputError(
+            f"suite {spec.suite_id} is labelled {spec.backend}, but run_state.json "
+            f"records {state.get('backend')!r}"
+        )
+    fingerprint, case_count = _caselist_fingerprint(spec.caselist)
+    if state.get("caselist_sha256") != fingerprint or state.get("case_count") != case_count:
+        raise MultiReportInputError(
+            f"suite {spec.suite_id} run_state.json belongs to a different caselist"
+        )
+    invocation_identity = state.get("invocation_identity")
+    if (
+        expected_run_identity is not None
+        and invocation_identity != expected_run_identity
+    ):
+        raise MultiReportInputError(
+            f"suite {spec.suite_id} run_state.json belongs to a different CTS invocation"
+        )
+    return {
+        "state": "VERIFIED",
+        "run_state": os.path.abspath(path),
+        "invocation_identity": invocation_identity,
+    }
+
+
+def _validate_specs(
+    specs: Sequence[SuiteSpec],
+    require_run_state: bool,
+    expected_run_identity: Optional[str],
+) -> dict[str, dict]:
+    if not specs:
+        raise MultiReportInputError("at least one --suite specification is required")
+
+    seen: set[tuple[str, str]] = set()
+    seen_result_dirs: list[tuple[str, str]] = []
+    provenance: dict[str, dict] = {}
+    for spec in specs:
+        if spec.backend not in SUPPORTED_BACKENDS:
+            raise MultiReportInputError(
+                f"unsupported backend {spec.backend!r}; expected one of "
+                + ", ".join(SUPPORTED_BACKENDS)
+            )
+        if not spec.label.strip():
+            raise MultiReportInputError("suite label cannot be empty")
+        identity = (spec.backend, spec.label)
+        if identity in seen:
+            raise MultiReportInputError(
+                f"duplicate suite specification for {spec.backend}/{spec.label}"
+            )
+        seen.add(identity)
+        if not os.path.isdir(spec.result_dir):
+            raise MultiReportInputError(
+                f"suite result directory does not exist: {spec.result_dir}"
+            )
+        physical_result_dir = os.path.normcase(
+            os.path.realpath(os.path.abspath(spec.result_dir))
+        )
+        for previous_dir, previous_suite in seen_result_dirs:
+            try:
+                common_dir = os.path.commonpath(
+                    [previous_dir, physical_result_dir]
+                )
+            except ValueError:
+                continue
+            if common_dir in (previous_dir, physical_result_dir):
+                raise MultiReportInputError(
+                    f"suite {spec.suite_id} uses a result directory which overlaps "
+                    f"{previous_suite}: {spec.result_dir}"
+                )
+        seen_result_dirs.append((physical_result_dir, spec.suite_id))
+        provenance[spec.suite_id] = _read_provenance(
+            spec, require_run_state, expected_run_identity
+        )
+    return provenance
+
+
+def build_report(
+    specs: Sequence[SuiteSpec],
+    require_run_state: bool = True,
+    expected_run_identity: Optional[str] = None,
+) -> dict:
+    """Build suite, per-backend, and overall serialisable reports."""
+
+    provenance = _validate_specs(
+        specs, require_run_state, expected_run_identity
+    )
+    suite_reports: list[dict] = []
+    backend_order: list[str] = []
+
+    for spec in specs:
+        if spec.backend not in backend_order:
+            backend_order.append(spec.backend)
+        item = cts_matrix_report.build_version_report(
+            spec.label, spec.caselist, [spec.result_dir]
+        )
+        # ``version`` is the generic label argument in build_version_report;
+        # expose explicit multi-report terminology while retaining all of its
+        # validation and case-level evidence.
+        item.pop("version", None)
+        item["backend"] = spec.backend
+        item["label"] = spec.label
+        item["suite_id"] = spec.suite_id
+        item["provenance"] = provenance[spec.suite_id]
+        if item["provenance"]["state"] == "UNVERIFIED":
+            item["validation"]["warnings"].append(
+                "result directory has no run_state.json; backend provenance is unverified"
+            )
+        suite_reports.append(item)
+
+    backends: dict[str, dict] = {}
+    for backend in backend_order:
+        backend_items = [
+            item for item in suite_reports if item["backend"] == backend
+        ]
+        labels = [item["label"] for item in backend_items]
+        aggregate = aggregate_reports(backend_items, labels)
+        aggregate["backend"] = backend
+        aggregate["suite_labels"] = labels
+        backends[backend] = aggregate
+
+    overall = aggregate_reports(
+        suite_reports, [item["suite_id"] for item in suite_reports]
+    )
+    overall["backend_count"] = len(backends)
+    overall["backends"] = backend_order
+
+    return {
+        "schema_version": 1,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "accepted_statuses": list(cts_matrix_report.ACCEPTED_STATUSES),
+        "rate_policy": {
+            "denominator": "unique expected cases from each suite caselist",
+            "unrun_cases": "included in the denominator and never accepted",
+            "backend_aggregation": "weighted by expected cases",
+            "overall_aggregation": "weighted by expected cases across backend-suite pairs",
+            "duplicate_results": "last QPA result wins, matching qpa_report.py",
+        },
+        "suites": suite_reports,
+        "backends": backends,
+        "overall": overall,
+    }
+
+
+def _percent(numerator: int, denominator: int) -> str:
+    if not denominator:
+        return "n/a"
+    return f"{100.0 * numerator / denominator:.2f}% ({numerator}/{denominator})"
+
+
+def _markdown_cell(value: object) -> str:
+    return str(value).replace("|", r"\|").replace("\r", " ").replace("\n", " ")
+
+
+def _table_row(backend: str, label: str, item: dict, bold: bool = False) -> str:
+    values = [
+        backend,
+        label,
+        str(item["expected"]),
+        str(item["result"]),
+        str(item["pass"]),
+        str(item["accepted"]),
+        str(item["crash"]),
+        str(item["hang"]),
+        str(item["unrun"]),
+        str(item["duplicate"]),
+        _percent(item["result"], item["expected"]),
+        _percent(item["pass"], item["expected"]),
+        _percent(item["accepted"], item["expected"]),
+        item["validation"]["state"],
+    ]
+    values = [_markdown_cell(value) for value in values]
+    if bold:
+        values = [f"**{value}**" for value in values]
+    return "| " + " | ".join(values) + " |"
+
+
+def render_markdown(report: dict) -> str:
+    lines = [
+        "# GL CTS multi-suite conformance report",
+        "",
+        (
+            "| Backend | Suite | Expected | Result | Pass | Accepted | Crash | Hang | "
+            "Unrun | Duplicate | Coverage | Strict Pass-only | Conformance-accepted | Validation |"
+        ),
+        "|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|:---:|",
+    ]
+
+    for backend in report["backends"]:
+        for item in report["suites"]:
+            if item["backend"] == backend:
+                lines.append(_table_row(backend, item["label"], item))
+        subtotal = report["backends"][backend]
+        lines.append(
+            _table_row(backend, f"{backend} weighted subtotal", subtotal, bold=True)
+        )
+
+    lines.append(
+        _table_row(
+            "All backends",
+            "Overall weighted",
+            report["overall"],
+            bold=True,
+        )
+    )
+    lines.extend(
+        [
+            "",
+            (
+                "Rates use unique **Expected** caselist cases as the denominator. "
+                "Unrun cases remain in the denominator and are not accepted."
+            ),
+            "Accepted statuses: "
+            + ", ".join(
+                f"`{status}`" for status in report["accepted_statuses"]
+            )
+            + ".",
+            (
+                "Duplicate is the number of extra QPA observations; the final "
+                "observation wins."
+            ),
+        ]
+    )
+
+    details: list[str] = []
+    for item in report["suites"]:
+        validation = item["validation"]
+        messages = validation["errors"] + validation["warnings"]
+        if messages:
+            details.append(
+                f"- **{_markdown_cell(item['suite_id'])} {validation['state']}**: "
+                + "; ".join(_markdown_cell(message) for message in messages)
+            )
+    if details:
+        lines.extend(["", "## Validation details", "", *details])
+    return "\n".join(lines) + "\n"
+
+
+def _write_text(path: str, contents: str) -> None:
+    absolute = os.path.abspath(path)
+    os.makedirs(os.path.dirname(absolute), exist_ok=True)
+    with open(absolute, "w", encoding="utf-8", newline="\n") as handle:
+        handle.write(contents)
+
+
+def _write_json(path: str, report: dict) -> None:
+    _write_text(path, json.dumps(report, indent=2, sort_keys=True) + "\n")
+
+
+def _normalise_compact_suite_args(argv: Sequence[str]) -> list[str]:
+    """Expand ``--suite=b,l,c,r`` into the four-value argparse form."""
+
+    result: list[str] = []
+    index = 0
+    while index < len(argv):
+        token = argv[index]
+        if token.startswith("--suite="):
+            compact = token.split("=", 1)[1]
+            parts = compact.split(",", 3)
+            if len(parts) != 4:
+                raise MultiReportInputError(
+                    "compact --suite expects backend,label,caselist,result-dir"
+                )
+            result.extend(["--suite", *parts])
+            index += 1
+            continue
+        if token == "--suite" and index + 1 < len(argv) and argv[index + 1].count(",") >= 3:
+            parts = argv[index + 1].split(",", 3)
+            result.extend(["--suite", *parts])
+            index += 2
+            continue
+        result.append(token)
+        index += 1
+    return result
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--suite",
+        action="append",
+        nargs=4,
+        required=True,
+        metavar=("BACKEND", "LABEL", "CASELIST", "RESULT_DIR"),
+        help=(
+            "suite specification; repeat for every backend/suite pair "
+            f"(backends: {', '.join(SUPPORTED_BACKENDS)})"
+        ),
+    )
+    parser.add_argument(
+        "--markdown",
+        default="cts_multi_report.md",
+        help="Markdown output path (default: ./cts_multi_report.md)",
+    )
+    parser.add_argument(
+        "--json",
+        dest="json_out",
+        default="cts_multi_report.json",
+        help="JSON output path (default: ./cts_multi_report.json)",
+    )
+    parser.add_argument(
+        "--allow-incomplete",
+        action="store_true",
+        help="return success even when one or more suites are ERROR/INCOMPLETE",
+    )
+    parser.add_argument(
+        "--adopt-legacy",
+        dest="allow_unverified_provenance",
+        action="store_true",
+        help="accept legacy result directories without run_state.json (provenance remains unverified)",
+    )
+    parser.add_argument(
+        "--allow-unverified-provenance",
+        dest="allow_unverified_provenance",
+        action="store_true",
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument(
+        "--expected-run-identity",
+        help="require every suite run_state.json to contain this controller fingerprint",
+    )
+    return parser
+
+
+def _specs_from_args(values: Sequence[Sequence[str]]) -> list[SuiteSpec]:
+    return [
+        SuiteSpec(
+            backend=backend.strip(),
+            label=label.strip(),
+            caselist=caselist,
+            result_dir=result_dir,
+        )
+        for backend, label, caselist, result_dir in values
+    ]
+
+
+def main(argv: Optional[Iterable[str]] = None) -> int:
+    raw_argv = list(argv) if argv is not None else sys.argv[1:]
+    try:
+        normalised = _normalise_compact_suite_args(raw_argv)
+    except MultiReportInputError as exc:
+        print(f"cts_multi_report: {exc}", file=sys.stderr)
+        return 2
+    args = _parser().parse_args(normalised)
+
+    if os.path.normcase(os.path.abspath(args.markdown)) == os.path.normcase(
+        os.path.abspath(args.json_out)
+    ):
+        print("cts_multi_report: Markdown and JSON paths must differ", file=sys.stderr)
+        return 2
+
+    try:
+        report = build_report(
+            _specs_from_args(args.suite),
+            require_run_state=not args.allow_unverified_provenance,
+            expected_run_identity=args.expected_run_identity,
+        )
+        markdown = render_markdown(report)
+        _write_text(args.markdown, markdown)
+        _write_json(args.json_out, report)
+    except (
+        OSError,
+        MultiReportInputError,
+        cts_matrix_report.ReportInputError,
+    ) as exc:
+        print(f"cts_multi_report: {exc}", file=sys.stderr)
+        return 2
+
+    print(markdown, end="")
+    print(f"\nMarkdown: {os.path.abspath(args.markdown)}")
+    print(f"JSON: {os.path.abspath(args.json_out)}")
+    if not args.allow_incomplete and not report["overall"]["validation"]["ok"]:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())