[Fix] (DirectGLES): lower gl_ClipDistance for Adreno's ESSL compiler - shadow the builtin in a Private array with constant-index flushes before EmitVertex/return, loop-copy gl_in clip distances through dynamic indices (whole-array reads segfault the Qualcomm compiler, constant-index element reads miscompile), strip the SPIRV-Cross redeclaration Adreno rejects, and split const struct-array LUT initializers so they stay dynamically indexable; quirk-gated to Qualcomm with MOBILEGL_QUIRK_CLIP_DISTANCE override

- SyncCurrentFBO skips the READ-target pass when the same GL FBO is bound as
  both draw and read (the common GL_FRAMEBUFFER case), but the read buffer
  (glReadBuffer) is only applied inside SyncToBackend's READ path — so the skip
  silently dropped every glReadBuffer change, leaving the backend read buffer
  stuck at COLOR_ATTACHMENT0.
- Extract the read-buffer application into BackendFramebufferObject::
  SyncReadBufferToBackend and invoke it from the skip branch (target == Read)
  as well as from SyncToBackend, so reads always target the right attachment.
- Bind the backend FBO as READ inside the helper before glReadBuffer, since the
  skip path only bound it as DRAW.
- Fixes KHR-GL3x.draw_buffers.draw_buffers_1 (reading COLOR_ATTACHMENT1 while
  the FBO stays GL_FRAMEBUFFER-bound returned attachment 0's value); the render
  was already correct, only the readback resolved the wrong attachment.

.github/scripts/fetch-trace-fixture-lfs.sh

@@ -9,7 +9,23 @@ fi
 case_name="$1"
 fixture_dir="${2:-tools/trace_replay/fixtures}"
 python_bin="${PYTHON:-python3}"
-mirror_base="${MOBILEGL_TRACE_FIXTURE_MIRROR_BASE:-https://repo.miawa.cn/mgl/tools/trace_replay/fixtures}"
+# Fixture mirrors, tried in order before falling back to Git LFS. Override the
+# whole list with MOBILEGL_TRACE_FIXTURE_MIRROR_BASES (whitespace separated);
+# MOBILEGL_TRACE_FIXTURE_MIRROR_BASE still works and is tried first.
+default_mirror_bases=(
+  "https://git.hit.moe/swung0x48/MobileGL/media/branch/dev/tools/trace_replay/fixtures"
+  "https://repo.miawa.cn/mgl/tools/trace_replay/fixtures"
+)
+if [ -n "${MOBILEGL_TRACE_FIXTURE_MIRROR_BASES:-}" ]; then
+  read -r -a mirror_bases <<< "${MOBILEGL_TRACE_FIXTURE_MIRROR_BASES}"
+else
+  mirror_bases=("${default_mirror_bases[@]}")
+fi
+if [ -n "${MOBILEGL_TRACE_FIXTURE_MIRROR_BASE:-}" ]; then
+  mirror_bases=("${MOBILEGL_TRACE_FIXTURE_MIRROR_BASE}" "${mirror_bases[@]}")
+fi
+# Optional bearer token for mirrors that require authentication (private Gitea).
+mirror_token="${MOBILEGL_TRACE_FIXTURE_MIRROR_TOKEN:-}"
 download_attempts="${MOBILEGL_TRACE_FIXTURE_DOWNLOAD_ATTEMPTS:-5}"
 retry_delay="${MOBILEGL_TRACE_FIXTURE_RETRY_DELAY:-2}"
 
@@ -30,7 +46,8 @@ fixture_list="$("${python_bin}" tools/trace_replay/trace_cases.py \
   --format fixture-files \
   --case "${case_name}" \
   --fixture-root "${fixture_dir}")"
-mapfile -t files <<< "${fixture_list}"
+# Strip CR so the script also works when python emits CRLF (Git Bash on Windows).
+mapfile -t files < <(printf '%s\n' "${fixture_list}" | tr -d '\r')
 
 include="$(IFS=,; echo "${files[*]}")"
 if [ "${case_name}" = "OpenRA" ]; then
@@ -106,6 +123,7 @@ fetch_file_from_mirror() {
   local attempt
   local partial_size
   local curl_status
+  local curl_auth
 
   metadata="$(get_lfs_metadata "${file}")" || return 1
   read -r expected_oid expected_size <<< "${metadata}"
@@ -136,7 +154,11 @@ fetch_file_from_mirror() {
       echo "Starting mirror download for ${file} (attempt ${attempt}/${download_attempts})"
     fi
 
-    if curl -L --fail --show-error --continue-at - --output "${tmp_file}" "${url}"; then
+    curl_auth=()
+    if [ -n "${mirror_token}" ]; then
+      curl_auth=(--header "Authorization: token ${mirror_token}")
+    fi
+    if curl -L --fail --show-error --continue-at - "${curl_auth[@]}" --output "${tmp_file}" "${url}"; then
       if verify_fixture_file "${tmp_file}" "${file}" "${expected_oid}" "${expected_size}"; then
         mv "${tmp_file}" "${file}"
         return 0
@@ -184,10 +206,19 @@ fetch_from_mirror() {
   for file in "${files[@]}"; do
     local name
     local url
+    local base
+    local fetched=0
     name="$(basename "${file}")"
-    url="${mirror_base%/}/${name}"
-    echo "Fetching trace fixture from mirror: ${url}"
-    if ! fetch_file_from_mirror "${file}" "${url}"; then
+    for base in "${mirror_bases[@]}"; do
+      url="${base%/}/${name}"
+      echo "Fetching trace fixture from mirror: ${url}"
+      if fetch_file_from_mirror "${file}" "${url}"; then
+        fetched=1
+        break
+      fi
+      echo "Mirror did not serve ${name}; trying the next mirror" >&2
+    done
+    if [ "${fetched}" -ne 1 ]; then
       return 1
     fi
   done
@@ -196,7 +227,7 @@ fetch_from_mirror() {
 if fetch_from_mirror; then
   echo "Fetched trace fixture files for ${case_name} from mirror: ${include}"
 else
-  echo "Mirror fetch failed for ${case_name}; falling back to Git LFS: ${include}"
+  echo "All mirrors failed for ${case_name}; falling back to Git LFS: ${include}"
   git lfs install --local
   git lfs pull --include="${include}" --exclude=""
 fi

.github/workflows/test.yml

@@ -455,6 +455,15 @@ jobs:
           if [ '${{ matrix.backend }}' = 'DirectVulkan' ]; then
             export MOBILEGL_MAGMA_R11G11B10F_FALLBACK=1
           fi
+          # The blended depth-write quirk auto-enables only on Qualcomm, which no CI
+          # runner has, so force it on for the OIT case it exists to fix. ForceOn
+          # bypasses only the vendor gate, so this exercises the real strip on
+          # lavapipe. The Android AVD lane deliberately leaves it off, keeping the
+          # unstripped path covered for the same trace.
+          if [ '${{ matrix.backend }}' = 'DirectVulkan' ] \
+             && [ '${{ matrix.case }}' = 'improved-transparency-minecraft-26.3' ]; then
+            export MOBILEGL_MAGMA_DISABLE_BLENDED_DEPTH_WRITE=1
+          fi
           ctest -V --no-tests=error -R '^MobileGLTraceReplay\.${{ matrix.case }}\.${{ matrix.backend }}$'
 
       - name: Upload actual image

CMakeLists.txt

@@ -188,9 +188,15 @@ set(SOURCE_FILES
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EliminateFloatEqualsZeroPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RenameSamplerFunctionParameterPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecomposeWorkgroupVec3Pass.cpp
+    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecoratePositionInvariantPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerDrawParametersPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RebaseInstanceIndexPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripUboMemberRelaxedPrecisionPass.cpp
+    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripNoPerspectivePass.cpp
+    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EmulateNoPerspectivePass.cpp
+    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FoldConstOffsetFor1DFetchPass.cpp
+    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerClipDistanceForEsslPass.cpp
+    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DefeatConstStructArrayLutPass.cpp
 
     MobileGL/MG_Util/BackendLoaders/OpenGL/Loader.cpp
     MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.cpp
@@ -300,6 +306,13 @@ if (ANDROID)
     )
 endif()
 
+if (WIN32)
+    list(APPEND SOURCE_FILES
+        MobileGL/MG_Impl/WGLImpl/WGLImpl.cpp
+        MobileGL/MG_Impl/WGLImpl/Exporting/Definitions.cpp
+    )
+endif()
+
 set(MOBILEGL_LINK_LIBRARIES
         glslang::glslang
         spirv-cross-c
@@ -328,10 +341,18 @@ set(MOBILEGL_INCLUDE_DIR
         ${SPIRV-Headers_SOURCE_DIR}/include
 )
 
-add_library(${CMAKE_PROJECT_NAME} SHARED 
+add_library(${CMAKE_PROJECT_NAME} SHARED
     ${SOURCE_FILES}
 )
 
+if (WIN32)
+    # The wgl* entry points are exported via .def (see the comment in wgl.def);
+    # only the shared library links it.
+    target_sources(${CMAKE_PROJECT_NAME} PRIVATE
+        MobileGL/MG_Impl/WGLImpl/Exporting/wgl.def
+    )
+endif()
+
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
     set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES
         C_VISIBILITY_PRESET default
@@ -374,6 +395,18 @@ if(UNIX AND NOT APPLE AND NOT ANDROID)
     endforeach()
 endif()
 
+if(WIN32)
+    # Drop-in for the classic GL loader path: a copy named opengl32.dll placed
+    # next to a host executable is what LoadLibrary("opengl32.dll") and gdi32's
+    # pixel-format forwarding will resolve.
+    add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                "$<TARGET_FILE:${CMAKE_PROJECT_NAME}>"
+                "$<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>/opengl32.dll"
+        COMMENT "Creating opengl32.dll drop-in copy"
+    )
+endif()
+
 if(NOT ANDROID)
     add_library(${CMAKE_PROJECT_NAME}_s STATIC 
         ${SOURCE_FILES}

MobileGL/Config.h

@@ -20,6 +20,15 @@ namespace MobileGL::MG_Config {
 
     extern BackendType ActiveBackendType;
 
+    // Tri-state override for device-specific quirks: Auto lets the detected device decide,
+    // ForceOn/ForceOff bypass the detection in either direction. ForceOn only bypasses the
+    // device gate - each quirk keeps its structural safety checks.
+    enum class QuirkOverride : Uint8 {
+        Auto = 0,
+        ForceOn,
+        ForceOff,
+    };
+
     // Feature toggles parsed once from environment variables in MG_ConfigLoader::Init()
     // (ConfigLoader.cpp), before the accepted-env map is destroyed. All Bool fields share
     // one truthy rule: the variable is set, non-empty, not "0", and not "false"
@@ -67,6 +76,26 @@ namespace MobileGL::MG_Config {
         // explicitly request a core profile via EGL_CONTEXT_OPENGL_PROFILE_MASK / a >=3.1
         // version request.
         Bool RelaxedSemantics = false;
+        // MOBILEGL_QUIRK_SUBGROUP_PREFIX_SCAN: overrides the shader-source quirk that
+        // rewrites the recognized workgroup prefix-scan template on Qualcomm devices with
+        // subgroups wider than 32 lanes (see ShaderSourceProcessor's quirk registry).
+        QuirkOverride SubgroupPrefixScanQuirk = QuirkOverride::Auto;
+        // MOBILEGL_QUIRK_CLIP_DISTANCE: overrides the DirectGLES quirk that lowers
+        // gl_ClipDistance for Adreno's ESSL compiler (shadow Private arrays with
+        // constant-index builtin flushes, dynamic-index gl_in copy loop, redeclaration
+        // strip, and const struct-array LUT splitting). Auto detects Qualcomm.
+        QuirkOverride ClipDistanceQuirk = QuirkOverride::Auto;
+        // MOBILEGL_MAGMA_DISABLE_BLENDED_DEPTH_WRITE: overrides the DirectVulkan quirk that
+        // strips depth writes from accumulation-blended pipelines (MIN/MAX or additive
+        // ONE+ONE - the multi-pass depth-equality signature) on drivers without
+        // cross-pipeline vertex position invariance. Sorted-transparency "over" blends,
+        // gl_FragDepth writers, and fully color-masked attachments are exempt (see
+        // PipelineFactory::ShouldSuppressDepthWrite). Auto detects Qualcomm.
+        QuirkOverride MagmaDisableBlendedDepthWriteQuirk = QuirkOverride::Auto;
+        // MOBILEGL_DISABLE_ROBUST_BUFFER_ACCESS: leave the Vulkan robustBufferAccess device
+        // feature off. It is enabled by default to match GL's defined out-of-range fetch
+        // behavior; this escape hatch exists to measure or dodge its GPU cost on a device.
+        Bool DisableRobustBufferAccess = false;
     };
     extern FeaturesTable Features;
 } // namespace MobileGL::MG_Config

MobileGL/ConfigLoader.cpp

@@ -86,6 +86,17 @@ namespace MobileGL::MG_ConfigLoader {
         return it != acceptedEnvVariablesMap->end() && IsTruthyValue(it->second);
     }
 
+    // Quirk overrides are tri-state: an unset variable keeps device auto-detection, a truthy
+    // value forces the quirk on, anything else set ("0", "false", "") forces it off.
+    inline MG_Config::QuirkOverride QueryEnvQuirkOverride(const String& key) {
+        auto it = acceptedEnvVariablesMap->find(key);
+        if (it == acceptedEnvVariablesMap->end()) {
+            return MG_Config::QuirkOverride::Auto;
+        }
+        return IsTruthyValue(it->second) ? MG_Config::QuirkOverride::ForceOn
+                                         : MG_Config::QuirkOverride::ForceOff;
+    }
+
     inline Uint32 QueryEnvUint32(const String& key, Uint32 defaultValue, Uint32 minValue, Uint32 maxValue) {
         auto it = acceptedEnvVariablesMap->find(key);
         if (it == acceptedEnvVariablesMap->end()) {
@@ -123,6 +134,11 @@ namespace MobileGL::MG_ConfigLoader {
         features.TraceSkipAutodestroy = QueryEnvFlag("MOBILEGL_TRACE_SKIP_AUTODESTROY");
         features.DisableUboRing = QueryEnvFlag("MOBILEGL_DISABLE_UBO_RING");
         features.RelaxedSemantics = QueryEnvFlag("MOBILEGL_RELAXED_SEMANTICS");
+        features.SubgroupPrefixScanQuirk = QueryEnvQuirkOverride("MOBILEGL_QUIRK_SUBGROUP_PREFIX_SCAN");
+        features.ClipDistanceQuirk = QueryEnvQuirkOverride("MOBILEGL_QUIRK_CLIP_DISTANCE");
+        features.MagmaDisableBlendedDepthWriteQuirk =
+            QueryEnvQuirkOverride("MOBILEGL_MAGMA_DISABLE_BLENDED_DEPTH_WRITE");
+        features.DisableRobustBufferAccess = QueryEnvFlag("MOBILEGL_DISABLE_ROBUST_BUFFER_ACCESS");
     }
 
     inline void InitBackendType() {

MobileGL/Defines.h

@@ -34,6 +34,7 @@
 #define MOBILEGL_EGL_API MOBILEGL_API
 #define MOBILEGL_CGL_API MOBILEGL_API
 #define MOBILEGL_NSOPENGL_API MOBILEGL_API
+#define MOBILEGL_WGL_API MOBILEGL_API
 
 // ====================== MobileGL configurations ======================= //
 #ifndef MOBILEGL_LOG_ACTIVE_LEVEL

MobileGL/GlobalObjects.cpp

@@ -14,7 +14,13 @@ namespace MobileGL {
     } // namespace MG_Config
 
     namespace MG_Backend {
-        UniquePtr<BackendObject> pActiveBackendObject;
+        // Leak-at-exit storage: the UniquePtr itself lives on the heap and is
+        // never destroyed by the runtime, so process exit runs no backend
+        // destructors (static destruction order across TUs is undefined).
+        // Deterministic teardown happens inside the EGL lifecycle instead:
+        // the last eglTerminate calls MobileGL::Destroy(), which .reset()s
+        // these singletons while the process is still healthy.
+        UniquePtr<BackendObject>& pActiveBackendObject = *new UniquePtr<BackendObject>();
         GlobalBackendFunctionsTable gBackendFunctionsTable;
     } // namespace MG_Backend
 } // namespace MobileGL

MobileGL/Init.cpp

@@ -9,14 +9,24 @@
 #include "Init.h"
 #include "Config.h"
 #include <MG_Backend/BackendObjects.h>
+#include <MG_Backend/DirectVulkan/DirectVulkan.h>
 #include <MG_State/GLState/Core.h>
 #include <MG_State/EGLState/Core.h>
 #include <MG_Impl/GLImpl/Texture/ProxyTexture.h>
 #include <MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h>
 
+#include <atomic>
+#include <mutex>
+
 namespace MobileGL {
     namespace {
-        Bool g_isInitialized = false;
+        std::atomic<Bool> g_isInitialized = false;
+        thread_local Bool tl_initializing = false;
+
+        std::mutex& InitMutex() {
+            static std::mutex mutex;
+            return mutex;
+        }
 
         void DestroyImpl(Bool logLifecycle) {
             if (!g_isInitialized) {
@@ -64,40 +74,35 @@ namespace MobileGL {
         MGLOG_I("MobileGL initialized");
     }
 
+    void EnsureInitialized() {
+        if (g_isInitialized.load(std::memory_order_acquire)) {
+            return;
+        }
+        // Re-entrant call while this thread is already inside Initialize()
+        // (e.g. an init step routing back through a public entry point).
+        if (tl_initializing) {
+            return;
+        }
+        const std::lock_guard<std::mutex> lock(InitMutex());
+        if (g_isInitialized.load(std::memory_order_acquire)) {
+            return;
+        }
+        tl_initializing = true;
+        Initialize();
+        tl_initializing = false;
+    }
+
     void Destroy() {
         DestroyImpl(true);
     }
 
-#if defined(__linux__) || defined(__APPLE__)
-    __attribute__((constructor)) static void AutoInit() {
-        Initialize();
-    }
-
-    __attribute__((destructor)) static void AutoDestroy() {
-        if (MG_Config::Features.TraceSkipAutodestroy) {
-            return;
-        }
-#if defined(__APPLE__)
-        // macOS injected dylibs can run destructors after logging/backend static state is already torn down.
-        return;
-#else
-        DestroyImpl(false);
-#endif
-    }
-#endif
-
-#ifdef _WIN32
-    BOOL WINAPI DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
-        switch (ul_reason_for_call) {
-        case DLL_PROCESS_ATTACH:
-            Initialize();
-            break;
-
-        case DLL_PROCESS_DETACH:
-            Destroy();
-            break;
-        }
-        return TRUE;
-    }
-#endif
+    // MobileGL's lifecycle is owned entirely by the host-API layers
+    // (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
+    // without eglTerminate simply leaks them to the OS instead of running
+    // backend destructors during static teardown.
 } // namespace MobileGL

MobileGL/Init.h

@@ -11,6 +11,12 @@
 
 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).
+    void EnsureInitialized();
     void Destroy();
 
     namespace MG_Util::Debug {

MobileGL/MG_Backend/BackendObject.h

@@ -230,6 +230,21 @@ namespace MobileGL {
             void (*SetSwapInterval)(Int interval);
         };
 
+        // Coarse GPU vendor identity for gating device-specific quirks. Detected from the
+        // Vulkan physical-device vendorID or the GLES GL_VENDOR/GL_RENDERER strings; stays
+        // Unknown when detection is inconclusive, in which case auto-gated quirks stay off.
+        enum class GpuVendorKind : Uint8 {
+            Unknown = 0,
+            Qualcomm,
+            Arm,
+            Nvidia,
+            Amd,
+            Intel,
+            ImgTec,
+            // Software rasterizers (llvmpipe/lavapipe, SwiftShader).
+            Software,
+        };
+
         struct DynamicBackendParameters {
             SizeT UniformBufferOffsetAlignment = 256;
             // GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT. 1.0 means the backend cannot filter anisotropically,
@@ -291,13 +306,15 @@ namespace MobileGL {
             Uint32 SubgroupSupportedStages = 0;
             Uint32 SubgroupSupportedFeatures = 0;
             Bool SubgroupQuadOperationsInAllStages = false;
+            GpuVendorKind GpuVendor = GpuVendorKind::Unknown;
         };
 
         enum class WindowBackend {
             Android,
             X11,
             MetalLayer,
-            // TODO: Wayland, Windows, etc.
+            Win32, // Handle is an HWND
+            // TODO: Wayland, etc.
             WindowBackendCount,
             Unknown = -1
         };

MobileGL/MG_Backend/BackendObjects.h

@@ -13,6 +13,6 @@
 #include "DirectVulkan/BackendObject_DirectVulkan.h"
 
 namespace MobileGL::MG_Backend {
-    extern UniquePtr<BackendObject> pActiveBackendObject;
+    extern UniquePtr<BackendObject>& pActiveBackendObject;
     extern GlobalBackendFunctionsTable gBackendFunctionsTable;
 } // namespace MobileGL::MG_Backend

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp

@@ -701,9 +701,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
         if ((handle.Backend != WindowBackend::Android &&
              handle.Backend != WindowBackend::X11 &&
-             handle.Backend != WindowBackend::MetalLayer) ||
+             handle.Backend != WindowBackend::MetalLayer &&
+             handle.Backend != WindowBackend::Win32) ||
             !handle.Handle) {
-            MGLOG_E("DirectGLES backend only supports Android, X11, and CAMetalLayer native windows");
+            MGLOG_E("DirectGLES backend only supports Android, X11, CAMetalLayer, and Win32 native windows");
             return false;
         }
 
@@ -826,7 +827,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                           E_GL_ARB_program_interface_query, E_GL_ARB_framebuffer_object,
                                           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_direct_state_access,
+                                          E_GL_ARB_clear_texture, E_GL_ARB_direct_state_access,
                                           E_GL_ARB_multi_draw_indirect, E_GL_ARB_indirect_parameters,
                                           E_GL_ARB_shader_draw_parameters, E_GL_ARB_gpu_shader5, E_GL_ARB_multi_bind,
                                           E_GL_ARB_shading_language_420pack, E_GL_ARB_vertex_attrib_binding,
@@ -1035,6 +1036,32 @@ namespace MobileGL::MG_Backend::DirectGLES {
         m_dynamicParameters.ViewportSubpixelBits = m_GLESCapabilities.ViewportSubpixelBits;
         m_dynamicParameters.SupportsWideLines =
             m_GLESCapabilities.AliasedLineWidthRangeMax > 1.0f || m_GLESCapabilities.SmoothLineWidthRangeMax > 1.0f;
+
+        const auto containsAny = [](const String& haystack, std::initializer_list<const char*> needles) {
+            return std::any_of(needles.begin(), needles.end(), [&](const char* needle) {
+                return haystack.find(needle) != String::npos;
+            });
+        };
+        const String vendorAndRenderer =
+            m_GLESCapabilities.GLESVendorString + " " + m_GLESCapabilities.GLESRendererString;
+        if (containsAny(vendorAndRenderer, {"llvmpipe", "SwiftShader", "softpipe"})) {
+            // Check software rasterizers first: ANGLE-on-llvmpipe reports both.
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Software;
+        } else if (containsAny(vendorAndRenderer, {"Qualcomm", "Adreno"})) {
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Qualcomm;
+        } else if (containsAny(vendorAndRenderer, {"Mali", "ARM"})) {
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Arm;
+        } else if (containsAny(vendorAndRenderer, {"NVIDIA"})) {
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Nvidia;
+        } else if (containsAny(vendorAndRenderer, {"AMD", "Radeon"})) {
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Amd;
+        } else if (containsAny(vendorAndRenderer, {"Intel"})) {
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Intel;
+        } else if (containsAny(vendorAndRenderer, {"Imagination", "PowerVR"})) {
+            m_dynamicParameters.GpuVendor = GpuVendorKind::ImgTec;
+        } else {
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Unknown;
+        }
     }
 
     const MG_External::GLESFunctionsTable& BackendObject_DirectGLES::GetGLESFunctions() const {

MobileGL/MG_Backend/DirectGLES/Managers.h

@@ -178,6 +178,21 @@ namespace MobileGL::MG_Backend::DirectGLES {
         // glBindBuffer with a redundant-bind cache for GL_ARRAY_BUFFER.
         void BindBufferId(GLenum target, Uint id);
         void InvalidateArrayBufferBindingCache();
+        // Redundant-bind caches for the driver-level GL_PIXEL_PACK/UNPACK_BUFFER
+        // bindings. Every backend readback (glReadPixels / pack-PBO map) and pixel
+        // upload site routes its binding through these so the shadow always matches
+        // the driver; the resting state between operations is 0, which keeps any
+        // path that implicitly assumes "no PBO bound" correct. Scrubbed when a
+        // buffer id is deleted/pooled (GL resets a deleted buffer's bindings to 0,
+        // and a recycled name matching the shadow would false-skip the rebind) and
+        // invalidated on MakeCurrent (context may reset).
+        void BindPixelPackBufferId(Uint id);
+        void BindPixelUnpackBufferId(Uint id);
+        void InvalidatePixelBufferBindingCaches();
+        // A GL buffer id is being deleted by code outside BufferImpl (e.g. the VAO
+        // client-attribute staging buffers): scrub every buffer-binding shadow that
+        // could false-skip when the name is recycled.
+        void NoteBufferIdDeleted(Uint id);
         // Redundant-bind cache for INDEXED buffer bindings (glBindBufferBase/Range on
         // GL_UNIFORM_BUFFER / GL_SHADER_STORAGE_BUFFER): skips the GL call when the
         // (id, range) already at that index matches, like the array-buffer/texture/
@@ -243,6 +258,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
         private:
             Uint m_backendVAOId = 0;
             Array<Uint, MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS> m_clientAttributeBufferIds;
+            // Attribs the frontend has Enabled but that have no source at all (no buffer object
+            // and NULL client pointer). GL keeps such attribs latently enabled, but Adreno's ES
+            // driver treats them as client arrays and memcpys from address 0 at draw time
+            // (SIGSEGV), so they are kept disabled on the backend VAO until they gain a source.
+            Uint32 m_forceDisabledAttribsMask = 0;
             Bool m_isInitialized = false;
             Uint16 m_syncedIndexBufferVersion = 0;
             Array<MG_State::GLState::VertexAttributeVersion, MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS>
@@ -332,6 +352,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
         class BackendTextureObject {
         public:
             BackendTextureObject();
+            // Deletes the GL texture (frontend glDeleteTextures used to leak every
+            // backend id for the context lifetime) and scrubs the binding/scratch-FBO
+            // shadows so a recycled name or heap address cannot false-skip a rebind.
+            ~BackendTextureObject();
+            BackendTextureObject(const BackendTextureObject&) = delete;
+            BackendTextureObject& operator=(const BackendTextureObject&) = delete;
             void SyncMipmapsToBackend(const SharedPtr<MG_State::GLState::ITextureObject>& stateTextureObject);
             void SyncBuiltinSamplerToBackend(const SharedPtr<MG_State::GLState::ITextureObject>& stateTextureObject);
             void SyncTextureParamsToBackend(const SharedPtr<MG_State::GLState::ITextureObject>& stateTextureObject);
@@ -343,6 +369,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
             void RecreateBackendTexture();
 
             Uint m_backendTextureId = 0;
+            // ES context generation the id was created under; a dtor running after
+            // that context died must not delete a foreign (recycled) name.
+            Uint m_contextGeneration = 0;
             Bool m_isInitialized = false;
             Bool m_imageBindableStorageRequired = false;
             Bool m_backendStorageImmutable = false;
@@ -367,6 +396,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
                      MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS>
             g_boundTexturesCache;
         extern Uint g_activeTextureUnit;
+        // Bumped when the backend ES context is destroyed; texture ids stamped with
+        // an older generation belong to a dead context and must not be deleted.
+        extern Uint g_textureContextGeneration;
     } // namespace TextureImpl
 
     namespace FramebufferImpl {
@@ -375,6 +407,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
             BackendFramebufferObject();
             void SyncToBackend(const SharedPtr<MG_State::GLState::FramebufferObject>& stateFBOObject,
                                FramebufferTarget asTarget);
+            // Apply only this FBO's read buffer (glReadBuffer) to the backend. Split out so it can
+            // still run when SyncCurrentFBO skips the READ-target sync because the same GL FBO is
+            // bound as both draw and read (otherwise glReadBuffer changes would be silently dropped).
+            void SyncReadBufferToBackend(const SharedPtr<MG_State::GLState::FramebufferObject>& stateFBOObject);
             void InvalidateSyncedState();
             Uint GetBackendFramebufferId() const { return m_backendFBOId; }
             void Bind(FramebufferTarget target) const;
@@ -414,8 +450,99 @@ namespace MobileGL::MG_Backend::DirectGLES {
         extern Array<Uint16, SizeT(FramebufferTarget::FramebufferTargetCount)> g_fboSyncedObjectVersions;
         extern Array<MG_State::GLState::FramebufferObject*, SizeT(FramebufferTarget::FramebufferTargetCount)>
             g_fboSyncedObjects;
+
+        // Driver-level READ/DRAW framebuffer-binding shadow. Every backend
+        // glBindFramebuffer routes through BindFramebufferId so scoped helpers can
+        // save/restore the current binding without a glGetIntegerv round-trip (that
+        // query forces a driver pipeline sync) and so redundant rebinds no-op.
+        // Starts unknown; the first CurrentFramebufferBinding() query pins it from
+        // the driver once. Invalidated on MakeCurrent (context may reset).
+        // GL_FRAMEBUFFER binds both targets.
+        void BindFramebufferId(GLenum fbTarget, Uint id);
+        Uint CurrentFramebufferBinding(FramebufferTarget target);
+        void InvalidateFramebufferBindingCache();
     } // namespace FramebufferImpl
 
+    // Shared scratch framebuffers for the readback/copy/blit emulation paths, with a
+    // driver-side attachment shadow: repeated uses skip redundant detach/attach GL
+    // calls, and an attachment left by one use (e.g. a depth copy's DEPTH_STENCIL
+    // texture) is detached exactly when a later use of another aspect would
+    // otherwise inherit it (stale cross-aspect attachments made the shared temp FBO
+    // incomplete and silently degraded later readbacks).
+    namespace ScratchFBOImpl {
+        struct ScratchFramebuffer {
+            Uint id = 0;
+            // false => attachment state unknown; scrub every point on next use.
+            // A fresh FBO starts with nothing attached, so creation sets it true.
+            Bool attachmentsKnown = false;
+            Uint colorTex = 0;
+            GLenum colorTarget = 0;
+            GLint colorLevel = 0;
+            GLint colorLayer = -1; // >= 0 => attached via glFramebufferTextureLayer
+            Uint depthTex = 0;
+            GLenum depthTarget = 0;
+            GLint depthLevel = 0;
+            Bool depthHasStencil = false;
+            // Per-FBO read/draw buffer state (0 = unknown, set on first use).
+            GLenum readBuffer = 0;
+            GLenum drawBuffer = 0;
+        };
+        ScratchFramebuffer& TempFramebuffer();     // GetTexImage READ / CopyTex*Image2D depth DRAW
+        ScratchFramebuffer& BlitReadFramebuffer(); // texture-to-texture blit source
+        ScratchFramebuffer& BlitDrawFramebuffer(); // texture-to-texture blit destination
+        // Returns the GL id, generating it if needed (requires a current ES context).
+        Uint EnsureId(ScratchFramebuffer& fb);
+        // The fb must currently be bound at fbTarget (glReadBuffer/glDrawBuffers
+        // target the READ/DRAW binding respectively). Each Ensure* performs the
+        // minimal detach/attach set and keeps the shadow in sync; a failed attach
+        // records the point as detached so the completeness check fails instead of
+        // silently reading a stale attachment.
+        void EnsureColorAttachment2D(ScratchFramebuffer& fb, GLenum fbTarget, Uint tex, GLenum texTarget, GLint level);
+        void EnsureColorAttachmentLayer(ScratchFramebuffer& fb, GLenum fbTarget, Uint tex, GLint level, GLint layer);
+        void EnsureDepthAttachment2D(ScratchFramebuffer& fb, GLenum fbTarget, Uint tex, GLenum texTarget, GLint level,
+                                     Bool withStencil);
+        void EnsureNoColorAttachment(ScratchFramebuffer& fb, GLenum fbTarget);
+        void EnsureNoDepthAttachment(ScratchFramebuffer& fb, GLenum fbTarget);
+        void EnsureReadBuffer(ScratchFramebuffer& fb, GLenum readBuffer);
+        void EnsureDrawBuffer(ScratchFramebuffer& fb, GLenum drawBuffer);
+        // A 1x1 RGBA8-renderbuffer-complete FBO (GenerateMipmap needs a complete
+        // binding while respecifying texture storage). Attachment is set once at
+        // creation and never changes.
+        Uint EnsureCompleteTinyFramebufferId();
+        // A backend texture id is being deleted or respecified: a scratch FBO still
+        // referencing it would hold a dangling attachment (ES only auto-detaches
+        // from the *bound* framebuffer), and a recycled name could false-skip a
+        // re-attach; force a full scrub on next use.
+        void NoteTextureIdDeleted(Uint textureId);
+        // The ES context (and the scratch FBO ids with it) is going away.
+        void OnBackendContextDestroyed();
+    } // namespace ScratchFBOImpl
+
+    // Driver-level GL_PACK_* pixel-store shadow, the readback-side sibling of the
+    // upload path's ScopedDefaultUnpackState (Managers.cpp): the backend PACK state
+    // is written ONLY through ApplyPackState, so scoped helpers can save/restore it
+    // from the shadow instead of glGetIntegerv (which forces a driver pipeline
+    // sync), and redundant glPixelStorei calls no-op. The first Apply/Current call
+    // pins the driver to the shadow by writing all fields once. Invalidated on
+    // MakeCurrent (context may reset). PACK_IMAGE_HEIGHT/SKIP_IMAGES/SWAP_BYTES/
+    // LSB_FIRST have no ES equivalents; readbacks honor them on the CPU from the
+    // frontend context state instead.
+    namespace PixelStoreImpl {
+        struct PackState {
+            GLint Alignment = 4;
+            GLint RowLength = 0;
+            GLint SkipRows = 0;
+            GLint SkipPixels = 0;
+            Bool operator==(const PackState& o) const {
+                return Alignment == o.Alignment && RowLength == o.RowLength && SkipRows == o.SkipRows &&
+                       SkipPixels == o.SkipPixels;
+            }
+        };
+        void ApplyPackState(const PackState& desired);
+        PackState CurrentPackState();
+        void InvalidatePackStateCache();
+    } // namespace PixelStoreImpl
+
     // Image uniforms take their unit from the layout(binding=N) qualifier baked into
     // the transpiled ESSL; unlike samplers they must not (and in ES cannot) be
     // assigned through glUniform1i.

MobileGL/MG_Backend/DirectGLES/Utils.cpp

@@ -342,6 +342,41 @@ namespace MobileGL::MG_Backend::DirectGLES {
             }
             return result;
         }
+
+        String RemoveClipDistanceRedeclaration(const String& glslCode) {
+#ifdef TRACY_ENABLE
+            ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
+#endif
+            // Adreno rejects any redeclaration of gl_ClipDistance/gl_CullDistance ("reserved
+            // built-in name") even with GL_EXT_clip_cull_distance required, but accepts plain
+            // usage of the builtin. Drop the desktop-style redeclaration line SPIRV-Cross
+            // prints; the "#extension GL_EXT_clip_cull_distance : require" line stays.
+            static const std::regex redeclarationRegex(
+                R"(^\s*(?:out|in)\s+(?:(?:high|medium|low)p\s+)?float\s+gl_(?:Clip|Cull)Distance\[[0-9]+\];\s*$)");
+
+            String result;
+            result.reserve(glslCode.size());
+            SizeT lineStart = 0;
+            Bool firstLine = true;
+            while (lineStart <= glslCode.size()) {
+                SizeT lineEnd = glslCode.find('\n', lineStart);
+                const Bool lastLine = lineEnd == String::npos;
+                String line = glslCode.substr(lineStart, lastLine ? String::npos : lineEnd - lineStart);
+
+                if (!std::regex_match(line, redeclarationRegex)) {
+                    if (!firstLine) {
+                        result += '\n';
+                    }
+                    result += line;
+                    firstLine = false;
+                }
+                if (lastLine) {
+                    break;
+                }
+                lineStart = lineEnd + 1;
+            }
+            return result;
+        }
     } // namespace PrgramImpl
 
     namespace Utils {
@@ -764,5 +799,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 {
@@ -97,6 +105,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                         Uint32 unormOutputMask);
         String ForceFlatIntegerVaryings(const String& glslCode, GLenum shaderType);
         String RemoveLayoutBinding(const String& glslCode);
+        String RemoveClipDistanceRedeclaration(const String& glslCode);
     } // namespace PrgramImpl
 
     namespace Utils {

MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.cpp

@@ -140,6 +140,20 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             case TextureInternalFormat::RGB:
             case TextureInternalFormat::RGB8:
                 return TextureInternalFormat::RGBA8;
+            // Legacy low-bit-depth formats with no (or rarely supported) native Vulkan
+            // encoding; a wider normalized fallback keeps at least the required precision.
+            case TextureInternalFormat::R3G3B2:
+            case TextureInternalFormat::RGB4:
+            case TextureInternalFormat::RGB5:
+            case TextureInternalFormat::RGBA2:
+            case TextureInternalFormat::RGBA4:
+            case TextureInternalFormat::RGB5A1:
+                return TextureInternalFormat::RGBA8;
+            case TextureInternalFormat::RGB10:
+                return TextureInternalFormat::RGB10A2;
+            case TextureInternalFormat::RGB12:
+            case TextureInternalFormat::RGBA12:
+                return TextureInternalFormat::RGBA16;
             case TextureInternalFormat::SRGB8:
                 return TextureInternalFormat::SRGB8Alpha8;
             case TextureInternalFormat::RGB8Snorm:
@@ -397,8 +411,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
         if (!handle.Handle || (handle.Backend != WindowBackend::Android &&
                                handle.Backend != WindowBackend::X11 &&
-                               handle.Backend != WindowBackend::MetalLayer)) {
-            MGLOG_E("DirectVulkan backend only supports Android, X11, and CAMetalLayer native windows");
+                               handle.Backend != WindowBackend::MetalLayer &&
+                               handle.Backend != WindowBackend::Win32)) {
+            MGLOG_E("DirectVulkan backend only supports Android, X11, CAMetalLayer, and Win32 native windows");
             return false;
         }
 
@@ -794,5 +809,32 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     m_vulkanCaps.MaxShaderStorageBlockSize,
                     m_dynamicParameters.MaxShaderStorageBlockSize);
         }
+        switch (m_vulkanCaps.VendorId) {
+        case 0x5143u: // VK_VENDOR_ID: Qualcomm
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Qualcomm;
+            break;
+        case 0x13B5u: // ARM
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Arm;
+            break;
+        case 0x10DEu: // NVIDIA
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Nvidia;
+            break;
+        case 0x1002u: // AMD
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Amd;
+            break;
+        case 0x8086u: // Intel
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Intel;
+            break;
+        case 0x1010u: // Imagination
+            m_dynamicParameters.GpuVendor = GpuVendorKind::ImgTec;
+            break;
+        case 0x10005u: // Mesa software (lavapipe)
+        case 0x1AE0u:  // Google (SwiftShader)
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Software;
+            break;
+        default:
+            m_dynamicParameters.GpuVendor = GpuVendorKind::Unknown;
+            break;
+        }
     }
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.cpp

@@ -20,7 +20,8 @@
 #include <spirv_reflect.h>
 
 namespace MobileGL::MG_Backend::DirectVulkan {
-    UniquePtr<VulkanRenderer> pVulkanRenderer = nullptr;
+    // Leak-at-exit storage; see GlobalObjects.cpp.
+    UniquePtr<VulkanRenderer>& pVulkanRenderer = *new UniquePtr<VulkanRenderer>();
 
     namespace {
         // Generation of the live VulkanRenderer instance, mirroring

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.h

@@ -12,7 +12,7 @@
 #include "Renderer/VulkanRenderer.h"
 
 namespace MobileGL::MG_Backend::DirectVulkan {
-    extern UniquePtr<VulkanRenderer> pVulkanRenderer;
+    extern UniquePtr<VulkanRenderer>& pVulkanRenderer;
 
     // Generation of the live VulkanRenderer instance, mirroring DirectGLES's
     // g_syncContextGeneration. BackendObject_DirectVulkan bumps it wherever

MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.cpp

@@ -8,6 +8,7 @@
 
 #include "PipelineFactory.h"
 
+
 namespace MobileGL::MG_Backend::DirectVulkan {
     static const char* PrimitiveTopologyToString(VkPrimitiveTopology topology) {
         switch (topology) {
@@ -108,6 +109,81 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                   "vkCreatePipelineCache");
     }
 
+    // Must be called once, before any pipeline is created: the flag is not part of the
+    // pipeline hash, so flipping it mid-life would serve cached pipelines built under the
+    // old value.
+    void PipelineFactory::SetSuppressBlendedDepthWrite(Bool enabled) {
+        s_suppressBlendedDepthWrite = enabled;
+    }
+
+    Bool PipelineFactory::ShouldSuppressBlendedDepthWriteForDevice(MG_Config::QuirkOverride quirkOverride,
+                                                                   Uint32 vendorId) {
+        static constexpr Uint32 kVendorIdQualcomm = 0x5143;
+        switch (quirkOverride) {
+        case MG_Config::QuirkOverride::ForceOn:
+            return true;
+        case MG_Config::QuirkOverride::ForceOff:
+            return false;
+        case MG_Config::QuirkOverride::Auto:
+        default:
+            return vendorId == kVendorIdQualcomm;
+        }
+    }
+
+    namespace {
+        // MIN/MAX extremum blending: the signature of a depth-bounds accumulation pass
+        // (MC 26.3 OIT writes vec4(-linD, linD, deviceZ, 0) under GL_MAX while writing
+        // depth for its equality chain). MIN/MAX ignore blend factors per the Vulkan spec.
+        //
+        // Deliberately the ONLY shape stripped. A quirk should touch as little unrelated
+        // content as possible, and a trace sweep of every fixture showed the wider
+        // alternatives all cost more than they fix:
+        //   - additive ONE+ONE with a depth write matched zero draws of the 26.3 chain
+        //     (its transmittance/accumulate passes disable depth writes themselves) - the
+        //     only real content it caught was harmless additive glow effects (Create);
+        //   - sorted-transparency "over" blends (SRC_ALPHA-style) are order-dependent,
+        //     drawn once per surface, and rely on their depth writes for occlusion;
+        //   - separate-alpha accumulation over an over-blending color channel has no
+        //     known pairing with a depth-equality chain (color channel only, see tests).
+        // If a future workload pairs another blend shape with an equality chain, widen
+        // this with that evidence in hand rather than pre-emptively.
+        Bool IsAccumulationBlend(const VkPipelineColorBlendAttachmentState& attachment) {
+            return attachment.colorBlendOp == VK_BLEND_OP_MIN ||
+                   attachment.colorBlendOp == VK_BLEND_OP_MAX;
+        }
+    } // namespace
+
+    Bool PipelineFactory::ShouldSuppressDepthWrite(const PipelineCreatePayload& payload) {
+        if (!payload.depthWriteEnable) {
+            return false;
+        }
+        // A shader that assigns gl_FragDepth supplies depth itself rather than taking the
+        // pipeline's interpolated Z, so a driver that varies the vertex position math
+        // between pipelines cannot desynchronize it. (A gl_FragDepth = gl_FragCoord.z
+        // passthrough is the exception that stays exposed; no known content pairs one with
+        // an equality chain, and 26.3's composite is a genuine computed-depth writer.)
+        if (payload.fragmentReplacesDepth) {
+            return false;
+        }
+        for (Uint32 i = 0; i < payload.colorAttachmentCount; ++i) {
+            const VkPipelineColorBlendAttachmentState& attachment = payload.colorBlendAttachments[i];
+            if (attachment.blendEnable != VK_TRUE) {
+                continue;
+            }
+            // All color writes masked: blending is moot (depth-prepass pattern that left
+            // GL_BLEND enabled); stripping the depth write would delete the whole prepass.
+            if (attachment.colorWriteMask == 0) {
+                continue;
+            }
+            // Any attachment qualifies, not just attachment 0: the 26.3 transmittance pass
+            // accumulates into a 2-target MRT and must stay stripped.
+            if (IsAccumulationBlend(attachment)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     PipelineFactory::~PipelineFactory() {
         DestroyAll();
         if (m_pipelineCache != VK_NULL_HANDLE) {
@@ -152,6 +228,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             XXH64_update(m_hashState, &payload.backStencilDepthFailOp, sizeof(payload.backStencilDepthFailOp)));
         XXHASH_VERIFY(
             XXH64_update(m_hashState, &payload.backStencilCompareOp, sizeof(payload.backStencilCompareOp)));
+        XXHASH_VERIFY(
+            XXH64_update(m_hashState, &payload.fragmentReplacesDepth, sizeof(payload.fragmentReplacesDepth)));
         if (payload.colorAttachmentCount > 0) {
             XXHASH_VERIFY(XXH64_update(
                 m_hashState,
@@ -258,6 +336,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         for (Uint32 i = 0; i < payload.colorAttachmentCount; ++i) {
             colorAttachments[i] = payload.colorBlendAttachments[i];
         }
+        // Suppress depth writes on accumulation-blended pipelines when the active driver
+        // cannot keep vertex positions invariant across the pipelines of a multi-pass
+        // depth-equality chain (see SetSuppressBlendedDepthWrite). The decision is narrowed
+        // in ShouldSuppressDepthWrite: sorted-transparency "over" blends (vanilla MC water),
+        // gl_FragDepth writers, and masked-out attachments keep their depth writes.
+        // This bakes the decision into the pipeline, which only works because depth write is
+        // static state here - adding VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE to kDynamicStates
+        // would let the record-time value override it and silently disable the quirk.
+        if (s_suppressBlendedDepthWrite && ShouldSuppressDepthWrite(payload)) {
+            depthStencil.depthWriteEnable = VK_FALSE;
+        }
         VkPipelineColorBlendStateCreateInfo blend{VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO};
         blend.logicOpEnable = payload.logicOpEnable ? VK_TRUE : VK_FALSE;
         blend.logicOp = payload.logicOp;

MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.h

@@ -49,6 +49,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkStencilOp backStencilPassOp = VK_STENCIL_OP_KEEP;
             VkStencilOp backStencilDepthFailOp = VK_STENCIL_OP_KEEP;
             VkCompareOp backStencilCompareOp = VK_COMPARE_OP_ALWAYS;
+            // The fragment module writes gl_FragDepth (SPIR-V DepthReplacing); exempts the
+            // pipeline from the blended depth-write quirk (see ShouldSuppressDepthWrite).
+            Bool fragmentReplacesDepth = false;
             Array<VkPipelineColorBlendAttachmentState, kMaxColorAttachments> colorBlendAttachments{};
             const Vector<VkPipelineShaderStageCreateInfo>* stages = nullptr;
             const VkPipelineVertexInputStateCreateInfo* vertexInputState = nullptr;
@@ -62,6 +65,27 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkPipeline GetOrCreatePipeline(const PipelineCreatePayload& payload);
         void DestroyAll();
 
+        // 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
+        // cross-pipeline position invariance that some mobile compilers do not provide, even
+        // with the SPIR-V Invariant decoration; whole primitives then drop out of the later
+        // passes. Only MIN/MAX extremum blends are stripped - the signature of such a
+        // chain's depth-bounds pass (MC 26.3 OIT), and per a fixture-wide trace sweep the
+        // only depth-writing shape the chain actually uses - so every other blend
+        // (sorted-transparency "over" like vanilla MC water, additive glows, ...) keeps
+        // its depth writes. Set at renderer initialization based on the active driver.
+        static void SetSuppressBlendedDepthWrite(Bool enabled);
+        static Bool IsSuppressBlendedDepthWriteEnabled() { return s_suppressBlendedDepthWrite; }
+        // Device gate for the quirk: ForceOn/ForceOff bypass detection, Auto enables it on
+        // the known-affected vendor (Qualcomm).
+        static Bool ShouldSuppressBlendedDepthWriteForDevice(MG_Config::QuirkOverride quirkOverride,
+                                                             Uint32 vendorId);
+        // Pure per-pipeline strip decision (exempts gl_FragDepth writers, masked-out and
+        // non-accumulation blends); combined with the device flag in CreatePipeline. Static
+        // and payload-only so tests can pin the contract without a VkDevice.
+        static Bool ShouldSuppressDepthWrite(const PipelineCreatePayload& payload);
+
     private:
         VkPipeline CreatePipeline(const PipelineCreatePayload& payload) const;
 
@@ -70,5 +94,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkPipelineCache m_pipelineCache = VK_NULL_HANDLE;
         UnorderedMap<HashType, VkPipeline> m_cache;
         static inline XXH64_state_t* m_hashState = XXH64_createState();
+        static inline Bool s_suppressBlendedDepthWrite = false;
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.cpp

@@ -312,34 +312,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return targetEnv;
         }
 
-        // Cheap raw-word scan for an `OpDecorate <id> BuiltIn InstanceIndex` decoration. Used
-        // only to decide whether to warn when shaderDrawParameters is unavailable; a false
-        // negative merely suppresses a diagnostic.
-        Bool SpirvDeclaresInstanceIndexBuiltin(const Vector<Uint>& spirv) {
-            constexpr Uint32 kSpirvMagicNumber = 0x07230203u;
-            constexpr SizeT kHeaderWordCount = 5;
-            if (spirv.size() <= kHeaderWordCount || spirv[0] != kSpirvMagicNumber) {
-                return false;
-            }
-
-            SizeT wordIndex = kHeaderWordCount;
-            while (wordIndex < spirv.size()) {
-                const Uint32 firstWord = spirv[wordIndex];
-                const Uint32 wordCount = firstWord >> 16;
-                const auto opcode = static_cast<spv::Op>(firstWord & 0xffffu);
-                if (wordCount == 0 || wordIndex + wordCount > spirv.size()) {
-                    break;
-                }
-                if (opcode == spv::Op::OpDecorate && wordCount >= 4 &&
-                    static_cast<spv::Decoration>(spirv[wordIndex + 2]) == spv::Decoration::BuiltIn &&
-                    static_cast<spv::BuiltIn>(spirv[wordIndex + 3]) == spv::BuiltIn::InstanceIndex) {
-                    return true;
-                }
-                wordIndex += wordCount;
-            }
-            return false;
-        }
-
         Bool IsInterfaceVariableStaticallyUsed(const Vector<Uint>& spirv, Uint32 spirvId) {
             if (spirv.empty() || spirvId == 0) {
                 return false;
@@ -1122,9 +1094,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;
@@ -1218,6 +1198,41 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
     } // namespace
 
+    // A shader that assigns gl_FragDepth (SPIR-V DepthReplacing) supplies depth itself
+    // instead of taking the pipeline's interpolated Z, so a driver that varies the vertex
+    // position math between pipelines cannot desynchronize it; the blended depth-write
+    // quirk therefore leaves it alone (see PipelineFactory::ShouldSuppressDepthWrite).
+    Bool ProgramFactory::ReflectedFragmentReplacesDepth(const SpvReflectShaderModule& reflectModule) {
+        for (Uint32 entryIndex = 0; entryIndex < reflectModule.entry_point_count; ++entryIndex) {
+            const SpvReflectEntryPoint& entryPoint = reflectModule.entry_points[entryIndex];
+            for (Uint32 modeIndex = 0; modeIndex < entryPoint.execution_mode_count; ++modeIndex) {
+                if (entryPoint.execution_modes[modeIndex] == SpvExecutionModeDepthReplacing) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    // glslang's relaxed-Vulkan mode maps GL's gl_InstanceID onto the InstanceIndex builtin.
+    // Without shaderDrawParameters there is no gl_BaseInstance to subtract, so such a shader
+    // cannot be corrected and instanced draws with a non-zero baseInstance misrender; this
+    // detects the case so the user gets one warning instead of silent corruption.
+    Bool ProgramFactory::ReflectedReadsInstanceIndexBuiltin(const SpvReflectShaderModule& reflectModule) {
+        for (Uint32 entryIndex = 0; entryIndex < reflectModule.entry_point_count; ++entryIndex) {
+            const SpvReflectEntryPoint& entryPoint = reflectModule.entry_points[entryIndex];
+            for (Uint32 variableIndex = 0; variableIndex < entryPoint.input_variable_count; ++variableIndex) {
+                const SpvReflectInterfaceVariable* variable = entryPoint.input_variables[variableIndex];
+                if (variable != nullptr &&
+                    (variable->decoration_flags & SPV_REFLECT_DECORATION_BUILT_IN) != 0 &&
+                    variable->built_in == SpvBuiltInInstanceIndex) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     VkShaderStageFlagBits ProgramFactory::ToVkStage(ShaderStage stage) {
         switch (stage) {
         case ShaderStage::Vertex:
@@ -1465,6 +1480,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 continue;
             }
 
+            if (!m_shaderDrawParametersEnabled && ReflectedReadsInstanceIndexBuiltin(reflectModule)) {
+                static Bool s_warnedInstanceIndexUnsupported = false;
+                if (!s_warnedInstanceIndexUnsupported) {
+                    s_warnedInstanceIndexUnsupported = true;
+                    MGLOG_W("ProgramFactory: shaderDrawParameters is unavailable; gl_InstanceID cannot be "
+                            "rebased and instanced draws with a non-zero baseInstance may render incorrectly");
+                }
+            }
+
             uint32_t inputCount = 0;
             SpvReflectResult reflectResult = spvReflectEnumerateInputVariables(&reflectModule, &inputCount, nullptr);
             MOBILEGL_ASSERT(reflectResult == SPV_REFLECT_RESULT_SUCCESS,
@@ -1512,6 +1536,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                 VkProgramObject& entry) const {
         entry.activeFragmentOutputLocationMask = 0;
         entry.fragmentOutputTypes.fill(0);
+        entry.fragmentReplacesDepth = false;
 
         for (SizeT moduleIndex = 0; moduleIndex < shaders.size() && moduleIndex < spirv.size(); ++moduleIndex) {
             if (!shaders[moduleIndex] || shaders[moduleIndex]->GetShaderStage() != ShaderStage::Fragment) {
@@ -1530,9 +1555,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                             "ProgramFactory::ReflectFragmentOutputs: failed to create reflection module (result=%d)",
                             static_cast<Int>(createResult));
             if (createResult != SPV_REFLECT_RESULT_SUCCESS) {
+                // Fail toward the exemption: stripping a genuine gl_FragDepth writer would
+                // corrupt its depth output outright, while wrongly exempting an accumulation
+                // pass merely reverts that one program to the pre-quirk behavior.
+                entry.fragmentReplacesDepth = true;
                 continue;
             }
 
+            entry.fragmentReplacesDepth = ReflectedFragmentReplacesDepth(reflectModule);
+
             uint32_t outputCount = 0;
             SpvReflectResult reflectResult = spvReflectEnumerateOutputVariables(&reflectModule, &outputCount, nullptr);
             MOBILEGL_ASSERT(reflectResult == SPV_REFLECT_RESULT_SUCCESS,
@@ -1590,6 +1621,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) {
@@ -1605,6 +1638,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) {
@@ -1630,9 +1684,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;
                 }
@@ -1642,14 +1756,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.
@@ -1796,7 +1905,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) {
@@ -1808,6 +1917,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 layoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
             } else if (kind == DescriptorBindingKind::StorageImage) {
                 layoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+                entry.hasStorageImages = true;
             } else {
                 layoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
             }
@@ -1862,28 +1972,43 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 moduleSpirvs[i] = spv;
             }
 
+            // 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
+            // per-pipeline compilers cannot vary the position math between passes.
+            {
+                Vector<Uint> invariantSpirv;
+                if (MG_Util::ShaderTranspiler::ShaderCompiler::DecoratePositionInvariantForVulkan(
+                        moduleSpirvs[i], invariantSpirv)) {
+                    moduleSpirvs[i] = std::move(invariantSpirv);
+                } else {
+                    // The pass round-trips through SPIRV-Tools IR, so an unparseable module
+                    // fails open and keeps the undecorated words - which silently reinstates
+                    // the multi-pass invariance bug rather than breaking anything loudly.
+                    MGLOG_E("ProgramFactory: position-invariant decoration failed for program %u; "
+                            "keeping the original module - multi-pass depth-equality chains "
+                            "(e.g. MC 26.3 OIT clouds) may drop primitives on this device",
+                            program.GetExternalIndex());
+                }
+            }
+
             // glslang's relaxed-Vulkan mode aliases GL's zero-based gl_InstanceID to Vulkan's
             // gl_InstanceIndex, which wrongly includes the draw's baseInstance. Rebase vertex-stage
             // loads to (InstanceIndex - BaseInstance) so shaders observe GL semantics. Reflection
             // below runs on the rebased words so the added BaseInstance builtin stays consistent.
-            if (shaders[i] && shaders[i]->GetShaderStage() == ShaderStage::Vertex) {
-                if (m_shaderDrawParametersEnabled) {
-                    Vector<Uint> rebasedSpirv;
-                    if (MG_Util::ShaderTranspiler::ShaderCompiler::RebaseInstanceIndexForVulkan(moduleSpirvs[i],
-                                                                                               rebasedSpirv)) {
-                        moduleSpirvs[i] = std::move(rebasedSpirv);
-                    } else {
-                        MGLOG_E("ProgramFactory: failed to rebase gl_InstanceID for program %u; "
-                                "instanced draws with a non-zero baseInstance may render incorrectly",
-                                program.GetExternalIndex());
-                    }
-                } else if (SpirvDeclaresInstanceIndexBuiltin(moduleSpirvs[i])) {
-                    static Bool s_warnedInstanceIndexUnsupported = false;
-                    if (!s_warnedInstanceIndexUnsupported) {
-                        s_warnedInstanceIndexUnsupported = true;
-                        MGLOG_W("ProgramFactory: shaderDrawParameters is unavailable; gl_InstanceID cannot be "
-                                "rebased and instanced draws with a non-zero baseInstance may render incorrectly");
-                    }
+            // The unsupported-device counterpart of this rebase (warning when a shader reads
+            // the builtin but shaderDrawParameters is missing) rides along with
+            // ReflectVertexInputs, which already reflects this stage.
+            if (shaders[i] && shaders[i]->GetShaderStage() == ShaderStage::Vertex &&
+                m_shaderDrawParametersEnabled) {
+                Vector<Uint> rebasedSpirv;
+                if (MG_Util::ShaderTranspiler::ShaderCompiler::RebaseInstanceIndexForVulkan(moduleSpirvs[i],
+                                                                                            rebasedSpirv)) {
+                    moduleSpirvs[i] = std::move(rebasedSpirv);
+                } else {
+                    MGLOG_E("ProgramFactory: failed to rebase gl_InstanceID for program %u; "
+                            "instanced draws with a non-zero baseInstance may render incorrectly",
+                            program.GetExternalIndex());
                 }
             }
 

MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.h

@@ -59,6 +59,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;
@@ -67,6 +73,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Vector<Bool> storageImageUsesBindingFormatByBinding;
             Vector<String> storageBlockNameByBinding;
             Vector<Int> storageBlockIndexByBinding;
+            // Set once during ReflectLayout so the per-draw path can skip the whole
+            // storage-image preparation for the overwhelming majority of programs.
+            Bool hasStorageImages = false;
             Int globalUboBinding = -1;
             Uint32 activeVertexInputLocationMask = 0;
             Array<GLenum, kMaxVertexInputLocations> vertexInputTypes{};
@@ -75,6 +84,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             ShaderStage rasterizationProducerStage = ShaderStage::Unknown;
             Uint32 producerOutputComponentCount = 0;
             Uint32 fragmentInputComponentCount = 0;
+            // The fragment module declares the DepthReplacing execution mode (writes
+            // gl_FragDepth); shader-computed depth is immune to the cross-pipeline
+            // position-invariance quirk (see PipelineFactory::ShouldSuppressDepthWrite).
+            Bool fragmentReplacesDepth = false;
 
             static inline VkDevice s_device = VK_NULL_HANDLE;
 
@@ -90,6 +103,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);
@@ -99,6 +114,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     std::move(other.storageImageUsesBindingFormatByBinding);
                 storageBlockNameByBinding = std::move(other.storageBlockNameByBinding);
                 storageBlockIndexByBinding = std::move(other.storageBlockIndexByBinding);
+                hasStorageImages = other.hasStorageImages;
                 globalUboBinding = other.globalUboBinding;
                 activeVertexInputLocationMask = other.activeVertexInputLocationMask;
                 vertexInputTypes = other.vertexInputTypes;
@@ -107,15 +123,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 rasterizationProducerStage = other.rasterizationProducerStage;
                 producerOutputComponentCount = other.producerOutputComponentCount;
                 fragmentInputComponentCount = other.fragmentInputComponentCount;
+                fragmentReplacesDepth = other.fragmentReplacesDepth;
                 other.hash = 0;
                 other.descriptorSetLayout = VK_NULL_HANDLE;
                 other.pipelineLayout = VK_NULL_HANDLE;
+                other.hasStorageImages = false;
                 other.globalUboBinding = -1;
                 other.activeVertexInputLocationMask = 0;
                 other.activeFragmentOutputLocationMask = 0;
                 other.rasterizationProducerStage = ShaderStage::Unknown;
                 other.producerOutputComponentCount = 0;
                 other.fragmentInputComponentCount = 0;
+                other.fragmentReplacesDepth = false;
             }
             VkProgramObject& operator=(VkProgramObject&& other) noexcept {
                 if (this == &other) {
@@ -130,6 +149,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);
@@ -139,6 +160,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     std::move(other.storageImageUsesBindingFormatByBinding);
                 storageBlockNameByBinding = std::move(other.storageBlockNameByBinding);
                 storageBlockIndexByBinding = std::move(other.storageBlockIndexByBinding);
+                hasStorageImages = other.hasStorageImages;
                 globalUboBinding = other.globalUboBinding;
                 activeVertexInputLocationMask = other.activeVertexInputLocationMask;
                 vertexInputTypes = other.vertexInputTypes;
@@ -147,15 +169,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 rasterizationProducerStage = other.rasterizationProducerStage;
                 producerOutputComponentCount = other.producerOutputComponentCount;
                 fragmentInputComponentCount = other.fragmentInputComponentCount;
+                fragmentReplacesDepth = other.fragmentReplacesDepth;
                 other.hash = 0;
                 other.descriptorSetLayout = VK_NULL_HANDLE;
                 other.pipelineLayout = VK_NULL_HANDLE;
+                other.hasStorageImages = false;
                 other.globalUboBinding = -1;
                 other.activeVertexInputLocationMask = 0;
                 other.activeFragmentOutputLocationMask = 0;
                 other.rasterizationProducerStage = ShaderStage::Unknown;
                 other.producerOutputComponentCount = 0;
                 other.fragmentInputComponentCount = 0;
+                other.fragmentReplacesDepth = false;
                 return *this;
             }
 
@@ -203,6 +228,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         static VkShaderStageFlagBits ToVkStage(ShaderStage stage);
         static VkFormat ConvertSpirvImageFormatToVkFormat(SpvImageFormat format);
         static SamplerNumericDomain UniformTypeToSamplerNumericDomain(GLenum glType);
+        // True when any entry point declares the DepthReplacing execution mode, i.e. the
+        // shader assigns gl_FragDepth. Exposed so the blended depth-write quirk's exemption
+        // can be pinned by tests. A false negative loses the exemption, so such a shader is
+        // stripped conservatively and forfeits its depth write.
+        static Bool ReflectedFragmentReplacesDepth(const SpvReflectShaderModule& reflectModule);
+        // True when an entry point reads the InstanceIndex builtin. Only gates a diagnostic:
+        // without shaderDrawParameters such a shader cannot have gl_InstanceID rebased.
+        static Bool ReflectedReadsInstanceIndexBuiltin(const SpvReflectShaderModule& reflectModule);
 
     private:
         struct ProgramLookupCache {

MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.cpp

@@ -298,8 +298,23 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // descriptor valid.
         const Bool forceNearestFiltering = numericDomain == SamplerNumericDomain::SignedInteger ||
                                            numericDomain == SamplerNumericDomain::UnsignedInteger;
-        const VkFormat sampledViewFormat =
-            VkTextureManager::ResolveSampledImageViewFormat(resource->format, numericDomain);
+        SamplerResolveMemo* viewFormatMemo =
+            binding < m_samplerResolveMemo.size() ? &m_samplerResolveMemo[binding] : nullptr;
+        VkFormat sampledViewFormat;
+        if (viewFormatMemo != nullptr && viewFormatMemo->viewFormatValid &&
+            viewFormatMemo->viewFormatSource == resource->format &&
+            viewFormatMemo->viewFormatDomain == numericDomain) {
+            sampledViewFormat = viewFormatMemo->viewFormat;
+        } else {
+            sampledViewFormat =
+                VkTextureManager::ResolveSampledImageViewFormat(resource->format, numericDomain);
+            if (viewFormatMemo != nullptr) {
+                viewFormatMemo->viewFormatSource = resource->format;
+                viewFormatMemo->viewFormatDomain = numericDomain;
+                viewFormatMemo->viewFormat = sampledViewFormat;
+                viewFormatMemo->viewFormatValid = true;
+            }
+        }
         if (sampledViewFormat == VK_FORMAT_UNDEFINED) {
             MGLOG_E("ResolveSamplerDescriptor: no compatible sampled view for binding=%u ('%s') "
                     "textureId=%d imageFormat=%d numericDomain=%d",
@@ -307,8 +322,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     static_cast<Int>(resource->format), static_cast<Int>(numericDomain));
             return false;
         }
+        // No reinterpretation requested: bind the depth-or-color aspect view the sync above
+        // already produced instead of re-entering GetOrCreateSampledImageView's sync path.
         const VkImageView sampledImageView =
-            m_textureManager->GetOrCreateSampledImageView(*texture, sampledViewFormat);
+            sampledViewFormat == resource->format
+                ? resource->sampledView
+                : m_textureManager->GetOrCreateSampledImageView(*texture, sampledViewFormat);
         if (sampledImageView == VK_NULL_HANDLE) {
             MGLOG_E("ResolveSamplerDescriptor: failed to resolve sampled view for binding=%u ('%s') "
                     "textureId=%d imageFormat=%d viewFormat=%d numericDomain=%d",
@@ -746,7 +765,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;
 
@@ -772,7 +791,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);
 
@@ -1019,11 +1050,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()));
@@ -1041,40 +1078,51 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             write.descriptorCount = 1;
 
             if (kind == ProgramFactory::DescriptorBindingKind::UniformBufferDynamic) {
-                UboBindResult ubo{};
-                const Bool hasPayload = ResolveUniformBufferPayload(program, programObj, binding, ubo);
-                MOBILEGL_ASSERT(hasPayload && ubo.payload != nullptr && ubo.payloadSize > 0,
-                                "UniformDescriptorBinder::BindProgramUniformBuffers failed: missing UBO payload on binding %u",
-                                binding);
+                const Uint32 descriptorCount =
+                    binding < programObj.bindingDescriptorCounts.size()
+                        ? std::max<Uint32>(1, programObj.bindingDescriptorCounts[binding])
+                        : 1u;
+                const SizeT firstBufferInfoIndex = bufferInfos.size();
+                for (Uint32 element = 0; element < descriptorCount; ++element) {
+                    UboBindResult ubo{};
+                    const Bool hasPayload =
+                        ResolveUniformBufferPayload(program, programObj, binding, element, ubo);
+                    MOBILEGL_ASSERT(hasPayload && ubo.payload != nullptr && ubo.payloadSize > 0,
+                                    "UniformDescriptorBinder::BindProgramUniformBuffers failed: missing UBO payload on binding %u element %u",
+                                    binding, element);
 
-                VkDescriptorBufferInfo bufferInfo{};
-                // Keep offset 0 (sub-range selected via the dynamic offset) so the hashed bufferInfo
-                // is stable across draws and the descriptor-set reuse cache keeps hitting.
-                bufferInfo.offset = 0;
-                Uint32 dynOffset;
-                if (ubo.directBindable) {
-                    // Zero-copy: bind the app's resident VkBuffer directly, no per-draw memcpy.
-                    bufferInfo.buffer = ubo.buffer;
-                    bufferInfo.range = ubo.range;
-                    dynOffset = static_cast<Uint32>(ubo.dynamicOffset);
-                } else {
-                    BufferSlice slice{};
-                    if (!m_bufferManager->UploadTransient(BufferKind::Uniform, frameIndex, ubo.payload,
-                                                          ubo.payloadSize, m_minDynamicOffsetAlignment, slice)) {
-                        MOBILEGL_ASSERT(false, "UniformDescriptorBinder::BindProgramUniformBuffers failed: UBO upload failed on binding %u",
-                                binding);
-                        return false;
+                    VkDescriptorBufferInfo bufferInfo{};
+                    // Keep offset 0 (sub-range selected via the dynamic offset) so the hashed bufferInfo
+                    // is stable across draws and the descriptor-set reuse cache keeps hitting.
+                    bufferInfo.offset = 0;
+                    Uint32 dynOffset;
+                    if (ubo.directBindable) {
+                        // Zero-copy: bind the app's resident VkBuffer directly, no per-draw memcpy.
+                        bufferInfo.buffer = ubo.buffer;
+                        bufferInfo.range = ubo.range;
+                        dynOffset = static_cast<Uint32>(ubo.dynamicOffset);
+                    } else {
+                        BufferSlice slice{};
+                        if (!m_bufferManager->UploadTransient(BufferKind::Uniform, frameIndex, ubo.payload,
+                                                              ubo.payloadSize, m_minDynamicOffsetAlignment, slice)) {
+                            MOBILEGL_ASSERT(false, "UniformDescriptorBinder::BindProgramUniformBuffers failed: UBO upload failed on binding %u element %u",
+                                    binding, element);
+                            return false;
+                        }
+                        bufferInfo.buffer = slice.buffer;
+                        bufferInfo.range = ubo.payloadSize;
+                        dynOffset = static_cast<Uint32>(slice.offset);
                     }
-                    bufferInfo.buffer = slice.buffer;
-                    bufferInfo.range = ubo.payloadSize;
-                    dynOffset = static_cast<Uint32>(slice.offset);
+                    bufferInfos.push_back(bufferInfo);
+                    // Dynamic offsets are consumed in binding order, then array element order,
+                    // matching Vulkan's dynamic-offset consumption rules.
+                    dynamicOffsets.push_back(dynOffset);
                 }
-                bufferInfos.push_back(bufferInfo);
 
                 write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
-                write.pBufferInfo = &bufferInfos.back();
+                write.descriptorCount = descriptorCount;
+                write.pBufferInfo = &bufferInfos[firstBufferInfoIndex];
                 writes.push_back(write);
-                dynamicOffsets.push_back(dynOffset);
             } else if (kind == ProgramFactory::DescriptorBindingKind::UniformTexelBuffer) {
                 VkBufferView bufferView = VK_NULL_HANDLE;
                 if (!ResolveTexelBufferDescriptor(program, programObj, binding, frameIndex, bufferView) ||

MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.h

@@ -116,7 +116,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(
@@ -176,6 +176,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint16 textureParamsVersion = 0;
             Bool forceNearestFiltering = false;
             Bool valid = false;
+            // ResolveSampledImageViewFormat is pure in (image format, numeric domain), but a
+            // domain mismatch walks a ~184-entry format table. Memo the resolution per binding
+            // so a reinterpreted sampler pays that scan once, not once per draw.
+            VkFormat viewFormatSource = VK_FORMAT_UNDEFINED;
+            SamplerNumericDomain viewFormatDomain = SamplerNumericDomain::Unknown;
+            VkFormat viewFormat = VK_FORMAT_UNDEFINED;
+            Bool viewFormatValid = false;
         };
         mutable Vector<SamplerResolveMemo> m_samplerResolveMemo;
     };

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.cpp

@@ -126,8 +126,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             const Bool packedAttribute = attr.Type == DataType::Int2101010Rev ||
                                          attr.Type == DataType::Uint2101010Rev;
             const SizeT requiredAlignment = packedAttribute ? attribByteSize : GetComponentSize(attr.Type);
+            // For a client-memory array attr.Offset holds the raw client pointer, and the
+            // draw path re-uploads the data to a 16-aligned transient slice with attribute
+            // offset 0, so only the stride can violate Vulkan's fetch alignment there.
+            const Bool clientMemoryAttribute = attr.Buffer == nullptr;
             if (conversion == VertexStreamConversion::None && requiredAlignment > 1 &&
-                ((sourceStride % requiredAlignment) != 0 || (attr.Offset % requiredAlignment) != 0)) {
+                ((sourceStride % requiredAlignment) != 0 ||
+                 (!clientMemoryAttribute && (attr.Offset % requiredAlignment) != 0))) {
                 // GL accepts arbitrary byte strides and offsets. Core Vulkan vertex fetches do not
                 // unless VK_EXT_legacy_vertex_attributes is available, so deinterleave this one
                 // attribute into a tightly packed transient stream without changing its format.

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.cpp

@@ -251,11 +251,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const auto internalFormat = renderbuffer->GetInternalFormat();
         const VkFormat format = MG_Util::ConvertTextureInternalFormatToVkEnum(internalFormat);
         const VkImageAspectFlags aspect = ResolveImageAspectMaskForFormat(format);
-        if ((aspect & VK_IMAGE_ASPECT_COLOR_BIT) != 0) {
-            MGLOG_E("GetOrCreateRenderbufferResource: color renderbuffer %u is not supported by DirectVulkan render passes yet",
-                    renderbuffer->GetExternalIndex());
-            return nullptr;
-        }
+        // Renderbuffers are never sampled (GL has no way to bind one to a sampler), so the
+        // usage set is attachment + transfer: transfer covers readback (vkCmdCopyImageToBuffer),
+        // BlitFramebuffer, CopyTexImage sources, and out-of-render-pass clear materialization.
+        const VkImageUsageFlags imageUsage =
+            ((aspect & VK_IMAGE_ASPECT_COLOR_BIT) != 0 ? VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
+                                                       : VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) |
+            VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
         auto& resource = m_renderbufferResources[renderbuffer.get()];
         const Bool needsCreate =
@@ -285,7 +287,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         imageInfo.format = format;
         imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
         imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-        imageInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+        imageInfo.usage = imageUsage;
         imageInfo.samples = sampleCount;
         imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
@@ -386,6 +388,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void VkRenderPassManager::QueueRenderbufferClear(
         GLbitfield mask, const ClearFramebufferPayload& clearPayload,
         const MG_State::GLState::FramebufferObject& drawFbo) {
+        if ((mask & GL_COLOR_BUFFER_BIT) != 0) {
+            // Color renderbuffer draw buffers take the framebuffer-level clear too; texture
+            // attachments are skipped by the per-attachment overload's IsRenderbuffer guard.
+            for (const auto attachmentType : drawFbo.GetDrawBuffers()) {
+                if (attachmentType == FramebufferAttachmentType::None) {
+                    continue;
+                }
+                QueueRenderbufferClear(
+                    ClearAttachmentPayload{.mask = GL_COLOR_BUFFER_BIT, .color = clearPayload.color},
+                    drawFbo.GetAttachment(attachmentType));
+            }
+        }
         if ((mask & GL_DEPTH_BUFFER_BIT) != 0) {
             QueueRenderbufferClear(
                 ClearAttachmentPayload{.mask = GL_DEPTH_BUFFER_BIT, .depth = clearPayload.depth},
@@ -682,6 +696,83 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // assuming default FBO has the right param
         for (Uint32 i = 0; i < colorAttachmentSlotCount; ++i) {
             auto drawbuf = drawbufs[i];
+
+            // Renderbuffer color attachments mirror the texture path below, with the
+            // resource (image/view/format/layout) coming from the render-pass manager's
+            // renderbuffer store instead of the texture manager.
+            if (drawbuf != FramebufferAttachmentType::None && !isDefaultFbo) {
+                const auto& rbAtt = fbo.GetAttachment(drawbuf);
+                if (rbAtt.IsRenderbuffer() && rbAtt.IsComplete()) {
+                    const auto& renderbuffer = rbAtt.GetRenderbuffer();
+                    auto* rbResource = GetOrCreateRenderbufferResource(renderbuffer);
+                    if (rbResource == nullptr || (rbResource->aspect & VK_IMAGE_ASPECT_COLOR_BIT) == 0) {
+                        MGLOG_E("GetOrCreateRenderPass: draw buffer slot %u on FBO %u has an unsupported color "
+                                "renderbuffer %u; using VK_ATTACHMENT_UNUSED",
+                                i, fbo.GetExternalIndex(), renderbuffer->GetExternalIndex());
+                        continue;
+                    }
+
+                    const Uint32 rbAttachmentIndex = static_cast<Uint32>(attachmentDescriptions.size());
+                    attachmentDescriptions.emplace_back();
+                    VkAttachmentDescription& rbDesc = attachmentDescriptions.back();
+
+                    ClearAttachmentPayload rbClearPayload{};
+                    Bool rbHasClear = GetPendingRenderbufferClear(renderbuffer.get(), rbClearPayload) &&
+                                      (rbClearPayload.mask & GL_COLOR_BUFFER_BIT) != 0;
+                    if (rbHasClear &&
+                        MG_Util::GetBaseInternalFormatComponentCount(renderbuffer->GetInternalFormat()) == 3) {
+                        // RGB renderbuffers are backed by an RGBA image; the missing alpha reads as 1.
+                        rbClearPayload.color =
+                            FloatVec4(rbClearPayload.color.x(), rbClearPayload.color.y(),
+                                      rbClearPayload.color.z(), 1.0f);
+                    }
+
+                    const VkImageLayout trackedRbLayout = rbResource->layout;
+                    rbDesc.flags = 0;
+                    rbDesc.format = rbResource->format;
+                    rbDesc.samples = rbResource->sampleCount;
+                    rbDesc.loadOp = rbHasClear ? VK_ATTACHMENT_LOAD_OP_CLEAR :
+                                    (trackedRbLayout == VK_IMAGE_LAYOUT_UNDEFINED ? VK_ATTACHMENT_LOAD_OP_DONT_CARE
+                                                                                  : VK_ATTACHMENT_LOAD_OP_LOAD);
+                    rbDesc.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+                    rbDesc.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+                    rbDesc.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+                    rbDesc.initialLayout = (rbHasClear || trackedRbLayout == VK_IMAGE_LAYOUT_UNDEFINED) ?
+                        VK_IMAGE_LAYOUT_UNDEFINED : trackedRbLayout;
+                    rbDesc.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+                    adoptRenderPassSampleCount(rbResource->sampleCount, "color",
+                                               static_cast<Int>(renderbuffer->GetExternalIndex()));
+
+                    if (rbHasClear) {
+                        pendingClearAttachments.emplace_back(PendingClearAttachmentInfo {
+                            .attachmentIndex = rbAttachmentIndex,
+                            .colorAttachmentSlot = i,
+                            .renderbuffer = renderbuffer.get(),
+                            .hasInlinePayload = true,
+                            .inlinePayload = rbClearPayload,
+                        });
+                    }
+
+                    if (width == 0)
+                        width = static_cast<Int>(rbResource->extent.width);
+                    if (height == 0)
+                        height = static_cast<Int>(rbResource->extent.height);
+
+                    trackedAttachmentLayouts.emplace_back(TrackedAttachmentLayoutInfo {
+                        .target = TrackedAttachmentTarget::Renderbuffer,
+                        .renderbuffer = renderbuffer,
+                        .finalLayout = rbDesc.finalLayout,
+                    });
+                    textureResources.emplace_back(nullptr);
+                    attachmentViews.emplace_back(rbResource->view);
+                    MOBILEGL_ASSERT(attachmentViews.back() != VK_NULL_HANDLE,
+                                    "GetOrCreateRenderPass: renderbuffer view missing at color attachment %d", i);
+
+                    colorAttachmentRefs[i].attachment = rbAttachmentIndex;
+                    continue;
+                }
+            }
+
             auto* texture = ResolveCompleteColorAttachmentTexture(fbo, drawbuf, i);
             if (texture == nullptr)
                 continue;
@@ -700,6 +791,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 ?

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.h

@@ -211,6 +211,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint64 m_rpFastRbEpoch = 0;
         Uint64 m_rpFastRenderPassHash = 0;
 
+    public:
         struct RenderbufferResource {
             WeakPtr<MG_State::GLState::RenderbufferObject> renderbuffer;
             VkImage image = VK_NULL_HANDLE;
@@ -227,6 +228,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             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{};
@@ -235,10 +244,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         UnorderedMap<MG_State::GLState::RenderbufferObject*, RenderbufferResource> m_renderbufferResources;
         UnorderedMap<MG_State::GLState::RenderbufferObject*, PendingRenderbufferClear> m_pendingRenderbufferClears;
 
-        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();

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.cpp

@@ -375,7 +375,23 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         switch (format) {
         case TextureInternalFormat::RGB:
         case TextureInternalFormat::RGB8:
+        // Legacy low-bit RGB formats share the UNorm8 canonical shadow layout (see
+        // TextureFormatProcessor), so they upload exactly like RGB8 with an alpha expand.
+        case TextureInternalFormat::R3G3B2:
+        case TextureInternalFormat::RGB4:
+        case TextureInternalFormat::RGB5:
             return {VK_FORMAT_R8G8B8A8_UNORM, true, 1, {0xFF, 0x00, 0x00, 0x00}};
+        // Low-bit RGBA formats: UNorm8x4 canonical shadow, no expansion needed.
+        case TextureInternalFormat::RGBA2:
+        case TextureInternalFormat::RGBA4:
+        case TextureInternalFormat::RGB5A1:
+            return {VK_FORMAT_R8G8B8A8_UNORM, false, 0, {0, 0, 0, 0}};
+        // 10/12-bit RGB(A): UNorm16 canonical shadow.
+        case TextureInternalFormat::RGB10:
+        case TextureInternalFormat::RGB12:
+            return {VK_FORMAT_R16G16B16A16_UNORM, true, 2, {0xFF, 0xFF, 0x00, 0x00}};
+        case TextureInternalFormat::RGBA12:
+            return {VK_FORMAT_R16G16B16A16_UNORM, false, 0, {0, 0, 0, 0}};
         case TextureInternalFormat::SRGB8:
             return {VK_FORMAT_R8G8B8A8_SRGB, true, 1, {0xFF, 0x00, 0x00, 0x00}};
         case TextureInternalFormat::RGB8Snorm:
@@ -1140,6 +1156,24 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return ok;
     }
 
+    Bool VkTextureManager::NeedsStorageImagePreparation(MG_State::GLState::ITextureObject& texture) const {
+        const auto it = m_textureResources.find(MakeTextureIdentity(&texture));
+        if (it == m_textureResources.end()) {
+            return true;
+        }
+        const TextureResource& resource = it->second;
+        if (resource.image == VK_NULL_HANDLE || resource.layout != VK_IMAGE_LAYOUT_GENERAL) {
+            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);
+        const Uint32 mipLevelCount = mipTexture != nullptr ? mipTexture->GetMipmapLevelCount() : 0u;
+        return resource.syncedContentVersion != texture.GetContentVersion() ||
+               resource.syncedTextureParamsVersion != texture.GetTextureParamsVersion() ||
+               resource.syncedMipLevelCount != mipLevelCount;
+    }
+
     Bool VkTextureManager::TransitionImageLayout(VkCommandBuffer commandBuffer, VkImage image,
                                                  VkImageLayout& trackedLayout, VkImageLayout newLayout,
                                                  VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
@@ -1323,7 +1357,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             (aspect & VK_IMAGE_ASPECT_COLOR_BIT) != 0 &&
             (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) != 0;
         VkImageCreateFlags imageCreateFlags = shapeInfo.imageFlags;
-        if (supportsStorageImage && IsMutableStorageImageFormat(format)) {
+        if (supportsStorageImage && IsMutableStorageImageFormat(format) &&
+            m_mutableFormatUnsupported.find(format) == m_mutableFormatUnsupported.end()) {
             imageCreateFlags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
         }
 
@@ -1391,9 +1426,27 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         imageInfo.samples = resolvedSampleCount;
         if (isMultisampleTexture || (imageInfo.flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) != 0) {
             VkImageFormatProperties imageFormatProperties{};
-            const VkResult imageFormatResult = vkGetPhysicalDeviceImageFormatProperties(
+            VkResult imageFormatResult = vkGetPhysicalDeviceImageFormatProperties(
                 m_physicalDevice, format, imageInfo.imageType, imageInfo.tiling, imageInfo.usage,
                 imageInfo.flags, &imageFormatProperties);
+            if (imageFormatResult != VK_SUCCESS && !isMultisampleTexture &&
+                (imageInfo.flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) != 0) {
+                // Losing reinterpreted views only degrades the formatless-image feature for
+                // this texture; failing creation would lose the texture entirely, so retry
+                // as a plain immutable-format image.
+                MGLOG_W("%s: mutable image format=%d is unsupported for textureId=%d; creating "
+                        "without VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT (format reinterpretation "
+                        "will be unavailable for it)",
+                        __func__, static_cast<Int>(format), texture.GetExternalIndex());
+                // Remember the verdict so later syncs of same-format textures neither retry
+                // the probe nor flag-mismatch against this image and recreate it.
+                m_mutableFormatUnsupported.insert(format);
+                imageInfo.flags &= ~VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
+                imageCreateFlags = imageInfo.flags;
+                imageFormatResult = vkGetPhysicalDeviceImageFormatProperties(
+                    m_physicalDevice, format, imageInfo.imageType, imageInfo.tiling, imageInfo.usage,
+                    imageInfo.flags, &imageFormatProperties);
+            }
             if (imageFormatResult != VK_SUCCESS ||
                 (isMultisampleTexture && (imageFormatProperties.sampleCounts & resolvedSampleCount) == 0)) {
                 MGLOG_D("%s: image flags=0x%x sampleCount=%d are unsupported for textureId=%d target=%s "
@@ -1921,6 +1974,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     VkFormat VkTextureManager::ResolveSampledImageViewFormat(VkFormat imageFormat,
                                                               SamplerNumericDomain numericDomain) {
+        // Depth/stencil images always sample through the existing depth-aspect sampledView.
+        // Combined formats (D24S8, D32FS8) are multi-numeric, so vkuFormatIsSampledFloat is
+        // false for them by design, yet their depth aspect reads as float in every GL depth
+        // texture mode; Vulkan also forbids reinterpreting them through color-class views.
+        // Integer domains keep the same view (pre-reinterpretation behavior for stencil-index
+        // style access) rather than failing the draw.
+        if (vkuFormatIsDepthOrStencil(imageFormat)) {
+            return imageFormat;
+        }
         if (imageFormat == VK_FORMAT_UNDEFINED || numericDomain == SamplerNumericDomain::Unknown ||
             FormatMatchesSamplerNumericDomain(imageFormat, numericDomain)) {
             return imageFormat;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.h

@@ -13,6 +13,7 @@
 #include <MG_State/GLState/TextureState/TextureObject.h>
 #include <vk_mem_alloc.h>
 #include <unordered_map>
+#include <unordered_set>
 
 namespace MobileGL::MG_State::GLState {
 class ITextureObject;
@@ -284,6 +285,11 @@ public:
                                                       VkImageLayout newLayout);
     Bool TransitionTextureForSampling(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
     Bool TransitionTextureForStorageImage(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
+    // 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
+    // true - a false positive merely ends the render pass, a false negative would skip a barrier.
+    Bool NeedsStorageImagePreparation(MG_State::GLState::ITextureObject& texture) const;
 
     static VkImageAspectFlags ResolveSampledImageViewAspectMask(VkImageAspectFlags imageAspect);
     static VkFormat ResolveSampledImageViewFormat(VkFormat imageFormat, SamplerNumericDomain numericDomain);
@@ -379,6 +385,9 @@ private:
         TextureResource* resource = nullptr;
     };
     Vector<DrawSyncedTexture> m_drawSyncedThisDraw;
+    // 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;
     Vector<Vector<TextureResource>> m_deferredReleases;

MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.h

@@ -51,6 +51,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint32 instanceCount = 1;
         Uint32 firstVertex = 0;
         Uint32 firstInstance = 0;
+        // Indexed-draw metadata for bounding vertex-stream conversion. baseVertex is the
+        // draw's base-vertex offset; indexRangeIsExactView is true only when the draw
+        // fetches exactly the indices its IndexBufferView describes (direct DrawElements;
+        // multi/indirect forms leave it false because the CPU cannot bound their ranges).
+        Int32 baseVertex = 0;
+        Bool indexRangeIsExactView = false;
     };
 
     struct DrawIndexedCmdParam {
@@ -251,7 +257,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint64 GetTimerQueryTimestampNs(const VkTimerQueryManager::TimestampRecord& record) const;
 
         void RequestSwapchainResize(Uint32 width, Uint32 height);
-        void RecreateSwapchain();
+        // Returns false when the surface is zero-area (minimized/hidden window):
+        // no new swapchain is installed and presentation must stay suspended.
+        Bool RecreateSwapchain();
 
     private:
         struct BlitUniformData {
@@ -349,6 +357,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void* m_platformCloseDisplay = nullptr;
         VulkanRendererConfig m_config;
         Bool m_swapchainResizeRequested = false;
+        // Presentation is suspended while the window is zero-area (minimized): the
+        // swapchain is unusable/out of date, so Present drops frames instead of
+        // submitting on a signaled fence / presenting never-acquired images.
+        Bool m_presentSuspended = false;
 
         // Vulkan objects
         Bool m_validationLayersEnabled = false;
@@ -488,7 +500,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         };
 
-        UnorderedMap<ConvertedVertexStreamKey, BufferSlice, ConvertedVertexStreamKeyHash>
+        struct ConvertedVertexStream {
+            BufferSlice slice;
+            // Number of source elements the cached slice covers. A draw needing a prefix of
+            // this range reuses the slice (converted streams are tightly packed); a draw
+            // needing more reconverts and replaces the entry, so per (buffer, layout) a
+            // frame converts at most the largest range any draw asked for.
+            SizeT elementCount = 0;
+            // Pins the source buffer for the frame so its heap address cannot be reused by
+            // a new BufferObject while this pointer-keyed entry is alive.
+            SharedPtr<const MG_State::GLState::BufferObject> sourcePin;
+        };
+        UnorderedMap<ConvertedVertexStreamKey, ConvertedVertexStream, ConvertedVertexStreamKeyHash>
             m_convertedVertexStreams;
 
         void CreateInstance();
@@ -519,7 +542,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         Bool UploadAndBindVertexBuffers(VkCommandBuffer commandBuffer, const MG_State::GLState::VertexArrayObject& vao,
                                         const ProgramFactory::VkProgramObject& programObj,
-                                        const DrawCmdParam& drawParams, Bool indexedDraw);
+                                        const DrawCmdParam& drawParams,
+                                        const IndexBufferView* pIndexBufferView);
         Bool UploadAndBindIndexBuffer(FrameContext::FrameData& frame,
                                      const MG_State::GLState::VertexArrayObject& vao,
                                       const IndexBufferView* pIndexBufferView = nullptr);
@@ -537,6 +561,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,

MobileGL/MG_Impl/EGLImpl/EGLImpl.cpp

@@ -8,6 +8,7 @@
 
 #include "EGLImpl.h"
 #include "../GetProcAddress.h"
+#include <Init.h>
 #include <MG_Backend/BackendObjects.h>
 #include <MG_State/EGLState/Core.h>
 #include <mutex>
@@ -25,6 +26,17 @@ namespace MobileGL::MG_Impl::EGLImpl {
             return MG_State::pEGLContext.get();
         }
 
+        // Entry points that can legitimately be an application's FIRST EGL
+        // call (display/proc-address/string queries) lazily bring MobileGL
+        // up here, so the library needs no static constructor and can
+        // re-initialize after the last eglTerminate tore everything down.
+        // Teardown-ish entry points keep using GetState() and fail benignly
+        // when MobileGL is not initialized.
+        EGLStateContext* GetStateEnsureInitialized() {
+            MobileGL::EnsureInitialized();
+            return GetState();
+        }
+
         MG_Backend::BackendObject* GetBackendObject(EGLStateContext* state) {
             auto* backendObject = MG_Backend::pActiveBackendObject.get();
             if (!backendObject && state) {
@@ -49,6 +61,8 @@ namespace MobileGL::MG_Impl::EGLImpl {
             return MG_Backend::WindowBackend::Android;
 #elif defined(__APPLE__)
             return MG_Backend::WindowBackend::MetalLayer;
+#elif defined(_WIN32)
+            return MG_Backend::WindowBackend::Win32;
 #elif defined(__linux__)
             return MG_Backend::WindowBackend::X11;
 #else
@@ -187,7 +201,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
     }
 
     EGLBoolean Initialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
-        auto* state = GetState();
+        auto* state = GetStateEnsureInitialized();
         if (!state) {
             return EGL_FALSE;
         }
@@ -208,7 +222,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
     }
 
     EGLDisplay GetDisplay(NativeDisplayType display) {
-        auto* state = GetState();
+        auto* state = GetStateEnsureInitialized();
         if (!state) {
             return EGL_NO_DISPLAY;
         }
@@ -313,6 +327,14 @@ namespace MobileGL::MG_Impl::EGLImpl {
         if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) {
             backendObject->ReleaseEGLResources();
         }
+        // The last initialized display is gone and nothing is current on any
+        // thread: tear the whole library down deterministically inside the
+        // EGL lifecycle (backend, GL/EGL state, glslang). A later EGL call
+        // re-initializes lazily via GetStateEnsureInitialized(); process exit
+        // then has nothing left to destroy.
+        if (!state->HasAnyInitializedDisplay() && !state->HasAnyCurrentContext()) {
+            MobileGL::Destroy();
+        }
         return EGL_TRUE;
     }
 
@@ -345,7 +367,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
     }
 
     EGLBoolean BindAPI(EGLenum api) {
-        auto* state = GetState();
+        auto* state = GetStateEnsureInitialized();
         if (!state) {
             return EGL_FALSE;
         }
@@ -378,7 +400,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
     }
 
     char const* QueryString(EGLDisplay display, EGLint name) {
-        auto* state = GetState();
+        auto* state = GetStateEnsureInitialized();
         if (!state) {
             return nullptr;
         }
@@ -641,7 +663,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
     EGLDisplay GetPlatformDisplay(EGLenum platform, void* native_display, const EGLAttrib* attrib_list) {
         (void)attrib_list;
 
-        auto* state = GetState();
+        auto* state = GetStateEnsureInitialized();
         if (!state) {
             return EGL_NO_DISPLAY;
         }
@@ -737,6 +759,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
         if (!name) {
             return nullptr;
         }
+        MobileGL::EnsureInitialized();
 
         MGLOG_D("eglGetProcAddress(%s)", name);
         void* proc = MG_Impl::GetProcAddress(name);

MobileGL/MG_Impl/GLImpl/Exporting/Definitions.cpp

@@ -295,7 +295,13 @@ DECLARE_GL_FUNCTION_HEAD(void, VertexAttribDivisor, GLuint index, GLuint divisor
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindTransformFeedback, GLenum target, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindTransformFeedback, target, id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteTransformFeedbacks, GLsizei n, const GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteTransformFeedbacks, n, ids)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenTransformFeedbacks, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenTransformFeedbacks, n, ids)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsTransformFeedback, GLuint id) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsTransformFeedback, id)
+// Transform feedback objects are not implemented, so no name is ever a live object. The shared
+// stub returns (type)1, telling a probing caller that every id it invents already exists; GL_FALSE
+// is both truthful and what the spec requires for a name that was never generated.
+MOBILEGL_GL_API GLboolean glIsTransformFeedback(GLuint id) {
+    MGLOG_W("Stub function: %s(...)", __FUNCTION__);
+    return GL_FALSE;
+}
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PauseTransformFeedback) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PauseTransformFeedback)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ResumeTransformFeedback) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ResumeTransformFeedback)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetProgramBinary, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetProgramBinary, program, bufSize, length, binaryFormat, binary)
@@ -418,7 +424,7 @@ DECLARE_GL_FUNCTION_HEAD(void, DrawRangeElementsBaseVertex, GLenum mode, GLuint
 DECLARE_GL_FUNCTION_HEAD(void, DrawElementsInstancedBaseVertex, GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawElementsInstancedBaseVertex, mode, count, type, indices, instancecount, basevertex)
 DECLARE_GL_FUNCTION_HEAD(void, FramebufferTexture, GLenum target, GLenum attachment, GLuint texture, GLint level) DECLARE_GL_FUNCTION_END_NO_RETURN(void, FramebufferTexture, target, attachment, texture, level)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PrimitiveBoundingBox, GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PrimitiveBoundingBox, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, GetGraphicsResetStatus) DECLARE_GL_FUNCTION_STUB_END(GLenum, GetGraphicsResetStatus)
+DECLARE_GL_FUNCTION_HEAD(GLenum, GetGraphicsResetStatus) DECLARE_GL_FUNCTION_END(GLenum, GetGraphicsResetStatus)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ReadnPixels, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ReadnPixels, x, y, width, height, format, type, bufSize, data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformfv, GLuint program, GLint location, GLsizei bufSize, GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformfv, program, location, bufSize, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformiv, GLuint program, GLint location, GLsizei bufSize, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformiv, program, location, bufSize, params)
@@ -2583,7 +2589,10 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, TransformFeedbackStreamAttribsNV, GLsizei co
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindTransformFeedbackNV, GLenum target, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindTransformFeedbackNV, target, id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteTransformFeedbacksNV, GLsizei n, const GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteTransformFeedbacksNV, n, ids)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenTransformFeedbacksNV, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenTransformFeedbacksNV, n, ids)
-DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsTransformFeedbackNV, GLuint id) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsTransformFeedbackNV, id)
+MOBILEGL_GL_API GLboolean glIsTransformFeedbackNV(GLuint id) {
+    MGLOG_W("Stub function: %s(...)", __FUNCTION__);
+    return GL_FALSE;
+}
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PauseTransformFeedbackNV, void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PauseTransformFeedbackNV, )
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ResumeTransformFeedbackNV, void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ResumeTransformFeedbackNV, )
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawTransformFeedbackNV, GLenum mode, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawTransformFeedbackNV, mode, id)

MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp

@@ -2144,6 +2144,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     namespace FramebufferImpl {
-        UniquePtr<DefaultFramebufferInfo> pDefaultFramebufferInfo;
+        // Leak-at-exit storage; see GlobalObjects.cpp.
+        UniquePtr<DefaultFramebufferInfo>& pDefaultFramebufferInfo = *new UniquePtr<DefaultFramebufferInfo>();
     } // namespace FramebufferImpl
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h

@@ -78,6 +78,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             SharedPtr<MG_State::GLState::ITextureObject> stencilAttachment;
         };
 
-        extern UniquePtr<DefaultFramebufferInfo> pDefaultFramebufferInfo;
+        extern UniquePtr<DefaultFramebufferInfo>& pDefaultFramebufferInfo;
     } // namespace FramebufferImpl
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.cpp

@@ -1996,4 +1996,12 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
         return MG_Util::ConvertErrorCodeToGLEnum(error->get()->code);
     }
+
+    GLenum GetGraphicsResetStatus() {
+        // MobileGL does not implement robustness reset notification, so report GL_NO_ERROR
+        // ("no reset detected"). Returning the generic stub's (GLenum)1 makes dEQP read a lost
+        // device after every case (gl3cTestPackages.cpp:121) and, under the default
+        // --deqp-terminate-on-device-lost=enable, tear the whole CTS run down.
+        return GL_NO_ERROR;
+    }
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.h

@@ -21,4 +21,5 @@ namespace MobileGL::MG_Impl::GLImpl {
     void GetIntegeri_v(GLenum target, GLuint index, GLint* data);
     void GetInteger64i_v(GLenum target, GLuint index, GLint64* data);
     GLenum GetError();
+    GLenum GetGraphicsResetStatus();
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Texture/GL_Texture.cpp

@@ -350,6 +350,10 @@ namespace MobileGL::MG_Impl::GLImpl {
                 texture.AllocateStorage(uploadTarget, level, {levelTexelSize, levelByteSize});
                 texture.MarkStorageDirty(uploadTarget, level, false);
             }
+            // glGenerateMipmap defines exactly levels 0..requiredLevelCount-1. AllocateStorage only
+            // grows, so a previously longer chain (a bigger base image before respecification) would
+            // otherwise keep a tail of stale levels here and read as incomplete.
+            texture.TruncateMipmapLevels(uploadTarget, requiredLevelCount);
             // Mip generation grows/regenerates the level set on the GPU without marking any CPU
             // level dirty (MarkStorageDirty(...,false) above). Bump the content version so the
             // backend re-syncs: a cached sampled VkImageView built for the pre-generate level
@@ -429,8 +433,10 @@ namespace MobileGL::MG_Impl::GLImpl {
 
             const Int maxSamples = GetMaxSupportedTextureSamples(textureInternalFormat);
             if (samples > maxSamples) {
+                // GL specifies INVALID_OPERATION - not INVALID_VALUE - when the sample count
+                // exceeds what the format supports, and the native Adreno driver agrees.
                 MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
+                    ErrorCode::InvalidOperation,
                     MakeUnique<GenericErrorInfo>(
                         "MG_Impl/GLImpl", caller,
                         std::format("Sample count {} exceeds the supported maximum {} for this texture format.",
@@ -454,8 +460,56 @@ namespace MobileGL::MG_Impl::GLImpl {
             textureObject->SetSamples(samples);
             textureObject->SetFixedSampleLocations(fixedsamplelocations == GL_TRUE);
             textureMipmapObject->AllocateStorage(textureUploadTarget, 0, {{width, height, depth}, 0});
+            // Multisample textures are single-level by definition, so a name that previously held a
+            // mip chain must not keep its tail now that AllocateStorage only grows.
+            textureMipmapObject->TruncateMipmapLevels(textureUploadTarget, 1);
             textureMipmapObject->MarkStorageDirty(textureUploadTarget, 0, false);
         }
+
+        // Redefining level 0 of a texture that already had a base image drops the rest of the chain,
+        // which is exactly what AllocateLevel used to do implicitly for every level. Keeping that
+        // behaviour for level 0 - and only for level 0 - is what makes the grow-only change safe:
+        // any level-0 respecification leaves the chain in precisely the state it would have had
+        // before, while an upload to level N no longer destroys the levels beneath it.
+        //
+        // Why it has to be *every* level-0 respecification and not just a size change: Minecraft's
+        // Mipmap Levels setting rebuilds the block atlas at the SAME dimensions with a different
+        // level count. A size-only test would leave the old tail in place, and because Mojang
+        // terminates its chains with a 0x0 level the result is the zero-then-nonzero pattern that
+        // IsComplete() rejects (TextureObject.cpp) - whereupon DirectGLES skips syncing the texture
+        // entirely (Managers.cpp) and the atlas samples black.
+        //
+        // The "already has a base image" test is what lets the fix work at all: a level that was
+        // never written reads back as {0,0,0}, so building a chain top-down - upload level N first,
+        // then level 0 - must not discard the levels just uploaded. That ordering is what
+        // KHR-GL33.texture_repeat_mode does.
+        // Scoped to the respecified upload target only, which is what AllocateLevel already did.
+        // Cube maps keep six independent chains while reporting a single level count (face +X), so
+        // respecifying a face other than +X can leave the count longer than that face - but that
+        // asymmetry predates this change and widening the truncation to all six faces would destroy
+        // mip data for faces the application never touched. Left alone deliberately.
+        void DiscardMipmapChainOnBaseRespecification(MG_State::GLState::TextureObjectMipmap* texture,
+                                                     TextureUploadTarget uploadTarget, Uint level) {
+            if (level != 0) return;
+
+            const IntVec3 existingBaseSize = texture->GetMipmapTexelSize(uploadTarget, 0);
+            const Bool hasExistingBaseImage =
+                existingBaseSize.x() > 0 && existingBaseSize.y() > 0 && existingBaseSize.z() > 0;
+            if (!hasExistingBaseImage) return;
+
+            texture->TruncateMipmapLevels(uploadTarget, 1);
+        }
+
+        // Compressed texture upload is not implemented yet. GL_NUM_COMPRESSED_TEXTURE_FORMATS
+        // reports 0, so every compressed internalformat is by definition unsupported and
+        // GL_INVALID_ENUM is the specified error - unlike THROW_UNIMPL_EXCEPTION, which unwinds
+        // a C++ exception through the C GL ABI and takes the process down.
+        void RecordUnsupportedCompressedFormat(const char* caller) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", caller,
+                                             "Compressed texture formats are not supported."));
+        }
     } // namespace
 
     const SharedPtr<MG_State::GLState::ITextureObject>& GetTextureObjectByName(GLuint texture, const char* caller) {
@@ -493,8 +547,15 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
 
             auto mipmapTexture = std::static_pointer_cast<MG_State::GLState::TextureObjectMipmap>(textureObject);
-            if (level < 0 || static_cast<Uint>(level) >= mipmapTexture->GetMipmapLevelCount()) {
+            if (level < 0) {
                 RecordClearTextureError(caller, ErrorCode::InvalidValue,
+                                        std::format("Texture level {} is negative.", level));
+                return nullptr;
+            }
+            // ARB_clear_texture: clearing an image that was never defined by TexImage*/
+            // TexStorage* is INVALID_OPERATION, not INVALID_VALUE.
+            if (static_cast<Uint>(level) >= mipmapTexture->GetMipmapLevelCount()) {
+                RecordClearTextureError(caller, ErrorCode::InvalidOperation,
                                         std::format("Texture level {} is not defined.", level));
                 return nullptr;
             }
@@ -536,6 +597,12 @@ namespace MobileGL::MG_Impl::GLImpl {
             return true;
         }
 
+        // Writes the clear into the CPU shadow and marks the whole level dirty, exactly like
+        // TexSubImage*_State does. Shared limitation of the level-granular shadow sync: the
+        // shadow does not reflect GPU-side writes (FBO rendering, imageStore), so a PARTIAL
+        // clear of a GPU-written level re-uploads stale shadow bytes outside the region on
+        // the next sync. Full-level clears (glClearTexImage, or a sub-clear covering the
+        // level) rewrite the entire shadow and are always correct.
         Bool ClearMipmapRegion(const SharedPtr<MG_State::GLState::TextureObjectMipmap>& textureObject,
                                TextureUploadTarget uploadTarget, GLint level,
                                GLint xoffset, GLint yoffset, GLint zoffset,
@@ -1657,6 +1724,21 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
+        // RGTC is a 2D-only compression scheme, so a 3D target rejects it. This has to be tested on
+        // the raw enum: the RGTC formats resolve to plain R8/RG8/SNORM storage on the way in (see
+        // GLToMG's TextureEnumConverter), so once the internal format is converted there is nothing
+        // left to distinguish them from an ordinary one- or two-channel upload.
+        if ((textureUploadTarget == TextureUploadTarget::Texture3D ||
+             textureUploadTarget == TextureUploadTarget::ProxyTexture3D) &&
+            (internalformat == GL_COMPRESSED_RED_RGTC1 || internalformat == GL_COMPRESSED_SIGNED_RED_RGTC1 ||
+             internalformat == GL_COMPRESSED_RG_RGTC2 || internalformat == GL_COMPRESSED_SIGNED_RG_RGTC2)) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                                             "RGTC compressed formats are invalid for 3D texture targets"));
+            return;
+        }
+
         // TODO: GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the
         // GL_PIXEL_UNPACK_BUFFER target and the buffer object's data store is currently mapped.
         // GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to the GL_PIXEL_UNPACK_BUFFER
@@ -1714,6 +1796,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (isProxy) {
             MGLOG_D("%s: isProxy = true, not allocating", __func__);
         } else {
+            DiscardMipmapChainOnBaseRespecification(textureMipmapObject, textureUploadTarget, level);
             textureMipmapObject->AllocateStorage(textureUploadTarget, level, {{width, height, depth}, internalBytes});
         }
 
@@ -1841,6 +1924,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             MGLOG_D("%s: isProxy = true, not allocating", __func__);
         } else {
             MGLOG_D("%s: Allocating %d bytes at mip %d", __func__, internalBytes, level);
+            DiscardMipmapChainOnBaseRespecification(textureMipmapObject, textureUploadTarget, level);
             textureMipmapObject->AllocateStorage(textureUploadTarget, level,
                                                  {{width, height, 1}, internalBytes});
         }
@@ -1929,6 +2013,7 @@ namespace MobileGL::MG_Impl::GLImpl {
                         "Texture object here should always be an object with mipmap");
         auto textureMipmapObject = static_cast<MG_State::GLState::TextureObjectMipmap*>(textureObject.get());
         if (!isProxy) {
+            DiscardMipmapChainOnBaseRespecification(textureMipmapObject, textureUploadTarget, level);
             textureMipmapObject->AllocateStorage(textureUploadTarget, level, {{width, 1, 1}, internalBytes});
         }
 
@@ -2581,7 +2666,13 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void GetCompressedTexImage_State(GLenum target, GLint level, void* img) {
-        // TODO: implement
+        // TODO: implement compressed readback. Reporting success while writing nothing hands
+        // the caller stale memory with GL_NO_ERROR; no texture can be compressed yet, and GL
+        // specifies GL_INVALID_OPERATION when the bound level is not compressed.
+        MG_State::pGLContext->RecordError(
+            ErrorCode::InvalidOperation,
+            MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                                         "Texture level is not stored in a compressed format."));
     }
 
     void GenTextures_State(GLsizei n, GLuint* textures) {
@@ -2768,20 +2859,20 @@ namespace MobileGL::MG_Impl::GLImpl {
     void CompressedTexSubImage3D_State(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
                                        GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize,
                                        const void* data) {
-        // TODO: implement
-        THROW_UNIMPL_EXCEPTION;
+        // TODO: implement compressed upload - see CompressedTexImage2D_State.
+        RecordUnsupportedCompressedFormat(__func__);
     }
 
     void CompressedTexSubImage2D_State(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
                                        GLsizei height, GLenum format, GLsizei imageSize, const void* data) {
-        // TODO: implement
-        THROW_UNIMPL_EXCEPTION;
+        // TODO: implement compressed upload - see CompressedTexImage2D_State.
+        RecordUnsupportedCompressedFormat(__func__);
     }
 
     void CompressedTexSubImage1D_State(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format,
                                        GLsizei imageSize, const void* data) {
-        // TODO: implement
-        THROW_UNIMPL_EXCEPTION;
+        // TODO: implement compressed upload - see CompressedTexImage2D_State.
+        RecordUnsupportedCompressedFormat(__func__);
     }
 
     void CompressedTexImage3D_State(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
@@ -2791,8 +2882,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         auto& textureObject = GetTextureObjectByTarget(textureUploadTarget, textureTarget);
         if (!ValidateTextureMutable(textureObject, __func__)) return;
 
-        // TODO: implement
-        THROW_UNIMPL_EXCEPTION;
+        // TODO: implement compressed upload - see CompressedTexImage2D_State.
+        RecordUnsupportedCompressedFormat(__func__);
     }
 
     void CompressedTexImage2D_State(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
@@ -2802,8 +2893,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         auto& textureObject = GetTextureObjectByTarget(textureUploadTarget, textureTarget);
         if (!ValidateTextureMutable(textureObject, __func__)) return;
 
-        // TODO: implement
-        THROW_UNIMPL_EXCEPTION;
+        // TODO: implement compressed upload. Until then report the spec error for an
+        // unsupported compressed format rather than throwing - a C++ exception unwinding
+        // through the C GL ABI is a hard crash for the caller, while GL_INVALID_ENUM is
+        // exactly what GL_NUM_COMPRESSED_TEXTURE_FORMATS == 0 promises.
+        RecordUnsupportedCompressedFormat(__func__);
     }
 
     void CompressedTexImage1D_State(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border,
@@ -2813,8 +2907,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         auto& textureObject = GetTextureObjectByTarget(textureUploadTarget, textureTarget);
         if (!ValidateTextureMutable(textureObject, __func__)) return;
 
-        // TODO: implement
-        THROW_UNIMPL_EXCEPTION;
+        // TODO: implement compressed upload - see CompressedTexImage2D_State.
+        RecordUnsupportedCompressedFormat(__func__);
     }
 
     void BindTexture_State(GLenum target, GLuint texture) {
@@ -3160,6 +3254,9 @@ namespace MobileGL::MG_Impl::GLImpl {
             textureMipmapObject->AllocateStorage(textureUploadTarget, level, {{levelWidth, 1, 1}, byteSize});
             textureMipmapObject->MarkStorageDirty(textureUploadTarget, level, false);
         }
+        // Immutable storage defines exactly `levels` levels; AllocateStorage only grows, so a
+        // longer pre-existing chain has to be dropped explicitly.
+        textureMipmapObject->TruncateMipmapLevels(textureUploadTarget, static_cast<Uint>(levels));
         textureObject->SetImmutableLevels(static_cast<Uint>(levels));
     }
 
@@ -3212,6 +3309,8 @@ namespace MobileGL::MG_Impl::GLImpl {
             textureMipmapObject->AllocateStorage(textureUploadTarget, level, {{levelWidth, levelHeight, 1}, byteSize});
             textureMipmapObject->MarkStorageDirty(textureUploadTarget, level, false);
         }
+        // See TextureStorage1D.
+        textureMipmapObject->TruncateMipmapLevels(textureUploadTarget, static_cast<Uint>(levels));
         textureObject->SetImmutableLevels(static_cast<Uint>(levels));
     }
 
@@ -3264,6 +3363,8 @@ namespace MobileGL::MG_Impl::GLImpl {
                                                  {{levelWidth, levelHeight, levelDepth}, byteSize});
             textureMipmapObject->MarkStorageDirty(textureUploadTarget, level, false);
         }
+        // See TextureStorage1D.
+        textureMipmapObject->TruncateMipmapLevels(textureUploadTarget, static_cast<Uint>(levels));
         textureObject->SetImmutableLevels(static_cast<Uint>(levels));
     }
 
@@ -4025,8 +4126,21 @@ namespace MobileGL::MG_Impl::GLImpl {
     void CopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
                                GLsizei width, GLsizei height) {
         auto textureObject = GetTextureObjectByName(texture, __func__);
-        WithTemporarilyBoundNamedTexture(textureObject, [&](GLenum target) {
-            CopyTexSubImage2D_Backend(target, level, xoffset, yoffset, x, y, width, height);
+        if (!textureObject) return;
+        // GL 4.6 sec. 8.8: the 2D form only accepts these effective targets; cube maps must
+        // go through CopyTextureSubImage3D with the face as a layer.
+        const auto target = textureObject->GetTarget();
+        if (target != TextureTarget::Texture2D && target != TextureTarget::Texture1DArray &&
+            target != TextureTarget::TextureRectangle) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                                             "CopyTextureSubImage2D requires a 2D, 1D-array, or "
+                                             "rectangle texture."));
+            return;
+        }
+        WithTemporarilyBoundNamedTexture(textureObject, [&](GLenum glTarget) {
+            CopyTexSubImage2D_Backend(glTarget, level, xoffset, yoffset, x, y, width, height);
         });
     }
 

MobileGL/MG_Impl/GLImpl/Texture/ProxyTexture.cpp

@@ -14,7 +14,8 @@
 #include <MG_State/GLState/TextureState/TextureObjectStubs.h>
 
 namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
-    UniquePtr<ProxyTextureManager> pProxyTextureManager;
+    // Leak-at-exit storage; see GlobalObjects.cpp.
+    UniquePtr<ProxyTextureManager>& pProxyTextureManager = *new UniquePtr<ProxyTextureManager>();
 
     Bool IsProxyTextureTarget(TextureUploadTarget target) {
         switch (target) {

MobileGL/MG_Impl/GLImpl/Texture/ProxyTexture.h

@@ -23,5 +23,5 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
         UnorderedMap<TextureUploadTarget, SharedPtr<MG_State::GLState::ITextureObject>> m_proxyTexturesMap;
     };
 
-    extern UniquePtr<ProxyTextureManager> pProxyTextureManager;
+    extern UniquePtr<ProxyTextureManager>& pProxyTextureManager;
 } // namespace MobileGL::MG_Impl::GLImpl::TextureImpl

MobileGL/MG_Impl/WGLImpl/Exporting/Definitions.cpp

@@ -0,0 +1,156 @@
+// MobileGL - MobileGL/MG_Impl/WGLImpl/Exporting/Definitions.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+// wingdi.h declares most wgl* entry points as WINGDIAPI (__declspec(dllimport)),
+// which would reject our definitions. _GDI32_ is the SDK's "I am the module that
+// implements these" switch: it turns WINGDIAPI into a plain declaration. It must
+// be defined before the first windows.h inclusion in this translation unit.
+#if defined(_WIN32) && !defined(_GDI32_)
+#define _GDI32_ 1
+#endif
+
+#include <Includes.h>
+
+#if defined(_WIN32)
+#include "../WGLImpl.h"
+
+namespace WGL = MobileGL::MG_Impl::WGLImpl;
+
+// ---- Pixel-format entry points (gdi32 forwards ChoosePixelFormat/SetPixelFormat/
+// ---- DescribePixelFormat/GetPixelFormat/SwapBuffers into these exports) ----
+
+extern "C" int WINAPI wglChoosePixelFormat(HDC hdc, CONST PIXELFORMATDESCRIPTOR* ppfd) {
+    return WGL::ChoosePixelFormat(hdc, ppfd);
+}
+
+extern "C" int WINAPI wglDescribePixelFormat(HDC hdc, int iPixelFormat, UINT nBytes,
+                                                   LPPIXELFORMATDESCRIPTOR ppfd) {
+    return WGL::DescribePixelFormat(hdc, iPixelFormat, nBytes, ppfd);
+}
+
+extern "C" int WINAPI wglGetPixelFormat(HDC hdc) {
+    return WGL::GetPixelFormat(hdc);
+}
+
+extern "C" BOOL WINAPI wglSetPixelFormat(HDC hdc, int iPixelFormat, CONST PIXELFORMATDESCRIPTOR* ppfd) {
+    return WGL::SetPixelFormat(hdc, iPixelFormat, ppfd);
+}
+
+extern "C" BOOL WINAPI wglSwapBuffers(HDC hdc) {
+    return WGL::SwapBuffers(hdc);
+}
+
+// ---- Context management ----
+
+extern "C" HGLRC WINAPI wglCreateContext(HDC hdc) {
+    return WGL::CreateContext(hdc);
+}
+
+extern "C" HGLRC WINAPI wglCreateLayerContext(HDC hdc, int iLayerPlane) {
+    return iLayerPlane == 0 ? WGL::CreateContext(hdc) : nullptr;
+}
+
+extern "C" BOOL WINAPI wglCopyContext(HGLRC, HGLRC, UINT) {
+    MGLOG_W("wglCopyContext is not supported");
+    SetLastError(ERROR_NOT_SUPPORTED);
+    return FALSE;
+}
+
+extern "C" BOOL WINAPI wglDeleteContext(HGLRC hglrc) {
+    return WGL::DeleteContext(hglrc);
+}
+
+extern "C" HGLRC WINAPI wglGetCurrentContext(VOID) {
+    return WGL::GetCurrentContext();
+}
+
+extern "C" HDC WINAPI wglGetCurrentDC(VOID) {
+    return WGL::GetCurrentDC();
+}
+
+extern "C" BOOL WINAPI wglMakeCurrent(HDC hdc, HGLRC hglrc) {
+    return WGL::MakeCurrent(hdc, hglrc);
+}
+
+extern "C" BOOL WINAPI wglShareLists(HGLRC hglrcShare, HGLRC hglrcDest) {
+    return WGL::ShareLists(hglrcShare, hglrcDest);
+}
+
+// ---- Proc address ----
+
+extern "C" PROC WINAPI wglGetProcAddress(LPCSTR lpszProc) {
+    return WGL::GetProcAddress(lpszProc);
+}
+
+extern "C" PROC WINAPI wglGetDefaultProcAddress(LPCSTR lpszProc) {
+    return WGL::GetProcAddress(lpszProc);
+}
+
+// ---- Layer planes and palettes (unsupported; overlay planes do not exist here) ----
+
+extern "C" BOOL WINAPI wglDescribeLayerPlane(HDC, int, int, UINT, LPLAYERPLANEDESCRIPTOR) {
+    return FALSE;
+}
+
+extern "C" int WINAPI wglSetLayerPaletteEntries(HDC, int, int, int, CONST COLORREF*) {
+    return 0;
+}
+
+extern "C" int WINAPI wglGetLayerPaletteEntries(HDC, int, int, int, COLORREF*) {
+    return 0;
+}
+
+extern "C" BOOL WINAPI wglRealizeLayerPalette(HDC, int, BOOL) {
+    return FALSE;
+}
+
+extern "C" BOOL WINAPI wglSwapLayerBuffers(HDC hdc, UINT fuPlanes) {
+    if (fuPlanes & WGL_SWAP_MAIN_PLANE) {
+        return WGL::SwapBuffers(hdc);
+    }
+    return FALSE;
+}
+
+extern "C" DWORD WINAPI wglSwapMultipleBuffers(UINT n, CONST WGLSWAP* ps) {
+    if (!ps) {
+        return 0;
+    }
+    DWORD swapped = 0;
+    for (UINT i = 0; i < n; ++i) {
+        if (WGL::SwapBuffers(ps[i].hdc)) {
+            ++swapped;
+        }
+    }
+    return swapped;
+}
+
+// ---- Font rendering (legacy immediate-mode feature; not supported) ----
+
+extern "C" BOOL WINAPI wglUseFontBitmapsA(HDC, DWORD, DWORD, DWORD) {
+    MGLOG_W("wglUseFontBitmapsA is not supported");
+    return FALSE;
+}
+
+extern "C" BOOL WINAPI wglUseFontBitmapsW(HDC, DWORD, DWORD, DWORD) {
+    MGLOG_W("wglUseFontBitmapsW is not supported");
+    return FALSE;
+}
+
+extern "C" BOOL WINAPI wglUseFontOutlinesA(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int,
+                                                 LPGLYPHMETRICSFLOAT) {
+    MGLOG_W("wglUseFontOutlinesA is not supported");
+    return FALSE;
+}
+
+extern "C" BOOL WINAPI wglUseFontOutlinesW(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int,
+                                                 LPGLYPHMETRICSFLOAT) {
+    MGLOG_W("wglUseFontOutlinesW is not supported");
+    return FALSE;
+}
+
+#endif // _WIN32

MobileGL/MG_Impl/WGLImpl/Exporting/wgl.def

@@ -0,0 +1,30 @@
+; MobileGL WGL exports. The wgl* entry points are defined without
+; __declspec(dllexport) because wingdi.h pre-declares them (with _GDI32_ they
+; become plain declarations, and MSVC rejects adding dllexport afterwards),
+; so this .def file is what actually exports them from the DLL.
+EXPORTS
+    wglChoosePixelFormat
+    wglCopyContext
+    wglCreateContext
+    wglCreateLayerContext
+    wglDeleteContext
+    wglDescribeLayerPlane
+    wglDescribePixelFormat
+    wglGetCurrentContext
+    wglGetCurrentDC
+    wglGetDefaultProcAddress
+    wglGetLayerPaletteEntries
+    wglGetPixelFormat
+    wglGetProcAddress
+    wglMakeCurrent
+    wglRealizeLayerPalette
+    wglSetLayerPaletteEntries
+    wglSetPixelFormat
+    wglShareLists
+    wglSwapBuffers
+    wglSwapLayerBuffers
+    wglSwapMultipleBuffers
+    wglUseFontBitmapsA
+    wglUseFontBitmapsW
+    wglUseFontOutlinesA
+    wglUseFontOutlinesW

MobileGL/MG_Impl/WGLImpl/WGLImpl.cpp

@@ -0,0 +1,732 @@
+// MobileGL - MobileGL/MG_Impl/WGLImpl/WGLImpl.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "WGLImpl.h"
+
+#if defined(_WIN32)
+#include "../EGLImpl/EGLImpl.h"
+#include "../GetProcAddress.h"
+#include <Init.h>
+
+namespace MobileGL::MG_Impl::WGLImpl {
+    namespace {
+        // WGL_ARB_pixel_format
+        constexpr int WGL_NUMBER_PIXEL_FORMATS_ARB = 0x2000;
+        constexpr int WGL_DRAW_TO_WINDOW_ARB = 0x2001;
+        constexpr int WGL_DRAW_TO_BITMAP_ARB = 0x2002;
+        constexpr int WGL_ACCELERATION_ARB = 0x2003;
+        constexpr int WGL_NEED_PALETTE_ARB = 0x2004;
+        constexpr int WGL_NEED_SYSTEM_PALETTE_ARB = 0x2005;
+        constexpr int WGL_SWAP_LAYER_BUFFERS_ARB = 0x2006;
+        constexpr int WGL_SWAP_METHOD_ARB = 0x2007;
+        constexpr int WGL_NUMBER_OVERLAYS_ARB = 0x2008;
+        constexpr int WGL_NUMBER_UNDERLAYS_ARB = 0x2009;
+        constexpr int WGL_TRANSPARENT_ARB = 0x200A;
+        constexpr int WGL_SHARE_DEPTH_ARB = 0x200C;
+        constexpr int WGL_SHARE_STENCIL_ARB = 0x200D;
+        constexpr int WGL_SHARE_ACCUM_ARB = 0x200E;
+        constexpr int WGL_SUPPORT_GDI_ARB = 0x200F;
+        constexpr int WGL_SUPPORT_OPENGL_ARB = 0x2010;
+        constexpr int WGL_DOUBLE_BUFFER_ARB = 0x2011;
+        constexpr int WGL_STEREO_ARB = 0x2012;
+        constexpr int WGL_PIXEL_TYPE_ARB = 0x2013;
+        constexpr int WGL_COLOR_BITS_ARB = 0x2014;
+        constexpr int WGL_RED_BITS_ARB = 0x2015;
+        constexpr int WGL_RED_SHIFT_ARB = 0x2016;
+        constexpr int WGL_GREEN_BITS_ARB = 0x2017;
+        constexpr int WGL_GREEN_SHIFT_ARB = 0x2018;
+        constexpr int WGL_BLUE_BITS_ARB = 0x2019;
+        constexpr int WGL_BLUE_SHIFT_ARB = 0x201A;
+        constexpr int WGL_ALPHA_BITS_ARB = 0x201B;
+        constexpr int WGL_ALPHA_SHIFT_ARB = 0x201C;
+        constexpr int WGL_ACCUM_BITS_ARB = 0x201D;
+        constexpr int WGL_ACCUM_RED_BITS_ARB = 0x201E;
+        constexpr int WGL_ACCUM_GREEN_BITS_ARB = 0x201F;
+        constexpr int WGL_ACCUM_BLUE_BITS_ARB = 0x2020;
+        constexpr int WGL_ACCUM_ALPHA_BITS_ARB = 0x2021;
+        constexpr int WGL_DEPTH_BITS_ARB = 0x2022;
+        constexpr int WGL_STENCIL_BITS_ARB = 0x2023;
+        constexpr int WGL_AUX_BUFFERS_ARB = 0x2024;
+        constexpr int WGL_NO_ACCELERATION_ARB = 0x2025;
+        constexpr int WGL_FULL_ACCELERATION_ARB = 0x2027;
+        constexpr int WGL_SWAP_EXCHANGE_ARB = 0x2028;
+        constexpr int WGL_TYPE_RGBA_ARB = 0x202B;
+        // WGL_ARB_multisample
+        constexpr int WGL_SAMPLE_BUFFERS_ARB = 0x2041;
+        constexpr int WGL_SAMPLES_ARB = 0x2042;
+        // WGL_ARB_create_context / _profile / _no_error
+        constexpr int WGL_CONTEXT_MAJOR_VERSION_ARB = 0x2091;
+        constexpr int WGL_CONTEXT_MINOR_VERSION_ARB = 0x2092;
+        constexpr int WGL_CONTEXT_LAYER_PLANE_ARB = 0x2093;
+        constexpr int WGL_CONTEXT_FLAGS_ARB = 0x2094;
+        constexpr int WGL_CONTEXT_PROFILE_MASK_ARB = 0x9126;
+        constexpr int WGL_CONTEXT_DEBUG_BIT_ARB = 0x0001;
+        constexpr int WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 0x0002;
+        constexpr int WGL_CONTEXT_CORE_PROFILE_BIT_ARB = 0x00000001;
+        constexpr int WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x00000002;
+        constexpr int WGL_CONTEXT_OPENGL_NO_ERROR_ARB = 0x31B3;
+        constexpr DWORD ERROR_INVALID_VERSION_ARB = 0x2095;
+        constexpr DWORD ERROR_INVALID_PROFILE_ARB = 0x2096;
+
+        struct PixelFormatInfo {
+            GLint AlphaBits;
+            GLint DepthBits;
+            GLint StencilBits;
+        };
+
+        // Mirrors the two EGLState configs (RGBA8 + depth24, stencil 8 / stencil 0).
+        constexpr PixelFormatInfo kPixelFormats[] = {
+            {8, 24, 8},
+            {8, 24, 0},
+        };
+        constexpr int kPixelFormatCount = static_cast<int>(std::size(kPixelFormats));
+
+        struct ContextObject {
+            EGLDisplay Display = EGL_NO_DISPLAY;
+            EGLConfig Config = nullptr;
+            EGLContext Context = EGL_NO_CONTEXT;
+        };
+
+        struct WindowSurface {
+            EGLDisplay Display = EGL_NO_DISPLAY;
+            EGLSurface Surface = EGL_NO_SURFACE;
+            Uint32 Width = 0;
+            Uint32 Height = 0;
+        };
+
+        std::recursive_mutex& RegistryMutex() {
+            static auto* mutex = new std::recursive_mutex();
+            return *mutex;
+        }
+
+        UnorderedMap<HGLRC, ContextObject>& Contexts() {
+            static auto* contexts = new UnorderedMap<HGLRC, ContextObject>();
+            return *contexts;
+        }
+
+        UnorderedMap<HWND, WindowSurface>& WindowSurfaces() {
+            static auto* surfaces = new UnorderedMap<HWND, WindowSurface>();
+            return *surfaces;
+        }
+
+        UnorderedMap<HWND, int>& WindowPixelFormats() {
+            static auto* formats = new UnorderedMap<HWND, int>();
+            return *formats;
+        }
+
+        Uint64& NextContextHandle() {
+            static auto* handle = new Uint64(0x10000);
+            return *handle;
+        }
+
+        struct ThreadCurrent {
+            HDC DC = nullptr;
+            HGLRC Context = nullptr;
+        };
+        thread_local ThreadCurrent t_current;
+
+        Int& SwapIntervalShadow() {
+            static auto* interval = new Int(1);
+            return *interval;
+        }
+
+        void EnsureInitialized() {
+            // Initialize() loads backend libraries and glslang, which must not run
+            // under the loader lock; first WGL call is the earliest safe moment.
+            // MobileGL::EnsureInitialized (not a local once_flag) so a fresh init
+            // can follow a full teardown from the last eglTerminate.
+            MobileGL::EnsureInitialized();
+        }
+
+        EGLDisplay EnsureDisplay() {
+            EnsureInitialized();
+            EGLDisplay display = EGLImpl::GetDisplay(EGL_DEFAULT_DISPLAY);
+            if (display == EGL_NO_DISPLAY) {
+                return EGL_NO_DISPLAY;
+            }
+            if (!EGLImpl::Initialize(display, nullptr, nullptr)) {
+                return EGL_NO_DISPLAY;
+            }
+            return display;
+        }
+
+        HGLRC EncodeContext(Uint64 handle) {
+            return reinterpret_cast<HGLRC>(static_cast<SizeT>(handle));
+        }
+
+        ContextObject* TryGetContext(HGLRC hglrc) {
+            auto& contexts = Contexts();
+            auto it = contexts.find(hglrc);
+            return it == contexts.end() ? nullptr : &it->second;
+        }
+
+        const PixelFormatInfo& PixelFormatForWindow(HWND hwnd) {
+            auto& formats = WindowPixelFormats();
+            auto it = formats.find(hwnd);
+            int index = it == formats.end() ? 1 : it->second;
+            if (index < 1 || index > kPixelFormatCount) {
+                index = 1;
+            }
+            return kPixelFormats[index - 1];
+        }
+
+        Bool QueryClientSize(HWND hwnd, Uint32& width, Uint32& height) {
+            RECT rect{};
+            if (!GetClientRect(hwnd, &rect)) {
+                return false;
+            }
+            width = static_cast<Uint32>(std::max<LONG>(rect.right - rect.left, 1));
+            height = static_cast<Uint32>(std::max<LONG>(rect.bottom - rect.top, 1));
+            return true;
+        }
+
+        // The backends never query the HWND client size themselves; the WGL layer
+        // owns size discovery and pushes changes through the internal resize hook
+        // (same contract as the macOS CGL layer).
+        void SyncSurfaceSize(HWND hwnd, WindowSurface& surface) {
+            Uint32 width = 0;
+            Uint32 height = 0;
+            if (!QueryClientSize(hwnd, width, height)) {
+                return;
+            }
+            if (width == surface.Width && height == surface.Height) {
+                return;
+            }
+            if (EGLImpl::ResizePlatformWindowSurface(surface.Display, surface.Surface,
+                                                     static_cast<EGLint>(width), static_cast<EGLint>(height))) {
+                surface.Width = width;
+                surface.Height = height;
+            }
+        }
+
+        WindowSurface* EnsureWindowSurface(HWND hwnd, const ContextObject& context) {
+            auto& surfaces = WindowSurfaces();
+            auto it = surfaces.find(hwnd);
+            if (it != surfaces.end()) {
+                SyncSurfaceSize(hwnd, it->second);
+                return &it->second;
+            }
+
+            Uint32 width = 0;
+            Uint32 height = 0;
+            if (!QueryClientSize(hwnd, width, height)) {
+                MGLOG_E("wgl: GetClientRect failed for HWND %p", hwnd);
+                return nullptr;
+            }
+
+            const EGLAttrib attribs[] = {
+                EGL_WIDTH, static_cast<EGLAttrib>(width),
+                EGL_HEIGHT, static_cast<EGLAttrib>(height),
+                EGL_NONE,
+            };
+            EGLSurface surface =
+                EGLImpl::CreatePlatformWindowSurface(context.Display, context.Config, hwnd, attribs);
+            if (surface == EGL_NO_SURFACE) {
+                MGLOG_E("wgl: failed to create window surface for HWND %p (%ux%u)", hwnd, width, height);
+                return nullptr;
+            }
+
+            WindowSurface record;
+            record.Display = context.Display;
+            record.Surface = surface;
+            record.Width = width;
+            record.Height = height;
+            auto [inserted, _] = surfaces.emplace(hwnd, record);
+            return &inserted->second;
+        }
+
+        HGLRC CreateContextFromEGLAttribs(HDC hdc, HGLRC share, const EGLint* contextAttribs) {
+            const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
+            EGLDisplay display = EnsureDisplay();
+            if (display == EGL_NO_DISPLAY) {
+                MGLOG_E("wgl: no EGL display");
+                return nullptr;
+            }
+            EGLImpl::BindAPI(EGL_OPENGL_API);
+
+            EGLContext shareContext = EGL_NO_CONTEXT;
+            if (share) {
+                auto* shareObject = TryGetContext(share);
+                if (!shareObject) {
+                    SetLastError(ERROR_INVALID_HANDLE);
+                    return nullptr;
+                }
+                shareContext = shareObject->Context;
+            }
+
+            HWND hwnd = WindowFromDC(hdc);
+            const PixelFormatInfo& pixelFormat = PixelFormatForWindow(hwnd);
+            const EGLint configAttribs[] = {
+                EGL_RED_SIZE, 8,
+                EGL_GREEN_SIZE, 8,
+                EGL_BLUE_SIZE, 8,
+                EGL_ALPHA_SIZE, pixelFormat.AlphaBits,
+                EGL_DEPTH_SIZE, pixelFormat.DepthBits,
+                EGL_STENCIL_SIZE, pixelFormat.StencilBits,
+                EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
+                EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
+                EGL_NONE,
+            };
+            EGLConfig config = nullptr;
+            EGLint configCount = 0;
+            if (!EGLImpl::ChooseConfig(display, configAttribs, &config, 1, &configCount) || configCount <= 0) {
+                MGLOG_E("wgl: eglChooseConfig failed");
+                return nullptr;
+            }
+
+            EGLContext eglContext = EGLImpl::CreateContext(display, config, shareContext, contextAttribs);
+            if (eglContext == EGL_NO_CONTEXT) {
+                MGLOG_E("wgl: eglCreateContext failed");
+                return nullptr;
+            }
+
+            ContextObject object;
+            object.Display = display;
+            object.Config = config;
+            object.Context = eglContext;
+            const auto handle = EncodeContext(NextContextHandle()++);
+            Contexts()[handle] = object;
+            MGLOG_I("wgl: created context %p (EGL context %p)", handle, eglContext);
+            return handle;
+        }
+
+        // ---- WGL extension entry points (resolved via wglGetProcAddress only) ----
+
+        const char* WINAPI Ext_GetExtensionsStringARB(HDC) {
+            return "WGL_ARB_create_context WGL_ARB_create_context_no_error WGL_ARB_create_context_profile "
+                   "WGL_ARB_extensions_string WGL_ARB_pixel_format WGL_EXT_extensions_string WGL_EXT_swap_control";
+        }
+
+        const char* WINAPI Ext_GetExtensionsStringEXT() {
+            return Ext_GetExtensionsStringARB(nullptr);
+        }
+
+        HGLRC WINAPI Ext_CreateContextAttribsARB(HDC hdc, HGLRC hShareContext, const int* attribList) {
+            EnsureInitialized();
+            int major = 1;
+            int minor = 0;
+            int profileMask = 0;
+            int flags = 0;
+            if (attribList) {
+                for (SizeT i = 0; attribList[i] != 0; i += 2) {
+                    const int attrib = attribList[i];
+                    const int value = attribList[i + 1];
+                    switch (attrib) {
+                    case WGL_CONTEXT_MAJOR_VERSION_ARB:
+                        major = value;
+                        break;
+                    case WGL_CONTEXT_MINOR_VERSION_ARB:
+                        minor = value;
+                        break;
+                    case WGL_CONTEXT_PROFILE_MASK_ARB:
+                        profileMask = value;
+                        break;
+                    case WGL_CONTEXT_FLAGS_ARB:
+                        flags = value;
+                        break;
+                    case WGL_CONTEXT_LAYER_PLANE_ARB:
+                        if (value != 0) {
+                            SetLastError(ERROR_INVALID_PARAMETER);
+                            return nullptr;
+                        }
+                        break;
+                    case WGL_CONTEXT_OPENGL_NO_ERROR_ARB:
+                        // Accepted and ignored: MobileGL always validates.
+                        break;
+                    default:
+                        MGLOG_D("wglCreateContextAttribsARB: ignoring attrib 0x%04x = 0x%x", attrib, value);
+                        break;
+                    }
+                }
+            }
+
+            if (major < 1 || (profileMask & ~(WGL_CONTEXT_CORE_PROFILE_BIT_ARB |
+                                              WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB))) {
+                SetLastError(profileMask ? ERROR_INVALID_PROFILE_ARB : ERROR_INVALID_VERSION_ARB);
+                return nullptr;
+            }
+
+            Vector<EGLint> attribs = {
+                EGL_CONTEXT_MAJOR_VERSION, major,
+                EGL_CONTEXT_MINOR_VERSION, minor,
+            };
+            const Bool wantsCompat = (profileMask & WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB) != 0;
+            if (major > 3 || (major == 3 && minor >= 2) || profileMask != 0) {
+                attribs.push_back(EGL_CONTEXT_OPENGL_PROFILE_MASK);
+                attribs.push_back(wantsCompat ? EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT
+                                              : EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT);
+            }
+            if (flags & WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB) {
+                attribs.push_back(EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE);
+                attribs.push_back(EGL_TRUE);
+            }
+            if (flags & WGL_CONTEXT_DEBUG_BIT_ARB) {
+                attribs.push_back(EGL_CONTEXT_OPENGL_DEBUG);
+                attribs.push_back(EGL_TRUE);
+            }
+            attribs.push_back(EGL_NONE);
+
+            return CreateContextFromEGLAttribs(hdc, hShareContext, attribs.data());
+        }
+
+        BOOL WINAPI Ext_SwapIntervalEXT(int interval) {
+            const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
+            EGLDisplay display = EnsureDisplay();
+            if (display == EGL_NO_DISPLAY) {
+                return FALSE;
+            }
+            if (interval < 0) {
+                // Adaptive vsync is not supported; clamp to regular vsync.
+                interval = 1;
+            }
+            EGLImpl::SwapInterval(display, interval);
+            SwapIntervalShadow() = interval;
+            return TRUE;
+        }
+
+        int WINAPI Ext_GetSwapIntervalEXT() {
+            const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
+            return SwapIntervalShadow();
+        }
+
+        int PixelFormatAttribValue(int format, int attrib) {
+            const PixelFormatInfo& info = kPixelFormats[format - 1];
+            switch (attrib) {
+            case WGL_NUMBER_PIXEL_FORMATS_ARB:
+                return kPixelFormatCount;
+            case WGL_SUPPORT_OPENGL_ARB:
+            case WGL_DRAW_TO_WINDOW_ARB:
+            case WGL_DOUBLE_BUFFER_ARB:
+                return 1;
+            case WGL_ACCELERATION_ARB:
+                return WGL_FULL_ACCELERATION_ARB;
+            case WGL_PIXEL_TYPE_ARB:
+                return WGL_TYPE_RGBA_ARB;
+            case WGL_COLOR_BITS_ARB:
+                return 32;
+            case WGL_RED_BITS_ARB:
+            case WGL_GREEN_BITS_ARB:
+            case WGL_BLUE_BITS_ARB:
+                return 8;
+            case WGL_RED_SHIFT_ARB:
+                return 16;
+            case WGL_GREEN_SHIFT_ARB:
+                return 8;
+            case WGL_BLUE_SHIFT_ARB:
+                return 0;
+            case WGL_ALPHA_BITS_ARB:
+                return info.AlphaBits;
+            case WGL_ALPHA_SHIFT_ARB:
+                return 24;
+            case WGL_DEPTH_BITS_ARB:
+                return info.DepthBits;
+            case WGL_STENCIL_BITS_ARB:
+                return info.StencilBits;
+            case WGL_SWAP_METHOD_ARB:
+                return WGL_SWAP_EXCHANGE_ARB;
+            case WGL_DRAW_TO_BITMAP_ARB:
+            case WGL_NEED_PALETTE_ARB:
+            case WGL_NEED_SYSTEM_PALETTE_ARB:
+            case WGL_SWAP_LAYER_BUFFERS_ARB:
+            case WGL_NUMBER_OVERLAYS_ARB:
+            case WGL_NUMBER_UNDERLAYS_ARB:
+            case WGL_TRANSPARENT_ARB:
+            case WGL_SHARE_DEPTH_ARB:
+            case WGL_SHARE_STENCIL_ARB:
+            case WGL_SHARE_ACCUM_ARB:
+            case WGL_SUPPORT_GDI_ARB:
+            case WGL_STEREO_ARB:
+            case WGL_ACCUM_BITS_ARB:
+            case WGL_ACCUM_RED_BITS_ARB:
+            case WGL_ACCUM_GREEN_BITS_ARB:
+            case WGL_ACCUM_BLUE_BITS_ARB:
+            case WGL_ACCUM_ALPHA_BITS_ARB:
+            case WGL_AUX_BUFFERS_ARB:
+            case WGL_SAMPLE_BUFFERS_ARB:
+            case WGL_SAMPLES_ARB:
+            default:
+                return 0;
+            }
+        }
+
+        BOOL WINAPI Ext_GetPixelFormatAttribivARB(HDC, int iPixelFormat, int iLayerPlane, UINT nAttributes,
+                                                  const int* piAttributes, int* piValues) {
+            if (iLayerPlane != 0 || !piAttributes || !piValues) {
+                return FALSE;
+            }
+            // Format 0 is only valid for WGL_NUMBER_PIXEL_FORMATS_ARB queries.
+            if (iPixelFormat < 0 || iPixelFormat > kPixelFormatCount) {
+                return FALSE;
+            }
+            const int format = iPixelFormat == 0 ? 1 : iPixelFormat;
+            for (UINT i = 0; i < nAttributes; ++i) {
+                piValues[i] = PixelFormatAttribValue(format, piAttributes[i]);
+            }
+            return TRUE;
+        }
+
+        BOOL WINAPI Ext_GetPixelFormatAttribfvARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes,
+                                                  const int* piAttributes, FLOAT* pfValues) {
+            if (!pfValues) {
+                return FALSE;
+            }
+            Vector<int> values(nAttributes);
+            if (!Ext_GetPixelFormatAttribivARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes,
+                                               values.data())) {
+                return FALSE;
+            }
+            for (UINT i = 0; i < nAttributes; ++i) {
+                pfValues[i] = static_cast<FLOAT>(values[i]);
+            }
+            return TRUE;
+        }
+
+        BOOL WINAPI Ext_ChoosePixelFormatARB(HDC, const int* piAttribIList, const FLOAT*, UINT nMaxFormats,
+                                             int* piFormats, UINT* nNumFormats) {
+            if (!piFormats || !nNumFormats) {
+                return FALSE;
+            }
+            int wantedStencil = 0;
+            if (piAttribIList) {
+                for (SizeT i = 0; piAttribIList[i] != 0; i += 2) {
+                    if (piAttribIList[i] == WGL_STENCIL_BITS_ARB) {
+                        wantedStencil = piAttribIList[i + 1];
+                    }
+                }
+            }
+            UINT count = 0;
+            const int preferred = wantedStencil > 0 ? 1 : 2;
+            const int fallback = wantedStencil > 0 ? 2 : 1;
+            if (count < nMaxFormats) {
+                piFormats[count++] = preferred;
+            }
+            if (count < nMaxFormats) {
+                piFormats[count++] = fallback;
+            }
+            *nNumFormats = count;
+            return TRUE;
+        }
+
+        struct WGLExtensionProc {
+            const char* Name;
+            PROC Proc;
+        };
+
+        const WGLExtensionProc kWGLExtensionProcs[] = {
+            {"wglGetExtensionsStringARB", reinterpret_cast<PROC>(Ext_GetExtensionsStringARB)},
+            {"wglGetExtensionsStringEXT", reinterpret_cast<PROC>(Ext_GetExtensionsStringEXT)},
+            {"wglCreateContextAttribsARB", reinterpret_cast<PROC>(Ext_CreateContextAttribsARB)},
+            {"wglSwapIntervalEXT", reinterpret_cast<PROC>(Ext_SwapIntervalEXT)},
+            {"wglGetSwapIntervalEXT", reinterpret_cast<PROC>(Ext_GetSwapIntervalEXT)},
+            {"wglGetPixelFormatAttribivARB", reinterpret_cast<PROC>(Ext_GetPixelFormatAttribivARB)},
+            {"wglGetPixelFormatAttribfvARB", reinterpret_cast<PROC>(Ext_GetPixelFormatAttribfvARB)},
+            {"wglChoosePixelFormatARB", reinterpret_cast<PROC>(Ext_ChoosePixelFormatARB)},
+        };
+    } // namespace
+
+    int ChoosePixelFormat(HDC hdc, const PIXELFORMATDESCRIPTOR* pfd) {
+        EnsureInitialized();
+        MGLOG_D("wglChoosePixelFormat(hdc=%p)", hdc);
+        // Format 1 (RGBA8 + depth24/stencil8) satisfies every request; a format
+        // exceeding the asked-for capabilities is a legal ChoosePixelFormat answer.
+        (void)pfd;
+        return 1;
+    }
+
+    int DescribePixelFormat(HDC hdc, int format, UINT size, PIXELFORMATDESCRIPTOR* pfd) {
+        EnsureInitialized();
+        MGLOG_D("wglDescribePixelFormat(hdc=%p, format=%d)", hdc, format);
+        if (!pfd) {
+            return kPixelFormatCount;
+        }
+        if (size < sizeof(PIXELFORMATDESCRIPTOR) || format < 1 || format > kPixelFormatCount) {
+            return 0;
+        }
+
+        const PixelFormatInfo& info = kPixelFormats[format - 1];
+        std::memset(pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
+        pfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
+        pfd->nVersion = 1;
+        pfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_SWAP_EXCHANGE
+#if defined(PFD_SUPPORT_COMPOSITION)
+                       | PFD_SUPPORT_COMPOSITION
+#endif
+            ;
+        pfd->iPixelType = PFD_TYPE_RGBA;
+        pfd->cColorBits = 32;
+        pfd->cRedBits = 8;
+        pfd->cRedShift = 16;
+        pfd->cGreenBits = 8;
+        pfd->cGreenShift = 8;
+        pfd->cBlueBits = 8;
+        pfd->cBlueShift = 0;
+        pfd->cAlphaBits = static_cast<BYTE>(info.AlphaBits);
+        pfd->cAlphaShift = 24;
+        pfd->cDepthBits = static_cast<BYTE>(info.DepthBits);
+        pfd->cStencilBits = static_cast<BYTE>(info.StencilBits);
+        pfd->iLayerType = PFD_MAIN_PLANE;
+        return kPixelFormatCount;
+    }
+
+    int GetPixelFormat(HDC hdc) {
+        EnsureInitialized();
+        HWND hwnd = WindowFromDC(hdc);
+        if (!hwnd) {
+            return 0;
+        }
+        const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
+        auto& formats = WindowPixelFormats();
+        auto it = formats.find(hwnd);
+        return it == formats.end() ? 0 : it->second;
+    }
+
+    BOOL SetPixelFormat(HDC hdc, int format, const PIXELFORMATDESCRIPTOR*) {
+        EnsureInitialized();
+        MGLOG_D("wglSetPixelFormat(hdc=%p, format=%d)", hdc, format);
+        if (format < 1 || format > kPixelFormatCount) {
+            SetLastError(ERROR_INVALID_PARAMETER);
+            return FALSE;
+        }
+        HWND hwnd = WindowFromDC(hdc);
+        if (!hwnd) {
+            SetLastError(ERROR_INVALID_HANDLE);
+            return FALSE;
+        }
+        const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
+        WindowPixelFormats()[hwnd] = format;
+        return TRUE;
+    }
+
+    BOOL SwapBuffers(HDC hdc) {
+        HWND hwnd = WindowFromDC(hdc);
+        if (!hwnd) {
+            SetLastError(ERROR_INVALID_HANDLE);
+            return FALSE;
+        }
+        const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
+        auto& surfaces = WindowSurfaces();
+        auto it = surfaces.find(hwnd);
+        if (it == surfaces.end()) {
+            MGLOG_W("wglSwapBuffers: no surface for HWND %p", hwnd);
+            return FALSE;
+        }
+        SyncSurfaceSize(hwnd, it->second);
+        return EGLImpl::SwapBuffers(it->second.Display, it->second.Surface) == EGL_TRUE ? TRUE : FALSE;
+    }
+
+    HGLRC CreateContext(HDC hdc) {
+        EnsureInitialized();
+        MGLOG_I("wglCreateContext(hdc=%p)", hdc);
+        // A legacy WGL context is a compatibility-profile context; MobileGL keys
+        // its relaxed-semantics mode off the explicit compatibility bit.
+        const EGLint attribs[] = {
+            EGL_CONTEXT_MAJOR_VERSION, 3,
+            EGL_CONTEXT_MINOR_VERSION, 3,
+            EGL_CONTEXT_OPENGL_PROFILE_MASK, EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT,
+            EGL_NONE,
+        };
+        return CreateContextFromEGLAttribs(hdc, nullptr, attribs);
+    }
+
+    BOOL DeleteContext(HGLRC hglrc) {
+        EnsureInitialized();
+        MGLOG_I("wglDeleteContext(%p)", hglrc);
+        if (t_current.Context == hglrc) {
+            MakeCurrent(nullptr, nullptr);
+        }
+        const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
+        auto* object = TryGetContext(hglrc);
+        if (!object) {
+            SetLastError(ERROR_INVALID_HANDLE);
+            return FALSE;
+        }
+        if (object->Context != EGL_NO_CONTEXT) {
+            EGLImpl::DestroyContext(object->Display, object->Context);
+        }
+        Contexts().erase(hglrc);
+        return TRUE;
+    }
+
+    BOOL MakeCurrent(HDC hdc, HGLRC hglrc) {
+        EnsureInitialized();
+        MGLOG_D("wglMakeCurrent(hdc=%p, hglrc=%p)", hdc, hglrc);
+        if (!hglrc) {
+            if (!t_current.Context) {
+                t_current = {};
+                return TRUE;
+            }
+            const EGLBoolean released =
+                EGLImpl::MakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+            t_current = {};
+            return released == EGL_TRUE ? TRUE : FALSE;
+        }
+
+        HWND hwnd = WindowFromDC(hdc);
+        if (!hwnd) {
+            SetLastError(ERROR_INVALID_HANDLE);
+            return FALSE;
+        }
+
+        const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
+        auto* object = TryGetContext(hglrc);
+        if (!object) {
+            SetLastError(ERROR_INVALID_HANDLE);
+            return FALSE;
+        }
+
+        WindowSurface* surface = EnsureWindowSurface(hwnd, *object);
+        if (!surface) {
+            return FALSE;
+        }
+
+        if (!EGLImpl::MakeCurrent(object->Display, surface->Surface, surface->Surface, object->Context)) {
+            MGLOG_E("wglMakeCurrent: eglMakeCurrent failed (hdc=%p, hglrc=%p)", hdc, hglrc);
+            return FALSE;
+        }
+        t_current = {hdc, hglrc};
+        return TRUE;
+    }
+
+    HGLRC GetCurrentContext() {
+        return t_current.Context;
+    }
+
+    HDC GetCurrentDC() {
+        return t_current.DC;
+    }
+
+    BOOL ShareLists(HGLRC hglrcShare, HGLRC hglrcDest) {
+        // All MobileGL contexts alias one global GL object namespace, so every
+        // pair of contexts already shares.
+        const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
+        if (!TryGetContext(hglrcShare) || !TryGetContext(hglrcDest)) {
+            SetLastError(ERROR_INVALID_HANDLE);
+            return FALSE;
+        }
+        return TRUE;
+    }
+
+    PROC GetProcAddress(const char* name) {
+        EnsureInitialized();
+        if (!name) {
+            return nullptr;
+        }
+        if (name[0] == 'w' && name[1] == 'g' && name[2] == 'l') {
+            for (const auto& entry : kWGLExtensionProcs) {
+                if (std::strcmp(entry.Name, name) == 0) {
+                    return entry.Proc;
+                }
+            }
+            MGLOG_D("wglGetProcAddress: unknown wgl entry point %s", name);
+            return nullptr;
+        }
+        return reinterpret_cast<PROC>(MG_Impl::GetProcAddress(name));
+    }
+} // namespace MobileGL::MG_Impl::WGLImpl
+
+#endif // _WIN32

MobileGL/MG_Impl/WGLImpl/WGLImpl.h

@@ -0,0 +1,34 @@
+// MobileGL - MobileGL/MG_Impl/WGLImpl/WGLImpl.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include <Includes.h>
+
+#if defined(_WIN32)
+
+namespace MobileGL::MG_Impl::WGLImpl {
+    // Classic opengl32.dll surface. gdi32's ChoosePixelFormat/SetPixelFormat/
+    // DescribePixelFormat/GetPixelFormat/SwapBuffers forward into the loaded
+    // opengl32.dll's wgl* exports, so these back both call paths.
+    int ChoosePixelFormat(HDC hdc, const PIXELFORMATDESCRIPTOR* pfd);
+    int DescribePixelFormat(HDC hdc, int format, UINT size, PIXELFORMATDESCRIPTOR* pfd);
+    int GetPixelFormat(HDC hdc);
+    BOOL SetPixelFormat(HDC hdc, int format, const PIXELFORMATDESCRIPTOR* pfd);
+    BOOL SwapBuffers(HDC hdc);
+
+    HGLRC CreateContext(HDC hdc);
+    BOOL DeleteContext(HGLRC hglrc);
+    BOOL MakeCurrent(HDC hdc, HGLRC hglrc);
+    HGLRC GetCurrentContext();
+    HDC GetCurrentDC();
+    BOOL ShareLists(HGLRC hglrcShare, HGLRC hglrcDest);
+
+    PROC GetProcAddress(const char* name);
+} // namespace MobileGL::MG_Impl::WGLImpl
+
+#endif // _WIN32

MobileGL/MG_State/EGLState/Core.cpp

@@ -368,6 +368,26 @@ namespace MobileGL {
                 return true;
             }
 
+            Bool EGLContext::HasAnyInitializedDisplay() const {
+                const std::lock_guard<std::recursive_mutex> lock(m_mutex);
+                for (const auto& [handle, displayObject] : m_displays) {
+                    if (displayObject.Initialized) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            Bool EGLContext::HasAnyCurrentContext() const {
+                const std::lock_guard<std::recursive_mutex> lock(m_mutex);
+                for (const auto& [threadId, current] : m_threadCurrents) {
+                    if (current.Context != nullptr) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
             Bool EGLContext::ChooseConfig(EGLDisplayHandle display, const EGLint* attribList, EGLConfigHandle* configs,
                                           EGLint configSize, EGLint* numConfig) {
                 const std::lock_guard<std::recursive_mutex> lock(m_mutex);
@@ -1415,6 +1435,7 @@ namespace MobileGL {
             }
         } // namespace EGLState
 
-        UniquePtr<EGLState::EGLContext> pEGLContext;
+        // Leak-at-exit storage; see GlobalObjects.cpp.
+        UniquePtr<EGLState::EGLContext>& pEGLContext = *new UniquePtr<EGLState::EGLContext>();
     } // namespace MG_State
 } // namespace MobileGL

MobileGL/MG_State/EGLState/Core.h

@@ -39,6 +39,10 @@ namespace MobileGL {
                 Bool IsDisplayInitialized(EGLDisplayHandle display) const;
                 Bool InitializeDisplay(EGLDisplayHandle display, EGLint* major, EGLint* minor);
                 Bool TerminateDisplay(EGLDisplayHandle display);
+                // Whole-library idle checks used by EGLImpl::Terminate to decide
+                // when the last eglTerminate may tear MobileGL down entirely.
+                Bool HasAnyInitializedDisplay() const;
+                Bool HasAnyCurrentContext() const;
 
                 // Config
                 Bool ChooseConfig(EGLDisplayHandle display, const EGLint* attribList, EGLConfigHandle* configs,
@@ -262,6 +266,6 @@ namespace MobileGL {
             };
         } // namespace EGLState
 
-        extern UniquePtr<EGLState::EGLContext> pEGLContext;
+        extern UniquePtr<EGLState::EGLContext>& pEGLContext;
     } // namespace MG_State
 } // namespace MobileGL

MobileGL/MG_State/GLState/Core.cpp

@@ -721,5 +721,6 @@ namespace MobileGL::MG_State {
         }
     } // namespace GLState
 
-    UniquePtr<GLState::GLContext> pGLContext;
+    // Leak-at-exit storage; see GlobalObjects.cpp.
+    UniquePtr<GLState::GLContext>& pGLContext = *new UniquePtr<GLState::GLContext>();
 } // namespace MobileGL::MG_State

MobileGL/MG_State/GLState/Core.h

@@ -252,7 +252,7 @@ namespace MobileGL {
             };
         } // namespace GLState
 
-        extern UniquePtr<GLState::GLContext> pGLContext;
+        extern UniquePtr<GLState::GLContext>& pGLContext;
 
         // True when relaxed GL semantics apply. Strict core rules are enforced only when the
         // current EGL context explicitly requested a core profile (core bit in

MobileGL/MG_State/GLState/TextureState/MipmapStorage.cpp

@@ -16,17 +16,32 @@ namespace MobileGL {
             }
 
             void MipmapStorage::AllocateLevel(Uint level, MipmapInput input) {
-                m_data.reserve(std::bit_ceil(level + 1));
-                m_data.resize(level + 1);
-                m_texelSizes.reserve(std::bit_ceil(level + 1));
-                m_texelSizes.resize(level + 1);
-                m_texelSizes[level] = input.texelSize;
-                m_isDirty.resize(level + 1, false);
+                // Grow only. GL respecifies exactly the level it is handed, so allocating level 0
+                // must not disturb the levels above it - but resize() shrinks as readily as it
+                // grows, so this used to truncate the whole chain to a single level. Callers that
+                // genuinely redefine the complete level set say so with TruncateToLevelCount.
+                const SizeT requiredLevelCount = static_cast<SizeT>(level) + 1;
+                if (m_data.size() < requiredLevelCount) {
+                    m_data.reserve(std::bit_ceil(requiredLevelCount));
+                    m_data.resize(requiredLevelCount);
+                    m_texelSizes.reserve(std::bit_ceil(requiredLevelCount));
+                    m_texelSizes.resize(requiredLevelCount);
+                    m_isDirty.resize(requiredLevelCount, false);
+                }
 
+                m_texelSizes[level] = input.texelSize;
                 auto& data = m_data[level];
                 data.resize(input.byteSize, 0);
             }
 
+            void MipmapStorage::TruncateToLevelCount(SizeT levelCount) {
+                if (levelCount >= m_data.size()) return;
+
+                m_data.resize(levelCount);
+                m_texelSizes.resize(levelCount);
+                m_isDirty.resize(levelCount);
+            }
+
             void MipmapStorage::UpdateSubData(Uint level, DataPtr input) {
                 auto& targetData = m_data;
                 MOBILEGL_ASSERT(level < targetData.size(), "UpdateSubData: level out of range");
@@ -55,6 +70,7 @@ namespace MobileGL {
             }
 
             SizeT MipmapStorage::GetByteSize(Uint level) const {
+                if (level >= m_data.size()) return 0;
                 return m_data[level].size();
             }
 

MobileGL/MG_State/GLState/TextureState/MipmapStorage.h

@@ -19,6 +19,10 @@ namespace MobileGL {
             public:
                 SizeT GetLevelCount() const;
                 void AllocateLevel(Uint level, MipmapInput input);
+                // Discard every level at or above levelCount. AllocateLevel never shrinks, so this
+                // is the only way a chain gets shorter - use it where the caller defines the whole
+                // level set (glTexStorage*, mip regeneration, atlas respecification).
+                void TruncateToLevelCount(SizeT levelCount);
                 void UpdateSubData(Uint level, DataPtr input);
                 void* MapData(Uint level);
                 IntVec3 GetTexelSize(Uint level) const;

MobileGL/MG_State/GLState/TextureState/MipmapUploadTargetArray.h

@@ -29,6 +29,14 @@ namespace MobileGL {
                     m_storage[targetIndex].AllocateLevel(level, input);
                 }
 
+                // Per-target, like AllocateLevel: cube-map faces are respecified independently, so
+                // truncating one face must not disturb the others.
+                void TruncateToLevelCount(Uint targetIndex, SizeT levelCount) {
+                    MOBILEGL_ASSERT(targetIndex < TargetCount, "TruncateToLevelCount: target invalid");
+
+                    m_storage[targetIndex].TruncateToLevelCount(levelCount);
+                }
+
                 void UpdateSubData(Uint targetIndex, Uint level, DataPtr input) {
                     MOBILEGL_ASSERT(targetIndex < TargetCount, "UpdateSubData: target invalid");
                     m_storage[targetIndex].UpdateSubData(level, input);

MobileGL/MG_State/GLState/TextureState/TextureObject.cpp

@@ -271,6 +271,10 @@ namespace MobileGL {
                 m_textureStorage.AllocateLevel(GetIndexOfTextureUploadTarget(uploadTarget), mipmapLevel, input);
             }
 
+            void TextureObjectWithOneMipmap::TruncateMipmapLevels(TextureUploadTarget uploadTarget, Uint levelCount) {
+                m_textureStorage.TruncateToLevelCount(GetIndexOfTextureUploadTarget(uploadTarget), levelCount);
+            }
+
             void TextureObjectWithOneMipmap::UpdateMipmapSubData(TextureUploadTarget uploadTarget, Uint mipmapLevel,
                                                                  DataPtr input) {
                 m_textureStorage.UpdateSubData(GetIndexOfTextureUploadTarget(uploadTarget), mipmapLevel, input);

MobileGL/MG_State/GLState/TextureState/TextureObject.h

@@ -134,6 +134,10 @@ namespace MobileGL::MG_State::GLState {
         virtual const IntVec3 GetMipmapTexelSize(TextureUploadTarget target, Uint mipmapLevel) const = 0;
         virtual const SizeT GetMipmapByteSize(TextureUploadTarget target, Uint mipmapLevel) const = 0;
         virtual void AllocateStorage(TextureUploadTarget uploadTarget, Uint mipmapLevel, MipmapInput input) = 0;
+        // AllocateStorage only ever grows the chain. Callers that define the complete level set -
+        // glTexStorage*, mip regeneration, or a level-0 respecification at a new size - drop the
+        // leftovers explicitly, so a stale tail can never make the texture silently incomplete.
+        virtual void TruncateMipmapLevels(TextureUploadTarget uploadTarget, Uint levelCount) = 0;
         virtual void UpdateMipmapSubData(TextureUploadTarget uploadTarget, Uint mipmapLevel, DataPtr input) = 0;
         virtual void* MapMipmapData(TextureUploadTarget uploadTarget, Uint mipmapLevel) = 0;
         virtual void MarkStorageDirty(TextureUploadTarget uploadTarget, Uint mipmapLevel, Bool dirty = true) = 0;
@@ -175,6 +179,7 @@ namespace MobileGL::MG_State::GLState {
         const IntVec3 GetMipmapTexelSize(TextureUploadTarget target, Uint mipmapLevel) const override;
         const SizeT GetMipmapByteSize(TextureUploadTarget target, Uint mipmapLevel) const override;
         void AllocateStorage(TextureUploadTarget uploadTarget, Uint mipmapLevel, MipmapInput input) override;
+        void TruncateMipmapLevels(TextureUploadTarget uploadTarget, Uint levelCount) override;
         void UpdateMipmapSubData(TextureUploadTarget uploadTarget, Uint mipmapLevel, DataPtr input) override;
         void* MapMipmapData(TextureUploadTarget uploadTarget, Uint mipmapLevel) override;
         void MarkStorageDirty(TextureUploadTarget uploadTarget, Uint mipmapLevel, Bool dirty) override;

MobileGL/MG_State/GLState/TextureState/TextureObject2DCube.cpp

@@ -31,6 +31,10 @@ namespace MobileGL {
                 m_textureStorage.AllocateLevel(GetIndexOfTextureUploadTarget(uploadTarget), mipmapLevel, input);
             }
 
+            void TextureObject2DCube::TruncateMipmapLevels(TextureUploadTarget uploadTarget, Uint levelCount) {
+                m_textureStorage.TruncateToLevelCount(GetIndexOfTextureUploadTarget(uploadTarget), levelCount);
+            }
+
             void TextureObject2DCube::UpdateMipmapSubData(TextureUploadTarget uploadTarget, Uint mipmapLevel,
                                                           DataPtr input) {
                 m_textureStorage.UpdateSubData(GetIndexOfTextureUploadTarget(uploadTarget), mipmapLevel, input);

MobileGL/MG_State/GLState/TextureState/TextureObject2DCube.h

@@ -22,6 +22,7 @@ namespace MobileGL {
                 const IntVec3 GetMipmapTexelSize(TextureUploadTarget target, Uint mipmapLevel) const override;
                 const SizeT GetMipmapByteSize(TextureUploadTarget target, Uint mipmapLevel) const override;
                 void AllocateStorage(TextureUploadTarget uploadTarget, Uint mipmapLevel, MipmapInput input) override;
+                void TruncateMipmapLevels(TextureUploadTarget uploadTarget, Uint levelCount) override;
                 void UpdateMipmapSubData(TextureUploadTarget uploadTarget, Uint mipmapLevel, DataPtr input) override;
                 void* MapMipmapData(TextureUploadTarget uploadTarget, Uint mipmapLevel) override;
                 void MarkStorageDirty(TextureUploadTarget uploadTarget, Uint mipmapLevel, bool dirty) override;

MobileGL/MG_Test/CMakeLists.txt

@@ -72,6 +72,8 @@ add_subdirectory(Texture)
 add_subdirectory(VertexArray)
 add_subdirectory(Program)
 add_subdirectory(Query)
+add_subdirectory(Pipeline)
+add_subdirectory(ShaderTranspiler)
 if (ENABLE_INTEGRATION_TESTS)
     add_subdirectory(Backend/DirectVulkan)
 endif()

MobileGL/MG_Test/Pipeline/CMakeLists.txt

@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.14)
+
+add_executable(
+        PipelineQuirkTest
+        PipelineQuirkTest.cpp
+)
+
+target_include_directories(PipelineQuirkTest PRIVATE
+        ${MGL_ROOT}/include
+        ${MGL_ROOT}/MobileGL
+        ${MGL_ROOT}/3rdparty/xxHash
+        ${MGL_ROOT}/3rdparty/Vulkan-Headers/include
+        ${MGL_ROOT}/3rdparty/SPIRV-Reflect
+)
+
+target_link_libraries(
+        PipelineQuirkTest PRIVATE
+        GTest::gtest_main
+        ${LINK_LIBRARIES}
+)
+
+if (MSVC)
+        target_compile_options(PipelineQuirkTest PRIVATE /Zc:preprocessor)
+endif()
+
+include(GoogleTest)
+gtest_discover_tests(PipelineQuirkTest DISCOVERY_TIMEOUT 30 PROPERTIES LABELS unit)

MobileGL/MG_Test/Pipeline/PipelineQuirkTest.cpp

@@ -0,0 +1,459 @@
+// MobileGL - MobileGL/MG_Test/Pipeline/PipelineQuirkTest.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include <gtest/gtest.h>
+
+#include <Config.h>
+#include <MG_Backend/DirectVulkan/Renderer/PipelineFactory.h>
+#include <MG_Backend/DirectVulkan/Renderer/ProgramFactory.h>
+
+using namespace MobileGL;
+using MobileGL::MG_Backend::DirectVulkan::PipelineFactory;
+using MobileGL::MG_Backend::DirectVulkan::ProgramFactory;
+using MobileGL::MG_Config::QuirkOverride;
+
+namespace {
+    constexpr Uint32 kVendorIdQualcomm = 0x5143;
+    constexpr Uint32 kVendorIdArm = 0x13B5;
+
+    constexpr VkColorComponentFlags kFullColorWriteMask =
+        VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+        VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+
+    // Builds non-separate blend state: the alpha channel repeats the color factors/op, which
+    // is what glBlendFunc/glBlendEquation (as opposed to their *Separate forms) produce.
+    // ShouldSuppressDepthWrite deliberately decides on the color channel alone, so these
+    // cases cover its whole input space; SeparateAlphaAccumulationIsNotStripped below pins
+    // the separate-alpha contract.
+    VkPipelineColorBlendAttachmentState MakeBlendAttachment(Bool blendEnable,
+                                                            VkBlendFactor srcColor,
+                                                            VkBlendFactor dstColor,
+                                                            VkBlendOp colorOp,
+                                                            VkColorComponentFlags colorWriteMask) {
+        VkPipelineColorBlendAttachmentState attachment{};
+        attachment.blendEnable = blendEnable ? VK_TRUE : VK_FALSE;
+        attachment.srcColorBlendFactor = srcColor;
+        attachment.dstColorBlendFactor = dstColor;
+        attachment.colorBlendOp = colorOp;
+        attachment.srcAlphaBlendFactor = srcColor;
+        attachment.dstAlphaBlendFactor = dstColor;
+        attachment.alphaBlendOp = colorOp;
+        attachment.colorWriteMask = colorWriteMask;
+        return attachment;
+    }
+
+    // glslangValidator -V output for:
+    //   #version 450
+    //   layout(location = 0) out vec4 outColor;
+    //   void main() { outColor = vec4(1.0); gl_FragDepth = 0.5; }
+    // Assigning gl_FragDepth makes glslang emit OpExecutionMode ... DepthReplacing.
+    constexpr Uint32 kFragDepthWriterSpirv[] = {
+        0x07230203u, 0x00010000u, 0x0008000bu, 0x0000000fu, 0x00000000u, 0x00020011u,
+        0x00000001u, 0x0006000bu, 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu,
+        0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, 0x0007000fu, 0x00000004u,
+        0x00000004u, 0x6e69616du, 0x00000000u, 0x00000009u, 0x0000000du, 0x00030010u,
+        0x00000004u, 0x00000007u, 0x00030010u, 0x00000004u, 0x0000000cu, 0x00030003u,
+        0x00000002u, 0x000001c2u, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u,
+        0x00050005u, 0x00000009u, 0x4374756fu, 0x726f6c6fu, 0x00000000u, 0x00060005u,
+        0x0000000du, 0x465f6c67u, 0x44676172u, 0x68747065u, 0x00000000u, 0x00040047u,
+        0x00000009u, 0x0000001eu, 0x00000000u, 0x00040047u, 0x0000000du, 0x0000000bu,
+        0x00000016u, 0x00020013u, 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u,
+        0x00030016u, 0x00000006u, 0x00000020u, 0x00040017u, 0x00000007u, 0x00000006u,
+        0x00000004u, 0x00040020u, 0x00000008u, 0x00000003u, 0x00000007u, 0x0004003bu,
+        0x00000008u, 0x00000009u, 0x00000003u, 0x0004002bu, 0x00000006u, 0x0000000au,
+        0x3f800000u, 0x0007002cu, 0x00000007u, 0x0000000bu, 0x0000000au, 0x0000000au,
+        0x0000000au, 0x0000000au, 0x00040020u, 0x0000000cu, 0x00000003u, 0x00000006u,
+        0x0004003bu, 0x0000000cu, 0x0000000du, 0x00000003u, 0x0004002bu, 0x00000006u,
+        0x0000000eu, 0x3f000000u, 0x00050036u, 0x00000002u, 0x00000004u, 0x00000000u,
+        0x00000003u, 0x000200f8u, 0x00000005u, 0x0003003eu, 0x00000009u, 0x0000000bu,
+        0x0003003eu, 0x0000000du, 0x0000000eu, 0x000100fdu, 0x00010038u,
+    };
+
+    // Same shader without the gl_FragDepth assignment.
+    constexpr Uint32 kPlainFragmentSpirv[] = {
+        0x07230203u, 0x00010000u, 0x0008000bu, 0x0000000cu, 0x00000000u, 0x00020011u,
+        0x00000001u, 0x0006000bu, 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu,
+        0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, 0x0006000fu, 0x00000004u,
+        0x00000004u, 0x6e69616du, 0x00000000u, 0x00000009u, 0x00030010u, 0x00000004u,
+        0x00000007u, 0x00030003u, 0x00000002u, 0x000001c2u, 0x00040005u, 0x00000004u,
+        0x6e69616du, 0x00000000u, 0x00050005u, 0x00000009u, 0x4374756fu, 0x726f6c6fu,
+        0x00000000u, 0x00040047u, 0x00000009u, 0x0000001eu, 0x00000000u, 0x00020013u,
+        0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, 0x00030016u, 0x00000006u,
+        0x00000020u, 0x00040017u, 0x00000007u, 0x00000006u, 0x00000004u, 0x00040020u,
+        0x00000008u, 0x00000003u, 0x00000007u, 0x0004003bu, 0x00000008u, 0x00000009u,
+        0x00000003u, 0x0004002bu, 0x00000006u, 0x0000000au, 0x3f800000u, 0x0007002cu,
+        0x00000007u, 0x0000000bu, 0x0000000au, 0x0000000au, 0x0000000au, 0x0000000au,
+        0x00050036u, 0x00000002u, 0x00000004u, 0x00000000u, 0x00000003u, 0x000200f8u,
+        0x00000005u, 0x0003003eu, 0x00000009u, 0x0000000bu, 0x000100fdu, 0x00010038u,
+    };
+
+
+    // glslangValidator -V output for a vertex shader reading gl_InstanceIndex:
+    //   #version 450
+    //   layout(location = 0) in vec4 inPos;
+    //   void main() { gl_Position = inPos + vec4(float(gl_InstanceIndex)); }
+    constexpr Uint32 kInstanceIndexVertexSpirv[] = {
+        0x07230203u, 0x00010000u, 0x0008000bu, 0x0000001bu, 0x00000000u, 0x00020011u,
+        0x00000001u, 0x0006000bu, 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu,
+        0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, 0x0008000fu, 0x00000000u,
+        0x00000004u, 0x6e69616du, 0x00000000u, 0x0000000du, 0x00000011u, 0x00000014u,
+        0x00030003u, 0x00000002u, 0x000001c2u, 0x00040005u, 0x00000004u, 0x6e69616du,
+        0x00000000u, 0x00060005u, 0x0000000bu, 0x505f6c67u, 0x65567265u, 0x78657472u,
+        0x00000000u, 0x00060006u, 0x0000000bu, 0x00000000u, 0x505f6c67u, 0x7469736fu,
+        0x006e6f69u, 0x00070006u, 0x0000000bu, 0x00000001u, 0x505f6c67u, 0x746e696fu,
+        0x657a6953u, 0x00000000u, 0x00070006u, 0x0000000bu, 0x00000002u, 0x435f6c67u,
+        0x4470696cu, 0x61747369u, 0x0065636eu, 0x00070006u, 0x0000000bu, 0x00000003u,
+        0x435f6c67u, 0x446c6c75u, 0x61747369u, 0x0065636eu, 0x00030005u, 0x0000000du,
+        0x00000000u, 0x00040005u, 0x00000011u, 0x6f506e69u, 0x00000073u, 0x00070005u,
+        0x00000014u, 0x495f6c67u, 0x6174736eu, 0x4965636eu, 0x7865646eu, 0x00000000u,
+        0x00030047u, 0x0000000bu, 0x00000002u, 0x00050048u, 0x0000000bu, 0x00000000u,
+        0x0000000bu, 0x00000000u, 0x00050048u, 0x0000000bu, 0x00000001u, 0x0000000bu,
+        0x00000001u, 0x00050048u, 0x0000000bu, 0x00000002u, 0x0000000bu, 0x00000003u,
+        0x00050048u, 0x0000000bu, 0x00000003u, 0x0000000bu, 0x00000004u, 0x00040047u,
+        0x00000011u, 0x0000001eu, 0x00000000u, 0x00040047u, 0x00000014u, 0x0000000bu,
+        0x0000002bu, 0x00020013u, 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u,
+        0x00030016u, 0x00000006u, 0x00000020u, 0x00040017u, 0x00000007u, 0x00000006u,
+        0x00000004u, 0x00040015u, 0x00000008u, 0x00000020u, 0x00000000u, 0x0004002bu,
+        0x00000008u, 0x00000009u, 0x00000001u, 0x0004001cu, 0x0000000au, 0x00000006u,
+        0x00000009u, 0x0006001eu, 0x0000000bu, 0x00000007u, 0x00000006u, 0x0000000au,
+        0x0000000au, 0x00040020u, 0x0000000cu, 0x00000003u, 0x0000000bu, 0x0004003bu,
+        0x0000000cu, 0x0000000du, 0x00000003u, 0x00040015u, 0x0000000eu, 0x00000020u,
+        0x00000001u, 0x0004002bu, 0x0000000eu, 0x0000000fu, 0x00000000u, 0x00040020u,
+        0x00000010u, 0x00000001u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000011u,
+        0x00000001u, 0x00040020u, 0x00000013u, 0x00000001u, 0x0000000eu, 0x0004003bu,
+        0x00000013u, 0x00000014u, 0x00000001u, 0x00040020u, 0x00000019u, 0x00000003u,
+        0x00000007u, 0x00050036u, 0x00000002u, 0x00000004u, 0x00000000u, 0x00000003u,
+        0x000200f8u, 0x00000005u, 0x0004003du, 0x00000007u, 0x00000012u, 0x00000011u,
+        0x0004003du, 0x0000000eu, 0x00000015u, 0x00000014u, 0x0004006fu, 0x00000006u,
+        0x00000016u, 0x00000015u, 0x00070050u, 0x00000007u, 0x00000017u, 0x00000016u,
+        0x00000016u, 0x00000016u, 0x00000016u, 0x00050081u, 0x00000007u, 0x00000018u,
+        0x00000012u, 0x00000017u, 0x00050041u, 0x00000019u, 0x0000001au, 0x0000000du,
+        0x0000000fu, 0x0003003eu, 0x0000001au, 0x00000018u, 0x000100fdu, 0x00010038u,
+    };
+
+
+    // Same, but reading gl_VertexIndex instead: a DIFFERENT input builtin. glslang emits
+    // this for GL's gl_VertexID, so nearly every real vertex shader has one - it is what
+    // separates "declares some builtin" from "declares the InstanceIndex builtin".
+    constexpr Uint32 kVertexIndexVertexSpirv[] = {
+        0x07230203u, 0x00010000u, 0x0008000bu, 0x0000001bu, 0x00000000u, 0x00020011u,
+        0x00000001u, 0x0006000bu, 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu,
+        0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, 0x0008000fu, 0x00000000u,
+        0x00000004u, 0x6e69616du, 0x00000000u, 0x0000000du, 0x00000011u, 0x00000014u,
+        0x00030003u, 0x00000002u, 0x000001c2u, 0x00040005u, 0x00000004u, 0x6e69616du,
+        0x00000000u, 0x00060005u, 0x0000000bu, 0x505f6c67u, 0x65567265u, 0x78657472u,
+        0x00000000u, 0x00060006u, 0x0000000bu, 0x00000000u, 0x505f6c67u, 0x7469736fu,
+        0x006e6f69u, 0x00070006u, 0x0000000bu, 0x00000001u, 0x505f6c67u, 0x746e696fu,
+        0x657a6953u, 0x00000000u, 0x00070006u, 0x0000000bu, 0x00000002u, 0x435f6c67u,
+        0x4470696cu, 0x61747369u, 0x0065636eu, 0x00070006u, 0x0000000bu, 0x00000003u,
+        0x435f6c67u, 0x446c6c75u, 0x61747369u, 0x0065636eu, 0x00030005u, 0x0000000du,
+        0x00000000u, 0x00040005u, 0x00000011u, 0x6f506e69u, 0x00000073u, 0x00060005u,
+        0x00000014u, 0x565f6c67u, 0x65747265u, 0x646e4978u, 0x00007865u, 0x00030047u,
+        0x0000000bu, 0x00000002u, 0x00050048u, 0x0000000bu, 0x00000000u, 0x0000000bu,
+        0x00000000u, 0x00050048u, 0x0000000bu, 0x00000001u, 0x0000000bu, 0x00000001u,
+        0x00050048u, 0x0000000bu, 0x00000002u, 0x0000000bu, 0x00000003u, 0x00050048u,
+        0x0000000bu, 0x00000003u, 0x0000000bu, 0x00000004u, 0x00040047u, 0x00000011u,
+        0x0000001eu, 0x00000000u, 0x00040047u, 0x00000014u, 0x0000000bu, 0x0000002au,
+        0x00020013u, 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, 0x00030016u,
+        0x00000006u, 0x00000020u, 0x00040017u, 0x00000007u, 0x00000006u, 0x00000004u,
+        0x00040015u, 0x00000008u, 0x00000020u, 0x00000000u, 0x0004002bu, 0x00000008u,
+        0x00000009u, 0x00000001u, 0x0004001cu, 0x0000000au, 0x00000006u, 0x00000009u,
+        0x0006001eu, 0x0000000bu, 0x00000007u, 0x00000006u, 0x0000000au, 0x0000000au,
+        0x00040020u, 0x0000000cu, 0x00000003u, 0x0000000bu, 0x0004003bu, 0x0000000cu,
+        0x0000000du, 0x00000003u, 0x00040015u, 0x0000000eu, 0x00000020u, 0x00000001u,
+        0x0004002bu, 0x0000000eu, 0x0000000fu, 0x00000000u, 0x00040020u, 0x00000010u,
+        0x00000001u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000011u, 0x00000001u,
+        0x00040020u, 0x00000013u, 0x00000001u, 0x0000000eu, 0x0004003bu, 0x00000013u,
+        0x00000014u, 0x00000001u, 0x00040020u, 0x00000019u, 0x00000003u, 0x00000007u,
+        0x00050036u, 0x00000002u, 0x00000004u, 0x00000000u, 0x00000003u, 0x000200f8u,
+        0x00000005u, 0x0004003du, 0x00000007u, 0x00000012u, 0x00000011u, 0x0004003du,
+        0x0000000eu, 0x00000015u, 0x00000014u, 0x0004006fu, 0x00000006u, 0x00000016u,
+        0x00000015u, 0x00070050u, 0x00000007u, 0x00000017u, 0x00000016u, 0x00000016u,
+        0x00000016u, 0x00000016u, 0x00050081u, 0x00000007u, 0x00000018u, 0x00000012u,
+        0x00000017u, 0x00050041u, 0x00000019u, 0x0000001au, 0x0000000du, 0x0000000fu,
+        0x0003003eu, 0x0000001au, 0x00000018u, 0x000100fdu, 0x00010038u,
+    };
+
+    // Owns the reflection module so each test case cleans up after itself.
+    class ReflectModule {
+    public:
+        template <SizeT WordCount>
+        explicit ReflectModule(const Uint32 (&spirv)[WordCount]) {
+            m_created = spvReflectCreateShaderModule(sizeof(spirv), spirv, &m_module) ==
+                        SPV_REFLECT_RESULT_SUCCESS;
+        }
+        ~ReflectModule() {
+            if (m_created) {
+                spvReflectDestroyShaderModule(&m_module);
+            }
+        }
+        ReflectModule(const ReflectModule&) = delete;
+        ReflectModule& operator=(const ReflectModule&) = delete;
+
+        Bool Created() const { return m_created; }
+        const SpvReflectShaderModule& Get() const { return m_module; }
+
+    private:
+        SpvReflectShaderModule m_module{};
+        Bool m_created = false;
+    };
+
+    PipelineFactory::PipelineCreatePayload MakeDepthWritingPayload(
+        const VkPipelineColorBlendAttachmentState& attachment0) {
+        PipelineFactory::PipelineCreatePayload payload{};
+        payload.colorAttachmentCount = 1;
+        payload.depthTestEnable = true;
+        payload.depthWriteEnable = true;
+        payload.colorBlendAttachments[0] = attachment0;
+        return payload;
+    }
+} // namespace
+
+// --- Device gate: MOBILEGL_MAGMA_DISABLE_BLENDED_DEPTH_WRITE tri-state ---
+
+TEST(PipelineQuirkDeviceGate, ForceOnEnablesOnAnyVendor) {
+    EXPECT_TRUE(PipelineFactory::ShouldSuppressBlendedDepthWriteForDevice(QuirkOverride::ForceOn,
+                                                                          kVendorIdArm));
+    EXPECT_TRUE(PipelineFactory::ShouldSuppressBlendedDepthWriteForDevice(QuirkOverride::ForceOn,
+                                                                          kVendorIdQualcomm));
+}
+
+TEST(PipelineQuirkDeviceGate, ForceOffDisablesEvenOnQualcomm) {
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressBlendedDepthWriteForDevice(QuirkOverride::ForceOff,
+                                                                           kVendorIdQualcomm));
+}
+
+TEST(PipelineQuirkDeviceGate, AutoDetectsQualcommOnly) {
+    EXPECT_TRUE(PipelineFactory::ShouldSuppressBlendedDepthWriteForDevice(QuirkOverride::Auto,
+                                                                          kVendorIdQualcomm));
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressBlendedDepthWriteForDevice(QuirkOverride::Auto,
+                                                                           kVendorIdArm));
+}
+
+TEST(PipelineQuirkDeviceGate, ForceOnRoundTripsThroughTheFactoryFlag) {
+    const Bool previous = PipelineFactory::IsSuppressBlendedDepthWriteEnabled();
+    PipelineFactory::SetSuppressBlendedDepthWrite(
+        PipelineFactory::ShouldSuppressBlendedDepthWriteForDevice(QuirkOverride::ForceOn, kVendorIdArm));
+    EXPECT_TRUE(PipelineFactory::IsSuppressBlendedDepthWriteEnabled());
+    PipelineFactory::SetSuppressBlendedDepthWrite(previous);
+}
+
+// --- Per-pipeline strip decision against the pipeline create-info payload ---
+
+TEST(PipelineQuirkStripDecision, MaxBlendIsStripped) {
+    // MC 26.3 OIT depth_bounds: GL_MAX accumulation writing depth - the case the quirk fixes.
+    const auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ZERO, VK_BLEND_OP_MAX, kFullColorWriteMask));
+    EXPECT_TRUE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, MinBlendIsStripped) {
+    const auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ZERO, VK_BLEND_OP_MIN, kFullColorWriteMask));
+    EXPECT_TRUE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, AdditiveOnePlusOneIsNotStripped) {
+    // ONE+ONE additive with a depth write matched zero draws of the 26.3 chain in the
+    // fixture sweep (transmittance/accumulate disable depth writes themselves); the only
+    // real content with this shape was harmless additive glow effects (Create). A quirk
+    // touches as little unrelated content as possible, so the shape stays exempt.
+    const auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_ADD, kFullColorWriteMask));
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, SortedTransparencyOverBlendIsNotStripped) {
+    // Vanilla MC translucent layer (water, stained glass): SRC_ALPHA "over" compositing
+    // draws each surface once and depends on its depth writes to occlude particles, rain,
+    // and clouds drawn later - it must keep them.
+    const auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_SRC_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, VK_BLEND_OP_ADD,
+        kFullColorWriteMask));
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, EffectivelyOpaqueBlendIsNotStripped) {
+    // GL_BLEND left enabled with ONE/ZERO+ADD factors is opaque in effect; stripping its
+    // depth write would break occlusion for plainly opaque geometry.
+    const auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ZERO, VK_BLEND_OP_ADD, kFullColorWriteMask));
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, FullyMaskedAccumulationBlendIsNotStripped) {
+    // Depth-prepass pattern: colorMask(0,0,0,0) with blending left enabled - blending is
+    // moot, and stripping would delete the entire prepass. MAX so the exemption, not the
+    // blend-op filter, is what keeps the depth write.
+    const auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_MAX, 0));
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, DisabledBlendIsNotStripped) {
+    const auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        false, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_MAX, kFullColorWriteMask));
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, NoDepthWriteMeansNoStrip) {
+    auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_MAX, kFullColorWriteMask));
+    payload.depthWriteEnable = false;
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, FragDepthWriterIsExempt) {
+    // gl_FragDepth output does not go through per-pipeline vertex position math, so the
+    // cross-pipeline invariance hazard cannot affect it (e.g. the 26.3 OIT composite).
+    auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_MAX, kFullColorWriteMask));
+    payload.fragmentReplacesDepth = true;
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, AccumulationOnSecondaryAttachmentIsStripped) {
+    // The scan is not limited to attachment 0: an extremum accumulation on any live
+    // attachment marks the pipeline.
+    PipelineFactory::PipelineCreatePayload payload{};
+    payload.colorAttachmentCount = 2;
+    payload.depthTestEnable = true;
+    payload.depthWriteEnable = true;
+    payload.colorBlendAttachments[0] = MakeBlendAttachment(
+        false, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ZERO, VK_BLEND_OP_ADD, kFullColorWriteMask);
+    payload.colorBlendAttachments[1] = MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_MAX, kFullColorWriteMask);
+    EXPECT_TRUE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, AlphaWeightedAdditiveIsNotStripped) {
+    // SRC_ALPHA,ONE additive: the classic *sorted* particle/glow blend. Kept exempt like
+    // every other ADD-op shape now that the strip is extremum-only.
+    const auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_SRC_ALPHA, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_ADD, kFullColorWriteMask));
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, ReverseSubtractIsNotStripped) {
+    // Deliberate narrowing: only the MIN/MAX extremum ops carry the depth-bounds
+    // signature. SUBTRACT-class ops stay outside the quirk until content demands them.
+    const auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_REVERSE_SUBTRACT,
+        kFullColorWriteMask));
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, PartiallyMaskedAccumulationIsStripped) {
+    // Only a fully masked attachment is exempt; a live alpha channel still accumulates.
+    const auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_MAX, VK_COLOR_COMPONENT_A_BIT));
+    EXPECT_TRUE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, NoColorAttachmentsMeansNoStrip) {
+    // Depth-only FBO: the loop must not read the (stale) attachment array at all.
+    PipelineFactory::PipelineCreatePayload payload{};
+    payload.colorAttachmentCount = 0;
+    payload.depthTestEnable = true;
+    payload.depthWriteEnable = true;
+    payload.colorBlendAttachments[0] = MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_MAX, kFullColorWriteMask);
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+TEST(PipelineQuirkStripDecision, SeparateAlphaAccumulationIsNotStripped) {
+    // glBlendEquationSeparate(GL_FUNC_ADD, GL_MAX) over an ordinary color over-blend: the
+    // alpha channel accumulates but the color channel does not. Pins that the decision is
+    // color-channel only - widening it to alpha would re-capture sorted transparency.
+    auto attachment = MakeBlendAttachment(true, VK_BLEND_FACTOR_SRC_ALPHA,
+                                          VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, VK_BLEND_OP_ADD,
+                                          kFullColorWriteMask);
+    attachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+    attachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+    attachment.alphaBlendOp = VK_BLEND_OP_MAX;
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(MakeDepthWritingPayload(attachment)));
+}
+
+TEST(PipelineQuirkStripDecision, MixedOverAndMaskedAttachmentsAreNotStripped) {
+    PipelineFactory::PipelineCreatePayload payload{};
+    payload.colorAttachmentCount = 2;
+    payload.depthTestEnable = true;
+    payload.depthWriteEnable = true;
+    payload.colorBlendAttachments[0] = MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_SRC_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, VK_BLEND_OP_ADD,
+        kFullColorWriteMask);
+    payload.colorBlendAttachments[1] = MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_MAX, 0);
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+// --- DepthReplacing reflection feeding the gl_FragDepth exemption ---
+
+TEST(ReflectedFragmentReplacesDepth, TrueForAShaderThatAssignsFragDepth) {
+    const ReflectModule module(kFragDepthWriterSpirv);
+    ASSERT_TRUE(module.Created());
+    EXPECT_TRUE(ProgramFactory::ReflectedFragmentReplacesDepth(module.Get()));
+}
+
+TEST(ReflectedFragmentReplacesDepth, FalseForAPlainFragmentShader) {
+    const ReflectModule module(kPlainFragmentSpirv);
+    ASSERT_TRUE(module.Created());
+    EXPECT_FALSE(ProgramFactory::ReflectedFragmentReplacesDepth(module.Get()));
+}
+
+TEST(ReflectedFragmentReplacesDepth, FalseForAnEmptyModule) {
+    // A default-constructed module has no entry points; the scan must not dereference.
+    SpvReflectShaderModule emptyModule{};
+    EXPECT_FALSE(ProgramFactory::ReflectedFragmentReplacesDepth(emptyModule));
+}
+
+TEST(ReflectedFragmentReplacesDepth, ReflectedFlagFlipsTheStripDecision) {
+    // The two fixtures differ only by the gl_FragDepth assignment, so they pin that the
+    // reflected flag is what flips the strip decision for an otherwise identical pipeline.
+    const ReflectModule depthWriter(kFragDepthWriterSpirv);
+    const ReflectModule plain(kPlainFragmentSpirv);
+    ASSERT_TRUE(depthWriter.Created());
+    ASSERT_TRUE(plain.Created());
+
+    auto payload = MakeDepthWritingPayload(MakeBlendAttachment(
+        true, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE, VK_BLEND_OP_MAX, kFullColorWriteMask));
+
+    payload.fragmentReplacesDepth = ProgramFactory::ReflectedFragmentReplacesDepth(plain.Get());
+    EXPECT_TRUE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+
+    payload.fragmentReplacesDepth = ProgramFactory::ReflectedFragmentReplacesDepth(depthWriter.Get());
+    EXPECT_FALSE(PipelineFactory::ShouldSuppressDepthWrite(payload));
+}
+
+
+// --- InstanceIndex reflection feeding the shaderDrawParameters diagnostic ---
+
+TEST(ReflectedReadsInstanceIndexBuiltin, TrueForAShaderReadingInstanceIndex) {
+    const ReflectModule module(kInstanceIndexVertexSpirv);
+    ASSERT_TRUE(module.Created());
+    EXPECT_TRUE(ProgramFactory::ReflectedReadsInstanceIndexBuiltin(module.Get()));
+}
+
+TEST(ReflectedReadsInstanceIndexBuiltin, FalseForAShaderReadingADifferentBuiltin) {
+    // Discriminates the builtin's identity, not merely its presence: weakening the check to
+    // "has any BuiltIn decoration" would fire the diagnostic on every real vertex shader.
+    const ReflectModule module(kVertexIndexVertexSpirv);
+    ASSERT_TRUE(module.Created());
+    EXPECT_FALSE(ProgramFactory::ReflectedReadsInstanceIndexBuiltin(module.Get()));
+}
+
+TEST(ReflectedReadsInstanceIndexBuiltin, FalseForAShaderWithNoInputBuiltins) {
+    const ReflectModule module(kPlainFragmentSpirv);
+    ASSERT_TRUE(module.Created());
+    EXPECT_FALSE(ProgramFactory::ReflectedReadsInstanceIndexBuiltin(module.Get()));
+}
+
+TEST(ReflectedReadsInstanceIndexBuiltin, FalseForAnEmptyModule) {
+    SpvReflectShaderModule emptyModule{};
+    EXPECT_FALSE(ProgramFactory::ReflectedReadsInstanceIndexBuiltin(emptyModule));
+}

MobileGL/MG_Test/Program/ProgramUtilTest.cpp

@@ -238,6 +238,77 @@ void main() {
     }
 }
 
+// KHR-GL33.shaders.preprocessor.* — a block comment is one preprocessing token that the C/GLSL
+// preprocessor replaces with a single space, even when it spans newlines inside a directive. glslang
+// handles this natively, so MobileGL must not mangle it. These reproduce the CTS cases that failed
+// because comment blanking preserved the interior newline, truncating multi-line #define bodies.
+static void ExpectCompiles(MobileGL::ShaderStage stage, GLenum glStage, MobileGL::String source) {
+    using namespace MG_Util::ShaderTranspiler;
+    PreprocessShaderSource(stage, source);
+    ShaderAttrib attrib{.shaderType = glStage, .sourceStr = source};
+    auto res = ShaderCompiler::CompileShader(attrib);
+    if (!res) {
+        FAIL() << "errc: " << res.error().errc << "\nlog: " << res.error().log << "\nsource:\n" << source;
+    }
+}
+
+TEST_F(ProgramUtilTest, PreprocessMultilineCommentInDefineBodyCompiles) {
+    ExpectCompiles(ShaderStage::Fragment, GL_FRAGMENT_SHADER,
+                   R"(#version 330
+precision mediump float;
+out float out0;
+#define VALUE /* current
+            value */ 4.2
+
+void main()
+{
+    out0 = VALUE;
+})");
+}
+
+TEST_F(ProgramUtilTest, PreprocessRedefineObjectMultilineCommentCompiles) {
+    ExpectCompiles(ShaderStage::Fragment, GL_FRAGMENT_SHADER,
+                   R"(#version 330
+precision mediump float;
+out float out0;
+#    define  VAL1 1.0
+#define        VAL2 2.0
+
+#define RES2 /* fdsjklfdsjkl
+                dsfjkhfdsjkh
+                fdsjklhfdsjkh */ (RES1 * VAL2)
+#define RES1    (VAL2 / VAL1)
+#define RES2    /* ewrlkjhsadf */ (RES1 * VAL2)
+#define VALUE    (RES2 + RES1)
+
+void main()
+{
+    out0 = VALUE;
+})");
+}
+
+TEST_F(ProgramUtilTest, PreprocessFunctionMacroRedefinitionMultilineCommentCompiles) {
+    ExpectCompiles(ShaderStage::Fragment, GL_FRAGMENT_SHADER,
+                   R"(#version 330
+precision mediump float;
+out float out0;
+# define FUNC(a,b)        (a  +b)
+# define FUNC(a,b)(a    /* comment
+                         */ +b)
+
+void main()
+{
+    out0 = FUNC(1.0, 2.0);
+})");
+}
+
+// Note: KHR-GL3x.shaders.preprocessor.conditional_inclusion.basic_2 (`#define AAA defined(BBB)` used
+// in `#if !AAA`) is intentionally NOT handled here. Generating the `defined` operator via macro
+// expansion is undefined per the C/GLSL preprocessor spec, and glslang deliberately rejects it
+// ("'defined' : cannot use in preprocessor expression when expanded from macros"). Making it pass
+// would require MobileGL to run its own macro expansion ahead of glslang, which is exactly the
+// preprocessing we defer to glslang; the two cases stay failing by design.
+
 TEST_F(ProgramUtilTest, PreprocessLegacyFragmentShaderModernizesGlmarkStyleSource) {
     using namespace MG_Util::ShaderTranspiler;
 
@@ -426,6 +497,62 @@ void main() {
     verifyVersion("#version 460 core");
 }
 
+// KHR-GL33.shaders.preprocessor.directive.version_* (also re-run verbatim under GL40-GL44): the
+// compiler must REJECT a malformed #version line. MobileGL used to rewrite the whole line to
+// "#version 330 core" whenever it could scrape a leading integer - or treat an unknown profile token
+// as core - which silently legalized every form below. CTS compiles the shader's own #version
+// verbatim, so the rejection has to survive preprocessing (and the 460 retry).
+TEST_F(ProgramUtilTest, PreprocessRejectsMalformedVersionDirectives) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    const char* body = "\nout vec4 fragColor;\nvoid main() { fragColor = vec4(1.0); }\n";
+    const auto rejects = [](const String& fullSource) {
+        String src = fullSource;
+        PreprocessShaderSource(ShaderStage::Fragment, src);
+        ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = src};
+        auto res = ShaderCompiler::CompileShader(attrib);
+        return res ? false : true;  // "rejects" == compile failed
+    };
+
+    // Silently legalized today - the five this fix must flip to rejection:
+    EXPECT_TRUE(rejects(String("#version 329") + body))        << "329 is not a real version";
+    EXPECT_TRUE(rejects(String("#version 331") + body))        << "331 is not a real version";
+    EXPECT_TRUE(rejects(String("#version 330 foo") + body))    << "unknown profile keyword";
+    EXPECT_TRUE(rejects(String("#version 330.0") + body))      << "float literal, not an int token";
+    EXPECT_TRUE(rejects(String("#version 330 foobar") + body)) << "trailing tokens after a valid decl";
+
+    // Already rejected (no leading integer, or #version is not the first token) - pinned so a future
+    // change to the normalizer cannot start legalizing them either:
+    EXPECT_TRUE(rejects(String("#version") + body))            << "missing version number";
+    EXPECT_TRUE(rejects(String("#version foobar") + body))     << "identifier where the int belongs";
+    EXPECT_TRUE(rejects(String("#version AAA") + body))        << "identifier where the int belongs";
+    EXPECT_TRUE(rejects(String("precision mediump float;\n#version 330") + body))
+        << "#version must be the first statement";
+    EXPECT_TRUE(rejects(String("#define FOO BAR\n#version 330") + body))
+        << "#version must precede a #define";
+}
+
+// The PASS half of the same CTS group: a valid decl, and #version preceded only by whitespace or a
+// comment, must still compile. Guards the fix above from over-rejecting.
+TEST_F(ProgramUtilTest, PreprocessKeepsValidVersionDirectivesCompiling) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    const char* body = "\nout vec4 fragColor;\nvoid main() { fragColor = vec4(1.0); }\n";
+    const auto compiles = [](const String& fullSource) {
+        String src = fullSource;
+        PreprocessShaderSource(ShaderStage::Fragment, src);
+        ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = src};
+        auto res = ShaderCompiler::CompileShader(attrib);
+        return res ? true : false;
+    };
+
+    EXPECT_TRUE(compiles(String("#version 330 core") + body));
+    EXPECT_TRUE(compiles(String("\n#version 330 core") + body))
+        << "leading whitespace is legal before #version";
+    EXPECT_TRUE(compiles(String("// test\n#version 330 core") + body))
+        << "a leading comment is legal before #version";
+}
+
 TEST_F(ProgramUtilTest, PreprocessUsesRealSpacedVersionDirectiveForInjectedOutput) {
     using namespace MG_Util::ShaderTranspiler;
 
@@ -446,6 +573,9 @@ void main() {
     EXPECT_NE(versionPos, String::npos);
     EXPECT_EQ(outputPos, versionPos + std::strlen("#version 330 core\n"));
     EXPECT_NE(source.find("// #version 460 core"), String::npos);
+    // This #line sits ahead of the version directive, where GLSL would never have honoured it, so
+    // it is still dropped. Directives that follow the version line are kept - see
+    // PreprocessKeepsPlainLineDirectivesAndSparesLookalikeIdentifiers.
     EXPECT_EQ(source.find("#line"), String::npos);
 
     ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = source};
@@ -455,6 +585,105 @@ void main() {
     }
 }
 
+// A banner line like "//*** NOTE ***" contains "/*" at offset 1 and no "*/" anywhere after it. The
+// old hand-rolled comment stripper searched for "/*" with no lexical state, found that, failed to
+// find a terminator, and erased everything from there to the end of the file - deleting the entire
+// shader. Banner comments in that exact shape are common in Iris and OptiFine packs.
+TEST_F(ProgramUtilTest, PreprocessKeepsShaderBodyAfterAStarredLineComment) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    String source = R"(#version 330 core
+//*** lighting pass ***
+out vec4 fragColor;
+void main() {
+    fragColor = vec4(1.0);
+}
+)";
+    PreprocessShaderSource(ShaderStage::Fragment, source);
+
+    EXPECT_NE(source.find("void main()"), String::npos) << "shader body was truncated:\n" << source;
+    EXPECT_NE(source.find("fragColor = vec4(1.0);"), String::npos);
+
+    ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = source};
+    auto res = ShaderCompiler::CompileShader(attrib);
+    if (!res) {
+        FAIL() << "errc: " << res.error().errc << "\nlog: " << res.error().log << "\nsource:\n" << source;
+    }
+}
+
+// The builtin-shadowing rename only fires when the shader really defines its own round/tanh/etc.
+// Deciding that from a commented-out definition renames every genuine call to the builtin to a
+// mg_ name that nothing defines, which fails to link.
+TEST_F(ProgramUtilTest, PreprocessIgnoresCommentedOutBuiltinShadowingDefinition) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    String source = R"(#version 330 core
+// float round(float x) { return floor(x + 0.5); }
+out vec4 fragColor;
+void main() {
+    fragColor = vec4(round(1.25));
+}
+)";
+    PreprocessShaderSource(ShaderStage::Fragment, source);
+
+    EXPECT_NE(source.find("round(1.25)"), String::npos) << "call was renamed from a comment:\n" << source;
+    EXPECT_EQ(source.find("mg_round"), String::npos);
+}
+
+// A block-commented extension directive must not be treated as a real one - the int64 filter turns
+// unsupported directives into #error, so reading one out of a comment manufactures a compile
+// failure for a shader that never asked for the extension.
+TEST_F(ProgramUtilTest, PreprocessIgnoresBlockCommentedExtensionDirectives) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    String source = R"(#version 330 core
+/*
+#extension GL_ARB_gpu_shader_int64 : require
+*/
+out vec4 fragColor;
+void main() {
+    fragColor = vec4(1.0);
+}
+)";
+    PreprocessShaderSource(ShaderStage::Fragment, source);
+
+    EXPECT_EQ(source.find("#error"), String::npos) << "#error synthesized from a comment:\n" << source;
+
+    ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = source};
+    auto res = ShaderCompiler::CompileShader(attrib);
+    if (!res) {
+        FAIL() << "errc: " << res.error().errc << "\nlog: " << res.error().log << "\nsource:\n" << source;
+    }
+}
+
+// KHR-GL33.shaders.preprocessor.builtin.line_* checks that __LINE__ follows #line. That only works
+// if the directive reaches glslang, so a plain integer form must pass through untouched - while
+// "#linear" and friends must not be mistaken for it.
+TEST_F(ProgramUtilTest, PreprocessKeepsPlainLineDirectivesAndSparesLookalikeIdentifiers) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    String source = R"(#version 330 core
+out vec4 fragColor;
+#line 42
+float linear(float x) { return x; }
+void main() {
+#line 100
+    fragColor = vec4(linear(float(__LINE__)));
+}
+)";
+    PreprocessShaderSource(ShaderStage::Fragment, source);
+
+    EXPECT_NE(source.find("#line 42"), String::npos) << source;
+    EXPECT_NE(source.find("#line 100"), String::npos) << source;
+    EXPECT_NE(source.find("float linear(float x)"), String::npos) << "identifier lookalike was eaten:\n" << source;
+
+    ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = source};
+    auto res = ShaderCompiler::CompileShader(attrib);
+    if (!res) {
+        FAIL() << "errc: " << res.error().errc << "\nlog: " << res.error().log << "\nsource:\n" << source;
+    }
+}
+
 TEST_F(ProgramUtilTest, PreprocessModernSampleQualifierStaysAtVersion460) {
     using namespace MG_Util::ShaderTranspiler;
 
@@ -745,6 +974,16 @@ TEST_F(ProgramUtilTest, RetargetLegacyVersionDirectiveOnlyTouchesNormalizedDeskt
     String commented = "// #version 330 core\nvoid main() {}\n";
     EXPECT_FALSE(RetargetLegacyVersionDirectiveTo460(commented));
     EXPECT_EQ(commented.find("#version 460"), String::npos);
+
+    // A malformed directive must NOT be rescued to 460 - that is what silently legalized the CTS
+    // directive.version_* rejection cases. The bad version stays put so glslang keeps rejecting it.
+    String badNumber = "#version 331\nvoid main() {}\n";
+    EXPECT_FALSE(RetargetLegacyVersionDirectiveTo460(badNumber));
+    EXPECT_EQ(badNumber.find("#version 460"), String::npos);
+
+    String badProfile = "#version 330 foo\nvoid main() {}\n";
+    EXPECT_FALSE(RetargetLegacyVersionDirectiveTo460(badProfile));
+    EXPECT_EQ(badProfile.find("#version 460"), String::npos);
 }
 
 const char* fs = R"(#version 150
@@ -921,6 +1160,353 @@ TEST_F(ProgramUtilTest, CompileFragmentShaderWithDiscard) {
     }
 }
 
+// noperspective is core desktop GLSL (1.30+) and maps to the SPIR-V NoPerspective decoration. It must
+// reach glslang (not be stripped as text) so the SPIR-V carries the decoration; SPIRV-Cross then emits
+// ESSL `noperspective` + the GL_NV_shader_noperspective_interpolation extension. Shader packs
+// (Iris/Complementary) depend on it, and KHR-GL33.glsl_noperspective fails if the result matches
+// smooth. This is the DirectGLES path with the NV extension available (SPIRV-Cross's default).
+TEST_F(ProgramUtilTest, NoperspectiveInterpolationSurvivesToEssl) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    String fs = R"(#version 330 core
+noperspective in vec4 vColor;
+out vec4 fragColor;
+void main() { fragColor = vColor; }
+)";
+    ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = fs};
+    auto res = ShaderCompiler::CompileShader(attrib);
+    if (!res) FAIL() << "compile errc: " << res.error().errc << "\nlog: " << res.error().log;
+
+    ProgramAttrib programAttrib{.shaders = {res.value()}};
+    auto program_res = ShaderCompiler::LinkProgram(programAttrib);
+    if (!program_res) FAIL() << "link errc: " << program_res.error().errc << "\nlog: " << program_res.error().log;
+
+    ProgramBinaryAttrib binaryAttrib{.shaderTypes = {GL_FRAGMENT_SHADER}, .program = *program_res.value()};
+    auto bin_res = ShaderCompiler::GetSpirvBinaryFromProgram(binaryAttrib);
+    if (!bin_res) FAIL() << "spirv errc: " << bin_res.error().errc << "\nlog: " << bin_res.error().log;
+    ASSERT_EQ(bin_res.value().size(), 1u);
+
+    SpvcSession session(bin_res.value()[0], SessionUsageBit::Transpile);
+    auto essl = ShaderCompiler::DecompileShader(session);
+    if (!essl) FAIL() << "decompile errc: " << essl.error().errc << "\nlog: " << essl.error().log;
+
+    EXPECT_NE(essl.value().find("noperspective"), String::npos)
+        << "noperspective was lost before it reached SPIR-V:\n" << essl.value();
+    EXPECT_NE(essl.value().find("GL_NV_shader_noperspective_interpolation"), String::npos)
+        << "SPIRV-Cross must require the NV extension for ES noperspective:\n" << essl.value();
+}
+
+// The old handling was a naked substring erase of "noperspective", so any identifier that merely
+// contained those characters (a uniform named noperspectiveBlend, say) got mangled. Removing the
+// strip fixes it - glslang, which is identifier-aware, is the only thing that should see the keyword.
+TEST_F(ProgramUtilTest, PreprocessDoesNotCorruptIdentifiersContainingNoperspective) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    String source = R"(#version 330 core
+uniform float noperspectiveBlend;
+out vec4 fragColor;
+void main() { fragColor = vec4(noperspectiveBlend); }
+)";
+    PreprocessShaderSource(ShaderStage::Fragment, source);
+    EXPECT_NE(source.find("noperspectiveBlend"), String::npos)
+        << "identifier was corrupted by substring stripping:\n" << source;
+}
+
+// The DirectGLES fallback for devices without GL_NV_shader_noperspective_interpolation: stripping the
+// NoPerspective decoration makes SPIRV-Cross emit a plain smooth varying with no `#extension … :
+// require`, so the shader still compiles (rendering as smooth) instead of being rejected by the driver.
+TEST_F(ProgramUtilTest, StripNoPerspectiveFallbackProducesPlainEssl) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    String fs = R"(#version 330 core
+noperspective in vec4 vColor;
+out vec4 fragColor;
+void main() { fragColor = vColor; }
+)";
+    ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = fs};
+    auto res = ShaderCompiler::CompileShader(attrib);
+    if (!res) FAIL() << "compile errc: " << res.error().errc << "\nlog: " << res.error().log;
+
+    ProgramAttrib programAttrib{.shaders = {res.value()}};
+    auto program_res = ShaderCompiler::LinkProgram(programAttrib);
+    if (!program_res) FAIL() << "link errc: " << program_res.error().errc << "\nlog: " << program_res.error().log;
+
+    ProgramBinaryAttrib binaryAttrib{.shaderTypes = {GL_FRAGMENT_SHADER}, .program = *program_res.value()};
+    auto bin_res = ShaderCompiler::GetSpirvBinaryFromProgram(binaryAttrib);
+    if (!bin_res) FAIL() << "spirv errc: " << bin_res.error().errc << "\nlog: " << bin_res.error().log;
+    ASSERT_EQ(bin_res.value().size(), 1u);
+
+    // Precondition: with the decoration present the default decompile requires the NV extension.
+    {
+        SpvcSession session(bin_res.value()[0], SessionUsageBit::Transpile);
+        auto essl = ShaderCompiler::DecompileShader(session);
+        if (!essl) FAIL() << "decompile errc: " << essl.error().errc;
+        ASSERT_NE(essl.value().find("noperspective"), String::npos) << essl.value();
+    }
+
+    // The fallback strips the decoration -> plain smooth ESSL, no extension require.
+    Vector<Uint32> stripped;
+    ASSERT_TRUE(ShaderCompiler::StripNoPerspectiveForEssl(bin_res.value()[0], stripped));
+    ASSERT_FALSE(stripped.empty());
+
+    SpvcSession session(stripped, SessionUsageBit::Transpile);
+    auto essl = ShaderCompiler::DecompileShader(session);
+    if (!essl) FAIL() << "decompile errc: " << essl.error().errc << "\nlog: " << essl.error().log;
+    EXPECT_EQ(essl.value().find("noperspective"), String::npos)
+        << "the decoration should be gone:\n" << essl.value();
+    EXPECT_EQ(essl.value().find("GL_NV_shader_noperspective_interpolation"), String::npos)
+        << "no extension require without the decoration:\n" << essl.value();
+}
+
+// Directly exercises BOTH decoration forms StripNoPerspectivePass handles: a plain-variable
+// OpDecorate NoPerspective (in-operand 1) and an interface-block-member OpMemberDecorate NoPerspective
+// (in-operand 2). The ESSL round-trip tests above use only a scalar input, so they never reach the
+// member-decorate branch, which a block varying like `in Block { noperspective vec4 c; }` (common in
+// shader packs) produces. Unrelated decorations (Flat, Location) must survive untouched.
+TEST_F(ProgramUtilTest, StripNoPerspectivePassRemovesBothDecorateForms) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    const String spirvText = R"(
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Fragment %main "main" %plainVar %blockVar %flatVar
+               OpExecutionMode %main OriginUpperLeft
+               OpName %main "main"
+               OpDecorate %plainVar Location 0
+               OpDecorate %plainVar NoPerspective
+               OpMemberDecorate %Block 0 NoPerspective
+               OpDecorate %blockVar Location 1
+               OpDecorate %flatVar Location 2
+               OpDecorate %flatVar Flat
+       %void = OpTypeVoid
+     %mainFn = OpTypeFunction %void
+      %float = OpTypeFloat 32
+    %v4float = OpTypeVector %float 4
+        %int = OpTypeInt 32 1
+    %inV4Ptr = OpTypePointer Input %v4float
+   %plainVar = OpVariable %inV4Ptr Input
+      %Block = OpTypeStruct %v4float
+ %inBlockPtr = OpTypePointer Input %Block
+   %blockVar = OpVariable %inBlockPtr Input
+   %inIntPtr = OpTypePointer Input %int
+    %flatVar = OpVariable %inIntPtr Input
+       %main = OpFunction %void None %mainFn
+   %mainBody = OpLabel
+               OpReturn
+               OpFunctionEnd
+)";
+
+    spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1);
+    Vector<uint32_t> inputBinary;
+    ASSERT_TRUE(tools.Assemble(spirvText, &inputBinary));
+
+    const auto countNoPerspective = [](const String& text) {
+        SizeT count = 0, offset = 0;
+        while ((offset = text.find("NoPerspective", offset)) != String::npos) {
+            ++count;
+            offset += std::strlen("NoPerspective");
+        }
+        return count;
+    };
+
+    String inputText;
+    ASSERT_TRUE(tools.Disassemble(inputBinary, &inputText));
+    ASSERT_EQ(countNoPerspective(inputText), 2u)
+        << "fixture must carry both a plain and a member NoPerspective:\n" << inputText;
+
+    Vector<uint32_t> outputBinary;
+    ASSERT_TRUE(ShaderCompiler::StripNoPerspectiveForEssl(inputBinary, outputBinary));
+    ASSERT_FALSE(outputBinary.empty());
+
+    String outputText;
+    ASSERT_TRUE(tools.Disassemble(outputBinary, &outputText));
+    EXPECT_EQ(countNoPerspective(outputText), 0u)
+        << "both NoPerspective decorations (OpDecorate and OpMemberDecorate) must be stripped:\n" << outputText;
+    EXPECT_NE(outputText.find("Flat"), String::npos)
+        << "the unrelated Flat decoration must survive:\n" << outputText;
+    EXPECT_NE(outputText.find("Location"), String::npos)
+        << "Location decorations must survive:\n" << outputText;
+}
+
+// Phase 2 emulation - fragment side. On a device without the NV extension the NoPerspective input is
+// recovered as `load * gl_FragCoord.w` and the decoration removed; gl_FragCoord is synthesized because
+// the shader did not otherwise use it. The emulated SPIR-V must validate and decompile without the
+// extension require.
+TEST_F(ProgramUtilTest, EmulateNoperspectiveFragmentRecoversWithFragCoordW) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    String fs = R"(#version 330 core
+noperspective in vec4 vColor;
+out vec4 f;
+void main() { f = vColor; }
+)";
+    ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = fs};
+    auto res = ShaderCompiler::CompileShader(attrib);
+    if (!res) FAIL() << "compile: " << res.error().log;
+    ProgramAttrib pa{.shaders = {res.value()}};
+    auto pr = ShaderCompiler::LinkProgram(pa);
+    if (!pr) FAIL() << "link: " << pr.error().log;
+    ProgramBinaryAttrib ba{.shaderTypes = {GL_FRAGMENT_SHADER}, .program = *pr.value()};
+    auto br = ShaderCompiler::GetSpirvBinaryFromProgram(ba);
+    if (!br) FAIL() << "spirv: " << br.error().log;
+    ASSERT_EQ(br.value().size(), 1u);
+
+    Vector<uint32_t> emulated;
+    ASSERT_TRUE(ShaderCompiler::EmulateNoPerspectiveForEssl(br.value()[0], emulated));
+    ASSERT_FALSE(emulated.empty());
+
+    spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1);
+    String dis;
+    ASSERT_TRUE(tools.Disassemble(emulated, &dis));
+    ASSERT_TRUE(tools.Validate(emulated)) << "emulated SPIR-V must be valid:\n" << dis;
+    EXPECT_EQ(dis.find("NoPerspective"), String::npos) << "decoration must be stripped:\n" << dis;
+    EXPECT_NE(dis.find("FragCoord"), String::npos) << "gl_FragCoord must be synthesized:\n" << dis;
+    EXPECT_NE(dis.find("OpVectorTimesScalar"), String::npos) << "the recovery multiply must be present:\n" << dis;
+
+    SpvcSession session(emulated, SessionUsageBit::Transpile);
+    auto essl = ShaderCompiler::DecompileShader(session);
+    if (!essl) FAIL() << "decompile: " << essl.error().log;
+    EXPECT_EQ(essl.value().find("noperspective"), String::npos) << essl.value();
+    EXPECT_EQ(essl.value().find("GL_NV_shader_noperspective_interpolation"), String::npos) << essl.value();
+    EXPECT_NE(essl.value().find("gl_FragCoord"), String::npos) << "recovery must reference gl_FragCoord:\n" << essl.value();
+}
+
+// Phase 2 emulation - vertex side. The NoPerspective output is pre-multiplied by gl_Position.w before
+// return and the decoration removed. Emulated SPIR-V must validate and decompile without the extension.
+TEST_F(ProgramUtilTest, EmulateNoperspectiveVertexPreMultipliesByPositionW) {
+    using namespace MG_Util::ShaderTranspiler;
+
+    String vs = R"(#version 330 core
+in vec4 pos;
+noperspective out vec4 vColor;
+void main() { gl_Position = pos; vColor = pos; }
+)";
+    ShaderAttrib attrib{.shaderType = GL_VERTEX_SHADER, .sourceStr = vs};
+    auto res = ShaderCompiler::CompileShader(attrib);
+    if (!res) FAIL() << "compile: " << res.error().log;
+    ProgramAttrib pa{.shaders = {res.value()}};
+    auto pr = ShaderCompiler::LinkProgram(pa);
+    if (!pr) FAIL() << "link: " << pr.error().log;
+    ProgramBinaryAttrib ba{.shaderTypes = {GL_VERTEX_SHADER}, .program = *pr.value()};
+    auto br = ShaderCompiler::GetSpirvBinaryFromProgram(ba);
+    if (!br) FAIL() << "spirv: " << br.error().log;
+    ASSERT_EQ(br.value().size(), 1u);
+
+    Vector<uint32_t> emulated;
+    ASSERT_TRUE(ShaderCompiler::EmulateNoPerspectiveForEssl(br.value()[0], emulated));
+    ASSERT_FALSE(emulated.empty());
+
+    spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1);
+    String dis;
+    ASSERT_TRUE(tools.Disassemble(emulated, &dis));
+    ASSERT_TRUE(tools.Validate(emulated)) << "emulated SPIR-V must be valid:\n" << dis;
+    EXPECT_EQ(dis.find("NoPerspective"), String::npos) << "decoration must be stripped:\n" << dis;
+    EXPECT_NE(dis.find("OpVectorTimesScalar"), String::npos) << "the pre-multiply must be present:\n" << dis;
+
+    SpvcSession session(emulated, SessionUsageBit::Transpile);
+    auto essl = ShaderCompiler::DecompileShader(session);
+    if (!essl) FAIL() << "decompile: " << essl.error().log;
+    EXPECT_EQ(essl.value().find("noperspective"), String::npos) << essl.value();
+    EXPECT_NE(essl.value().find("gl_Position"), String::npos) << "pre-multiply must reference gl_Position:\n" << essl.value();
+}
+
+namespace {
+// Compiles one shader stage through the full pipeline and returns its SPIR-V, or fails the test.
+MobileGL::Vector<uint32_t> CompileStageSpirv(GLenum type, const char* src) {
+    using namespace MG_Util::ShaderTranspiler;
+    ShaderAttrib attrib{.shaderType = type, .sourceStr = src};
+    auto res = ShaderCompiler::CompileShader(attrib);
+    EXPECT_TRUE(static_cast<bool>(res)) << (res ? "" : res.error().log);
+    if (!res) return {};
+    ProgramAttrib pa{.shaders = {res.value()}};
+    auto pr = ShaderCompiler::LinkProgram(pa);
+    EXPECT_TRUE(static_cast<bool>(pr)) << (pr ? "" : pr.error().log);
+    if (!pr) return {};
+    ProgramBinaryAttrib ba{.shaderTypes = {type}, .program = *pr.value()};
+    auto br = ShaderCompiler::GetSpirvBinaryFromProgram(ba);
+    EXPECT_TRUE(static_cast<bool>(br)) << (br ? "" : br.error().log);
+    if (!br || br.value().empty()) return {};
+    return br.value()[0];
+}
+} // namespace
+
+// Regression: the vertex pre-multiply must be applied exactly once (in main), not once per function.
+// glslang does not inline, so a helper function survives as its own OpFunction; instrumenting its
+// return too would scale the varying by gl_Position.w twice (w^2).
+TEST_F(ProgramUtilTest, EmulateNoperspectiveVertexWithHelperScalesExactlyOnce) {
+    using namespace MG_Util::ShaderTranspiler;
+    // helper() returns via OpReturnValue and adds (no vector*scalar), so the ONLY OpVectorTimesScalar
+    // in the module is the emulation's pre-multiply. The old all-functions code injected it at both
+    // helper's and main's return -> count 2; restricted to the entry function it is 1.
+    auto spirv = CompileStageSpirv(GL_VERTEX_SHADER, R"(#version 330 core
+in vec4 pos;
+noperspective out vec4 vColor;
+vec4 helper(vec4 x) { return x + vec4(1.0); }
+void main() { gl_Position = pos; vColor = helper(pos); }
+)");
+    ASSERT_FALSE(spirv.empty());
+
+    Vector<uint32_t> emulated;
+    ASSERT_TRUE(ShaderCompiler::EmulateNoPerspectiveForEssl(spirv, emulated));
+    spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1);
+    String dis;
+    ASSERT_TRUE(tools.Disassemble(emulated, &dis));
+    ASSERT_TRUE(tools.Validate(emulated)) << dis;
+
+    SizeT count = 0, off = 0;
+    while ((off = dis.find("OpVectorTimesScalar", off)) != String::npos) {
+        ++count;
+        off += std::strlen("OpVectorTimesScalar");
+    }
+    EXPECT_EQ(count, 1u) << "the gl_Position.w pre-multiply must happen exactly once, not per function:\n" << dis;
+}
+
+// Regression: a single-component read (vColor.x), which glslang lowers via OpAccessChain, must still be
+// recovered with gl_FragCoord.w - not silently left un-scaled.
+TEST_F(ProgramUtilTest, EmulateNoperspectiveFragmentComponentReadIsRecovered) {
+    using namespace MG_Util::ShaderTranspiler;
+    auto spirv = CompileStageSpirv(GL_FRAGMENT_SHADER, R"(#version 330 core
+noperspective in vec4 vColor;
+out vec4 f;
+void main() { f = vec4(vColor.x); }
+)");
+    ASSERT_FALSE(spirv.empty());
+
+    Vector<uint32_t> emulated;
+    ASSERT_TRUE(ShaderCompiler::EmulateNoPerspectiveForEssl(spirv, emulated));
+    spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1);
+    String dis;
+    ASSERT_TRUE(tools.Disassemble(emulated, &dis));
+    ASSERT_TRUE(tools.Validate(emulated)) << dis;
+    EXPECT_EQ(dis.find("NoPerspective"), String::npos) << dis;
+    EXPECT_NE(dis.find("FragCoord"), String::npos)
+        << "the component read must still be recovered via gl_FragCoord.w:\n" << dis;
+}
+
+// Coverage: a scalar float varying exercises the OpFMul path; a vector varying the OpVectorTimesScalar
+// path; multiple noperspective varyings in one stage are all handled.
+TEST_F(ProgramUtilTest, EmulateNoperspectiveHandlesScalarAndMultipleVaryings) {
+    using namespace MG_Util::ShaderTranspiler;
+    auto spirv = CompileStageSpirv(GL_FRAGMENT_SHADER, R"(#version 330 core
+noperspective in float a;
+noperspective in vec2 b;
+out vec4 f;
+void main() { f = vec4(a, b, 1.0); }
+)");
+    ASSERT_FALSE(spirv.empty());
+
+    Vector<uint32_t> emulated;
+    ASSERT_TRUE(ShaderCompiler::EmulateNoPerspectiveForEssl(spirv, emulated));
+    spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1);
+    String dis;
+    ASSERT_TRUE(tools.Disassemble(emulated, &dis));
+    ASSERT_TRUE(tools.Validate(emulated)) << dis;
+    EXPECT_EQ(dis.find("NoPerspective"), String::npos) << dis;
+    EXPECT_NE(dis.find("OpFMul"), String::npos) << "the scalar varying must scale with OpFMul:\n" << dis;
+    EXPECT_NE(dis.find("OpVectorTimesScalar"), String::npos)
+        << "the vector varying must scale with OpVectorTimesScalar:\n" << dis;
+}
+
 const char* vs_location = R"(#version 460
 
 in vec4 Position;
@@ -1623,4 +2209,26 @@ TEST_F(ProgramUtilTest, RewriteLinearSubgroupPrefixScanRejectsPartialOrUnsafeTem
     ASSERT_NE(consumerEnd, String::npos);
     nestedScan.insert(consumerEnd + 1, "\n    }");
     expectUnchanged(std::move(nestedScan));
+
+    // ARB/NV spellings of lane-width-sensitive builtins must block the rewrite exactly
+    // like their KHR counterparts.
+    String arbSubgroupBuiltin = MakeLinearSubgroupPrefixScanShader();
+    arbSubgroupBuiltin.insert(arbSubgroupBuiltin.find("float importance"),
+                              "uint arbLane = gl_SubGroupInvocationARB;\n    ");
+    expectUnchanged(std::move(arbSubgroupBuiltin));
+
+    String arbBallotCall = MakeLinearSubgroupPrefixScanShader();
+    arbBallotCall.insert(arbBallotCall.find("float importance"),
+                         "uint64_t arbMask = ballotARB(true);\n    ");
+    expectUnchanged(std::move(arbBallotCall));
+
+    String nvWarpBuiltin = MakeLinearSubgroupPrefixScanShader();
+    nvWarpBuiltin.insert(nvWarpBuiltin.find("float importance"),
+                         "uint warpSize = gl_WarpSizeNV;\n    ");
+    expectUnchanged(std::move(nvWarpBuiltin));
+
+    String nvShuffleCall = MakeLinearSubgroupPrefixScanShader();
+    nvShuffleCall.insert(nvShuffleCall.find("float importance"),
+                         "float other = shuffleNV(1.0f, 0u, 32u);\n    ");
+    expectUnchanged(std::move(nvShuffleCall));
 }

MobileGL/MG_Test/SanityTest.cpp

@@ -794,6 +794,33 @@ TEST(DirectVulkanSanity, ReadbackConvertsRgba8AndRgba16fPixels) {
     EXPECT_FLOAT_EQ(rgba16fFloatResult[3], 1.0f);
 }
 
+TEST(DirectVulkanSanity, ReadbackDecodesSingleChannel32BitFormats) {
+    using MobileGL::MG_Backend::DirectVulkan::VulkanRenderer;
+
+    // The reinterpretation feature makes R32F/R32UI-class images common readback sources
+    // (iterationRP custom images). Missing channels take GL defaults: 0 for GB, 1 for alpha.
+    const MobileGL::Float r32f[] = {0.75f, -2.0f};
+    MobileGL::Float r32fResult[8]{};
+    ASSERT_TRUE(VulkanRenderer::ConvertReadbackPixels(
+        reinterpret_cast<const MobileGL::Uint8*>(r32f), VK_FORMAT_R32_SFLOAT,
+        2, 1, GL_RGBA, GL_FLOAT, sizeof(MobileGL::Float) * 8,
+        reinterpret_cast<MobileGL::Uint8*>(r32fResult)));
+    EXPECT_FLOAT_EQ(r32fResult[0], 0.75f);
+    EXPECT_FLOAT_EQ(r32fResult[1], 0.0f);
+    EXPECT_FLOAT_EQ(r32fResult[2], 0.0f);
+    EXPECT_FLOAT_EQ(r32fResult[3], 1.0f);
+    EXPECT_FLOAT_EQ(r32fResult[4], -2.0f);
+
+    const MobileGL::Uint32 r32ui[] = {12345u};
+    MobileGL::Float r32uiResult[4]{};
+    ASSERT_TRUE(VulkanRenderer::ConvertReadbackPixels(
+        reinterpret_cast<const MobileGL::Uint8*>(r32ui), VK_FORMAT_R32_UINT,
+        1, 1, GL_RGBA, GL_FLOAT, sizeof(MobileGL::Float) * 4,
+        reinterpret_cast<MobileGL::Uint8*>(r32uiResult)));
+    EXPECT_FLOAT_EQ(r32uiResult[0], 12345.0f);
+    EXPECT_FLOAT_EQ(r32uiResult[3], 1.0f);
+}
+
 TEST(DirectVulkanSanity, DrawIndexedIndirectCommandMatchesGlAndVulkanLayout) {
     using namespace MobileGL::MG_Backend::DirectVulkan;
 
@@ -999,9 +1026,27 @@ TEST(DirectVulkanSanity, SampledViewFormatMatchesSamplerNumericDomainWithoutChan
     EXPECT_EQ(VkTextureManager::ResolveSampledImageViewFormat(
                   VK_FORMAT_B10G11R11_UFLOAT_PACK32, SamplerNumericDomain::UnsignedInteger),
               VK_FORMAT_UNDEFINED);
+
+    // Depth/stencil formats never resolve through color-class reinterpretation; they pass
+    // through unchanged so the existing depth-aspect sampled view is used. Combined
+    // depth-stencil formats are multi-numeric (vkuFormatIsSampledFloat is false for them),
+    // so without the passthrough a plain sampler2D/sampler2DShadow on GL_DEPTH24_STENCIL8
+    // would resolve to UNDEFINED and the draw would be dropped.
+    EXPECT_EQ(VkTextureManager::ResolveSampledImageViewFormat(
+                  VK_FORMAT_D24_UNORM_S8_UINT, SamplerNumericDomain::Float),
+              VK_FORMAT_D24_UNORM_S8_UINT);
+    EXPECT_EQ(VkTextureManager::ResolveSampledImageViewFormat(
+                  VK_FORMAT_D32_SFLOAT_S8_UINT, SamplerNumericDomain::Float),
+              VK_FORMAT_D32_SFLOAT_S8_UINT);
+    EXPECT_EQ(VkTextureManager::ResolveSampledImageViewFormat(
+                  VK_FORMAT_D32_SFLOAT, SamplerNumericDomain::Float),
+              VK_FORMAT_D32_SFLOAT);
+    EXPECT_EQ(VkTextureManager::ResolveSampledImageViewFormat(
+                  VK_FORMAT_D24_UNORM_S8_UINT, SamplerNumericDomain::UnsignedInteger),
+              VK_FORMAT_D24_UNORM_S8_UINT);
     EXPECT_EQ(VkTextureManager::ResolveSampledImageViewFormat(
                   VK_FORMAT_D32_SFLOAT, SamplerNumericDomain::UnsignedInteger),
-              VK_FORMAT_UNDEFINED);
+              VK_FORMAT_D32_SFLOAT);
 
     EXPECT_TRUE(VkTextureManager::AreSampledImageViewFormatsCompatible(
         VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32_UINT));
@@ -1386,3 +1431,308 @@ TEST(RenderStateSanity, PrimitiveRestartIndexStoresAndReadsBack) {
 
     MG_State::pGLContext.reset();
 }
+
+
+// ---- DirectGLES readback driver-state shadows ----------------------------------------------------
+// Regression coverage for the readback-path state-leak overhaul: the pixel-PBO
+// binding cache, the framebuffer-binding shadow, the PACK pixel-store shadow and
+// the scratch-FBO attachment shadow must (a) leave the driver in the documented
+// resting state, (b) skip redundant GL calls, and (c) scrub correctly on
+// deletion. All drive the real Managers.cpp implementations against a recording
+// mock GLES table.
+namespace {
+    struct StateGuardCallLog {
+        MobileGL::Vector<MobileGL::String> calls;
+
+        MobileGL::SizeT Count(const MobileGL::String& prefix) const {
+            MobileGL::SizeT n = 0;
+            for (const auto& c : calls) {
+                if (c.compare(0, prefix.size(), prefix) == 0) ++n;
+            }
+            return n;
+        }
+    };
+
+    StateGuardCallLog* g_stateGuardLog = nullptr;
+    GLuint g_nextStateGuardFBOId = 201;
+
+    void SG_Log(MobileGL::String entry) {
+        if (g_stateGuardLog) g_stateGuardLog->calls.push_back(MobileGL::Move(entry));
+    }
+    void SG_BindBuffer(GLenum target, GLuint buffer) {
+        SG_Log("BindBuffer:" + std::to_string(target) + ":" + std::to_string(buffer));
+    }
+    void SG_BindFramebuffer(GLenum target, GLuint framebuffer) {
+        SG_Log("BindFramebuffer:" + std::to_string(target) + ":" + std::to_string(framebuffer));
+    }
+    void SG_GetIntegerv(GLenum pname, GLint* data) {
+        SG_Log("GetIntegerv:" + std::to_string(pname));
+        if (data) *data = 0;
+    }
+    void SG_PixelStorei(GLenum pname, GLint param) {
+        SG_Log("PixelStorei:" + std::to_string(pname) + ":" + std::to_string(param));
+    }
+    void SG_GenFramebuffers(GLsizei count, GLuint* framebuffers) {
+        for (GLsizei i = 0; i < count; ++i) framebuffers[i] = g_nextStateGuardFBOId++;
+    }
+    void SG_FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
+        SG_Log("FramebufferTexture2D:" + std::to_string(target) + ":" + std::to_string(attachment) + ":" +
+               std::to_string(textarget) + ":" + std::to_string(texture) + ":" + std::to_string(level));
+    }
+    void SG_FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {
+        SG_Log("FramebufferTextureLayer:" + std::to_string(target) + ":" + std::to_string(attachment) + ":" +
+               std::to_string(texture) + ":" + std::to_string(level) + ":" + std::to_string(layer));
+    }
+    void SG_ReadBuffer(GLenum src) {
+        SG_Log("ReadBuffer:" + std::to_string(src));
+    }
+    void SG_DrawBuffers(GLsizei n, const GLenum* bufs) {
+        SG_Log("DrawBuffers:" + std::to_string(n) + ":" + std::to_string(n > 0 && bufs ? bufs[0] : 0));
+    }
+    GLenum SG_NoError() {
+        return GL_NO_ERROR;
+    }
+
+    // Installs the recording table and resets every readback driver-state shadow on
+    // both ends, so these tests cannot bleed into (or inherit from) other tests.
+    struct ScopedStateGuardMocks {
+        ScopedStateGuardMocks(): previousFunctions(MobileGL::MG_Backend::DirectGLES::g_GLESFuncs) {
+            ResetShadows();
+            MobileGL::MG_External::GLESFunctionsTable functions{};
+            functions.glBindBuffer = SG_BindBuffer;
+            functions.glBindFramebuffer = SG_BindFramebuffer;
+            functions.glGetIntegerv = SG_GetIntegerv;
+            functions.glPixelStorei = SG_PixelStorei;
+            functions.glGenFramebuffers = SG_GenFramebuffers;
+            functions.glFramebufferTexture2D = SG_FramebufferTexture2D;
+            functions.glFramebufferTextureLayer = SG_FramebufferTextureLayer;
+            functions.glReadBuffer = SG_ReadBuffer;
+            functions.glDrawBuffers = SG_DrawBuffers;
+            functions.glGetError = SG_NoError;
+            MobileGL::MG_Backend::DirectGLES::SetGLESFuncsTable(functions);
+            g_stateGuardLog = &log;
+        }
+
+        ~ScopedStateGuardMocks() {
+            g_stateGuardLog = nullptr;
+            MobileGL::MG_Backend::DirectGLES::SetGLESFuncsTable(previousFunctions);
+            ResetShadows();
+        }
+
+        ScopedStateGuardMocks(const ScopedStateGuardMocks&) = delete;
+        ScopedStateGuardMocks& operator=(const ScopedStateGuardMocks&) = delete;
+
+        static void ResetShadows() {
+            MobileGL::MG_Backend::DirectGLES::BufferImpl::InvalidatePixelBufferBindingCaches();
+            MobileGL::MG_Backend::DirectGLES::FramebufferImpl::InvalidateFramebufferBindingCache();
+            MobileGL::MG_Backend::DirectGLES::PixelStoreImpl::InvalidatePackStateCache();
+            MobileGL::MG_Backend::DirectGLES::ScratchFBOImpl::OnBackendContextDestroyed();
+        }
+
+        StateGuardCallLog log;
+        MobileGL::MG_External::GLESFunctionsTable previousFunctions;
+    };
+} // namespace
+
+TEST(DirectGLESStateGuards, PixelPackBindingCacheSkipsRedundantBindsAndRestsAtZero) {
+    using namespace MobileGL::MG_Backend::DirectGLES;
+    ScopedStateGuardMocks mocks;
+
+    BufferImpl::BindPixelPackBufferId(5);
+    EXPECT_EQ(mocks.log.Count("BindBuffer:"), 1u);
+    BufferImpl::BindPixelPackBufferId(5); // redundant: must not reach the driver
+    EXPECT_EQ(mocks.log.Count("BindBuffer:"), 1u);
+    BufferImpl::BindPixelPackBufferId(0); // scope exit: resting state
+    EXPECT_EQ(mocks.log.Count("BindBuffer:"), 2u);
+    BufferImpl::BindPixelPackBufferId(0);
+    EXPECT_EQ(mocks.log.Count("BindBuffer:"), 2u);
+
+    // After invalidation (MakeCurrent / context reset) the first bind must reach
+    // the driver again even for the same value.
+    BufferImpl::InvalidatePixelBufferBindingCaches();
+    BufferImpl::BindPixelPackBufferId(0);
+    EXPECT_EQ(mocks.log.Count("BindBuffer:"), 3u);
+}
+
+TEST(DirectGLESStateGuards, FramebufferBindingShadowPinsOnceThenSkips) {
+    using namespace MobileGL::MG_Backend::DirectGLES;
+    ScopedStateGuardMocks mocks;
+
+    // Cold path: one driver query pins the shadow; further reads are free.
+    (void)FramebufferImpl::CurrentFramebufferBinding(MobileGL::FramebufferTarget::Read);
+    EXPECT_EQ(mocks.log.Count("GetIntegerv:"), 1u);
+    (void)FramebufferImpl::CurrentFramebufferBinding(MobileGL::FramebufferTarget::Read);
+    EXPECT_EQ(mocks.log.Count("GetIntegerv:"), 1u);
+
+    FramebufferImpl::BindFramebufferId(GL_READ_FRAMEBUFFER, 7);
+    EXPECT_EQ(mocks.log.Count("BindFramebuffer:"), 1u);
+    FramebufferImpl::BindFramebufferId(GL_READ_FRAMEBUFFER, 7);
+    EXPECT_EQ(mocks.log.Count("BindFramebuffer:"), 1u);
+    // GL_FRAMEBUFFER touches both targets; DRAW is still unknown so it must bind.
+    FramebufferImpl::BindFramebufferId(GL_FRAMEBUFFER, 7);
+    EXPECT_EQ(mocks.log.Count("BindFramebuffer:"), 2u);
+    // Both halves now match: no further calls for either single target.
+    FramebufferImpl::BindFramebufferId(GL_DRAW_FRAMEBUFFER, 7);
+    FramebufferImpl::BindFramebufferId(GL_READ_FRAMEBUFFER, 7);
+    FramebufferImpl::BindFramebufferId(GL_FRAMEBUFFER, 7);
+    EXPECT_EQ(mocks.log.Count("BindFramebuffer:"), 2u);
+    EXPECT_EQ(FramebufferImpl::CurrentFramebufferBinding(MobileGL::FramebufferTarget::Draw), 7u);
+    EXPECT_EQ(mocks.log.Count("GetIntegerv:"), 1u); // shadow answered, no new query
+}
+
+TEST(DirectGLESStateGuards, PackStateShadowAppliesMinimalDeltas) {
+    using namespace MobileGL::MG_Backend::DirectGLES;
+    ScopedStateGuardMocks mocks;
+
+    // First application pins all four parameters.
+    PixelStoreImpl::ApplyPackState(PixelStoreImpl::PackState{4, 0, 0, 0});
+    EXPECT_EQ(mocks.log.Count("PixelStorei:"), 4u);
+    // Identical state: zero driver calls.
+    PixelStoreImpl::ApplyPackState(PixelStoreImpl::PackState{4, 0, 0, 0});
+    EXPECT_EQ(mocks.log.Count("PixelStorei:"), 4u);
+    // One field changed: exactly one driver call.
+    PixelStoreImpl::ApplyPackState(PixelStoreImpl::PackState{1, 0, 0, 0});
+    EXPECT_EQ(mocks.log.Count("PixelStorei:"), 5u);
+
+    const auto current = PixelStoreImpl::CurrentPackState();
+    EXPECT_EQ(current.Alignment, 1);
+    EXPECT_EQ(current.RowLength, 0);
+    EXPECT_EQ(current.SkipRows, 0);
+    EXPECT_EQ(current.SkipPixels, 0);
+}
+
+TEST(DirectGLESStateGuards, ScratchFBODetachesCrossAspectResidue) {
+    using namespace MobileGL::MG_Backend::DirectGLES;
+    ScopedStateGuardMocks mocks;
+
+    auto& fb = ScratchFBOImpl::TempFramebuffer();
+    EXPECT_NE(ScratchFBOImpl::EnsureId(fb), 0u);
+
+    // A depth copy leaves a DEPTH_STENCIL attachment (the pre-fix code never
+    // detached it, wedging every later color readback through this FBO).
+    ScratchFBOImpl::EnsureDepthAttachment2D(fb, GL_DRAW_FRAMEBUFFER, 11, GL_TEXTURE_2D, 0, /*withStencil=*/true);
+    const MobileGL::String dsAttach = "FramebufferTexture2D:" + std::to_string(GL_DRAW_FRAMEBUFFER) + ":" +
+                                      std::to_string(GL_DEPTH_STENCIL_ATTACHMENT);
+    EXPECT_EQ(mocks.log.Count(dsAttach), 1u);
+
+    // The next color use must detach the stale depth-stencil attachment exactly once.
+    mocks.log.calls.clear();
+    ScratchFBOImpl::EnsureColorAttachment2D(fb, GL_READ_FRAMEBUFFER, 22, GL_TEXTURE_2D, 0);
+    const MobileGL::String dsDetach = "FramebufferTexture2D:" + std::to_string(GL_READ_FRAMEBUFFER) + ":" +
+                                      std::to_string(GL_DEPTH_STENCIL_ATTACHMENT) + ":" +
+                                      std::to_string(GL_TEXTURE_2D) + ":0:0";
+    const MobileGL::String colorAttach = "FramebufferTexture2D:" + std::to_string(GL_READ_FRAMEBUFFER) + ":" +
+                                         std::to_string(GL_COLOR_ATTACHMENT0) + ":" +
+                                         std::to_string(GL_TEXTURE_2D) + ":22:0";
+    EXPECT_EQ(mocks.log.Count(dsDetach), 1u);
+    EXPECT_EQ(mocks.log.Count(colorAttach), 1u);
+
+    // Back-to-back identical color use: no driver traffic at all.
+    mocks.log.calls.clear();
+    ScratchFBOImpl::EnsureColorAttachment2D(fb, GL_READ_FRAMEBUFFER, 22, GL_TEXTURE_2D, 0);
+    EXPECT_EQ(mocks.log.Count("FramebufferTexture2D:"), 0u);
+}
+
+TEST(DirectGLESStateGuards, ScratchFBOTextureDeletionForcesFullScrub) {
+    using namespace MobileGL::MG_Backend::DirectGLES;
+    ScopedStateGuardMocks mocks;
+
+    auto& fb = ScratchFBOImpl::TempFramebuffer();
+    ScratchFBOImpl::EnsureId(fb);
+    ScratchFBOImpl::EnsureColorAttachment2D(fb, GL_READ_FRAMEBUFFER, 22, GL_TEXTURE_2D, 0);
+
+    // The attached texture id dies: the shadow can no longer vouch for the FBO
+    // (ES does not auto-detach from unbound FBOs, and the name may be recycled),
+    // so the next use must scrub and re-attach instead of skipping.
+    ScratchFBOImpl::NoteTextureIdDeleted(22);
+    mocks.log.calls.clear();
+    ScratchFBOImpl::EnsureColorAttachment2D(fb, GL_READ_FRAMEBUFFER, 22, GL_TEXTURE_2D, 0);
+    EXPECT_GE(mocks.log.Count("FramebufferTexture2D:"), 2u); // scrub (color + depth) ...
+    const MobileGL::String colorAttach = "FramebufferTexture2D:" + std::to_string(GL_READ_FRAMEBUFFER) + ":" +
+                                         std::to_string(GL_COLOR_ATTACHMENT0) + ":" +
+                                         std::to_string(GL_TEXTURE_2D) + ":22:0";
+    EXPECT_EQ(mocks.log.Count(colorAttach), 1u); // ... then the real re-attach
+}
+
+TEST(DirectGLESStateGuards, ScratchFBOReadDrawBufferStateCached) {
+    using namespace MobileGL::MG_Backend::DirectGLES;
+    ScopedStateGuardMocks mocks;
+
+    auto& fb = ScratchFBOImpl::BlitReadFramebuffer();
+    ScratchFBOImpl::EnsureId(fb);
+
+    // Fresh FBOs default to COLOR_ATTACHMENT0 for both buffers: no call needed.
+    ScratchFBOImpl::EnsureReadBuffer(fb, GL_COLOR_ATTACHMENT0);
+    EXPECT_EQ(mocks.log.Count("ReadBuffer:"), 0u);
+    // Depth blits want GL_NONE; the transition costs one call, repeats are free.
+    ScratchFBOImpl::EnsureReadBuffer(fb, GL_NONE);
+    ScratchFBOImpl::EnsureReadBuffer(fb, GL_NONE);
+    EXPECT_EQ(mocks.log.Count("ReadBuffer:"), 1u);
+    ScratchFBOImpl::EnsureDrawBuffer(fb, GL_NONE);
+    ScratchFBOImpl::EnsureDrawBuffer(fb, GL_NONE);
+    EXPECT_EQ(mocks.log.Count("DrawBuffers:"), 1u);
+}
+
+namespace {
+    MobileGL::Vector<GLuint>* g_deletedTextureIds = nullptr;
+
+    void SG_DeleteTextures(GLsizei count, const GLuint* textures) {
+        if (!g_deletedTextureIds) return;
+        for (GLsizei i = 0; i < count; ++i) g_deletedTextureIds->push_back(textures[i]);
+    }
+
+    // Clears the recording hook even when a gtest assertion unwinds the test body
+    // (a dangling pointer to the dead stack vector would corrupt later tests).
+    struct ScopedDeletedTextureRecording {
+        explicit ScopedDeletedTextureRecording(MobileGL::Vector<GLuint>& sink) { g_deletedTextureIds = &sink; }
+        ~ScopedDeletedTextureRecording() { g_deletedTextureIds = nullptr; }
+        ScopedDeletedTextureRecording(const ScopedDeletedTextureRecording&) = delete;
+        ScopedDeletedTextureRecording& operator=(const ScopedDeletedTextureRecording&) = delete;
+    };
+} // namespace
+
+TEST(DirectGLESBackendTexture, DestructorDeletesIdAndScrubsBindingCache) {
+    using namespace MobileGL::MG_Backend::DirectGLES;
+    ScopedDirectGLESTextureBindings scoped; // installs glGenTextures/glBindTexture mocks + resets caches
+    MobileGL::Vector<GLuint> deleted;
+    ScopedDeletedTextureRecording recording(deleted);
+    auto functions = g_GLESFuncs;
+    functions.glDeleteTextures = SG_DeleteTextures;
+    SetGLESFuncsTable(functions);
+
+    const auto texture2DSlot = static_cast<MobileGL::SizeT>(MobileGL::TextureTarget::Texture2D);
+    GLuint id = 0;
+    {
+        auto backendTexture = MobileGL::MakeShared<TextureImpl::BackendTextureObject>();
+        id = backendTexture->GetBackendTextureId();
+        ASSERT_NE(id, 0u);
+        backendTexture->Bind(GL_TEXTURE_2D, 0);
+        ASSERT_EQ(TextureImpl::g_boundTexturesCache[0][texture2DSlot], backendTexture.get());
+    }
+    // Frontend glDeleteTextures used to leak the backend id forever and leave the
+    // cache pointer dangling (heap-address reuse then false-skips a later Bind).
+    ASSERT_EQ(deleted.size(), 1u);
+    EXPECT_EQ(deleted[0], id);
+    EXPECT_EQ(TextureImpl::g_boundTexturesCache[0][texture2DSlot], nullptr);
+
+    // A wrapper whose context died must NOT delete a foreign (recycled) name.
+    {
+        auto backendTexture = MobileGL::MakeShared<TextureImpl::BackendTextureObject>();
+        ++TextureImpl::g_textureContextGeneration;
+        backendTexture.reset();
+        --TextureImpl::g_textureContextGeneration; // restore for later tests
+        EXPECT_EQ(deleted.size(), 1u);
+    }
+}
+
+TEST(DirectGLESStateGuards, DefaultFramebufferBindGoesThroughShadow) {
+    using namespace MobileGL::MG_Backend::DirectGLES;
+    ScopedStateGuardMocks mocks;
+
+    // The regression this guards against: binding framebuffer 0 raw while the
+    // shadow keeps a user-FBO id makes the next re-bind of that FBO false-skip.
+    FramebufferImpl::BindFramebufferId(GL_DRAW_FRAMEBUFFER, 7);
+    FramebufferImpl::BindFramebufferId(GL_DRAW_FRAMEBUFFER, 0); // default-FBO path must use this API
+    FramebufferImpl::BindFramebufferId(GL_DRAW_FRAMEBUFFER, 7); // must reach the driver again
+    EXPECT_EQ(mocks.log.Count("BindFramebuffer:"), 3u);
+}

MobileGL/MG_Test/ShaderTranspiler/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.14)
+
+add_executable(
+        SpirvPassTest
+        SpirvPassTest.cpp
+)
+
+target_include_directories(SpirvPassTest PRIVATE
+        ${MGL_ROOT}/include
+        ${MGL_ROOT}/MobileGL
+        ${MGL_ROOT}/3rdparty/SPIRV-Reflect
+)
+
+target_link_libraries(
+        SpirvPassTest PRIVATE
+        GTest::gtest_main
+        ${LINK_LIBRARIES}
+)
+
+if (MSVC)
+        target_compile_options(SpirvPassTest PRIVATE /Zc:preprocessor)
+endif()
+
+include(GoogleTest)
+gtest_discover_tests(SpirvPassTest DISCOVERY_TIMEOUT 30 PROPERTIES LABELS unit)

MobileGL/MG_Test/ShaderTranspiler/SpirvPassTest.cpp

@@ -0,0 +1,170 @@
+// MobileGL - MobileGL/MG_Test/ShaderTranspiler/SpirvPassTest.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include <gtest/gtest.h>
+
+#include <MG_Util/ShaderTranspiler/ShaderCompiler.h>
+
+#include <spirv_reflect.h>
+
+using namespace MobileGL;
+using MobileGL::MG_Util::ShaderTranspiler::ShaderCompiler;
+
+namespace {
+    // glslangValidator -V output. Both are vertex shaders writing gl_Position through
+    // the gl_PerVertex block, i.e. the Position builtin arrives as OpMemberDecorate rather
+    // than a plain OpDecorate - the shape real glslang output actually takes.
+
+    //   #version 450
+    //   layout(location = 0) in vec4 inPos;
+    //   void main() { gl_Position = inPos; }
+    constexpr Uint32 kPlainVertexSpirv[] = {
+        0x07230203u, 0x00010000u, 0x0008000bu, 0x00000015u, 0x00000000u, 0x00020011u,
+        0x00000001u, 0x0006000bu, 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu,
+        0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, 0x0007000fu, 0x00000000u,
+        0x00000004u, 0x6e69616du, 0x00000000u, 0x0000000du, 0x00000011u, 0x00030003u,
+        0x00000002u, 0x000001c2u, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u,
+        0x00060005u, 0x0000000bu, 0x505f6c67u, 0x65567265u, 0x78657472u, 0x00000000u,
+        0x00060006u, 0x0000000bu, 0x00000000u, 0x505f6c67u, 0x7469736fu, 0x006e6f69u,
+        0x00070006u, 0x0000000bu, 0x00000001u, 0x505f6c67u, 0x746e696fu, 0x657a6953u,
+        0x00000000u, 0x00070006u, 0x0000000bu, 0x00000002u, 0x435f6c67u, 0x4470696cu,
+        0x61747369u, 0x0065636eu, 0x00070006u, 0x0000000bu, 0x00000003u, 0x435f6c67u,
+        0x446c6c75u, 0x61747369u, 0x0065636eu, 0x00030005u, 0x0000000du, 0x00000000u,
+        0x00040005u, 0x00000011u, 0x6f506e69u, 0x00000073u, 0x00030047u, 0x0000000bu,
+        0x00000002u, 0x00050048u, 0x0000000bu, 0x00000000u, 0x0000000bu, 0x00000000u,
+        0x00050048u, 0x0000000bu, 0x00000001u, 0x0000000bu, 0x00000001u, 0x00050048u,
+        0x0000000bu, 0x00000002u, 0x0000000bu, 0x00000003u, 0x00050048u, 0x0000000bu,
+        0x00000003u, 0x0000000bu, 0x00000004u, 0x00040047u, 0x00000011u, 0x0000001eu,
+        0x00000000u, 0x00020013u, 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u,
+        0x00030016u, 0x00000006u, 0x00000020u, 0x00040017u, 0x00000007u, 0x00000006u,
+        0x00000004u, 0x00040015u, 0x00000008u, 0x00000020u, 0x00000000u, 0x0004002bu,
+        0x00000008u, 0x00000009u, 0x00000001u, 0x0004001cu, 0x0000000au, 0x00000006u,
+        0x00000009u, 0x0006001eu, 0x0000000bu, 0x00000007u, 0x00000006u, 0x0000000au,
+        0x0000000au, 0x00040020u, 0x0000000cu, 0x00000003u, 0x0000000bu, 0x0004003bu,
+        0x0000000cu, 0x0000000du, 0x00000003u, 0x00040015u, 0x0000000eu, 0x00000020u,
+        0x00000001u, 0x0004002bu, 0x0000000eu, 0x0000000fu, 0x00000000u, 0x00040020u,
+        0x00000010u, 0x00000001u, 0x00000007u, 0x0004003bu, 0x00000010u, 0x00000011u,
+        0x00000001u, 0x00040020u, 0x00000013u, 0x00000003u, 0x00000007u, 0x00050036u,
+        0x00000002u, 0x00000004u, 0x00000000u, 0x00000003u, 0x000200f8u, 0x00000005u,
+        0x0004003du, 0x00000007u, 0x00000012u, 0x00000011u, 0x00050041u, 0x00000013u,
+        0x00000014u, 0x0000000du, 0x0000000fu, 0x0003003eu, 0x00000014u, 0x00000012u,
+        0x000100fdu, 0x00010038u,
+    };
+
+    //   ... plus `invariant gl_Position;` - already carries OpMemberDecorate %gl_PerVertex 0
+    //   Invariant, so the pass must not add a duplicate.
+    constexpr Uint32 kAlreadyInvariantVertexSpirv[] = {
+        0x07230203u, 0x00010000u, 0x0008000bu, 0x00000015u, 0x00000000u, 0x00020011u,
+        0x00000001u, 0x0006000bu, 0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu,
+        0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u, 0x0007000fu, 0x00000000u,
+        0x00000004u, 0x6e69616du, 0x00000000u, 0x0000000du, 0x00000011u, 0x00030003u,
+        0x00000002u, 0x000001c2u, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u,
+        0x00060005u, 0x0000000bu, 0x505f6c67u, 0x65567265u, 0x78657472u, 0x00000000u,
+        0x00060006u, 0x0000000bu, 0x00000000u, 0x505f6c67u, 0x7469736fu, 0x006e6f69u,
+        0x00070006u, 0x0000000bu, 0x00000001u, 0x505f6c67u, 0x746e696fu, 0x657a6953u,
+        0x00000000u, 0x00070006u, 0x0000000bu, 0x00000002u, 0x435f6c67u, 0x4470696cu,
+        0x61747369u, 0x0065636eu, 0x00070006u, 0x0000000bu, 0x00000003u, 0x435f6c67u,
+        0x446c6c75u, 0x61747369u, 0x0065636eu, 0x00030005u, 0x0000000du, 0x00000000u,
+        0x00040005u, 0x00000011u, 0x6f506e69u, 0x00000073u, 0x00030047u, 0x0000000bu,
+        0x00000002u, 0x00050048u, 0x0000000bu, 0x00000000u, 0x0000000bu, 0x00000000u,
+        0x00040048u, 0x0000000bu, 0x00000000u, 0x00000012u, 0x00050048u, 0x0000000bu,
+        0x00000001u, 0x0000000bu, 0x00000001u, 0x00050048u, 0x0000000bu, 0x00000002u,
+        0x0000000bu, 0x00000003u, 0x00050048u, 0x0000000bu, 0x00000003u, 0x0000000bu,
+        0x00000004u, 0x00040047u, 0x00000011u, 0x0000001eu, 0x00000000u, 0x00020013u,
+        0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, 0x00030016u, 0x00000006u,
+        0x00000020u, 0x00040017u, 0x00000007u, 0x00000006u, 0x00000004u, 0x00040015u,
+        0x00000008u, 0x00000020u, 0x00000000u, 0x0004002bu, 0x00000008u, 0x00000009u,
+        0x00000001u, 0x0004001cu, 0x0000000au, 0x00000006u, 0x00000009u, 0x0006001eu,
+        0x0000000bu, 0x00000007u, 0x00000006u, 0x0000000au, 0x0000000au, 0x00040020u,
+        0x0000000cu, 0x00000003u, 0x0000000bu, 0x0004003bu, 0x0000000cu, 0x0000000du,
+        0x00000003u, 0x00040015u, 0x0000000eu, 0x00000020u, 0x00000001u, 0x0004002bu,
+        0x0000000eu, 0x0000000fu, 0x00000000u, 0x00040020u, 0x00000010u, 0x00000001u,
+        0x00000007u, 0x0004003bu, 0x00000010u, 0x00000011u, 0x00000001u, 0x00040020u,
+        0x00000013u, 0x00000003u, 0x00000007u, 0x00050036u, 0x00000002u, 0x00000004u,
+        0x00000000u, 0x00000003u, 0x000200f8u, 0x00000005u, 0x0004003du, 0x00000007u,
+        0x00000012u, 0x00000011u, 0x00050041u, 0x00000013u, 0x00000014u, 0x0000000du,
+        0x0000000fu, 0x0003003eu, 0x00000014u, 0x00000012u, 0x000100fdu, 0x00010038u,
+    };
+
+    // OpMemberDecorate <struct-id> <member> <decoration>
+    constexpr Uint32 kOpMemberDecorate = 72;
+    constexpr Uint32 kDecorationInvariant = 18;
+    constexpr Uint32 kSpirvHeaderWordCount = 5;
+
+    // Test-side reference walker. Deliberately independent of the production code so a bug in
+    // the pass cannot hide behind the same helper; only used to count what the pass emitted.
+    Uint32 CountInvariantMemberDecorations(const Vector<Uint32>& spirv) {
+        Uint32 count = 0;
+        for (SizeT i = kSpirvHeaderWordCount; i < spirv.size();) {
+            const Uint32 wordCount = spirv[i] >> 16;
+            const Uint32 opcode = spirv[i] & 0xFFFFu;
+            if (wordCount == 0 || i + wordCount > spirv.size()) {
+                break;
+            }
+            if (opcode == kOpMemberDecorate && wordCount >= 4 && spirv[i + 3] == kDecorationInvariant) {
+                ++count;
+            }
+            i += wordCount;
+        }
+        return count;
+    }
+
+    template <SizeT WordCount>
+    Vector<Uint32> ToVector(const Uint32 (&words)[WordCount]) {
+        return Vector<Uint32>(words, words + WordCount);
+    }
+} // namespace
+
+// --- DecoratePositionInvariantPass ---
+
+TEST(DecoratePositionInvariant, AddsInvariantToThePositionMember) {
+    const Vector<Uint32> input = ToVector(kPlainVertexSpirv);
+    ASSERT_EQ(CountInvariantMemberDecorations(input), 0u);
+
+    Vector<Uint32> output;
+    ASSERT_TRUE(ShaderCompiler::DecoratePositionInvariantForVulkan(input, output));
+    EXPECT_EQ(CountInvariantMemberDecorations(output), 1u);
+}
+
+TEST(DecoratePositionInvariant, DoesNotDuplicateAnExistingInvariant) {
+    const Vector<Uint32> input = ToVector(kAlreadyInvariantVertexSpirv);
+    ASSERT_EQ(CountInvariantMemberDecorations(input), 1u);
+
+    Vector<Uint32> output;
+    ASSERT_TRUE(ShaderCompiler::DecoratePositionInvariantForVulkan(input, output));
+    EXPECT_EQ(CountInvariantMemberDecorations(output), 1u);
+    // The pass reports SuccessWithoutChange here, and SPIRV-Tools asserts (in assert-enabled
+    // builds) that such a run round-trips byte-identically. Pin that from the outside so an
+    // assert-enabled CI build cannot be the first thing to discover a violation.
+    EXPECT_EQ(output, input);
+}
+
+TEST(DecoratePositionInvariant, IsIdempotent) {
+    Vector<Uint32> once;
+    ASSERT_TRUE(ShaderCompiler::DecoratePositionInvariantForVulkan(ToVector(kPlainVertexSpirv), once));
+    Vector<Uint32> twice;
+    ASSERT_TRUE(ShaderCompiler::DecoratePositionInvariantForVulkan(once, twice));
+    EXPECT_EQ(CountInvariantMemberDecorations(twice), 1u);
+}
+
+TEST(DecoratePositionInvariant, OutputStaysAReflectableModule) {
+    Vector<Uint32> output;
+    ASSERT_TRUE(ShaderCompiler::DecoratePositionInvariantForVulkan(ToVector(kPlainVertexSpirv), output));
+
+    SpvReflectShaderModule module{};
+    ASSERT_EQ(spvReflectCreateShaderModule(output.size() * sizeof(Uint32), output.data(), &module),
+              SPV_REFLECT_RESULT_SUCCESS);
+    EXPECT_EQ(module.entry_point_count, 1u);
+    spvReflectDestroyShaderModule(&module);
+}
+
+TEST(DecoratePositionInvariant, RejectsGarbageInput) {
+    const Vector<Uint32> notSpirv{0xdeadbeefu, 0u, 0u, 0u, 0u};
+    Vector<Uint32> output;
+    EXPECT_FALSE(ShaderCompiler::DecoratePositionInvariantForVulkan(notSpirv, output));
+}

MobileGL/MG_Test/Texture/TextureTest.cpp

@@ -318,6 +318,49 @@ TEST_F(TextureTest, CopyTextureSubImage2DUsesNamedObjectAndRestoresBinding) {
     EXPECT_EQ(MG_Impl::GLImpl::GetError(), GL_NO_ERROR);
 }
 
+TEST_F(TextureTest, CopyTextureSubImage2DRejectsCubeMapTargets) {
+    const ScopedTextureBackendFunctionsOverride backendGuard;
+    MG_Backend::gBackendFunctionsTable.GL.CopyTexSubImage2D = RecordCopyTexSubImage2D;
+    g_copyTexSubImage2DCall = {};
+
+    GLuint cubeTexture = 0;
+    MG_Impl::GLImpl::CreateTextures(GL_TEXTURE_CUBE_MAP, 1, &cubeTexture);
+    MG_Impl::GLImpl::CopyTextureSubImage2D(cubeTexture, 0, 0, 0, 0, 0, 1, 1);
+
+    // GL 4.6 sec. 8.8: the 2D form only accepts 2D/1D-array/rectangle effective targets.
+    EXPECT_FALSE(g_copyTexSubImage2DCall.Called);
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), static_cast<GLenum>(GL_INVALID_OPERATION));
+}
+
+TEST_F(TextureTest, ClearTexImageErrorContracts) {
+    GLuint texture = 0;
+    MG_Impl::GLImpl::GenTextures(1, &texture);
+    MG_Impl::GLImpl::BindTexture(GL_TEXTURE_2D, texture);
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 2, 2, 0,
+                                GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+    // Zero texture name is INVALID_OPERATION (ARB_clear_texture).
+    MG_Impl::GLImpl::ClearTexImage(0, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), static_cast<GLenum>(GL_INVALID_OPERATION));
+
+    // A negative level is INVALID_VALUE...
+    MG_Impl::GLImpl::ClearTexImage(texture, -1, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), static_cast<GLenum>(GL_INVALID_VALUE));
+
+    // ...but clearing a level that was never defined is INVALID_OPERATION.
+    MG_Impl::GLImpl::ClearTexImage(texture, 5, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), static_cast<GLenum>(GL_INVALID_OPERATION));
+
+    // A clear region outside the level is INVALID_VALUE.
+    MG_Impl::GLImpl::ClearTexSubImage(texture, 0, 1, 1, 0, 4, 4, 1,
+                                      GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), static_cast<GLenum>(GL_INVALID_VALUE));
+
+    // An invalid pixel-transfer format is INVALID_ENUM from the shared validators.
+    MG_Impl::GLImpl::ClearTexImage(texture, 0, GL_NONE, GL_UNSIGNED_BYTE, nullptr);
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), static_cast<GLenum>(GL_INVALID_ENUM));
+}
+
 // GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT is float state that must answer every numeric query: GetFloatv
 // is authoritative and GetIntegerv would otherwise fall through to its INVALID_ENUM default.
 TEST_F(TextureTest, MaxTextureMaxAnisotropyIsAnsweredFromTheBackendLimit) {
@@ -1384,6 +1427,158 @@ TEST_F(TextureTest, TextureStorage1DAndSubImageModifyNamedObjectOnly) {
     EXPECT_EQ(MG_Impl::GLImpl::GetError(), GL_NO_ERROR);
 }
 
+// Building a mip chain top-down - upload level N, then level 0 - must not destroy the levels
+// already uploaded. AllocateLevel used to resize() the storage down to level+1 on every call, so
+// the level-0 upload truncated the chain to a single level; the higher level then read back as
+// {0,0,0}, IsComplete() rejected the zero-then-nonzero pattern, and DirectGLES answered that by
+// skipping the texture's sync entirely. This is the shape KHR-GL33.texture_repeat_mode uses, and
+// it accounted for 108 CTS failures in every GL version.
+TEST_F(TextureTest, TexImage2DOnLevelZeroKeepsAnAlreadyUploadedHigherLevel) {
+    GLuint texture = 0;
+    MG_Impl::GLImpl::GenTextures(1, &texture);
+    MG_Impl::GLImpl::BindTexture(GL_TEXTURE_2D, texture);
+
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 49, 23, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 98, 46, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+    const auto textureObject = MG_State::pGLContext->GetTextureObject(texture);
+    auto* mipmapObject = static_cast<MG_State::GLState::TextureObjectMipmap*>(textureObject.get());
+    ASSERT_NE(mipmapObject, nullptr);
+    EXPECT_EQ(mipmapObject->GetMipmapLevelCount(), 2u);
+    EXPECT_EQ(mipmapObject->GetMipmapTexelSize(TextureUploadTarget::Texture2D, 0), IntVec3(98, 46, 1));
+    EXPECT_EQ(mipmapObject->GetMipmapTexelSize(TextureUploadTarget::Texture2D, 1), IntVec3(49, 23, 1));
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), GL_NO_ERROR);
+}
+
+// The other half of the contract: respecifying a level 0 that already held an image still drops
+// the chain, exactly as before. Minecraft rebinds the block-atlas name and calls glTexImage2D on
+// level 0 before uploading the new levels; leaving the previous chain in place would strand a tail
+// at the wrong sizes and - because Mojang terminates its chains with a 0x0 level - reproduce the
+// same incomplete-texture black atlas the fix above exists to prevent.
+TEST_F(TextureTest, TexImage2DRespecifyingAnExistingLevelZeroDropsTheStaleChain) {
+    GLuint texture = 0;
+    MG_Impl::GLImpl::GenTextures(1, &texture);
+    MG_Impl::GLImpl::BindTexture(GL_TEXTURE_2D, texture);
+
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 2, GL_RGBA8, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+    const auto textureObject = MG_State::pGLContext->GetTextureObject(texture);
+    auto* mipmapObject = static_cast<MG_State::GLState::TextureObjectMipmap*>(textureObject.get());
+    ASSERT_NE(mipmapObject, nullptr);
+    ASSERT_EQ(mipmapObject->GetMipmapLevelCount(), 3u);
+
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+    EXPECT_EQ(mipmapObject->GetMipmapLevelCount(), 1u);
+    EXPECT_EQ(mipmapObject->GetMipmapTexelSize(TextureUploadTarget::Texture2D, 0), IntVec3(16, 16, 1));
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), GL_NO_ERROR);
+}
+
+// Same-size respecification has to drop the chain too. The Mipmap Levels video setting rebuilds
+// the atlas at identical dimensions with a different level count, so a size-change-only test would
+// let the old tail survive.
+TEST_F(TextureTest, TexImage2DRespecifyingLevelZeroAtTheSameSizeStillDropsTheChain) {
+    GLuint texture = 0;
+    MG_Impl::GLImpl::GenTextures(1, &texture);
+    MG_Impl::GLImpl::BindTexture(GL_TEXTURE_2D, texture);
+
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+    const auto textureObject = MG_State::pGLContext->GetTextureObject(texture);
+    auto* mipmapObject = static_cast<MG_State::GLState::TextureObjectMipmap*>(textureObject.get());
+    ASSERT_NE(mipmapObject, nullptr);
+    EXPECT_EQ(mipmapObject->GetMipmapLevelCount(), 1u);
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), GL_NO_ERROR);
+}
+
+// glTexStorage2D defines exactly `levels` levels. AllocateStorage only grows now, so the immutable
+// path has to drop a longer pre-existing chain explicitly.
+TEST_F(TextureTest, TexStorage2DTrimsALongerPreExistingMipChain) {
+    GLuint texture = 0;
+    MG_Impl::GLImpl::GenTextures(1, &texture);
+    MG_Impl::GLImpl::BindTexture(GL_TEXTURE_2D, texture);
+
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 2, GL_RGBA8, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 3, GL_RGBA8, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+    MG_Impl::GLImpl::TexStorage2D(GL_TEXTURE_2D, 2, GL_RGBA8, 8, 8);
+
+    const auto textureObject = MG_State::pGLContext->GetTextureObject(texture);
+    auto* mipmapObject = static_cast<MG_State::GLState::TextureObjectMipmap*>(textureObject.get());
+    ASSERT_NE(mipmapObject, nullptr);
+    EXPECT_EQ(mipmapObject->GetMipmapLevelCount(), 2u);
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), GL_NO_ERROR);
+}
+
+// glTexImage2D used to reject every GL_COMPRESSED_* internal format with GL_INVALID_ENUM, because
+// none of them mapped to a TextureInternalFormat and the "unknown format" gate fired. They now
+// resolve to the uncompressed storage that backs them - what GL prescribes for the generic formats,
+// and a deliberate deviation for RGTC, which ES cannot compress. The (format, type) pairs below are
+// the ones KHR-GL33.packed_pixels uploads with, so this table doubles as a pin for those 480 cases.
+TEST_F(TextureTest, CompressedInternalFormatsResolveToTheirUncompressedStorage) {
+    struct Case {
+        GLenum internalFormat;
+        GLenum format;
+        GLenum type;
+        TextureInternalFormat expected;
+    };
+    const Case cases[] = {
+        {GL_COMPRESSED_RED, GL_RED, GL_UNSIGNED_BYTE, TextureInternalFormat::R8},
+        {GL_COMPRESSED_RG, GL_RG, GL_UNSIGNED_BYTE, TextureInternalFormat::RG8},
+        {GL_COMPRESSED_RGB, GL_RGB, GL_UNSIGNED_BYTE, TextureInternalFormat::RGB8},
+        {GL_COMPRESSED_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, TextureInternalFormat::RGBA8},
+        {GL_COMPRESSED_SRGB, GL_RGB, GL_UNSIGNED_BYTE, TextureInternalFormat::SRGB8},
+        {GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_UNSIGNED_BYTE, TextureInternalFormat::SRGB8Alpha8},
+        {GL_COMPRESSED_RED_RGTC1, GL_RED, GL_UNSIGNED_BYTE, TextureInternalFormat::R8},
+        {GL_COMPRESSED_RG_RGTC2, GL_RG, GL_UNSIGNED_BYTE, TextureInternalFormat::RG8},
+        // The signed RGTC pair is uploaded as GL_BYTE and must land on SNORM storage - resolving
+        // them to plain R8/RG8 would silently reinterpret negative texels.
+        {GL_COMPRESSED_SIGNED_RED_RGTC1, GL_RED, GL_BYTE, TextureInternalFormat::R8Snorm},
+        {GL_COMPRESSED_SIGNED_RG_RGTC2, GL_RG, GL_BYTE, TextureInternalFormat::RG8Snorm},
+    };
+
+    MG_Impl::GLImpl::PixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    for (const auto& c : cases) {
+        GLuint texture = 0;
+        MG_Impl::GLImpl::GenTextures(1, &texture);
+        MG_Impl::GLImpl::BindTexture(GL_TEXTURE_2D, texture);
+        MG_Impl::GLImpl::TexImage2D(GL_TEXTURE_2D, 0, c.internalFormat, 4, 4, 0, c.format, c.type, nullptr);
+
+        const auto textureObject = MG_State::pGLContext->GetTextureObject(texture);
+        ASSERT_NE(textureObject, nullptr) << "internalFormat 0x" << std::hex << c.internalFormat;
+        EXPECT_EQ(textureObject->GetFormat(), c.expected) << "internalFormat 0x" << std::hex << c.internalFormat;
+        EXPECT_EQ(MG_Impl::GLImpl::GetError(), GL_NO_ERROR) << "internalFormat 0x" << std::hex << c.internalFormat;
+    }
+}
+
+// RGTC compresses 4x4 blocks of a 2D image and has no 3D form, so glTexImage3D must reject it even
+// though the same enum is accepted on a 2D target. The generic compressed formats carry no such
+// restriction and stay legal in 3D.
+TEST_F(TextureTest, RgtcInternalFormatsAreRejectedOnThreeDimensionalTargets) {
+    const GLenum rgtc[] = {GL_COMPRESSED_RED_RGTC1, GL_COMPRESSED_SIGNED_RED_RGTC1, GL_COMPRESSED_RG_RGTC2,
+                           GL_COMPRESSED_SIGNED_RG_RGTC2};
+    for (const GLenum internalFormat : rgtc) {
+        GLuint texture = 0;
+        MG_Impl::GLImpl::GenTextures(1, &texture);
+        MG_Impl::GLImpl::BindTexture(GL_TEXTURE_3D, texture);
+        MG_Impl::GLImpl::TexImage3D(GL_TEXTURE_3D, 0, internalFormat, 4, 4, 4, 0, GL_RED, GL_UNSIGNED_BYTE, nullptr);
+        EXPECT_EQ(MG_Impl::GLImpl::GetError(), GL_INVALID_OPERATION)
+            << "internalFormat 0x" << std::hex << internalFormat;
+    }
+
+    GLuint generic = 0;
+    MG_Impl::GLImpl::GenTextures(1, &generic);
+    MG_Impl::GLImpl::BindTexture(GL_TEXTURE_3D, generic);
+    MG_Impl::GLImpl::TexImage3D(GL_TEXTURE_3D, 0, GL_COMPRESSED_RGBA, 4, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    EXPECT_EQ(MG_Impl::GLImpl::GetError(), GL_NO_ERROR);
+}
+
 TEST_F(TextureTest, TextureStorage3DAndSubImageModifyNamedObjectOnly) {
     GLuint texture = 0;
     MG_Impl::GLImpl::CreateTextures(GL_TEXTURE_3D, 1, &texture);

MobileGL/MG_Util/BackendLoaders/OpenGL/Loader.cpp

@@ -9,7 +9,12 @@
 #include "Loader.h"
 #include "MG_Util/Types.h"
 #include <Config.h>
-#if !defined(__WIN32) && !defined(_WIN32)
+#if defined(_WIN32)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+#else
 #include <dlfcn.h>
 #endif
 
@@ -60,7 +65,14 @@ namespace MobileGL::MG_Util::BackendLoader {
 #endif
 
     static void* OpenLib(const Vector<String>& names) {
-#if !defined(__WIN32) && !defined(_WIN32) && (!defined(__APPLE__) || defined(MOBILEGL_IOS))
+#if defined(_WIN32)
+        for (const auto& name : names) {
+            if (HMODULE lib = LoadLibraryA(name.c_str())) {
+                MGLOG_I("Loaded GL backend library: %s", name.c_str());
+                return reinterpret_cast<void*>(lib);
+            }
+        }
+#elif !defined(__APPLE__) || defined(MOBILEGL_IOS)
         static const String LibPathPrefixes[] = {
 #if defined(MOBILEGL_IOS)
             "@rpath/", "@executable_path/Frameworks/", "@loader_path/Frameworks/",
@@ -104,7 +116,9 @@ namespace MobileGL::MG_Util::BackendLoader {
     }
 
     inline void* ProcAddress(void* lib, const char* name) {
-#if !defined(__WIN32) && !defined(_WIN32) && (!defined(__APPLE__) || defined(MOBILEGL_IOS))
+#if defined(_WIN32)
+        return reinterpret_cast<void*>(::GetProcAddress(reinterpret_cast<HMODULE>(lib), name));
+#elif !defined(__APPLE__) || defined(MOBILEGL_IOS)
         return dlsym(lib, name);
 #else
         return nullptr;
@@ -520,6 +534,15 @@ namespace MobileGL::MG_Util::BackendLoader {
 #if defined(MOBILEGL_TRACE_ANGLE_VARIANTS) && defined(__ANDROID__)
         void* angleGlesLib = nullptr;
 #endif
+#if defined(_WIN32)
+        // ANGLE is the GLES provider on Windows regardless of UseAngle(). Preload
+        // libGLESv2.dll so libEGL.dll resolves its dependency from the same directory.
+        if (!OpenLib({"libGLESv2.dll"})) {
+            MGLOG_E("Failed to open ANGLE libGLESv2.dll");
+            return;
+        }
+        eglLib = OpenLib({"libEGL.dll"});
+#else
         if (UseAngle()) {
             void* glesLib = OpenLib({"libGLESv2_angle.so"});
             if (!glesLib) {
@@ -541,6 +564,7 @@ namespace MobileGL::MG_Util::BackendLoader {
             eglLib = OpenLib({"libEGL.so"});
 #endif
         }
+#endif // !_WIN32
 
         if (!eglLib) {
             MGLOG_E("Failed to open EGL library");
@@ -811,6 +835,9 @@ namespace MobileGL::MG_Util::BackendLoader {
                 if (std::strcmp(extension, "GL_EXT_blend_func_extended") == 0) {
                     caps.SupportsDualSourceBlend = true;
                 }
+                if (std::strcmp(extension, "GL_NV_shader_noperspective_interpolation") == 0) {
+                    caps.SupportsNoperspectiveInterpolation = true;
+                }
             }
         }
 

MobileGL/MG_Util/BackendLoaders/OpenGL/Loader.h

@@ -1050,6 +1050,11 @@ namespace MobileGL {
             // factors and layout(index = 1) fragment outputs. GLES core has no dual-source blending,
             // so without this a draw using a SRC1 factor cannot proceed.
             Bool SupportsDualSourceBlend = false;
+            // GL_NV_shader_noperspective_interpolation is present: the driver accepts the
+            // `noperspective` interpolation qualifier in ESSL. GLES core has none, so without this
+            // 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;
             // GL_RENDERER contains "ANGLE".
             Bool IsAngleRenderer = false;
             // GL_RENDERER contains both "ANGLE" and "llvmpipe".

MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.cpp

@@ -121,6 +121,7 @@ namespace MobileGL::MG_Util::BackendLoader {
         caps.VulkanAPIVersion = DecodeApiVersion(p.apiVersion);
         caps.DeviceName = p.deviceName;
         caps.DriverVersionString = DecodeDriverVersion(p.driverVersion);
+        caps.VendorId = p.vendorID;
         caps.UniformBufferOffsetAlignment = static_cast<int>(p.limits.minUniformBufferOffsetAlignment);
         caps.AliasedLineWidthRangeMin = p.limits.lineWidthRange[0];
         caps.AliasedLineWidthRangeMax = p.limits.lineWidthRange[1];
@@ -210,6 +211,7 @@ namespace MobileGL::MG_Util::BackendLoader {
         caps.VulkanAPIVersion = DecodeApiVersion(properties.apiVersion);
         caps.DeviceName = properties.deviceName;
         caps.DriverVersionString = DecodeDriverVersion(properties.driverVersion);
+        caps.VendorId = properties.vendorID;
         caps.UniformBufferOffsetAlignment = static_cast<int>(properties.limits.minUniformBufferOffsetAlignment);
         caps.AliasedLineWidthRangeMin = properties.limits.lineWidthRange[0];
         caps.AliasedLineWidthRangeMax = properties.limits.lineWidthRange[1];

MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.h

@@ -15,6 +15,8 @@ namespace MobileGL {
             Version VulkanAPIVersion{1, 0, 0};
             String DeviceName;
             String DriverVersionString;
+            // VkPhysicalDeviceProperties::vendorID, for device-quirk vendor gating.
+            Uint32 VendorId = 0;
             Int UniformBufferOffsetAlignment = 256;
             Float AliasedLineWidthRangeMin = 1.0f;
             Float AliasedLineWidthRangeMax = 1.0f;

MobileGL/MG_Util/Converters/GLToMG/TextureEnumConverter.cpp

@@ -255,6 +255,37 @@ namespace MobileGL {
                 return TextureInternalFormat::DepthComponent;
             case GL_DEPTH_STENCIL:
                 return TextureInternalFormat::DepthStencil;
+            // Compressed internal formats resolve to the uncompressed storage that backs them.
+            //
+            // For the six generic formats this is exactly what GL prescribes: the implementation
+            // picks a specific compressed format, and when none is available it falls back to the
+            // corresponding base format. Nothing downstream ever sees a compressed enum, so the
+            // metrics, pixel-store and backend tables keep their "one format, N bytes per texel"
+            // invariant instead of each needing a compressed-aware arm.
+            //
+            // The four RGTC formats are a deliberate deviation: they are specific formats that GL
+            // 3.3 requires, but ES exposes no RGTC compressor to hand the data to. Storing the
+            // texels uncompressed keeps them renderable at the cost of the memory saving, which is
+            // strictly better than the INVALID_ENUM the application used to get. Note the signed
+            // variants must land on SNORM storage - CTS uploads them as GL_BYTE.
+            case GL_COMPRESSED_RED:
+            case GL_COMPRESSED_RED_RGTC1:
+                return TextureInternalFormat::R8;
+            case GL_COMPRESSED_SIGNED_RED_RGTC1:
+                return TextureInternalFormat::R8Snorm;
+            case GL_COMPRESSED_RG:
+            case GL_COMPRESSED_RG_RGTC2:
+                return TextureInternalFormat::RG8;
+            case GL_COMPRESSED_SIGNED_RG_RGTC2:
+                return TextureInternalFormat::RG8Snorm;
+            case GL_COMPRESSED_RGB:
+                return TextureInternalFormat::RGB8;
+            case GL_COMPRESSED_RGBA:
+                return TextureInternalFormat::RGBA8;
+            case GL_COMPRESSED_SRGB:
+                return TextureInternalFormat::SRGB8;
+            case GL_COMPRESSED_SRGB_ALPHA:
+                return TextureInternalFormat::SRGB8Alpha8;
             case GL_ALPHA:
             case GL_RED:
                 return TextureInternalFormat::Red;

MobileGL/MG_Util/Debug/Log.h

@@ -9,10 +9,14 @@
 #pragma once
 #include <Includes.h>
 
+// Severity-ordered: a build compiled at level X keeps X and everything MORE
+// severe. INFO builds must keep WARN/ERROR/FATAL — the old ordering
+// (WARN=1/ERROR=2 below INFO=3) compiled every warning and error out of
+// release builds and hid real backend failures.
 #define MOBILEGL_LOG_LEVEL_DEBUG 0
-#define MOBILEGL_LOG_LEVEL_WARN 1
-#define MOBILEGL_LOG_LEVEL_ERROR 2
-#define MOBILEGL_LOG_LEVEL_INFO 3
+#define MOBILEGL_LOG_LEVEL_INFO 1
+#define MOBILEGL_LOG_LEVEL_WARN 2
+#define MOBILEGL_LOG_LEVEL_ERROR 3
 #define MOBILEGL_LOG_LEVEL_FATAL 4
 
 #define MOBILEGL_LOG_INTERNAL(levelTag, androidLogLevel, fmt, ...)                                                     \

MobileGL/MG_Util/SelfTest/DriverPost.cpp

@@ -401,6 +401,230 @@ namespace MobileGL::MG_Util::SelfTest {
                              disabledNote);
         }
 
+        // Compiles + links a two-stage program on the probe context. Returns 0 on failure and writes a
+        // human-readable reason into |detail|.
+        GLuint CompileLinkProgram(const MG_External::GLESFunctionsTable& g, const char* vs, const char* fs,
+                                  String& detail) {
+            const auto compile = [&](GLenum stage, const char* src, GLuint& out) -> bool {
+                out = g.glCreateShader(stage);
+                if (out == 0) {
+                    detail = "glCreateShader returned 0";
+                    return false;
+                }
+                g.glShaderSource(out, 1, &src, nullptr);
+                g.glCompileShader(out);
+                GLint ok = GL_FALSE;
+                g.glGetShaderiv(out, GL_COMPILE_STATUS, &ok);
+                if (ok != GL_TRUE) {
+                    GLchar log[512] = {};
+                    GLsizei len = 0;
+                    g.glGetShaderInfoLog(out, static_cast<GLsizei>(sizeof(log) - 1), &len, log);
+                    detail = format("{} shader compile failed: {}",
+                                    stage == GL_VERTEX_SHADER ? "vertex" : "fragment",
+                                    len > 0 ? log : "(no info log)");
+                    return false;
+                }
+                return true;
+            };
+            GLuint v = 0, f = 0;
+            const ScopeGuard delV([&]() { if (v) g.glDeleteShader(v); });
+            const ScopeGuard delF([&]() { if (f) g.glDeleteShader(f); });
+            if (!compile(GL_VERTEX_SHADER, vs, v) || !compile(GL_FRAGMENT_SHADER, fs, f)) {
+                return 0;
+            }
+            const GLuint prog = g.glCreateProgram();
+            if (prog == 0) {
+                detail = "glCreateProgram returned 0";
+                return 0;
+            }
+            g.glAttachShader(prog, v);
+            g.glAttachShader(prog, f);
+            g.glLinkProgram(prog);
+            GLint linked = GL_FALSE;
+            g.glGetProgramiv(prog, GL_LINK_STATUS, &linked);
+            if (linked != GL_TRUE) {
+                detail = "program link failed";
+                g.glDeleteProgram(prog);
+                return 0;
+            }
+            return prog;
+        }
+
+        // "noperspective interpolation" row - a real correctness render, not just a compile. A viewport-
+        // filling quad is drawn with strong perspective (left clip-w 1, right clip-w 8) and a varying that
+        // runs 0..1 across it. At the screen centre screen-linear interpolation gives 0.5 while perspective-
+        // correct gives 1/(w+1) ~= 0.11, so reading the centre texel tells the two apart. The varying is
+        // carried either through the native `noperspective` qualifier (extension present) or through the
+        // exact gl_Position.w / gl_FragCoord.w rewrite MobileGL applies when it is absent. Verdict:
+        //   PASS  - extension present and the native noperspective result is screen-linear;
+        //   WARN  - extension absent but the gl_Position.w/gl_FragCoord.w emulation renders screen-linear
+        //           (correct, just the fallback path shipping shader packs hit on such devices);
+        //   FAIL  - either path renders perspective-correct / wrong (noperspective does not actually work),
+        //           or the program will not compile/link, or the render errors.
+        // Requires the probe context to still be current.
+        void ProbeGlesNoperspective(ReportBuilder& builder, const MG_External::GLESCapabilities& caps,
+                                    const MG_External::GLESFunctionsTable& g) {
+            const Bool native = caps.SupportsNoperspectiveInterpolation;
+            const String pathNote = native ? "GL_NV_shader_noperspective_interpolation present (native path)"
+                                           : "GL_NV_shader_noperspective_interpolation absent (gl_Position.w / "
+                                             "gl_FragCoord.w emulation path)";
+            const auto fail = [&](const String& detail) {
+                builder.Fail("noperspective interpolation", pathNote + "; " + detail);
+            };
+
+            if (!g.glCreateShader || !g.glShaderSource || !g.glCompileShader || !g.glGetShaderiv ||
+                !g.glGetShaderInfoLog || !g.glDeleteShader || !g.glCreateProgram || !g.glAttachShader ||
+                !g.glLinkProgram || !g.glGetProgramiv || !g.glUseProgram || !g.glDeleteProgram ||
+                !g.glGenFramebuffers || !g.glBindFramebuffer || !g.glDeleteFramebuffers ||
+                !g.glGenRenderbuffers || !g.glBindRenderbuffer || !g.glRenderbufferStorage ||
+                !g.glFramebufferRenderbuffer || !g.glDeleteRenderbuffers || !g.glCheckFramebufferStatus ||
+                !g.glGenBuffers || !g.glBindBuffer || !g.glBufferData || !g.glDeleteBuffers ||
+                !g.glGetAttribLocation || !g.glVertexAttribPointer || !g.glEnableVertexAttribArray ||
+                !g.glViewport || !g.glClearColor || !g.glClear || !g.glDrawArrays || !g.glReadPixels ||
+                !g.glFinish || !g.glGetError) {
+                fail("the render entry points did not resolve through eglGetProcAddress");
+                return;
+            }
+
+            // Match MobileGL's own ESSL target (the device's version). At #version 300 es some drivers
+            // (Adreno) still treat `noperspective` as reserved even with the extension enabled; the ES 3.2
+            // form the backend actually emits compiles. Emulated shaders are version-agnostic but use the
+            // same header for consistency.
+            const Int esslVer = caps.GLESVersion.Major * 100 + caps.GLESVersion.Minor * 10;
+            const String header = format("#version {} es\n", esslVer >= 300 ? esslVer : 300);
+            static const char* const kVsNativeBody =
+                "#extension GL_NV_shader_noperspective_interpolation : require\n"
+                "in vec4 a_pos;\n"
+                "in float a_v;\n"
+                "noperspective out highp float v_out;\n"
+                "void main() { gl_Position = a_pos; v_out = a_v; }\n";
+            static const char* const kFsNativeBody =
+                "#extension GL_NV_shader_noperspective_interpolation : require\n"
+                "precision highp float;\n"
+                "noperspective in highp float v_out;\n"
+                "out vec4 fragColor;\n"
+                "void main() { fragColor = vec4(v_out, 0.0, 0.0, 1.0); }\n";
+            // Exactly MobileGL's emulation (verified against EmulateNoPerspectivePass output): pre-multiply
+            // the varying by clip-w in the vertex stage, recover with gl_FragCoord.w in the fragment stage,
+            // no noperspective qualifier (so the driver interpolates it perspective-correct).
+            static const char* const kVsEmuBody =
+                "in vec4 a_pos;\n"
+                "in float a_v;\n"
+                "out highp float v_out;\n"
+                "void main() { gl_Position = a_pos; v_out = a_v * gl_Position.w; }\n";
+            static const char* const kFsEmuBody =
+                "precision highp float;\n"
+                "in highp float v_out;\n"
+                "out vec4 fragColor;\n"
+                "void main() { fragColor = vec4(v_out * gl_FragCoord.w, 0.0, 0.0, 1.0); }\n";
+
+            while (g.glGetError() != GL_NO_ERROR) {
+            }
+
+            const String vsSrc = header + (native ? kVsNativeBody : kVsEmuBody);
+            const String fsSrc = header + (native ? kFsNativeBody : kFsEmuBody);
+            String linkDetail;
+            const GLuint prog = CompileLinkProgram(g, vsSrc.c_str(), fsSrc.c_str(), linkDetail);
+            if (prog == 0) {
+                fail(native ? "a noperspective program failed to build though the extension is advertised: " +
+                                  linkDetail
+                            : "the emulation program failed to build: " + linkDetail);
+                return;
+            }
+            const ScopeGuard delProg([&]() { g.glDeleteProgram(prog); });
+
+            // 9x9 so the centre texel (4,4) sits exactly at NDC (0,0).
+            constexpr GLsizei kDim = 9;
+            GLuint rbo = 0, fbo = 0, vbo = 0;
+            g.glGenRenderbuffers(1, &rbo);
+            const ScopeGuard delRbo([&]() { if (rbo) g.glDeleteRenderbuffers(1, &rbo); });
+            g.glBindRenderbuffer(GL_RENDERBUFFER, rbo);
+            g.glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, kDim, kDim);
+            g.glGenFramebuffers(1, &fbo);
+            const ScopeGuard delFbo([&]() {
+                if (fbo) {
+                    g.glBindFramebuffer(GL_FRAMEBUFFER, 0);
+                    g.glDeleteFramebuffers(1, &fbo);
+                }
+            });
+            g.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+            g.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);
+            if (g.glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
+                fail("the probe framebuffer is incomplete");
+                return;
+            }
+
+            // Interleaved [vec4 clip-pos, float v]. Left w=1, right w=8; x/y pre-multiplied by w so the quad
+            // still fills NDC after the perspective divide.
+            const GLfloat verts[] = {
+                -1.f, -1.f, 0.f, 1.f, 0.f, //
+                8.f,  -8.f, 0.f, 8.f, 1.f, //
+                -1.f, 1.f,  0.f, 1.f, 0.f, //
+                8.f,  8.f,  0.f, 8.f, 1.f, //
+            };
+            g.glGenBuffers(1, &vbo);
+            const ScopeGuard delVbo([&]() { if (vbo) g.glDeleteBuffers(1, &vbo); });
+            g.glBindBuffer(GL_ARRAY_BUFFER, vbo);
+            g.glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
+
+            g.glUseProgram(prog);
+            const GLint posLoc = g.glGetAttribLocation(prog, "a_pos");
+            const GLint vLoc = g.glGetAttribLocation(prog, "a_v");
+            if (posLoc < 0 || vLoc < 0) {
+                fail("the probe vertex attributes did not resolve");
+                return;
+            }
+            g.glEnableVertexAttribArray(static_cast<GLuint>(posLoc));
+            g.glVertexAttribPointer(static_cast<GLuint>(posLoc), 4, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat),
+                                    reinterpret_cast<const void*>(0));
+            g.glEnableVertexAttribArray(static_cast<GLuint>(vLoc));
+            g.glVertexAttribPointer(static_cast<GLuint>(vLoc), 1, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat),
+                                    reinterpret_cast<const void*>(4 * sizeof(GLfloat)));
+
+            g.glViewport(0, 0, kDim, kDim);
+            g.glClearColor(0.f, 0.f, 0.f, 1.f);
+            g.glClear(GL_COLOR_BUFFER_BIT);
+            g.glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+            g.glFinish();
+
+            const GLenum drawError = g.glGetError();
+            if (drawError != GL_NO_ERROR) {
+                fail(format("GL error 0x{:x} while rendering the probe quad", drawError));
+                return;
+            }
+
+            GLubyte center[4] = {};
+            g.glReadPixels(kDim / 2, kDim / 2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, center);
+            const GLenum readError = g.glGetError();
+            if (readError != GL_NO_ERROR) {
+                fail(format("GL error 0x{:x} while reading the probe pixel back", readError));
+                return;
+            }
+
+            // At the centre: screen-linear -> 0.5 (~128); perspective-correct -> 1/(8+1) ~= 0.111 (~28).
+            const float observed = static_cast<float>(center[0]) / 255.0f;
+            const int observedByte = center[0];
+            constexpr float kScreenLinear = 0.5f;
+            const bool screenLinear = observed > 0.5f * (kScreenLinear + 1.0f / 9.0f); // midpoint ~= 0.306
+            if (!screenLinear) {
+                fail(format("the centre texel read {} (~{:.3f}); expected the screen-linear ~0.5 - "
+                            "interpolation came out perspective-correct, so noperspective does not work here",
+                            observedByte, observed));
+                return;
+            }
+            if (native) {
+                builder.Pass("noperspective interpolation",
+                             pathNote + format("; native noperspective renders screen-linear (centre {} ~= 0.5)",
+                                               observedByte));
+            } else {
+                builder.Warn("noperspective interpolation",
+                             pathNote +
+                                 format("; the emulation renders screen-linear correctly (centre {} ~= 0.5), "
+                                        "but this is the fallback path with less driver coverage",
+                                        observedByte));
+            }
+        }
+
         // Everything the "MobileGL reported ..." rows need from the GLES device probe.
         struct GlesProbeSummary {
             Bool capsValid = false;
@@ -527,6 +751,7 @@ namespace MobileGL::MG_Util::SelfTest {
             builder.report.rendererInfo = format("{} ({})", caps.GLESRendererString, caps.GLESVersionString);
             EvaluateGlesChecklist(builder, caps, glesFuncs);
             ProbeGlesTimerQuery(builder, caps, glesFuncs);
+            ProbeGlesNoperspective(builder, caps, glesFuncs);
             builder.report.formatCapabilities.emplace();
             MG_Backend::DirectGLES::PopulateFormatCapabilities(
                 glesFuncs, caps, builder.report.formatCapabilities.value());

MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp

@@ -16,9 +16,15 @@
 #include "SpirvPasses/FlattenInterfaceStructPass.h"
 #include "SpirvPasses/RenameSamplerFunctionParameterPass.h"
 #include "SpirvPasses/DecomposeWorkgroupVec3Pass.h"
+#include "SpirvPasses/DecoratePositionInvariantPass.h"
 #include "SpirvPasses/LowerDrawParametersPass.h"
 #include "SpirvPasses/RebaseInstanceIndexPass.h"
 #include "SpirvPasses/StripUboMemberRelaxedPrecisionPass.h"
+#include "SpirvPasses/StripNoPerspectivePass.h"
+#include "SpirvPasses/EmulateNoPerspectivePass.h"
+#include "SpirvPasses/FoldConstOffsetFor1DFetchPass.h"
+#include "SpirvPasses/LowerClipDistanceForEsslPass.h"
+#include "SpirvPasses/DefeatConstStructArrayLutPass.h"
 #include "spirv-tools/libspirv.h"
 #include "spirv-tools/optimizer.hpp"
 
@@ -26,6 +32,7 @@
 #include <MG_Backend/BackendObjects.h>
 #include <MG_Util/Converters/GLToStr/GLEnumConverter.h>
 #include <MG_Util/Converters/GLToGlslang/ProgramEnumConverter.h>
+#include <cstdlib>
 
 namespace MobileGL {
     namespace MG_Util {
@@ -319,6 +326,55 @@ namespace MobileGL {
                 return optimizer.Run(inputBinary.data(), inputBinary.size(), &outputBinary, options);
             }
 
+            bool ShaderCompiler::ClampAccessChainIndicesForEssl(const Vector<Uint32>& inputBinary,
+                                                                Vector<uint32_t>& outputBinary) {
+                using namespace spvtools;
+                OptimizerOptions options;
+                options.set_run_validator(false);
+
+                Optimizer optimizer(SPV_ENV_VULKAN_1_1);
+                optimizer.RegisterPass(CreateGraphicsRobustAccessPass());
+
+                return optimizer.Run(inputBinary.data(), inputBinary.size(), &outputBinary, options);
+            }
+
+            bool ShaderCompiler::FoldConstOffsetFor1DFetchForEssl(const Vector<Uint32>& inputBinary,
+                                                                  Vector<uint32_t>& outputBinary) {
+                using namespace spvtools;
+                OptimizerOptions options;
+                options.set_run_validator(false);
+
+                Optimizer optimizer(SPV_ENV_VULKAN_1_1);
+                optimizer.RegisterPass(FoldConstOffsetFor1DFetchPass::CreateFoldConstOffsetFor1DFetchPass());
+
+                return optimizer.Run(inputBinary.data(), inputBinary.size(), &outputBinary, options);
+            }
+
+            bool ShaderCompiler::LowerClipDistanceForEssl(const Vector<Uint32>& inputBinary,
+                                                          Vector<uint32_t>& outputBinary) {
+                using namespace spvtools;
+                OptimizerOptions options;
+                options.set_run_validator(false);
+
+                Optimizer optimizer(SPV_ENV_VULKAN_1_1);
+                optimizer.RegisterPass(LowerClipDistanceForEsslPass::CreateLowerClipDistanceForEsslPass());
+
+                return optimizer.Run(inputBinary.data(), inputBinary.size(), &outputBinary, options);
+            }
+
+            bool ShaderCompiler::DefeatConstStructArrayLutForEssl(const Vector<Uint32>& inputBinary,
+                                                                  Vector<uint32_t>& outputBinary) {
+                using namespace spvtools;
+                OptimizerOptions options;
+                options.set_run_validator(false);
+
+                Optimizer optimizer(SPV_ENV_VULKAN_1_1);
+                optimizer.RegisterPass(
+                    DefeatConstStructArrayLutPass::CreateDefeatConstStructArrayLutPass());
+
+                return optimizer.Run(inputBinary.data(), inputBinary.size(), &outputBinary, options);
+            }
+
             bool ShaderCompiler::StripUboMemberRelaxedPrecisionForEssl(const Vector<Uint32>& inputBinary,
                                                                        Vector<uint32_t>& outputBinary) {
                 using namespace spvtools;
@@ -332,6 +388,30 @@ namespace MobileGL {
                 return optimizer.Run(inputBinary.data(), inputBinary.size(), &outputBinary, options);
             }
 
+            bool ShaderCompiler::StripNoPerspectiveForEssl(const Vector<Uint32>& inputBinary,
+                                                           Vector<uint32_t>& outputBinary) {
+                using namespace spvtools;
+                OptimizerOptions options;
+                options.set_run_validator(false);
+
+                Optimizer optimizer(SPV_ENV_VULKAN_1_1);
+                optimizer.RegisterPass(StripNoPerspectivePass::CreateStripNoPerspectivePass());
+
+                return optimizer.Run(inputBinary.data(), inputBinary.size(), &outputBinary, options);
+            }
+
+            bool ShaderCompiler::EmulateNoPerspectiveForEssl(const Vector<Uint32>& inputBinary,
+                                                             Vector<uint32_t>& outputBinary) {
+                using namespace spvtools;
+                OptimizerOptions options;
+                options.set_run_validator(false);
+
+                Optimizer optimizer(SPV_ENV_VULKAN_1_1);
+                optimizer.RegisterPass(EmulateNoPerspectivePass::CreateEmulateNoPerspectivePass());
+
+                return optimizer.Run(inputBinary.data(), inputBinary.size(), &outputBinary, options);
+            }
+
             bool ShaderCompiler::RebaseInstanceIndexForVulkan(const Vector<Uint32>& inputBinary,
                                                               Vector<uint32_t>& outputBinary) {
                 using namespace spvtools;
@@ -344,6 +424,18 @@ namespace MobileGL {
                 return optimizer.Run(inputBinary.data(), inputBinary.size(), &outputBinary, options);
             }
 
+            bool ShaderCompiler::DecoratePositionInvariantForVulkan(const Vector<Uint32>& inputBinary,
+                                                                    Vector<uint32_t>& outputBinary) {
+                using namespace spvtools;
+                OptimizerOptions options;
+                options.set_run_validator(false);
+
+                Optimizer optimizer(SPV_ENV_VULKAN_1_1);
+                optimizer.RegisterPass(DecoratePositionInvariantPass::CreateDecoratePositionInvariantPass());
+
+                return optimizer.Run(inputBinary.data(), inputBinary.size(), &outputBinary, options);
+            }
+
             bool ShaderCompiler::UseUnformattedFloatStorageImagesForVulkan(
                 const Vector<Uint32>& inputBinary, Vector<uint32_t>& outputBinary) {
                 constexpr SizeT kSpirvHeaderWordCount = 5;

MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.h

@@ -27,18 +27,65 @@ namespace MobileGL {
                 // Only for backends without native draw-parameter support (DirectGLES).
                 static bool LowerDrawParametersForEssl(const Vector<Uint32>& inputBinary,
                                                        Vector<uint32_t>& outputBinary);
+                // Clamps every access-chain index to its declared bounds (spirv-tools
+                // GraphicsRobustAccessPass). GL 3.3 only promises undefined *values* for
+                // out-of-bounds indexing, but Adreno's ESSL compiler constant-folds a provably
+                // out-of-bounds local-array index into poison that corrupts the whole shader's
+                // output; clamping restores the "some value from the array" contract. Only for
+                // the DirectGLES transpile path.
+                static bool ClampAccessChainIndicesForEssl(const Vector<Uint32>& inputBinary,
+                                                           Vector<uint32_t>& outputBinary);
+                // Folds the ConstOffset image operand of Dim1D OpImageFetch into the integer
+                // coordinate (texelFetchOffset(t,P,l,o) == texelFetch(t,P+o,l)). SPIRV-Cross
+                // emulates 1D samplers as 2D for ES: it widens the coordinate to ivec2 but keeps
+                // the scalar offset, and ESSL has no texelFetchOffset(sampler2D, ivec2, int,
+                // scalar) overload, so Adreno rejects the shader. Only for the DirectGLES
+                // transpile path.
+                static bool FoldConstOffsetFor1DFetchForEssl(const Vector<Uint32>& inputBinary,
+                                                             Vector<uint32_t>& outputBinary);
+                // Shadows gl_ClipDistance in Private mg_ClipDistance/mg_ClipDistanceIn arrays so
+                // the decompiled ESSL only writes the builtin with literal constant indices
+                // (flush before EmitVertex/return) and only reads gl_in clip distances with
+                // dynamic loop indices (copy loop): the other shapes miscompile or crash
+                // Adreno's ESSL compiler. Vertex/geometry stages; DirectGLES transpile path on
+                // Qualcomm only (quirk-gated). See LowerClipDistanceForEsslPass.
+                static bool LowerClipDistanceForEssl(const Vector<Uint32>& inputBinary,
+                                                     Vector<uint32_t>& outputBinary);
+                // Splits a Function-storage array-of-structs variable's single constant-composite
+                // store into per-element stores so SPIRV-Cross does not hoist it into a global
+                // const struct[] LUT, which Adreno cannot dynamically index. DirectGLES
+                // transpile path on Qualcomm only (quirk-gated). See DefeatConstStructArrayLutPass.
+                static bool DefeatConstStructArrayLutForEssl(const Vector<Uint32>& inputBinary,
+                                                             Vector<uint32_t>& outputBinary);
                 // Drops RelaxedPrecision member decorations from uniform-block structs so
                 // SPIRV-Cross prints the same (highp) member precision in every stage; ES
                 // drivers reject cross-stage uniform blocks whose member precisions differ.
                 // Only for the DirectGLES transpile path.
                 static bool StripUboMemberRelaxedPrecisionForEssl(const Vector<Uint32>& inputBinary,
                                                                   Vector<uint32_t>& outputBinary);
+                // Removes NoPerspective decorations so SPIRV-Cross emits plain (smooth) ESSL varyings.
+                // DirectGLES fallback only, for devices lacking GL_NV_shader_noperspective_interpolation
+                // (SPIRV-Cross would otherwise require that extension and the driver would reject it).
+                static bool StripNoPerspectiveForEssl(const Vector<Uint32>& inputBinary,
+                                                      Vector<uint32_t>& outputBinary);
+                // Emulates noperspective (screen-linear) interpolation via gl_Position.w / gl_FragCoord.w
+                // so no NV extension is needed; strips what it cannot emulate. DirectGLES fallback for
+                // devices lacking GL_NV_shader_noperspective_interpolation. See EmulateNoPerspectivePass.
+                static bool EmulateNoPerspectiveForEssl(const Vector<Uint32>& inputBinary,
+                                                        Vector<uint32_t>& outputBinary);
                 // Rebases loads of the InstanceIndex builtin to (InstanceIndex - BaseInstance) so
                 // shaders see GL's zero-based gl_InstanceID. Vertex shaders only; DirectVulkan
                 // backend only (glslang's relaxed mode aliases gl_InstanceID to gl_InstanceIndex,
                 // which wrongly includes baseInstance).
                 static bool RebaseInstanceIndexForVulkan(const Vector<Uint32>& inputBinary,
                                                          Vector<uint32_t>& outputBinary);
+                // Adds the Invariant decoration to every Position builtin output. GL apps
+                // routinely rely on cross-program position invariance for multi-pass
+                // equality depth tests (e.g. GEQUAL re-draws of the same geometry), and
+                // mobile drivers that optimize per-pipeline break that without the
+                // decoration. DirectVulkan only.
+                static bool DecoratePositionInvariantForVulkan(const Vector<Uint32>& inputBinary,
+                                                               Vector<uint32_t>& outputBinary);
                 // Replaces the declared format of float storage images with Unknown and adds the
                 // matching SPIR-V capabilities. DirectVulkan uses this only when both Vulkan
                 // shaderStorageImage*WithoutFormat features are enabled, allowing the

MobileGL/MG_Util/ShaderTranspiler/ShaderSourceProcessor.cpp

@@ -12,6 +12,7 @@
 #include <cctype>
 #include <initializer_list>
 #include <utility>
+#include <Config.h>
 #include <MG_Backend/BackendObjects.h>
 
 namespace {
@@ -95,6 +96,77 @@ namespace {
         return masked;
     }
 
+    // Blank out block comments in place, leaving line comments and every other byte where it is.
+    //
+    // The passes that follow scan the source as raw text, so block comments have to stop being
+    // visible to them - but they must not be *deleted*: replacing the bytes with spaces keeps every
+    // later offset valid and keeps newlines, so glslang's diagnostics still point at the line the
+    // application wrote. It also has to be lexically aware. A banner line such as
+    //
+    //     //*** lighting pass ***
+    //
+    // contains "/*" one byte in, and a naive search for that opener treats the rest of the file as
+    // an unterminated comment.
+    void BlankBlockComments(MobileGL::String& source) {
+        enum class Region { Code, SingleLineComment, MultiLineComment, QuotedText };
+
+        Region region = Region::Code;
+        char quote = '\0';
+        bool escaped = false;
+
+        for (SizeT pos = 0; pos < source.size(); pos++) {
+            const char ch = source[pos];
+            const char next = pos + 1 < source.size() ? source[pos + 1] : '\0';
+
+            if (region == Region::Code) {
+                if (ch == '/' && next == '/') {
+                    pos++;
+                    region = Region::SingleLineComment;
+                } else if (ch == '/' && next == '*') {
+                    source[pos] = ' ';
+                    source[pos + 1] = ' ';
+                    pos++;
+                    region = Region::MultiLineComment;
+                } else if (ch == '"' || ch == '\'') {
+                    quote = ch;
+                    escaped = false;
+                    region = Region::QuotedText;
+                }
+                continue;
+            }
+
+            if (region == Region::SingleLineComment) {
+                if (ch == '\n' || ch == '\r') region = Region::Code;
+                continue;
+            }
+
+            if (region == Region::MultiLineComment) {
+                if (ch == '*' && next == '/') {
+                    source[pos] = ' ';
+                    source[pos + 1] = ' ';
+                    pos++;
+                    region = Region::Code;
+                } else if (ch != '\n' && ch != '\r') {
+                    source[pos] = ' ';
+                }
+                continue;
+            }
+
+            // GLSL has no multi-line string literals, so a quote that reaches end of line was never
+            // a literal to begin with - most likely an apostrophe in a #error or #pragma message.
+            // Ending the region here keeps one stray apostrophe from swallowing the rest of the file.
+            if (ch == '\n' || ch == '\r') {
+                region = Region::Code;
+            } else if (escaped) {
+                escaped = false;
+            } else if (ch == '\\') {
+                escaped = true;
+            } else if (ch == quote) {
+                region = Region::Code;
+            }
+        }
+    }
+
     struct CodeToken {
         String text;
         SizeT begin = 0;
@@ -365,7 +437,21 @@ namespace {
             HasIdentifierWithPrefixOutsideAllowed(tokens, "subgroup", {"subgroupInclusiveAdd"}) ||
             HasIdentifierWithPrefixOutsideAllowed(
                 tokens, "gl_Subgroup",
-                {"gl_SubgroupInvocationID", "gl_SubgroupSize", "gl_SubgroupID", "gl_NumSubgroups"})) {
+                {"gl_SubgroupInvocationID", "gl_SubgroupSize", "gl_SubgroupID", "gl_NumSubgroups"}) ||
+            // ARB/NV spellings of lane-width-sensitive builtins and functions
+            // (gl_SubGroupSizeARB, ballotARB, gl_WarpSizeNV, shuffleNV, ...) must block the
+            // rewrite just like their KHR counterparts: they would silently keep native-width
+            // semantics in a module rewritten to the virtual 32-lane model.
+            HasIdentifierWithPrefixOutsideAllowed(tokens, "gl_SubGroup", {}) ||
+            HasIdentifierWithPrefixOutsideAllowed(tokens, "gl_Warp", {}) ||
+            HasIdentifierWithPrefixOutsideAllowed(tokens, "gl_Thread", {}) ||
+            HasIdentifierWithPrefixOutsideAllowed(tokens, "gl_SMID", {}) ||
+            HasIdentifierWithPrefixOutsideAllowed(tokens, "ballot", {}) ||
+            HasIdentifierWithPrefixOutsideAllowed(tokens, "shuffle", {}) ||
+            HasIdentifierWithPrefixOutsideAllowed(tokens, "readInvocation", {}) ||
+            HasIdentifierWithPrefixOutsideAllowed(tokens, "readFirstInvocation", {}) ||
+            HasIdentifierWithPrefixOutsideAllowed(tokens, "anyInvocation", {}) ||
+            HasIdentifierWithPrefixOutsideAllowed(tokens, "allInvocations", {})) {
             return false;
         }
 
@@ -487,6 +573,23 @@ namespace {
                static_cast<unsigned char>(source[1]) == 0xbb && static_cast<unsigned char>(source[2]) == 0xbf;
     }
 
+    // The GLSL versions MobileGL is willing to normalize. Anything else in a #version line - a number
+    // that is not a real language version (329, 331), a bad profile keyword, a float/identifier where
+    // the integer belongs, or trailing tokens - is left untouched so glslang rejects it, matching
+    // KHR-GL33.shaders.preprocessor.directive.version_*. The set is deliberately generous (every real
+    // desktop and ES version) so the normalizer never starts rejecting a form it used to accept.
+    bool IsRecognizedGlslVersion(unsigned version) {
+        switch (version) {
+            case 100: case 110: case 120: case 130: case 140: case 150:
+            case 300: case 310: case 320:
+            case 330: case 400: case 410: case 420: case 430:
+            case 440: case 450: case 460:
+                return true;
+            default:
+                return false;
+        }
+    }
+
     struct ShaderLanguageInfo {
         unsigned version = 110;
         MobileGL::ShaderProfile profile = MobileGL::ShaderProfile::Core;
@@ -494,6 +597,9 @@ namespace {
         SizeT versionDirectiveEnd = MobileGL::String::npos;
         bool hasUtf8Bom = false;
         bool enablesGpuShader5 = false;
+        // Whether the parsed #version directive is a well-formed one MobileGL should rewrite. A
+        // malformed directive (see IsRecognizedGlslVersion) is left alone for glslang to reject.
+        bool hasValidVersionDirective = false;
 
         bool HasVersionDirective() const { return versionDirectiveStart != MobileGL::String::npos; }
     };
@@ -537,13 +643,25 @@ namespace {
                         info.versionDirectiveEnd = lineEnd + (hasLineBreak ? 1 : 0);
                         SkipDirectiveWhitespace(code, probe, lineEnd);
                         const MobileGL::String profile = ReadDirectiveIdentifier(code, probe, lineEnd);
-                        if (profile == "es" || profile == "ES") {
+                        bool profileTokenValid = true;
+                        if (profile.empty() || profile == "core") {
+                            info.profile = MobileGL::ShaderProfile::Core;
+                        } else if (profile == "es" || profile == "ES") {
                             info.profile = MobileGL::ShaderProfile::ES;
                         } else if (profile == "compatibility") {
                             info.profile = MobileGL::ShaderProfile::Compatibility;
                         } else {
+                            // "#version 330 foo": an unrecognized profile keyword. Keep Core for any
+                            // downstream routing, but mark the directive malformed.
                             info.profile = MobileGL::ShaderProfile::Core;
+                            profileTokenValid = false;
                         }
+                        // Comments are already masked to spaces, so anything non-blank left on the
+                        // line is real trailing garbage: "#version 330 foobar" / "#version 330.0".
+                        SkipDirectiveWhitespace(code, probe, lineEnd);
+                        const bool hasTrailingTokens = probe < lineEnd;
+                        info.hasValidVersionDirective =
+                            IsRecognizedGlslVersion(info.version) && profileTokenValid && !hasTrailingTokens;
                     }
                 } else if (directive == "extension") {
                     SkipDirectiveWhitespace(code, probe, lineEnd);
@@ -590,6 +708,17 @@ namespace {
     }
 
     void NormalizeVersionDirective(MobileGL::String& source, const ShaderLanguageInfo& info) {
+        // A malformed #version (329, 331, bad profile, float/trailing tokens) is left exactly as the
+        // application wrote it so glslang rejects it - rewriting it to "#version 330 core" would
+        // silently legalize the CTS directive.version_* rejection cases. Still drop a leading BOM so
+        // the reported error is the bad version rather than a stray byte-order mark.
+        if (info.HasVersionDirective() && !info.hasValidVersionDirective) {
+            if (info.hasUtf8Bom) {
+                source.erase(0, 3);
+            }
+            return;
+        }
+
         const MobileGL::String replacement = GetNormalizedVersionDirective(info);
         if (info.HasVersionDirective()) {
             source.replace(info.versionDirectiveStart, info.versionDirectiveEnd - info.versionDirectiveStart,
@@ -671,7 +800,10 @@ namespace {
 
     void RenameBuiltinShadowingFunction(MobileGL::String& source, const char* from, const char* to) {
         const MobileGL::String fromName = from;
-        if (!HasSingleLineFunctionDefinition(source, fromName)) {
+        // Decide from a comment-free view. A commented-out definition is not a definition, and
+        // acting on one renames every genuine call to the builtin to a name nothing defines - which
+        // then fails to resolve. Line comments survive BlankBlockComments, so this matters.
+        if (!HasSingleLineFunctionDefinition(MaskCommentsAndQuotedText(source), fromName)) {
             return;
         }
 
@@ -744,6 +876,58 @@ namespace {
         return info.HasVersionDirective() ? info.versionDirectiveEnd : 0;
     }
 
+    // GLSL's #line takes integer expressions only, but plenty of shader-pack preprocessors emit the
+    // C form with a quoted filename. Deleting every #line outright made those harmless - at the cost
+    // of __LINE__ reporting the position in MobileGL's rewritten text rather than the one the pack
+    // author wrote, and of every later diagnostic pointing at the wrong line. Dropping just the
+    // quoted operand keeps the directive doing its job and still hands glslang something it accepts.
+    void NormalizeLineDirectives(MobileGL::String& source) {
+        const MobileGL::String masked = MaskCommentsAndQuotedText(source);
+        const SizeT versionEnd = FindAfterVersionDirective(source);
+        MobileGL::String result;
+        result.reserve(source.size());
+
+        SizeT lineStart = 0;
+        while (lineStart <= source.size()) {
+            SizeT lineEnd = source.find('\n', lineStart);
+            const bool lastLine = lineEnd == MobileGL::String::npos;
+            if (lastLine) lineEnd = source.size();
+
+            SizeT probe = lineStart;
+            while (probe < lineEnd && (source[probe] == ' ' || source[probe] == '\t')) probe++;
+
+            const bool isLineDirective = masked.compare(probe, 5, "#line") == 0 &&
+                                         (probe + 5 >= lineEnd || !IsIdentifierChar(source[probe + 5]));
+            if (isLineDirective && lineStart < versionEnd) {
+                // #version has to be the first token in the shader, so a #line ahead of it could
+                // never have taken effect. Drop it rather than hand glslang a source it must reject
+                // - some pack preprocessors emit their directives before the version line.
+            } else if (isLineDirective) {
+                // Keep everything up to the first quote that the masker identified as string text.
+                SizeT quotePos = MobileGL::String::npos;
+                for (SizeT i = probe + 5; i < lineEnd; i++) {
+                    if (source[i] == '"' || source[i] == '\'') {
+                        quotePos = i;
+                        break;
+                    }
+                }
+                if (quotePos != MobileGL::String::npos) {
+                    result.append(source, lineStart, quotePos - lineStart);
+                } else {
+                    result.append(source, lineStart, lineEnd - lineStart);
+                }
+            } else {
+                result.append(source, lineStart, lineEnd - lineStart);
+            }
+
+            if (lastLine) break;
+            result.push_back('\n');
+            lineStart = lineEnd + 1;
+        }
+
+        source = std::move(result);
+    }
+
     bool IsExtensionAdvertised(MobileGL::GLExtension extension) {
         const auto& activeBackendObject = MobileGL::MG_Backend::pActiveBackendObject;
         if (!activeBackendObject) {
@@ -772,15 +956,28 @@ namespace {
             return;
         }
 
+        // Detect the directive on a comment/string-masked copy so a commented-out
+        // "#extension GL_ARB_gpu_shader_int64" is never turned into a synthesized #error. Comments are
+        // no longer blanked in the delivered source (glslang handles them), so this pass must mask
+        // locally like its siblings. Masking preserves offsets, so edits collected against the scan
+        // apply verbatim to `source`; they are applied back-to-front to keep earlier offsets valid.
+        const MobileGL::String scan = MaskCommentsAndQuotedText(source);
+        struct DirectiveEdit {
+            SizeT pos;
+            SizeT len;
+            MobileGL::String replacement;
+        };
+        Vector<DirectiveEdit> edits;
+
         SizeT lineStart = 0;
-        while (lineStart < source.size()) {
-            SizeT lineEnd = source.find('\n', lineStart);
+        while (lineStart < scan.size()) {
+            SizeT lineEnd = scan.find('\n', lineStart);
             const bool hasLineBreak = lineEnd != MobileGL::String::npos;
             if (!hasLineBreak) {
-                lineEnd = source.size();
+                lineEnd = scan.size();
             }
 
-            const MobileGL::String line = source.substr(lineStart, lineEnd - lineStart);
+            const MobileGL::String line = scan.substr(lineStart, lineEnd - lineStart);
             SizeT probe = 0;
             while (probe < line.size() && std::isspace(static_cast<unsigned char>(line[probe]))) {
                 probe++;
@@ -822,16 +1019,12 @@ namespace {
                             const MobileGL::String behavior = TrimDirectiveToken(line.substr(probe));
                             const SizeT replaceLen = lineEnd - lineStart + (hasLineBreak ? 1 : 0);
                             if (behavior == "require") {
-                                const MobileGL::String replacement =
-                                    "#error GL_ARB_gpu_shader_int64 is not advertised by MobileGL\n";
-                                source.replace(lineStart, replaceLen, replacement);
-                                lineStart += replacement.size();
+                                edits.push_back({lineStart, replaceLen,
+                                                 "#error GL_ARB_gpu_shader_int64 is not advertised by MobileGL\n"});
                             } else if (behavior == "enable" || behavior == "warn") {
-                                source.replace(lineStart, replaceLen, "\n");
-                                lineStart++;
-                            } else {
-                                lineStart = lineEnd + (hasLineBreak ? 1 : 0);
+                                edits.push_back({lineStart, replaceLen, "\n"});
                             }
+                            lineStart = lineEnd + (hasLineBreak ? 1 : 0);
                             continue;
                         }
                     }
@@ -841,6 +1034,10 @@ namespace {
             lineStart = lineEnd + (hasLineBreak ? 1 : 0);
         }
 
+        for (auto it = edits.rbegin(); it != edits.rend(); ++it) {
+            source.replace(it->pos, it->len, it->replacement);
+        }
+
         ReplaceIdentifier(source, "GL_ARB_gpu_shader_int64", "MG_DISABLED_GL_ARB_gpu_shader_int64");
     }
 
@@ -967,6 +1164,14 @@ namespace MobileGL {
                 const Vector<CodeToken> tokens = TokenizeCode(source);
                 LinearPrefixScanMatch match;
                 if (!ParseLinearPrefixScanTemplate(tokens, match)) {
+                    // Diagnosability: when the trigger op is present but the template no longer
+                    // matches (e.g. the pack shipped a new shader revision), the affected device
+                    // silently falls back to the driver's miscompiled path. Make that visible.
+                    if (CountToken(tokens, "subgroupInclusiveAdd") > 0) {
+                        MGLOG_W("%s: subgroupInclusiveAdd present but the linear prefix-scan template "
+                                "did not match; the wide-subgroup rewrite was NOT applied",
+                                __func__);
+                    }
                     return false;
                 }
 
@@ -979,48 +1184,98 @@ namespace MobileGL {
                 return true;
             }
 
+            namespace {
+                struct ShaderSourceQuirkContext {
+                    ShaderStage stage = ShaderStage::Unknown;
+                    BackendType backend = BackendType::Unknown;
+                    MG_Backend::GpuVendorKind vendor = MG_Backend::GpuVendorKind::Unknown;
+                    Uint32 subgroupSize = 0;
+                };
+
+                // Device-quirk registry. Every entry is a narrowly scoped source rewrite that
+                // works around a specific driver defect. A quirk runs when its env override
+                // forces it on, or when the override is Auto and DeviceApplies matches the
+                // detected device. ForceOn bypasses only the device gate - each Apply keeps
+                // its own structural safety checks. Add new per-device workarounds here
+                // instead of open-coding them in PreprocessShaderSource.
+                struct ShaderSourceQuirk {
+                    const char* name;
+                    MG_Config::QuirkOverride (*GetOverride)();
+                    Bool (*DeviceApplies)(const ShaderSourceQuirkContext&);
+                    Bool (*Apply)(const ShaderSourceQuirkContext&, String&);
+                };
+
+                constexpr ShaderSourceQuirk kShaderSourceQuirks[] = {
+                    {
+                        // MOBILEGL_QUIRK_SUBGROUP_PREFIX_SCAN
+                        "subgroup-prefix-scan-rewrite",
+                        [] { return MG_Config::Features.SubgroupPrefixScanQuirk; },
+                        [](const ShaderSourceQuirkContext& ctx) {
+                            // Qualcomm's Vulkan driver miscompiles the recognized float
+                            // InclusiveScan pattern for native subgroups wider than the
+                            // captured 32 lanes; other vendors compile it correctly and
+                            // should keep their native scan.
+                            return ctx.backend == BackendType::DirectVulkan &&
+                                   ctx.vendor == MG_Backend::GpuVendorKind::Qualcomm;
+                        },
+                        [](const ShaderSourceQuirkContext& ctx, String& source) {
+                            return RewriteLinearSubgroupPrefixScanForVulkan(ctx.stage, ctx.subgroupSize,
+                                                                            source);
+                        },
+                    },
+                };
+
+                void ApplyShaderSourceQuirks(ShaderStage stage, String& source) {
+                    const auto& activeBackend = MG_Backend::pActiveBackendObject;
+                    if (!activeBackend) {
+                        return;
+                    }
+                    const auto& dynamicParameters = activeBackend->GetDynamicParameters();
+                    const ShaderSourceQuirkContext quirkContext{
+                        stage,
+                        activeBackend->GetBackendType(),
+                        dynamicParameters.GpuVendor,
+                        dynamicParameters.SubgroupSize,
+                    };
+                    for (const ShaderSourceQuirk& quirk : kShaderSourceQuirks) {
+                        const MG_Config::QuirkOverride quirkOverride = quirk.GetOverride();
+                        if (quirkOverride == MG_Config::QuirkOverride::ForceOff) {
+                            continue;
+                        }
+                        if (quirkOverride == MG_Config::QuirkOverride::Auto &&
+                            !quirk.DeviceApplies(quirkContext)) {
+                            continue;
+                        }
+                        if (quirk.Apply(quirkContext, source)) {
+                            MGLOG_I("ApplyShaderSourceQuirks: applied '%s'%s", quirk.name,
+                                    quirkOverride == MG_Config::QuirkOverride::ForceOn ? " (forced on)" : "");
+                        }
+                    }
+                }
+            } // namespace
+
             void PreprocessShaderSource(ShaderStage stage, String& source) {
                 // Normalize while the inspector's source span still refers to the untouched input. Later passes
                 // remove comments and directives, so any subsequent insertion re-inspects the current source.
                 const ShaderLanguageInfo originalLanguage = InspectShaderLanguage(source);
                 NormalizeVersionDirective(source, originalLanguage);
 
-                // remove multi-line comment
-                size_t commentStartPos = source.find("/*");
-                while (commentStartPos != String::npos) {
-                    size_t commentEndPos = source.find("*/", commentStartPos);
-                    if (commentEndPos == String::npos) {
-                        source.erase(commentStartPos);
-                        break;
-                    }
-                    // + length of "*/"
-                    source = source.replace(commentStartPos, commentEndPos - commentStartPos + 2, "");
-                    commentStartPos = source.find("/*", commentStartPos);
-                }
+                // Comments are left intact for glslang's own preprocessor: a block comment is a single
+                // preprocessing token that collapses to one space even across newlines and inside a
+                // directive, so blanking it here (which preserved the interior newlines) truncated
+                // multi-line #define bodies and broke otherwise-valid shaders (KHR-GL3x.shaders.
+                // preprocessor multiline_comment_define / redefine_object / function_redefinition).
+                // Every MobileGL pass that must ignore comment/string text already masks them locally
+                // via MaskCommentsAndQuotedText/TokenizeCode, so the source we hand glslang keeps them.
+                NormalizeLineDirectives(source);
 
-                // remove #line directives
-                SizeT linedirPos = source.find("#line");
-                while (linedirPos != String::npos) {
-                    SizeT newlinePos = source.find('\n', linedirPos);
-                    if (newlinePos == String::npos) {
-                        source.erase(linedirPos);
-                        break;
-                    }
-
-                    // Preserve a line break so adjacent preprocessor directives do not merge.
-                    source = source.replace(linedirPos, newlinePos - linedirPos + 1, "\n");
-                    linedirPos = source.find("#line", linedirPos);
-                }
-
-                // remove "noperspective"
-                const char* str_np = "noperspective";
-                const SizeT len_np = strlen(str_np);
-                SizeT noperspectivePos = source.find(str_np);
-                while (noperspectivePos != String::npos) {
-                    // + length of "\n"
-                    source = source.replace(noperspectivePos, len_np, "");
-                    noperspectivePos = source.find(str_np);
-                }
+                // noperspective is intentionally NOT touched here. It is core in desktop GLSL (1.30+)
+                // and maps to the core SPIR-V NoPerspective decoration, which DirectVulkan renders
+                // natively and SPIRV-Cross turns into ESSL `noperspective` + the
+                // GL_NV_shader_noperspective_interpolation extension. The old naked substring erase
+                // both discarded that interpolation (shader packs need it) and corrupted any
+                // identifier that merely contained the word. The GLES fallback for devices without
+                // the extension lives in the backend, where device capabilities are known.
 
                 FilterUnsupportedGpuShaderInt64(source);
                 CoerceUniformBlockPackingToStd140(source);
@@ -1035,12 +1290,7 @@ namespace MobileGL {
                 ModernizeLegacyGLSL(stage, source);
                 InjectDepthRangeBuiltinShim(stage, source);
 
-                const auto& activeBackend = MG_Backend::pActiveBackendObject;
-                if (stage == ShaderStage::Compute && activeBackend &&
-                    activeBackend->GetBackendType() == BackendType::DirectVulkan) {
-                    RewriteLinearSubgroupPrefixScanForVulkan(stage, activeBackend->GetDynamicParameters().SubgroupSize,
-                                                             source);
-                }
+                ApplyShaderSourceQuirks(stage, source);
             }
 
             Bool RetargetLegacyVersionDirectiveTo460(String& source) {
@@ -1049,6 +1299,10 @@ namespace MobileGL {
                 // must not be mistaken for the real one.
                 const ShaderLanguageInfo info = InspectShaderLanguage(source);
                 if (!info.HasVersionDirective()) return false;
+                // Never rescue a malformed directive to 460: that is precisely what re-legalized the
+                // CTS directive.version_* rejection cases after the first compile failed. The shader-
+                // pack retry this exists for only ever sees a valid low version (a real "#version 330").
+                if (!info.hasValidVersionDirective) return false;
                 // 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;

MobileGL/MG_Util/ShaderTranspiler/ShaderSourceProcessor.h

@@ -27,8 +27,10 @@ namespace MobileGL {
             // wider than the capture's 32 lanes. For the narrowly recognized, uniform-control-
             // flow template, replace the subgroup-local scan with a shared-memory, strict
             // left-fold over virtual 32-lane segments. Returns true only when the complete safe
-            // template was recognized and rewritten. DirectVulkan calls this through
-            // PreprocessShaderSource; the explicit entry point exists for deterministic tests.
+            // template was recognized and rewritten. PreprocessShaderSource reaches this through
+            // its device-quirk registry: by default only on detected Qualcomm Vulkan devices,
+            // overridable either way with MOBILEGL_QUIRK_SUBGROUP_PREFIX_SCAN=1/0. The explicit
+            // entry point exists for deterministic tests.
             Bool RewriteLinearSubgroupPrefixScanForVulkan(ShaderStage stage, Uint32 nativeSubgroupSize, String& source);
 
             // Rewrites a "#version 330 core" directive that PreprocessShaderSource normalized down

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecoratePositionInvariantPass.cpp

@@ -0,0 +1,139 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecoratePositionInvariantPass.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "DecoratePositionInvariantPass.h"
+
+#include "spirv.hpp"
+#include "source/opt/instruction.h"
+#include "source/opt/ir_context.h"
+#include "source/util/make_unique.h"
+
+#include <algorithm>
+#include <vector>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            namespace {
+                using spvtools::opt::Instruction;
+                using spvtools::opt::IRContext;
+                using spvtools::opt::Operand;
+
+                // Identifies one member of a decorated struct (gl_PerVertex's Position slot).
+                struct MemberKey {
+                    uint32_t id = 0;
+                    uint32_t member = 0;
+                    bool operator==(const MemberKey& other) const {
+                        return id == other.id && member == other.member;
+                    }
+                };
+
+                // OpDecorate      <target-id> <decoration> [literals...]
+                // OpMemberDecorate <struct-id> <member> <decoration> [literals...]
+                constexpr uint32_t kDecorateTargetOperand = 0;
+                constexpr uint32_t kDecorateDecorationOperand = 1;
+                constexpr uint32_t kDecorateBuiltInOperand = 2;
+                constexpr uint32_t kMemberDecorateStructOperand = 0;
+                constexpr uint32_t kMemberDecorateMemberOperand = 1;
+                constexpr uint32_t kMemberDecorateDecorationOperand = 2;
+                constexpr uint32_t kMemberDecorateBuiltInOperand = 3;
+            } // namespace
+
+            spvtools::opt::Pass::Status DecoratePositionInvariantPass::Process() {
+                auto* irContext = context();
+
+                // Collect first: AddAnnotationInst mutates the list being walked.
+                std::vector<uint32_t> invariantIds;
+                std::vector<MemberKey> invariantMembers;
+                std::vector<uint32_t> positionIds;
+                std::vector<MemberKey> positionMembers;
+
+                for (const Instruction& annotation : irContext->annotations()) {
+                    if (annotation.opcode() == spv::Op::OpDecorate) {
+                        if (annotation.NumInOperands() <= kDecorateDecorationOperand) {
+                            continue;
+                        }
+                        const auto decoration = static_cast<spv::Decoration>(
+                            annotation.GetSingleWordInOperand(kDecorateDecorationOperand));
+                        const uint32_t target = annotation.GetSingleWordInOperand(kDecorateTargetOperand);
+                        if (decoration == spv::Decoration::Invariant) {
+                            invariantIds.push_back(target);
+                        } else if (decoration == spv::Decoration::BuiltIn &&
+                                   annotation.NumInOperands() > kDecorateBuiltInOperand &&
+                                   static_cast<spv::BuiltIn>(annotation.GetSingleWordInOperand(
+                                       kDecorateBuiltInOperand)) == spv::BuiltIn::Position) {
+                            positionIds.push_back(target);
+                        }
+                    } else if (annotation.opcode() == spv::Op::OpMemberDecorate) {
+                        if (annotation.NumInOperands() <= kMemberDecorateDecorationOperand) {
+                            continue;
+                        }
+                        const auto decoration = static_cast<spv::Decoration>(
+                            annotation.GetSingleWordInOperand(kMemberDecorateDecorationOperand));
+                        const MemberKey key{
+                            annotation.GetSingleWordInOperand(kMemberDecorateStructOperand),
+                            annotation.GetSingleWordInOperand(kMemberDecorateMemberOperand)};
+                        if (decoration == spv::Decoration::Invariant) {
+                            invariantMembers.push_back(key);
+                        } else if (decoration == spv::Decoration::BuiltIn &&
+                                   annotation.NumInOperands() > kMemberDecorateBuiltInOperand &&
+                                   static_cast<spv::BuiltIn>(annotation.GetSingleWordInOperand(
+                                       kMemberDecorateBuiltInOperand)) == spv::BuiltIn::Position) {
+                            positionMembers.push_back(key);
+                        }
+                    }
+                }
+
+                Bool changed = false;
+
+                for (const uint32_t target : positionIds) {
+                    if (std::find(invariantIds.begin(), invariantIds.end(), target) != invariantIds.end()) {
+                        continue;
+                    }
+                    irContext->AddAnnotationInst(spvtools::MakeUnique<Instruction>(
+                        irContext, spv::Op::OpDecorate, 0, 0,
+                        std::initializer_list<Operand>{
+                            {SPV_OPERAND_TYPE_ID, {target}},
+                            {SPV_OPERAND_TYPE_DECORATION,
+                             {static_cast<uint32_t>(spv::Decoration::Invariant)}}}));
+                    // Guard against a second Position decoration on the same target.
+                    invariantIds.push_back(target);
+                    changed = true;
+                }
+
+                for (const MemberKey& key : positionMembers) {
+                    if (std::find(invariantMembers.begin(), invariantMembers.end(), key) !=
+                        invariantMembers.end()) {
+                        continue;
+                    }
+                    irContext->AddAnnotationInst(spvtools::MakeUnique<Instruction>(
+                        irContext, spv::Op::OpMemberDecorate, 0, 0,
+                        std::initializer_list<Operand>{
+                            {SPV_OPERAND_TYPE_ID, {key.id}},
+                            {SPV_OPERAND_TYPE_LITERAL_INTEGER, {key.member}},
+                            {SPV_OPERAND_TYPE_DECORATION,
+                             {static_cast<uint32_t>(spv::Decoration::Invariant)}}}));
+                    invariantMembers.push_back(key);
+                    changed = true;
+                }
+
+                if (!changed) {
+                    return Status::SuccessWithoutChange;
+                }
+
+                irContext->InvalidateAnalysesExceptFor(IRContext::kAnalysisNone);
+                return Status::SuccessWithChange;
+            }
+
+            spvtools::Optimizer::PassToken
+            DecoratePositionInvariantPass::CreateDecoratePositionInvariantPass() {
+                return spvtools::Optimizer::PassToken(MakeUnique<DecoratePositionInvariantPass>());
+            }
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecoratePositionInvariantPass.h

@@ -0,0 +1,35 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecoratePositionInvariantPass.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include "source/opt/pass.h"
+#include "spirv-tools/optimizer.hpp"
+
+#include <Includes.h>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            // Adds the Invariant decoration to every Position builtin output. GL apps
+            // routinely rely 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 - and a driver that optimizes each pipeline
+            // separately may otherwise vary the position math between passes, dropping whole
+            // primitives from the later ones. Both the plain (OpDecorate on a Position
+            // variable) and the block-member (OpMemberDecorate on gl_PerVertex) spellings are
+            // handled; targets that already carry Invariant are left alone. DirectVulkan only.
+            class DecoratePositionInvariantPass : public spvtools::opt::Pass {
+            public:
+                const char* name() const override { return "decorate-position-invariant"; }
+                Status Process() override;
+
+                static spvtools::Optimizer::PassToken CreateDecoratePositionInvariantPass();
+            };
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DefeatConstStructArrayLutPass.cpp

@@ -0,0 +1,175 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DefeatConstStructArrayLutPass.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "DefeatConstStructArrayLutPass.h"
+
+#include "spirv.hpp"
+#include "source/opt/constants.h"
+#include "source/opt/def_use_manager.h"
+#include "source/opt/instruction.h"
+#include "source/opt/ir_context.h"
+#include "source/opt/module.h"
+#include "source/opt/type_manager.h"
+#include "source/opt/types.h"
+#include "source/util/make_unique.h"
+
+#include <vector>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            namespace {
+                using spvtools::opt::BasicBlock;
+                using spvtools::opt::Function;
+                using spvtools::opt::Instruction;
+                using spvtools::opt::IRContext;
+                using spvtools::opt::Operand;
+                namespace analysis = spvtools::opt::analysis;
+
+                uint32_t PointerTypeTo(IRContext* ctx, uint32_t pointeeId, spv::StorageClass sc) {
+                    analysis::Type* pointee = ctx->get_type_mgr()->GetType(pointeeId);
+                    analysis::Pointer ptr(pointee, sc);
+                    return ctx->get_type_mgr()->GetTypeInstruction(&ptr);
+                }
+
+                uint32_t SignedIntConstant(IRContext* ctx, uint32_t value) {
+                    analysis::Integer i(32, true);
+                    analysis::Type* reg = ctx->get_type_mgr()->GetRegisteredType(&i);
+                    const analysis::Constant* c = ctx->get_constant_mgr()->GetConstant(reg, {value});
+                    return ctx->get_constant_mgr()->GetDefiningInstruction(c)->result_id();
+                }
+
+                // True when |var| (a Function-storage OpVariable) points to an array of structs.
+                // Reports the struct type id on success.
+                bool IsArrayOfStructsVariable(IRContext* ctx, Instruction* var, uint32_t& structTypeId) {
+                    auto* defUse = ctx->get_def_use_mgr();
+                    Instruction* ptrType = defUse->GetDef(var->type_id());
+                    if (ptrType == nullptr || ptrType->opcode() != spv::Op::OpTypePointer) return false;
+                    Instruction* pointee = defUse->GetDef(ptrType->GetSingleWordInOperand(1));
+                    if (pointee == nullptr || pointee->opcode() != spv::Op::OpTypeArray) return false;
+                    Instruction* element = defUse->GetDef(pointee->GetSingleWordInOperand(0));
+                    if (element == nullptr || element->opcode() != spv::Op::OpTypeStruct) return false;
+                    structTypeId = element->result_id();
+                    return true;
+                }
+            } // namespace
+
+            spvtools::opt::Pass::Status DefeatConstStructArrayLutPass::Process() {
+                auto* ctx = context();
+                auto* defUse = ctx->get_def_use_mgr();
+                bool modified = false;
+
+                for (Function& function : *get_module()) {
+                    if (function.begin() == function.end()) continue;
+                    BasicBlock* entryBlock = &*function.begin();
+
+                    // Candidate variables: Function-storage arrays of structs declared in this
+                    // function's entry block (where OpVariables must live).
+                    struct Candidate {
+                        Instruction* var;
+                        uint32_t structTypeId;
+                    };
+                    std::vector<Candidate> candidates;
+                    for (Instruction& inst : *entryBlock) {
+                        if (inst.opcode() != spv::Op::OpVariable) break;
+                        // Variables with initializers keep SPIRV-Cross's initializer path; the
+                        // glslang pattern under attack is initializer-free with one OpStore.
+                        if (inst.NumInOperands() > 1) continue;
+                        uint32_t structTypeId = 0;
+                        if (IsArrayOfStructsVariable(ctx, &inst, structTypeId)) {
+                            candidates.push_back({&inst, structTypeId});
+                        }
+                    }
+
+                    for (const Candidate& candidate : candidates) {
+                        Instruction* var = candidate.var;
+
+                        // The variable qualifies only when its single write is one direct
+                        // OpStore of an OpConstantComposite; any other write shape already
+                        // defeats SPIRV-Cross's LUT promotion, so it is left untouched.
+                        Instruction* singleStore = nullptr;
+                        bool disqualified = false;
+                        defUse->ForEachUser(var, [&](Instruction* user) {
+                            if (user->opcode() == spv::Op::OpStore &&
+                                user->GetSingleWordInOperand(0) == var->result_id()) {
+                                if (singleStore != nullptr) {
+                                    disqualified = true;
+                                } else {
+                                    singleStore = user;
+                                }
+                            } else if (user->opcode() == spv::Op::OpCopyMemory) {
+                                disqualified = true;
+                            } else if (user->opcode() == spv::Op::OpAccessChain ||
+                                       user->opcode() == spv::Op::OpInBoundsAccessChain) {
+                                defUse->ForEachUser(user, [&](Instruction* chainUser) {
+                                    if (chainUser->opcode() == spv::Op::OpStore ||
+                                        chainUser->opcode() == spv::Op::OpCopyMemory) {
+                                        disqualified = true;
+                                    }
+                                });
+                            }
+                        });
+                        if (disqualified || singleStore == nullptr) continue;
+
+                        Instruction* composite = defUse->GetDef(singleStore->GetSingleWordInOperand(1));
+                        if (composite == nullptr ||
+                            composite->opcode() != spv::Op::OpConstantComposite) {
+                            continue;
+                        }
+
+                        // The store must sit in the entry block: that is the only placement
+                        // SPIRV-Cross treats as a LUT initializer.
+                        bool storeInEntryBlock = false;
+                        for (Instruction& inst : *entryBlock) {
+                            if (&inst == singleStore) {
+                                storeInEntryBlock = true;
+                                break;
+                            }
+                        }
+                        if (!storeInEntryBlock) continue;
+
+                        // Split the composite store into one constant-index store per element.
+                        const uint32_t ptrFnStruct =
+                            PointerTypeTo(ctx, candidate.structTypeId, spv::StorageClass::Function);
+                        for (uint32_t element = 0; element < composite->NumInOperands(); ++element) {
+                            const uint32_t elementConstId = composite->GetSingleWordInOperand(element);
+                            const uint32_t chainId = ctx->TakeNextId();
+                            Instruction* chain =
+                                singleStore->InsertBefore(spvtools::MakeUnique<Instruction>(
+                                    ctx, spv::Op::OpAccessChain, ptrFnStruct, chainId,
+                                    std::initializer_list<Operand>{
+                                        {SPV_OPERAND_TYPE_ID, {var->result_id()}},
+                                        {SPV_OPERAND_TYPE_ID, {SignedIntConstant(ctx, element)}}}));
+                            ctx->AnalyzeDefUse(chain);
+                            Instruction* store =
+                                singleStore->InsertBefore(spvtools::MakeUnique<Instruction>(
+                                    ctx, spv::Op::OpStore, 0, 0,
+                                    std::initializer_list<Operand>{
+                                        {SPV_OPERAND_TYPE_ID, {chainId}},
+                                        {SPV_OPERAND_TYPE_ID, {elementConstId}}}));
+                            ctx->AnalyzeDefUse(store);
+                        }
+                        ctx->KillInst(singleStore);
+                        modified = true;
+                    }
+                }
+
+                if (!modified) {
+                    return Status::SuccessWithoutChange;
+                }
+                ctx->InvalidateAnalysesExceptFor(spvtools::opt::IRContext::kAnalysisNone);
+                return Status::SuccessWithChange;
+            }
+
+            spvtools::Optimizer::PassToken
+            DefeatConstStructArrayLutPass::CreateDefeatConstStructArrayLutPass() {
+                return spvtools::Optimizer::PassToken(MakeUnique<DefeatConstStructArrayLutPass>());
+            }
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DefeatConstStructArrayLutPass.h

@@ -0,0 +1,36 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DefeatConstStructArrayLutPass.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include "source/opt/pass.h"
+#include "spirv-tools/optimizer.hpp"
+
+#include <Includes.h>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            // SPIRV-Cross hoists a Function-storage array variable whose only write is a single
+            // constant-composite store into a global `const struct[]` LUT (variable_is_lut).
+            // Adreno's ESSL compiler cannot dynamically index such a global const struct array
+            // ("Cannot offset into the structure" - device-verified on Adreno 750). Splitting
+            // the one composite store into per-element constant-index stores makes
+            // variable_is_lut fail, so SPIRV-Cross keeps the array as an ordinary local that
+            // Adreno indexes fine. Scalar/vector const arrays are unaffected on Adreno and are
+            // left alone - only arrays OF STRUCTS are rewritten. Only meant for the DirectGLES
+            // transpile path on Qualcomm devices.
+            class DefeatConstStructArrayLutPass : public spvtools::opt::Pass {
+            public:
+                const char* name() const override { return "defeat-const-struct-array-lut"; }
+                Status Process() override;
+
+                static spvtools::Optimizer::PassToken CreateDefeatConstStructArrayLutPass();
+            };
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EmulateNoPerspectivePass.cpp

@@ -0,0 +1,407 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EmulateNoPerspectivePass.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "EmulateNoPerspectivePass.h"
+
+#include "spirv.hpp"
+#include "source/opt/constants.h"
+#include "source/opt/def_use_manager.h"
+#include "source/opt/instruction.h"
+#include "source/opt/ir_context.h"
+#include "source/opt/module.h"
+#include "source/opt/type_manager.h"
+#include "source/opt/types.h"
+#include "source/util/make_unique.h"
+
+#include <algorithm>
+#include <vector>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            namespace {
+                using spvtools::opt::Instruction;
+                using spvtools::opt::IRContext;
+                using spvtools::opt::Operand;
+                namespace analysis = spvtools::opt::analysis;
+
+                spv::ExecutionModel EntryExecutionModel(IRContext* ctx) {
+                    for (Instruction& ep : ctx->module()->entry_points()) {
+                        return static_cast<spv::ExecutionModel>(ep.GetSingleWordInOperand(0));
+                    }
+                    return spv::ExecutionModel::Max;
+                }
+
+                uint32_t VariablePointeeType(IRContext* ctx, Instruction* var) {
+                    Instruction* ptrType = ctx->get_def_use_mgr()->GetDef(var->type_id());
+                    // OpTypePointer <storage-class> <pointee>
+                    return ptrType->GetSingleWordInOperand(1);
+                }
+
+                // If |typeId| is float or a vector of float, returns true and reports the scalar float
+                // type and whether it is a vector. Matrices, structs, ints etc. are not emulatable.
+                bool IsFloatScalarOrVector(IRContext* ctx, uint32_t typeId, uint32_t& floatTypeId, bool& isVector) {
+                    Instruction* t = ctx->get_def_use_mgr()->GetDef(typeId);
+                    if (t == nullptr) return false;
+                    if (t->opcode() == spv::Op::OpTypeFloat) {
+                        floatTypeId = typeId;
+                        isVector = false;
+                        return true;
+                    }
+                    if (t->opcode() == spv::Op::OpTypeVector) {
+                        const uint32_t comp = t->GetSingleWordInOperand(0);
+                        Instruction* ct = ctx->get_def_use_mgr()->GetDef(comp);
+                        if (ct != nullptr && ct->opcode() == spv::Op::OpTypeFloat) {
+                            floatTypeId = comp;
+                            isVector = true;
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+
+                uint32_t PointerTypeTo(IRContext* ctx, uint32_t pointeeId, spv::StorageClass sc) {
+                    analysis::Type* pointee = ctx->get_type_mgr()->GetType(pointeeId);
+                    analysis::Pointer ptr(pointee, sc);
+                    return ctx->get_type_mgr()->GetTypeInstruction(&ptr);
+                }
+
+                uint32_t V4FloatType(IRContext* ctx) {
+                    analysis::Float f(32);
+                    analysis::Type* freg = ctx->get_type_mgr()->GetRegisteredType(&f);
+                    analysis::Vector v(freg, 4);
+                    return ctx->get_type_mgr()->GetTypeInstruction(&v);
+                }
+
+                uint32_t FloatType(IRContext* ctx) {
+                    analysis::Float f(32);
+                    return ctx->get_type_mgr()->GetTypeInstruction(&f);
+                }
+
+                uint32_t SignedIntConstant(IRContext* ctx, int32_t value) {
+                    analysis::Integer i(32, true);
+                    analysis::Type* reg = ctx->get_type_mgr()->GetRegisteredType(&i);
+                    const analysis::Constant* c =
+                        ctx->get_constant_mgr()->GetConstant(reg, {static_cast<uint32_t>(value)});
+                    return ctx->get_constant_mgr()->GetDefiningInstruction(c)->result_id();
+                }
+
+                // Multiply |valueId| (of type |valueTypeId|) by the scalar |scalarId|, inserting the op
+                // before |before|. Returns the product's id.
+                uint32_t InsertScale(IRContext* ctx, Instruction* before, uint32_t valueTypeId,
+                                     uint32_t valueId, uint32_t scalarId, bool isVector) {
+                    const uint32_t productId = ctx->TakeNextId();
+                    const spv::Op op = isVector ? spv::Op::OpVectorTimesScalar : spv::Op::OpFMul;
+                    before->InsertBefore(spvtools::MakeUnique<Instruction>(
+                        ctx, op, valueTypeId, productId,
+                        std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {valueId}},
+                                                       {SPV_OPERAND_TYPE_ID, {scalarId}}}));
+                    return productId;
+                }
+
+                // --- Vertex stage: gl_Position discovery ------------------------------------------
+
+                // Finds gl_Position as member |memberIndex| of a gl_PerVertex-style block whose Output
+                // variable is |blockVarId|; |v4floatTypeId| is that member's (vec4) type. Returns false
+                // if gl_Position is not a block member (older plain-variable form is left to the strip).
+                bool FindPositionBlock(IRContext* ctx, uint32_t& blockVarId, uint32_t& memberIndex,
+                                       uint32_t& v4floatTypeId) {
+                    uint32_t structId = 0;
+                    uint32_t member = 0;
+                    for (Instruction& ann : ctx->annotations()) {
+                        if (ann.opcode() == spv::Op::OpMemberDecorate && ann.NumInOperands() >= 4 &&
+                            static_cast<spv::Decoration>(ann.GetSingleWordInOperand(2)) ==
+                                spv::Decoration::BuiltIn &&
+                            static_cast<spv::BuiltIn>(ann.GetSingleWordInOperand(3)) ==
+                                spv::BuiltIn::Position) {
+                            structId = ann.GetSingleWordInOperand(0);
+                            member = ann.GetSingleWordInOperand(1);
+                            break;
+                        }
+                    }
+                    if (structId == 0) return false;
+
+                    Instruction* structType = ctx->get_def_use_mgr()->GetDef(structId);
+                    if (structType == nullptr || member >= structType->NumInOperands()) return false;
+                    v4floatTypeId = structType->GetSingleWordInOperand(member);
+
+                    for (Instruction& inst : ctx->module()->types_values()) {
+                        if (inst.opcode() == spv::Op::OpVariable &&
+                            static_cast<spv::StorageClass>(inst.GetSingleWordInOperand(0)) ==
+                                spv::StorageClass::Output &&
+                            VariablePointeeType(ctx, &inst) == structId) {
+                            blockVarId = inst.result_id();
+                            memberIndex = member;
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+
+                // --- Fragment stage: gl_FragCoord discovery/synthesis -----------------------------
+
+                Instruction* FindBuiltinInput(IRContext* ctx, spv::BuiltIn builtin) {
+                    for (Instruction& ann : ctx->annotations()) {
+                        if (ann.opcode() != spv::Op::OpDecorate || ann.NumInOperands() < 3) continue;
+                        if (static_cast<spv::Decoration>(ann.GetSingleWordInOperand(1)) !=
+                            spv::Decoration::BuiltIn)
+                            continue;
+                        if (static_cast<spv::BuiltIn>(ann.GetSingleWordInOperand(2)) != builtin) continue;
+                        Instruction* var = ctx->get_def_use_mgr()->GetDef(ann.GetSingleWordInOperand(0));
+                        if (var != nullptr && var->opcode() == spv::Op::OpVariable &&
+                            static_cast<spv::StorageClass>(var->GetSingleWordInOperand(0)) ==
+                                spv::StorageClass::Input) {
+                            return var;
+                        }
+                    }
+                    return nullptr;
+                }
+
+                uint32_t SynthesizeFragCoord(IRContext* ctx, uint32_t v4floatTypeId) {
+                    const uint32_t ptrType = PointerTypeTo(ctx, v4floatTypeId, spv::StorageClass::Input);
+                    const uint32_t varId = ctx->TakeNextId();
+                    ctx->AddGlobalValue(spvtools::MakeUnique<Instruction>(
+                        ctx, spv::Op::OpVariable, ptrType, varId,
+                        std::initializer_list<Operand>{
+                            {SPV_OPERAND_TYPE_STORAGE_CLASS,
+                             {static_cast<uint32_t>(spv::StorageClass::Input)}}}));
+                    ctx->AddAnnotationInst(spvtools::MakeUnique<Instruction>(
+                        ctx, spv::Op::OpDecorate, 0, 0,
+                        std::initializer_list<Operand>{
+                            {SPV_OPERAND_TYPE_ID, {varId}},
+                            {SPV_OPERAND_TYPE_DECORATION,
+                             {static_cast<uint32_t>(spv::Decoration::BuiltIn)}},
+                            {SPV_OPERAND_TYPE_LITERAL_INTEGER,
+                             {static_cast<uint32_t>(spv::BuiltIn::FragCoord)}}}));
+                    for (Instruction& ep : ctx->module()->entry_points()) {
+                        ep.AddOperand({SPV_OPERAND_TYPE_ID, {varId}});
+                    }
+                    return varId;
+                }
+            } // namespace
+
+            spvtools::opt::Pass::Status EmulateNoPerspectivePass::Process() {
+                auto* ctx = context();
+                const spv::ExecutionModel model = EntryExecutionModel(ctx);
+                const bool isVertex = model == spv::ExecutionModel::Vertex;
+                const bool isFragment = model == spv::ExecutionModel::Fragment;
+
+                // Collect NoPerspective-decorated plain variables and every NoPerspective annotation.
+                std::vector<uint32_t> plainVarIds;
+                std::vector<Instruction*> decorationsToKill;
+                for (Instruction& ann : ctx->annotations()) {
+                    if (ann.opcode() == spv::Op::OpDecorate && ann.NumInOperands() >= 2 &&
+                        static_cast<spv::Decoration>(ann.GetSingleWordInOperand(1)) ==
+                            spv::Decoration::NoPerspective) {
+                        plainVarIds.push_back(ann.GetSingleWordInOperand(0));
+                        decorationsToKill.push_back(&ann);
+                    } else if (ann.opcode() == spv::Op::OpMemberDecorate && ann.NumInOperands() >= 3 &&
+                               static_cast<spv::Decoration>(ann.GetSingleWordInOperand(2)) ==
+                                   spv::Decoration::NoPerspective) {
+                        // Block-member noperspective is not emulated here; the decoration is stripped
+                        // (smooth fallback) so SPIRV-Cross does not require the NV extension.
+                        decorationsToKill.push_back(&ann);
+                    }
+                }
+
+                if (decorationsToKill.empty()) {
+                    return Status::SuccessWithoutChange;
+                }
+
+                const spv::StorageClass wantStorage =
+                    isVertex ? spv::StorageClass::Output : spv::StorageClass::Input;
+
+                // Emulatable = plain variable of the stage's interface direction, float or floatN.
+                struct Target {
+                    Instruction* var;
+                    uint32_t typeId;
+                    uint32_t floatTypeId;
+                    bool isVector;
+                };
+                std::vector<Target> targets;
+                if (isVertex || isFragment) {
+                    for (const uint32_t id : plainVarIds) {
+                        Instruction* var = ctx->get_def_use_mgr()->GetDef(id);
+                        if (var == nullptr || var->opcode() != spv::Op::OpVariable) continue;
+                        if (static_cast<spv::StorageClass>(var->GetSingleWordInOperand(0)) != wantStorage)
+                            continue;
+                        const uint32_t pointee = VariablePointeeType(ctx, var);
+                        uint32_t floatTypeId = 0;
+                        bool isVector = false;
+                        if (IsFloatScalarOrVector(ctx, pointee, floatTypeId, isVector)) {
+                            targets.push_back({var, pointee, floatTypeId, isVector});
+                        }
+                    }
+                }
+
+                // Force highp on the varyings we emulate: the a*w round-trip overflows a mediump (fp16)
+                // varying at large clip-space w. Dropping RelaxedPrecision makes SPIRV-Cross emit them
+                // highp on both stages, keeping the emulation exact. Only touches emulated variables.
+                if (!targets.empty()) {
+                    std::vector<uint32_t> targetIds;
+                    targetIds.reserve(targets.size());
+                    for (const Target& t : targets) targetIds.push_back(t.var->result_id());
+                    for (Instruction& ann : ctx->annotations()) {
+                        if (ann.opcode() == spv::Op::OpDecorate && ann.NumInOperands() >= 2 &&
+                            static_cast<spv::Decoration>(ann.GetSingleWordInOperand(1)) ==
+                                spv::Decoration::RelaxedPrecision &&
+                            std::find(targetIds.begin(), targetIds.end(),
+                                      ann.GetSingleWordInOperand(0)) != targetIds.end()) {
+                            decorationsToKill.push_back(&ann);
+                        }
+                    }
+                }
+
+                if (isVertex && !targets.empty()) {
+                    uint32_t blockVarId = 0;
+                    uint32_t memberIndex = 0;
+                    uint32_t v4floatTypeId = 0;
+                    if (FindPositionBlock(ctx, blockVarId, memberIndex, v4floatTypeId)) {
+                        const uint32_t ptrOutV4 =
+                            PointerTypeTo(ctx, v4floatTypeId, spv::StorageClass::Output);
+                        const uint32_t memberConst = SignedIntConstant(ctx, static_cast<int32_t>(memberIndex));
+                        const uint32_t floatTy = FloatType(ctx);
+
+                        uint32_t entryFuncId = 0;
+                        for (Instruction& ep : ctx->module()->entry_points()) {
+                            // OpEntryPoint <model> <function> "name" <interface...>
+                            entryFuncId = ep.GetSingleWordInOperand(1);
+                            break;
+                        }
+
+                        // Pre-multiply every target output by gl_Position.w before each return of the
+                        // ENTRY function only. glslang does not inline, so a called helper survives as
+                        // its own OpFunction; instrumenting its returns too would scale the varying
+                        // more than once (w^2), breaking the identity.
+                        for (auto funcIt = ctx->module()->begin(); funcIt != ctx->module()->end(); ++funcIt) {
+                            if (funcIt->result_id() != entryFuncId) continue;
+                            funcIt->ForEachInst([&](Instruction* inst) {
+                                if (inst->opcode() != spv::Op::OpReturn &&
+                                    inst->opcode() != spv::Op::OpReturnValue) {
+                                    return;
+                                }
+                                const uint32_t posPtrId = ctx->TakeNextId();
+                                inst->InsertBefore(spvtools::MakeUnique<Instruction>(
+                                    ctx, spv::Op::OpAccessChain, ptrOutV4, posPtrId,
+                                    std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {blockVarId}},
+                                                                   {SPV_OPERAND_TYPE_ID, {memberConst}}}));
+                                const uint32_t posId = ctx->TakeNextId();
+                                inst->InsertBefore(spvtools::MakeUnique<Instruction>(
+                                    ctx, spv::Op::OpLoad, v4floatTypeId, posId,
+                                    std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {posPtrId}}}));
+                                const uint32_t wId = ctx->TakeNextId();
+                                inst->InsertBefore(spvtools::MakeUnique<Instruction>(
+                                    ctx, spv::Op::OpCompositeExtract, floatTy, wId,
+                                    std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {posId}},
+                                                                   {SPV_OPERAND_TYPE_LITERAL_INTEGER, {3u}}}));
+                                for (const Target& t : targets) {
+                                    const uint32_t valId = ctx->TakeNextId();
+                                    inst->InsertBefore(spvtools::MakeUnique<Instruction>(
+                                        ctx, spv::Op::OpLoad, t.typeId, valId,
+                                        std::initializer_list<Operand>{
+                                            {SPV_OPERAND_TYPE_ID, {t.var->result_id()}}}));
+                                    const uint32_t scaledId =
+                                        InsertScale(ctx, inst, t.typeId, valId, wId, t.isVector);
+                                    inst->InsertBefore(spvtools::MakeUnique<Instruction>(
+                                        ctx, spv::Op::OpStore, 0, 0,
+                                        std::initializer_list<Operand>{
+                                            {SPV_OPERAND_TYPE_ID, {t.var->result_id()}},
+                                            {SPV_OPERAND_TYPE_ID, {scaledId}}}));
+                                }
+                            });
+                        }
+                    }
+                }
+
+                if (isFragment && !targets.empty()) {
+                    Instruction* fragCoord = FindBuiltinInput(ctx, spv::BuiltIn::FragCoord);
+                    uint32_t fragCoordId = 0;
+                    uint32_t v4floatTypeId = 0;
+                    if (fragCoord != nullptr) {
+                        fragCoordId = fragCoord->result_id();
+                        v4floatTypeId = VariablePointeeType(ctx, fragCoord);
+                    } else {
+                        v4floatTypeId = V4FloatType(ctx);
+                        fragCoordId = SynthesizeFragCoord(ctx, v4floatTypeId);
+                    }
+                    const uint32_t floatTy = FloatType(ctx);
+
+                    auto* defUse = ctx->get_def_use_mgr();
+                    for (const Target& t : targets) {
+                        // Collect every load that reads the varying. glslang lowers a whole-variable
+                        // read to OpLoad(var), but a single-component read (v.x) to
+                        // OpAccessChain(var) + OpLoad(chain). Both must be scaled; the identity is
+                        // per-component, so scaling one loaded component by gl_FragCoord.w is valid.
+                        std::vector<Instruction*> loads;
+                        defUse->ForEachUser(t.var, [&](Instruction* user) {
+                            if (user->opcode() == spv::Op::OpLoad &&
+                                user->GetSingleWordInOperand(0) == t.var->result_id()) {
+                                loads.push_back(user);
+                            } else if (user->opcode() == spv::Op::OpAccessChain &&
+                                       user->GetSingleWordInOperand(0) == t.var->result_id()) {
+                                const uint32_t chainId = user->result_id();
+                                defUse->ForEachUser(user, [&](Instruction* chainUser) {
+                                    if (chainUser->opcode() == spv::Op::OpLoad &&
+                                        chainUser->GetSingleWordInOperand(0) == chainId) {
+                                        loads.push_back(chainUser);
+                                    }
+                                });
+                            }
+                        });
+
+                        // Rewrite `%r = OpLoad %ty %ptr` into
+                        //   %orig = OpLoad %ty %ptr
+                        //   %fc   = OpLoad %v4float %fragCoord
+                        //   %w    = OpCompositeExtract %float %fc 3
+                        //   %r    = OpVectorTimesScalar/OpFMul %ty %orig %w   (reuse %r: uses stay intact)
+                        // The op is chosen from the LOAD's own result type: a whole-vector load scales
+                        // with OpVectorTimesScalar, a scalar component load with OpFMul.
+                        for (Instruction* load : loads) {
+                            const uint32_t loadType = load->type_id();
+                            uint32_t componentFloat = 0;
+                            bool loadIsVector = false;
+                            if (!IsFloatScalarOrVector(ctx, loadType, componentFloat, loadIsVector)) {
+                                continue;
+                            }
+                            const uint32_t ptrId = load->GetSingleWordInOperand(0);
+                            const uint32_t origId = ctx->TakeNextId();
+                            load->InsertBefore(spvtools::MakeUnique<Instruction>(
+                                ctx, spv::Op::OpLoad, loadType, origId,
+                                std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {ptrId}}}));
+                            const uint32_t fcId = ctx->TakeNextId();
+                            load->InsertBefore(spvtools::MakeUnique<Instruction>(
+                                ctx, spv::Op::OpLoad, v4floatTypeId, fcId,
+                                std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {fragCoordId}}}));
+                            const uint32_t wId = ctx->TakeNextId();
+                            load->InsertBefore(spvtools::MakeUnique<Instruction>(
+                                ctx, spv::Op::OpCompositeExtract, floatTy, wId,
+                                std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {fcId}},
+                                                               {SPV_OPERAND_TYPE_LITERAL_INTEGER, {3u}}}));
+                            load->SetOpcode(loadIsVector ? spv::Op::OpVectorTimesScalar : spv::Op::OpFMul);
+                            load->SetInOperands(Instruction::OperandList{
+                                {SPV_OPERAND_TYPE_ID, {origId}}, {SPV_OPERAND_TYPE_ID, {wId}}});
+                        }
+                    }
+                }
+
+                // Strip every NoPerspective decoration: emulated varyings now transport smooth, and
+                // non-emulatable ones fall back to smooth.
+                for (Instruction* dec : decorationsToKill) {
+                    ctx->KillInst(dec);
+                }
+
+                ctx->InvalidateAnalysesExceptFor(IRContext::kAnalysisNone);
+                return Status::SuccessWithChange;
+            }
+
+            spvtools::Optimizer::PassToken EmulateNoPerspectivePass::CreateEmulateNoPerspectivePass() {
+                return spvtools::Optimizer::PassToken(MakeUnique<EmulateNoPerspectivePass>());
+            }
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EmulateNoPerspectivePass.h

@@ -0,0 +1,41 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EmulateNoPerspectivePass.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include "source/opt/pass.h"
+#include "spirv-tools/optimizer.hpp"
+
+#include <Includes.h>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            // Emulates 'noperspective' (screen-linear) interpolation on GLES devices that lack
+            // GL_NV_shader_noperspective_interpolation, so no NV extension is required. The hardware
+            // interpolates perspective-correct; screen-linear L(a) is recovered from the identity
+            //     L(a) = P(a * w) * gl_FragCoord.w
+            // where P is perspective-correct interpolation and w is the vertex clip-space w. So each
+            // NoPerspective-decorated output is pre-multiplied by gl_Position.w in the vertex stage
+            // and each NoPerspective-decorated input is multiplied by gl_FragCoord.w in the fragment
+            // stage; the decoration is then removed so the varying transports smooth. This is exact
+            // (modulo float precision - the emulated varyings want highp).
+            //
+            // Scope: plain interface variables of float or floatN type. Anything it cannot emulate
+            // (interface-block members, matrices, or a stage lacking the needed builtin) has its
+            // NoPerspective decoration stripped instead, degrading to smooth - the same result the
+            // extension-less fallback produced before, and never invalid SPIR-V. DirectGLES only.
+            class EmulateNoPerspectivePass : public spvtools::opt::Pass {
+            public:
+                const char* name() const override { return "emulate-noperspective"; }
+                Status Process() override;
+
+                static spvtools::Optimizer::PassToken CreateEmulateNoPerspectivePass();
+            };
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FoldConstOffsetFor1DFetchPass.cpp

@@ -0,0 +1,131 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FoldConstOffsetFor1DFetchPass.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "FoldConstOffsetFor1DFetchPass.h"
+
+#include "spirv.hpp"
+#include "source/opt/def_use_manager.h"
+#include "source/opt/instruction.h"
+#include "source/opt/ir_builder.h"
+#include "source/opt/ir_context.h"
+#include "source/opt/module.h"
+#include "source/util/make_unique.h"
+
+#include <vector>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            namespace {
+                using spvtools::opt::Instruction;
+                using spvtools::opt::InstructionBuilder;
+                using spvtools::opt::IRContext;
+                using spvtools::opt::Operand;
+
+                // Number of ImageOperands ids that precede the ConstOffset id: one per
+                // lower-order bit set in the mask, except Grad which carries two ids.
+                uint32_t CountIdsBeforeConstOffset(uint32_t mask) {
+                    uint32_t count = 0;
+                    if (mask & static_cast<uint32_t>(spv::ImageOperandsMask::Bias)) count += 1;
+                    if (mask & static_cast<uint32_t>(spv::ImageOperandsMask::Lod)) count += 1;
+                    if (mask & static_cast<uint32_t>(spv::ImageOperandsMask::Grad)) count += 2;
+                    return count;
+                }
+            } // namespace
+
+            spvtools::opt::Pass::Status FoldConstOffsetFor1DFetchPass::Process() {
+                auto* irContext = context();
+                auto* defUseMgr = irContext->get_def_use_mgr();
+                Bool modified = false;
+
+                constexpr uint32_t kConstOffsetBit =
+                    static_cast<uint32_t>(spv::ImageOperandsMask::ConstOffset);
+
+                for (auto& function : *get_module()) {
+                    for (auto& block : function) {
+                        for (auto& inst : block) {
+                            if (inst.opcode() != spv::Op::OpImageFetch) continue;
+                            // In-operands: image, coordinate, [ImageOperands mask, ids...].
+                            if (inst.NumInOperands() < 3) continue;
+                            const uint32_t operandsMask = inst.GetSingleWordInOperand(2);
+                            if ((operandsMask & kConstOffsetBit) == 0) continue;
+
+                            Instruction* imageInst = defUseMgr->GetDef(inst.GetSingleWordInOperand(0));
+                            if (imageInst == nullptr) continue;
+                            Instruction* imageType = defUseMgr->GetDef(imageInst->type_id());
+                            if (imageType == nullptr || imageType->opcode() != spv::Op::OpTypeImage ||
+                                static_cast<spv::Dim>(imageType->GetSingleWordInOperand(1)) != spv::Dim::Dim1D) {
+                                continue;
+                            }
+
+                            const uint32_t offsetOperandIndex = 3 + CountIdsBeforeConstOffset(operandsMask);
+                            const uint32_t offsetId = inst.GetSingleWordInOperand(offsetOperandIndex);
+
+                            const uint32_t coordId = inst.GetSingleWordInOperand(1);
+                            Instruction* coordType = defUseMgr->GetDef(defUseMgr->GetDef(coordId)->type_id());
+
+                            InstructionBuilder builder(
+                                irContext, &inst,
+                                IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping);
+
+                            uint32_t newCoordId = 0;
+                            if (coordType->opcode() == spv::Op::OpTypeVector) {
+                                // Arrayed 1D fetch: component 0 is the texel coordinate,
+                                // component 1 the layer - only component 0 takes the offset.
+                                const uint32_t componentTypeId = coordType->GetSingleWordInOperand(0);
+                                Instruction* extracted = builder.AddCompositeExtract(componentTypeId, coordId, {0});
+                                Instruction* sum =
+                                    builder.AddIAdd(componentTypeId, extracted->result_id(), offsetId);
+                                Instruction* inserted = builder.AddInstruction(spvtools::MakeUnique<Instruction>(
+                                    irContext, spv::Op::OpCompositeInsert, coordType->result_id(),
+                                    irContext->TakeNextId(),
+                                    std::initializer_list<Operand>{
+                                        {SPV_OPERAND_TYPE_ID, {sum->result_id()}},
+                                        {SPV_OPERAND_TYPE_ID, {coordId}},
+                                        {SPV_OPERAND_TYPE_LITERAL_INTEGER, {0}}}));
+                                newCoordId = inserted->result_id();
+                            } else {
+                                Instruction* sum = builder.AddIAdd(coordType->result_id(), coordId, offsetId);
+                                newCoordId = sum->result_id();
+                            }
+
+                            const uint32_t newMask = operandsMask & ~kConstOffsetBit;
+                            // 3 fixed operands + the offset id: anything beyond that is another
+                            // image-operand id that must keep the mask word alive.
+                            const Bool otherOperandIdsRemain = inst.NumInOperands() > 4;
+
+                            irContext->ForgetUses(&inst);
+                            std::vector<Operand> newOperands;
+                            newOperands.push_back(inst.GetInOperand(0));
+                            newOperands.push_back({SPV_OPERAND_TYPE_ID, {newCoordId}});
+                            if (newMask != 0 || otherOperandIdsRemain) {
+                                Operand maskOperand = inst.GetInOperand(2);
+                                maskOperand.words[0] = newMask;
+                                newOperands.push_back(maskOperand);
+                                for (uint32_t i = 3; i < inst.NumInOperands(); ++i) {
+                                    if (i == offsetOperandIndex) continue;
+                                    newOperands.push_back(inst.GetInOperand(i));
+                                }
+                            }
+                            inst.SetInOperands(std::move(newOperands));
+                            irContext->AnalyzeUses(&inst);
+
+                            modified = true;
+                        }
+                    }
+                }
+
+                return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
+            }
+
+            spvtools::Optimizer::PassToken FoldConstOffsetFor1DFetchPass::CreateFoldConstOffsetFor1DFetchPass() {
+                return spvtools::Optimizer::PassToken(MakeUnique<FoldConstOffsetFor1DFetchPass>());
+            }
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FoldConstOffsetFor1DFetchPass.h

@@ -0,0 +1,36 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FoldConstOffsetFor1DFetchPass.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include "source/opt/pass.h"
+#include "spirv-tools/optimizer.hpp"
+
+#include <Includes.h>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            // SPIRV-Cross emulates 1D textures as 2D for ES targets: it widens the texelFetch
+            // coordinate to ivec2 but keeps the ConstOffset image operand scalar, and ESSL has
+            // no texelFetchOffset(sampler2D, ivec2, int, scalar-offset) overload, so drivers
+            // (Adreno) reject the transpiled shader. This pass folds the constant offset into
+            // the integer coordinate before the fetch - texelFetchOffset(t, P, l, o) ==
+            // texelFetch(t, P + o, l) per the GLSL spec - and drops the ConstOffset operand,
+            // so SPIRV-Cross emits a plain texelFetch. For arrayed 1D fetches only coordinate
+            // component 0 is offset (component 1 is the layer). Only meant for the DirectGLES
+            // transpile path.
+            class FoldConstOffsetFor1DFetchPass : public spvtools::opt::Pass {
+            public:
+                const char* name() const override { return "fold-const-offset-for-1d-fetch"; }
+                Status Process() override;
+
+                static spvtools::Optimizer::PassToken CreateFoldConstOffsetFor1DFetchPass();
+            };
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerClipDistanceForEsslPass.cpp

@@ -0,0 +1,613 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerClipDistanceForEsslPass.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "LowerClipDistanceForEsslPass.h"
+
+#include "spirv.hpp"
+#include "source/opt/basic_block.h"
+#include "source/opt/constants.h"
+#include "source/opt/def_use_manager.h"
+#include "source/opt/instruction.h"
+#include "source/opt/ir_context.h"
+#include "source/opt/module.h"
+#include "source/opt/type_manager.h"
+#include "source/opt/types.h"
+#include "source/util/make_unique.h"
+
+#include <memory>
+#include <vector>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            namespace {
+                using spvtools::opt::BasicBlock;
+                using spvtools::opt::Function;
+                using spvtools::opt::Instruction;
+                using spvtools::opt::IRContext;
+                using spvtools::opt::Operand;
+                namespace analysis = spvtools::opt::analysis;
+
+                spv::ExecutionModel EntryExecutionModel(IRContext* ctx) {
+                    for (Instruction& ep : ctx->module()->entry_points()) {
+                        return static_cast<spv::ExecutionModel>(ep.GetSingleWordInOperand(0));
+                    }
+                    return spv::ExecutionModel::Max;
+                }
+
+                uint32_t EntryFunctionId(IRContext* ctx) {
+                    for (Instruction& ep : ctx->module()->entry_points()) {
+                        // OpEntryPoint <model> <function> "name" <interface...>
+                        return ep.GetSingleWordInOperand(1);
+                    }
+                    return 0;
+                }
+
+                uint32_t VariablePointeeType(IRContext* ctx, Instruction* var) {
+                    Instruction* ptrType = ctx->get_def_use_mgr()->GetDef(var->type_id());
+                    // OpTypePointer <storage-class> <pointee>
+                    return ptrType->GetSingleWordInOperand(1);
+                }
+
+                uint32_t PointerTypeTo(IRContext* ctx, uint32_t pointeeId, spv::StorageClass sc) {
+                    analysis::Type* pointee = ctx->get_type_mgr()->GetType(pointeeId);
+                    analysis::Pointer ptr(pointee, sc);
+                    return ctx->get_type_mgr()->GetTypeInstruction(&ptr);
+                }
+
+                uint32_t IntConstant(IRContext* ctx, bool isSigned, uint32_t value) {
+                    analysis::Integer i(32, isSigned);
+                    analysis::Type* reg = ctx->get_type_mgr()->GetRegisteredType(&i);
+                    const analysis::Constant* c = ctx->get_constant_mgr()->GetConstant(reg, {value});
+                    return ctx->get_constant_mgr()->GetDefiningInstruction(c)->result_id();
+                }
+
+                uint32_t UintType(IRContext* ctx) {
+                    analysis::Integer i(32, false);
+                    return ctx->get_type_mgr()->GetTypeInstruction(&i);
+                }
+
+                uint32_t BoolType(IRContext* ctx) {
+                    analysis::Bool b;
+                    return ctx->get_type_mgr()->GetTypeInstruction(&b);
+                }
+
+                // Constant length of OpTypeArray |arrayTypeId| (0 when not a sized constant).
+                uint32_t ArrayLength(IRContext* ctx, uint32_t arrayTypeId) {
+                    Instruction* arrayType = ctx->get_def_use_mgr()->GetDef(arrayTypeId);
+                    if (arrayType == nullptr || arrayType->opcode() != spv::Op::OpTypeArray) {
+                        return 0;
+                    }
+                    Instruction* length = ctx->get_def_use_mgr()->GetDef(arrayType->GetSingleWordInOperand(1));
+                    if (length == nullptr || length->opcode() != spv::Op::OpConstant) {
+                        return 0;
+                    }
+                    return length->GetSingleWordInOperand(0);
+                }
+
+                bool IsConstantWithValue(IRContext* ctx, uint32_t id, uint32_t value) {
+                    Instruction* def = ctx->get_def_use_mgr()->GetDef(id);
+                    return def != nullptr && def->opcode() == spv::Op::OpConstant &&
+                           def->GetSingleWordInOperand(0) == value;
+                }
+
+                bool IsAccessChain(const Instruction* inst) {
+                    return inst->opcode() == spv::Op::OpAccessChain ||
+                           inst->opcode() == spv::Op::OpInBoundsAccessChain;
+                }
+
+                Instruction* AddPrivateVariable(IRContext* ctx, uint32_t pointeeTypeId, const char* name) {
+                    const uint32_t ptrType = PointerTypeTo(ctx, pointeeTypeId, spv::StorageClass::Private);
+                    const uint32_t varId = ctx->TakeNextId();
+                    ctx->AddGlobalValue(spvtools::MakeUnique<Instruction>(
+                        ctx, spv::Op::OpVariable, ptrType, varId,
+                        std::initializer_list<Operand>{
+                            {SPV_OPERAND_TYPE_STORAGE_CLASS,
+                             {static_cast<uint32_t>(spv::StorageClass::Private)}}}));
+                    ctx->AddDebug2Inst(spvtools::MakeUnique<Instruction>(
+                        ctx, spv::Op::OpName, 0, 0,
+                        std::initializer_list<Operand>{
+                            {SPV_OPERAND_TYPE_ID, {varId}},
+                            {SPV_OPERAND_TYPE_LITERAL_STRING, spvtools::utils::MakeVector(name)}}));
+                    return ctx->get_def_use_mgr()->GetDef(varId);
+                }
+
+                // Retargets |chain| onto |newBaseId|, dropping the first |dropIndexCount| index
+                // operands and switching the result pointer's storage class to Private.
+                void RetargetChainToPrivate(IRContext* ctx, Instruction* chain, uint32_t newBaseId,
+                                            uint32_t dropIndexCount) {
+                    Instruction* chainPtrType = ctx->get_def_use_mgr()->GetDef(chain->type_id());
+                    const uint32_t pointeeId = chainPtrType->GetSingleWordInOperand(1);
+                    const uint32_t newPtrType = PointerTypeTo(ctx, pointeeId, spv::StorageClass::Private);
+
+                    ctx->ForgetUses(chain);
+                    std::vector<Operand> newOperands;
+                    newOperands.push_back({SPV_OPERAND_TYPE_ID, {newBaseId}});
+                    for (uint32_t i = 1 + dropIndexCount; i < chain->NumInOperands(); ++i) {
+                        newOperands.push_back(chain->GetInOperand(i));
+                    }
+                    chain->SetResultType(newPtrType);
+                    chain->SetInOperands(std::move(newOperands));
+                    ctx->AnalyzeUses(chain);
+                }
+
+                // ---- Output side --------------------------------------------------------------
+
+                struct OutputTarget {
+                    Instruction* var = nullptr;   // Output gl_PerVertex block or standalone builtin
+                    bool isBlockMember = false;
+                    uint32_t memberIndex = 0;     // valid when isBlockMember
+                    uint32_t arrayTypeId = 0;     // float[N]
+                    uint32_t elemTypeId = 0;      // float
+                    uint32_t arrayLen = 0;        // N
+                };
+
+                // Inserts "gl_ClipDistance[k] = mg_ClipDistance[k]" for every literal k before
+                // |before|. Constant-index writes are the only write shape Adreno links correctly.
+                void InsertFlushBefore(IRContext* ctx, Instruction* before, const OutputTarget& target,
+                                       uint32_t mgVarId) {
+                    const uint32_t ptrPrivElem =
+                        PointerTypeTo(ctx, target.elemTypeId, spv::StorageClass::Private);
+                    const uint32_t ptrOutElem =
+                        PointerTypeTo(ctx, target.elemTypeId, spv::StorageClass::Output);
+                    for (uint32_t k = 0; k < target.arrayLen; ++k) {
+                        const uint32_t kConst = IntConstant(ctx, true, k);
+                        const uint32_t srcChainId = ctx->TakeNextId();
+                        before->InsertBefore(spvtools::MakeUnique<Instruction>(
+                            ctx, spv::Op::OpAccessChain, ptrPrivElem, srcChainId,
+                            std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {mgVarId}},
+                                                           {SPV_OPERAND_TYPE_ID, {kConst}}}));
+                        const uint32_t valId = ctx->TakeNextId();
+                        before->InsertBefore(spvtools::MakeUnique<Instruction>(
+                            ctx, spv::Op::OpLoad, target.elemTypeId, valId,
+                            std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {srcChainId}}}));
+                        const uint32_t dstChainId = ctx->TakeNextId();
+                        std::vector<Operand> dstOperands;
+                        dstOperands.push_back({SPV_OPERAND_TYPE_ID, {target.var->result_id()}});
+                        if (target.isBlockMember) {
+                            dstOperands.push_back(
+                                {SPV_OPERAND_TYPE_ID, {IntConstant(ctx, true, target.memberIndex)}});
+                        }
+                        dstOperands.push_back({SPV_OPERAND_TYPE_ID, {kConst}});
+                        before->InsertBefore(spvtools::MakeUnique<Instruction>(
+                            ctx, spv::Op::OpAccessChain, ptrOutElem, dstChainId, dstOperands));
+                        before->InsertBefore(spvtools::MakeUnique<Instruction>(
+                            ctx, spv::Op::OpStore, 0, 0,
+                            std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {dstChainId}},
+                                                           {SPV_OPERAND_TYPE_ID, {valId}}}));
+                    }
+                }
+
+                bool LowerOutputClipDistance(IRContext* ctx, bool isGeometry) {
+                    auto* defUse = ctx->get_def_use_mgr();
+
+                    // Collect (struct type, member) pairs decorated BuiltIn ClipDistance and
+                    // standalone variables decorated BuiltIn ClipDistance.
+                    std::vector<std::pair<uint32_t, uint32_t>> memberTargets; // (structId, member)
+                    std::vector<uint32_t> plainTargets;                       // variable ids
+                    for (Instruction& ann : ctx->annotations()) {
+                        if (ann.opcode() == spv::Op::OpMemberDecorate && ann.NumInOperands() >= 4 &&
+                            static_cast<spv::Decoration>(ann.GetSingleWordInOperand(2)) ==
+                                spv::Decoration::BuiltIn &&
+                            static_cast<spv::BuiltIn>(ann.GetSingleWordInOperand(3)) ==
+                                spv::BuiltIn::ClipDistance) {
+                            memberTargets.emplace_back(ann.GetSingleWordInOperand(0),
+                                                       ann.GetSingleWordInOperand(1));
+                        } else if (ann.opcode() == spv::Op::OpDecorate && ann.NumInOperands() >= 3 &&
+                                   static_cast<spv::Decoration>(ann.GetSingleWordInOperand(1)) ==
+                                       spv::Decoration::BuiltIn &&
+                                   static_cast<spv::BuiltIn>(ann.GetSingleWordInOperand(2)) ==
+                                       spv::BuiltIn::ClipDistance) {
+                            plainTargets.push_back(ann.GetSingleWordInOperand(0));
+                        }
+                    }
+
+                    std::vector<OutputTarget> targets;
+                    for (Instruction& inst : ctx->module()->types_values()) {
+                        if (inst.opcode() != spv::Op::OpVariable ||
+                            static_cast<spv::StorageClass>(inst.GetSingleWordInOperand(0)) !=
+                                spv::StorageClass::Output) {
+                            continue;
+                        }
+                        const uint32_t pointee = VariablePointeeType(ctx, &inst);
+                        for (const auto& [structId, member] : memberTargets) {
+                            if (pointee != structId) continue;
+                            Instruction* structType = defUse->GetDef(structId);
+                            if (structType == nullptr || member >= structType->NumInOperands()) continue;
+                            OutputTarget target;
+                            target.var = &inst;
+                            target.isBlockMember = true;
+                            target.memberIndex = member;
+                            target.arrayTypeId = structType->GetSingleWordInOperand(member);
+                            target.arrayLen = ArrayLength(ctx, target.arrayTypeId);
+                            targets.push_back(target);
+                        }
+                        for (const uint32_t varId : plainTargets) {
+                            if (inst.result_id() != varId) continue;
+                            OutputTarget target;
+                            target.var = &inst;
+                            target.isBlockMember = false;
+                            target.arrayTypeId = pointee;
+                            target.arrayLen = ArrayLength(ctx, target.arrayTypeId);
+                            targets.push_back(target);
+                        }
+                    }
+
+                    bool changed = false;
+                    for (OutputTarget& target : targets) {
+                        if (target.arrayLen == 0) continue;
+                        Instruction* arrayType = defUse->GetDef(target.arrayTypeId);
+                        target.elemTypeId = arrayType->GetSingleWordInOperand(0);
+
+                        // Collect the accesses to redirect. For the block form only chains whose
+                        // leading index selects the ClipDistance member count; for the standalone
+                        // form every chain plus whole-variable loads/stores.
+                        std::vector<Instruction*> chains;
+                        std::vector<Instruction*> directAccesses;
+                        bool unsupportedUse = false;
+                        defUse->ForEachUser(target.var, [&](Instruction* user) {
+                            if (IsAccessChain(user) &&
+                                user->GetSingleWordInOperand(0) == target.var->result_id()) {
+                                if (target.isBlockMember) {
+                                    if (user->NumInOperands() >= 2 &&
+                                        IsConstantWithValue(ctx, user->GetSingleWordInOperand(1),
+                                                            target.memberIndex)) {
+                                        chains.push_back(user);
+                                    }
+                                } else {
+                                    chains.push_back(user);
+                                }
+                            } else if (!target.isBlockMember) {
+                                if (user->opcode() == spv::Op::OpLoad ||
+                                    (user->opcode() == spv::Op::OpStore &&
+                                     user->GetSingleWordInOperand(0) == target.var->result_id())) {
+                                    directAccesses.push_back(user);
+                                } else if (user->opcode() == spv::Op::OpCopyMemory) {
+                                    unsupportedUse = true;
+                                }
+                            }
+                        });
+                        if (unsupportedUse || (chains.empty() && directAccesses.empty())) {
+                            continue;
+                        }
+
+                        Instruction* mgVar = AddPrivateVariable(ctx, target.arrayTypeId, "mg_ClipDistance");
+                        const uint32_t mgVarId = mgVar->result_id();
+
+                        for (Instruction* chain : chains) {
+                            const uint32_t dropCount = target.isBlockMember ? 1u : 0u;
+                            if (chain->NumInOperands() == 1 + dropCount) {
+                                // Pointer to the whole float[N]: reuse the private variable itself.
+                                ctx->ReplaceAllUsesWith(chain->result_id(), mgVarId);
+                                ctx->KillInst(chain);
+                            } else {
+                                RetargetChainToPrivate(ctx, chain, mgVarId, dropCount);
+                            }
+                        }
+                        for (Instruction* access : directAccesses) {
+                            ctx->ForgetUses(access);
+                            access->SetInOperand(0, {mgVarId});
+                            ctx->AnalyzeUses(access);
+                        }
+
+                        // Flush the shadow into the real builtin: geometry right before every
+                        // EmitVertex, vertex before every return of the entry point. The flush is
+                        // also what keeps the builtin statically used for cross-stage IO matching.
+                        std::vector<Instruction*> flushSites;
+                        if (isGeometry) {
+                            for (Function& function : *ctx->module()) {
+                                function.ForEachInst([&](Instruction* inst) {
+                                    if (inst->opcode() == spv::Op::OpEmitVertex) {
+                                        flushSites.push_back(inst);
+                                    }
+                                });
+                            }
+                        } else {
+                            const uint32_t entryFuncId = EntryFunctionId(ctx);
+                            for (Function& function : *ctx->module()) {
+                                if (function.result_id() != entryFuncId) continue;
+                                function.ForEachInst([&](Instruction* inst) {
+                                    if (inst->opcode() == spv::Op::OpReturn ||
+                                        inst->opcode() == spv::Op::OpReturnValue) {
+                                        flushSites.push_back(inst);
+                                    }
+                                });
+                            }
+                        }
+                        for (Instruction* site : flushSites) {
+                            InsertFlushBefore(ctx, site, target, mgVarId);
+                        }
+
+                        changed = true;
+                    }
+                    return changed;
+                }
+
+                // ---- Input side (geometry gl_in) ----------------------------------------------
+
+                bool LowerInputClipDistance(IRContext* ctx) {
+                    auto* defUse = ctx->get_def_use_mgr();
+                    auto* typeMgr = ctx->get_type_mgr();
+
+                    // Locate the gl_in block member decorated ClipDistance.
+                    Instruction* glInVar = nullptr;
+                    uint32_t memberIndex = 0;
+                    uint32_t arrayTypeId = 0; // float[N]
+                    for (Instruction& ann : ctx->annotations()) {
+                        if (ann.opcode() != spv::Op::OpMemberDecorate || ann.NumInOperands() < 4 ||
+                            static_cast<spv::Decoration>(ann.GetSingleWordInOperand(2)) !=
+                                spv::Decoration::BuiltIn ||
+                            static_cast<spv::BuiltIn>(ann.GetSingleWordInOperand(3)) !=
+                                spv::BuiltIn::ClipDistance) {
+                            continue;
+                        }
+                        const uint32_t structId = ann.GetSingleWordInOperand(0);
+                        const uint32_t member = ann.GetSingleWordInOperand(1);
+                        for (Instruction& inst : ctx->module()->types_values()) {
+                            if (inst.opcode() != spv::Op::OpVariable ||
+                                static_cast<spv::StorageClass>(inst.GetSingleWordInOperand(0)) !=
+                                    spv::StorageClass::Input) {
+                                continue;
+                            }
+                            const uint32_t pointee = VariablePointeeType(ctx, &inst);
+                            Instruction* pointeeType = defUse->GetDef(pointee);
+                            if (pointeeType == nullptr || pointeeType->opcode() != spv::Op::OpTypeArray ||
+                                pointeeType->GetSingleWordInOperand(0) != structId) {
+                                continue;
+                            }
+                            Instruction* structType = defUse->GetDef(structId);
+                            if (structType == nullptr || member >= structType->NumInOperands()) continue;
+                            glInVar = &inst;
+                            memberIndex = member;
+                            arrayTypeId = structType->GetSingleWordInOperand(member);
+                            break;
+                        }
+                        if (glInVar != nullptr) break;
+                    }
+                    if (glInVar == nullptr) {
+                        return false;
+                    }
+
+                    const uint32_t clipCount = ArrayLength(ctx, arrayTypeId);
+                    const uint32_t vertexCount = ArrayLength(ctx, VariablePointeeType(ctx, glInVar));
+                    if (clipCount == 0 || vertexCount == 0) {
+                        return false;
+                    }
+
+                    // Every gl_in chain that selects the ClipDistance member:
+                    // (vertex, member) yields a whole float[N], (vertex, member, k) an element.
+                    std::vector<Instruction*> chains;
+                    defUse->ForEachUser(glInVar, [&](Instruction* user) {
+                        if (IsAccessChain(user) && user->GetSingleWordInOperand(0) == glInVar->result_id() &&
+                            user->NumInOperands() >= 3 &&
+                            IsConstantWithValue(ctx, user->GetSingleWordInOperand(2), memberIndex)) {
+                            chains.push_back(user);
+                        }
+                    });
+                    if (chains.empty()) {
+                        return false;
+                    }
+
+                    Instruction* arrayTypeInst = defUse->GetDef(arrayTypeId);
+                    const uint32_t elemTypeId = arrayTypeInst->GetSingleWordInOperand(0);
+
+                    // Private mg_ClipDistanceIn = float[vertexCount][clipCount].
+                    const uint32_t vertexCountConst = IntConstant(ctx, false, vertexCount);
+                    analysis::Type* innerType = typeMgr->GetType(arrayTypeId);
+                    analysis::Array outerArray(
+                        innerType, analysis::Array::LengthInfo{
+                                       vertexCountConst,
+                                       {analysis::Array::LengthInfo::kConstant, vertexCount}});
+                    const uint32_t outerArrayTypeId = typeMgr->GetTypeInstruction(&outerArray);
+                    Instruction* mgInVar = AddPrivateVariable(ctx, outerArrayTypeId, "mg_ClipDistanceIn");
+                    const uint32_t mgInVarId = mgInVar->result_id();
+
+                    // Copy loop at the top of the entry point:
+                    //   for (uint t = 0; t < vertexCount * clipCount; ++t)
+                    //       mg_ClipDistanceIn[t / clipCount][t % clipCount] =
+                    //           gl_in[t / clipCount].gl_ClipDistance[t % clipCount];
+                    // Both gl_in indices are loop-derived (dynamic): constant-index element reads
+                    // miscompile and whole-array reads crash the Adreno compiler.
+                    const uint32_t entryFuncId = EntryFunctionId(ctx);
+                    Function* entryFn = nullptr;
+                    for (Function& function : *ctx->module()) {
+                        if (function.result_id() == entryFuncId) {
+                            entryFn = &function;
+                            break;
+                        }
+                    }
+                    if (entryFn == nullptr || entryFn->begin() == entryFn->end()) {
+                        return false;
+                    }
+
+                    const uint32_t uintTypeId = UintType(ctx);
+                    const uint32_t boolTypeId = BoolType(ctx);
+                    const uint32_t ptrFnUint = PointerTypeTo(ctx, uintTypeId, spv::StorageClass::Function);
+                    const uint32_t ptrInElem = PointerTypeTo(ctx, elemTypeId, spv::StorageClass::Input);
+                    const uint32_t ptrPrivElem = PointerTypeTo(ctx, elemTypeId, spv::StorageClass::Private);
+                    const uint32_t uint0 = IntConstant(ctx, false, 0);
+                    const uint32_t uint1 = IntConstant(ctx, false, 1);
+                    const uint32_t uintN = IntConstant(ctx, false, clipCount);
+                    const uint32_t uintTotal = IntConstant(ctx, false, vertexCount * clipCount);
+                    const uint32_t memberConst = IntConstant(ctx, true, memberIndex);
+
+                    BasicBlock* entryBlock = &*entryFn->begin();
+                    auto splitPoint = entryBlock->begin();
+                    while (splitPoint != entryBlock->end() &&
+                           splitPoint->opcode() == spv::Op::OpVariable) {
+                        ++splitPoint;
+                    }
+
+                    // Loop counter lives with the other function-local variables.
+                    const uint32_t counterVarId = ctx->TakeNextId();
+                    splitPoint->InsertBefore(spvtools::MakeUnique<Instruction>(
+                        ctx, spv::Op::OpVariable, ptrFnUint, counterVarId,
+                        std::initializer_list<Operand>{
+                            {SPV_OPERAND_TYPE_STORAGE_CLASS,
+                             {static_cast<uint32_t>(spv::StorageClass::Function)}}}));
+
+                    const uint32_t restLabelId = ctx->TakeNextId();
+                    BasicBlock* restBlock = entryBlock->SplitBasicBlock(ctx, restLabelId, splitPoint);
+
+                    const uint32_t headerLabelId = ctx->TakeNextId();
+                    const uint32_t checkLabelId = ctx->TakeNextId();
+                    const uint32_t bodyLabelId = ctx->TakeNextId();
+                    const uint32_t continueLabelId = ctx->TakeNextId();
+
+                    auto makeBlock = [&](uint32_t labelId) {
+                        return spvtools::MakeUnique<BasicBlock>(spvtools::MakeUnique<Instruction>(
+                            ctx, spv::Op::OpLabel, 0, labelId, std::initializer_list<Operand>{}));
+                    };
+                    auto addInst = [&](BasicBlock* block, spv::Op opcode, uint32_t typeId,
+                                       uint32_t resultId, std::vector<Operand> operands) {
+                        block->AddInstruction(spvtools::MakeUnique<Instruction>(
+                            ctx, opcode, typeId, resultId, std::move(operands)));
+                    };
+
+                    // entry: t = 0; branch header
+                    addInst(entryBlock, spv::Op::OpStore, 0, 0,
+                            {{SPV_OPERAND_TYPE_ID, {counterVarId}}, {SPV_OPERAND_TYPE_ID, {uint0}}});
+                    addInst(entryBlock, spv::Op::OpBranch, 0, 0, {{SPV_OPERAND_TYPE_ID, {headerLabelId}}});
+
+                    // header: structured loop header
+                    auto headerBlock = makeBlock(headerLabelId);
+                    addInst(headerBlock.get(), spv::Op::OpLoopMerge, 0, 0,
+                            {{SPV_OPERAND_TYPE_ID, {restLabelId}},
+                             {SPV_OPERAND_TYPE_ID, {continueLabelId}},
+                             {SPV_OPERAND_TYPE_LOOP_CONTROL,
+                              {static_cast<uint32_t>(spv::LoopControlMask::MaskNone)}}});
+                    addInst(headerBlock.get(), spv::Op::OpBranch, 0, 0,
+                            {{SPV_OPERAND_TYPE_ID, {checkLabelId}}});
+
+                    // check: t < vertexCount * clipCount ?
+                    auto checkBlock = makeBlock(checkLabelId);
+                    const uint32_t tCheckId = ctx->TakeNextId();
+                    addInst(checkBlock.get(), spv::Op::OpLoad, uintTypeId, tCheckId,
+                            {{SPV_OPERAND_TYPE_ID, {counterVarId}}});
+                    const uint32_t condId = ctx->TakeNextId();
+                    addInst(checkBlock.get(), spv::Op::OpULessThan, boolTypeId, condId,
+                            {{SPV_OPERAND_TYPE_ID, {tCheckId}}, {SPV_OPERAND_TYPE_ID, {uintTotal}}});
+                    addInst(checkBlock.get(), spv::Op::OpBranchConditional, 0, 0,
+                            {{SPV_OPERAND_TYPE_ID, {condId}},
+                             {SPV_OPERAND_TYPE_ID, {bodyLabelId}},
+                             {SPV_OPERAND_TYPE_ID, {restLabelId}}});
+
+                    // body: mg_ClipDistanceIn[t / N][t % N] = gl_in[t / N].gl_ClipDistance[t % N]
+                    auto bodyBlock = makeBlock(bodyLabelId);
+                    const uint32_t tBodyId = ctx->TakeNextId();
+                    addInst(bodyBlock.get(), spv::Op::OpLoad, uintTypeId, tBodyId,
+                            {{SPV_OPERAND_TYPE_ID, {counterVarId}}});
+                    const uint32_t vertexIdxId = ctx->TakeNextId();
+                    addInst(bodyBlock.get(), spv::Op::OpUDiv, uintTypeId, vertexIdxId,
+                            {{SPV_OPERAND_TYPE_ID, {tBodyId}}, {SPV_OPERAND_TYPE_ID, {uintN}}});
+                    const uint32_t clipIdxId = ctx->TakeNextId();
+                    addInst(bodyBlock.get(), spv::Op::OpUMod, uintTypeId, clipIdxId,
+                            {{SPV_OPERAND_TYPE_ID, {tBodyId}}, {SPV_OPERAND_TYPE_ID, {uintN}}});
+                    const uint32_t srcChainId = ctx->TakeNextId();
+                    addInst(bodyBlock.get(), spv::Op::OpAccessChain, ptrInElem, srcChainId,
+                            {{SPV_OPERAND_TYPE_ID, {glInVar->result_id()}},
+                             {SPV_OPERAND_TYPE_ID, {vertexIdxId}},
+                             {SPV_OPERAND_TYPE_ID, {memberConst}},
+                             {SPV_OPERAND_TYPE_ID, {clipIdxId}}});
+                    const uint32_t valId = ctx->TakeNextId();
+                    addInst(bodyBlock.get(), spv::Op::OpLoad, elemTypeId, valId,
+                            {{SPV_OPERAND_TYPE_ID, {srcChainId}}});
+                    const uint32_t dstChainId = ctx->TakeNextId();
+                    addInst(bodyBlock.get(), spv::Op::OpAccessChain, ptrPrivElem, dstChainId,
+                            {{SPV_OPERAND_TYPE_ID, {mgInVarId}},
+                             {SPV_OPERAND_TYPE_ID, {vertexIdxId}},
+                             {SPV_OPERAND_TYPE_ID, {clipIdxId}}});
+                    addInst(bodyBlock.get(), spv::Op::OpStore, 0, 0,
+                            {{SPV_OPERAND_TYPE_ID, {dstChainId}}, {SPV_OPERAND_TYPE_ID, {valId}}});
+                    addInst(bodyBlock.get(), spv::Op::OpBranch, 0, 0,
+                            {{SPV_OPERAND_TYPE_ID, {continueLabelId}}});
+
+                    // continue: ++t
+                    auto continueBlock = makeBlock(continueLabelId);
+                    const uint32_t tContinueId = ctx->TakeNextId();
+                    addInst(continueBlock.get(), spv::Op::OpLoad, uintTypeId, tContinueId,
+                            {{SPV_OPERAND_TYPE_ID, {counterVarId}}});
+                    const uint32_t tIncId = ctx->TakeNextId();
+                    addInst(continueBlock.get(), spv::Op::OpIAdd, uintTypeId, tIncId,
+                            {{SPV_OPERAND_TYPE_ID, {tContinueId}}, {SPV_OPERAND_TYPE_ID, {uint1}}});
+                    addInst(continueBlock.get(), spv::Op::OpStore, 0, 0,
+                            {{SPV_OPERAND_TYPE_ID, {counterVarId}}, {SPV_OPERAND_TYPE_ID, {tIncId}}});
+                    addInst(continueBlock.get(), spv::Op::OpBranch, 0, 0,
+                            {{SPV_OPERAND_TYPE_ID, {headerLabelId}}});
+
+                    BasicBlock* headerPtr = entryFn->InsertBasicBlockBefore(std::move(headerBlock), restBlock);
+                    BasicBlock* checkPtr = entryFn->InsertBasicBlockAfter(std::move(checkBlock), headerPtr);
+                    BasicBlock* bodyPtr = entryFn->InsertBasicBlockAfter(std::move(bodyBlock), checkPtr);
+                    entryFn->InsertBasicBlockAfter(std::move(continueBlock), bodyPtr);
+
+                    // Redirect the pre-existing accesses to the shadow copy.
+                    for (Instruction* chain : chains) {
+                        if (chain->NumInOperands() == 3) {
+                            // (vertex, member): whole float[N] of one vertex.
+                            Instruction* chainPtrType = defUse->GetDef(chain->type_id());
+                            const uint32_t pointeeId = chainPtrType->GetSingleWordInOperand(1);
+                            const uint32_t newPtrType =
+                                PointerTypeTo(ctx, pointeeId, spv::StorageClass::Private);
+                            ctx->ForgetUses(chain);
+                            std::vector<Operand> newOperands;
+                            newOperands.push_back({SPV_OPERAND_TYPE_ID, {mgInVarId}});
+                            newOperands.push_back(chain->GetInOperand(1));
+                            chain->SetResultType(newPtrType);
+                            chain->SetInOperands(std::move(newOperands));
+                            ctx->AnalyzeUses(chain);
+                        } else {
+                            // (vertex, member, k, ...): drop the member index.
+                            Instruction* chainPtrType = defUse->GetDef(chain->type_id());
+                            const uint32_t pointeeId = chainPtrType->GetSingleWordInOperand(1);
+                            const uint32_t newPtrType =
+                                PointerTypeTo(ctx, pointeeId, spv::StorageClass::Private);
+                            ctx->ForgetUses(chain);
+                            std::vector<Operand> newOperands;
+                            newOperands.push_back({SPV_OPERAND_TYPE_ID, {mgInVarId}});
+                            newOperands.push_back(chain->GetInOperand(1));
+                            for (uint32_t i = 3; i < chain->NumInOperands(); ++i) {
+                                newOperands.push_back(chain->GetInOperand(i));
+                            }
+                            chain->SetResultType(newPtrType);
+                            chain->SetInOperands(std::move(newOperands));
+                            ctx->AnalyzeUses(chain);
+                        }
+                    }
+
+                    return true;
+                }
+            } // namespace
+
+            spvtools::opt::Pass::Status LowerClipDistanceForEsslPass::Process() {
+                auto* ctx = context();
+                const spv::ExecutionModel model = EntryExecutionModel(ctx);
+                const bool isVertex = model == spv::ExecutionModel::Vertex;
+                const bool isGeometry = model == spv::ExecutionModel::Geometry;
+                if (!isVertex && !isGeometry) {
+                    return Status::SuccessWithoutChange;
+                }
+
+                bool changed = LowerOutputClipDistance(ctx, isGeometry);
+                if (isGeometry) {
+                    changed |= LowerInputClipDistance(ctx);
+                }
+
+                if (!changed) {
+                    return Status::SuccessWithoutChange;
+                }
+                ctx->InvalidateAnalysesExceptFor(spvtools::opt::IRContext::kAnalysisNone);
+                return Status::SuccessWithChange;
+            }
+
+            spvtools::Optimizer::PassToken
+            LowerClipDistanceForEsslPass::CreateLowerClipDistanceForEsslPass() {
+                return spvtools::Optimizer::PassToken(MakeUnique<LowerClipDistanceForEsslPass>());
+            }
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerClipDistanceForEsslPass.h

@@ -0,0 +1,44 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerClipDistanceForEsslPass.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include "source/opt/pass.h"
+#include "spirv-tools/optimizer.hpp"
+
+#include <Includes.h>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            // Adreno's ESSL compiler mishandles gl_ClipDistance (device-verified on Adreno 750):
+            //   - writes through non-constant indices silently fail to link,
+            //   - reads of gl_in[i].gl_ClipDistance[k] with a CONSTANT k >= 1 fail to compile
+            //     ("array indexing out of boundary") while dynamic-index reads work,
+            //   - compiling a whole-array read of gl_in[i].gl_ClipDistance segfaults the
+            //     compiler backend (libllvm-qgl.so).
+            // This pass shadows the builtin so the decompiled ESSL only ever touches it in the
+            // shapes Adreno accepts. Output side (vertex + geometry): all accesses to the
+            // Output ClipDistance (gl_PerVertex member or standalone variable) are redirected
+            // to a Private mg_ClipDistance array, and a flush writing the real builtin with
+            // literal constant indices is inserted before every OpEmitVertex (geometry) or
+            // every return of the entry point (vertex). Input side (geometry): accesses to
+            // gl_in[...].gl_ClipDistance are redirected to a Private mg_ClipDistanceIn
+            // array-of-arrays filled once at the top of the entry point by a structured loop
+            // whose gl_in reads use dynamic (loop-variable) indices. The builtin members stay
+            // statically referenced by the flush/copy so cross-stage IO matching is intact.
+            // Only meant for the DirectGLES transpile path on Qualcomm devices.
+            class LowerClipDistanceForEsslPass : public spvtools::opt::Pass {
+            public:
+                const char* name() const override { return "lower-clip-distance-for-essl"; }
+                Status Process() override;
+
+                static spvtools::Optimizer::PassToken CreateLowerClipDistanceForEsslPass();
+            };
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripNoPerspectivePass.cpp

@@ -0,0 +1,72 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripNoPerspectivePass.cpp
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#include "StripNoPerspectivePass.h"
+
+#include "spirv.hpp"
+#include "source/opt/instruction.h"
+#include "source/opt/ir_context.h"
+#include "source/util/make_unique.h"
+
+#include <vector>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            namespace {
+                using spvtools::opt::Instruction;
+                using spvtools::opt::IRContext;
+
+                // OpDecorate       <target-id> <decoration> [literals...]
+                // OpMemberDecorate <struct-id>  <member> <decoration> [literals...]
+                constexpr uint32_t kDecorateDecorationOperand = 1;
+                constexpr uint32_t kMemberDecorateDecorationOperand = 2;
+            } // namespace
+
+            spvtools::opt::Pass::Status StripNoPerspectivePass::Process() {
+                auto* irContext = context();
+
+                // Collect first: KillInst mutates the annotation list being walked.
+                std::vector<Instruction*> toKill;
+                for (Instruction& annotation : irContext->annotations()) {
+                    uint32_t decorationOperand = 0;
+                    if (annotation.opcode() == spv::Op::OpDecorate) {
+                        decorationOperand = kDecorateDecorationOperand;
+                    } else if (annotation.opcode() == spv::Op::OpMemberDecorate) {
+                        decorationOperand = kMemberDecorateDecorationOperand;
+                    } else {
+                        continue;
+                    }
+
+                    if (annotation.NumInOperands() <= decorationOperand) {
+                        continue;
+                    }
+                    if (static_cast<spv::Decoration>(annotation.GetSingleWordInOperand(decorationOperand)) ==
+                        spv::Decoration::NoPerspective) {
+                        toKill.push_back(&annotation);
+                    }
+                }
+
+                if (toKill.empty()) {
+                    return Status::SuccessWithoutChange;
+                }
+
+                for (Instruction* inst : toKill) {
+                    irContext->KillInst(inst);
+                }
+
+                irContext->InvalidateAnalysesExceptFor(IRContext::kAnalysisNone);
+                return Status::SuccessWithChange;
+            }
+
+            spvtools::Optimizer::PassToken StripNoPerspectivePass::CreateStripNoPerspectivePass() {
+                return spvtools::Optimizer::PassToken(MakeUnique<StripNoPerspectivePass>());
+            }
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripNoPerspectivePass.h

@@ -0,0 +1,35 @@
+// MobileGL - MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripNoPerspectivePass.h
+// Copyright (c) 2025-2026 MobileGL-Dev
+// Licensed under the GNU Lesser General Public License v3.0:
+//   https://www.gnu.org/licenses/gpl-3.0.txt
+//   https://www.gnu.org/licenses/lgpl-3.0.txt
+// SPDX-License-Identifier: LGPL-3.0-only
+// End of Source File Header
+
+#pragma once
+#include "source/opt/pass.h"
+#include "spirv-tools/optimizer.hpp"
+
+#include <Includes.h>
+
+namespace MobileGL {
+    namespace MG_Util {
+        namespace ShaderTranspiler {
+            // Removes the NoPerspective decoration from every interface variable and block member.
+            // DirectGLES fallback only, for devices that lack GL_NV_shader_noperspective_interpolation:
+            // SPIRV-Cross renders a NoPerspective-decorated varying as ESSL `noperspective` plus
+            // `#extension GL_NV_shader_noperspective_interpolation : require`, which such a driver
+            // rejects. Dropping the decoration falls the varying back to smooth (perspective-correct)
+            // interpolation - the same visible result the old text-level strip produced, but without
+            // corrupting identifiers and without touching DirectVulkan, where NoPerspective is native.
+            // (The exact screen-linear emulation via gl_Position.w / gl_FragCoord.w is a later step.)
+            class StripNoPerspectivePass : public spvtools::opt::Pass {
+            public:
+                const char* name() const override { return "strip-noperspective"; }
+                Status Process() override;
+
+                static spvtools::Optimizer::PassToken CreateStripNoPerspectivePass();
+            };
+        } // namespace ShaderTranspiler
+    } // namespace MG_Util
+} // namespace MobileGL

tools/cts/README.md

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

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

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

tools/cts/platform/tcuMobileGLPlatform.cpp

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

tools/cts/platform/tcuMobileGLPlatform.hpp

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

tools/cts/probe/.gitignore

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

tools/cts/probe/mgprobe.c

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

tools/cts/scripts/qpa_report.py

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

tools/cts/scripts/run_cts.py

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

tools/cts/scripts/sync_to_cts.py

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

tools/cts/skills/README.md

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

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

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

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

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