[Fix] (MG_Impl): report a buffer texture as the wrong object, not the wrong token

glGetTextureParameter* resolve the texture by name and then hand the work to the
target-based getter, which validates the target it was given. For a buffer texture that
is GL_TEXTURE_BUFFER, and the target form correctly calls that an unaccepted token -
INVALID_ENUM.

By name there is no token to blame. The application named an object that carries none of
the sampler or level state the query reports, which is INVALID_OPERATION (GL 4.6 core
8.11). The four by-name getters check the resolved object before delegating, so the error
describes what the caller actually got wrong.

Fixes direct_state_access.textures_parameter_errors on both backends, taking the group to
74.93% on Espryt and 73.32% on Magma.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DnW6wQYv2Pvrfisqak8UJu

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

@@ -201,11 +201,6 @@ fetch_file_from_mirror() {
   return 1
 }
 
-# Files no mirror could serve, even after retrying every mirror. Only these fall
-# back to Git LFS, so a mirror that served the rest of the case still spares
-# GitHub the bandwidth for those files.
-mirror_failures=()
-
 fetch_from_mirror() {
   mkdir -p "${fixture_dir}"
   for file in "${files[@]}"; do
@@ -224,19 +219,17 @@ fetch_from_mirror() {
       echo "Mirror did not serve ${name}; trying the next mirror" >&2
     done
     if [ "${fetched}" -ne 1 ]; then
-      mirror_failures+=("${file}")
+      return 1
     fi
   done
-  [ "${#mirror_failures[@]}" -eq 0 ]
 }
 
 if fetch_from_mirror; then
   echo "Fetched trace fixture files for ${case_name} from mirror: ${include}"
 else
-  fallback_include="$(IFS=,; echo "${mirror_failures[*]}")"
-  echo "All mirrors failed for ${#mirror_failures[@]} of ${#files[@]} file(s) of ${case_name}; falling back to Git LFS: ${fallback_include}"
+  echo "All mirrors failed for ${case_name}; falling back to Git LFS: ${include}"
   git lfs install --local
-  git lfs pull --include="${fallback_include}" --exclude=""
+  git lfs pull --include="${include}" --exclude=""
 fi
 
 for file in "${files[@]}"; do

.github/workflows/test.yml

@@ -177,13 +177,9 @@ jobs:
         uses: lukka/get-cmake@v4.3.3
 
       - name: Install runtime dependencies
-        # libegl-mesa0 is the EGL vendor library itself: DriverBench brings up a
-        # real GL context, and libegl1 is only glvnd's dispatch. It normally
-        # arrives as a Recommends of libegl1, which is too quiet a dependency for
-        # the one job that needs a working driver.
         run: |
           sudo apt-get update
-          sudo apt-get install -y libvulkan1 libegl1 libegl-mesa0 libgles2 libgl1-mesa-dri mesa-vulkan-drivers
+          sudo apt-get install -y libvulkan1 libegl1 libgles2 libgl1-mesa-dri mesa-vulkan-drivers
 
       - name: Download Linux runtime
         uses: actions/download-artifact@v8

.gitmodules

@@ -31,9 +31,3 @@
 [submodule "3rdparty/apitrace"]
 	path = 3rdparty/apitrace
 	url = https://github.com/MobileGL-Dev/apitrace.git
-[submodule "3rdparty/asio"]
-	path = 3rdparty/asio
-	url = https://github.com/chriskohlhoff/asio.git
-[submodule "3rdparty/libfork"]
-	path = 3rdparty/libfork
-	url = https://github.com/ConorWilliams/libfork.git

CMakeLists.txt

@@ -4,11 +4,6 @@ project("MobileGL")
 
 option(MOBILEGL_BUILD_TEST        "Build MobileGL tests"                             ON )
 option(MOBILEGL_BUILD_BENCHMARK   "Build MobileGL benchmarks"                        ON )
-# Headless end-to-end GPU scenarios (MobileGL/MG_IntegrationTest). They need a
-# real GPU/ICD to do anything, so they are off by default for CI; every scenario
-# skips cleanly where there is none. Registered under the `integration-gpu`
-# ctest label so a run can select or exclude them.
-option(MOBILEGL_BUILD_INTEGRATION_TEST "Build MobileGL headless GPU integration tests" OFF)
 option(MOBILEGL_FORCE_RELEASE_OPT "Enable Release optimization flags in Debug build" ON )
 option(MOBILEGL_ENABLE_TRACY      "Enable tracy for profiling"                       OFF)
 option(MOBILEGL_BUILD_TRACE_REPLAY "Build desktop apitrace replay runner"            OFF)
@@ -22,9 +17,7 @@ if (ANDROID)
     set(MOBILEGL_BUILD_BENCHMARK  OFF CACHE BOOL "Build MobileGL benchmarks" FORCE)
 endif()
 
-option(MOBILEGL_ENABLE_LTO "Build with ThinLTO/IPO" OFF)
-
-if ((NOT CMAKE_BUILD_TYPE STREQUAL "Debug" OR MOBILEGL_FORCE_RELEASE_OPT) AND MOBILEGL_ENABLE_LTO)
+if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug" OR MOBILEGL_FORCE_RELEASE_OPT)
     # Check if ThinLTO or LTO is suppported
     include(CheckIPOSupported)
     include(CheckCCompilerFlag)
@@ -154,9 +147,6 @@ set(SOURCE_FILES
 
     MobileGL/MG_Util/Debug/Log.cpp
 
-    MobileGL/MG_Util/Async/JobNode.cpp
-    MobileGL/MG_Util/Async/ShaderCompilePool.cpp
-
     MobileGL/MG_Util/Math/VectorTypes.cpp
     MobileGL/MG_Util/Metrics/TextureMetrics.cpp
 
@@ -190,7 +180,6 @@ set(SOURCE_FILES
 
     MobileGL/MG_Util/Classifiers/TextureEnumClassifier.cpp
 
-    MobileGL/MG_Util/ShaderTranspiler/CompileEnv.cpp
     MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpvcSession.cpp
     MobileGL/MG_Util/ShaderTranspiler/ShaderSourceProcessor.cpp
@@ -198,11 +187,9 @@ set(SOURCE_FILES
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FlattenInterfaceStructPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EliminateFloatEqualsZeroPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RenameSamplerFunctionParameterPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RenameBuiltinShadowingFunctionsPass.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/PackDoubleVertexInputsPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RebaseInstanceIndexPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/NormalizeRectCoordinatesPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripUboMemberRelaxedPrecisionPass.cpp
@@ -218,7 +205,6 @@ set(SOURCE_FILES
     MobileGL/MG_Util/Texture/TextureFormatProcessor.cpp
 
     MobileGL/MG_Impl/GLXImpl/Exporting/Definitions.cpp
-    MobileGL/MG_Impl/GLXImpl/GLXImpl.cpp
     MobileGL/MG_Impl/GLXImpl/LookUp/LookUp.cpp
 
     MobileGL/MG_Impl/EGLImpl/Exporting/Definitions.cpp
@@ -232,8 +218,6 @@ set(SOURCE_FILES
     MobileGL/MG_Impl/GLImpl/Framebuffer/Validators.cpp
     MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp
     MobileGL/MG_Impl/GLImpl/Program/GL_Program.cpp
-    MobileGL/MG_Impl/GLImpl/Program/ProgramInterface.cpp
-    MobileGL/MG_Impl/GLImpl/Program/GL_ProgramPipeline.cpp
     MobileGL/MG_Impl/GLImpl/Texture/GL_Texture.cpp
     MobileGL/MG_Impl/GLImpl/Texture/Validators.cpp
     MobileGL/MG_Impl/GLImpl/Texture/ProxyTexture.cpp
@@ -256,7 +240,6 @@ set(SOURCE_FILES
     MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp
     MobileGL/MG_Backend/DirectGLES/Utils.cpp
     MobileGL/MG_Backend/DirectGLES/Managers.cpp
-    MobileGL/MG_Backend/DirectGLES/MultiDraw.cpp
 
     MobileGL/MG_Backend/DirectVulkan/DirectVulkan.cpp
     MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.cpp
@@ -295,11 +278,7 @@ set(SOURCE_FILES
     MobileGL/MG_State/GLState/TextureState/TextureUnit.cpp
     MobileGL/MG_State/GLState/TextureState/TextureState.cpp
     MobileGL/MG_State/GLState/ProgramState/ProgramObject.cpp
-    MobileGL/MG_State/GLState/ProgramState/ProgramLinkTask.cpp
-    MobileGL/MG_State/GLState/ProgramState/ShaderCompileTask.cpp
     MobileGL/MG_State/GLState/ProgramState/ShaderObject.cpp
-    MobileGL/MG_State/GLState/ProgramState/ShaderPreprocessCache.cpp
-    MobileGL/MG_State/GLState/ProgramState/ShaderCompileAdoptionMap.cpp
     MobileGL/MG_State/GLState/ProgramState/ProgramState.cpp
     MobileGL/MG_State/GLState/RenderState/RenderState.cpp
     MobileGL/MG_State/GLState/FramebufferState/FramebufferObject.cpp
@@ -322,7 +301,6 @@ endif()
 if (ANDROID)
     list(APPEND SOURCE_FILES
         MobileGL/MG_Util/SelfTest/DriverPostJni.cpp
-        MobileGL/MG_Util/SelfTest/DriverBenchJni.cpp
     )
 endif()
 
@@ -333,11 +311,6 @@ if (WIN32)
     )
 endif()
 
-# The shader-compile pool runs standalone Asio on real threads. This host's glibc (>= 2.34)
-# merged pthread into libc, so it links without asking, but the NDK and musl are not
-# guaranteed to be as forgiving - ask for it explicitly rather than rely on the accident.
-find_package(Threads REQUIRED)
-
 set(MOBILEGL_LINK_LIBRARIES
         glslang::glslang
         spirv-cross-c
@@ -347,17 +320,12 @@ set(MOBILEGL_LINK_LIBRARIES
         GPUOpen::VulkanMemoryAllocator
         Vulkan::UtilityHeaders
         spirv-reflect-static
-        Threads::Threads
 )
 
 set(MOBILEGL_COMPILE_DEF
         -DVMA_STATIC_VULKAN_FUNCTIONS=0
         -DVMA_DYNAMIC_VULKAN_FUNCTIONS=1
         -DVMA_VULKAN_VERSION=1001000
-        # Header-only Asio, no Boost, no deprecated interfaces. Set on the definition list
-        # rather than per-target so the shared library and the _s static target agree.
-        -DASIO_STANDALONE
-        -DASIO_NO_DEPRECATED
 )
 
 message(STATUS "MOBILEGL_COMPILE_DEF=${MOBILEGL_COMPILE_DEF}")
@@ -369,17 +337,6 @@ set(MOBILEGL_INCLUDE_DIR
         ${spirv-tools_SOURCE_DIR}/include
         ${spirv-tools_BINARY_DIR}
         ${SPIRV-Headers_SOURCE_DIR}/include
-        # Header-only submodule: no add_subdirectory, no link target. Only
-        # MG_Util/Async/ShaderCompilePool.cpp includes it, and it stays behind that file's
-        # pimpl so no consumer target needs this path.
-        ${CMAKE_SOURCE_DIR}/3rdparty/asio/asio/include
-        # The second shader-compile execution engine (MOBILEGL_ASYNC_POOL=libfork), on the
-        # same terms as Asio above: header-only, no add_subdirectory (its CMakeLists only
-        # declares an INTERFACE target plus install/test scaffolding we do not want), no link
-        # target, and reachable from exactly one translation unit. libfork's own
-        # target_compile_features asks for cxx_std_23, which this project already sets
-        # globally, so its C++20 coroutines need no per-source standard override.
-        ${CMAKE_SOURCE_DIR}/3rdparty/libfork/include
 )
 
 add_library(${CMAKE_PROJECT_NAME} SHARED
@@ -577,12 +534,6 @@ if (NOT ANDROID)
         add_subdirectory(MobileGL/MG_Test)
     endif()
 
-    # After MG_Test so googletest is already available when the unit tests are
-    # built; the module fetches its own copy when they are not.
-    if (MOBILEGL_BUILD_INTEGRATION_TEST)
-        add_subdirectory(MobileGL/MG_IntegrationTest)
-    endif()
-
     if (MOBILEGL_BUILD_BENCHMARK)
         add_subdirectory(MobileGL/MG_Benchmark)
     endif()

MobileGL/Config.h

@@ -29,33 +29,6 @@ namespace MobileGL::MG_Config {
         ForceOff,
     };
 
-    // Preferred DirectVulkan dispatch tier for the glMultiDraw* families. A preference,
-    // never a demand: the renderer clamps it to what the device supports at device
-    // creation, falling down the chain ext -> indirect -> unroll with one log line.
-    enum class MultiDrawMode : Uint8 {
-        Auto = 0, // unset: best supported tier
-        Ext,      // VK_EXT_multi_draw: one vkCmdDrawMultiEXT / vkCmdDrawMultiIndexedEXT
-        Indirect, // multiDrawIndirect feature: one vkCmdDraw*Indirect over a transient command array
-        Unroll,   // one vkCmdDraw* per sub-draw
-    };
-
-    // Preferred DirectGLES emulation tier for glMultiDrawElements(BaseVertex). GLES has no
-    // such entry point in core, so every tier below is an emulation; they differ only in
-    // which driver capability they lean on and how many driver calls a batch costs. Like
-    // the Magma knob this is a preference, clamped at resolution time to what the ES
-    // driver actually supports, with one log line when it falls back.
-    enum class GLESMultiDrawMode : Uint8 {
-        Auto = 0,      // unset: best supported tier
-        Ext,           // one glMultiDrawElementsBaseVertexEXT
-        MultiIndirect, // one glMultiDrawElementsIndirectEXT over a scratch command buffer
-        Indirect,      // one glDrawElementsIndirect per sub-draw over that same buffer
-        BaseVertex,    // one glDrawElementsBaseVertex per sub-draw
-        DrawElements,  // baseVertex folded into a scratch index buffer on the CPU, then plain
-                       // glDrawElements per sub-draw (for drivers with no base-vertex draw at all)
-        Compute,       // a compute shader flattens every sub-draw into one rebased index buffer,
-                       // drawn by a single glDrawElements
-    };
-
     // 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"
@@ -66,12 +39,6 @@ namespace MobileGL::MG_Config {
     //   - DISPLAY: X11 session variable, not MobileGL configuration.
     //   - MOBILEGL_LOG_FILE_PATH: log-file init runs before MG_ConfigLoader::Init
     //     (see MG_Util/Debug/Log.cpp).
-    //   - MOBILEGL_ASYNC_POOL: a ShaderCompilePool is constructed by binaries that never call
-    //     MobileGL::Initialize() and so never run MG_ConfigLoader::Init - MG_Test's
-    //     JobNodeTest builds pools directly, and it is the suite that runs the whole async
-    //     matrix against both execution engines. Mirroring it here would resolve to the
-    //     default in exactly the tests that exist to tell the engines apart (see
-    //     MG_Util/Async/ShaderCompilePool.cpp, DetectAsyncPoolEngine).
     struct FeaturesTable {
         // MOBILEGL_DISABLE_TIMERQUERY: do not advertise or use GPU timer queries.
         Bool DisableTimerQuery = false;
@@ -124,24 +91,6 @@ namespace MobileGL::MG_Config {
         // 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;
-        // MOBILEGL_MAGMA_MULTIDRAW_MODE: preferred DirectVulkan multi-draw dispatch tier
-        // ("ext" | "indirect" | "unroll", see MultiDrawMode). Clamped to device support;
-        // unset picks the best supported tier.
-        MultiDrawMode MagmaMultiDrawMode = MultiDrawMode::Auto;
-        // MOBILEGL_ESPRYT_MULTIDRAW_MODE: preferred DirectGLES glMultiDrawElements emulation
-        // tier ("ext" | "multiindirect" | "indirect" | "basevertex" | "drawelements" |
-        // "compute", see GLESMultiDrawMode). Clamped to driver support; unset picks the best
-        // supported tier, which never includes "compute" - see the note on its resolution.
-        GLESMultiDrawMode EsprytMultiDrawMode = GLESMultiDrawMode::Auto;
-        // MOBILEGL_ASYNC_SHADER_COMPILE: overrides asynchronous shader compilation. Unset
-        // keeps the built-in default (MG_Util::Async::kAsyncShaderCompileDefault); falsy
-        // forces every glCompileShader/glLinkProgram to run synchronously on the calling
-        // thread AND withdraws GL_KHR_parallel_shader_compile, so the single switch reverts
-        // both the threading and the application-visible behaviour change.
-        QuirkOverride AsyncShaderCompile = QuirkOverride::Auto;
-        // MOBILEGL_ASYNC_SHADER_COMPILE_THREADS: shader-compile worker count. 0 (unset) means
-        // auto, which is min(4, big cores); an explicit value is honoured as given.
-        Uint32 AsyncShaderCompileThreads = 0;
     };
     extern FeaturesTable Features;
 } // namespace MobileGL::MG_Config

MobileGL/ConfigLoader.cpp

@@ -97,47 +97,6 @@ namespace MobileGL::MG_ConfigLoader {
                                          : MG_Config::QuirkOverride::ForceOff;
     }
 
-    // Multi-draw mode is a named-value preference: unset keeps Auto (best supported tier),
-    // a recognized name selects that tier as the ceiling, anything else warns and keeps Auto.
-    inline MG_Config::MultiDrawMode QueryEnvMultiDrawMode(const String& key) {
-        auto it = acceptedEnvVariablesMap->find(key);
-        if (it == acceptedEnvVariablesMap->end()) {
-            return MG_Config::MultiDrawMode::Auto;
-        }
-        String lowered = it->second;
-        std::transform(lowered.begin(), lowered.end(), lowered.begin(),
-                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-        if (lowered == "ext") return MG_Config::MultiDrawMode::Ext;
-        if (lowered == "indirect") return MG_Config::MultiDrawMode::Indirect;
-        if (lowered == "unroll") return MG_Config::MultiDrawMode::Unroll;
-        if (lowered.empty() || lowered == "auto") return MG_Config::MultiDrawMode::Auto;
-        MGLOG_W("Config: Ignoring invalid env variable %s='%s'; expected ext|indirect|unroll|auto, using auto",
-                key.c_str(), it->second.c_str());
-        return MG_Config::MultiDrawMode::Auto;
-    }
-
-    // Same contract as QueryEnvMultiDrawMode, over the DirectGLES tier names.
-    inline MG_Config::GLESMultiDrawMode QueryEnvGLESMultiDrawMode(const String& key) {
-        auto it = acceptedEnvVariablesMap->find(key);
-        if (it == acceptedEnvVariablesMap->end()) {
-            return MG_Config::GLESMultiDrawMode::Auto;
-        }
-        String lowered = it->second;
-        std::transform(lowered.begin(), lowered.end(), lowered.begin(),
-                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-        if (lowered == "ext") return MG_Config::GLESMultiDrawMode::Ext;
-        if (lowered == "multiindirect") return MG_Config::GLESMultiDrawMode::MultiIndirect;
-        if (lowered == "indirect") return MG_Config::GLESMultiDrawMode::Indirect;
-        if (lowered == "basevertex") return MG_Config::GLESMultiDrawMode::BaseVertex;
-        if (lowered == "drawelements") return MG_Config::GLESMultiDrawMode::DrawElements;
-        if (lowered == "compute") return MG_Config::GLESMultiDrawMode::Compute;
-        if (lowered.empty() || lowered == "auto") return MG_Config::GLESMultiDrawMode::Auto;
-        MGLOG_W("Config: Ignoring invalid env variable %s='%s'; expected "
-                "ext|multiindirect|indirect|basevertex|drawelements|compute|auto, using auto",
-                key.c_str(), it->second.c_str());
-        return MG_Config::GLESMultiDrawMode::Auto;
-    }
-
     inline Uint32 QueryEnvUint32(const String& key, Uint32 defaultValue, Uint32 minValue, Uint32 maxValue) {
         auto it = acceptedEnvVariablesMap->find(key);
         if (it == acceptedEnvVariablesMap->end()) {
@@ -179,10 +138,6 @@ namespace MobileGL::MG_ConfigLoader {
         features.MagmaDisableBlendedDepthWriteQuirk =
             QueryEnvQuirkOverride("MOBILEGL_MAGMA_DISABLE_BLENDED_DEPTH_WRITE");
         features.DisableRobustBufferAccess = QueryEnvFlag("MOBILEGL_DISABLE_ROBUST_BUFFER_ACCESS");
-        features.MagmaMultiDrawMode = QueryEnvMultiDrawMode("MOBILEGL_MAGMA_MULTIDRAW_MODE");
-        features.EsprytMultiDrawMode = QueryEnvGLESMultiDrawMode("MOBILEGL_ESPRYT_MULTIDRAW_MODE");
-        features.AsyncShaderCompile = QueryEnvQuirkOverride("MOBILEGL_ASYNC_SHADER_COMPILE");
-        features.AsyncShaderCompileThreads = QueryEnvUint32("MOBILEGL_ASYNC_SHADER_COMPILE_THREADS", 0, 0, 64);
     }
 
     inline void InitBackendType() {

MobileGL/Init.cpp

@@ -15,8 +15,6 @@
 #include <MG_Impl/GLImpl/Texture/ProxyTexture.h>
 #include <MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h>
 #include <MG_Impl/GLImpl/Sync/GL_Sync.h>
-#include <MG_Util/Async/ShaderCompilePool.h>
-#include <MG_Util/ShaderTranspiler/ShaderCompiler.h>
 
 #include <atomic>
 #include <mutex>
@@ -39,12 +37,7 @@ namespace MobileGL {
             if (logLifecycle) {
                 MGLOG_I("MobileGL closing...");
             }
-            // First, before anything else is torn down. In-flight compile/link jobs own
-            // their own inputs and are safe against everything below EXCEPT glslang's
-            // process globals and the TShader/TProgram objects hanging off pGLContext,
-            // both of which this function is about to destroy. This is the one
-            // cancellation path in the whole design that waits.
-            MG_Util::Async::ShaderCompilePool::Get().StopAndDrain();
+            glslang::FinalizeProcess();
             // GL syncs die with their contexts, and every context is gone by the
             // time full teardown runs: drain the live-sync registry while the
             // backend function table can still release the backend handles (and
@@ -56,16 +49,6 @@ namespace MobileGL {
             MG_State::pEGLContext.reset();
             MG_Impl::GLImpl::TextureImpl::pProxyTextureManager.reset();
             MG_Impl::GLImpl::FramebufferImpl::pDefaultFramebufferInfo.reset();
-            // Must run AFTER pGLContext.reset(). FinalizeProcess -> ShFinalize deletes
-            // glslang's process-wide pool allocator and every cached built-in symbol table,
-            // while the TShader/TProgram objects owned by the shader and program objects
-            // still reference levels adopted from those tables. Finalizing first left live
-            // glslang objects pointing at freed memory for the rest of the teardown.
-            glslang::FinalizeProcess();
-            // Immediately after, and never apart from it: FinalizeProcess just deleted the
-            // built-in symbol tables the prewarm latch stands for, so leaving it set would
-            // make the next Initialize() skip a prewarm it genuinely needs.
-            MG_Util::ShaderTranspiler::ShaderCompiler::ResetPrewarmLatch();
             MG_Backend::gBackendFunctionsTable = {};
             g_isInitialized = false;
             if (logLifecycle) {
@@ -93,19 +76,6 @@ namespace MobileGL {
         MG_Impl::Init();
         MGLOG_D("MG_Impl initialized");
         glslang::InitializeProcess();
-        // On the GL thread, before any worker can exist. glslang builds its built-in symbol
-        // tables lazily under a process-wide lock held for the whole build, so without this
-        // the first concurrent compiles of a shaderpack all serialize behind the very first
-        // parse and asynchronous compilation looks like it is doing nothing.
-        //
-        // Gated on the flag, because the problem it solves only exists when there are
-        // workers: with compilation synchronous, nothing ever contends for that lock and the
-        // three throwaway parses buy nothing - they just add to every eglInitialize. Read the
-        // flag here rather than inside PrewarmBuiltins so ShaderCompiler keeps no dependency
-        // on the async subsystem (ProgramUtilTest compiles that file without it).
-        if (MG_Util::Async::AsyncShaderCompileEnabled()) {
-            MG_Util::ShaderTranspiler::ShaderCompiler::PrewarmBuiltins();
-        }
         MGLOG_D("glslang initialized");
         g_isInitialized = true;
         MGLOG_I("MobileGL initialized");

MobileGL/MG_Backend/BackendObject.h

@@ -145,10 +145,6 @@ namespace MobileGL {
                                             GLenum buffer, GLint drawbuffer, const GLfloat* value);
             void (*ClearNamedFramebufferfi)(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
                                             GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-            void (*ClearNamedFramebufferiv)(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                            GLenum buffer, GLint drawbuffer, const GLint* value);
-            void (*ClearNamedFramebufferuiv)(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                             GLenum buffer, GLint drawbuffer, const GLuint* value);
             void (*BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0,
                                     GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
             void (*BlitNamedFramebuffer)(const SharedPtr<MG_State::GLState::FramebufferObject>& readFramebuffer,
@@ -181,18 +177,15 @@ namespace MobileGL {
             void (*GetIntegeri_v)(GLenum target, GLuint index, GLint* data);
             void (*GetInteger64i_v)(GLenum target, GLuint index, GLint64* data);
             void (*GetProgramiv)(GLuint program, GLenum pname, GLint* params);
-            // The GL program interface (glGetProgramInterfaceiv / glGetProgramResource*) is NOT
-            // a backend query: it describes the program the application wrote, in the
-            // application's namespace, which neither backend program is in. It is answered
-            // entirely by MG_Impl/GLImpl/Program/ProgramInterface from the frontend reflection.
-            // Takes the block's GL NAME, not glShaderStorageBlockBinding's index. The index
-            // the application passes is the frontend interface-query enumeration's, and no
-            // backend shares that index space: DirectVulkan enumerates SPIR-V descriptor
-            // bindings and DirectGLES asks a real driver about SPIRV-Cross-generated ESSL.
-            // The name is the one coordinate all three agree on, so the frontend resolves the
-            // index against its own enumeration and each backend maps the name to its own.
-            void (*ShaderStorageBlockBinding)(GLuint program, const GLchar* storageBlockName,
-                                              GLuint storageBlockBinding);
+            void (*GetProgramInterfaceiv)(GLuint program, GLenum programInterface, GLenum pname, GLint* params);
+            GLuint (*GetProgramResourceIndex)(GLuint program, GLenum programInterface, const GLchar* name);
+            void (*GetProgramResourceName)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize,
+                                           GLsizei* length, GLchar* name);
+            void (*GetProgramResourceiv)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount,
+                                         const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params);
+            GLint (*GetProgramResourceLocation)(GLuint program, GLenum programInterface, const GLchar* name);
+            GLint (*GetProgramResourceLocationIndex)(GLuint program, GLenum programInterface, const GLchar* name);
+            void (*ShaderStorageBlockBinding)(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
             // GL fence sync objects. All entries are optional (may be null); the
             // frontend then falls back to always-signaled sync semantics.
             // FenceSync may itself return null when the backend cannot create a
@@ -356,40 +349,6 @@ namespace MobileGL {
             // real ES drivers behind DirectGLES both do. Defaults to true so a backend
             // that never sets it keeps the permissive behaviour.
             Bool SupportsDistinctDepthStencilAttachments = true;
-            // Whether attaching a single layer of a 3D or array texture to a framebuffer actually
-            // renders to that layer. DirectGLES hands the layer straight to
-            // glFramebufferTextureLayer, so it does; DirectVulkan maps a GL layer onto a Vulkan
-            // array layer with no notion of a 3D depth slice, so it does not yet. Defaults to false
-            // so a backend that never sets it gets the conservative answer.
-            // Which layered texture targets this backend can attach ONE layer of to a framebuffer
-            // and then really clear, render and read back that layer. Bit (1u << TextureTarget) is
-            // set for each supported target. Deliberately per target rather than one flag: the three
-            // ways a GL layer maps onto Vulkan are independent capabilities. A 2D or 2D multisample
-            // array layer IS a VkImage array layer and needs nothing extra; a 3D texture's layer is
-            // a z slice, which needs a 2D-array-compatible image and a per-slice clear that
-            // vkCmdClearColorImage cannot express; a cube map array needs an image shape and the
-            // imageCubeArray feature before it can be attached at any layer at all. Defaults to 0 so
-            // a backend that never sets it gets the conservative answer.
-            Uint32 PerLayerFramebufferAttachmentTargets = 0;
-
-            static constexpr Uint32 PerLayerFramebufferAttachmentBit(TextureTarget target) {
-                return (static_cast<Int>(target) >= 0 &&
-                        static_cast<Int>(target) < static_cast<Int>(TextureTarget::TextureTargetCount))
-                           ? (1u << static_cast<Uint32>(target))
-                           : 0u;
-            }
-
-            Bool SupportsPerLayerFramebufferAttachment(TextureTarget target) const {
-                const Uint32 bit = PerLayerFramebufferAttachmentBit(target);
-                return bit != 0 && (PerLayerFramebufferAttachmentTargets & bit) != 0;
-            }
-            // Whether glVertexAttribLFormat / glVertexArrayAttribLFormat can be honoured, i.e.
-            // whether a 64-bit vertex attribute can actually reach a shader unconverted. Detected,
-            // never assumed: DirectVulkan needs VkPhysicalDeviceFeatures::shaderFloat64 (the
-            // attribute travels as its 32-bit word pair, so no VK_FORMAT_R64* is required, but the
-            // bitcast result is Float64); DirectGLES can never have it, ESSL having no fp64 type at
-            // all. Defaults to false so a backend that never sets it gets the conservative answer.
-            Bool SupportsFloat64VertexAttributes = false;
             SizeT MaxShaderStorageBlockSize = 128 * 1024 * 1024;
             Uint32 SubgroupSize = 0;
             Uint32 SubgroupSupportedStages = 0;

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp

@@ -18,7 +18,6 @@
 #include <MG_Util/Converters/MGToGL/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToStr/TextureEnumConverter.h>
 #include <MG_Util/Texture/TextureFormatProcessor.h>
-#include <MG_Util/Async/ShaderCompilePool.h>
 #include <Config.h>
 #include <algorithm>
 #include <cmath>
@@ -33,7 +32,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
         void ClearGLErrors(const MG_External::GLESFunctionsTable& gl) {
             if (!gl.glGetError) return;
-            while (gl.glGetError() != GL_NO_ERROR) {}
+            while (gl.glGetError() != GL_NO_ERROR) {
+            }
         }
 
         Bool CheckNoGLError(const MG_External::GLESFunctionsTable& gl) {
@@ -77,7 +77,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
         }
 
         Bool IsGLESProbeMultisampleTarget(TextureTarget target) {
-            return target == TextureTarget::Texture2DMultisample || target == TextureTarget::Texture2DMultisampleArray;
+            return target == TextureTarget::Texture2DMultisample ||
+                   target == TextureTarget::Texture2DMultisampleArray;
         }
 
         GLenum GetFramebufferAttachment(TextureInternalFormat format) {
@@ -114,8 +115,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
             GLenum normalizedInternalFormat = glFormat;
             GLenum imageFormat = GL_RGBA;
             GLenum imageType = GL_UNSIGNED_BYTE;
-            MG_Util::TextureFormatProcessor::NormalizePixelFormat(glFormat, PixelFormatNormalizeOptionBit::None,
-                                                                  &normalizedInternalFormat, &imageFormat, &imageType);
+            MG_Util::TextureFormatProcessor::NormalizePixelFormat(
+                glFormat, PixelFormatNormalizeOptionBit::None, &normalizedInternalFormat, &imageFormat, &imageType);
             return imageFormat != GL_RED_INTEGER && imageFormat != GL_RG_INTEGER && imageFormat != GL_RGB_INTEGER &&
                    imageFormat != GL_RGBA_INTEGER && !MG_Util::IsDepthFormatInternalFormat(format) &&
                    !MG_Util::IsStencilFormatInternalFormat(format);
@@ -153,9 +154,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
         GLESProbeFormatInfo BuildNativeProbeFormatInfo(GLenum requestedInternalFormat) {
             GLESProbeFormatInfo info;
             info.InternalFormat = requestedInternalFormat;
-            MG_Util::TextureFormatProcessor::NormalizePixelFormat(requestedInternalFormat,
-                                                                  PixelFormatNormalizeOptionBit::None, nullptr,
-                                                                  &info.ImageFormat, &info.ImageType);
+            MG_Util::TextureFormatProcessor::NormalizePixelFormat(
+                requestedInternalFormat, PixelFormatNormalizeOptionBit::None, nullptr, &info.ImageFormat,
+                &info.ImageType);
             return info;
         }
 
@@ -210,7 +211,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 reasons.push_back("GL_DEPTH_COMPONENT32 native probe failed on OpenGL ES");
             }
             if (options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget) {
-                reasons.push_back("no colour-renderable three-channel format on OpenGL ES");
+                reasons.push_back("no three-channel multisample storage format on OpenGL ES");
             }
             if (options & PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget) {
                 reasons.push_back("EXT_render_snorm not supported");
@@ -232,16 +233,20 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return MG_Util::ConvertGLEnumToString(internalFormat);
         }
 
-        void LogGLESFormatCaveat(TextureInternalFormat logicalFormat, SizeT targetIndex,
+        void LogGLESFormatCaveat(TextureInternalFormat logicalFormat,
+                                 SizeT targetIndex,
                                  const GLESProbeFormatInfo& fallbackInfo) {
             MGLOG_D("Caveat: %s %s not fully supported. Reason: %s. Fallback: %s",
                     GetFormatCapabilityTargetName(targetIndex).c_str(),
-                    MG_Util::ConvertTextureInternalFormatToString(logicalFormat).c_str(), fallbackInfo.Reason.c_str(),
+                    MG_Util::ConvertTextureInternalFormatToString(logicalFormat).c_str(),
+                    fallbackInfo.Reason.c_str(),
                     ConvertFallbackInternalFormatToString(fallbackInfo.InternalFormat).c_str());
         }
 
-        Bool BuildFallbackProbeFormatInfo(GLenum requestedInternalFormat, Flags<PixelFormatNormalizeOptionBit> options,
-                                          Bool forced, GLESProbeFormatInfo& outInfo) {
+        Bool BuildFallbackProbeFormatInfo(GLenum requestedInternalFormat,
+                                          Flags<PixelFormatNormalizeOptionBit> options,
+                                          Bool forced,
+                                          GLESProbeFormatInfo& outInfo) {
             const Flags<PixelFormatNormalizeOptionBit> applicableOptions =
                 MG_Util::TextureFormatProcessor::GetApplicablePixelFormatNormalizeOptions(requestedInternalFormat,
                                                                                           options);
@@ -256,7 +261,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return outInfo.InternalFormat != GL_UNKNOWN_MGL;
         }
 
-        FormatCapabilityFlags BuildTextureCapsFromProbe(TextureInternalFormat logicalFormat, TextureTarget target,
+        FormatCapabilityFlags BuildTextureCapsFromProbe(TextureInternalFormat logicalFormat,
+                                                        TextureTarget target,
                                                         Bool renderable) {
             FormatCapabilityFlags caps = GetTextureFeatureCaps(logicalFormat, target);
             if (renderable) {
@@ -270,12 +276,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return caps;
         }
 
-        void AddFullFormatCaps(FormatCapabilityCache& cache, SizeT targetIndex, SizeT formatIndex,
+        void AddFullFormatCaps(FormatCapabilityCache& cache,
+                               SizeT targetIndex,
+                               SizeT formatIndex,
                                FormatCapabilityFlags caps) {
             cache.FullCaps[targetIndex][formatIndex] |= caps;
         }
 
-        Bool AddCaveatFormatCaps(FormatCapabilityCache& cache, SizeT targetIndex, SizeT formatIndex,
+        Bool AddCaveatFormatCaps(FormatCapabilityCache& cache,
+                                 SizeT targetIndex,
+                                 SizeT formatIndex,
                                  FormatCapabilityFlags caps) {
             Bool added = false;
             for (FormatCapability capability : kReportedFormatCapabilities) {
@@ -289,7 +299,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
         }
 
         Int GetGLESFormatMaxSamples(const MG_External::GLESCapabilities& capabilities,
-                                    TextureInternalFormat logicalFormat, GLenum imageFormat) {
+                                    TextureInternalFormat logicalFormat,
+                                    GLenum imageFormat) {
             const Bool isDepth = MG_Util::IsDepthFormatInternalFormat(logicalFormat);
             const Bool isStencil = MG_Util::IsStencilFormatInternalFormat(logicalFormat);
             const Bool isInteger = imageFormat == GL_RED_INTEGER || imageFormat == GL_RG_INTEGER ||
@@ -303,8 +314,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return capabilities.MaxColorTextureSamples;
         }
 
-        Bool ProbeFramebufferCompletenessForTexture(const MG_External::GLESFunctionsTable& gl, TextureTarget target,
-                                                    GLuint texture, TextureInternalFormat format) {
+        Bool ProbeFramebufferCompletenessForTexture(const MG_External::GLESFunctionsTable& gl,
+                                                   TextureTarget target,
+                                                   GLuint texture,
+                                                   TextureInternalFormat format) {
             GLuint framebuffer = 0;
             GLint prevFramebuffer = 0;
             if (!gl.glGenFramebuffers || !gl.glBindFramebuffer || !gl.glCheckFramebufferStatus ||
@@ -386,8 +399,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return supported;
         }
 
-        Bool ProbeFramebufferCompletenessForRenderbuffer(const MG_External::GLESFunctionsTable& gl, GLuint renderbuffer,
-                                                         TextureInternalFormat format) {
+        Bool ProbeFramebufferCompletenessForRenderbuffer(const MG_External::GLESFunctionsTable& gl,
+                                                        GLuint renderbuffer,
+                                                        TextureInternalFormat format) {
             GLuint framebuffer = 0;
             GLint prevFramebuffer = 0;
             if (!gl.glGenFramebuffers || !gl.glBindFramebuffer || !gl.glFramebufferRenderbuffer ||
@@ -454,16 +468,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     }
                     break;
                 case TextureTarget::Texture3D:
-                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 2, 0, imageFormat, imageType,
-                                    nullptr);
+                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 2, 0, imageFormat,
+                                    imageType, nullptr);
                     break;
                 case TextureTarget::Texture2DArray:
-                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 1, 0, imageFormat, imageType,
-                                    nullptr);
+                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 1, 0, imageFormat,
+                                    imageType, nullptr);
                     break;
                 case TextureTarget::TextureCubeMapArray:
-                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 6, 0, imageFormat, imageType,
-                                    nullptr);
+                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 6, 0, imageFormat,
+                                    imageType, nullptr);
                     break;
                 default:
                     break;
@@ -484,8 +498,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return created;
         }
 
-        Bool ProbeRenderbuffer(const MG_External::GLESFunctionsTable& gl, GLenum internalFormat,
-                               TextureInternalFormat logicalFormat, Bool multisample, Int samples) {
+        Bool ProbeRenderbuffer(const MG_External::GLESFunctionsTable& gl,
+                               GLenum internalFormat,
+                               TextureInternalFormat logicalFormat,
+                               Bool multisample,
+                               Int samples) {
             if (!gl.glGenRenderbuffers || !gl.glBindRenderbuffer || !gl.glDeleteRenderbuffers) {
                 return false;
             }
@@ -507,16 +524,17 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 gl.glRenderbufferStorage(GL_RENDERBUFFER, internalFormat, 1, 1);
             }
             const Bool created = CheckNoGLError(gl);
-            const Bool complete =
-                created && ProbeFramebufferCompletenessForRenderbuffer(gl, renderbuffer, logicalFormat);
+            const Bool complete = created && ProbeFramebufferCompletenessForRenderbuffer(gl, renderbuffer, logicalFormat);
             gl.glBindRenderbuffer(GL_RENDERBUFFER, static_cast<GLuint>(prevRenderbuffer));
             gl.glDeleteRenderbuffers(1, &renderbuffer);
             ClearGLErrors(gl);
             return complete;
         }
 
-        Vector<Int> ProbeRenderbufferSampleCounts(const MG_External::GLESFunctionsTable& gl, GLenum internalFormat,
-                                                  TextureInternalFormat logicalFormat, Int maxSamples) {
+        Vector<Int> ProbeRenderbufferSampleCounts(const MG_External::GLESFunctionsTable& gl,
+                                                  GLenum internalFormat,
+                                                  TextureInternalFormat logicalFormat,
+                                                  Int maxSamples) {
             Vector<Int> sampleCounts;
             for (Int samples = std::max(maxSamples, 1); samples > 1; samples >>= 1) {
                 if (ProbeRenderbuffer(gl, internalFormat, logicalFormat, true, samples)) {
@@ -553,60 +571,26 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
                 for (SizeT targetIndex = 0; targetIndex < kFormatCapabilityTextureTargetCount; ++targetIndex) {
                     const auto target = static_cast<TextureTarget>(targetIndex);
-                    // Colour-attachable targets need a colour-renderable fallback; the ordinary
-                    // fallback for a three-channel format is another three-channel one, which ES
-                    // accepts as a texture but never as an attachment. Recompute the fallback per
-                    // target so those formats get widened where the target demands it.
-                    const Flags<PixelFormatNormalizeOptionBit> renderTargetOptions =
-                        TextureImpl::GetRenderTargetNormalizeOptions(capabilities, targetIndex);
-                    // Multisample storage has no three-channel form on ES at all, so its widening
-                    // is unconditional and skips the native probe (which cannot succeed). Every
-                    // other target keeps the widening on the DRIVER branch, behind the native
-                    // probe: `shouldProbeFallback = !nativeCreated || !nativeRenderable` below is
-                    // what makes the substitution conditional on the driver actually refusing, so
-                    // a driver that does render to a three-channel image keeps allocating it byte
-                    // for byte. That is a per-format runtime answer, NOT a desktop-vs-device
-                    // split: llvmpipe renders to GL_RGB16F but refuses GL_RGB8_SNORM, GL_SRGB8,
-                    // GL_RGB32F and the RGB integer formats, so the CI driver widens those eight
-                    // too. Re-run the retrace fixtures and the glcts suites on any change here.
-                    const Bool widenUnconditionally = IsGLESProbeMultisampleTarget(target);
+                    // A multisample texture can only ever be rendered into, so its storage format
+                    // has to stay colour-renderable; the ordinary fallback for a three-channel
+                    // format is a three-channel one, which ES accepts as a texture but rejects as
+                    // multisample storage. Recompute the fallback per target so those formats get
+                    // widened here and nowhere else.
+                    Flags<PixelFormatNormalizeOptionBit> targetOptions;
+                    if (IsGLESProbeMultisampleTarget(target)) {
+                        targetOptions |= PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget;
+                        if (!capabilities.SupportsRenderSnorm || !capabilities.SupportsNorm16Texture) {
+                            targetOptions |= PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget;
+                        }
+                    }
                     GLESProbeFormatInfo fallbackInfo = outerFallbackInfo;
                     Bool hasForcedFallback = outerHasForcedFallback;
-                    if (renderTargetOptions) {
-                        // Folded into the forced options only when a forced fallback already
-                        // applies, so the render-target bits never *create* one: ANGLE's forced
-                        // GL_RGB8_SNORM -> GL_RGB16F is still three-channel and still needs
-                        // widening, but a non-ANGLE driver must not lose its native probe.
-                        const Flags<PixelFormatNormalizeOptionBit> forcedProbeOptions =
-                            (outerHasForcedFallback || widenUnconditionally) ? forcedOptions | renderTargetOptions
-                                                                             : forcedOptions;
-                        hasForcedFallback =
-                            BuildFallbackProbeFormatInfo(requestedInternalFormat, forcedProbeOptions, true,
-                                                         fallbackInfo);
+                    if (targetOptions) {
+                        hasForcedFallback = BuildFallbackProbeFormatInfo(
+                            requestedInternalFormat, forcedOptions | targetOptions, true, fallbackInfo);
                         if (!hasForcedFallback) {
-                            BuildFallbackProbeFormatInfo(requestedInternalFormat,
-                                                         driverOptions | renderTargetOptions, false, fallbackInfo);
-                        }
-                        // HONEST STATUS OF THE FORCED PATH. A forced fallback is only ever built
-                        // for ANGLE (GetForcedPixelFormatNormalizeOptions returns nothing for any
-                        // other renderer), and it SKIPS the native probe entirely - the widened
-                        // format is asserted rather than measured on this device. That assertion
-                        // is validated on exactly one configuration, the android-angle retrace
-                        // golden; it is NOT covered by the headless llvmpipe suites, which take
-                        // the driver branch below and prove nothing about ANGLE's answers. So log
-                        // the choice at INFO rather than the usual MGLOG_D caveat: on any other
-                        // ANGLE device the device report is the only evidence there is of which
-                        // storage format the image really got. Once per format on the ordinary 2D
-                        // target - repeating it for all ten targets would bury the report.
-                        if (hasForcedFallback && target == TextureTarget::Texture2D &&
-                            (MG_Util::TextureFormatProcessor::GetApplicablePixelFormatNormalizeOptions(
-                                 requestedInternalFormat, renderTargetOptions) &
-                             PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget)) {
-                            MGLOG_I("Three-channel widening (FORCED path, no native probe): %s stored as %s. "
-                                    "Reason: %s. Device-validated on the android-angle golden only.",
-                                    MG_Util::ConvertTextureInternalFormatToString(logicalFormat).c_str(),
-                                    ConvertFallbackInternalFormatToString(fallbackInfo.InternalFormat).c_str(),
-                                    fallbackInfo.Reason.c_str());
+                            BuildFallbackProbeFormatInfo(requestedInternalFormat, driverOptions | targetOptions,
+                                                         false, fallbackInfo);
                         }
                     }
 
@@ -639,9 +623,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
                             ProbeTexture(gl, probeTarget, fallbackInfo.InternalFormat, fallbackInfo.ImageFormat,
                                          fallbackInfo.ImageType, logicalFormat, &fallbackRenderable);
                         if (fallbackCreated) {
-                            if (AddCaveatFormatCaps(
-                                    cache, targetIndex, formatIndex,
-                                    BuildTextureCapsFromProbe(logicalFormat, target, fallbackRenderable))) {
+                            if (AddCaveatFormatCaps(cache, targetIndex, formatIndex,
+                                                    BuildTextureCapsFromProbe(logicalFormat, target,
+                                                                              fallbackRenderable))) {
                                 LogGLESFormatCaveat(logicalFormat, targetIndex, fallbackInfo);
                             }
                             if (IsGLESProbeMultisampleTarget(target)) {
@@ -652,26 +636,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
 
                 const SizeT renderbufferTargetIndex = GetRenderbufferFormatCapabilityTargetIndex();
-                // A renderbuffer exists only to be attached, so it needs the same three-channel
-                // widening the colour-attachable texture targets get - and on the same terms: the
-                // native storage is probed first, so a driver that renders to it keeps it.
-                const Flags<PixelFormatNormalizeOptionBit> renderbufferOptions =
-                    TextureImpl::GetRenderTargetNormalizeOptions(capabilities, renderbufferTargetIndex);
-                GLESProbeFormatInfo renderbufferFallbackInfo = outerFallbackInfo;
-                Bool renderbufferHasForcedFallback = outerHasForcedFallback;
-                if (renderbufferOptions) {
-                    const Flags<PixelFormatNormalizeOptionBit> forcedProbeOptions =
-                        outerHasForcedFallback ? forcedOptions | renderbufferOptions : forcedOptions;
-                    renderbufferHasForcedFallback = BuildFallbackProbeFormatInfo(
-                        requestedInternalFormat, forcedProbeOptions, true, renderbufferFallbackInfo);
-                    if (!renderbufferHasForcedFallback) {
-                        BuildFallbackProbeFormatInfo(requestedInternalFormat, driverOptions | renderbufferOptions,
-                                                     false, renderbufferFallbackInfo);
-                    }
-                }
-
-                Bool shouldProbeFallbackRenderbuffer = renderbufferHasForcedFallback;
-                if (!renderbufferHasForcedFallback) {
+                Bool shouldProbeFallbackRenderbuffer = outerHasForcedFallback;
+                if (!outerHasForcedFallback) {
                     const Bool nativeRenderbufferComplete =
                         ProbeRenderbuffer(gl, nativeInfo.InternalFormat, logicalFormat, false, 1);
                     if (nativeRenderbufferComplete) {
@@ -685,16 +651,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
                         shouldProbeFallbackRenderbuffer = true;
                     }
                 }
-                if (shouldProbeFallbackRenderbuffer && renderbufferFallbackInfo.InternalFormat != GL_UNKNOWN_MGL &&
-                    ProbeRenderbuffer(gl, renderbufferFallbackInfo.InternalFormat, logicalFormat, false, 1)) {
+                if (shouldProbeFallbackRenderbuffer && outerFallbackInfo.InternalFormat != GL_UNKNOWN_MGL &&
+                    ProbeRenderbuffer(gl, outerFallbackInfo.InternalFormat, logicalFormat, false, 1)) {
                     if (AddCaveatFormatCaps(cache, renderbufferTargetIndex, formatIndex,
                                             GetRenderbufferFeatureCaps(logicalFormat))) {
-                        LogGLESFormatCaveat(logicalFormat, renderbufferTargetIndex, renderbufferFallbackInfo);
+                        LogGLESFormatCaveat(logicalFormat, renderbufferTargetIndex, outerFallbackInfo);
                     }
                     const Int maxSamples =
-                        GetGLESFormatMaxSamples(capabilities, logicalFormat, renderbufferFallbackInfo.ImageFormat);
-                    cache.SampleCounts[renderbufferTargetIndex][formatIndex] = ProbeRenderbufferSampleCounts(
-                        gl, renderbufferFallbackInfo.InternalFormat, logicalFormat, maxSamples);
+                        GetGLESFormatMaxSamples(capabilities, logicalFormat, outerFallbackInfo.ImageFormat);
+                    cache.SampleCounts[renderbufferTargetIndex][formatIndex] =
+                        ProbeRenderbufferSampleCounts(gl, outerFallbackInfo.InternalFormat, logicalFormat, maxSamples);
                 }
             }
         }
@@ -710,7 +676,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 .ExtraVendor = Nullopt,              // Extra vendor
                 .RendererGLInfo =
                     {
-                        .TargetGLVersion = {4, 0, 0},   // GL target version
+                        .TargetGLVersion = {3, 3, 0},   // GL target version
                         .TargetGLSLVersion = {4, 6, 0}, // Target Shading Language Version
                         // Baseline advertisement (no timer queries / anisotropy yet); reconciled
                         // once the ES capabilities exist, see UpdateAdvertisedCapabilityExtensions.
@@ -741,7 +707,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
     } // namespace
 
     void PopulateFormatCapabilities(const MG_External::GLESFunctionsTable& gl,
-                                    const MG_External::GLESCapabilities& capabilities, FormatCapabilityCache& cache) {
+                                    const MG_External::GLESCapabilities& capabilities,
+                                    FormatCapabilityCache& cache) {
         PopulateFormatCapabilitiesImpl(gl, capabilities, cache);
     }
 
@@ -805,8 +772,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return false;
         }
 
-        if ((handle.Backend != WindowBackend::Android && handle.Backend != WindowBackend::X11 &&
-             handle.Backend != WindowBackend::MetalLayer && handle.Backend != WindowBackend::Win32) ||
+        if ((handle.Backend != WindowBackend::Android &&
+             handle.Backend != WindowBackend::X11 &&
+             handle.Backend != WindowBackend::MetalLayer &&
+             handle.Backend != WindowBackend::Win32) ||
             !handle.Handle) {
             MGLOG_E("DirectGLES backend only supports Android, X11, CAMetalLayer, and Win32 native windows");
             return false;
@@ -925,41 +894,27 @@ namespace MobileGL::MG_Backend::DirectGLES {
     }
 
     Vector<GLExtension> BuildAdvertisedExtensions(Bool timerQueriesSupported, Bool anisotropicFilteringSupported) {
-        Vector<GLExtension> extensions = {
-            V_OpenGL30, V_OpenGL31, V_OpenGL32, V_OpenGL33, V_OpenGL40, E_GL_ARB_draw_buffers_blend,
-            E_GL_ARB_compute_shader, E_GL_ARB_shader_storage_buffer_object, E_GL_ARB_shader_image_load_store,
-            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_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,
-            // Both are core from GL 3.2/3.3 on and implemented here for
-            // every advertised version, but an app targeting 3.0/3.1
-            // only reaches them through the extension string - the CTS
-            // picks a whole different shader for draw_buffers without
-            // explicit_attrib_location. DirectVulkan advertises both.
-            E_GL_ARB_explicit_attrib_location, E_GL_ARB_texture_multisample, E_GL_ARB_shader_image_size,
-            // Advertised with GL_NUM_PROGRAM_BINARY_FORMATS = 0, which the
-            // extension explicitly permits. It is also the only thing that
-            // exposes glProgramParameteri before GL 4.1.
-            E_GL_ARB_get_program_binary};
-        // GL_KHR_parallel_shader_compile is MobileGL's own capability, not the host ES
-        // driver's: the compiler threads are MobileGL's, and glCompileShader/glLinkProgram
-        // are serviced entirely inside the frontend. Whether the device driver advertises
-        // the string is irrelevant here (the POST reports it separately, for the day the
-        // driver-side link is what gets parallelised).
-        //
-        // Gated on the async flag deliberately, and this is the whole reason the gate
-        // exists. Advertising the string is the one part of asynchronous compilation that a
-        // recorded trace can never cover: Iris and Sodium change their SUBMISSION SCHEDULE
-        // the moment they see it - they enqueue whole pipeline batches and poll
-        // GL_COMPLETION_STATUS_KHR instead of compiling one program at a time - so
-        // MOBILEGL_ASYNC_SHADER_COMPILE=0 has to withdraw the application-visible behaviour
-        // change as well as the threading, or the kill switch would only be half a switch.
-        if (MG_Util::Async::AsyncShaderCompileEnabled()) {
-            extensions.push_back(E_GL_KHR_parallel_shader_compile);
-        }
+        Vector<GLExtension> extensions = {V_OpenGL30, V_OpenGL31, V_OpenGL32,
+                                          V_OpenGL33, E_GL_ARB_draw_buffers_blend, E_GL_ARB_compute_shader,
+                                          E_GL_ARB_shader_storage_buffer_object, E_GL_ARB_shader_image_load_store,
+                                          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_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,
+                                          // Both are core from GL 3.2/3.3 on and implemented here for
+                                          // every advertised version, but an app targeting 3.0/3.1
+                                          // only reaches them through the extension string - the CTS
+                                          // picks a whole different shader for draw_buffers without
+                                          // explicit_attrib_location. DirectVulkan advertises both.
+                                          E_GL_ARB_explicit_attrib_location, E_GL_ARB_texture_multisample,
+                                          E_GL_ARB_shader_image_size,
+                                          // Advertised with GL_NUM_PROGRAM_BINARY_FORMATS = 0, which the
+                                          // extension explicitly permits. It is also the only thing that
+                                          // exposes glProgramParameteri before GL 4.1.
+                                          E_GL_ARB_get_program_binary};
         // Only advertised when the device driver actually has usable timer queries
         // (GL_EXT_disjoint_timer_query plus its entry points) and the
         // MOBILEGL_DISABLE_TIMERQUERY escape hatch is off.
@@ -1020,6 +975,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
             funcsTable.GL.GetIntegeri_v = GetIntegeri_v;
             funcsTable.GL.GetInteger64i_v = GetInteger64i_v;
             funcsTable.GL.GetProgramiv = GetProgramiv;
+            funcsTable.GL.GetProgramInterfaceiv = GetProgramInterfaceiv;
+            funcsTable.GL.GetProgramResourceIndex = GetProgramResourceIndex;
+            funcsTable.GL.GetProgramResourceName = GetProgramResourceName;
+            funcsTable.GL.GetProgramResourceiv = GetProgramResourceiv;
+            funcsTable.GL.GetProgramResourceLocation = GetProgramResourceLocation;
+            funcsTable.GL.GetProgramResourceLocationIndex = GetProgramResourceLocationIndex;
             funcsTable.GL.ShaderStorageBlockBinding = ShaderStorageBlockBinding;
             funcsTable.GL.Clear = Clear;
             funcsTable.GL.ClearBufferfi = ClearBufferfi;
@@ -1027,8 +988,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             funcsTable.GL.ClearBufferuiv = ClearBufferuiv;
             funcsTable.GL.ClearBufferiv = ClearBufferiv;
             funcsTable.GL.ClearNamedFramebufferfv = ClearNamedFramebufferfv;
-            funcsTable.GL.ClearNamedFramebufferiv = ClearNamedFramebufferiv;
-            funcsTable.GL.ClearNamedFramebufferuiv = ClearNamedFramebufferuiv;
             funcsTable.GL.ClearNamedFramebufferfi = ClearNamedFramebufferfi;
             funcsTable.GL.BlitFramebuffer = BlitFramebuffer;
             funcsTable.GL.BlitNamedFramebuffer = BlitNamedFramebuffer;
@@ -1091,7 +1050,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
         return m_dynamicParameters;
     }
 
-    void BackendObject_DirectGLES::ApplyGLESCapabilitiesForTesting(const MG_External::GLESCapabilities& capabilities) {
+    void BackendObject_DirectGLES::ApplyGLESCapabilitiesForTesting(
+        const MG_External::GLESCapabilities& capabilities) {
         m_GLESCapabilities = capabilities;
         UpdateDynamicBackendParameters();
     }
@@ -1155,7 +1115,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
         m_dynamicParameters.TextureBufferOffsetAlignment = m_GLESCapabilities.TextureBufferOffsetAlignment;
         m_dynamicParameters.MaxUniformBufferBindings = m_GLESCapabilities.MaxUniformBufferBindings;
         m_dynamicParameters.MaxUniformBlockSize = m_GLESCapabilities.MaxUniformBlockSize;
-        const Int maxSupportedTextureUnits = static_cast<Int>(MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS);
+        const Int maxSupportedTextureUnits =
+            static_cast<Int>(MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS);
         m_dynamicParameters.MaxImageUnits =
             std::max(std::min(m_GLESCapabilities.MaxImageUnits, maxSupportedTextureUnits), 0);
         m_dynamicParameters.MaxCombinedImageUniforms = std::max(m_GLESCapabilities.MaxCombinedImageUniforms, 0);
@@ -1163,7 +1124,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return std::min({std::max(stageLimit, 0), m_dynamicParameters.MaxImageUnits,
                              m_dynamicParameters.MaxCombinedImageUniforms});
         };
-        m_dynamicParameters.MaxVertexImageUniforms = clampStageImageUniforms(m_GLESCapabilities.MaxVertexImageUniforms);
+        m_dynamicParameters.MaxVertexImageUniforms =
+            clampStageImageUniforms(m_GLESCapabilities.MaxVertexImageUniforms);
         m_dynamicParameters.MaxGeometryImageUniforms =
             clampStageImageUniforms(m_GLESCapabilities.MaxGeometryImageUniforms);
         m_dynamicParameters.MaxFragmentImageUniforms =
@@ -1172,31 +1134,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             clampStageImageUniforms(m_GLESCapabilities.MaxComputeImageUniforms);
         m_dynamicParameters.SupportsDistinctDepthStencilAttachments =
             ProbeDistinctDepthStencilAttachments(DirectGLES::g_GLESFuncs);
-        // SyncAttachmentObject routes a layered upload target to glFramebufferTextureLayer with the
-        // attachment's layer passed through, so this backend really does render to the layer it was
-        // given - provided the driver resolved the entry point at all.
-        // SyncAttachmentObject (Managers.cpp, the glFramebufferTextureLayer branch) routes exactly
-        // five upload targets to glFramebufferTextureLayer with the attachment's layer passed
-        // through, so this backend really does render to the layer it was given - provided the driver
-        // resolved the entry point at all. The cube map array is the one target that also needs
-        // ES-level support before it has any storage to attach.
-        m_dynamicParameters.PerLayerFramebufferAttachmentTargets = 0;
-        if (DirectGLES::g_GLESFuncs.glFramebufferTextureLayer != nullptr) {
-            using DynParams = MG_Backend::DynamicBackendParameters;
-            m_dynamicParameters.PerLayerFramebufferAttachmentTargets |=
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture3D) |
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture1DArray) |
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture2DArray) |
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture2DMultisampleArray);
-            if (m_GLESCapabilities.SupportsTextureCubeMapArray) {
-                m_dynamicParameters.PerLayerFramebufferAttachmentTargets |=
-                    DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::TextureCubeMapArray);
-            }
-        }
-        // Not a driver question and never will be: OpenGL ES has no double-precision vertex format
-        // and ESSL has no fp64 type to consume one with, so a 64-bit vertex attribute has nowhere to
-        // land on this backend regardless of what the driver underneath happens to support.
-        m_dynamicParameters.SupportsFloat64VertexAttributes = false;
         m_dynamicParameters.MaxDrawBuffers = m_GLESCapabilities.MaxDrawBuffers;
         m_dynamicParameters.MaxColorAttachments = m_GLESCapabilities.MaxColorAttachments;
         m_dynamicParameters.MaxClipDistances = m_GLESCapabilities.MaxClipDistances;
@@ -1218,7 +1155,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
             const Float requiredMaxOffset =
                 0.5f - std::ldexp(1.0f, -m_GLESCapabilities.FragmentInterpolationOffsetBits);
             if (m_GLESCapabilities.MaxFragmentInterpolationOffset >= requiredMaxOffset) {
-                m_dynamicParameters.MaxFragmentInterpolationOffset = m_GLESCapabilities.MaxFragmentInterpolationOffset;
+                m_dynamicParameters.MaxFragmentInterpolationOffset =
+                    m_GLESCapabilities.MaxFragmentInterpolationOffset;
                 m_dynamicParameters.FragmentInterpolationOffsetBits =
                     m_GLESCapabilities.FragmentInterpolationOffsetBits;
             }
@@ -1227,8 +1165,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
             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; });
+            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;

MobileGL/MG_Backend/DirectGLES/DirectGLES.h

@@ -59,10 +59,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                  GLenum buffer, GLint drawbuffer, const GLfloat* value);
     void ClearNamedFramebufferfi(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
                                  GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void ClearNamedFramebufferiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                 GLenum buffer, GLint drawbuffer, const GLint* value);
-    void ClearNamedFramebufferuiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                  GLenum buffer, GLint drawbuffer, const GLuint* value);
     void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1,
                          GLint dstY1, GLbitfield mask, GLenum filter);
     void BlitNamedFramebuffer(const SharedPtr<MG_State::GLState::FramebufferObject>& readFramebuffer,
@@ -92,7 +88,15 @@ namespace MobileGL::MG_Backend::DirectGLES {
     void GetIntegeri_v(GLenum target, GLuint index, GLint* data);
     void GetInteger64i_v(GLenum target, GLuint index, GLint64* data);
     void GetProgramiv(GLuint program, GLenum pname, GLint* params);
-    void ShaderStorageBlockBinding(GLuint program, const GLchar* storageBlockName, GLuint storageBlockBinding);
+    void GetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint* params);
+    GLuint GetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar* name);
+    void GetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length,
+                                GLchar* name);
+    void GetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount,
+                              const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params);
+    GLint GetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar* name);
+    GLint GetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar* name);
+    void ShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
     Bool InitWindowSurface(NativeWindowType window);
     Bool InitPbufferSurface(EGLint width, EGLint height);
     Bool MakeCurrent();
@@ -152,11 +156,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
     // A buffer retired during frame N is safe to recycle once CompletedFrameSerial() >= N.
     Uint64 CurrentFrameSerial();
     Uint64 CompletedFrameSerial();
-    // Block (up to timeoutNs) until the given frame serial provably retired on the
-    // GPU, using the per-frame fence ring. False when no usable fence covers the
-    // serial (fence-less context, foreign thread, or the slot was recycled);
-    // completion state is untouched in that case.
-    Bool WaitForFrameSerialCompleted(Uint64 serial, Uint64 timeoutNs);
     // Applies (or defers until the window surface exists) the app-requested
     // eglSwapInterval on the native EGL surface.
     void SetSwapInterval(Int interval);
@@ -174,11 +173,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
     namespace XfbImpl {
         Bool AreTransformFeedbacksSupported();
-        // True while a capture span is open on the current transform feedback object
-        // (frontend Begin seen and not paused), whether or not the deferred driver-side
-        // Begin has been issued yet. Draw paths that would restructure the primitive
-        // stream, or that need to dispatch compute mid-draw, decline while it is set.
-        Bool IsCaptureSpanOpen();
         void BeginTransformFeedback(GLenum primitiveMode);
         void EndTransformFeedback();
         void PauseTransformFeedback();
@@ -188,26 +182,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         void OnBackendContextDestroyed();
     } // namespace XfbImpl
 
-    namespace RenderStateImpl {
-        // Pushes the frontend's render-state block to the ES driver, diffed against what was
-        // last pushed.
-        //
-        // `forColorClear` names the CALLER, and the only thing it changes is the colour write
-        // mask handed to the driver. A draw into a colour attachment the backend widened from
-        // three channels to four gets that buffer's alpha channel masked OFF, so nothing can
-        // move the stored alpha away from the 1.0 the application's three-channel format
-        // implies (see FramebufferImpl::g_alphaWidenedDrawBufferMask). A CLEAR is how that 1.0
-        // gets there in the first place, so it must be allowed to write alpha - hence the flag
-        // rather than an unconditional doctoring. It is part of the sync memo, so a clear
-        // followed by a draw re-pushes the mask instead of early-outing on an unchanged
-        // frontend version.
-        //
-        // The application's own colour mask is never modified: glGet(GL_COLOR_WRITEMASK)
-        // answers from the frontend state, which this function only reads.
-        void SyncRenderState(Bool forColorClear = false);
-        void InvalidateSyncedRenderState();
-    } // namespace RenderStateImpl
-
     extern MG_External::EGLFunctionsTable g_EGLFuncs;
     extern MG_External::GLESFunctionsTable g_GLESFuncs;
     extern MG_External::GLESCapabilities g_GLESCapabilities;

MobileGL/MG_Backend/DirectGLES/Managers.h

@@ -21,126 +21,45 @@ namespace MobileGL::MG_Backend::DirectGLES {
     String EmulateBaseInstanceInVertexShader(String source, GLenum shaderType);
     String PromoteDrawParameterGlobalsToUniforms(String source, GLenum shaderType);
 
-    // True once the process has entered exit(): past that point the EGL library and
-    // the driver may already be unloaded, so a backend twin's destructor must not
-    // call into g_GLESFuncs (the observed crash is a jump through an unmapped driver
-    // pointer from __run_exit_handlers) nor touch statics in other TUs (cross-TU
-    // destruction order is unspecified). Deliberate leak: the process is exiting and
-    // the driver reclaims GPU objects. The flag is set by a std::atexit handler that
-    // EnsureProcessTeardownSentinel() registers lazily on first registry use - by
-    // then every static everywhere has finished constructing, so this handler is
-    // guaranteed to run BEFORE any static destructor (atexit is LIFO). A destructor
-    // hook on the registry itself was tried first and is WRONG: tests and cache
-    // resets destroy temporary registry instances mid-run, which would latch the
-    // flag while the process is very much alive.
-    Bool InProcessTeardown();
-    void EnsureProcessTeardownSentinel();
-
-    // Which optional pieces of state a draw needs synchronized before it is issued.
-    // Index/indirect buffer syncs and the instancing-related work are skipped for
-    // draws that provably cannot read them.
-    enum class DrawSyncBit : Uint32 {
-        None = 0,
-        IndexBuffer = 1 << 0,
-        IndirectBuffer = 1 << 1,
-        Instancing = 1 << 2
-    };
-    // Deliberately the shared Flags<> rather than hand-written operators for this enum:
-    // a namespace-local operator| here would hide MobileGL::operator|(Bit, Bit) from
-    // every other scoped-enum flag set used inside this namespace.
-    using DrawSyncFlags = Flags<DrawSyncBit>;
-
-    // The GL-defined indirect command layouts, byte-identical to what the driver reads
-    // out of a GL_DRAW_INDIRECT_BUFFER. Also the staging layout the multi-draw emulation
-    // synthesizes commands into.
-    struct DrawElementsIndirectCommand {
-        Uint32 count = 0;
-        Uint32 instanceCount = 0;
-        Uint32 firstIndex = 0;
-        Int32 baseVertex = 0;
-        Uint32 baseInstance = 0;
-    };
-
-    struct DrawArraysIndirectCommand {
-        Uint32 count = 0;
-        Uint32 instanceCount = 0;
-        Uint32 first = 0;
-        Uint32 baseInstance = 0;
-    };
-
-    // Brings the whole draw-relevant frontend state onto the native ES context and binds
-    // the program; every GL draw entry point calls it exactly once before issuing draws.
-    void PrepareForDraw(DrawSyncFlags syncBits);
-    // GLES core supports only GL_PRIMITIVE_RESTART_FIXED_INDEX. Throws when the app enabled
-    // the arbitrary GL_PRIMITIVE_RESTART with a non-fixed index for this index type.
-    void CheckPrimitiveRestartSupported(GLenum indexType);
-    // Feed the current program's gl_BaseInstance / gl_DrawID emulation uniforms. Both are
-    // no-ops when the program does not read the corresponding builtin.
-    void SetCurrentBaseInstance(Uint32 baseInstance);
-    void SetCurrentDrawID(Uint32 drawId);
-    // True when the current program actually reads gl_DrawID, i.e. when a batched
-    // (single driver call) multi-draw tier would have to feed it one value for the whole
-    // batch and would therefore be wrong.
-    Bool CurrentProgramReadsDrawID();
-
     template <typename StateObject, typename BackendObject>
     class StateBackendObjectRegistry {
     public:
-
         using StatePtr = SharedPtr<StateObject>;
         using StateWeakPtr = std::weak_ptr<StateObject>;
         using BackendPtr = SharedPtr<BackendObject>;
-
-        // The backend twin and the weak reference that decides whether the raw key still
-        // names the state object the twin was built for. Both live in one entry: a
-        // separate liveness map answered nothing the backend probe had not already found
-        // and cost a second hash lookup on every Find, which the draw path runs ~10 times.
-        struct Entry {
-            BackendPtr backend;
-            StateWeakPtr stateRef;
-        };
-        using BackendMap = UnorderedMap<StateObject*, Entry>;
+        using BackendMap = UnorderedMap<StateObject*, BackendPtr>;
+        using StateRefMap = UnorderedMap<StateObject*, StateWeakPtr>;
         using iterator = typename BackendMap::iterator;
         using const_iterator = typename BackendMap::const_iterator;
 
         BackendPtr& GetOrCreate(const StatePtr& stateObj) {
             MOBILEGL_ASSERT(stateObj != nullptr, "State object must not be null");
 
-            // Twin creation is the moment a driver-owned id starts needing a guarded
-            // destructor; cold path, so the once-guard costs nothing per draw.
-            EnsureProcessTeardownSentinel();
-            auto& entry = m_entries[stateObj.get()];
-            if (entry.stateRef.expired()) {
-                // The previous owner of this address is gone and the allocator handed it
-                // to a new object: its twin describes ids the new state object never made.
-                entry.backend.reset();
+            auto* key = stateObj.get();
+            auto trackedStateIt = m_stateRefs.find(key);
+            if (trackedStateIt != m_stateRefs.end() && trackedStateIt->second.expired()) {
+                EraseByKey(key);
             }
-            entry.stateRef = stateObj;
-            return entry.backend;
+            m_stateRefs[key] = stateObj;
+            return m_backendObjects[key];
         }
 
-        // Null when no live state object owns this key. The result points into the map, so
-        // it stays valid only until the next GetOrCreate/Find/CollectGarbage on this registry.
-        BackendPtr* Find(StateObject* stateObj) {
-            const auto entryIt = m_entries.find(stateObj);
-            if (entryIt == m_entries.end()) {
-                return nullptr;
+        iterator find(StateObject* stateObj) {
+            if (!IsAlive(stateObj)) {
+                EraseByKey(stateObj);
+                return m_backendObjects.end();
             }
-            if (entryIt->second.stateRef.expired()) {
-                m_entries.erase(entryIt);
-                return nullptr;
-            }
-            return &entryIt->second.backend;
+            return m_backendObjects.find(stateObj);
         }
 
-        const BackendPtr* Find(StateObject* stateObj) const {
-            return const_cast<StateBackendObjectRegistry*>(this)->Find(stateObj);
+        const_iterator find(StateObject* stateObj) const {
+            return const_cast<StateBackendObjectRegistry*>(this)->find(stateObj);
         }
 
-        iterator begin() { return m_entries.begin(); }
-        const_iterator begin() const { return m_entries.begin(); }
-        iterator end() { return m_entries.end(); }
-        const_iterator end() const { return m_entries.end(); }
+        iterator begin() { return m_backendObjects.begin(); }
+        const_iterator begin() const { return m_backendObjects.begin(); }
+        iterator end() { return m_backendObjects.end(); }
+        const_iterator end() const { return m_backendObjects.end(); }
 
         void CollectGarbageIfNeeded() {
             ++m_gcTick;
@@ -154,6 +73,19 @@ namespace MobileGL::MG_Backend::DirectGLES {
         void CollectGarbageNow() { CollectGarbage(); }
 
     private:
+        bool IsAlive(StateObject* stateObj) const {
+            const auto trackedStateIt = m_stateRefs.find(stateObj);
+            if (trackedStateIt == m_stateRefs.end()) {
+                return false;
+            }
+            return !trackedStateIt->second.expired();
+        }
+
+        void EraseByKey(StateObject* stateObj) {
+            m_stateRefs.erase(stateObj);
+            m_backendObjects.erase(stateObj);
+        }
+
         void CollectGarbage() {
             if (m_isCollecting) {
                 return;
@@ -162,15 +94,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
             m_isCollecting = true;
 
             Vector<StateObject*> staleKeys;
-            staleKeys.reserve(m_entries.size());
-            for (const auto& [stateKey, entry] : m_entries) {
-                if (entry.stateRef.expired()) {
+            staleKeys.reserve(m_stateRefs.size());
+            for (const auto& [stateKey, stateWeakRef] : m_stateRefs) {
+                if (stateWeakRef.expired()) {
                     staleKeys.push_back(stateKey);
                 }
             }
 
             for (auto* stateKey : staleKeys) {
-                m_entries.erase(stateKey);
+                m_stateRefs.erase(stateKey);
+                m_backendObjects.erase(stateKey);
             }
 
             m_isCollecting = false;
@@ -178,7 +111,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
     private:
         static constexpr Uint32 kGCInterval = 1024;
-        BackendMap m_entries;
+        StateRefMap m_stateRefs;
+        BackendMap m_backendObjects;
         Uint32 m_gcTick = 0;
         Bool m_isCollecting = false;
     };
@@ -186,43 +120,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
     namespace BufferImpl {
         const GLenum TempBufferTarget = GL_ARRAY_BUFFER;
 
-        // --- Buffer-mutation epoch -------------------------------------------------
-        // Manager-wide monotonic counter: it moves whenever ANY buffer resource may
-        // have gone from draw-clean to dirty. Draw-path memos read it once per pass
-        // (CurrentBufferMutationEpoch, acquire), re-run their IsBufferDrawClean
-        // probes only when it moved, and stamp the PRE-pass value after a pass in
-        // which every probe came up clean - so a concurrent bump lands strictly
-        // after the stamped value and forces a re-probe on the next pass no matter
-        // how the probe interleaved with the mutation. Conservative-correct: a bump
-        // never skips work, it only re-runs the probes once.
-        //
-        // Every clean->dirty transition path bumps it (BumpBufferMutationEpoch,
-        // release, AFTER the mutation lands so an acquire reader that still sees
-        // the old epoch cannot have missed the mutation):
-        //   * the frontend BufferBackendOps table - Respecify, SubData,
-        //     FlushMappedRange, AcquirePersistentMap, ReadbackFromGpu, OnDestroy -
-        //     which every frontend change-serial bump and every pending-range
-        //     queueing reaches while ops are registered (upload, orphan/respecify,
-        //     map flush/unmap writeback, persistent-map adoption, delete/pooling);
-        //   * backend-initiated shadow writebacks that bump the frontend change
-        //     serial without an op: transform-feedback capture readback
-        //     (XfbImpl::ReadbackCapturedRanges and the scatter path) and every
-        //     pack-PBO WritebackFromBackend site (glReadPixels/glGetTexImage);
-        //   * RegisterBufferBackendOps/UnregisterBufferBackendOps - while ops are
-        //     unregistered, frontend writes advance serials silently, so both edges
-        //     of that window re-open every memo;
-        //   * OnBackendContextDestroyed - the buffer context generation moved, so
-        //     every previously clean resource is invalid.
-        // NOT bumped (cleanliness provably unchanged): MarkGpuWritten (the backend
-        // copy is authoritative; IsBufferDrawClean does not consult it),
-        // NotifyContentWrite on a GPU-resident buffer (persistent-mapped resources
-        // are clean by construction), and EnsureBufferResource itself (it only
-        // repairs toward clean). A non-persistent map (draws on it are GL errors
-        // the frontend rejects) sets IsMapped without an op; persistent maps reach
-        // AcquirePersistentMap or (FLUSH_EXPLICIT) publish only via FlushMappedRange.
-        Uint64 CurrentBufferMutationEpoch();
-        void BumpBufferMutationEpoch();
-
         // The DirectGLES storage behind one frontend buffer. Owned (refcounted) by
         // the frontend BufferObject; immediate BufferBackendOps keep it current, so
         // draw-time "sync" reduces to ensuring the storage exists.
@@ -248,12 +145,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             Bool pendingRespecify = false;
             VecRange1D pendingRanges;
             std::mutex pendingMutex;
-            // Buffer-mutation epoch (see CurrentBufferMutationEpoch) at which this
-            // resource last probed IsBufferDrawClean == true, 0 = never (epochs start
-            // at 1). Written only on the draw thread; per-draw resource consumers
-            // (the UBO binding walk) skip the probe while their pre-pass epoch read
-            // matches, exactly like the per-VAO memo stamps.
-            Uint64 drawCleanEpoch = 0;
             // Zero-copy coherent persistent map (EXT_buffer_storage): the GL store is
             // immutable, persistently+coherently mapped, and persistentPtr is what the app
             // (and the frontend PipeResource) write into directly. While set, draw-time
@@ -279,17 +170,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         GLESBufferResource* EnsureBufferResource(const SharedPtr<MG_State::GLState::BufferObject>& bufferObject);
         // Existing resource or nullptr; performs no GL calls.
         GLESBufferResource* GetBufferResource(MG_State::GLState::BufferObject* bufferObject);
-        // True when EnsureBufferResource(frontend) would provably fall straight through
-        // every branch and do no work — i.e. `resource` is still the frontend's own
-        // resource, its id belongs to the live ES context, and either it is the
-        // zero-copy coherent persistent store (draw-time sync is a no-op by design) or
-        // the storage is initialized at the right size with no pending ops and a synced
-        // change serial while the buffer is not mapped (an active map may owe a
-        // per-draw persistent-range push, so it always takes the full path).
-        // `frontend` must be non-null and alive; the caller guarantees that by holding
-        // (or shadowing something that holds) a SharedPtr to it. Enables the per-VAO
-        // resolved-buffers memo to skip EnsureBufferResource on clean static buffers.
-        Bool IsBufferDrawClean(const MG_State::GLState::BufferObject* frontend, const GLESBufferResource* resource);
 
         // Deletes GL buffers whose owning frontend objects died (possibly on a
         // thread without a current ES context). Called from draw-time sync.
@@ -375,85 +255,17 @@ namespace MobileGL::MG_Backend::DirectGLES {
             Uint GetBackendVertexArrayId() const { return m_backendVAOId; }
             void Bind() const;
 
-            // Draw-path memo of SyncNeccessaryBuffers' attribute walk for this VAO: the
-            // distinct enabled-attribute buffers (deduped) and the index buffer, resolved
-            // to their backend resources once. Valid while the VAO's config version is
-            // unchanged — every attach/enable/disable/format mutation bumps it (the same
-            // invariant SyncToBackend's gate already leans on), and the VAO's attribute
-            // SharedPtrs pin each memoed frontend buffer for exactly that long, so the raw
-            // pointers cannot dangle on a hit. Per-buffer cleanliness is NOT memoed here:
-            // each hit re-checks IsBufferDrawClean (resource identity, context generation,
-            // pending ops, change serial) and falls back to EnsureBufferResource for just
-            // the dirty entries via their attribute index. The IBO entry is keyed on the
-            // slot's bound-object identity instead (its slot version is a wrapping Uint16
-            // and is not covered by the config version).
-            struct ResolvedDrawBuffers {
-                struct Entry {
-                    MG_State::GLState::BufferObject* frontend = nullptr;
-                    BufferImpl::GLESBufferResource* resource = nullptr;
-                    Uint8 attribIndex = 0;
-                };
-                Bool valid = false;
-                Uint32 configVersion = 0;
-                Uint count = 0;
-                Array<Entry, MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS> entries;
-                MG_State::GLState::BufferObject* iboFrontend = nullptr;
-                BufferImpl::GLESBufferResource* iboResource = nullptr;
-                // Buffer-mutation epoch (BufferImpl::CurrentBufferMutationEpoch) at which
-                // the LAST probe pass found every entry / the IBO clean; 0 = not stamped
-                // (epochs start at 1). While a stamp matches the pre-pass epoch read, the
-                // probes are skipped outright: any path that can dirty ANY buffer bumps
-                // the epoch (the exhaustive site list lives at the epoch declaration).
-                // The IBO stamp is only trusted together with the bound-object identity
-                // compare - the VAO's index slot can rebind with no epoch or config move.
-                Uint64 vboCleanEpoch = 0;
-                Uint64 iboCleanEpoch = 0;
-            };
-            ResolvedDrawBuffers& GetResolvedDrawBuffersMemo() { return m_resolvedDrawBuffers; }
-
-            // Memo for SyncCurrentVertexAttributeValues: which of a program's ACTIVE
-            // attribute locations lack an enabled array in this VAO (those read the
-            // context's current generic value instead of a buffer). Keyed on the VAO
-            // config version (enable/disable bumps it) and the program's active-location
-            // mask. Hosted per twin — the former function-static single entry missed on
-            // every draw once the app cycled VAOs, re-reading the cold attribute slots.
-            struct PendingAttribValueMask {
-                Bool valid = false;
-                Uint32 configVersion = 0;
-                Uint32 activeMask = 0;
-                Uint32 pendingMask = 0;
-            };
-            PendingAttribValueMask& GetPendingAttribValueMaskMemo() { return m_pendingAttribValueMask; }
-
         private:
-            ResolvedDrawBuffers m_resolvedDrawBuffers;
-            PendingAttribValueMask m_pendingAttribValueMask;
             Uint m_backendVAOId = 0;
             Array<Uint, MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS> m_clientAttributeBufferIds;
             Bool m_isInitialized = false;
             Uint16 m_syncedIndexBufferVersion = 0;
-            // Aggregate gate over the per-attribute walk below: the frontend bumps its config
-            // version on every per-attribute version bump (the three Bump*Version functions are
-            // its only writers), so an unchanged config version proves every per-attribute
-            // compare in SyncToBackend would come up clean. The index-buffer slot has its own
-            // version and is NOT covered. The Bool (not a sentinel value) marks "never synced".
-            Bool m_hasSyncedConfigVersion = false;
-            Uint32 m_syncedConfigVersion = 0;
             Array<MG_State::GLState::VertexAttributeVersion, MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS>
                 m_syncedAttributeVersions;
         };
 
         extern StateBackendObjectRegistry<MG_State::GLState::VertexArrayObject, BackendVertexArrayObject>
             g_backendVertexArrayObjects;
-
-        // Shadowed glBindVertexArray: every backend VAO bind goes through here so a
-        // draw's second bind of the same VAO (SyncToBackend, then PrepareForDraw's
-        // re-bind) reaches the driver once. Invalidate whenever the ES context is
-        // replaced - ids restart and the resting binding is 0 again.
-        void BindBackendVAOId(Uint id);
-        void InvalidateVAOBindingCache();
-        // ES resets the binding to 0 when the currently bound VAO is deleted.
-        void NoteVAOIdDeleted(Uint id);
     } // namespace VertexArrayImpl
 
     namespace TextureImpl {
@@ -515,25 +327,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return target == TextureTarget::Texture3D || target == TextureTarget::TextureCubeMap;
         }
 
-        // Components per texel the frontend format's client data carries, for the three-channel
-        // formats that can be widened to a four-channel colour-renderable target; 0 for everything
-        // else. See PrepareChannelWidenedUpload.
-        Uint GetWidenableClientComponentCount(TextureInternalFormat format);
-
-        // True when a widenable format's components are integer rather than normalized, which is
-        // what decides the synthetic alpha's value: GL_RGB8I and GL_RGB8_SNORM are both uploaded
-        // as GL_BYTE, but their 1.0 is 1 and 0x7F respectively.
-        Bool IsIntegerWidenableFormat(TextureInternalFormat format);
-
-        // Repacks three-component client data as four components with an alpha of 1.0 in
-        // `uploadType`, for a format the backend widened to keep a colour attachment renderable.
-        // Returns `data` untouched when no widening applies. Pure CPU and context-free so a unit
-        // test can exercise the exact packing the driver is handed; `widenedData` is the caller's
-        // scratch buffer and has to outlive the returned pointer.
-        const void* PrepareChannelWidenedUpload(Uint componentCount, const IntVec3& texelSize, const void* data,
-                                                SizeT byteSize, GLenum uploadType, Vector<Uint8>& widenedData,
-                                                Bool integerData = false);
-
         struct StateTextureBasicInfo { // Used for tracking texture state changes
             TextureInternalFormat internalFormat = TextureInternalFormat::Unknown;
             SizeT width = 0;
@@ -571,38 +364,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             void Bind(GLenum target, Uint unit = TempTextureUnit);
             Uint GetBackendTextureId() const;
 
-            // Aggregate first-level clean gate for the per-draw trio
-            // SyncTextureParamsToBackend + SyncBuiltinSamplerToBackend +
-            // SyncMipmapsToBackend: EXACTLY the conjunction of their own early-outs
-            // (params version == synced params version; builtin-sampler version ==
-            // synced sampler version; and SyncMipmapsToBackend's cheap gate - stamped
-            // trio + content version + Mipmap storage). True means each of the three
-            // would provably return without work, so the caller may skip the calls;
-            // false only falls through to the three calls, whose own gates re-decide
-            // individually - this gate must never be MORE permissive than they are.
-            // `contextId`/`samplingGeneration` are the frontend context's current
-            // values, hoisted by the caller so a per-draw list walk reads them once
-            // instead of per texture. `t` must be the live frontend texture.
-            Bool IsDrawSyncClean(const MG_State::GLState::ITextureObject* t, Uint64 contextId,
-                                 Uint64 samplingGeneration) const {
-                if (!m_isInitialized || m_syncedShapeContextId == 0 || m_syncedShapeContextId != contextId ||
-                    m_syncedShapeGeneration != samplingGeneration) {
-                    return false;
-                }
-                const Uint16 paramsVersion = t->GetTextureParamsVersion();
-                if (m_syncedShapeParamsVersion != paramsVersion || m_syncedTextureParamsVersion != paramsVersion) {
-                    return false;
-                }
-                if (m_syncedContentVersion == 0 || m_syncedContentVersion != t->GetContentVersion()) {
-                    return false;
-                }
-                const auto& samplerObject = t->GetSamplerObject();
-                if (!samplerObject || m_syncedSamplerVersion != samplerObject->GetVersion()) {
-                    return false;
-                }
-                return t->GetStorageType() == TextureStorageType::Mipmap;
-            }
-
         private:
             void RecreateBackendTexture();
 
@@ -614,25 +375,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             Bool m_imageBindableStorageRequired = false;
             Bool m_backendStorageImmutable = false;
             StateTextureBasicInfo m_prevTextureInfo;
-            // Frontend content version at the last completed mipmap sync. The per-draw
-            // clean probe compares this before rebuilding shape info and scanning
-            // per-level dirty flags; 0 never matches a real version (they start at 1).
-            Uint64 m_syncedContentVersion = 0;
-            // First-level clean gate for SyncMipmapsToBackend, checked before even the
-            // IsComplete()/shape-probe walk. Valid only as a trio with the content and
-            // texture-params versions: the context's sampling-resolution generation moves on
-            // EVERY texture-shape mutation (BumpShapeVersion is the only writer of shape and
-            // unconditionally bumps it), the content version on every CPU pixel mutation, and
-            // the params version covers SetSamples/SetFixedSampleLocations, which bump neither
-            // of the other two but feed the shape probe. The context id pins the generation to
-            // the context that produced it - generations restart at 0 with a new context, and a
-            // texture is owned by exactly one context (share groups are not implemented), so a
-            // mutation can never happen under a context this key does not name. 0 = never
-            // stamped (real context ids start at 1). Backend-side invalidation rides on
-            // m_isInitialized: RequireImageBindableStorage and RecreateBackendTexture clear it.
-            Uint64 m_syncedShapeContextId = 0;
-            Uint64 m_syncedShapeGeneration = 0;
-            Uint16 m_syncedShapeParamsVersion = 0;
             SamplerParameters m_cacheSamplerParameters;
             UintVec2 m_cacheLodRange = {0, 1000};
             FloatVec4 m_cacheBorderColor = {0.0f, 0.0f, 0.0f, 0.0f};
@@ -649,10 +391,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         SharedPtr<BackendTextureObject>& SyncTextureObjectToBackend(
             const SharedPtr<MG_State::GLState::ITextureObject>& textureObject,
             Bool imageBindableStorageRequired = false);
-        // Brings every texture the next draw reads - the touched units' bindings and the draw
-        // FBO's texture attachments - onto the backend, through the two borrowed-pair memos
-        // documented at their definitions. Declared here so tests can drive those memos directly.
-        void SyncNeccessaryTextures();
         extern Array<Array<BackendTextureObject*, (SizeT)TextureTarget::TextureTargetCount>,
                      MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS>
             g_boundTexturesCache;
@@ -695,28 +433,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
                this array could be provided as data directly to ES `glDrawBuffers` function
              */
             GLenum m_backendDrawBuffers[MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS] = {GL_NONE};
-
-            static constexpr Uint MAX_COLOR_ATTACHMENT_SLOTS =
-                static_cast<Uint>(FramebufferAttachmentType::Color31) -
-                static_cast<Uint>(FramebufferAttachmentType::Color0) + 1;
-            /* Where each frontend GL_COLOR_ATTACHMENTn image physically lives in the backend ES
-               framebuffer, as a GL_COLOR_ATTACHMENTm enum. ES only accepts glDrawBuffers bufs[s] ==
-               GL_COLOR_ATTACHMENTs, so a GL draw-buffer slot s naming attachment a forces a's image
-               under backend slot s. This table is the single owner of that decision and is kept a
-               PERMUTATION of the backend colour slots: every other attachment keeps its identity
-               slot when that slot survived, and is parked on the lowest free slot when it did not.
-               Deriving the point per-query from the draw-buffer array instead handed the identity
-               point to any attachment that was not a draw buffer - i.e. exactly the point a
-               relocated draw buffer had just taken over. The permutation is only true of the
-               PHYSICAL framebuffer because the attachment loop detaches a point whose frontend
-               owner is empty; do not remove that detach. */
-            GLenum m_backendColorSlots[MAX_COLOR_ATTACHMENT_SLOTS] = {GL_NONE};
-            /* Rebuild m_backendColorSlots from the frontend draw-buffer array. Returns true when any
-               attachment moved, i.e. when the physical attachments and the memoised read buffer have
-               to be re-applied. */
-            Bool RecomputeBackendColorSlots(
-                const MG_State::GLState::FramebufferObject::FramebufferAttachmentArray& stateDrawBuffers);
-
             FramebufferAttachmentType m_frontendReadBuffer = FramebufferAttachmentType::Color0;
             GLenum m_backendReadBuffer = GL_COLOR_ATTACHMENT0;
 
@@ -733,81 +449,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
         // has to apply the clamp itself.
         Bool IsFixedPointFallbackReadAttachment();
 
-        // True when the read buffer names a three-channel attachment the backend actually stores
-        // in a four-channel format (the colour-renderable widening). A format without alpha reads
-        // back as 1.0, so the readback path has to overwrite the alpha the draw left behind -
-        // unconditionally, since this is the format's own semantics rather than the
-        // GL_CLAMP_READ_COLOR rule the clamp above implements.
-        Bool IsAlphaWidenedFallbackReadAttachment();
-
-        // True when this attachment's storage carries an alpha channel its frontend format does
-        // not (the three-channel colour-renderable widening).
-        Bool IsAlphaWidenedColorAttachment(const MG_State::GLState::FramebufferAttachmentObject& attachmentObject);
-
-        // Bit i set = DRAW BUFFER i of `fbo` resolves to a colour attachment the backend widened
-        // from three channels to four. Indexed by draw-buffer slot, not by attachment point,
-        // because that is what glColorMaski / glClearBufferfv address.
-        Uint32 ComputeAlphaWidenedDrawBufferMask(const MG_State::GLState::FramebufferObject& fbo);
-
-        // The same mask for whatever is currently bound to GL_DRAW_FRAMEBUFFER, recomputed by
-        // SyncCurrentFBO (BackendFramebufferObject::SyncToBackend for the DRAW target, and reset
-        // to 0 on the default framebuffer). Read by the draw/clear state sync, so it is only
-        // trustworthy after SyncCurrentFBO has run in the same entry point.
-        //
-        // WHY IT EXISTS (the dst-alpha discipline). A widened attachment has a real alpha channel
-        // the application's format does not, and GL says a missing channel reads as 1.0. Readback
-        // can paper over that (ForceWideReadAlphaToOne), but GL_DST_ALPHA /
-        // GL_ONE_MINUS_DST_ALPHA blending and glBlitFramebuffer read the STORED alpha inside the
-        // driver where no interception is possible. So the stored alpha is kept at 1.0 instead:
-        // a clear touching a widened buffer writes alpha 1.0, and every draw into it has its
-        // alpha write mask forced off, so nothing can ever move it again. The application's own
-        // colour mask is untouched - glGet(GL_COLOR_WRITEMASK) still reports what it set.
-        extern Uint32 g_alphaWidenedDrawBufferMask;
-
-        // Bit i set = DRAW BUFFER i of the framebuffer bound as DRAW resolves to a colour
-        // attachment with an INTEGER format. Recomputed beside the mask above and for its sake:
-        // glClearBufferfv on an integer colour buffer is GL_INVALID_OPERATION, so the
-        // per-draw-buffer clear route the widening needs has to stand down when one is present.
-        // (glClear on an integer colour buffer is left undefined by ES in the first place, and
-        // an application that wants a defined answer has to call glClearBufferuiv/iv - which does
-        // carry the widened alpha substitution.)
-        extern Uint32 g_integerColorDrawBufferMask;
-
-        // The colour a clear has to hand the driver for one draw buffer: the application's value,
-        // except that a widened attachment's alpha is replaced by the 1.0 its three-channel
-        // format implies. `one` is 1.0 encoded in the clear call's own component type - the
-        // integer clears carry the integer 1, the float clear carries 1.0f.
-        //
-        // Returns `value` itself when nothing is substituted, so the ordinary path allocates and
-        // copies nothing; `scratch` is the caller's buffer and has to outlive the returned
-        // pointer. Free of GL state on purpose, so the substitution can be unit-tested exactly as
-        // the driver sees it.
-        template <typename T>
-        const T* SubstituteWidenedClearAlpha(const T* value, Bool widened, T one, T (&scratch)[4]) {
-            if (!widened || value == nullptr) {
-                return value;
-            }
-            scratch[0] = value[0];
-            scratch[1] = value[1];
-            scratch[2] = value[2];
-            scratch[3] = one;
-            return scratch;
-        }
-
-        // What SyncCurrentFBO last pushed for each target, as a (binding, object, revision)
-        // triple; it re-syncs unless all three still match. Stamped by SyncCurrentFBO and
-        // ForceBindCurrentFBO, cleared by InvalidateFramebufferBindingCache. The three are
-        // only meaningful together - see SyncCurrentFBO.
-        //
-        // The binding slot's own version, which changes whenever a different object is bound
-        // to this target. Distinguishes a rebind from an in-place edit, and keeps the raw
-        // pointer below from matching an address the allocator recycled for a new FBO.
-        extern Array<Uint16, SizeT(FramebufferTarget::FramebufferTargetCount)> g_fboSyncedSlotVersions;
+        extern Array<Uint16, SizeT(FramebufferTarget::FramebufferTargetCount)> g_fboBindVersions;
         // Tracks the bound FBO's object version (bumped on any attachment/drawbuffer change)
         // per target: re-attaching textures or changing draw buffers on an already-bound FBO
         // must re-sync it even when the binding-slot version has not moved.
         extern Array<Uint16, SizeT(FramebufferTarget::FramebufferTargetCount)> g_fboSyncedObjectVersions;
-        // Which object was synced. Raw and never dereferenced: only compared for identity.
         extern Array<MG_State::GLState::FramebufferObject*, SizeT(FramebufferTarget::FramebufferTargetCount)>
             g_fboSyncedObjects;
 
@@ -903,10 +549,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         void InvalidatePackStateCache();
     } // namespace PixelStoreImpl
 
-    namespace SamplerImpl {
-        class BackendSamplerObject; // for PrgramImpl's sampler-pass memo rows below
-    }
-
     // 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.
@@ -953,43 +595,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 Float lastAssignedLodBias = 0.0f;
             };
 
-            // Memo of the whole per-draw sampler-uniform pass (glUniform1i unit
-            // assignments, lod-bias uniform, raw-depth-fetch substitution and the
-            // per-unit sampler-object binds) in BindCurrentProgramWithResources.
-            // The pass is a pure function of the keys below, and its only driver-side
-            // effect is the sampler binding of each sampled unit, so replaying it as
-            // "do nothing" additionally requires those bindings to still be on the
-            // driver - the per-entry row compare against g_boundSamplersCache (the
-            // shadow every sampler bind in this backend already routes through).
-            //
-            // Invalidation enumeration:
-            //  * sampler-uniform unit assignment (glUniform1i) and uniform-block
-            //    binding edits -> frontend backendStateVersion;
-            //  * any texture/sampler bind moving on any unit (incl. the high-water
-            //    mark moving) -> unitBindingsEpoch;
-            //  * any sampler parameter (incl. lod bias, compare mode) or texture
-            //    shape/format change -> samplingGeneration;
-            //  * another frontend context -> contextId (never-reused id);
-            //  * ES context recreation -> textureContextGeneration;
-            //  * relink / backend program rebuild -> SyncToBackend resets `valid`
-            //    (it rebuilds m_samplerUniformBindings, whose lastAssignedUnit /
-            //    lastAssignedLodBias dedup state this memo leans on);
-            //  * any other writer moving a sampled unit's sampler binding
-            //    (BindCurrentUnitSamplers on a unit-sampler change, scratch binds)
-            //    -> the row snapshot compare.
-            struct SamplerPassMemo {
-                static constexpr SizeT kMaxEntries = 16;
-                Bool valid = false;
-                Uint8 count = 0;
-                Uint64 contextId = 0;
-                Uint64 unitBindingsEpoch = 0;
-                Uint64 samplingGeneration = 0;
-                Uint32 backendStateVersion = 0;
-                Uint textureContextGeneration = 0;
-                Array<Uint8, kMaxEntries> units{};
-                Array<SamplerImpl::BackendSamplerObject*, kMaxEntries> rows{};
-            };
-
             BackendProgramObjectImpl();
             ~BackendProgramObjectImpl();
             void SyncToBackend(const SharedPtr<MG_State::GLState::ProgramObject>& stateProgramObject);
@@ -997,9 +602,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             void SetBaseInstance(Uint32 baseInstance) const;
             void SetBaseInstanceWordIndex(Int32 wordIndex) const;
             void SetDrawID(Uint32 drawId) const;
-            // True when the transpiled program kept a gl_DrawID uniform, i.e. SetDrawID
-            // actually reaches a shader read rather than being discarded.
-            Bool ReadsDrawID() const { return m_drawIdUniformLocation >= 0; }
             Int GetIndirectParamsBinding() const { return m_indirectParamsBinding; }
             Uint GetBackendProgramId() const { return m_backendProgramId; }
             // False when the last SyncToBackend could not produce a usable program (a
@@ -1021,7 +623,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             // reflected size when the transpiled block pads differently).
             Int GetGlobalUboBackendBlockSize() const { return m_globalUboBackendBlockSize; }
             BufferImpl::UboRingAllocation& GetGlobalUboRingAllocation() { return m_globalUboRingAllocation; }
-            SamplerPassMemo& GetSamplerPassMemo() { return m_samplerPassMemo; }
             // Frontend link version this backend program (and its resource caches) was
             // built from; a mismatch means every link-derived cache here is stale.
             Uint32 GetSyncedLinkVersion() const { return m_syncedLinkVersion; }
@@ -1050,7 +651,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             Uint32 m_lastUploadedGlobalUboVersion = ~0u;
             BufferImpl::UboRingAllocation m_globalUboRingAllocation;
             Uint32 m_syncedLinkVersion = ~0u;
-            SamplerPassMemo m_samplerPassMemo;
         };
 
         extern Uint32 g_snormFallbackClampOutputMask;
@@ -1065,22 +665,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         extern Uint g_lastUsedBackendProgramId;
         extern StateBackendObjectRegistry<MG_State::GLState::ProgramObject, BackendProgramObjectImpl>
             g_backendProgramObjects;
-
-        // Points one shader storage block of an ALREADY-LINKED backend program at
-        // `binding`. `blockName` is the frontend interface-query spelling; the real
-        // driver's own index for it is looked up here, because the transpiled ESSL's
-        // block order is not the frontend's. Returns false when the block does not exist
-        // on the backend program (eliminated as unused, or the driver lacks the entry
-        // points), which is not an error - GL_BUFFER_BINDING is served from the frontend
-        // record either way.
-        Bool ApplyShaderStorageBlockBinding(Uint backendProgramId, const String& blockName, Uint binding);
-        // Replays every glShaderStorageBlockBinding recorded on the program onto a backend
-        // program that was just built. The frontend record is authoritative (only the
-        // shader's DECLARED binding survives in the SPIR-V), so without this replay any
-        // rebuild would silently revert rebound blocks. Mirrors DirectVulkan's
-        // reseed-on-rebuild in BuildProgramResourceCache.
-        void ReseedShaderStorageBlockBindings(Uint backendProgramId,
-                                              const MG_State::GLState::ProgramObject& stateProgramObject);
     } // namespace PrgramImpl
 
     namespace SamplerImpl {

MobileGL/MG_Backend/DirectGLES/MultiDraw.cpp

@@ -1,894 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectGLES/MultiDraw.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 "MultiDraw.h"
-#include "Managers.h"
-#include <MG_State/GLState/Core.h>
-#include <cstring>
-#include <limits>
-
-namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
-    using MG_Config::GLESMultiDrawMode;
-
-    namespace {
-        // ---------------------------------------------------------------------------
-        // Batch shape
-        // ---------------------------------------------------------------------------
-
-        SizeT IndexTypeSize(GLenum type) {
-            switch (type) {
-            case GL_UNSIGNED_BYTE: return 1;
-            case GL_UNSIGNED_SHORT: return 2;
-            case GL_UNSIGNED_INT: return 4;
-            default: return 0;
-            }
-        }
-
-        // The all-ones value of an index type, which is what GL restarts on once
-        // primitive restart is in play. CheckPrimitiveRestartSupported has already
-        // rejected the arbitrary-index form of GL_PRIMITIVE_RESTART, so an enabled
-        // restart always restarts here and nowhere else.
-        Uint32 RestartSentinelFor(GLenum type) {
-            switch (type) {
-            case GL_UNSIGNED_BYTE: return 0xFFu;
-            case GL_UNSIGNED_SHORT: return 0xFFFFu;
-            default: return 0xFFFFFFFFu;
-            }
-        }
-
-        Bool RestartActive() {
-            return MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::PrimitiveRestart) ||
-                   MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::PrimitiveRestartFixedIndex);
-        }
-
-        // Vertices per primitive for the modes whose sub-draws may be concatenated into a
-        // single draw without changing the primitive stream. Zero for strip/loop/fan modes
-        // (concatenation would weld one sub-draw's last primitive to the next sub-draw's
-        // first) and for GL_PATCHES, whose primitive size is dynamic tessellation state.
-        Uint32 ConcatenablePrimitiveSize(GLenum mode) {
-            switch (mode) {
-            case GL_POINTS: return 1;
-            case GL_LINES: return 2;
-            case GL_TRIANGLES: return 3;
-            case GL_LINES_ADJACENCY: return 4;
-            case GL_TRIANGLES_ADJACENCY: return 6;
-            default: return 0;
-            }
-        }
-
-        // Beyond this an emulated batch would ask for a scratch allocation measured in
-        // hundreds of megabytes (and the scratch ring never shrinks again); decline and let
-        // a per-sub-draw tier handle it instead of trying and failing inside the driver.
-        constexpr SizeT kMaxFlattenedIndices = SizeT{1} << 24;
-
-        // The flattening dispatch is one invocation per output index. ES 3.1 only
-        // guarantees 65535 work groups per dimension, and exceeding it makes
-        // glDispatchCompute an INVALID_VALUE no-op - which would leave the draw reading an
-        // uninitialised index buffer rather than failing visibly. Cap the tier there
-        // instead of querying: 4.19M indices is far past any real multi-draw batch, and
-        // beyond it the per-sub-draw tiers are the better answer anyway.
-        constexpr SizeT kComputeWorkGroupSize = 64;
-        constexpr SizeT kMaxComputeWorkGroups = 65535;
-        constexpr SizeT kMaxComputeFlattenedIndices = kMaxComputeWorkGroups * kComputeWorkGroupSize;
-
-        Uint BoundDrawIndirectBufferId() {
-            const auto& indirect =
-                MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
-            if (!indirect) return 0;
-            const auto* resource = BufferImpl::EnsureBufferResource(indirect);
-            return resource ? resource->id : 0;
-        }
-
-        const SharedPtr<MG_State::GLState::BufferObject>& BoundIndexBuffer() {
-            static const SharedPtr<MG_State::GLState::BufferObject> none;
-            const auto& vao = MG_State::pGLContext->GetBoundVertexArray();
-            if (!vao) return none;
-            return vao->GetIndexBufferBindingSlot().GetBoundObject();
-        }
-
-        // The GL name PrepareForDraw left on GL_ELEMENT_ARRAY_BUFFER, i.e. what a tier
-        // that swaps in a scratch index buffer has to put back. Restoring the exact name
-        // matters beyond tidiness: the VAO twin memoises that it already synced this
-        // index binding and will not re-issue it on the next draw.
-        Uint BoundIndexBufferId() {
-            const auto& ibo = BoundIndexBuffer();
-            if (!ibo) return 0;
-            const auto* resource = BufferImpl::EnsureBufferResource(ibo);
-            return resource ? resource->id : 0;
-        }
-
-        // ---------------------------------------------------------------------------
-        // Scratch GL objects
-        //
-        // All of them belong to the ES context and are abandoned (not deleted) when it
-        // dies, exactly like XfbImpl's scatter buffer: the names are the dead context's
-        // to reclaim, and deleting them would target whatever the successor context
-        // handed out for the same name.
-        // ---------------------------------------------------------------------------
-
-        struct ScratchBuffer {
-            Uint id = 0;
-            SizeT capacity = 0;
-            SizeT cursor = 0; // ring buffers only: next free byte
-        };
-
-        ScratchBuffer g_indirectCommands; // synthesized DrawElementsIndirectCommand array
-        ScratchBuffer g_rebasedIndices;   // CPU-rebased index stream
-        ScratchBuffer g_drawInfo;         // compute tier: per-sub-draw descriptors
-        ScratchBuffer g_flattenedIndices; // compute tier: flattened index stream
-
-        Uint g_computeProgram = 0;
-        Bool g_computeProgramFailed = false;
-        GLint g_uElementSize = -1;
-        GLint g_uDrawCount = -1;
-        GLint g_uTotalIndices = -1;
-
-        // Reused staging, so a steady stream of batches allocates nothing.
-        Vector<DrawElementsIndirectCommand> g_commandStaging;
-        Vector<Uint32> g_indexStaging;
-        Vector<Uint32> g_drawInfoStaging;
-        Vector<GLint> g_zeroBaseVertices;
-
-        // Everything below stages through GL_ARRAY_BUFFER, the manager-wide staging target
-        // (BufferImpl::TempBufferTarget); binding it disturbs no VAO state.
-        Bool EnsureScratchName(ScratchBuffer& buffer) {
-            if (buffer.id != 0) return true;
-            GLuint id = 0;
-            g_GLESFuncs.glGenBuffers(1, &id);
-            if (id == 0) return false;
-            buffer.id = id;
-            buffer.capacity = 0;
-            buffer.cursor = 0;
-            return true;
-        }
-
-        // Whole-buffer upload, for the two buffers that are read from offset 0 because they
-        // are bound as storage blocks. Respecifies rather than sub-updates: glBufferData
-        // orphans the previous store, so the upload never waits on a dispatch still reading
-        // the old contents out of the same name.
-        Bool UploadScratch(ScratchBuffer& buffer, SizeT bytes, const void* data) {
-            if (bytes == 0) return true;
-            if (!EnsureScratchName(buffer)) return false;
-            BufferImpl::BindBufferId(BufferImpl::TempBufferTarget, buffer.id);
-            // Grow in powers of two so a batch that creeps up in size stops respecifying.
-            SizeT capacity = buffer.capacity == 0 ? bytes : buffer.capacity;
-            while (capacity < bytes) capacity *= 2;
-            g_GLESFuncs.glBufferData(BufferImpl::TempBufferTarget, static_cast<GLsizeiptr>(capacity), nullptr,
-                                     GL_STREAM_DRAW);
-            buffer.capacity = capacity;
-            buffer.cursor = 0;
-            if (data) {
-                g_GLESFuncs.glBufferSubData(BufferImpl::TempBufferTarget, 0, static_cast<GLsizeiptr>(bytes), data);
-            }
-            return true;
-        }
-
-        // Ring upload, for the buffers whose consumers can address a byte offset (indirect
-        // commands and rewritten index streams). Respecifying per batch is what an
-        // orphan-every-time scheme costs, and on a desktop-class driver that allocation
-        // dominated the tiers that use these buffers - a multi-draw of 32 sub-draws stages
-        // 640 bytes and paid for a fresh store to hold them. Bump-allocating instead means
-        // one respecify per wrap; every byte between two wraps is written exactly once, so
-        // nothing in flight is overwritten, and the wrap itself orphans.
-        constexpr SizeT kRingAlignment = 16; // >= 4, so both command and uint32-index offsets stay legal
-        constexpr SizeT kMinRingBytes = 1u << 16;
-
-        Bool UploadScratchRing(ScratchBuffer& buffer, SizeT bytes, const void* data, SizeT& outOffset) {
-            outOffset = 0;
-            if (bytes == 0) return true;
-            if (!EnsureScratchName(buffer)) return false;
-            BufferImpl::BindBufferId(BufferImpl::TempBufferTarget, buffer.id);
-
-            const SizeT aligned = (bytes + kRingAlignment - 1) & ~(kRingAlignment - 1);
-            if (buffer.capacity < aligned) {
-                SizeT capacity = buffer.capacity == 0 ? kMinRingBytes : buffer.capacity;
-                while (capacity < aligned) capacity *= 2;
-                g_GLESFuncs.glBufferData(BufferImpl::TempBufferTarget, static_cast<GLsizeiptr>(capacity), nullptr,
-                                         GL_STREAM_DRAW);
-                buffer.capacity = capacity;
-                buffer.cursor = 0;
-            } else if (buffer.cursor + aligned > buffer.capacity) {
-                g_GLESFuncs.glBufferData(BufferImpl::TempBufferTarget, static_cast<GLsizeiptr>(buffer.capacity),
-                                         nullptr, GL_STREAM_DRAW);
-                buffer.cursor = 0;
-            }
-
-            outOffset = buffer.cursor;
-            if (data) {
-                g_GLESFuncs.glBufferSubData(BufferImpl::TempBufferTarget, static_cast<GLintptr>(outOffset),
-                                            static_cast<GLsizeiptr>(bytes), data);
-            }
-            buffer.cursor += aligned;
-            return true;
-        }
-
-        // ---------------------------------------------------------------------------
-        // Tier resolution
-        // ---------------------------------------------------------------------------
-
-        // Best-first, and measured rather than assumed. MobileGlues orders its own Auto
-        // multiindirect -> indirect -> basevertex; on both ES drivers available here that
-        // is backwards, because staging a command buffer per batch costs more than the
-        // driver entries it saves. mc_sodium_multidraw (132 batches x 32 sub-draws),
-        // ns/op, median of three:
-        //
-        //                    NVIDIA ES 3.2   Mesa llvmpipe ES 3.2
-        //   ext                  n/a               19300
-        //   basevertex           2500              25200
-        //   multiindirect        5700              27600
-        //   drawelements         5600              28700
-        //   indirect             5800              31000
-        //
-        // Ring-allocating the command staging (instead of respecifying per batch) was
-        // tried first and moved the indirect tiers by less than noise, so the cost is the
-        // indirect draw path itself, not the upload. Only "ext" - a real multi-draw entry
-        // point rather than an indirect one - actually beats replaying the sub-draws.
-        //
-        // The compute tier is deliberately absent from the ladder: it rewrites the
-        // primitive stream rather than replaying it, and it measured slowest of all here,
-        // so it stays opt-in behind the env knob (the same call MobileGlues makes - its
-        // Auto never selects Compute either).
-        constexpr GLESMultiDrawMode kAutoLadder[] = {
-            GLESMultiDrawMode::Ext,      GLESMultiDrawMode::BaseVertex,   GLESMultiDrawMode::MultiIndirect,
-            GLESMultiDrawMode::Indirect, GLESMultiDrawMode::DrawElements,
-        };
-
-        Bool SupportsTier(GLESMultiDrawMode tier) {
-            return IsTierSupported(g_GLESCapabilities, g_GLESFuncs, tier);
-        }
-
-        GLESMultiDrawMode g_resolvedTier = GLESMultiDrawMode::Auto;
-        Bool g_tierResolved = false;
-        String g_tierResolution;
-
-        void ResolveTierOnce() {
-            if (g_tierResolved) return;
-            g_tierResolved = true;
-            g_resolvedTier =
-                ResolveTier(g_GLESCapabilities, g_GLESFuncs, MG_Config::Features.EsprytMultiDrawMode,
-                            &g_tierResolution);
-            MGLOG_I("DirectGLES multi-draw: %s", g_tierResolution.c_str());
-        }
-
-        // Which tiers have already announced themselves, one bit per GLESMultiDrawMode.
-        // The resolution line above says which tier was CHOSEN; this says which one a
-        // batch actually went through, and the two differ whenever a batch's shape
-        // demotes it. Worth a line each: a multi-draw path that resolves to a tier and
-        // then quietly runs a different one is exactly how "the batch drew nothing"
-        // hides.
-        Uint32 g_announcedTiers = 0;
-
-        void NoteTierExecuted(GLESMultiDrawMode tier) {
-            const Uint32 bit = 1u << static_cast<Uint32>(tier);
-            if (g_announcedTiers & bit) return;
-            g_announcedTiers |= bit;
-            MGLOG_I("DirectGLES multi-draw: first batch executed via tier \"%s\"", TierName(tier));
-        }
-
-        // The tier this particular batch can actually take. A tier is demoted here when
-        // the batch's own shape - not the driver - rules it out; the compute tier keeps
-        // its remaining feasibility checks inside its implementation, where the data it
-        // has to walk is already in hand.
-        GLESMultiDrawMode ResolveTierForBatch(Bool programReadsDrawID, Bool hasIndexBuffer) {
-            ResolveTierOnce();
-            GLESMultiDrawMode tier = g_resolvedTier;
-
-            // Batched tiers issue one driver entry for the whole batch, so the emulated
-            // gl_DrawID uniform can only hold one value across every sub-draw. A program
-            // that reads gl_DrawID gets an unrolled tier, which feeds each sub-draw its
-            // own index (the spec's value); nothing else observes the difference.
-            const Bool batched = tier == GLESMultiDrawMode::Ext || tier == GLESMultiDrawMode::MultiIndirect ||
-                                 tier == GLESMultiDrawMode::Compute;
-            if (batched && programReadsDrawID) {
-                tier = SupportsTier(GLESMultiDrawMode::BaseVertex) ? GLESMultiDrawMode::BaseVertex
-                                                                   : GLESMultiDrawMode::DrawElements;
-            }
-
-            // The indirect tiers describe each sub-draw as an element offset into the
-            // bound element array buffer. A client-memory index array has no such buffer,
-            // and indirect draws are not defined without one.
-            if (!hasIndexBuffer &&
-                (tier == GLESMultiDrawMode::MultiIndirect || tier == GLESMultiDrawMode::Indirect)) {
-                tier = SupportsTier(GLESMultiDrawMode::BaseVertex) ? GLESMultiDrawMode::BaseVertex
-                                                                   : GLESMultiDrawMode::DrawElements;
-            }
-            return tier;
-        }
-
-        // ---------------------------------------------------------------------------
-        // Index rewriting, shared by the two tiers that fold base vertices into indices
-        // ---------------------------------------------------------------------------
-
-        // Both of those tiers emit GL_UNSIGNED_INT regardless of the source type. Keeping
-        // the source width would be wrong, not merely tight: GL adds baseVertex to the
-        // index at full precision, so a GL_UNSIGNED_SHORT index plus a base vertex past
-        // 65535 addresses a vertex the source type cannot spell. Widening also gives the
-        // rewritten stream a restart sentinel (0xFFFFFFFF) that survives the rebase.
-        void RebaseIndices(const Uint8* source, SizeT sourceIndexCount, SizeT indexSize, Int32 baseVertex,
-                           Bool restartActive, Uint32 restartSentinel, Uint32* out) {
-            const Uint32 baseVertexBits = static_cast<Uint32>(baseVertex);
-            for (SizeT i = 0; i < sourceIndexCount; ++i) {
-                Uint32 value = 0;
-                switch (indexSize) {
-                case 1: value = source[i]; break;
-                case 2: {
-                    Uint16 narrow = 0;
-                    std::memcpy(&narrow, source + i * 2, sizeof(narrow));
-                    value = narrow;
-                    break;
-                }
-                default: std::memcpy(&value, source + i * 4, sizeof(value)); break;
-                }
-                // Unsigned wraparound is the defined behaviour for a negative base vertex.
-                out[i] = (restartActive && value == restartSentinel) ? 0xFFFFFFFFu : value + baseVertexBits;
-            }
-        }
-
-        // CPU-readable bytes of one sub-draw's indices, from the frontend shadow of the
-        // bound index buffer or straight from the client array. Null when the sub-draw
-        // would read outside the buffer.
-        const Uint8* ResolveSubDrawIndices(const SharedPtr<MG_State::GLState::BufferObject>& indexBuffer,
-                                           const Uint8* indexBufferBytes, SizeT indexBufferSize, const void* indices,
-                                           SizeT indexCount, SizeT indexSize) {
-            if (!indexBuffer) {
-                return static_cast<const Uint8*>(indices);
-            }
-            if (!indexBufferBytes) return nullptr;
-            const SizeT byteOffset = reinterpret_cast<SizeT>(indices);
-            const SizeT byteEnd = byteOffset + indexCount * indexSize;
-            if (byteEnd > indexBufferSize || byteEnd < byteOffset) return nullptr;
-            return indexBufferBytes + byteOffset;
-        }
-
-        // ---------------------------------------------------------------------------
-        // Tier: Ext - one glMultiDrawElementsBaseVertexEXT
-        // ---------------------------------------------------------------------------
-
-        Bool RunExt(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei drawcount,
-                    const GLint* basevertex) {
-            if (!SupportsTier(GLESMultiDrawMode::Ext)) return false;
-            const GLint* baseVertices = basevertex;
-            if (!baseVertices) {
-                // glMultiDrawElements: every base vertex is 0, but the entry point still
-                // wants an array. One permanently-zero vector serves every such batch.
-                if (g_zeroBaseVertices.size() < static_cast<SizeT>(drawcount)) {
-                    g_zeroBaseVertices.resize(static_cast<SizeT>(drawcount), 0);
-                }
-                baseVertices = g_zeroBaseVertices.data();
-            }
-            g_GLESFuncs.glMultiDrawElementsBaseVertexEXT(mode, count, type, indices, drawcount, baseVertices);
-            NoteTierExecuted(GLESMultiDrawMode::Ext);
-            return true;
-        }
-
-        // ---------------------------------------------------------------------------
-        // Tiers: MultiIndirect / Indirect - synthesized indirect commands
-        // ---------------------------------------------------------------------------
-
-        Bool RunIndirect(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                         GLsizei drawcount, const GLint* basevertex, Bool batched, Bool feedDrawID) {
-            if (!SupportsTier(batched ? GLESMultiDrawMode::MultiIndirect : GLESMultiDrawMode::Indirect)) return false;
-            const SizeT indexSize = IndexTypeSize(type);
-            if (indexSize == 0) return false;
-            // Indirect commands address indices as an element offset into the bound element
-            // array buffer, and an indirect draw is not defined without one.
-            const auto& indexBuffer = BoundIndexBuffer();
-            if (!indexBuffer) return false;
-
-            g_commandStaging.resize(static_cast<SizeT>(drawcount));
-            for (GLsizei i = 0; i < drawcount; ++i) {
-                const SizeT byteOffset = reinterpret_cast<SizeT>(indices[i]);
-                // firstIndex counts elements, so an offset that is not a whole number of
-                // them cannot be expressed as a command at all.
-                if (byteOffset % indexSize != 0) return false;
-                auto& command = g_commandStaging[static_cast<SizeT>(i)];
-                command.count = count[i] > 0 ? static_cast<Uint32>(count[i]) : 0u;
-                command.instanceCount = 1;
-                command.firstIndex = static_cast<Uint32>(byteOffset / indexSize);
-                command.baseVertex = basevertex ? basevertex[i] : 0;
-                command.baseInstance = 0;
-            }
-
-            const SizeT commandBytes = g_commandStaging.size() * sizeof(DrawElementsIndirectCommand);
-            SizeT commandBase = 0;
-            if (!UploadScratchRing(g_indirectCommands, commandBytes, g_commandStaging.data(), commandBase)) {
-                return false;
-            }
-
-            // Every synthesized command carries baseInstance 0. Say so through the direct
-            // path, which also clears the indirect-params word index a preceding real
-            // indirect draw may have left pointing into its own command buffer.
-            SetCurrentBaseInstance(0);
-
-            const Uint previousIndirectBinding = BoundDrawIndirectBufferId();
-            BufferImpl::BindBufferId(GL_DRAW_INDIRECT_BUFFER, g_indirectCommands.id);
-            if (batched) {
-                g_GLESFuncs.glMultiDrawElementsIndirectEXT(mode, type, reinterpret_cast<const void*>(commandBase),
-                                                           drawcount, 0);
-            } else {
-                for (GLsizei i = 0; i < drawcount; ++i) {
-                    if (feedDrawID) SetCurrentDrawID(static_cast<Uint32>(i));
-                    const SizeT commandOffset = commandBase + static_cast<SizeT>(i) * sizeof(DrawElementsIndirectCommand);
-                    g_GLESFuncs.glDrawElementsIndirect(mode, type, reinterpret_cast<const void*>(commandOffset));
-                }
-                if (feedDrawID) SetCurrentDrawID(0);
-            }
-            BufferImpl::BindBufferId(GL_DRAW_INDIRECT_BUFFER, previousIndirectBinding);
-            NoteTierExecuted(batched ? GLESMultiDrawMode::MultiIndirect : GLESMultiDrawMode::Indirect);
-            return true;
-        }
-
-        // ---------------------------------------------------------------------------
-        // Tier: BaseVertex - the per-sub-draw replay
-        // ---------------------------------------------------------------------------
-
-        Bool RunBaseVertexLoop(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                               GLsizei drawcount, const GLint* basevertex, Bool feedDrawID) {
-            if (!SupportsTier(GLESMultiDrawMode::BaseVertex)) return false;
-            for (GLsizei i = 0; i < drawcount; ++i) {
-                if (count[i] <= 0) continue;
-                if (feedDrawID) SetCurrentDrawID(static_cast<Uint32>(i));
-                g_GLESFuncs.glDrawElementsBaseVertex(mode, count[i], type, indices[i],
-                                                     basevertex ? basevertex[i] : 0);
-            }
-            if (feedDrawID) SetCurrentDrawID(0);
-            NoteTierExecuted(GLESMultiDrawMode::BaseVertex);
-            return true;
-        }
-
-        // ---------------------------------------------------------------------------
-        // Tier: DrawElements - base vertices folded into a scratch index stream
-        // ---------------------------------------------------------------------------
-
-        Bool RunRebasedDrawElements(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                                    GLsizei drawcount, const GLint* basevertex, Bool feedDrawID) {
-            const SizeT indexSize = IndexTypeSize(type);
-            if (indexSize == 0) return false;
-
-            SizeT total = 0;
-            for (GLsizei i = 0; i < drawcount; ++i) {
-                if (count[i] > 0) total += static_cast<SizeT>(count[i]);
-            }
-            if (total == 0) return true;
-            if (total > kMaxFlattenedIndices) return false;
-
-            const auto& indexBuffer = BoundIndexBuffer();
-            const Uint8* indexBufferBytes = nullptr;
-            SizeT indexBufferSize = 0;
-            if (indexBuffer) {
-                // The shadow is the source of truth for CPU reads, but a persistent map or
-                // a shader write may have moved past it since the last sync.
-                indexBuffer->SyncPersistentMappedRange();
-                indexBuffer->SyncGpuWrites();
-                indexBufferBytes = indexBuffer->MappedData();
-                indexBufferSize = indexBuffer->GetSize();
-            }
-
-            const Bool restartActive = RestartActive();
-            const Uint32 restartSentinel = RestartSentinelFor(type);
-            g_indexStaging.resize(total);
-            SizeT cursor = 0;
-            for (GLsizei i = 0; i < drawcount; ++i) {
-                if (count[i] <= 0) continue;
-                const SizeT subDrawCount = static_cast<SizeT>(count[i]);
-                const Uint8* source = ResolveSubDrawIndices(indexBuffer, indexBufferBytes, indexBufferSize, indices[i],
-                                                            subDrawCount, indexSize);
-                if (!source) {
-                    MGLOG_E("DirectGLES multi-draw (drawelements tier): sub-draw %d reads outside the bound index "
-                            "buffer; skipping the batch",
-                            i);
-                    return false;
-                }
-                RebaseIndices(source, subDrawCount, indexSize, basevertex ? basevertex[i] : 0, restartActive,
-                              restartSentinel, g_indexStaging.data() + cursor);
-                cursor += subDrawCount;
-            }
-
-            SizeT indexBase = 0;
-            if (!UploadScratchRing(g_rebasedIndices, total * sizeof(Uint32), g_indexStaging.data(), indexBase)) {
-                return false;
-            }
-
-            const Uint previousIndexBinding = BoundIndexBufferId();
-            BufferImpl::BindBufferId(GL_ELEMENT_ARRAY_BUFFER, g_rebasedIndices.id);
-            cursor = 0;
-            for (GLsizei i = 0; i < drawcount; ++i) {
-                if (count[i] <= 0) continue;
-                if (feedDrawID) SetCurrentDrawID(static_cast<Uint32>(i));
-                g_GLESFuncs.glDrawElements(mode, count[i], GL_UNSIGNED_INT,
-                                           reinterpret_cast<const void*>(indexBase + cursor * sizeof(Uint32)));
-                cursor += static_cast<SizeT>(count[i]);
-            }
-            if (feedDrawID) SetCurrentDrawID(0);
-            BufferImpl::BindBufferId(GL_ELEMENT_ARRAY_BUFFER, previousIndexBinding);
-            NoteTierExecuted(GLESMultiDrawMode::DrawElements);
-            return true;
-        }
-
-        // ---------------------------------------------------------------------------
-        // Tier: Compute - the whole batch flattened into one rebased index stream
-        // ---------------------------------------------------------------------------
-
-        // One index per invocation. The sub-draw an output slot belongs to is found by
-        // binary search over the inclusive prefix sums of the sub-draw counts, which is
-        // why the descriptors are sorted by construction. Sub-draws with a zero count
-        // repeat the previous prefix sum and are therefore skipped by the search.
-        //
-        // Three storage blocks, not the five the shape suggests: ES 3.1 only guarantees
-        // four per compute stage, so the per-sub-draw descriptors share one buffer.
-        constexpr const char* kFlattenComputeSource = R"(#version 310 es
-layout(local_size_x = 64) in;
-
-uniform uint uElementSize;
-uniform uint uDrawCount;
-uniform uint uTotalIndices;
-
-layout(std430, binding = 0) readonly buffer SourceIndices { uint sourceWords[]; };
-layout(std430, binding = 1) readonly buffer DrawInfo { uint drawInfo[]; };
-layout(std430, binding = 2) writeonly buffer FlatIndices { uint flatIndices[]; };
-
-uint ReadSourceIndex(uint element) {
-    if (uElementSize == 4u) {
-        return sourceWords[element];
-    }
-    if (uElementSize == 2u) {
-        uint word = sourceWords[element >> 1u];
-        return (word >> ((element & 1u) * 16u)) & 0xFFFFu;
-    }
-    uint word = sourceWords[element >> 2u];
-    return (word >> ((element & 3u) * 8u)) & 0xFFu;
-}
-
-void main() {
-    uint outIndex = gl_GlobalInvocationID.x;
-    if (outIndex >= uTotalIndices) {
-        return;
-    }
-
-    uint low = 0u;
-    uint high = uDrawCount - 1u;
-    while (low < high) {
-        uint mid = low + (high - low) / 2u;
-        if (drawInfo[mid * 3u + 2u] > outIndex) {
-            high = mid;
-        } else {
-            low = mid + 1u;
-        }
-    }
-
-    uint localIndex = outIndex - (low == 0u ? 0u : drawInfo[(low - 1u) * 3u + 2u]);
-    // Unsigned wraparound is the defined behaviour for a negative base vertex. No
-    // restart sentinel handling: the tier declines outright while restart is enabled.
-    flatIndices[outIndex] = ReadSourceIndex(localIndex + drawInfo[low * 3u]) + drawInfo[low * 3u + 1u];
-}
-)";
-
-        struct FlattenedStream {
-            Uint bufferId = 0;
-            SizeT indexCount = 0;
-        };
-
-        Bool EnsureComputeProgram() {
-            if (g_computeProgram != 0) return true;
-            if (g_computeProgramFailed) return false;
-            g_computeProgramFailed = true; // cleared again only on a complete success
-
-            const GLuint shader = g_GLESFuncs.glCreateShader(GL_COMPUTE_SHADER);
-            if (shader == 0) {
-                MGLOG_E("DirectGLES multi-draw (compute tier): glCreateShader(GL_COMPUTE_SHADER) failed");
-                return false;
-            }
-            const char* source = kFlattenComputeSource;
-            g_GLESFuncs.glShaderSource(shader, 1, &source, nullptr);
-            g_GLESFuncs.glCompileShader(shader);
-            GLint status = GL_FALSE;
-            g_GLESFuncs.glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
-            if (status != GL_TRUE) {
-                char log[1024] = {};
-                g_GLESFuncs.glGetShaderInfoLog(shader, sizeof(log) - 1, nullptr, log);
-                MGLOG_E("DirectGLES multi-draw (compute tier): index-flattening shader failed to compile: %s", log);
-                g_GLESFuncs.glDeleteShader(shader);
-                return false;
-            }
-
-            const GLuint program = g_GLESFuncs.glCreateProgram();
-            if (program == 0) {
-                MGLOG_E("DirectGLES multi-draw (compute tier): glCreateProgram failed");
-                g_GLESFuncs.glDeleteShader(shader);
-                return false;
-            }
-            g_GLESFuncs.glAttachShader(program, shader);
-            g_GLESFuncs.glLinkProgram(program);
-            g_GLESFuncs.glDeleteShader(shader);
-            g_GLESFuncs.glGetProgramiv(program, GL_LINK_STATUS, &status);
-            if (status != GL_TRUE) {
-                char log[1024] = {};
-                g_GLESFuncs.glGetProgramInfoLog(program, sizeof(log) - 1, nullptr, log);
-                MGLOG_E("DirectGLES multi-draw (compute tier): index-flattening program failed to link: %s", log);
-                g_GLESFuncs.glDeleteProgram(program);
-                return false;
-            }
-
-            g_computeProgram = program;
-            g_uElementSize = g_GLESFuncs.glGetUniformLocation(program, "uElementSize");
-            g_uDrawCount = g_GLESFuncs.glGetUniformLocation(program, "uDrawCount");
-            g_uTotalIndices = g_GLESFuncs.glGetUniformLocation(program, "uTotalIndices");
-            g_computeProgramFailed = false;
-            MGLOG_I("DirectGLES multi-draw: index-flattening compute program ready (id %u)", program);
-            return true;
-        }
-
-        // Builds the flattened stream, or leaves `out` empty when this batch's shape rules
-        // the tier out. Runs BEFORE PrepareForDraw - see the call site - so it may leave
-        // the compute program current and the first storage points unbound; the
-        // preparation that follows re-establishes both.
-        void FlattenWithCompute(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                                GLsizei drawcount, const GLint* basevertex, FlattenedStream& out) {
-            if (!SupportsTier(GLESMultiDrawMode::Compute)) return;
-            const SizeT indexSize = IndexTypeSize(type);
-            if (indexSize == 0) return;
-
-            // Merging sub-draws into a single draw only reproduces the original primitive
-            // stream for list-shaped modes: a strip, loop or fan would gain primitives
-            // spanning the seam between two sub-draws.
-            const Uint32 primitiveSize = ConcatenablePrimitiveSize(mode);
-            if (primitiveSize == 0) return;
-
-            // Primitive restart defeats the whole-multiple-of-a-primitive argument below,
-            // even for a list mode. A restart ends the current primitive, so a sub-draw of
-            // six GL_TRIANGLES indices with a restart after the third emits ONE triangle
-            // and drops the two leftover vertices - and once concatenated those leftovers
-            // find a third vertex in the next sub-draw and become a triangle that GL never
-            // draws. Splicing separator sentinels into the flattened stream could fix it,
-            // at the cost of a per-sub-draw offset the prefix-sum layout does not carry;
-            // declining is the honest trade for a tier that is already opt-in.
-            if (RestartActive()) return;
-
-            // The shader reads the source indices as a storage buffer, so there has to be
-            // a real buffer to read - a client-memory index array has none.
-            const auto& indexBuffer = BoundIndexBuffer();
-            if (!indexBuffer) return;
-
-            // A dispatch inside an open capture span is not legal, and the span would also
-            // observe one merged draw rather than the batch it asked for.
-            if (XfbImpl::IsCaptureSpanOpen()) return;
-
-            auto* sourceResource = BufferImpl::EnsureBufferResource(indexBuffer);
-            if (!sourceResource || sourceResource->id == 0) return;
-            const SizeT sourceSize = indexBuffer->GetSize();
-            // std430 addresses the source as uint[]; a tail shorter than a word is not
-            // reachable, so a narrow index type needs a word-multiple buffer.
-            if (indexSize < 4 && (sourceSize % 4) != 0) return;
-
-            g_drawInfoStaging.resize(3 * static_cast<SizeT>(drawcount));
-            SizeT total = 0;
-            for (GLsizei i = 0; i < drawcount; ++i) {
-                const SizeT subDrawCount = count[i] > 0 ? static_cast<SizeT>(count[i]) : 0;
-                // GL drops a trailing partial primitive per sub-draw; concatenation would
-                // instead splice it onto the next sub-draw's first vertices.
-                if (subDrawCount % primitiveSize != 0) return;
-                const SizeT byteOffset = reinterpret_cast<SizeT>(indices[i]);
-                if (byteOffset % indexSize != 0) return;
-                if (subDrawCount != 0) {
-                    const SizeT byteEnd = byteOffset + subDrawCount * indexSize;
-                    if (byteEnd > sourceSize || byteEnd < byteOffset) return;
-                }
-                total += subDrawCount;
-                if (total > kMaxComputeFlattenedIndices) return;
-                const SizeT slot = 3 * static_cast<SizeT>(i);
-                g_drawInfoStaging[slot] = static_cast<Uint32>(byteOffset / indexSize);
-                g_drawInfoStaging[slot + 1] = static_cast<Uint32>(basevertex ? basevertex[i] : 0);
-                g_drawInfoStaging[slot + 2] = static_cast<Uint32>(total);
-            }
-            if (total == 0) return; // nothing to draw; the ordinary tiers no-op just as well
-
-            if (!EnsureComputeProgram()) return;
-            if (!UploadScratch(g_drawInfo, g_drawInfoStaging.size() * sizeof(Uint32), g_drawInfoStaging.data())) {
-                return;
-            }
-            if (!UploadScratch(g_flattenedIndices, total * sizeof(Uint32), nullptr)) return;
-
-            BufferImpl::BindBufferBaseCached(GL_SHADER_STORAGE_BUFFER, 0, sourceResource->id);
-            BufferImpl::BindBufferBaseCached(GL_SHADER_STORAGE_BUFFER, 1, g_drawInfo.id);
-            BufferImpl::BindBufferBaseCached(GL_SHADER_STORAGE_BUFFER, 2, g_flattenedIndices.id);
-
-            g_GLESFuncs.glUseProgram(g_computeProgram);
-            PrgramImpl::g_lastUsedBackendProgramId = g_computeProgram;
-            if (g_uElementSize >= 0) g_GLESFuncs.glUniform1ui(g_uElementSize, static_cast<GLuint>(indexSize));
-            if (g_uDrawCount >= 0) g_GLESFuncs.glUniform1ui(g_uDrawCount, static_cast<GLuint>(drawcount));
-            if (g_uTotalIndices >= 0) g_GLESFuncs.glUniform1ui(g_uTotalIndices, static_cast<GLuint>(total));
-
-            g_GLESFuncs.glDispatchCompute(
-                static_cast<GLuint>((total + kComputeWorkGroupSize - 1) / kComputeWorkGroupSize), 1, 1);
-            g_GLESFuncs.glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT | GL_ELEMENT_ARRAY_BARRIER_BIT);
-
-            // Hand the storage points back to their GL default. PrepareForDraw re-syncs
-            // only the points the app has actually touched, so leaving a scratch buffer on
-            // an untouched point would keep it visible to the next shader that declares one.
-            for (Uint point = 0; point < 3; ++point) {
-                BufferImpl::BindBufferBaseCached(GL_SHADER_STORAGE_BUFFER, point, 0);
-            }
-
-            NoteTierExecuted(GLESMultiDrawMode::Compute);
-            out.bufferId = g_flattenedIndices.id;
-            out.indexCount = total;
-        }
-    } // namespace
-
-    // -------------------------------------------------------------------------------
-    // Public surface
-    // -------------------------------------------------------------------------------
-
-    Bool IsTierSupported(const MG_External::GLESCapabilities& caps, const MG_External::GLESFunctionsTable& funcs,
-                         GLESMultiDrawMode tier) {
-        const Bool esAtLeast31 =
-            caps.GLESVersion.Major > 3 || (caps.GLESVersion.Major == 3 && caps.GLESVersion.Minor >= 1);
-        switch (tier) {
-        case GLESMultiDrawMode::Ext:
-            return caps.SupportsMultiDrawElementsBaseVertex;
-        case GLESMultiDrawMode::MultiIndirect:
-            return caps.SupportsMultiDrawIndirect && esAtLeast31 && funcs.glDrawElementsIndirect != nullptr;
-        case GLESMultiDrawMode::Indirect:
-            return esAtLeast31 && funcs.glDrawElementsIndirect != nullptr;
-        case GLESMultiDrawMode::BaseVertex:
-            return caps.SupportsDrawElementsBaseVertex;
-        case GLESMultiDrawMode::DrawElements:
-            // Plain glDrawElements over a rewritten index stream: ES 2 core, so this is
-            // the floor every other tier can fall back to.
-            return true;
-        case GLESMultiDrawMode::Compute:
-            // Three storage blocks, which is inside the four ES 3.1 guarantees per stage.
-            return caps.SupportsComputeShader && caps.MaxComputeShaderStorageBlocks >= 3 &&
-                   funcs.glBindBufferBase != nullptr;
-        case GLESMultiDrawMode::Auto:
-            break;
-        }
-        return false;
-    }
-
-    GLESMultiDrawMode ResolveTier(const MG_External::GLESCapabilities& caps,
-                                  const MG_External::GLESFunctionsTable& funcs, GLESMultiDrawMode requested,
-                                  String* explanation) {
-        const auto bestAuto = [&]() {
-            for (const GLESMultiDrawMode tier : kAutoLadder) {
-                if (IsTierSupported(caps, funcs, tier)) return tier;
-            }
-            return GLESMultiDrawMode::DrawElements;
-        };
-
-        GLESMultiDrawMode resolved = GLESMultiDrawMode::DrawElements;
-        String line;
-        if (requested == GLESMultiDrawMode::Auto) {
-            resolved = bestAuto();
-            line = String("auto -> ") + TierName(resolved);
-        } else if (IsTierSupported(caps, funcs, requested)) {
-            resolved = requested;
-            line = String("MOBILEGL_ESPRYT_MULTIDRAW_MODE=") + TierName(requested) + " -> " + TierName(resolved);
-        } else {
-            resolved = bestAuto();
-            line = String("MOBILEGL_ESPRYT_MULTIDRAW_MODE=") + TierName(requested) +
-                   " requested but unsupported by this driver -> " + TierName(resolved);
-        }
-
-        if (explanation) {
-            String supported;
-            for (const GLESMultiDrawMode tier : kAutoLadder) {
-                if (!IsTierSupported(caps, funcs, tier)) continue;
-                if (!supported.empty()) supported += ", ";
-                supported += TierName(tier);
-            }
-            if (IsTierSupported(caps, funcs, GLESMultiDrawMode::Compute)) {
-                supported += supported.empty() ? "compute (opt-in)" : ", compute (opt-in)";
-            }
-            *explanation = line + " (driver supports: " + supported + ")";
-        }
-        return resolved;
-    }
-
-    const char* TierName(GLESMultiDrawMode tier) {
-        switch (tier) {
-        case GLESMultiDrawMode::Auto: return "auto";
-        case GLESMultiDrawMode::Ext: return "ext";
-        case GLESMultiDrawMode::MultiIndirect: return "multiindirect";
-        case GLESMultiDrawMode::Indirect: return "indirect";
-        case GLESMultiDrawMode::BaseVertex: return "basevertex";
-        case GLESMultiDrawMode::DrawElements: return "drawelements";
-        case GLESMultiDrawMode::Compute: return "compute";
-        }
-        return "unknown";
-    }
-
-    GLESMultiDrawMode ResolvedTier() {
-        ResolveTierOnce();
-        return g_resolvedTier;
-    }
-
-    String DescribeTierResolution() {
-        ResolveTierOnce();
-        return g_tierResolution;
-    }
-
-    void OnBackendContextDestroyed() {
-        g_indirectCommands = {};
-        g_rebasedIndices = {};
-        g_drawInfo = {};
-        g_flattenedIndices = {};
-        g_computeProgram = 0;
-        g_computeProgramFailed = false;
-        g_uElementSize = -1;
-        g_uDrawCount = -1;
-        g_uTotalIndices = -1;
-    }
-
-    void DrawElementsBatch(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                           GLsizei drawcount, const GLint* basevertex) {
-        if (drawcount <= 0 || !count || !indices) return;
-        // State-independent and possibly throwing, so it runs before any GL work.
-        CheckPrimitiveRestartSupported(type);
-
-        const Bool hasIndexBuffer = BoundIndexBuffer() != nullptr;
-
-        // The compute tier dispatches BEFORE the draw state is established: doing it
-        // afterwards would mean unpicking the program, SSBO and index bindings
-        // PrepareForDraw just made, and a dispatch inside an open transform feedback
-        // span is not legal at all. On success it hands back a flattened index stream.
-        FlattenedStream flattened;
-        if (ResolvedTier() == GLESMultiDrawMode::Compute && !CurrentProgramReadsDrawID()) {
-            FlattenWithCompute(mode, count, type, indices, drawcount, basevertex, flattened);
-        }
-
-        PrepareForDraw(DrawSyncBit::IndexBuffer);
-
-        if (flattened.indexCount != 0) {
-            const Uint previousIndexBinding = BoundIndexBufferId();
-            BufferImpl::BindBufferId(GL_ELEMENT_ARRAY_BUFFER, flattened.bufferId);
-            g_GLESFuncs.glDrawElements(mode, static_cast<GLsizei>(flattened.indexCount), GL_UNSIGNED_INT, nullptr);
-            BufferImpl::BindBufferId(GL_ELEMENT_ARRAY_BUFFER, previousIndexBinding);
-            return;
-        }
-
-        const Bool feedDrawID = CurrentProgramReadsDrawID();
-        const GLESMultiDrawMode tier = ResolveTierForBatch(feedDrawID, hasIndexBuffer);
-
-        Bool drawn = false;
-        switch (tier) {
-        case GLESMultiDrawMode::Ext:
-            drawn = RunExt(mode, count, type, indices, drawcount, basevertex);
-            break;
-        case GLESMultiDrawMode::MultiIndirect:
-            drawn = RunIndirect(mode, count, type, indices, drawcount, basevertex, /*batched=*/true, feedDrawID);
-            break;
-        case GLESMultiDrawMode::Indirect:
-            drawn = RunIndirect(mode, count, type, indices, drawcount, basevertex, /*batched=*/false, feedDrawID);
-            break;
-        case GLESMultiDrawMode::BaseVertex:
-            drawn = RunBaseVertexLoop(mode, count, type, indices, drawcount, basevertex, feedDrawID);
-            break;
-        case GLESMultiDrawMode::DrawElements:
-            drawn = RunRebasedDrawElements(mode, count, type, indices, drawcount, basevertex, feedDrawID);
-            break;
-        case GLESMultiDrawMode::Compute:
-            // Its pre-pass ran above; reaching here means it declined this batch's shape.
-            break;
-        case GLESMultiDrawMode::Auto:
-            break; // resolution never yields Auto
-        }
-
-        // Every tier above may decline a batch whose shape it cannot express. The two
-        // below are the floor: a base-vertex replay where the driver has one, and the
-        // rewritten index stream where it does not. Both are safe for any batch these
-        // entry points can receive.
-        if (!drawn) drawn = RunBaseVertexLoop(mode, count, type, indices, drawcount, basevertex, feedDrawID);
-        if (!drawn) drawn = RunRebasedDrawElements(mode, count, type, indices, drawcount, basevertex, feedDrawID);
-        if (!drawn) {
-            MGLOG_E("DirectGLES multi-draw: no usable tier for a %d sub-draw batch (mode 0x%x, type 0x%x); "
-                    "the batch was dropped",
-                    drawcount, mode, type);
-        }
-    }
-} // namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl

MobileGL/MG_Backend/DirectGLES/MultiDraw.h

@@ -1,64 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectGLES/MultiDraw.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>
-#include <Config.h>
-#include "DirectGLES.h"
-
-// Emulation of the desktop glMultiDrawElements / glMultiDrawElementsBaseVertex entry
-// points on OpenGL ES, which has neither in core.
-//
-// Every strategy below is an emulation; they differ only in which driver capability
-// they lean on and in how many driver entries a batch of N sub-draws costs. The design
-// follows MobileGlues (MobileGL-Dev/MobileGlues, gl/multidraw.cpp) tier for tier, plus
-// the native GL_EXT_multi_draw_arrays interaction that MobileGL already had:
-//
-//   Ext           one glMultiDrawElementsBaseVertexEXT           1 driver entry
-//   MultiIndirect one glMultiDrawElementsIndirectEXT             1 driver entry + 1 upload
-//   Indirect      N x glDrawElementsIndirect                     N + 1 upload
-//   BaseVertex    N x glDrawElementsBaseVertex                   N
-//   DrawElements  N x glDrawElements over CPU-rebased indices    N + 1 upload
-//   Compute       1 x glDrawElements over a GPU-flattened,       1 dispatch + 1 entry
-//                 rebased index stream
-//
-// Which one runs is resolved once per ES context from the driver's capabilities,
-// capped by MOBILEGL_ESPRYT_MULTIDRAW_MODE, and can additionally be demoted per batch
-// when the batch's own shape rules a tier out (see ResolveTierForBatch in the .cpp).
-namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
-    // The tier this ES context resolved to, computed on first use and stable after.
-    MG_Config::GLESMultiDrawMode ResolvedTier();
-    // "multiindirect", "compute", ... - stable identifiers, also used by the POST row.
-    const char* TierName(MG_Config::GLESMultiDrawMode tier);
-    // One line naming the resolved tier, the tiers the driver can support, and the env
-    // clamp if one applied. For DriverPost and the startup log.
-    String DescribeTierResolution();
-
-    // The resolution itself, as a pure function of a capability set: the backend feeds
-    // it the live ES context's capabilities, DriverPost feeds it the ones it probed
-    // standalone, and both therefore report the same tier. `explanation`, when non-null,
-    // receives the "requested -> resolved (driver supports: ...)" line.
-    MG_Config::GLESMultiDrawMode ResolveTier(const MG_External::GLESCapabilities& caps,
-                                             const MG_External::GLESFunctionsTable& funcs,
-                                             MG_Config::GLESMultiDrawMode requested, String* explanation);
-    // Whether one tier is runnable on the given capability set, for per-row POST output.
-    Bool IsTierSupported(const MG_External::GLESCapabilities& caps, const MG_External::GLESFunctionsTable& funcs,
-                         MG_Config::GLESMultiDrawMode tier);
-
-    // Runs `drawcount` indexed sub-draws as one glMultiDrawElements(BaseVertex) call
-    // would. `basevertex` is null for the plain glMultiDrawElements entry point (every
-    // base vertex is 0). Owns the whole draw, preparation included: callers must not
-    // have run PrepareForDraw, because the compute tier has to dispatch before the
-    // draw state is established.
-    void DrawElementsBatch(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                           GLsizei drawcount, const GLint* basevertex);
-
-    // The ES context is gone: every scratch buffer and the compute program belonged to
-    // it, so drop the names without deleting them (the dead context reclaims them).
-    void OnBackendContextDestroyed();
-} // namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl

MobileGL/MG_Backend/DirectGLES/Utils.cpp

@@ -61,6 +61,29 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 requestedInternalFormat, GetDriverPixelFormatNormalizeOptions() | extraOptions);
         }
 
+        // Multisample textures can only ever be rendered into, never uploaded to, so a fallback
+        // format for them has to stay colour-renderable - a three-channel float fallback is a legal
+        // ES texture format but not a legal multisample storage format. Widening to four channels
+        // is safe here precisely because there is no transfer path that would have to expand
+        // three-channel client data, and the alpha the draw writes for a three-channel source is
+        // already the 1.0 the frontend format implies.
+        Bool TargetRequiresRenderableFormat(SizeT targetIndex) {
+            return targetIndex == static_cast<SizeT>(TextureTarget::Texture2DMultisample) ||
+                   targetIndex == static_cast<SizeT>(TextureTarget::Texture2DMultisampleArray);
+        }
+
+        Flags<PixelFormatNormalizeOptionBit> GetRenderTargetNormalizeOptions(SizeT targetIndex) {
+            Flags<PixelFormatNormalizeOptionBit> options;
+            if (!TargetRequiresRenderableFormat(targetIndex)) {
+                return options;
+            }
+            options |= PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget;
+            if (!g_GLESCapabilities.SupportsRenderSnorm || !g_GLESCapabilities.SupportsNorm16Texture) {
+                options |= PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget;
+            }
+            return options;
+        }
+
         Bool HasCachedFormatCapability(TextureInternalFormat internalFormat,
                                        SizeT targetIndex,
                                        Bool caveat,
@@ -118,61 +141,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
             const GLenum requestedInternalFormat = MG_Util::ConvertTextureInternalFormatToGLEnum(internalFormat);
             Flags<PixelFormatNormalizeOptionBit> options;
             if (!pActiveBackendObject || ShouldUseCaveatFormat(internalFormat, targetIndex)) {
-                options = GetRuntimeFallbackNormalizeOptions(
-                    requestedInternalFormat,
-                    TextureImpl::GetRenderTargetNormalizeOptions(g_GLESCapabilities, targetIndex));
+                options = GetRuntimeFallbackNormalizeOptions(requestedInternalFormat,
+                                                             GetRenderTargetNormalizeOptions(targetIndex));
             }
             NormalizePixelFormat(requestedInternalFormat, options, outInternalFormat, outFormat, outType);
         }
     } // namespace
 
     namespace TextureImpl {
-        // Every image that can back a colour attachment needs a colour-renderable storage format,
-        // and ES has no renderable three-channel format at all: a three-channel float fallback is
-        // a legal ES texture but neither legal multisample storage nor a legal attachment, so
-        // GL_RGB8_SNORM / GL_RGB16F / ... have to be widened to four channels for any of them.
-        // This used to cover the multisample pair alone, on the grounds that only those can never
-        // be uploaded to; the transfer paths now expand three-channel client data themselves
-        // (Managers.cpp PrepareFallbackUpload) and hide the added alpha again on sample and
-        // readback, so the same substitution is available everywhere.
-        //
-        // The widening only ever *happens* where the driver refuses the native form (see
-        // PopulateFormatCapabilitiesImpl: outside multisample storage it rides the driver branch,
-        // behind the native probe), so a driver that does render to a three-channel image keeps
-        // allocating it byte for byte.
-        //
-        // Do NOT read that as "nothing changes off-device". Measured on Mesa 26.1.6 llvmpipe
-        // (the headless CI driver), an ES 3.2 GL_TEXTURE_2D colour attachment is COMPLETE for
-        // GL_RGB8 and GL_RGB16F but INCOMPLETE_ATTACHMENT for GL_RGB8_SNORM, GL_SRGB8 and every
-        // RGB integer format, and UNSUPPORTED for GL_RGB32F. Those eight formats therefore DO
-        // take the widened path on llvmpipe, which is where the retrace fixtures and the glcts
-        // green suites run - the substitution is driver-conditional, not desktop-exempt.
-        //
-        // A buffer texture is the one image that can never be an attachment; its storage is the
-        // buffer object's, and widening it would misdescribe the application's data.
-        Bool TargetRequiresRenderableFormat(SizeT targetIndex) {
-            if (targetIndex >= kFormatCapabilityTargetCount) {
-                return false;
-            }
-            if (targetIndex == kFormatCapabilityRenderbufferTargetIndex) {
-                return true;
-            }
-            return static_cast<TextureTarget>(targetIndex) != TextureTarget::TextureBuffer;
-        }
-
-        Flags<PixelFormatNormalizeOptionBit> GetRenderTargetNormalizeOptions(
-            const MG_External::GLESCapabilities& capabilities, SizeT targetIndex) {
-            Flags<PixelFormatNormalizeOptionBit> options;
-            if (!TargetRequiresRenderableFormat(targetIndex)) {
-                return options;
-            }
-            options |= PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget;
-            if (!capabilities.SupportsRenderSnorm || !capabilities.SupportsNorm16Texture) {
-                options |= PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget;
-            }
-            return options;
-        }
-
         void GenerateTextureFormatInfo(TextureInternalFormat internalFormat, GLenum* outInternalFormat,
                                        GLenum* outFormat, GLenum* outType, TextureTarget target) {
 #ifdef TRACY_ENABLE
@@ -202,29 +178,20 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return ShouldUseCaveatFormat(internalFormat, GetRenderbufferFormatCapabilityTargetIndex());
         }
 
-        namespace {
-            Bool BackendFormatAddsAlpha(TextureInternalFormat internalFormat, SizeT targetIndex) {
-                if (!TargetRequiresRenderableFormat(targetIndex)) {
-                    return false;
-                }
-                if (pActiveBackendObject && !ShouldUseCaveatFormat(internalFormat, targetIndex)) {
-                    return false;
-                }
-                const GLenum requestedInternalFormat = MG_Util::ConvertTextureInternalFormatToGLEnum(internalFormat);
-                const Flags<PixelFormatNormalizeOptionBit> options = GetRuntimeFallbackNormalizeOptions(
-                    requestedInternalFormat, GetRenderTargetNormalizeOptions(g_GLESCapabilities, targetIndex));
-                return static_cast<Bool>(options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget);
-            }
-        } // namespace
-
         Bool BackendTextureFormatAddsAlpha(TextureInternalFormat internalFormat, TextureTarget target) {
             const SizeT targetIndex =
                 target == TextureTarget::Unknown ? kFormatCapabilityTargetCount : GetFormatCapabilityTargetIndex(target);
-            return BackendFormatAddsAlpha(internalFormat, targetIndex);
-        }
-
-        Bool BackendRenderbufferFormatAddsAlpha(TextureInternalFormat internalFormat) {
-            return BackendFormatAddsAlpha(internalFormat, GetRenderbufferFormatCapabilityTargetIndex());
+            if (!TargetRequiresRenderableFormat(targetIndex)) {
+                return false;
+            }
+            if (pActiveBackendObject && !ShouldUseCaveatFormat(internalFormat, targetIndex)) {
+                return false;
+            }
+            const GLenum requestedInternalFormat = MG_Util::ConvertTextureInternalFormatToGLEnum(internalFormat);
+            const Flags<PixelFormatNormalizeOptionBit> options =
+                GetRuntimeFallbackNormalizeOptions(requestedInternalFormat,
+                                                   GetRenderTargetNormalizeOptions(targetIndex));
+            return static_cast<Bool>(options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget);
         }
     } // namespace TextureImpl
     namespace PrgramImpl {
@@ -1140,11 +1107,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
             }
         }
-            if (pixelPackBufferObject) {
-                // WritebackFromBackend bumps change serials with no backend op; re-open
-                // the buffer draw-clean memos (once for the whole row loop).
-                BufferImpl::BumpBufferMutationEpoch();
-            }
             return true;
         }
     } // namespace ReadbackImpl

MobileGL/MG_Backend/DirectGLES/Utils.h

@@ -9,8 +9,6 @@
 #pragma once
 #include <Includes.h>
 #include <MG_State/GLState/Core.h>
-#include <MG_Util/BackendLoaders/OpenGL/Loader.h>
-#include <MG_Util/Texture/TextureFormatProcessor.h>
 
 namespace MobileGL::MG_Backend::DirectGLES {
     namespace DebugImpl {
@@ -36,16 +34,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
     } // namespace VertexArrayImpl
 
     namespace TextureImpl {
-        // Whether images on this format-capability target can back a colour attachment, and so
-        // need a colour-renderable storage format even when the frontend asked for a
-        // three-channel one ES never renders to. Shared by the capability probe (which passes the
-        // capabilities it has just queried, before the globals are published) and by the
-        // allocation path (which reads the active backend's), so the format the cache was probed
-        // with is always the format the image is created with.
-        Bool TargetRequiresRenderableFormat(SizeT targetIndex);
-        Flags<PixelFormatNormalizeOptionBit> GetRenderTargetNormalizeOptions(
-            const MG_External::GLESCapabilities& capabilities, SizeT targetIndex);
-
         void GenerateTextureFormatInfo(TextureInternalFormat internalFormat, GLenum* outInternalFormat,
                                        GLenum* outFormat, GLenum* outType,
                                        TextureTarget target = TextureTarget::Unknown);
@@ -53,12 +41,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                             GLenum* outFormat, GLenum* outType);
         Bool ShouldUseCaveatTextureFormat(TextureInternalFormat internalFormat, TextureTarget target);
 
-        // True when the format the image is actually created with has an alpha channel the
-        // frontend format does not (the three-channel colour-renderable widening). GL reads such
-        // a channel back as 1.0, so any swizzle source of ALPHA has to be answered with ONE and
-        // any readback of the image has to overwrite the alpha the draw happened to leave there.
+        // True when the format the texture is actually created with has an alpha channel the
+        // frontend format does not (the three-channel multisample widening). GL reads such a
+        // channel back as 1.0, so any swizzle source of ALPHA has to be answered with ONE.
         Bool BackendTextureFormatAddsAlpha(TextureInternalFormat internalFormat, TextureTarget target);
-        Bool BackendRenderbufferFormatAddsAlpha(TextureInternalFormat internalFormat);
         Bool ShouldUseCaveatRenderbufferFormat(TextureInternalFormat internalFormat);
     } // namespace TextureImpl
 

MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.cpp

@@ -16,7 +16,6 @@
 #include "MG_Util/Converters/MGToStr/TextureEnumConverter.h"
 #include "MG_Util/Converters/MGToVk/TextureEnumConverter.h"
 #include "MG_Util/Texture/TextureFormatProcessor.h"
-#include "MG_Util/Async/ShaderCompilePool.h"
 
 #include <Config.h>
 #include <cmath>
@@ -42,11 +41,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Bool IsLayeredTarget(TextureTarget target) {
             return target == TextureTarget::Texture3D || target == TextureTarget::Texture1DArray ||
                    target == TextureTarget::Texture2DArray || target == TextureTarget::TextureCubeMap ||
-                   target == TextureTarget::TextureCubeMapArray || target == TextureTarget::Texture2DMultisampleArray;
+                   target == TextureTarget::TextureCubeMapArray ||
+                   target == TextureTarget::Texture2DMultisampleArray;
         }
 
         Bool IsMultisampleTarget(TextureTarget target) {
-            return target == TextureTarget::Texture2DMultisample || target == TextureTarget::Texture2DMultisampleArray;
+            return target == TextureTarget::Texture2DMultisample ||
+                   target == TextureTarget::Texture2DMultisampleArray;
         }
 
         Bool IsTextureBufferTarget(TextureTarget target) {
@@ -58,8 +59,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             GLenum normalizedInternalFormat = glFormat;
             GLenum imageFormat = GL_RGBA;
             GLenum imageType = GL_UNSIGNED_BYTE;
-            MG_Util::TextureFormatProcessor::NormalizePixelFormat(glFormat, PixelFormatNormalizeOptionBit::None,
-                                                                  &normalizedInternalFormat, &imageFormat, &imageType);
+            MG_Util::TextureFormatProcessor::NormalizePixelFormat(
+                glFormat, PixelFormatNormalizeOptionBit::None, &normalizedInternalFormat, &imageFormat, &imageType);
             return imageFormat == GL_RED_INTEGER || imageFormat == GL_RG_INTEGER || imageFormat == GL_RGB_INTEGER ||
                    imageFormat == GL_RGBA_INTEGER;
         }
@@ -80,7 +81,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return caps;
         }
 
-        FormatCapabilityFlags BuildVulkanCaps(TextureInternalFormat logicalFormat, TextureTarget target,
+        FormatCapabilityFlags BuildVulkanCaps(TextureInternalFormat logicalFormat,
+                                              TextureTarget target,
                                               VkFormatFeatureFlags features) {
             FormatCapabilityFlags caps;
             const Bool isDepth = MG_Util::IsDepthFormatInternalFormat(logicalFormat);
@@ -99,7 +101,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             const Bool sampled = (features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0;
             const Bool linearFilter = (features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT) != 0;
             const Bool colorRenderable = (features & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) != 0;
-            const Bool depthStencilRenderable = (features & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0;
+            const Bool depthStencilRenderable =
+                (features & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0;
             const Bool renderable = (isDepth || isStencil) ? depthStencilRenderable : colorRenderable;
 
             if (sampled || renderable) {
@@ -196,20 +199,21 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         Bool HasNewCaveatFormatCaps(FormatCapabilityFlags nativeCaps, FormatCapabilityFlags fallbackCaps) {
             for (FormatCapability capability : kReportedFormatCapabilities) {
-                if (HasFormatCapability(fallbackCaps, capability) && !HasFormatCapability(nativeCaps, capability)) {
+                if (HasFormatCapability(fallbackCaps, capability) &&
+                    !HasFormatCapability(nativeCaps, capability)) {
                     return true;
                 }
             }
             return false;
         }
 
-        void LogVulkanFormatCaveat(TextureInternalFormat logicalFormat, SizeT targetIndex,
+        void LogVulkanFormatCaveat(TextureInternalFormat logicalFormat,
+                                   SizeT targetIndex,
                                    TextureInternalFormat fallbackFormat) {
-            MGLOG_D(
-                "Caveat: %s %s not fully supported. Reason: native Vulkan format is not fully supported. Fallback: %s",
-                GetFormatCapabilityTargetName(targetIndex).c_str(),
-                MG_Util::ConvertTextureInternalFormatToString(logicalFormat).c_str(),
-                MG_Util::ConvertTextureInternalFormatToString(fallbackFormat).c_str());
+            MGLOG_D("Caveat: %s %s not fully supported. Reason: native Vulkan format is not fully supported. Fallback: %s",
+                    GetFormatCapabilityTargetName(targetIndex).c_str(),
+                    MG_Util::ConvertTextureInternalFormatToString(logicalFormat).c_str(),
+                    MG_Util::ConvertTextureInternalFormatToString(fallbackFormat).c_str());
         }
 
         Vector<Int> BuildSampleCounts(Int maxSamples) {
@@ -253,15 +257,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
                 for (SizeT targetIndex = 0; targetIndex < kFormatCapabilityTextureTargetCount; ++targetIndex) {
                     const auto target = static_cast<TextureTarget>(targetIndex);
-                    const VkFormatFeatureFlags nativeFeatures = IsTextureBufferTarget(target)
-                                                                    ? nativeProperties.bufferFeatures
-                                                                    : nativeProperties.optimalTilingFeatures;
+                    const VkFormatFeatureFlags nativeFeatures =
+                        IsTextureBufferTarget(target) ? nativeProperties.bufferFeatures
+                                                      : nativeProperties.optimalTilingFeatures;
                     FormatCapabilityFlags nativeCaps = BuildVulkanCaps(logicalFormat, target, nativeFeatures);
                     cache.FullCaps[targetIndex][formatIndex] |= nativeCaps;
 
-                    const VkFormatFeatureFlags fallbackFeatures = IsTextureBufferTarget(target)
-                                                                      ? fallbackProperties.bufferFeatures
-                                                                      : fallbackProperties.optimalTilingFeatures;
+                    const VkFormatFeatureFlags fallbackFeatures =
+                        IsTextureBufferTarget(target) ? fallbackProperties.bufferFeatures
+                                                      : fallbackProperties.optimalTilingFeatures;
                     FormatCapabilityFlags fallbackCaps = BuildVulkanCaps(logicalFormat, target, fallbackFeatures);
                     if (fallbackFormat != VK_FORMAT_UNDEFINED && fallbackFormat != nativeFormat) {
                         cache.CaveatCaps[targetIndex][formatIndex] |= fallbackCaps;
@@ -296,8 +300,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 cache.FullCaps[renderbufferTargetIndex][formatIndex] |= renderbufferCaps;
 
                 if (fallbackFormat != VK_FORMAT_UNDEFINED && fallbackFormat != nativeFormat) {
-                    FormatCapabilityFlags fallbackRenderbufferCaps = BuildVulkanCaps(
-                        logicalFormat, TextureTarget::Texture2D, fallbackProperties.optimalTilingFeatures);
+                    FormatCapabilityFlags fallbackRenderbufferCaps =
+                        BuildVulkanCaps(logicalFormat, TextureTarget::Texture2D,
+                                        fallbackProperties.optimalTilingFeatures);
                     fallbackRenderbufferCaps &= FormatCapability::Creatable;
                     if ((fallbackProperties.optimalTilingFeatures &
                          (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) !=
@@ -306,7 +311,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         fallbackRenderbufferCaps |= FormatCapability::MultisampleRenderbuffer;
                     }
                     cache.CaveatCaps[renderbufferTargetIndex][formatIndex] |= fallbackRenderbufferCaps;
-                    if (fallbackLogicalFormat && HasNewCaveatFormatCaps(renderbufferCaps, fallbackRenderbufferCaps)) {
+                    if (fallbackLogicalFormat &&
+                        HasNewCaveatFormatCaps(renderbufferCaps, fallbackRenderbufferCaps)) {
                         LogVulkanFormatCaveat(logicalFormat, renderbufferTargetIndex, *fallbackLogicalFormat);
                     }
                 }
@@ -323,13 +329,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     void PopulateFormatCapabilities(VkPhysicalDevice physicalDevice,
                                     PFN_vkGetPhysicalDeviceFormatProperties getFormatProperties,
-                                    const MG_External::VulkanCapabilities& capabilities, FormatCapabilityCache& cache) {
+                                    const MG_External::VulkanCapabilities& capabilities,
+                                    FormatCapabilityCache& cache) {
         PopulateFormatCapabilitiesImpl(physicalDevice, getFormatProperties, capabilities, cache);
     }
 
     BackendObject_DirectVulkan::~BackendObject_DirectVulkan() = default;
 
-    BackendObject_DirectVulkan::BackendObject_DirectVulkan() : m_rendererInfo{GetRendererIdentity()} {}
+    BackendObject_DirectVulkan::BackendObject_DirectVulkan(): m_rendererInfo{GetRendererIdentity()} {}
 
     Bool BackendObject_DirectVulkan::InitWindowSurface() {
         if (!m_windowHandle.Handle) {
@@ -403,8 +410,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             MGLOG_E("DirectVulkan backend not initialized");
             return false;
         }
-        if (!handle.Handle || (handle.Backend != WindowBackend::Android && handle.Backend != WindowBackend::X11 &&
-                               handle.Backend != WindowBackend::MetalLayer && handle.Backend != WindowBackend::Win32)) {
+        if (!handle.Handle || (handle.Backend != WindowBackend::Android &&
+                               handle.Backend != WindowBackend::X11 &&
+                               handle.Backend != WindowBackend::MetalLayer &&
+                               handle.Backend != WindowBackend::Win32)) {
             MGLOG_E("DirectVulkan backend only supports Android, X11, CAMetalLayer, and Win32 native windows");
             return false;
         }
@@ -495,50 +504,40 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             .RendererName = "Magma",
             .BackendName = "Direct (Vulkan)",
             .ExtraVendor = Nullopt,
-            .RendererGLInfo = {.TargetGLVersion = {4, 0, 0},
-                               .TargetGLSLVersion = {4, 6, 0},
-                               // Baseline advertisement (no shader subgroup, no timer queries); a
-                               // live backend reconciles its copy in UpdateAdvertisedExtensions.
-                               .Extensions = BuildAdvertisedExtensions(false, false, false),
-                               .IsCompatibilityProfile = false},
+            .RendererGLInfo =
+                {
+                    .TargetGLVersion = {3, 3, 0},
+                    .TargetGLSLVersion = {4, 6, 0},
+                    // Baseline advertisement (no shader subgroup, no timer queries); a
+                    // live backend reconciles its copy in UpdateAdvertisedExtensions.
+                    .Extensions = BuildAdvertisedExtensions(false, false, false),
+                    .IsCompatibilityProfile = false
+                },
             .StaticBackendCapability = {.AllowVSOnlyPrograms = false}};
         return rendererInfo;
     }
 
     Vector<GLExtension> BuildAdvertisedExtensions(Bool shaderSubgroupSupported, Bool timerQueriesSupported,
                                                   Bool anisotropicFilteringSupported) {
-        Vector<GLExtension> extensions = {
-            V_OpenGL30, V_OpenGL31, V_OpenGL32, V_OpenGL33, V_OpenGL40, E_GL_ARB_draw_buffers_blend,
-            E_GL_ARB_compute_shader, E_GL_ARB_shader_storage_buffer_object, E_GL_ARB_shader_image_load_store,
-            E_GL_ARB_program_interface_query, E_GL_ARB_framebuffer_object, E_GL_ARB_multi_draw_indirect,
-            E_GL_ARB_indirect_parameters, E_GL_EXT_framebuffer_object, E_GL_ARB_depth_texture, E_GL_ARB_buffer_storage,
-            E_GL_ARB_texture_storage, E_GL_ARB_texture_storage_multisample, E_GL_ARB_texture_multisample,
-            E_GL_ARB_clear_texture, E_GL_ARB_direct_state_access, E_GL_ARB_shader_draw_parameters,
-            E_GL_ARB_gpu_shader_int64, E_GL_KHR_debug, E_GL_ARB_gpu_shader5, E_GL_ARB_multi_bind,
-            E_GL_ARB_shading_language_420pack, E_GL_ARB_vertex_attrib_binding, E_GL_ARB_shader_image_size,
-            E_GL_ARB_explicit_attrib_location,
-            // Advertised with GL_NUM_PROGRAM_BINARY_FORMATS = 0, which the
-            // extension explicitly permits. It is also the only thing that
-            // exposes glProgramParameteri before GL 4.1.
-            E_GL_ARB_get_program_binary};
+        Vector<GLExtension> extensions = {V_OpenGL30, V_OpenGL31, V_OpenGL32,
+                                          V_OpenGL33, E_GL_ARB_draw_buffers_blend, E_GL_ARB_compute_shader,
+                                          E_GL_ARB_shader_storage_buffer_object, E_GL_ARB_shader_image_load_store,
+                                          E_GL_ARB_program_interface_query, E_GL_ARB_framebuffer_object,
+                                          E_GL_ARB_multi_draw_indirect, E_GL_ARB_indirect_parameters,
+                                          E_GL_EXT_framebuffer_object, E_GL_ARB_depth_texture, E_GL_ARB_buffer_storage,
+                                          E_GL_ARB_texture_storage, E_GL_ARB_texture_storage_multisample,
+                                          E_GL_ARB_texture_multisample, E_GL_ARB_clear_texture, E_GL_ARB_direct_state_access,
+                                          E_GL_ARB_shader_draw_parameters, E_GL_ARB_gpu_shader_int64, E_GL_KHR_debug,
+                                          E_GL_ARB_gpu_shader5, E_GL_ARB_multi_bind, E_GL_ARB_shading_language_420pack,
+                                          E_GL_ARB_vertex_attrib_binding, E_GL_ARB_shader_image_size,
+                                          E_GL_ARB_explicit_attrib_location,
+                                          // Advertised with GL_NUM_PROGRAM_BINARY_FORMATS = 0, which the
+                                          // extension explicitly permits. It is also the only thing that
+                                          // exposes glProgramParameteri before GL 4.1.
+                                          E_GL_ARB_get_program_binary};
         if (shaderSubgroupSupported && !MG_Config::Features.DisableSubgroup) {
             extensions.push_back(E_GL_KHR_shader_subgroup);
         }
-        // GL_KHR_parallel_shader_compile is MobileGL's own capability, not the Vulkan
-        // device's: the compiler threads belong to MobileGL's shader pool and
-        // glCompileShader/glLinkProgram are serviced entirely inside the frontend, so there
-        // is no device feature to condition this on.
-        //
-        // Gated on the async flag deliberately, and this is the whole reason the gate
-        // exists. Advertising the string is the one part of asynchronous compilation that a
-        // recorded trace can never cover: Iris and Sodium change their SUBMISSION SCHEDULE
-        // the moment they see it - they enqueue whole pipeline batches and poll
-        // GL_COMPLETION_STATUS_KHR instead of compiling one program at a time - so
-        // MOBILEGL_ASYNC_SHADER_COMPILE=0 has to withdraw the application-visible behaviour
-        // change as well as the threading, or the kill switch would only be half a switch.
-        if (MG_Util::Async::AsyncShaderCompileEnabled()) {
-            extensions.push_back(E_GL_KHR_parallel_shader_compile);
-        }
         // GL_ARB_timer_query gates MC's F3 GPU% (LWJGL checks the extension string);
         // only advertised when the device actually supports timestamp queries and the
         // MOBILEGL_DISABLE_TIMERQUERY escape hatch is off.
@@ -598,8 +597,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             funcsTable.GL.ClearBufferiv = ClearBufferiv;
             funcsTable.GL.ClearNamedFramebufferfv = ClearNamedFramebufferfv;
             funcsTable.GL.ClearNamedFramebufferfi = ClearNamedFramebufferfi;
-            funcsTable.GL.ClearNamedFramebufferiv = ClearNamedFramebufferiv;
-            funcsTable.GL.ClearNamedFramebufferuiv = ClearNamedFramebufferuiv;
             funcsTable.GL.BlitFramebuffer = BlitFramebuffer;
             funcsTable.GL.BlitNamedFramebuffer = BlitNamedFramebuffer;
             funcsTable.GL.CopyTexImage2D = CopyTexImage2D;
@@ -617,6 +614,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             funcsTable.GL.GetIntegeri_v = GetIntegeri_v;
             funcsTable.GL.GetInteger64i_v = GetInteger64i_v;
             funcsTable.GL.GetProgramiv = GetProgramiv;
+            funcsTable.GL.GetProgramInterfaceiv = GetProgramInterfaceiv;
+            funcsTable.GL.GetProgramResourceIndex = GetProgramResourceIndex;
+            funcsTable.GL.GetProgramResourceName = GetProgramResourceName;
+            funcsTable.GL.GetProgramResourceiv = GetProgramResourceiv;
+            funcsTable.GL.GetProgramResourceLocation = GetProgramResourceLocation;
+            funcsTable.GL.GetProgramResourceLocationIndex = GetProgramResourceLocationIndex;
             funcsTable.GL.ShaderStorageBlockBinding = ShaderStorageBlockBinding;
             funcsTable.GL.FenceSync = FenceSync;
             funcsTable.GL.ClientWaitSync = ClientWaitSync;
@@ -726,7 +729,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // rather than a maximum the sampler manager will never apply.
         m_dynamicParameters.MaxTextureMaxAnisotropy =
             (pVulkanRenderer && pVulkanRenderer->IsSamplerAnisotropySupported()) ? m_vulkanCaps.MaxSamplerAnisotropy
-                                                                                 : 1.0f;
+                                                                                : 1.0f;
         m_dynamicParameters.SmoothLineWidthRangeMin = m_vulkanCaps.SmoothLineWidthRangeMin;
         m_dynamicParameters.SmoothLineWidthRangeMax = m_vulkanCaps.SmoothLineWidthRangeMax;
         m_dynamicParameters.SmoothLineWidthGranularity = m_vulkanCaps.SmoothLineWidthGranularity;
@@ -747,7 +750,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_dynamicParameters.MaxIntegerSamples = m_vulkanCaps.MaxIntegerSamples;
         m_dynamicParameters.MaxSamples = m_vulkanCaps.MaxSamples;
         m_dynamicParameters.MaxSampleMaskWords = m_vulkanCaps.MaxSampleMaskWords;
-        const Int maxSupportedTextureUnits = static_cast<Int>(MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS);
+        const Int maxSupportedTextureUnits =
+            static_cast<Int>(MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS);
         // GL_MAX_TEXTURE_IMAGE_UNITS is a *per-stage* sampler limit. Adreno/Qualcomm report a huge
         // maxPerStageDescriptorSampledImages (descriptor-indexing scale), so clamping it only to our
         // combined array capacity (192) still advertises 192 per stage. Host code treats this value as
@@ -757,7 +761,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // limits while keeping the combined limit at our texture-unit array capacity.
         constexpr Int maxPerStageTextureUnits =
             static_cast<Int>(MG_State::GLState::TextureState::MAX_PER_STAGE_TEXTURE_IMAGE_UNITS);
-        m_dynamicParameters.MaxTextureImageUnits = std::min(m_vulkanCaps.MaxTextureImageUnits, maxPerStageTextureUnits);
+        m_dynamicParameters.MaxTextureImageUnits =
+            std::min(m_vulkanCaps.MaxTextureImageUnits, maxPerStageTextureUnits);
         m_dynamicParameters.MaxVertexTextureImageUnits =
             std::min(m_vulkanCaps.MaxVertexTextureImageUnits, maxPerStageTextureUnits);
         m_dynamicParameters.MaxComputeTextureImageUnits =
@@ -766,8 +771,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             std::min(m_vulkanCaps.MaxCombinedTextureImageUnits, maxSupportedTextureUnits);
         // Never advertise more attributes than the state layer can store: the current-value array and
         // the Uint32 attribute masks the draw path passes around are both bounded by MAX_VERTEX_ATTRIBS.
-        m_dynamicParameters.MaxVertexAttribs = std::min(
-            m_vulkanCaps.MaxVertexAttribs, static_cast<Int>(MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS));
+        m_dynamicParameters.MaxVertexAttribs =
+            std::min(m_vulkanCaps.MaxVertexAttribs,
+                     static_cast<Int>(MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS));
         m_dynamicParameters.MaxComputeShaderStorageBlocks = m_vulkanCaps.MaxComputeShaderStorageBlocks;
         m_dynamicParameters.MaxCombinedShaderStorageBlocks = m_vulkanCaps.MaxCombinedShaderStorageBlocks;
         m_dynamicParameters.MaxComputeUniformBlocks = m_vulkanCaps.MaxComputeUniformBlocks;
@@ -777,7 +783,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_dynamicParameters.TextureBufferOffsetAlignment = m_vulkanCaps.TextureBufferOffsetAlignment;
         m_dynamicParameters.MaxUniformBufferBindings = m_vulkanCaps.MaxUniformBufferBindings;
         m_dynamicParameters.MaxUniformBlockSize = m_vulkanCaps.MaxUniformBlockSize;
-        m_dynamicParameters.MaxImageUnits = std::max(std::min(m_vulkanCaps.MaxImageUnits, maxSupportedTextureUnits), 0);
+        m_dynamicParameters.MaxImageUnits =
+            std::max(std::min(m_vulkanCaps.MaxImageUnits, maxSupportedTextureUnits), 0);
         m_dynamicParameters.MaxCombinedImageUniforms = std::max(m_vulkanCaps.MaxCombinedImageUniforms, 0);
         const Int maxPerStageImageUniforms =
             std::min(m_dynamicParameters.MaxImageUnits, m_dynamicParameters.MaxCombinedImageUniforms);
@@ -794,7 +801,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_vulkanCaps.SupportsFragmentStoresAndAtomics ? maxPerStageImageUniforms : 0;
         m_dynamicParameters.MaxComputeImageUniforms =
             std::min(std::max(m_vulkanCaps.MaxComputeImageUniforms, 0), maxPerStageImageUniforms);
-        const Int maxSupportedDrawBuffers = static_cast<Int>(MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS);
+        const Int maxSupportedDrawBuffers =
+            static_cast<Int>(MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS);
         m_dynamicParameters.MaxDrawBuffers = std::min(m_vulkanCaps.MaxDrawBuffers, maxSupportedDrawBuffers);
         m_dynamicParameters.MaxColorAttachments = std::min(m_vulkanCaps.MaxColorAttachments, maxSupportedDrawBuffers);
         m_dynamicParameters.MaxClipDistances = m_vulkanCaps.MaxClipDistances;
@@ -813,44 +821,21 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_dynamicParameters.FragmentInterpolationOffsetBits = 4;
         if (m_vulkanCaps.FragmentInterpolationOffsetBits >= 4 &&
             std::isfinite(m_vulkanCaps.MaxFragmentInterpolationOffset)) {
-            const Float requiredMaxOffset = 0.5f - std::ldexp(1.0f, -m_vulkanCaps.FragmentInterpolationOffsetBits);
+            const Float requiredMaxOffset =
+                0.5f - std::ldexp(1.0f, -m_vulkanCaps.FragmentInterpolationOffsetBits);
             if (m_vulkanCaps.MaxFragmentInterpolationOffset >= requiredMaxOffset) {
                 m_dynamicParameters.MaxFragmentInterpolationOffset = m_vulkanCaps.MaxFragmentInterpolationOffset;
-                m_dynamicParameters.FragmentInterpolationOffsetBits = m_vulkanCaps.FragmentInterpolationOffsetBits;
+                m_dynamicParameters.FragmentInterpolationOffsetBits =
+                    m_vulkanCaps.FragmentInterpolationOffsetBits;
             }
         }
         m_dynamicParameters.SupportsWideLines = m_vulkanCaps.SupportsWideLines;
-        // A 2D or 2D multisample array texture is a VK_IMAGE_TYPE_2D image whose GL depth IS its
-        // arrayLayers, so a GL layer is a Vulkan array layer with nothing to translate.
-        // ResolveAttachmentBaseArrayLayer already passes the attachment's layer through. The other
-        // layered targets are declared separately as their own machinery lands.
-        {
-            using DynParams = MG_Backend::DynamicBackendParameters;
-            m_dynamicParameters.PerLayerFramebufferAttachmentTargets |=
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture2DArray) |
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture2DMultisampleArray);
-            // A cube map array is one 2D image with arrayLayers = 6 * cubeCount, so a GL layer is a
-            // Vulkan array layer here too - but the image cannot be created without imageCubeArray.
-            // A 3D texture's GL layer is a z slice, which only a 2D view over a 2D-array-compatible
-            // image can name. Optimistic: a format that refuses the flag is caught at image creation
-            // and declines the slice view there, which the clear path handles as a soft miss.
-            if (m_vulkanCaps.Supports2DArrayCompatible3DImages) {
-                m_dynamicParameters.PerLayerFramebufferAttachmentTargets |=
-                    DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture3D);
-            }
-            if (m_vulkanCaps.SupportsImageCubeArray) {
-                m_dynamicParameters.PerLayerFramebufferAttachmentTargets |=
-                    DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::TextureCubeMapArray);
-            }
-        }
-        m_dynamicParameters.SupportsFloat64VertexAttributes = m_vulkanCaps.SupportsShaderFloat64;
         m_dynamicParameters.MaxShaderStorageBlockSize =
             std::min(m_vulkanCaps.MaxShaderStorageBlockSize, kMaxAdvertisedShaderStorageBlockSize);
         if (m_vulkanCaps.SupportsShaderSubgroup) {
             m_dynamicParameters.SubgroupSize = m_vulkanCaps.SubgroupSize;
             m_dynamicParameters.SubgroupSupportedStages = mapShaderStages(m_vulkanCaps.SubgroupSupportedStages);
-            m_dynamicParameters.SubgroupSupportedFeatures =
-                mapSubgroupFeatures(m_vulkanCaps.SubgroupSupportedOperations);
+            m_dynamicParameters.SubgroupSupportedFeatures = mapSubgroupFeatures(m_vulkanCaps.SubgroupSupportedOperations);
             m_dynamicParameters.SubgroupQuadOperationsInAllStages = m_vulkanCaps.SubgroupQuadOperationsInAllStages;
         } else {
             m_dynamicParameters.SubgroupSize = 0;
@@ -860,7 +845,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
         if (m_dynamicParameters.MaxShaderStorageBlockSize != m_vulkanCaps.MaxShaderStorageBlockSize) {
             MGLOG_I("DirectVulkan: clamped GL_MAX_SHADER_STORAGE_BLOCK_SIZE from %zu to %zu",
-                    m_vulkanCaps.MaxShaderStorageBlockSize, m_dynamicParameters.MaxShaderStorageBlockSize);
+                    m_vulkanCaps.MaxShaderStorageBlockSize,
+                    m_dynamicParameters.MaxShaderStorageBlockSize);
         }
         switch (m_vulkanCaps.VendorId) {
         case 0x5143u: // VK_VENDOR_ID: Qualcomm

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.cpp

@@ -16,7 +16,6 @@
 #include "MG_Util/Metrics/TextureMetrics.h"
 #include "MG_Util/Miscellany/IndexGenerator.h"
 #include <atomic>
-#include <bit>
 #include <cstring>
 #include <spirv_reflect.h>
 
@@ -232,13 +231,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     StorageBlockResource block{};
                     block.name = blockName;
                     block.binding = binding->binding;
-                    // glShaderStorageBlockBinding survives every rebuild of this cache: the
-                    // authoritative record of a rebound block lives on the program (it is what
-                    // GL_BUFFER_BINDING reports), and only the shader's declared binding is
-                    // recoverable from the SPIR-V. Without this, any unrelated state-version
-                    // bump would silently revert the block to its declared binding.
-                    const Int rebound = program.GetShaderStorageBlockBindingOverride(blockName);
-                    if (rebound >= 0) block.binding = static_cast<Uint32>(rebound);
                     block.dataSize = static_cast<GLint>(binding->block.size);
                     const GLuint blockIndex = static_cast<GLuint>(cache.storageBlocks.size());
                     AddBufferVariablesRecursive(binding->block, blockName, blockIndex, cache.bufferVariables,
@@ -263,6 +255,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return programObject.get();
         }
 
+        void CopyResourceName(const String& source, GLsizei bufSize, GLsizei* length, GLchar* name) {
+            const GLsizei writtenLength = static_cast<GLsizei>(source.size());
+            if (length) {
+                *length = writtenLength;
+            }
+            if (name && bufSize > 0) {
+                const GLsizei copyLength = std::min<GLsizei>(bufSize - 1, writtenLength);
+                std::memcpy(name, source.data(), static_cast<SizeT>(copyLength));
+                name[copyLength] = '\0';
+            }
+        }
+
         const Uint8* ResolveIndirectCommandBytes(const void* indirect, SizeT requiredBytes, const char* label) {
             auto drawBuffer = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
             if (drawBuffer) {
@@ -283,6 +287,100 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return reinterpret_cast<const Uint8*>(indirect);
         }
 
+        Vector<GLuint> GetUniformBlockActiveVariables(const MG_State::GLState::ProgramObject& program,
+                                                      GLuint blockIndex) {
+            Vector<GLuint> activeVariables;
+            const Uint uniformCount = program.GetUniformCount();
+            activeVariables.reserve(uniformCount);
+            for (Uint uniformIndex = 0; uniformIndex < uniformCount; ++uniformIndex) {
+                if (program.GetActiveUniformBlockIndex(uniformIndex) == static_cast<Int>(blockIndex)) {
+                    activeVariables.push_back(uniformIndex);
+                }
+            }
+            return activeVariables;
+        }
+
+        GLuint FindProgramInputIndex(const MG_State::GLState::ProgramObject& program, const String& name) {
+            const Int activeCount = program.GetActiveAttributesCount();
+            for (Int index = 0; index < activeCount; ++index) {
+                if (program.GetActiveAttribName(index) == name) {
+                    return static_cast<GLuint>(index);
+                }
+            }
+            return GL_INVALID_INDEX;
+        }
+
+        GLuint FindProgramOutputIndex(const MG_State::GLState::ProgramObject& program, const String& name) {
+            const Int activeCount = program.GetActiveFragmentOutputCount();
+            for (Int index = 0; index < activeCount; ++index) {
+                if (program.GetActiveFragmentOutputName(index) == name) {
+                    return static_cast<GLuint>(index);
+                }
+            }
+            return GL_INVALID_INDEX;
+        }
+
+        GLint GetProgramOutputLocation(const MG_State::GLState::ProgramObject& program, const String& name) {
+            const Int activeCount = program.GetActiveFragmentOutputCount();
+            for (Int index = 0; index < activeCount; ++index) {
+                if (program.GetActiveFragmentOutputName(index) == name) {
+                    return program.GetFragmentOutputLocation(index);
+                }
+            }
+            return -1;
+        }
+
+        GLint GetProgramResourceActiveCount(const MG_State::GLState::ProgramObject& program, GLenum programInterface,
+                                            const ProgramResourceCache& cache) {
+            switch (programInterface) {
+            case GL_SHADER_STORAGE_BLOCK:
+                return static_cast<GLint>(cache.storageBlocks.size());
+            case GL_BUFFER_VARIABLE:
+                return static_cast<GLint>(cache.bufferVariables.size());
+            case GL_UNIFORM_BLOCK:
+                return program.GetActiveUniformBlocksCount();
+            case GL_UNIFORM:
+                return static_cast<GLint>(program.GetUniformCount());
+            case GL_PROGRAM_INPUT:
+                return program.GetActiveAttributesCount();
+            case GL_PROGRAM_OUTPUT:
+                return program.GetActiveFragmentOutputCount();
+            default:
+                return 0;
+            }
+        }
+
+        GLint GetProgramResourceMaxNameLength(const MG_State::GLState::ProgramObject& program, GLenum programInterface,
+                                              const ProgramResourceCache& cache) {
+            switch (programInterface) {
+            case GL_SHADER_STORAGE_BLOCK: {
+                SizeT maxLength = 0;
+                for (const auto& block : cache.storageBlocks) maxLength = std::max(maxLength, block.name.size() + 1);
+                return static_cast<GLint>(maxLength);
+            }
+            case GL_BUFFER_VARIABLE: {
+                SizeT maxLength = 0;
+                for (const auto& var : cache.bufferVariables) maxLength = std::max(maxLength, var.name.size() + 1);
+                return static_cast<GLint>(maxLength);
+            }
+            case GL_UNIFORM_BLOCK:
+                return program.GetActiveUniformBlocksMaxNameLength() + 1;
+            case GL_UNIFORM:
+                return program.GetUniformMaxLength() + 1;
+            case GL_PROGRAM_INPUT:
+                return program.GetActiveAttributesMaxLength() + 1;
+            case GL_PROGRAM_OUTPUT: {
+                SizeT maxLength = 0;
+                const Int activeCount = program.GetActiveFragmentOutputCount();
+                for (Int index = 0; index < activeCount; ++index) {
+                    maxLength = std::max(maxLength, program.GetActiveFragmentOutputName(index).size() + 1);
+                }
+                return static_cast<GLint>(maxLength);
+            }
+            default:
+                return 0;
+            }
+        }
     } // namespace
 
     void ClearProgramResourceCaches() {
@@ -296,21 +394,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     GLuint GetShaderStorageBlockIndex(const MG_State::GLState::ProgramObject& program, const String& name) {
         auto& cache = GetProgramResourceCache(program);
-        auto find = [&cache](const String& key) {
-            return std::find_if(cache.storageBlocks.begin(), cache.storageBlocks.end(),
-                [&](const StorageBlockResource& block) { return block.name == key; });
-        };
-        auto it = find(name);
-        if (it == cache.storageBlocks.end()) {
-            // Cache names are normalized (NormalizeDescriptorName drops the array suffix), so
-            // an arrayed block that GL enumerates per element - "B[0]", "B[1]" - is one entry
-            // here, spelled "B". Retry against the bare name before giving up.
-            const auto bracket = name.rfind('[');
-            if (bracket == String::npos || name.empty() || name.back() != ']') return GL_INVALID_INDEX;
-            it = find(name.substr(0, bracket));
-            if (it == cache.storageBlocks.end()) return GL_INVALID_INDEX;
-        }
-        return static_cast<GLuint>(std::distance(cache.storageBlocks.begin(), it));
+        const auto it = std::find_if(cache.storageBlocks.begin(), cache.storageBlocks.end(),
+            [&](const StorageBlockResource& block) { return block.name == name; });
+        return it == cache.storageBlocks.end()
+            ? GL_INVALID_INDEX
+            : static_cast<GLuint>(std::distance(cache.storageBlocks.begin(), it));
     }
 
     GLuint GetShaderStorageBlockBinding(const MG_State::GLState::ProgramObject& program, GLuint blockIndex) {
@@ -352,20 +440,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         pVulkanRenderer->ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
     }
 
-    void ClearNamedFramebufferiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
-                                 GLint drawbuffer, const GLint* value) {
-        MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::ClearNamedFramebufferiv called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::ClearNamedFramebufferiv called with null GL context");
-        pVulkanRenderer->ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
-    }
-
-    void ClearNamedFramebufferuiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
-                                  GLint drawbuffer, const GLuint* value) {
-        MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::ClearNamedFramebufferuiv called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::ClearNamedFramebufferuiv called with null GL context");
-        pVulkanRenderer->ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
-    }
-
     void ClearNamedFramebufferfi(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
                                  GLint drawbuffer, GLfloat depth, GLint stencil) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::ClearNamedFramebufferfi called with null VulkanRenderer");
@@ -785,9 +859,357 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
     }
 
-    void ShaderStorageBlockBinding(GLuint program, const GLchar* storageBlockName, GLuint storageBlockBinding) {
+    void GetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint* params) {
+        if (!params) return;
         auto* programObject = TryGetDirectVulkanProgram(program);
-        if (!programObject || storageBlockName == nullptr) return;
+        if (!programObject) return;
+        auto& cache = GetProgramResourceCache(*programObject);
+        switch (pname) {
+        case GL_ACTIVE_RESOURCES:
+            *params = GetProgramResourceActiveCount(*programObject, programInterface, cache);
+            return;
+        case GL_MAX_NAME_LENGTH:
+            *params = GetProgramResourceMaxNameLength(*programObject, programInterface, cache);
+            return;
+        case GL_MAX_NUM_ACTIVE_VARIABLES:
+            if (programInterface == GL_SHADER_STORAGE_BLOCK) {
+                SizeT maxCount = 0;
+                for (const auto& block : cache.storageBlocks) {
+                    maxCount = std::max(maxCount, block.activeVariables.size());
+                }
+                *params = static_cast<GLint>(maxCount);
+            } else if (programInterface == GL_UNIFORM_BLOCK) {
+                GLint maxCount = 0;
+                const Int activeBlocks = programObject->GetActiveUniformBlocksCount();
+                for (Int index = 0; index < activeBlocks; ++index) {
+                    maxCount = std::max(maxCount, programObject->GetUniformBlockActiveUniformCount(index));
+                }
+                *params = maxCount;
+            } else {
+                *params = 0;
+            }
+            return;
+        default:
+            *params = 0;
+            return;
+        }
+    }
+
+    GLuint GetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar* name) {
+        if (!name) return GL_INVALID_INDEX;
+        auto* programObject = TryGetDirectVulkanProgram(program);
+        if (!programObject) return GL_INVALID_INDEX;
+        auto& cache = GetProgramResourceCache(*programObject);
+        const String resourceName = name;
+        if (programInterface == GL_SHADER_STORAGE_BLOCK) {
+            return GetShaderStorageBlockIndex(*programObject, name);
+        }
+        if (programInterface == GL_BUFFER_VARIABLE) {
+            const auto it = std::find_if(cache.bufferVariables.begin(), cache.bufferVariables.end(),
+                [&](const BufferVariableResource& var) { return var.name == resourceName; });
+            return it == cache.bufferVariables.end()
+                ? GL_INVALID_INDEX
+                : static_cast<GLuint>(std::distance(cache.bufferVariables.begin(), it));
+        }
+        if (programInterface == GL_UNIFORM_BLOCK) {
+            return programObject->GetUniformBlockIndex(name);
+        }
+        if (programInterface == GL_UNIFORM) {
+            const Int activeUniformIndex = programObject->GetActiveUniformIndex(resourceName);
+            return activeUniformIndex >= 0 ? static_cast<GLuint>(activeUniformIndex) : GL_INVALID_INDEX;
+        }
+        if (programInterface == GL_PROGRAM_INPUT) {
+            return FindProgramInputIndex(*programObject, resourceName);
+        }
+        if (programInterface == GL_PROGRAM_OUTPUT) {
+            return FindProgramOutputIndex(*programObject, resourceName);
+        }
+        return GL_INVALID_INDEX;
+    }
+
+    void GetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize,
+                                GLsizei* length, GLchar* name) {
+        auto* programObject = TryGetDirectVulkanProgram(program);
+        if (!programObject) return;
+        auto& cache = GetProgramResourceCache(*programObject);
+        if (programInterface == GL_SHADER_STORAGE_BLOCK && index < cache.storageBlocks.size()) {
+            CopyResourceName(cache.storageBlocks[index].name, bufSize, length, name);
+            return;
+        }
+        if (programInterface == GL_BUFFER_VARIABLE && index < cache.bufferVariables.size()) {
+            CopyResourceName(cache.bufferVariables[index].name, bufSize, length, name);
+            return;
+        }
+        if (programInterface == GL_UNIFORM_BLOCK && programObject->IsActiveUniformBlock(index)) {
+            CopyResourceName(programObject->GetUniformBlockName(index), bufSize, length, name);
+            return;
+        }
+        if (programInterface == GL_UNIFORM && index < programObject->GetUniformCount()) {
+            CopyResourceName(programObject->GetActiveUniformName(index), bufSize, length, name);
+            return;
+        }
+        if (programInterface == GL_PROGRAM_INPUT && index < static_cast<GLuint>(programObject->GetActiveAttributesCount())) {
+            CopyResourceName(programObject->GetActiveAttribName(index), bufSize, length, name);
+            return;
+        }
+        if (programInterface == GL_PROGRAM_OUTPUT &&
+            index < static_cast<GLuint>(programObject->GetActiveFragmentOutputCount())) {
+            CopyResourceName(programObject->GetActiveFragmentOutputName(index), bufSize, length, name);
+            return;
+        }
+        if (length) *length = 0;
+        if (name && bufSize > 0) name[0] = '\0';
+    }
+
+    void GetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount,
+                              const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params) {
+        auto* programObject = TryGetDirectVulkanProgram(program);
+        if (!programObject || !props || !params || bufSize <= 0) return;
+        auto& cache = GetProgramResourceCache(*programObject);
+        GLsizei written = 0;
+        auto writeValue = [&](GLint value) {
+            if (written < bufSize) {
+                params[written++] = value;
+            }
+        };
+
+        for (GLsizei propIndex = 0; propIndex < propCount; ++propIndex) {
+            const GLenum prop = props[propIndex];
+            if (programInterface == GL_SHADER_STORAGE_BLOCK && index < cache.storageBlocks.size()) {
+                const auto& block = cache.storageBlocks[index];
+                switch (prop) {
+                case GL_NAME_LENGTH:
+                    writeValue(static_cast<GLint>(block.name.size() + 1));
+                    break;
+                case GL_BUFFER_BINDING:
+                    writeValue(static_cast<GLint>(block.binding));
+                    break;
+                case GL_BUFFER_DATA_SIZE:
+                    writeValue(block.dataSize);
+                    break;
+                case GL_NUM_ACTIVE_VARIABLES:
+                    writeValue(static_cast<GLint>(block.activeVariables.size()));
+                    break;
+                case GL_ACTIVE_VARIABLES:
+                    for (const auto variable : block.activeVariables) writeValue(static_cast<GLint>(variable));
+                    break;
+                default:
+                    writeValue(0);
+                    break;
+                }
+            } else if (programInterface == GL_BUFFER_VARIABLE && index < cache.bufferVariables.size()) {
+                const auto& var = cache.bufferVariables[index];
+                switch (prop) {
+                case GL_NAME_LENGTH:
+                    writeValue(static_cast<GLint>(var.name.size() + 1));
+                    break;
+                case GL_TYPE:
+                    writeValue(GL_FLOAT);
+                    break;
+                case GL_ARRAY_SIZE:
+                    writeValue(1);
+                    break;
+                case GL_OFFSET:
+                    writeValue(var.offset);
+                    break;
+                case GL_BLOCK_INDEX:
+                    writeValue(static_cast<GLint>(var.blockIndex));
+                    break;
+                case GL_ARRAY_STRIDE:
+                case GL_MATRIX_STRIDE:
+                case GL_TOP_LEVEL_ARRAY_SIZE:
+                case GL_TOP_LEVEL_ARRAY_STRIDE:
+                case GL_IS_ROW_MAJOR:
+                    writeValue(0);
+                    break;
+                default:
+                    writeValue(0);
+                    break;
+                }
+            } else if (programInterface == GL_UNIFORM_BLOCK &&
+                       programObject->IsActiveUniformBlock(index)) {
+                const auto activeVariables = GetUniformBlockActiveVariables(*programObject, index);
+                switch (prop) {
+                case GL_NAME_LENGTH:
+                    writeValue(static_cast<GLint>(programObject->GetUniformBlockName(index).size() + 1));
+                    break;
+                case GL_BUFFER_BINDING:
+                    writeValue(static_cast<GLint>(programObject->GetUniformBlockBinding(index)));
+                    break;
+                case GL_BUFFER_DATA_SIZE:
+                    writeValue(static_cast<GLint>(programObject->GetUBOSizeAt(index)));
+                    break;
+                case GL_NUM_ACTIVE_VARIABLES:
+                    writeValue(static_cast<GLint>(activeVariables.size()));
+                    break;
+                case GL_ACTIVE_VARIABLES:
+                    for (const GLuint variableIndex : activeVariables) {
+                        writeValue(static_cast<GLint>(variableIndex));
+                    }
+                    break;
+                case GL_REFERENCED_BY_VERTEX_SHADER:
+                    writeValue(programObject->IsUniformBlockReferencedByStage(index, EShLangVertex) ? GL_TRUE
+                                                                                                     : GL_FALSE);
+                    break;
+                case GL_REFERENCED_BY_FRAGMENT_SHADER:
+                    writeValue(programObject->IsUniformBlockReferencedByStage(index, EShLangFragment) ? GL_TRUE
+                                                                                                       : GL_FALSE);
+                    break;
+                case GL_REFERENCED_BY_COMPUTE_SHADER:
+                    writeValue(programObject->IsUniformBlockReferencedByStage(index, EShLangCompute) ? GL_TRUE
+                                                                                                      : GL_FALSE);
+                    break;
+                case GL_REFERENCED_BY_GEOMETRY_SHADER:
+                case GL_REFERENCED_BY_TESS_CONTROL_SHADER:
+                case GL_REFERENCED_BY_TESS_EVALUATION_SHADER:
+                    writeValue(GL_FALSE);
+                    break;
+                default:
+                    writeValue(0);
+                    break;
+                }
+            } else if (programInterface == GL_UNIFORM && index < programObject->GetUniformCount()) {
+                const auto& uniformName = programObject->GetActiveUniformName(index);
+                const GLint location = programObject->GetUniformLocation(uniformName);
+                switch (prop) {
+                case GL_NAME_LENGTH:
+                    writeValue(static_cast<GLint>(uniformName.size() + 1));
+                    break;
+                case GL_TYPE:
+                    writeValue(static_cast<GLint>(programObject->GetActiveUniformType(index)));
+                    break;
+                case GL_ARRAY_SIZE:
+                    writeValue(programObject->GetActiveUniformArraySize(index));
+                    break;
+                case GL_BLOCK_INDEX:
+                    writeValue(programObject->GetActiveUniformBlockIndex(index));
+                    break;
+                case GL_LOCATION:
+                    writeValue(location);
+                    break;
+                case GL_OFFSET:
+                    writeValue(location >= 0 && programObject->IsValidUniformLocation(location)
+                                   ? static_cast<GLint>(programObject->GetUniformOffset(location))
+                                   : 0);
+                    break;
+                case GL_ARRAY_STRIDE:
+                case GL_MATRIX_STRIDE:
+                case GL_IS_ROW_MAJOR:
+                case GL_TOP_LEVEL_ARRAY_SIZE:
+                case GL_TOP_LEVEL_ARRAY_STRIDE:
+                case GL_REFERENCED_BY_VERTEX_SHADER:
+                case GL_REFERENCED_BY_FRAGMENT_SHADER:
+                case GL_REFERENCED_BY_COMPUTE_SHADER:
+                case GL_REFERENCED_BY_GEOMETRY_SHADER:
+                case GL_REFERENCED_BY_TESS_CONTROL_SHADER:
+                case GL_REFERENCED_BY_TESS_EVALUATION_SHADER:
+                    writeValue(0);
+                    break;
+                default:
+                    writeValue(0);
+                    break;
+                }
+            } else if (programInterface == GL_PROGRAM_INPUT &&
+                       index < static_cast<GLuint>(programObject->GetActiveAttributesCount())) {
+                const auto& resourceName = programObject->GetActiveAttribName(index);
+                switch (prop) {
+                case GL_NAME_LENGTH:
+                    writeValue(static_cast<GLint>(resourceName.size() + 1));
+                    break;
+                case GL_TYPE:
+                    writeValue(static_cast<GLint>(programObject->GetActiveAttribType(index)));
+                    break;
+                case GL_ARRAY_SIZE:
+                    writeValue(programObject->GetActiveAttribArraySize(index));
+                    break;
+                case GL_LOCATION:
+                    writeValue(programObject->GetAttributeLocation(resourceName));
+                    break;
+                case GL_REFERENCED_BY_VERTEX_SHADER:
+                    writeValue(GL_TRUE);
+                    break;
+                case GL_REFERENCED_BY_FRAGMENT_SHADER:
+                case GL_REFERENCED_BY_COMPUTE_SHADER:
+                case GL_REFERENCED_BY_GEOMETRY_SHADER:
+                case GL_REFERENCED_BY_TESS_CONTROL_SHADER:
+                case GL_REFERENCED_BY_TESS_EVALUATION_SHADER:
+                case GL_IS_PER_PATCH:
+                case GL_LOCATION_INDEX:
+                    writeValue(0);
+                    break;
+                default:
+                    writeValue(0);
+                    break;
+                }
+            } else if (programInterface == GL_PROGRAM_OUTPUT &&
+                       index < static_cast<GLuint>(programObject->GetActiveFragmentOutputCount())) {
+                const auto& resourceName = programObject->GetActiveFragmentOutputName(index);
+                switch (prop) {
+                case GL_NAME_LENGTH:
+                    writeValue(static_cast<GLint>(resourceName.size() + 1));
+                    break;
+                case GL_TYPE:
+                    writeValue(static_cast<GLint>(programObject->GetFragmentOutputType(index)));
+                    break;
+                case GL_ARRAY_SIZE:
+                    writeValue(programObject->GetActiveFragmentOutputArraySize(index));
+                    break;
+                case GL_LOCATION:
+                    writeValue(programObject->GetFragmentOutputLocation(index));
+                    break;
+                case GL_LOCATION_INDEX:
+                    writeValue(0);
+                    break;
+                case GL_REFERENCED_BY_FRAGMENT_SHADER:
+                    writeValue(GL_TRUE);
+                    break;
+                case GL_REFERENCED_BY_VERTEX_SHADER:
+                case GL_REFERENCED_BY_COMPUTE_SHADER:
+                case GL_REFERENCED_BY_GEOMETRY_SHADER:
+                case GL_REFERENCED_BY_TESS_CONTROL_SHADER:
+                case GL_REFERENCED_BY_TESS_EVALUATION_SHADER:
+                case GL_IS_PER_PATCH:
+                    writeValue(0);
+                    break;
+                default:
+                    writeValue(0);
+                    break;
+                }
+            } else {
+                writeValue(0);
+            }
+        }
+        if (length) *length = written;
+    }
+
+    GLint GetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar* name) {
+        auto* programObject = TryGetDirectVulkanProgram(program);
+        if (!programObject || !name) return -1;
+        if (programInterface == GL_UNIFORM) {
+            return programObject->GetUniformLocation(name);
+        }
+        if (programInterface == GL_PROGRAM_INPUT) {
+            return programObject->GetAttributeLocation(name);
+        }
+        if (programInterface == GL_PROGRAM_OUTPUT) {
+            return GetProgramOutputLocation(*programObject, name);
+        }
+        return -1;
+    }
+
+    GLint GetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar* name) {
+        auto* programObject = TryGetDirectVulkanProgram(program);
+        if (!programObject || !name) return -1;
+        if (programInterface == GL_PROGRAM_OUTPUT) {
+            return GetProgramOutputLocation(*programObject, name) >= 0 ? 0 : -1;
+        }
+        return -1;
+    }
+
+    void ShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding) {
+        auto* programObject = TryGetDirectVulkanProgram(program);
+        if (!programObject) return;
+        auto& cache = GetProgramResourceCache(*programObject);
         const Int maxBindings = pActiveBackendObject
             ? pActiveBackendObject->GetDynamicParameters().MaxShaderStorageBufferBindings
             : 0;
@@ -797,14 +1219,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 MakeUnique<GenericErrorInfo>("DirectVulkan", __func__, "Shader storage binding is out of range."));
             return;
         }
-        // The frontend already validated that the name denotes an active block, and has
-        // already recorded the new binding on the program - which is what reseeds this cache
-        // whenever it is rebuilt. Writing the entry here as well keeps an ALREADY-BUILT cache
-        // (the common case: the very next draw reads it) from having to be thrown away.
-        auto& cache = GetProgramResourceCache(*programObject);
-        const GLuint blockIndex = GetShaderStorageBlockIndex(*programObject, storageBlockName);
-        if (blockIndex == GL_INVALID_INDEX) return;
-        cache.storageBlocks[blockIndex].binding = storageBlockBinding;
+        if (storageBlockIndex >= cache.storageBlocks.size()) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("DirectVulkan", __func__, "Shader storage block index is not active."));
+            return;
+        }
+        cache.storageBlocks[storageBlockIndex].binding = storageBlockBinding;
     }
     void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::ReadPixels called with null VulkanRenderer");
@@ -957,66 +1378,31 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         pVulkanRenderer->MultiDrawArrays(payload);
     }
 
-    // Shared body of glMultiDrawElements (basevertex == nullptr) and
-    // glMultiDrawElementsBaseVertex: identical calls except for the per-draw
-    // vertex offset, which VkMultiDrawIndexedInfoEXT / VkDrawIndexedIndirectCommand /
-    // vkCmdDrawIndexed all carry natively.
-    static void MultiDrawElementsImpl(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                                      GLsizei drawcount, const GLint* basevertex) {
-        if (drawcount <= 0) {
-            return;
-        }
-        MultiDrawIndexedCmd payload{};
-        payload.mode = mode;
-        payload.indexBufferView.indexType = type;
-
-        // Loop-invariant: the index type is fixed for the whole multi-draw, so resolve
-        // its byte size once instead of twice per sub-draw (a cross-TU switch that
-        // showed up in per-frame profiles of sodium-style 132x32 multi-draws). Index
-        // sizes are 1/2/4, so the per-sub-draw offset division below reduces to a
-        // shift - the hardware divide was the hottest instruction of this loop.
-        const SizeT indexSize = MG_Util::GetGLTypeSize(type);
-        if (indexSize == 0) {
-            MGLOG_E("MultiDrawElements skipped: unsupported index type 0x%x", type);
-            return;
-        }
-        const Uint32 indexSizeShift = static_cast<Uint32>(std::countr_zero(indexSize));
-
-        // TODO: allocate draw cmd buf elsewhere
-        static Vector<DrawIndexedCmdParam> params;
-        params.clear();
-        params.resize(drawcount);
-
-        for (GLsizei i = 0; i < drawcount; ++i) {
-            if (count[i] == 0) {
-                continue;
-            }
-
-            // TODO: this index view needs a redesign, now there's a lotta redundant uploads
-
-            payload.indexBufferView.indexByteOffset = 0;
-            payload.indexBufferView.indexByteSize =
-                    std::max(reinterpret_cast<SizeT>(indices[i]) + count[i] * indexSize,
-                             payload.indexBufferView.indexByteSize);
-
-            auto& param = params[i];
-
-            param.indexCount = count[i];
-            param.instanceCount = 1;
-            param.firstIndex = reinterpret_cast<SizeT>(indices[i]) >> indexSizeShift;
-            param.vertexOffset = basevertex != nullptr ? basevertex[i] : 0;
-            param.firstInstance = 0;
-        }
-        payload.drawCount = drawcount;
-        payload.pParams = params.data();
-        pVulkanRenderer->MultiDrawElements(payload);
-    }
-
     void MultiDrawElements(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
                            GLsizei drawcount) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::MultiDrawElements called with null VulkanRenderer");
         MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::MultiDrawElements called with null GL context");
-        MultiDrawElementsImpl(mode, count, type, indices, drawcount, nullptr);
+
+        // Vector<DrawElementCmd> cmds;
+        // cmds.reserve(static_cast<SizeT>(drawcount));
+        // for (GLsizei i = 0; i < drawcount; ++i) {
+        //     if (count[i] == 0) {
+        //         continue;
+        //     }
+        //
+        //     DrawElementCmd payload{};
+        //     payload.mode = mode;
+        //     payload.firstVertex = 0;
+        //     payload.indexCount = count[i];
+        //     payload.indexType = type;
+        //     payload.indexByteOffset = reinterpret_cast<SizeT>(indices[i]);
+        //     cmds.push_back(payload);
+        // }
+        //
+        // if (cmds.empty()) {
+        //     return;
+        // }
+        // pVulkanRenderer->MultiDrawElements(cmds);
     }
 
     void DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLint basevertex) {
@@ -1044,9 +1430,40 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     void MultiDrawElementsBaseVertex(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
                                      GLsizei drawcount, const GLint* basevertex) {
-        MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::MultiDrawElementsBaseVertex called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::MultiDrawElementsBaseVertex called with null GL context");
-        MultiDrawElementsImpl(mode, count, type, indices, drawcount, basevertex);
+        MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::MultiDrawElements called with null VulkanRenderer");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::MultiDrawElements called with null GL context");
+        MultiDrawIndexedCmd payload{};
+        payload.mode = mode;
+        payload.indexBufferView.indexType = type;
+
+        // TODO: allocate draw cmd buf elsewhere
+        static Vector<DrawIndexedCmdParam> params;
+        params.clear();
+        params.resize(drawcount);
+
+        for (GLsizei i = 0; i < drawcount; ++i) {
+            if (count[i] == 0) {
+                continue;
+            }
+
+            // TODO: this index view needs a redesign, now there's a lotta redundant uploads
+
+            payload.indexBufferView.indexByteOffset = 0;
+            payload.indexBufferView.indexByteSize =
+                    std::max(reinterpret_cast<SizeT>(indices[i]) + count[i] * MG_Util::GetGLTypeSize(type),
+                             payload.indexBufferView.indexByteSize);
+
+            auto& param = params[i];
+
+            param.indexCount = count[i];
+            param.instanceCount = 1;
+            param.firstIndex = reinterpret_cast<SizeT>(indices[i]) / MG_Util::GetGLTypeSize(type);
+            param.vertexOffset = basevertex[i];
+            param.firstInstance = 0;
+        }
+        payload.drawCount = drawcount;
+        payload.pParams = params.data();
+        pVulkanRenderer->MultiDrawElements(payload);
     }
 
     void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1,

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.h

@@ -35,10 +35,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value);
     void ClearNamedFramebufferfv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
                                  GLint drawbuffer, const GLfloat* value);
-    void ClearNamedFramebufferiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
-                                 GLint drawbuffer, const GLint* value);
-    void ClearNamedFramebufferuiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
-                                  GLint drawbuffer, const GLuint* value);
     void ClearNamedFramebufferfi(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
                                  GLint drawbuffer, GLfloat depth, GLint stencil);
     void Clear(GLbitfield mask);
@@ -97,7 +93,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void GetIntegeri_v(GLenum target, GLuint index, GLint* data);
     void GetInteger64i_v(GLenum target, GLuint index, GLint64* data);
     void GetProgramiv(GLuint program, GLenum pname, GLint* params);
-    void ShaderStorageBlockBinding(GLuint program, const GLchar* storageBlockName, GLuint storageBlockBinding);
+    void GetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint* params);
+    GLuint GetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar* name);
+    void GetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize,
+                                GLsizei* length, GLchar* name);
+    void GetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount,
+                              const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params);
+    GLint GetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar* name);
+    GLint GetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar* name);
+    void ShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
     void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
     void GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels);
     void GetTextureImage(const SharedPtr<MG_State::GLState::ITextureObject>& texture, TextureUploadTarget uploadTarget,

MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.cpp

@@ -209,8 +209,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.polygonMode, sizeof(payload.polygonMode)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.cullMode, sizeof(payload.cullMode)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.frontFace, sizeof(payload.frontFace)));
-        XXHASH_VERIFY(
-            XXH64_update(m_hashState, &payload.provokingVertexMode, sizeof(payload.provokingVertexMode)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.depthTestEnable, sizeof(payload.depthTestEnable)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.depthWriteEnable, sizeof(payload.depthWriteEnable)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.depthBiasEnable, sizeof(payload.depthBiasEnable)));
@@ -399,17 +397,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         raster.depthBiasEnable = payload.depthBiasEnable ? VK_TRUE : VK_FALSE;
         raster.rasterizerDiscardEnable = payload.rasterizerDiscardEnable ? VK_TRUE : VK_FALSE;
         raster.lineWidth = 1.0f;
-        // Only chain the struct when the mode is not Vulkan's implicit default: a device without
-        // VK_EXT_provoking_vertex enabled must never see this pNext entry, and the renderer's
-        // selector already collapses to FIRST in exactly that case - so a device without the
-        // extension produces a byte-identical VkGraphicsPipelineCreateInfo to before.
-        VkPipelineRasterizationProvokingVertexStateCreateInfoEXT provokingVertexState{
-            VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT};
-        if (payload.provokingVertexMode != VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT) {
-            provokingVertexState.provokingVertexMode = payload.provokingVertexMode;
-            provokingVertexState.pNext = raster.pNext;
-            raster.pNext = &provokingVertexState;
-        }
 
         VkPipelineMultisampleStateCreateInfo ms{VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO};
         ms.rasterizationSamples = payload.rasterizationSamples;

MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.h

@@ -35,11 +35,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkPolygonMode polygonMode = VK_POLYGON_MODE_FILL;
             VkCullModeFlags cullMode = VK_CULL_MODE_BACK_BIT;
             VkFrontFace frontFace = VK_FRONT_FACE_CLOCKWISE;
-            // GL's provoking vertex, baked into the pipeline (VK_EXT_provoking_vertex). It selects
-            // which vertex a flat varying takes AND the vertex order transform feedback records for
-            // strips/fans, so it is part of the pipeline's identity, not dynamic state. Defaults to
-            // Vulkan's own convention, which is what a device without the extension gets.
-            VkProvokingVertexModeEXT provokingVertexMode = VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT;
             Bool depthTestEnable = false;
             Bool depthWriteEnable = false;
             Bool depthBiasEnable = false;

MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.cpp

@@ -2348,16 +2348,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         pipelineLayoutInfo.pSetLayouts = &entry.descriptorSetLayout;
         VK_VERIFY(vkCreatePipelineLayout(m_device, &pipelineLayoutInfo, nullptr, &entry.pipelineLayout),
                   "ProgramFactory::ReflectLayout, vkCreatePipelineLayout");
-
-        // Built here rather than where bindingKinds is sized: at that point the vector is only
-        // zero-initialised and the kinds are assigned further down, so a list built there would be
-        // empty. Ascending by construction because the index walks upward.
-        entry.activeBindings.clear();
-        for (Uint32 binding = 0; binding < static_cast<Uint32>(entry.bindingKinds.size()); ++binding) {
-            if (entry.bindingKinds[binding] != DescriptorBindingKind::None) {
-                entry.activeBindings.push_back(binding);
-            }
-        }
     }
 
     const ProgramFactory::VkProgramObject& ProgramFactory::GetOrCreateProgram(
@@ -2379,9 +2369,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return it->second;
         }
 
-        // Structural change: the insert below can move every entry of this
-        // open-addressing map, so all memoised entry pointers die here.
-        ++m_cacheStructureEpoch;
         auto& entry = m_cache[hash];
         entry.hash = hash;
         entry.lastUsedFrame = m_frameCounter;
@@ -2471,33 +2458,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 }
             }
 
-            // A 64-bit vertex input has to arrive as its 32-bit word pair: VK_FORMAT_R64*_SFLOAT is
-            // optional and lavapipe advertises none of them at all. The pass is unconditional so it
-            // always agrees with the Float64 case in VertexInputStateFactory::ToVkVertexFormat, and
-            // ReflectVertexInputs below then sees an ordinary uvec2/uvec4 input.
-            //
-            // Failure here is not recoverable and must not be swallowed: ToVkVertexFormat has already
-            // committed to R32G32{,B32A32}_UINT for the attribute, so a module still declaring
-            // `in double` would reconcile to Unknown and build a pipeline with a UINT format under a
-            // double input - garbage with no diagnostic anywhere.
-            if (shaders[i] && shaders[i]->GetShaderStage() == ShaderStage::Vertex) {
-                Vector<Uint> packedSpirv;
-                const Bool packOk = MG_Util::ShaderTranspiler::ShaderCompiler::PackDoubleVertexInputsForVulkan(
-                    moduleSpirvs[i], packedSpirv);
-                MOBILEGL_ASSERT(packOk,
-                                "ProgramFactory: 64-bit vertex input packing failed for program %u; the "
-                                "vertex-input format and the shader input type now disagree",
-                                program.GetExternalIndex());
-                if (packOk) {
-                    moduleSpirvs[i] = std::move(packedSpirv);
-                } else {
-                    MGLOG_E("ProgramFactory: failed to pack 64-bit vertex inputs for program %u; "
-                            "double-typed vertex attributes will be fetched as uint32 words and not "
-                            "reinterpreted",
-                            program.GetExternalIndex());
-                }
-            }
-
             // When Vulkan can legally access storage images without a statically declared
             // format, let GL's glBindImageTexture format select the runtime image view. This
             // provides desktop-driver-compatible behavior for packs such as iterationRP, whose
@@ -2583,7 +2543,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 // erase runs ~VkProgramObject (modules/layouts destroyed); notify after
                 // so an observer never observes a half-destroyed entry through a lookup.
                 // Observers only need the handle values to purge their keyed caches.
-                ++m_cacheStructureEpoch; // erase moves/kills entries: memoised pointers die
                 it = m_cache.erase(it);
                 if (m_evictionObserver != nullptr) {
                     m_evictionObserver->OnProgramEvicted(hash, descriptorSetLayout);

MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.h

@@ -67,12 +67,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkDescriptorSetLayout descriptorSetLayout = VK_NULL_HANDLE;
             VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
             Vector<DescriptorBindingKind> bindingKinds;
-            // The bindings this program actually declares, ascending. bindingKinds is sized to the
-            // 256-binding cap while a real GL program uses 1-8, so the per-draw descriptor walk was
-            // scanning 256 slots to find a handful. MUST stay ascending: Vulkan consumes
-            // pDynamicOffsets in binding order and the writer pushes them in iteration order, so an
-            // unordered list would silently mis-pair dynamic offsets with their uniform blocks.
-            Vector<Uint32> activeBindings;
             Vector<Uint32> dynamicBindings;
             Vector<Int> uniformBlockIndexByBinding;
             // Descriptor count per binding (1 except for UBO instance arrays, which occupy one
@@ -105,9 +99,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // position-invariance quirk (see PipelineFactory::ShouldSuppressDepthWrite).
             Bool fragmentReplacesDepth = false;
             // Frame-boundary counter value of the last GetOrCreateProgram hit; drives
-            // cache eviction (see OnFrameBoundary). Mutable: the draw snapshot's memoised
-            // entry pointer re-stamps use through a const reference (StampProgramUse).
-            mutable Uint64 lastUsedFrame = 0;
+            // cache eviction (see OnFrameBoundary).
+            Uint64 lastUsedFrame = 0;
 
             static inline VkDevice s_device = VK_NULL_HANDLE;
 
@@ -121,7 +114,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 descriptorSetLayout = other.descriptorSetLayout;
                 pipelineLayout = other.pipelineLayout;
                 bindingKinds = std::move(other.bindingKinds);
-                activeBindings = std::move(other.activeBindings);
                 dynamicBindings = std::move(other.dynamicBindings);
                 uniformBlockIndexByBinding = std::move(other.uniformBlockIndexByBinding);
                 bindingDescriptorCounts = std::move(other.bindingDescriptorCounts);
@@ -170,7 +162,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 descriptorSetLayout = other.descriptorSetLayout;
                 pipelineLayout = other.pipelineLayout;
                 bindingKinds = std::move(other.bindingKinds);
-                activeBindings = std::move(other.activeBindings);
                 dynamicBindings = std::move(other.dynamicBindings);
                 uniformBlockIndexByBinding = std::move(other.uniformBlockIndexByBinding);
                 bindingDescriptorCounts = std::move(other.bindingDescriptorCounts);
@@ -263,16 +254,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const VkProgramObject& GetOrCreateProgram(
             const MG_State::GLState::ProgramObject& program, CompileOptionFlags flags);
 
-        // Bumped whenever m_cache's STRUCTURE changes (any insert or erase): the cache is
-        // an open-addressing map holding entries by value, so both moves existing entries.
-        // A caller that memoised a VkProgramObject* may keep dereferencing it only while
-        // this is unchanged; on a bump it must re-run GetOrCreateProgram.
-        Uint64 GetCacheStructureEpoch() const { return m_cacheStructureEpoch; }
-        // A memoised entry pointer bypasses GetOrCreateProgram, whose per-lookup stamp is
-        // what keeps an in-use entry out of OnFrameBoundary's idle sweep - so such a
-        // caller must re-stamp the entry itself, at least once per frame boundary.
-        void StampProgramUse(const VkProgramObject& entry) const { entry.lastUsedFrame = m_frameCounter; }
-
         // Observer may be null (no notifications). Not owned.
         void SetEvictionObserver(IEvictionObserver* observer) { m_evictionObserver = observer; }
         // Frame boundary hook: ages the program cache and evicts long-unused entries
@@ -323,8 +304,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         mutable ProgramLookupCache m_lastLookup;
         // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
         Uint64 m_frameCounter = 0;
-        // See GetCacheStructureEpoch(). Starts at 1 so a zero-initialized memo can never match.
-        Uint64 m_cacheStructureEpoch = 1;
         IEvictionObserver* m_evictionObserver = nullptr;
         static inline XXH64_state_t* m_hashState = XXH64_createState();
     };

MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.cpp

@@ -116,9 +116,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_frameCount = frameCount;
         m_maxBindings = maxBindings;
         m_samplerResolveMemo.assign(m_maxBindings, SamplerResolveMemo{});
-        // Every entry is freshly constructed (all-invalid), so nothing needs sweeping until
-        // a resolve writes one.
-        m_samplerResolveMemoHighWater = 0;
         m_setsPerFrame = setsPerFrame;
         m_peakDescriptorSetsObserved = 0;
         m_textureManager = textureManager;
@@ -177,8 +174,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_minDynamicOffsetAlignment = 1;
         m_frameCount = 0;
         m_maxBindings = 0;
-        m_samplerResolveMemo.clear();
-        m_samplerResolveMemoHighWater = 0;
         m_setsPerFrame = 0;
         m_peakDescriptorSetsObserved = 0;
         m_textureManager = nullptr;
@@ -207,23 +202,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         for (auto& cacheEntryPair : frame.descriptorSetCacheByLayout) {
             cacheEntryPair.second.cursor = 0;
         }
-        // The frame's descriptor sets are recycled above, so last frame's reuse targets
-        // are gone: start the per-draw descriptor-reuse cache fresh this frame.
-        for (auto& entry : m_descriptorReuseMemo) {
-            entry.valid = false;
-        }
-        m_fastRebindMemo.valid = false;
+        // The frame's descriptor sets are recycled above, so last frame's reuse target
+        // is gone: start the per-draw descriptor-reuse cache fresh this frame.
+        m_hasLastDescriptor = false;
         m_lastBindValid = false;
         // Re-fingerprint the bound sampler set fresh this frame so any GL object address
-        // reuse cannot outlive a single frame (see SamplerResolveMemo). Only the entries a
-        // resolve has actually written can be valid, so the high-water mark bounds the
-        // sweep - the vector itself is sized to the device's binding cap (256 here), which
-        // is ~30x more entries than any program declares.
-        const Uint32 touchedBindings =
-            std::min<Uint32>(m_samplerResolveMemoHighWater, static_cast<Uint32>(m_samplerResolveMemo.size()));
-        for (Uint32 binding = 0; binding < touchedBindings; ++binding) {
-            m_samplerResolveMemo[binding].valid = false;
-            m_samplerResolveMemo[binding].infoValid = false;
+        // reuse cannot outlive a single frame (see SamplerResolveMemo).
+        for (auto& memo : m_samplerResolveMemo) {
+            memo.valid = false;
         }
     }
 
@@ -255,12 +241,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
         if (purgedSets > 0) {
             // The per-draw reuse memo folds the layout handle into its signature; drop
-            // every entry so a recycled handle value cannot revive a purged set mid-frame.
-            for (auto& entry : m_descriptorReuseMemo) {
-                entry.valid = false;
-            }
-            // The rebind memo's set may be among the freed ones.
-            m_fastRebindMemo.valid = false;
+            // it so a recycled handle value cannot revive a purged set mid-frame.
+            m_hasLastDescriptor = false;
             MGLOG_D("UniformDescriptorBinder: freed %zu descriptor sets for destroyed layout", purgedSets);
         }
     }
@@ -268,19 +250,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     Bool UniformManager::ResolveSamplerDescriptor(VkCommandBuffer commandBuffer,
                                                             const MG_State::GLState::ProgramObject& program,
                                                             const ProgramFactory::VkProgramObject& programObj,
-                                                            Uint32 binding, VkDescriptorImageInfo& outImageInfo,
-                                                            Bool trustUnchangedHint) const {
+                                                            Uint32 binding, VkDescriptorImageInfo& outImageInfo) const {
         MOBILEGL_ASSERT(m_textureManager != nullptr, "ResolveSamplerDescriptor: texture manager is null");
         MOBILEGL_ASSERT(m_samplerManager != nullptr, "ResolveSamplerDescriptor: sampler manager is null");
-        // The caller proved every input of this binding's resolution unchanged since the
-        // last full resolve (which also filled the cache), so the whole chain below -
-        // texture/sampler resolution, completeness probe, sync, layout handling, sampler
-        // and view lookups - would recompute the identical descriptor.
-        if (trustUnchangedHint && binding < m_samplerResolveMemo.size() &&
-            m_samplerResolveMemo[binding].infoValid) {
-            outImageInfo = m_samplerResolveMemo[binding].info;
-            return true;
-        }
         MOBILEGL_ASSERT(binding < programObj.samplerNameByBinding.size(),
                         "ResolveSamplerDescriptor: sampler binding %u name lookup out of range", binding);
         // Raw-pointer resolve to skip the SharedPtr atomic refcount churn: the bound texture stays
@@ -389,7 +361,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 viewFormatMemo->viewFormatDomain = numericDomain;
                 viewFormatMemo->viewFormat = sampledViewFormat;
                 viewFormatMemo->viewFormatValid = true;
-                NoteSamplerResolveMemoTouched(binding);
             }
         }
         if (sampledViewFormat == VK_FORMAT_UNDEFINED) {
@@ -445,7 +416,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 memo.viewLevelCount = viewLevelCount;
                 memo.sampler = resolvedSampler;
                 memo.valid = true;
-                NoteSamplerResolveMemoTouched(binding);
             }
         } else {
             resolvedSampler = m_samplerManager->GetOrCreateSampler(*samplerToUse, *texture, forceNearestFiltering,
@@ -456,15 +426,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             .imageView = sampledImageView,
             .imageLayout = resource->layout,
         };
-        if (outImageInfo.sampler == VK_NULL_HANDLE) {
-            return false;
-        }
-        if (binding < m_samplerResolveMemo.size()) {
-            m_samplerResolveMemo[binding].info = outImageInfo;
-            m_samplerResolveMemo[binding].infoValid = true;
-            NoteSamplerResolveMemoTouched(binding);
-        }
-        return true;
+        return outImageInfo.sampler != VK_NULL_HANDLE;
     }
 
     Bool UniformManager::ResolveSamplerDescriptorOverride(
@@ -842,55 +804,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return m_fallbackTexture2D;
     }
 
-    Bool UniformManager::ResolveSampledBinding(const MG_State::GLState::ProgramObject& program,
-                                               const ProgramFactory::VkProgramObject& programObj,
-                                               Uint32 binding,
-                                               MG_State::GLState::ITextureObject*& outTexture,
-                                               const MG_State::GLState::SamplerObject*& outSampler) const {
-        // Open-coded ResolveSamplerTextureRaw so the unit is resolved once for both the
-        // texture and the sampler override - this runs per binding per full-path draw,
-        // and program-alternating draw streams take the full path on every draw.
-        MOBILEGL_ASSERT(MG_State::pGLContext != nullptr, "ResolveSampledBinding: GL context is null");
-        MOBILEGL_ASSERT(binding < programObj.samplerUniformLocationByBinding.size(),
-                        "ResolveSampledBinding: sampler location binding %u out of range", binding);
-        MOBILEGL_ASSERT(binding < programObj.samplerTextureTargetByBinding.size(),
-                        "ResolveSampledBinding: sampler target binding %u out of range", binding);
-        const Int location = programObj.samplerUniformLocationByBinding[binding];
-        const Int unit = ResolveSamplerUnitIndex(program, location, binding);
-        auto& textureUnit = MG_State::pGLContext->GetTextureUnitObject(unit);
-        const TextureTarget preferredTarget = programObj.samplerTextureTargetByBinding[binding];
-        MG_State::GLState::ITextureObject* texture =
-            textureUnit.GetBindingSlot(preferredTarget).GetBoundObject().get();
-        // Undefined default texture (name 0, no image) resolves as "unbound", exactly
-        // like ResolveSamplerTextureRaw reports it.
-        if (MG_State::GLState::IsUndefinedDefaultTexture(texture)) {
-            texture = nullptr;
-        }
-        if (texture == nullptr) {
-            // ResolveSamplerDescriptor will substitute the fallback texture for this binding;
-            // include it in the sampled set so the pre-render-pass sync/transition pass covers
-            // its first use instead of leaving that work to happen inside an active pass.
-            if (preferredTarget != TextureTarget::Texture2D &&
-                preferredTarget != TextureTarget::TextureRectangle) {
-                return false;
-            }
-            texture = GetFallbackTexture(preferredTarget).get();
-        }
-        const auto& samplerOverride = textureUnit.GetSamplerObject();
-        outTexture = texture;
-        outSampler = samplerOverride ? samplerOverride.get()
-                                     : (texture != nullptr ? texture->GetSamplerObject().get() : nullptr);
-        return true;
-    }
-
     Bool UniformManager::CollectSampledTextures(const MG_State::GLState::ProgramObject& program,
                                                           const ProgramFactory::VkProgramObject& programObj,
-                                                          Vector<MG_State::GLState::ITextureObject*>& outTextures,
-                                                          Vector<SampledBindingRecord>* outBindingRecords) {
+                                                          Vector<MG_State::GLState::ITextureObject*>& outTextures) {
         outTextures.clear();
-        if (outBindingRecords != nullptr) {
-            outBindingRecords->clear();
-        }
 
         const Uint32 bindingCount =
             std::min<Uint32>(m_maxBindings, static_cast<Uint32>(programObj.bindingKinds.size()));
@@ -899,14 +816,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 continue;
             }
 
-            MG_State::GLState::ITextureObject* texture = nullptr;
-            const MG_State::GLState::SamplerObject* sampler = nullptr;
-            if (!ResolveSampledBinding(program, programObj, binding, texture, sampler)) {
-                continue;
-            }
-            if (outBindingRecords != nullptr) {
-                outBindingRecords->push_back({texture != nullptr ? texture->GetLifetimeId() : 0,
-                                              sampler != nullptr ? sampler->GetLifetimeId() : 0});
+            MG_State::GLState::ITextureObject* texture = ResolveSamplerTextureRaw(program, programObj, binding);
+            if (!texture) {
+                // ResolveSamplerDescriptor will substitute the fallback texture for this binding;
+                // include it in the sampled set so the pre-render-pass sync/transition pass covers
+                // its first use instead of leaving that work to happen inside an active pass.
+                const TextureTarget preferredTarget = programObj.samplerTextureTargetByBinding[binding];
+                if (preferredTarget != TextureTarget::Texture2D &&
+                    preferredTarget != TextureTarget::TextureRectangle) {
+                    continue;
+                }
+                texture = GetFallbackTexture(preferredTarget).get();
             }
 
             auto found = std::find(outTextures.begin(), outTextures.end(), texture);
@@ -917,38 +837,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return true;
     }
 
-    Bool UniformManager::SampledBindingsUnchanged(const MG_State::GLState::ProgramObject& program,
-                                                  const ProgramFactory::VkProgramObject& programObj,
-                                                  const Vector<SampledBindingRecord>& previousRecords) const {
-        SizeT recordIndex = 0;
-        // Iterate only the bindings this program declares (ascending), exactly like
-        // BindProgramUniformBuffers: this runs per draw whenever the texture bind
-        // generation moved, and walking all m_maxBindings slots to find the 1-8 real
-        // ones dominated it.
-        for (const Uint32 binding : programObj.activeBindings) {
-            if (binding >= m_maxBindings) {
-                break; // ascending, so nothing past the cap can follow
-            }
-            if (programObj.bindingKinds[binding] != ProgramFactory::DescriptorBindingKind::CombinedImageSampler) {
-                continue;
-            }
-            MG_State::GLState::ITextureObject* texture = nullptr;
-            const MG_State::GLState::SamplerObject* sampler = nullptr;
-            if (!ResolveSampledBinding(program, programObj, binding, texture, sampler)) {
-                continue;
-            }
-            if (recordIndex >= previousRecords.size()) {
-                return false;
-            }
-            const SampledBindingRecord& record = previousRecords[recordIndex++];
-            if (record.textureLifetimeId != (texture != nullptr ? texture->GetLifetimeId() : 0) ||
-                record.samplerLifetimeId != (sampler != nullptr ? sampler->GetLifetimeId() : 0)) {
-                return false;
-            }
-        }
-        return recordIndex == previousRecords.size();
-    }
-
     Bool UniformManager::CollectStorageImageTextures(
         const MG_State::GLState::ProgramObject& program,
         const ProgramFactory::VkProgramObject& programObj,
@@ -1120,17 +1008,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return false;
         }
 
-        // Sized from what a real program declares, not from the 256-binding cap. A GL program's
-        // single descriptor set holds the bindings shader reflection found - typically 2 to 8 - so
-        // scaling by m_maxBindings declared 5 x 64 x 256 = 81,920 descriptors per pool and 245,760
-        // across the three frames in flight, which drivers that reserve backing store proportional
-        // to the declared count pay for at init. An outlier program is absorbed by the existing
-        // VK_ERROR_OUT_OF_POOL_MEMORY -> GrowFrameDescriptorPool path: pool sizes are aggregate
-        // budgets rather than per-set limits, and vkAllocateDescriptorSets is spec-required to
-        // report that error rather than fail hard.
-        static constexpr Uint32 kEstimatedBindingsPerSet = 8;
-        const Uint64 descriptorCount64 =
-            static_cast<Uint64>(maxSets) * static_cast<Uint64>(std::min(m_maxBindings, kEstimatedBindingsPerSet));
+        const Uint64 descriptorCount64 = static_cast<Uint64>(maxSets) * static_cast<Uint64>(m_maxBindings);
         if (descriptorCount64 > static_cast<Uint64>(std::numeric_limits<Uint32>::max())) {
             MGLOG_E("UniformDescriptorBinder::CreateDescriptorPool failed: descriptorCount overflow");
             return false;
@@ -1263,101 +1141,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return VK_SUCCESS;
     }
 
-    Bool UniformManager::ResolveDynamicUboDescriptor(const MG_State::GLState::ProgramObject& program,
-                                                     const ProgramFactory::VkProgramObject& programObj,
-                                                     Uint32 binding, Uint32 arrayElement, Uint32 frameIndex,
-                                                     VkBuffer& outBuffer, VkDeviceSize& outRange,
-                                                     Uint32& outDynamicOffset) {
-        UboBindResult ubo{};
-        const Bool hasPayload = ResolveUniformBufferPayload(program, programObj, binding, arrayElement, ubo);
-        MOBILEGL_ASSERT(hasPayload && (ubo.directBindable || (ubo.payload != nullptr && ubo.payloadSize > 0)),
-                        "UniformDescriptorBinder::ResolveDynamicUboDescriptor failed: missing UBO payload on binding %u element %u",
-                        binding, arrayElement);
-        if (ubo.directBindable) {
-            // Zero-copy: bind the app's resident VkBuffer directly, no per-draw memcpy.
-            outBuffer = ubo.buffer;
-            outRange = ubo.range;
-            outDynamicOffset = static_cast<Uint32>(ubo.dynamicOffset);
-            return true;
-        }
-        // Global-UBO slice reuse (see GlobalUboSliceMemo): unchanged
-        // uniform bytes re-use the slice already uploaded this frame.
-        const Bool isGlobalUbo = programObj.globalUboBinding == static_cast<Int>(binding) && arrayElement == 0;
-        const Uint64 uboFrameSerial = m_bufferManager->GetFrameSerial();
-        const Uint64 uboProgramLifetimeId = program.GetLifetimeId();
-        const Uint32 uboContentVersion = program.GetUBOContentVersion();
-        if (isGlobalUbo) {
-            for (const auto& memo : m_globalUboMemo) {
-                if (memo.buffer != VK_NULL_HANDLE && memo.programLifetimeId == uboProgramLifetimeId &&
-                    memo.frameSerial == uboFrameSerial && memo.uboContentVersion == uboContentVersion &&
-                    memo.range == static_cast<VkDeviceSize>(ubo.payloadSize)) {
-                    outBuffer = memo.buffer;
-                    outRange = memo.range;
-                    outDynamicOffset = static_cast<Uint32>(memo.offset);
-                    return true;
-                }
-            }
-        }
-        BufferSlice slice{};
-        if (!m_bufferManager->UploadTransient(BufferKind::Uniform, frameIndex, ubo.payload, ubo.payloadSize,
-                                              m_minDynamicOffsetAlignment, slice)) {
-            MOBILEGL_ASSERT(false,
-                            "UniformDescriptorBinder::ResolveDynamicUboDescriptor failed: UBO upload failed on binding %u element %u",
-                            binding, arrayElement);
-            return false;
-        }
-        outBuffer = slice.buffer;
-        outRange = ubo.payloadSize;
-        outDynamicOffset = static_cast<Uint32>(slice.offset);
-        if (isGlobalUbo) {
-            m_globalUboMemo[m_globalUboMemoNext] =
-                GlobalUboSliceMemo{uboProgramLifetimeId, uboFrameSerial, uboContentVersion,
-                                   slice.buffer, slice.offset, static_cast<VkDeviceSize>(ubo.payloadSize)};
-            m_globalUboMemoNext = (m_globalUboMemoNext + 1) % kGlobalUboMemoSize;
-        }
-        return true;
-    }
-
-    void UniformManager::BindDescriptorSetDeduped(VkCommandBuffer commandBuffer, VkPipelineBindPoint bindPoint,
-                                                  VkPipelineLayout pipelineLayout, VkDescriptorSet descriptorSet,
-                                                  const Vector<Uint32>& dynamicOffsets) {
-        // Skip the driver call when this exact binding is already live on the
-        // command buffer (see the bind-dedup shadow in the header).
-        const Uint32 offsetCount = static_cast<Uint32>(dynamicOffsets.size());
-        Bool identicalBind = m_lastBindValid && m_lastBindSet == descriptorSet &&
-                             m_lastBindLayout == pipelineLayout && m_lastBindPoint == bindPoint &&
-                             m_lastBindOffsetCount == offsetCount && offsetCount <= kMaxShadowedDynamicOffsets;
-        if (identicalBind) {
-            for (Uint32 i = 0; i < offsetCount; ++i) {
-                if (m_lastBindOffsets[i] != dynamicOffsets[i]) {
-                    identicalBind = false;
-                    break;
-                }
-            }
-        }
-        if (!identicalBind) {
-            vkCmdBindDescriptorSets(commandBuffer, bindPoint, pipelineLayout, 0, 1,
-                                    &descriptorSet, offsetCount, dynamicOffsets.data());
-            if (offsetCount <= kMaxShadowedDynamicOffsets) {
-                m_lastBindValid = true;
-                m_lastBindSet = descriptorSet;
-                m_lastBindLayout = pipelineLayout;
-                m_lastBindPoint = bindPoint;
-                m_lastBindOffsetCount = offsetCount;
-                std::copy_n(dynamicOffsets.data(), offsetCount, m_lastBindOffsets);
-            } else {
-                m_lastBindValid = false;
-            }
-        }
-    }
-
     Bool UniformManager::BindProgramUniformBuffers(VkCommandBuffer commandBuffer,
                                                              const MG_State::GLState::ProgramObject& program,
                                                              const ProgramFactory::VkProgramObject& programObj,
                                                              Uint32 frameIndex,
                                                              VkPipelineBindPoint bindPoint,
-                                                             const SamplerBindingOverride* samplerBindingOverride,
-                                                             Bool samplerDescriptorsUnchangedHint) {
+                                                             const SamplerBindingOverride* samplerBindingOverride) {
         auto& frame = m_frames[frameIndex];
         if (frame.descriptorPools.empty()) {
             MGLOG_E("UniformDescriptorBinder::BindProgramUniformBuffers failed: frame descriptor pools are invalid");
@@ -1367,34 +1156,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             frame.activeDescriptorPoolIndex = 0;
         }
 
-        // Dynamic-offset-only rebind (see FastRebindMemo in the header): the last
-        // cacheable walk of this exact program selected a set whose contents are
-        // provably still what this walk would write - the hint covers every
-        // sampler binding, and an unchanged (buffer, range) for the single
-        // dynamic UBO covers the rest - except the dynamic offset, which rebinding
-        // the SAME set delivers without any descriptor write.
-        const Bool cacheable = (samplerBindingOverride == nullptr);
-        if (cacheable && samplerDescriptorsUnchangedHint && m_fastRebindMemo.valid &&
-            m_fastRebindMemo.frameIndex == frameIndex &&
-            m_fastRebindMemo.programLifetimeId == program.GetLifetimeId() &&
-            m_fastRebindMemo.programHash == programObj.hash) {
-            VkBuffer uboBuffer = VK_NULL_HANDLE;
-            VkDeviceSize uboRange = 0;
-            Uint32 uboDynamicOffset = 0;
-            if (ResolveDynamicUboDescriptor(program, programObj, m_fastRebindMemo.uboBinding, 0, frameIndex,
-                                            uboBuffer, uboRange, uboDynamicOffset) &&
-                uboBuffer == m_fastRebindMemo.uboBuffer && uboRange == m_fastRebindMemo.uboRange) {
-                auto& fastOffsets = m_dynamicOffsetsScratch;
-                fastOffsets.clear();
-                fastOffsets.push_back(uboDynamicOffset);
-                BindDescriptorSetDeduped(commandBuffer, bindPoint, programObj.pipelineLayout,
-                                         m_fastRebindMemo.set, fastOffsets);
-                return true;
-            }
-            // Any mismatch (arena wrap or growth, direct-bind retarget, upload
-            // failure) falls through to the full walk, which re-records the memo.
-        }
-
         // The descriptor set is chosen AFTER the writes are built (below), so a draw
         // whose resolved descriptor content matches the previous draw can reuse that
         // set and skip both AcquireDescriptorSet and vkUpdateDescriptorSets.
@@ -1426,21 +1187,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         texelBufferViews.reserve(m_maxBindings);
         dynamicOffsets.reserve(programObj.dynamicBindings.size() + uboArrayExtra);
 
-        // Eligibility probe for FastRebindMemo, filled by this walk: exactly one
-        // dynamic-UBO descriptor (no arrayed elements) and otherwise only
-        // combined-image samplers, so the whole set's content is pinned by the
-        // sampler hint plus one (buffer, range) compare.
-        Uint32 dynamicUboDescriptorCount = 0;
-        Uint32 fastRebindUboBinding = 0;
-        Bool fastRebindKindsEligible = true;
-
-        // Iterate only the bindings this program declares. The old walk covered all 256 slots of
-        // bindingKinds on every draw to find the 1-8 a real program uses.
-        for (const Uint32 binding : programObj.activeBindings) {
-            if (binding >= m_maxBindings) {
-                break; // ascending, so nothing past the cap can follow
-            }
+        const Uint32 bindingCount =
+            std::min<Uint32>(m_maxBindings, static_cast<Uint32>(programObj.bindingKinds.size()));
+        for (Uint32 binding = 0; binding < bindingCount; ++binding) {
             const auto kind = programObj.bindingKinds[binding];
+            if (kind == ProgramFactory::DescriptorBindingKind::None) {
+                continue;
+            }
 
             VkWriteDescriptorSet write{};
             write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
@@ -1454,18 +1207,67 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     binding < programObj.bindingDescriptorCounts.size()
                         ? std::max<Uint32>(1, programObj.bindingDescriptorCounts[binding])
                         : 1u;
-                dynamicUboDescriptorCount += descriptorCount;
-                fastRebindUboBinding = binding;
                 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 = 0;
-                    if (!ResolveDynamicUboDescriptor(program, programObj, binding, element, frameIndex,
-                                                     bufferInfo.buffer, bufferInfo.range, dynOffset)) {
-                        return false;
+                    Uint32 dynOffset;
+                    if (ubo.directBindable) {
+                        // Zero-copy: bind the app's resident VkBuffer directly, no per-draw memcpy.
+                        bufferInfo.buffer = ubo.buffer;
+                        bufferInfo.range = ubo.range;
+                        dynOffset = static_cast<Uint32>(ubo.dynamicOffset);
+                    } else {
+                        // Global-UBO slice reuse (see GlobalUboSliceMemo): unchanged
+                        // uniform bytes re-use the slice already uploaded this frame.
+                        const Bool isGlobalUbo =
+                            programObj.globalUboBinding == static_cast<Int>(binding) && element == 0;
+                        const Uint64 uboFrameSerial = m_bufferManager->GetFrameSerial();
+                        const Uint64 uboProgramLifetimeId = program.GetLifetimeId();
+                        const Uint32 uboContentVersion = program.GetUBOContentVersion();
+                        Bool reusedSlice = false;
+                        if (isGlobalUbo) {
+                            for (const auto& memo : m_globalUboMemo) {
+                                if (memo.buffer != VK_NULL_HANDLE &&
+                                    memo.programLifetimeId == uboProgramLifetimeId &&
+                                    memo.frameSerial == uboFrameSerial &&
+                                    memo.uboContentVersion == uboContentVersion &&
+                                    memo.range == static_cast<VkDeviceSize>(ubo.payloadSize)) {
+                                    bufferInfo.buffer = memo.buffer;
+                                    bufferInfo.range = memo.range;
+                                    dynOffset = static_cast<Uint32>(memo.offset);
+                                    reusedSlice = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!reusedSlice) {
+                            BufferSlice slice{};
+                            if (!m_bufferManager->UploadTransient(BufferKind::Uniform, frameIndex, ubo.payload,
+                                                                  ubo.payloadSize, m_minDynamicOffsetAlignment, slice)) {
+                                MOBILEGL_ASSERT(false, "UniformDescriptorBinder::BindProgramUniformBuffers failed: UBO upload failed on binding %u element %u",
+                                        binding, element);
+                                return false;
+                            }
+                            bufferInfo.buffer = slice.buffer;
+                            bufferInfo.range = ubo.payloadSize;
+                            dynOffset = static_cast<Uint32>(slice.offset);
+                            if (isGlobalUbo) {
+                                m_globalUboMemo[m_globalUboMemoNext] = GlobalUboSliceMemo{
+                                    uboProgramLifetimeId, uboFrameSerial, uboContentVersion,
+                                    slice.buffer, slice.offset, static_cast<VkDeviceSize>(ubo.payloadSize)};
+                                m_globalUboMemoNext = (m_globalUboMemoNext + 1) % kGlobalUboMemoSize;
+                            }
+                        }
                     }
                     bufferInfos.push_back(bufferInfo);
                     // Dynamic offsets are consumed in binding order, then array element order,
@@ -1488,7 +1290,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 }
 
                 texelBufferViews.push_back(bufferView);
-                fastRebindKindsEligible = false;
                 write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
                 write.pTexelBufferView = &texelBufferViews.back();
                 writes.push_back(write);
@@ -1502,7 +1303,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 }
 
                 bufferInfos.push_back(bufferInfo);
-                fastRebindKindsEligible = false;
                 write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
                 write.pBufferInfo = &bufferInfos.back();
                 writes.push_back(write);
@@ -1515,7 +1315,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     return false;
                 }
                 imageInfos.push_back(imageInfo);
-                fastRebindKindsEligible = false;
                 write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
                 write.pImageInfo = &imageInfos.back();
                 writes.push_back(write);
@@ -1528,8 +1327,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     samplerBindingOverride->sampler != nullptr) {
                     hasImage = ResolveSamplerDescriptorOverride(*samplerBindingOverride, imageInfo);
                 } else {
-                    hasImage = ResolveSamplerDescriptor(commandBuffer, program, programObj, binding, imageInfo,
-                                                        samplerDescriptorsUnchangedHint);
+                    hasImage = ResolveSamplerDescriptor(commandBuffer, program, programObj, binding, imageInfo);
                 }
                 if (!hasImage) {
                     MGLOG_E(
@@ -1550,16 +1348,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         }
 
-        // Reuse a recent draw's descriptor set when the resolved content is
+        // Reuse the previous draw's descriptor set when the resolved content is
         // byte-identical (only the bind-time dynamic offsets differ). The signature
         // covers the descriptor-set layout + every write's binding/type/count + the
         // pointed-to buffer/image/texel-buffer infos (all value-initialized, so no
         // padding noise). Correctness: bindings are re-resolved every draw, so the
         // signature always reflects the current state and reuse happens only on an
-        // exact match; a reused set is never re-acquired within a frame (the acquire
+        // exact match; the reused set is never re-acquired within a frame (the acquire
         // cursor only advances), so its written contents survive; the layout is part of
         // the signature so reuse never crosses programs. Sampler overrides (blits)
         // bypass and invalidate the cache.
+        const Bool cacheable = (samplerBindingOverride == nullptr);
         Uint64 signature = 0xcbf29ce484222325ULL;
         {
             const auto mix64 = [&signature](Uint64 word) {
@@ -1587,17 +1386,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             mixWords(texelBufferViews.data(), texelBufferViews.size() * sizeof(VkBufferView));
         }
 
-        VkDescriptorSet reusedSet = VK_NULL_HANDLE;
-        if (cacheable) {
-            for (const auto& entry : m_descriptorReuseMemo) {
-                if (entry.valid && entry.signature == signature) {
-                    reusedSet = entry.set;
-                    break;
-                }
-            }
-        }
-        if (reusedSet != VK_NULL_HANDLE) {
-            descriptorSet = reusedSet;
+        if (cacheable && m_hasLastDescriptor && signature == m_lastDescriptorSignature) {
+            descriptorSet = m_lastBoundDescriptorSet;
         } else {
             VkResult allocResult = AcquireDescriptorSet(frameIndex, programObj, descriptorSet);
             if (allocResult != VK_SUCCESS || descriptorSet == VK_NULL_HANDLE) {
@@ -1611,33 +1401,39 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             if (!writes.empty()) {
                 vkUpdateDescriptorSets(m_device, static_cast<Uint32>(writes.size()), writes.data(), 0, nullptr);
             }
-            if (cacheable) {
-                m_descriptorReuseMemo[m_descriptorReuseMemoNext] =
-                    DescriptorReuseEntry{signature, descriptorSet, true};
-                m_descriptorReuseMemoNext = (m_descriptorReuseMemoNext + 1) % kDescriptorReuseMemoSize;
-            } else {
-                for (auto& entry : m_descriptorReuseMemo) {
-                    entry.valid = false;
+            m_lastBoundDescriptorSet = descriptorSet;
+            m_lastDescriptorSignature = signature;
+            m_hasLastDescriptor = cacheable;
+        }
+
+        // Skip the driver call when this exact binding is already live on the
+        // command buffer (see the bind-dedup shadow in the header).
+        const Uint32 offsetCount = static_cast<Uint32>(dynamicOffsets.size());
+        Bool identicalBind = m_lastBindValid && m_lastBindSet == descriptorSet &&
+                             m_lastBindLayout == programObj.pipelineLayout && m_lastBindPoint == bindPoint &&
+                             m_lastBindOffsetCount == offsetCount && offsetCount <= kMaxShadowedDynamicOffsets;
+        if (identicalBind) {
+            for (Uint32 i = 0; i < offsetCount; ++i) {
+                if (m_lastBindOffsets[i] != dynamicOffsets[i]) {
+                    identicalBind = false;
+                    break;
                 }
             }
         }
-
-        // (Re)record the dynamic-offset-only rebind memo. Recording on every
-        // cacheable walk (allocated or reused set alike - both hold exactly the
-        // content just computed) keeps the single slot tracking the most recent
-        // program; a non-cacheable override walk drops it alongside the reuse
-        // memo above.
-        if (cacheable && fastRebindKindsEligible && dynamicUboDescriptorCount == 1) {
-            m_fastRebindMemo = FastRebindMemo{
-                /*valid=*/true,          frameIndex,      program.GetLifetimeId(), programObj.hash,
-                fastRebindUboBinding,    bufferInfos[0].buffer,
-                bufferInfos[0].range,    descriptorSet};
-        } else {
-            m_fastRebindMemo.valid = false;
+        if (!identicalBind) {
+            vkCmdBindDescriptorSets(commandBuffer, bindPoint, programObj.pipelineLayout, 0, 1,
+                                    &descriptorSet, offsetCount, dynamicOffsets.data());
+            if (offsetCount <= kMaxShadowedDynamicOffsets) {
+                m_lastBindValid = true;
+                m_lastBindSet = descriptorSet;
+                m_lastBindLayout = programObj.pipelineLayout;
+                m_lastBindPoint = bindPoint;
+                m_lastBindOffsetCount = offsetCount;
+                std::copy_n(dynamicOffsets.data(), offsetCount, m_lastBindOffsets);
+            } else {
+                m_lastBindValid = false;
+            }
         }
-
-        BindDescriptorSetDeduped(commandBuffer, bindPoint, programObj.pipelineLayout, descriptorSet,
-                                 dynamicOffsets);
         return true;
     }
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.h

@@ -53,42 +53,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // caches - a live layout's entry must never be purged (its sets would be
         // unreachable pool slots), so there is deliberately no age-based sweep here.
         void OnDescriptorSetLayoutDestroyed(VkDescriptorSetLayout descriptorSetLayout);
-        // One record per visited CombinedImageSampler binding (post fallback substitution,
-        // in binding order): the resolved texture and effective sampler, as never-reused
-        // lifetime ids so a freed-and-reallocated object at the same heap address can only
-        // MISS a comparison, never false-hit it (same ABA rule as SamplerResolveMemo).
-        struct SampledBindingRecord {
-            Uint64 textureLifetimeId = 0;
-            Uint64 samplerLifetimeId = 0;
-        };
         Bool CollectSampledTextures(const MG_State::GLState::ProgramObject& program,
                                     const ProgramFactory::VkProgramObject& programObj,
-                                    Vector<MG_State::GLState::ITextureObject*>& outTextures,
-                                    Vector<SampledBindingRecord>* outBindingRecords = nullptr);
-        // Shadow-compare for the SetupDraw fast path: re-runs the CollectSampledTextures
-        // walk and reports whether every visited binding still resolves to the recorded
-        // (texture, effective sampler) pair. A texture bind generation bump alone (e.g. a
-        // redundant glBindSampler, which always bumps it) does not prove the sampled set
-        // moved; this walk does, without rebuilding the set or falling off the fast path.
-        Bool SampledBindingsUnchanged(const MG_State::GLState::ProgramObject& program,
-                                      const ProgramFactory::VkProgramObject& programObj,
-                                      const Vector<SampledBindingRecord>& previousRecords) const;
+                                    Vector<MG_State::GLState::ITextureObject*>& outTextures);
         Bool CollectStorageImageTextures(const MG_State::GLState::ProgramObject& program,
                                          const ProgramFactory::VkProgramObject& programObj,
                                          Vector<MG_State::GLState::ITextureObject*>& outTextures) const;
-        // samplerDescriptorsUnchangedHint: the caller (SetupDraw fast path) proved that
-        // every input of every combined-image-sampler resolution is unchanged since the
-        // previous draw's resolve - same (texture, sampler) per binding, texture params
-        // sum, sampling-resolution generation (sampler params + texture shape), image
-        // epochs AND per-resource layout values - so the per-binding cached
-        // VkDescriptorImageInfo may be reused without re-running the resolve chain.
         Bool BindProgramUniformBuffers(VkCommandBuffer commandBuffer,
                                        const MG_State::GLState::ProgramObject& program,
                                        const ProgramFactory::VkProgramObject& programObj,
                                        Uint32 frameIndex,
                                        VkPipelineBindPoint bindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                       const SamplerBindingOverride* samplerBindingOverride = nullptr,
-                                       Bool samplerDescriptorsUnchangedHint = false);
+                                       const SamplerBindingOverride* samplerBindingOverride = nullptr);
 
         // Pure format-policy helper kept public for host regression tests. Formatted storage
         // images use their shader qualifier; transformed float images use glBindImageTexture's
@@ -138,15 +114,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         static Bool ResolveSamplerTexture(const MG_State::GLState::ProgramObject& program,
                                    const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
                                    SharedPtr<MG_State::GLState::ITextureObject>& outTexture);
-        // Shared per-binding resolution for CollectSampledTextures and
-        // SampledBindingsUnchanged, so membership and comparison can never diverge:
-        // texture after the fallback substitution (may still be null when no fallback
-        // exists), effective sampler = unit override else the texture's own sampler.
-        // False = the binding is skipped (unbound with a non-2D fallback target).
-        Bool ResolveSampledBinding(const MG_State::GLState::ProgramObject& program,
-                                   const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                   MG_State::GLState::ITextureObject*& outTexture,
-                                   const MG_State::GLState::SamplerObject*& outSampler) const;
         // Raw-pointer variant for the per-draw sampled-texture walk (CollectSampledTextures):
         // the bound texture stays alive through the draw via GL binding state, so callers that
         // only need the pointer skip the SharedPtr copy's atomic refcount churn.
@@ -154,13 +121,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             const MG_State::GLState::ProgramObject& program,
             const ProgramFactory::VkProgramObject& programObj, Uint32 binding);
         SharedPtr<MG_State::GLState::ITextureObject> GetFallbackTexture(TextureTarget target) const;
-        // trustUnchangedHint: reuse this binding's cached VkDescriptorImageInfo outright
-        // (see BindProgramUniformBuffers' samplerDescriptorsUnchangedHint for the proof
-        // obligations the caller carries).
         Bool ResolveSamplerDescriptor(VkCommandBuffer commandBuffer, const MG_State::GLState::ProgramObject& program,
                                       const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                      VkDescriptorImageInfo& outImageInfo,
-                                      Bool trustUnchangedHint = false) const;
+                                      VkDescriptorImageInfo& outImageInfo) const;
         Bool ResolveSamplerDescriptorOverride(const SamplerBindingOverride& samplerBindingOverride,
                                               VkDescriptorImageInfo& outImageInfo) const;
         Bool ResolveTexelBufferDescriptor(const MG_State::GLState::ProgramObject& program,
@@ -186,21 +149,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Bool ResolveUniformBufferPayload(const MG_State::GLState::ProgramObject& program,
                                          const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
                                          Uint32 arrayElement, UboBindResult& out) const;
-        // Shared resolution of one dynamic-UBO binding element into the
-        // (buffer, range, dynamicOffset) triple the descriptor consumes: direct
-        // bind, global-slice reuse, or transient upload. Used by the full walk
-        // and by the dynamic-offset-only rebind (see FastRebindMemo).
-        Bool ResolveDynamicUboDescriptor(const MG_State::GLState::ProgramObject& program,
-                                         const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                         Uint32 arrayElement, Uint32 frameIndex, VkBuffer& outBuffer,
-                                         VkDeviceSize& outRange, Uint32& outDynamicOffset);
-        // The vkCmdBindDescriptorSets tail shared by the full walk and the
-        // dynamic-offset-only rebind: skips the driver call when this exact
-        // binding is already live on the command buffer (see the bind-dedup
-        // shadow below), otherwise binds and refreshes the shadow.
-        void BindDescriptorSetDeduped(VkCommandBuffer commandBuffer, VkPipelineBindPoint bindPoint,
-                                      VkPipelineLayout pipelineLayout, VkDescriptorSet descriptorSet,
-                                      const Vector<Uint32>& dynamicOffsets);
         Bool CreateDescriptorPool(Uint32 maxSets, VkDescriptorPool& outPool) const;
         Bool GrowFrameDescriptorPool(FrameResources& frame, Uint32 frameIndex);
         VkResult AllocateDescriptorSetsFromActivePool(
@@ -231,53 +179,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Vector<VkBufferView> m_texelBufferViewsScratch;
         Vector<Uint32> m_dynamicOffsetsScratch;
 
-        // Descriptor-set reuse across recent draws (see BindProgramUniformBuffers).
-        // When a draw's resolved descriptor content is byte-identical to one memoized
-        // earlier, reuse that VkDescriptorSet and skip AcquireDescriptorSet +
-        // vkUpdateDescriptorSets - only the bind-time dynamic offsets differ. Four
-        // entries with round-robin replacement rather than one: draws alternating
-        // between two programs (MC's chunk<->entity ping-pong) would thrash a single
-        // slot into a full re-allocate+write every draw. Reset each frame in BeginFrame
-        // because the frame's descriptor sets are recycled there.
-        struct DescriptorReuseEntry {
-            Uint64 signature = 0;
-            VkDescriptorSet set = VK_NULL_HANDLE;
-            Bool valid = false;
-        };
-        static constexpr Uint32 kDescriptorReuseMemoSize = 4;
-        DescriptorReuseEntry m_descriptorReuseMemo[kDescriptorReuseMemoSize];
-        Uint32 m_descriptorReuseMemoNext = 0;
-
-        // Dynamic-offset-only rebind (see BindProgramUniformBuffers): records the
-        // descriptor set selected by the last cacheable full walk of a program
-        // whose active bindings are exactly one dynamic UBO (single descriptor)
-        // plus combined-image samplers. When the next call proves every sampler
-        // descriptor input unchanged (samplerDescriptorsUnchangedHint) and the
-        // UBO re-resolves to the SAME VkBuffer+range - only the dynamic offset
-        // moved, the per-draw glUniform case - the walk collapses to: resolve one
-        // offset, rebind the recorded set with new pDynamicOffsets (Vulkan allows
-        // rebinding the same set with different dynamic offsets).
-        // Invalidation inventory: BeginFrame clears it (the frame's sets are
-        // recycled) and the frameIndex field guards cross-frame confusion on top;
-        // OnDescriptorSetLayoutDestroyed clears it (the set may be freed); a
-        // sampler-override walk clears it (mirrors m_descriptorReuseMemo); a
-        // program relink bumps the backend state version and thus programObj.hash
-        // so the key misses; the program lifetime id is never reused, so a
-        // deleted-and-recreated program misses; a texture/sampler/binding change
-        // drops the hint upstream; an arena wrap or growth resolves a different
-        // VkBuffer and misses. AcquireDescriptorSet's per-frame cursor only
-        // advances, so the recorded set is never re-written within its frame.
-        struct FastRebindMemo {
-            Bool valid = false;
-            Uint32 frameIndex = 0;
-            Uint64 programLifetimeId = 0;
-            ProgramFactory::HashType programHash = 0;
-            Uint32 uboBinding = 0;
-            VkBuffer uboBuffer = VK_NULL_HANDLE;
-            VkDeviceSize uboRange = 0;
-            VkDescriptorSet set = VK_NULL_HANDLE;
-        };
-        FastRebindMemo m_fastRebindMemo;
+        // Descriptor-set reuse across consecutive draws (see BindProgramUniformBuffers).
+        // When a draw's resolved descriptor content is byte-identical to the previous
+        // draw's, reuse the same VkDescriptorSet and skip AcquireDescriptorSet +
+        // vkUpdateDescriptorSets - only the bind-time dynamic offsets differ. Reset each
+        // frame in BeginFrame because the frame's descriptor sets are recycled there.
+        VkDescriptorSet m_lastBoundDescriptorSet = VK_NULL_HANDLE;
+        Uint64 m_lastDescriptorSignature = 0;
+        Bool m_hasLastDescriptor = false;
 
         // vkCmdBindDescriptorSets dedup: consecutive draws with a static uniform
         // block resolve to the same set AND the same dynamic offsets, so the
@@ -336,28 +245,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             SamplerNumericDomain viewFormatDomain = SamplerNumericDomain::Unknown;
             VkFormat viewFormat = VK_FORMAT_UNDEFINED;
             Bool viewFormatValid = false;
-            // Whole resolved descriptor from this binding's last full resolve. Reused
-            // ONLY under ResolveSamplerDescriptor's trustUnchangedHint, whose caller
-            // proves every resolve input unchanged; cleared with the per-frame reset
-            // (the cached VkSampler outlives a frame only via a fresh resolve, which
-            // also re-stamps it against VkSamplerManager's frame-boundary sweep).
-            VkDescriptorImageInfo info{};
-            Bool infoValid = false;
         };
         mutable Vector<SamplerResolveMemo> m_samplerResolveMemo;
-        // Exclusive upper bound on the entries of m_samplerResolveMemo that any resolve
-        // has ever written. The vector is sized to the DEVICE binding cap (256 on desktop
-        // NVIDIA), but a program declares 1-8 bindings, so the per-frame reset below was
-        // memsetting ~22 KB of never-touched entries every frame - a measurable slice of
-        // the per-frame fixed cost on draw-light frames. Every site that can turn any of
-        // an entry's *Valid flags on raises this mark first, so entries at or above it are
-        // provably still in their constructed (all-invalid) state and clearing them is a
-        // no-op. Never lowered except by Initialize/Shutdown, which rebuild the vector.
-        mutable Uint32 m_samplerResolveMemoHighWater = 0;
-        void NoteSamplerResolveMemoTouched(Uint32 binding) const {
-            if (binding >= m_samplerResolveMemoHighWater) {
-                m_samplerResolveMemoHighWater = binding + 1;
-            }
-        }
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.cpp

@@ -29,22 +29,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.Stride, sizeof(attr.Stride)));
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.Offset, sizeof(attr.Offset)));
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.IsInteger, sizeof(attr.IsInteger)));
-            XXHASH_VERIFY(XXH64_update(m_hashState, &attr.IsLong, sizeof(attr.IsLong)));
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.IsBgra, sizeof(attr.IsBgra)));
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.Divisor, sizeof(attr.Divisor)));
 
-            // The bound buffer's IDENTITY is a component of the key, and it has to be the
-            // buffer's never-reused lifetime id - NOT its heap address, which this used to
-            // hash. An address is recycled by the allocator, so a deleted-and-recreated
-            // buffer reproduces it; combined with a byte-identical attribute layout that
-            // reproduces the WHOLE content hash, and the hash is what
-            // TryBindResolvedVertexBindings accepts as proof that a memoised binding still
-            // reads the buffer it was resolved from. It did not: a destroyed buffer's GPU
-            // slice was bound for its successor's draw, which is how a transform-feedback
-            // capture came back holding a dead VAO's vertex data (0,0,0,1 - the previous
-            // test's positions) instead of its own.
-            // Zero for client memory (no buffer), which is a distinct identity of its own.
-            const Uint64 bufferKey = attr.Buffer ? attr.Buffer->GetLifetimeId() : 0;
+            // The buffer's heap address is an identity component of the key: a freed
+            // buffer's reused address can alias an old cache entry, but only under a
+            // byte-identical attribute layout - and the entry payload is a pure function
+            // of the hashed inputs, with the draw path re-resolving bindingBufferKeys
+            // against the live VAO attribute pointers, so an aliased hit returns exactly
+            // what a rebuild would. Address drift only grows the map; the OnFrameBoundary
+            // aging sweep bounds that.
+            const SizeT bufferKey = reinterpret_cast<SizeT>(attr.Buffer.get());
             XXHASH_VERIFY(XXH64_update(m_hashState, &bufferKey, sizeof(bufferKey)));
         }
 
@@ -75,12 +70,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
         const BackendVertexInputState& entry = GetOrCreateVertexInputState(vao, GetOrComputeHash(vao));
         vao.SetBackendStateMemo(&entry, m_evictionEpoch);
-        // Also mirror the layout identity and the two per-draw masks into the VAO's aux
-        // memo (pure VALUES derived from the VAO configuration, so config-version
-        // guarding alone is sound). The draw fast path reads them from the VAO object it
-        // already touched instead of chasing into this entry - see PackVertexInputAuxMemo.
-        vao.SetBackendAuxMemo(entry.layoutHash,
-                              PackVertexInputAuxMasks(entry.unsupportedAttribMask, entry.attributeLocationMask));
         return entry;
     }
 
@@ -108,7 +97,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
 
             const VkFormat sourceVkFormat =
-                ToVkVertexFormat(attr.Type, attr.Size, attr.Normalized, attr.IsInteger, attr.IsBgra, attr.IsLong);
+                ToVkVertexFormat(attr.Type, attr.Size, attr.Normalized, attr.IsInteger, attr.IsBgra);
             if (sourceVkFormat == VK_FORMAT_UNDEFINED) {
                 MGLOG_E("Unsupported vertex attribute layout (location=%u, type=%s, size=%d): the array is "
                         "enabled but cannot be mapped to a VkFormat",
@@ -284,7 +273,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     VkFormat VertexInputStateFactory::ToVkVertexFormat(DataType type, Int size, Bool normalized, Bool isInteger,
-                                                       Bool isBgra, Bool isLong) {
+                                                       Bool isBgra) {
         if (isBgra) {
             // GL_BGRA: four reversed-order components, always normalized (enforced at validation), only
             // legal with GL_UNSIGNED_BYTE or a 2_10_10_10 type. The reversed VkFormats put the
@@ -309,22 +298,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         case DataType::Int2101010Rev:
             if (isInteger || size != 4) return VK_FORMAT_UNDEFINED;
             return normalized ? VK_FORMAT_A2B10G10R10_SNORM_PACK32 : VK_FORMAT_A2B10G10R10_SSCALED_PACK32;
-        case DataType::Float64:
-            // A 64-bit attribute is fetched as its 32-bit word pair and bitcast back to double in the
-            // shader (PackDoubleVertexInputsPass does the shader half). That is bit-exact and, unlike
-            // VK_FORMAT_R64*_SFLOAT, needs no format capability: lavapipe reports bufferFeatures = 0
-            // for every R64 float format, so a native 64-bit vertex fetch is simply unavailable there
-            // while shaderFloat64 is not. Both halves key off nothing but the attribute being long,
-            // so they always agree without extra plumbing.
-            if (!isLong || isInteger || normalized) return VK_FORMAT_UNDEFINED;
-            switch (size) {
-            case 1: return VK_FORMAT_R32G32_UINT;
-            case 2: return VK_FORMAT_R32G32B32A32_UINT;
-            // A dvec3/dvec4 input is 6/8 uint32 components: no single VkFormat, and GL spreads it
-            // over two attribute locations, which the location-per-VAO-index model here does not
-            // express. Declined rather than fetched wrong.
-            default: return VK_FORMAT_UNDEFINED;
-            }
         case DataType::Float32:
             switch (size) {
             case 1: return VK_FORMAT_R32_SFLOAT;

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.h

@@ -28,12 +28,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         struct BackendVertexInputState {
             HashType hash = 0;
             // Hash of the resolved Vulkan vertex layout only (bindings, attributes,
-            // unsupported mask) - NO buffer identities. `hash` mixes each bound
-            // buffer's never-reused LIFETIME ID, so per-chunk VBOs mint a fresh
-            // identity per buffer; keying pipelines on that minted one VkPipeline per
-            // chunk section for an identical layout, defeating pipeline reuse and the
-            // per-draw memo. Pipelines depend only on the layout, so they key on this
-            // instead.
+            // unsupported mask) - NO buffer identities. `hash` mixes buffer heap
+            // addresses so per-chunk VBOs mint a fresh identity per buffer; keying
+            // pipelines on that minted one VkPipeline per chunk section for an
+            // identical layout, defeating pipeline reuse and the per-draw memo.
+            // Pipelines depend only on the layout, so they key on this instead.
             HashType layoutHash = 0;
             // Frame boundary of the last cache hit; entries idle past the
             // OnFrameBoundary retirement age are evicted (CPU heap only).
@@ -72,13 +71,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         ~VertexInputStateFactory() = default;
         VertexInputStateFactory(const VertexInputStateFactory&) = delete;
 
-        // The VAO aux-memo payload GetOrCreateVertexInputState(vao) stamps: aux0 is the
-        // entry's layoutHash, aux1 packs (unsupportedAttribMask << 32) | attributeLocationMask.
-        // Readers that find the aux memo valid can use these without resolving the entry.
-        static Uint64 PackVertexInputAuxMasks(Uint32 unsupportedAttribMask, Uint32 attributeLocationMask) {
-            return (static_cast<Uint64>(unsupportedAttribMask) << 32) | attributeLocationMask;
-        }
-
         HashType ComputeHash(const MG_State::GLState::VertexArrayObject& vao) const;
         // Memoized ComputeHash: reuses the VAO's cached hash while its config version
         // is unchanged. Use this on per-draw paths.
@@ -87,10 +79,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             const MG_State::GLState::VertexArrayObject& vao, HashType hash);
         const BackendVertexInputState& GetOrCreateVertexInputState(const MG_State::GLState::VertexArrayObject& vao);
         // Frame boundary hook: ages the cache and evicts entries not hit for many
-        // frames. The key mixes each bound buffer's never-reused lifetime id, so
-        // buffer/VAO churn keeps minting fresh keys - and does so by construction,
-        // not by luck: a recreated buffer can no longer land back on its dead
-        // predecessor's key. Without eviction the map grows for the whole session.
+        // frames. The key mixes buffer heap addresses, so buffer/VAO churn keeps
+        // minting fresh keys; without eviction the map grows for the whole session.
         // Entries hold no Vulkan handles (pipeline creation copies the descriptions)
         // and the draw path's entry reference never spans a frame boundary, so
         // eviction here needs no GPU-idle proof. Self-gated: one counter bump and
@@ -103,8 +93,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         static SizeT GetAttributeByteSize(DataType type, Int size, Bool isBgra);
 
     private:
-        static VkFormat ToVkVertexFormat(DataType type, Int size, Bool normalized, Bool isInteger, Bool isBgra = false,
-                                         Bool isLong = false);
+        static VkFormat ToVkVertexFormat(DataType type, Int size, Bool normalized, Bool isInteger, Bool isBgra = false);
         static Bool IsScaledIntegerVertexFormat(VkFormat format);
         static VkFormat ToFloat32VertexFormat(Int componentCount);
         Bool SupportsVertexBufferFormat(VkFormat format) const;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.cpp

@@ -242,15 +242,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     void VkBufferManager::TrackLiveResource(const SharedPtr<VkBufferResource>& resource) {
-        // Sweep on a doubling watermark rather than on every insert past the threshold. The old
-        // form walked the whole vector for each new buffer once the list passed 256, and when the
-        // buffers are all live the walk removes nothing and the list grows by one - so creating N
-        // live buffers cost ~N^2/2 expired() checks. Reclamation semantics are unchanged: the sweep
-        // still removes exactly the expired entries, just less often and with the same bound on how
-        // much dead weight can accumulate (at most as many entries as were live at the last sweep).
-        if (m_liveResources.size() >= std::max<SizeT>(kLiveResourcePruneThreshold, 2 * m_liveResourcesLastPruned)) {
+        if (m_liveResources.size() >= kLiveResourcePruneThreshold) {
             std::erase_if(m_liveResources, [](const WeakPtr<VkBufferResource>& weak) { return weak.expired(); });
-            m_liveResourcesLastPruned = m_liveResources.size();
         }
         m_liveResources.push_back(resource);
     }
@@ -258,7 +251,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void VkBufferManager::ReleaseAllLiveResources() {
         for (auto& weak : m_liveResources) {
             if (auto resource = weak.lock()) {
-                BumpSliceEpoch(*resource);
                 resource->buffer.Destroy();
                 resource->storageSize = 0;
                 resource->usageFlags = 0;
@@ -273,9 +265,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     Bool VkBufferManager::CreateResidentStorage(VkBufferResource& resource, VkDeviceSize size,
                                                 VkBufferUsageFlags usage, VkMemoryPropertyFlags requiredFlags) {
-        // The only place a resident VkBuffer handle is minted, so every resident slice
-        // change funnels through here (callers release the old handle first).
-        BumpSliceEpoch(resource);
         // Staged range copies write resident storage with vkCmdCopyBuffer.
         usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
         const Bool created = resource.buffer.Create({
@@ -362,10 +351,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (!resource) {
             return; // lazy: AcquireResidentSlice performs a full upload on creation
         }
-        // A respecify can change the size, the usage hint (so the resident/streamed
-        // route), and the contents at once; retire every memo before deciding what to
-        // do about the storage.
-        BumpSliceEpoch(*resource);
         // Any cached streaming slice refers to the previous contents.
         resource->transientFrameSerial = 0;
         if (!resource->buffer.IsValid()) {
@@ -398,9 +383,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (!resource) {
             return;
         }
-        // Drops the streaming memo below and may end in a storage swap or a deferred
-        // full re-upload, so no memoised slice survives this.
-        BumpSliceEpoch(*resource);
         resource->transientFrameSerial = 0;
         if (!resource->buffer.IsValid() || resource->pendingFullUpload) {
             return;
@@ -433,7 +415,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (!resource) {
             return;
         }
-        BumpSliceEpoch(*resource);
         resource->transientFrameSerial = 0;
         if (!resource->buffer.IsValid() || resource->pendingFullUpload) {
             return;
@@ -493,13 +474,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             TrackLiveResource(resource);
         }
 
-        // Bumped for the request, not just for the storage it may create. This is the
-        // one call the frontend makes when a buffer becomes persistently mapped for
-        // writing (BufferObject::AcquireMemoryRange), and a map the backend declines
-        // keeps mutating its shadow with no further API call - so it is what lets
-        // GetSliceEpochCounter stand for "no buffer needs a persistent-map range push".
-        BumpSliceEpoch(*resource);
-
         // Idempotent: an already-backed buffer returns the same mapped base.
         if (resource->persistentMapped && resource->buffer.IsValid() && resource->storageSize == size) {
             return resource->buffer.GetMappedData();
@@ -610,41 +584,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return true;
         }
 
-        // Idle-content promotion: see the field comments in VkBufferResource. The
-        // streak counts frame BOUNDARIES survived unchanged (the same-frame memo
-        // above swallows repeat draws), so a promotion needs the content stable
-        // for kStreamedPromotionStreak whole frames - one no-op frame does not
-        // trigger the resident round-trip, whose creation upload is itself a
-        // staged copy worth avoiding for content that is about to change again.
-        constexpr Uint32 kStreamedPromotionStreak = 2;
-        if (resource->promotedResident) {
-            if (resource->promotedChangeSerial == changeSerial &&
-                static_cast<VkDeviceSize>(bufferObject->GetSize()) == size) {
-                return AcquireResidentSlice(kind, bufferObject, outSlice);
-            }
-            resource->promotedResident = false;
-            resource->unchangedStreak = 0;
-        } else if (resource->transientChangeSerial == changeSerial && resource->transientSize == size &&
-                   resource->transientFrameSerial != 0) {
-            if (++resource->unchangedStreak >= kStreamedPromotionStreak) {
-                // Promotion moves the buffer off the arena and onto resident storage.
-                resource->promotedResident = true;
-                resource->promotedChangeSerial = changeSerial;
-                BumpSliceEpoch(*resource);
-                if (AcquireResidentSlice(kind, bufferObject, outSlice)) {
-                    return true;
-                }
-                resource->promotedResident = false; // resident creation failed: stream as before
-            }
-        } else {
-            resource->unchangedStreak = 0;
-        }
-
-        // A fresh arena allocation: a different slice than the last call handed back,
-        // and (below) the point where a promoted buffer's resident storage is released.
-        // The stable-promotion exit above returns before this, so a buffer the app has
-        // stopped touching keeps one slice for as long as it keeps its resident storage.
-        BumpSliceEpoch(*resource);
         if (!m_transientUploadArena.Upload(m_currentFrameIndex, bufferObject->MappedData(), size, 16,
                                            outSlice)) {
             return false;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.h

@@ -57,33 +57,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // never orphaned or recreated. Draw-time acquire binds it directly, no re-upload.
         Bool persistentMapped = false;
 
-        // Bumped from a manager-wide counter every time anything that decides which
-        // BufferSlice an Acquire*Slice call hands back changes: storage created or
-        // released, a full re-upload becoming due, a promotion/demotion between
-        // resident and streamed storage, or a new per-frame arena slice. Callers that
-        // memoise a resolved slice compare this to prove the memo still describes the
-        // buffer. The counter is manager-wide (never per-resource) so a freshly
-        // created resource - including one that replaces a destroyed resource at the
-        // same address - can never reproduce a value some memo already holds. 0 means
-        // "no slice has ever been handed out", which no memo can match.
-        Uint64 sliceEpoch = 0;
-
         // Cached transient (streaming) slice for the current frame.
         BufferSlice transientSlice{};
         Uint64 transientFrameSerial = 0;
         Uint64 transientChangeSerial = 0;
         VkDeviceSize transientSize = 0;
-
-        // Streaming re-copies the whole store into the per-frame arena on every
-        // frame, which is right for genuinely per-frame data but pure waste for a
-        // Dynamic-hinted buffer the app stopped touching. After the content
-        // survives kStreamedPromotionStreak frame boundaries unchanged it is
-        // promoted to resident storage (one final upload, then zero per-frame
-        // cost); the first content change demotes it back to streaming, and the
-        // streaming path's existing downgrade releases the resident store.
-        Uint32 unchangedStreak = 0;
-        Bool promotedResident = false;
-        Uint64 promotedChangeSerial = 0;
     };
 
     // Supplies a command buffer that is recording and outside any render pass,
@@ -143,11 +121,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void OnResourceDestroyed(SharedPtr<MG_State::GLState::BackendBufferResource>&& resource);
 
         Uint64 GetFrameSerial() const { return m_frameSerial; }
-        // Highest value handed to any VkBufferResource::sliceEpoch. Unchanged since a
-        // memo was taken means no buffer this manager owns changed which slice it hands
-        // back, and none was persistently mapped, in between - so a memo of resolved
-        // slices needs no per-buffer re-check. See AcquirePersistentMap for the mapping half.
-        Uint64 GetSliceEpochCounter() const { return m_sliceEpochCounter; }
         // Highest frame serial whose GPU work is known complete; serials at or
         // below it may be considered signaled. Drives IsResourceBusy and the
         // backend GL fence objects.
@@ -174,8 +147,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void DestroyAllDeferredReleases();
         void TrackLiveResource(const SharedPtr<VkBufferResource>& resource);
         void ReleaseAllLiveResources();
-        // See VkBufferResource::sliceEpoch.
-        void BumpSliceEpoch(VkBufferResource& resource) { resource.sliceEpoch = ++m_sliceEpochCounter; }
 
         VkBufferManagerInitInfo m_initInfo{};
         BufferArena m_transientUploadArena;
@@ -183,14 +154,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Vector<Vector<VkBufferObject>> m_deferredBufferReleases;
         Vector<Vector<SharedPtr<VkBufferResource>>> m_deferredResourceReleases;
         Vector<WeakPtr<VkBufferResource>> m_liveResources;
-    // Size m_liveResources had just after the last sweep; the next sweep waits for it to double.
-    SizeT m_liveResourcesLastPruned = 0;
         Uint32 m_currentFrameIndex = 0;
         Uint64 m_frameSerial = 1;
         Uint64 m_completedSerialFloor = 0;
-        // Never reset (not even by Shutdown): a value handed to a resource must stay
-        // unique for the process, or a memo taken before a re-initialize could match
-        // a different resource's state after it.
-        Uint64 m_sliceEpochCounter = 0;
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferObject.cpp

@@ -176,4 +176,16 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return true;
     }
 
+    BufferSlice VkBufferObject::GetSlice(VkDeviceSize offset, VkDeviceSize size) const {
+        MOBILEGL_ASSERT(offset <= m_size, "VkBufferObject::GetSlice offset out of range");
+        const VkDeviceSize resolvedSize = (size == VK_WHOLE_SIZE) ? (m_size - offset) : size;
+        MOBILEGL_ASSERT(offset + resolvedSize <= m_size, "VkBufferObject::GetSlice range out of bounds");
+
+        BufferSlice slice{};
+        slice.buffer = m_buffer;
+        slice.offset = offset;
+        slice.size = resolvedSize;
+        slice.mapped = (m_mappedData != nullptr) ? static_cast<Uint8*>(m_mappedData) + offset : nullptr;
+        return slice;
+    }
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferObject.h

@@ -48,20 +48,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         VkBuffer GetHandle() const { return m_buffer; }
         VkDeviceSize GetSize() const { return m_size; }
-        // Inline: runs on the per-draw acquire path (a resident buffer bind is a
-        // GetSlice per binding), where an out-of-line call was measurable.
-        BufferSlice GetSlice(VkDeviceSize offset = 0, VkDeviceSize size = VK_WHOLE_SIZE) const {
-            MOBILEGL_ASSERT(offset <= m_size, "VkBufferObject::GetSlice offset out of range");
-            const VkDeviceSize resolvedSize = (size == VK_WHOLE_SIZE) ? (m_size - offset) : size;
-            MOBILEGL_ASSERT(offset + resolvedSize <= m_size, "VkBufferObject::GetSlice range out of bounds");
-
-            BufferSlice slice{};
-            slice.buffer = m_buffer;
-            slice.offset = offset;
-            slice.size = resolvedSize;
-            slice.mapped = (m_mappedData != nullptr) ? static_cast<Uint8*>(m_mappedData) + offset : nullptr;
-            return slice;
-        }
+        BufferSlice GetSlice(VkDeviceSize offset = 0, VkDeviceSize size = VK_WHOLE_SIZE) const;
         void* GetMappedData() const { return m_mappedData; }
         Bool IsMapped() const { return m_mappedData != nullptr; }
         Bool IsValid() const { return m_allocator != nullptr && m_buffer != VK_NULL_HANDLE && m_allocation != nullptr; }

MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.cpp

@@ -8,75 +8,15 @@
 
 #include "VkClearManager.h"
 
-#include "MG_State/GLState/Core.h"
 #include "MG_Util/Converters/MGToStr/FramebufferEnumConverter.h"
 #include "MG_Util/Converters/MGToStr/TextureEnumConverter.h"
 
-#include <algorithm>
-#include <cmath>
-
 namespace MobileGL::MG_Backend::DirectVulkan {
     static Bool IsCubeMapFaceUploadTarget(TextureUploadTarget target) {
         return target >= TextureUploadTarget::CubeMapPositiveX &&
                target <= TextureUploadTarget::CubeMapNegativeZ;
     }
 
-    VkClearColorValue MakeVkClearColorValue(const ClearAttachmentPayload& payload, Bool formatLacksAlpha) {
-        VkClearColorValue clearValue{};
-        switch (payload.colorEncoding) {
-        case ClearColorEncoding::Int:
-            clearValue.int32[0] = payload.colorInt.x();
-            clearValue.int32[1] = payload.colorInt.y();
-            clearValue.int32[2] = payload.colorInt.z();
-            clearValue.int32[3] = formatLacksAlpha ? 1 : payload.colorInt.w();
-            break;
-        case ClearColorEncoding::Uint:
-            clearValue.uint32[0] = payload.colorUint.x();
-            clearValue.uint32[1] = payload.colorUint.y();
-            clearValue.uint32[2] = payload.colorUint.z();
-            clearValue.uint32[3] = formatLacksAlpha ? 1u : payload.colorUint.w();
-            break;
-        case ClearColorEncoding::Float:
-            clearValue.float32[0] = payload.color.x();
-            clearValue.float32[1] = payload.color.y();
-            clearValue.float32[2] = payload.color.z();
-            clearValue.float32[3] = formatLacksAlpha ? 1.0f : payload.color.w();
-            break;
-        }
-        return clearValue;
-    }
-
-    void PreCompensateSrgbClearColor(ClearAttachmentPayload& payload, VkFormat destinationFormat) {
-        if (payload.colorEncoding != ClearColorEncoding::Float) return;
-        // With GL_FRAMEBUFFER_SRGB enabled GL performs the encoding itself, so the driver doing it
-        // is exactly right and there is nothing to undo.
-        if (MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb)) return;
-        if (ResolveSrgbAttachmentWriteFormat(destinationFormat, false) == destinationFormat) return;
-
-        // sRGB -> linear (GL 4.6 core 8.24), applied to the colour channels only: alpha is stored
-        // linearly in an sRGB format and must pass through untouched.
-        const auto toLinear = [](Float encoded) {
-            const Float value = std::clamp(encoded, 0.0f, 1.0f);
-            return value <= 0.04045f ? value / 12.92f : std::pow((value + 0.055f) / 1.055f, 2.4f);
-        };
-        payload.color = FloatVec4(toLinear(payload.color.x()), toLinear(payload.color.y()),
-                                  toLinear(payload.color.z()), payload.color.w());
-    }
-
-    void ForceOpaqueClearAlpha(ClearAttachmentPayload& payload) {
-        switch (payload.colorEncoding) {
-        case ClearColorEncoding::Int:
-            payload.colorInt = IntVec4(payload.colorInt.x(), payload.colorInt.y(), payload.colorInt.z(), 1);
-            break;
-        case ClearColorEncoding::Uint:
-            payload.colorUint = UintVec4(payload.colorUint.x(), payload.colorUint.y(), payload.colorUint.z(), 1u);
-            break;
-        case ClearColorEncoding::Float:
-            payload.color = FloatVec4(payload.color.x(), payload.color.y(), payload.color.z(), 1.0f);
-            break;
-        }
-    }
-
     static Bool PendingClearMatchesTextureIdentity(const PendingClearKey& key, const TextureIdentity& identity) {
         return key.texture == identity.texture && key.textureLifetimeId == identity.lifetimeId;
     }

MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.h

@@ -24,41 +24,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint32 stencil{};
     };
 
-    // A colour clear reaches us from one of glClear/ClearBufferfv, ClearBufferiv or
-    // ClearBufferuiv, and Vulkan reads VkClearColorValue's union according to the destination
-    // image's format rather than converting between the members - a float written where an
-    // integer format is expected is reinterpreted bit for bit, not rounded. Remember which entry
-    // point supplied the value so the member written when the clear is materialized matches.
-    enum class ClearColorEncoding : Uint8 { Float, Int, Uint };
-
     struct ClearAttachmentPayload {
         GLbitfield mask = 0;
         FloatVec4 color = FloatVec4(0.0f, 0.0f, 0.0f, 0.0f);
-        ClearColorEncoding colorEncoding = ClearColorEncoding::Float;
-        IntVec4 colorInt = IntVec4(0, 0, 0, 0);
-        UintVec4 colorUint = UintVec4(0u, 0u, 0u, 0u);
         Float depth = 1.0f;
         Uint32 stencil = 0;
     };
 
-    // Builds the clear value for `payload` in the union member its encoding calls for.
-    // `formatLacksAlpha` applies GL's rule that a format without an alpha channel reads as one,
-    // expressed in whichever type matches (GL 4.6 core 15.2.3).
-    VkClearColorValue MakeVkClearColorValue(const ClearAttachmentPayload& payload, Bool formatLacksAlpha);
-
-    // Applies that same rule in place, for the paths that have to bake it into the payload before
-    // the destination is known.
-    void ForceOpaqueClearAlpha(ClearAttachmentPayload& payload);
-
-    // vkCmdClearColorImage names the image, so the driver applies the destination format's transfer
-    // function to whatever value it is handed. Every other write path in this backend goes through
-    // the UNORM twin view while GL_FRAMEBUFFER_SRGB is off (ResolveSrgbAttachmentWriteFormat) and
-    // therefore stores the raw value GL asked for. Rewrites `payload` to the linear colour whose
-    // encoding is that raw value, so a direct image clear of an sRGB destination agrees with them.
-    // A no-op for every other format, for integer clear encodings, and when GL is doing the
-    // encoding itself.
-    void PreCompensateSrgbClearColor(ClearAttachmentPayload& payload, VkFormat destinationFormat);
-
     struct PendingClearKey {
         MG_State::GLState::ITextureObject* texture = nullptr;
         Uint64 textureLifetimeId = 0;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.cpp

@@ -50,11 +50,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
     }
 
-    static Bool ColorFormatLacksAlpha(const MG_State::GLState::ITextureObject* texture) {
-        return texture != nullptr && MG_Util::GetBaseInternalFormatComponentCount(texture->GetFormat()) == 3;
-    }
-
-    [[maybe_unused]] static Float ResolveColorClearAlpha(const MG_State::GLState::ITextureObject* texture, Float requestedAlpha) {
+    static Float ResolveColorClearAlpha(const MG_State::GLState::ITextureObject* texture, Float requestedAlpha) {
         if (texture != nullptr && MG_Util::GetBaseInternalFormatComponentCount(texture->GetFormat()) == 3) {
             return 1.0f;
         }
@@ -87,20 +83,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     static VkImageViewType ResolveAttachmentViewType(
         const MG_State::GLState::FramebufferAttachmentObject& attachment,
         const VkTextureManager::TextureResource& resource) {
-        if (attachment.IsLayered()) {
-            return resource.viewType;
-        }
-        // A non-layered attachment names ONE layer, so the view over it is a plain 2D view whatever
-        // the image's own view type is. The cube-face upload targets always meant this; a cube map
-        // array attached through glFramebufferTextureLayer means it too, and a CUBE_ARRAY view over
-        // a single layer is not a legal attachment. The CUBE arm is inert today - no frontend path
-        // produces a non-layered cube attachment without a face upload target - and is kept for
-        // symmetry with CUBE_ARRAY.
-        if (IsCubeMapFaceUploadTarget(attachment.GetTextureUploadTarget()) ||
-            resource.viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY || resource.viewType == VK_IMAGE_VIEW_TYPE_CUBE) {
-            return VK_IMAGE_VIEW_TYPE_2D;
-        }
-        return resource.viewType;
+        return !attachment.IsLayered() && IsCubeMapFaceUploadTarget(attachment.GetTextureUploadTarget()) ?
+            VK_IMAGE_VIEW_TYPE_2D :
+            resource.viewType;
     }
 
     static MG_State::GLState::ITextureObject* ResolveCompleteColorAttachmentTexture(
@@ -541,13 +526,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         pending.renderbuffer = renderbuffer;
         pending.payload.mask |= clearPayload.mask;
         if ((clearPayload.mask & GL_COLOR_BUFFER_BIT) != 0) {
-            // The whole colour description, not just the float vector: an integer clear keeps its
-            // value in colorInt/colorUint, and dropping the encoding here would leave the pending
-            // clear reading as an all-zero float one.
             pending.payload.color = clearPayload.color;
-            pending.payload.colorEncoding = clearPayload.colorEncoding;
-            pending.payload.colorInt = clearPayload.colorInt;
-            pending.payload.colorUint = clearPayload.colorUint;
         }
         if ((clearPayload.mask & GL_DEPTH_BUFFER_BIT) != 0) {
             pending.payload.depth = clearPayload.depth;
@@ -945,7 +924,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     if (rbHasClear &&
                         MG_Util::GetBaseInternalFormatComponentCount(renderbuffer->GetInternalFormat()) == 3) {
                         // RGB renderbuffers are backed by an RGBA image; the missing alpha reads as 1.
-                        ForceOpaqueClearAlpha(rbClearPayload);
+                        rbClearPayload.color =
+                            FloatVec4(rbClearPayload.color.x(), rbClearPayload.color.y(),
+                                      rbClearPayload.color.z(), 1.0f);
                     }
 
                     const VkImageLayout trackedRbLayout = rbResource->layout;
@@ -1515,8 +1496,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 }
             }
             if ((clearPayload.mask & GL_COLOR_BUFFER_BIT) != 0) {
-                clearValues[pending.attachmentIndex].color =
-                    MakeVkClearColorValue(clearPayload, ColorFormatLacksAlpha(liveTexture.get()));
+                clearValues[pending.attachmentIndex].color = {
+                    clearPayload.color.x(),
+                    clearPayload.color.y(),
+                    clearPayload.color.z(),
+                    ResolveColorClearAlpha(liveTexture.get(), clearPayload.color.w())
+                };
             }
             if ((clearPayload.mask & GL_DEPTH_BUFFER_BIT) != 0) {
                 clearValues[pending.attachmentIndex].depthStencil.depth = clearPayload.depth;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.h

@@ -16,7 +16,6 @@
 #include "MG_State/GLState/FramebufferState/FramebufferObject.h"
 
 #include <Includes.h>
-#include <unordered_map>
 #include <vk_mem_alloc.h>
 
 namespace MobileGL::MG_Backend::DirectVulkan {
@@ -315,27 +314,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint64 deferredAtFrame = 0;
         };
 
-        // Node-based std::unordered_map, deliberately not FastSTL's open-addressing UnorderedMap:
-        // callers cache a RenderbufferResource* - or a bare &resource->layout - and then make further
-        // calls that touch this map. BlitFramebuffer is the one that bit: it resolves the source and
-        // destination colour bindings (ResolveColorBlitBinding caches &rbResource->layout), then
-        // materializes the source's pending clear, which looks that same resource up again. FastSTL's
-        // operator[] runs its load-factor check before find_key and reallocates the whole bucket array
-        // when occupancy crosses it, so even a plain lookup relocates every element; erase only
-        // tombstones and never decrements the occupancy, so the doubling keeps firing. After a
-        // relocation the cached pointer names freed storage still holding the pre-clear
-        // VK_IMAGE_LAYOUT_UNDEFINED, and BlitFramebuffer bails out at "source image layout is
-        // undefined", silently dropping the blit - renderbuffers_storage_multisample read back zero
-        // instead of the clear colour on exactly the iterations that grew the table.
-        //
-        // Reordering the materialize ahead of the resolves - the fix ReadPixels got - does not cover
-        // this: the destination resolve still runs after the source pointer is taken. The depth blit,
-        // GetOrCreateRenderPass's depthRenderbufferResource and ReadDepthStencilPixels cache the same
-        // kind of pointer, so the invariant belongs in the container rather than in a per-call-site
-        // ordering rule. m_textureResources is node-based for the same reason. This buys stability
-        // across rehash and insert only - erase still invalidates the erased element, which is safe
-        // here because a renderbuffer that is an FBO attachment is held alive by that attachment.
-        std::unordered_map<MG_State::GLState::RenderbufferObject*, RenderbufferResource> m_renderbufferResources;
+        UnorderedMap<MG_State::GLState::RenderbufferObject*, RenderbufferResource> m_renderbufferResources;
         UnorderedMap<MG_State::GLState::RenderbufferObject*, PendingRenderbufferClear> m_pendingRenderbufferClears;
         Vector<DeferredRenderbufferRelease> m_deferredRenderbufferReleases;
         // Supported sample counts per attachment format, so per-draw resource lookups

MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.cpp

@@ -164,7 +164,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         XXHASH_VERIFY(XXH64_update(m_hashState, &maxAnisotropy, sizeof(maxAnisotropy)));
         const auto compareMode = sampler.GetCompareMode();
         XXHASH_VERIFY(XXH64_update(m_hashState, &compareMode, sizeof(compareMode)));
-        const auto compareFunc = sampler.GetSamplerCompareFunc();
+        const auto compareFunc = ResolveCompareFunc(sampler, texture);
         XXHASH_VERIFY(XXH64_update(m_hashState, &compareFunc, sizeof(compareFunc)));
         const auto borderColor = ResolveVkBorderColor(sampler, texture);
         XXHASH_VERIFY(XXH64_update(m_hashState, &borderColor, sizeof(borderColor)));
@@ -207,7 +207,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         samplerInfo.anisotropyEnable = maxAnisotropy > 1.0f ? VK_TRUE : VK_FALSE;
         samplerInfo.maxAnisotropy = maxAnisotropy;
         samplerInfo.compareEnable = sampler.GetCompareMode() == SamplerCompareMode::CompareToTexture ? VK_TRUE : VK_FALSE;
-        samplerInfo.compareOp = ToVkCompareOp(sampler.GetSamplerCompareFunc());
+        samplerInfo.compareOp = ToVkCompareOp(ResolveCompareFunc(sampler, texture));
         // Must match BuildSamplerKey's resolution exactly.
         samplerInfo.maxLod = ResolveSingleLevelMaxLod(sampler, singleLevelView);
         samplerInfo.minLod = ResolveEffectiveMinLod(sampler, samplerInfo.maxLod);
@@ -281,15 +281,24 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
     }
 
+    SamplerCompareFunc VkSamplerManager::ResolveCompareFunc(const MG_State::GLState::SamplerObject& sampler,
+                                                            const MG_State::GLState::ITextureObject& texture) {
+        const auto compareFunc = sampler.GetSamplerCompareFunc();
+        if (sampler.GetCompareMode() == SamplerCompareMode::CompareToTexture &&
+            IsDepthTextureFormat(texture.GetFormat()) && compareFunc == SamplerCompareFunc::Always) {
+            return SamplerCompareFunc::LessEqual;
+        }
+
+        return compareFunc;
+    }
+
     VkBorderColor VkSamplerManager::ResolveVkBorderColor(const MG_State::GLState::SamplerObject& sampler,
                                                          const MG_State::GLState::ITextureObject& texture) {
         if (!UsesBorderColor(sampler)) {
             return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
         }
 
-        // Border colour is sampler state: a bound sampler object supplies its own, and a texture
-        // with none reaches the very same value through the sampler object it owns.
-        const auto& borderColor = sampler.GetBorderColor();
+        const auto& borderColor = texture.GetBorderColor();
         const Bool isDepthTexture = IsDepthTextureFormat(texture.GetFormat());
 
         if (isDepthTexture) {

MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.h

@@ -69,6 +69,8 @@ private:
     static VkSamplerMipmapMode ToVkMipmapMode(SamplerMipmapMode mode);
     static VkSamplerAddressMode ToVkAddressMode(SamplerWrapMode mode);
     static VkCompareOp ToVkCompareOp(SamplerCompareFunc func);
+    static SamplerCompareFunc ResolveCompareFunc(const MG_State::GLState::SamplerObject& sampler,
+                                                 const MG_State::GLState::ITextureObject& texture);
     static VkBorderColor ResolveVkBorderColor(const MG_State::GLState::SamplerObject& sampler,
                                               const MG_State::GLState::ITextureObject& texture);
     // The anisotropy Vulkan will actually apply: 1.0 (i.e. disabled) unless the feature is on and

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.cpp

@@ -15,7 +15,6 @@
 #include "MG_Util/Converters/MGToVk/TextureEnumConverter.h"
 
 #include <Config.h>
-#include <algorithm>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
@@ -26,14 +25,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     // Compute shaders may legally sample framebuffer-attached textures (the GL feedback-loop rule
     // only covers rendering commands; e.g. Flywheel's Hi-Z depth pyramid downsample samples the
     // depth attachment of the bound draw framebuffer), so sampled-read barriers must cover the
-    // compute stage in addition to the graphics stages. Set at Initialize from the renderer's
-    // device-feature-derived mask: geometry/tessellation stage bits are invalid in a barrier when
-    // their feature is off (VUID-vkCmdPipelineBarrier-srcStageMask-04090/-04091), and ALL_GRAPHICS
-    // would also serialize against non-shader stages. The default only matters before a device
-    // exists, when nothing records barriers.
-    static VkPipelineStageFlags s_sampledReadStages =
-        VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-        VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+    // compute stage in addition to the graphics stages.
+    static constexpr VkPipelineStageFlags kSampledReadStages =
+        VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 
     static Uint32 ComputeFullMipLevelCount(const IntVec3& baseTexelSize) {
         Int maxDimension = std::max<Int>(baseTexelSize.x(),
@@ -199,7 +193,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
         case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
         case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-            outSrcStageMask = s_sampledReadStages;
+            outSrcStageMask = kSampledReadStages;
             outSrcAccessMask = VK_ACCESS_SHADER_READ_BIT;
             return;
         case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
@@ -247,7 +241,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
         case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL:
         case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
-            outDstStageMask = s_sampledReadStages;
+            outDstStageMask = kSampledReadStages;
             outDstAccessMask = VK_ACCESS_SHADER_READ_BIT;
             return;
         case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
@@ -570,27 +564,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             outShape.depth = 1;
             outShape.arrayLayers = 6;
             return true;
-        case TextureUploadTarget::CubeMapArray:
-        case TextureUploadTarget::ProxyCubeMapArray:
-            // GL_TEXTURE_CUBE_MAP_ARRAY is an array texture whose layers happen to be cube faces:
-            // one 2D image with arrayLayers = 6 * cubeCount, CUBE_COMPATIBLE so the whole thing can
-            // be sampled as a samplerCubeArray. glTexStorage3D hands the 6*n through as the GL depth
-            // and the upload path's depthSelectsArrayLayer already lists VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
-            // so the copies address layers correctly.
-            //
-            // A depth that is not a whole number of cubes, or a non-square level, has no Vulkan shape
-            // - declined the way every other unrepresentable target is. This function's Bool return
-            // exists for exactly that; asserting here would abort the process on ordinary application
-            // input, GL_PROXY_TEXTURE_CUBE_MAP_ARRAY above all.
-            if (texelSize.z() <= 0 || (texelSize.z() % 6) != 0 || texelSize.x() != texelSize.y()) {
-                return false;
-            }
-            outShape.imageType = VK_IMAGE_TYPE_2D;
-            outShape.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
-            outShape.imageFlags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
-            outShape.depth = 1;
-            outShape.arrayLayers = static_cast<Uint32>(texelSize.z());
-            return true;
         default:
             return false;
         }
@@ -605,7 +578,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_commandPool = initInfo.commandPool;
         m_graphicsQueue = initInfo.graphicsQueue;
         m_imageFormatListSupported = initInfo.imageFormatListSupported;
-        s_sampledReadStages = initInfo.sampledReadStageMask;
         m_currentFrameIndex = 0;
         m_deferredReleases.clear();
         m_deferredReleases.resize(initInfo.frameCount);
@@ -621,34 +593,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         TextureResource::s_device = m_device;
         TextureResource::s_allocator = m_allocator;
 
-        // Own pool for the recycled upload-batch command buffers. Parking a
-        // dozen reset-but-alive command buffers in the renderer's shared pool
-        // interleaves their retained chunks with the frame command buffers
-        // allocated/freed there every frame; isolating them keeps both pools'
-        // internal allocators dense.
-        VkCommandPoolCreateInfo uploadPoolInfo{VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO};
-        uploadPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT |
-                               VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
-        uploadPoolInfo.queueFamilyIndex = initInfo.graphicsQueueFamilyIndex;
-        VK_VERIFY(vkCreateCommandPool(m_device, &uploadPoolInfo, nullptr, &m_uploadCommandPool),
-                  "vkCreateCommandPool(texture upload batch)");
-
         return true;
     }
 
     void VkTextureManager::Shutdown() {
         if (m_device != VK_NULL_HANDLE) {
-            // A still-open (never-submitted) batch is discarded, not submitted:
-            // the renderer has already drained the device and the data has no
-            // observer. Submitted batches are waited and recycled, then the
-            // pools they recycled into are destroyed.
-            DiscardPendingUploadBatch();
             ReclaimCompletedUploads(/*waitAll=*/true);
-            DestroyUploadPools();
-            if (m_uploadCommandPool != VK_NULL_HANDLE) {
-                vkDestroyCommandPool(m_device, m_uploadCommandPool, nullptr);
-                m_uploadCommandPool = VK_NULL_HANDLE;
-            }
         }
         DestroyDeferredReleases();
         ++m_resourceEraseEpoch;  // every memoized resource pointer dies with the map
@@ -872,23 +822,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (resource == nullptr || resource->image == VK_NULL_HANDLE || mipLevel >= resource->mipLevels) {
             return VK_NULL_HANDLE;
         }
-        // A 3D image has arrayLayers == 1 and keeps its GL layers on the z axis, so a per-slice
-        // attachment view is a 2D view whose "array layer" is the slice - legal only on a
-        // 2D-array-compatible image (VUID-VkImageViewCreateInfo-image-04970), which
-        // SyncTextureResource asks for and may have had refused per format.
-        if (resource->viewType == VK_IMAGE_VIEW_TYPE_3D && viewType == VK_IMAGE_VIEW_TYPE_2D) {
-            const Uint32 sliceCount = std::max(resource->depth >> mipLevel, 1u);
-            if ((resource->imageCreateFlags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT) == 0 ||
-                layerCount == 0 || baseArrayLayer >= sliceCount || baseArrayLayer + layerCount > sliceCount) {
-                MGLOG_D("%s: cannot name slice span [%u, %u) of 3D textureId=%d (mip %u has %u slices, "
-                        "2D-array-compatible=%d)",
-                        __func__, baseArrayLayer, baseArrayLayer + layerCount, texture.GetExternalIndex(),
-                        mipLevel, sliceCount,
-                        (int)((resource->imageCreateFlags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT) != 0));
-                return VK_NULL_HANDLE;
-            }
-        } else if (layerCount == 0 || baseArrayLayer >= resource->arrayLayers ||
-                   baseArrayLayer + layerCount > resource->arrayLayers) {
+        if (layerCount == 0 || baseArrayLayer >= resource->arrayLayers ||
+            baseArrayLayer + layerCount > resource->arrayLayers) {
             MGLOG_D("%s: invalid layer span [%u, %u) for textureId=%d arrayLayers=%u",
                     __func__, baseArrayLayer, baseArrayLayer + layerCount, texture.GetExternalIndex(),
                     resource->arrayLayers);
@@ -1255,7 +1190,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
 
         const Bool ok = TransitionImageLayout(commandBuffer, resource->image, resource->layout, targetLayout, srcStageMask,
-                                              s_sampledReadStages, srcAccessMask,
+                                              kSampledReadStages, srcAccessMask,
                                               VK_ACCESS_SHADER_READ_BIT, resource->aspect, 0, resource->mipLevels,
                                               resource->arrayLayers);
         MOBILEGL_ASSERT(ok, "TransitionTextureForSampling: transition failed for textureId=%d", texture.GetExternalIndex());
@@ -1557,28 +1492,20 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // preserve-copy path below carries the pixels over), so sequentially-
         // defined atlas mips do not recreate per level, and glGenerateMipmap -
         // which defines every level before syncing - works unchanged.
+        const Uint32 backingMipLevels =
+            isMultisampleTexture ? 1u
+            : (mipLevels > 1 ? std::max(mipLevels, ComputeFullMipLevelCount(texelSize)) : 1u);
         TextureShapeInfo shapeInfo{};
         const Bool supportedShape = TryResolveTextureShapeInfo(texture, uploadTarget, texelSize, shapeInfo);
-        // ComputeFullMipLevelCount takes max(x, y, z), and for every ARRAY shape z is the layer
-        // count, not a mip-able axis: a 4x4 array with 192 layers asked for 6 levels on an image
-        // whose legal maximum is 3 (VUID-VkImageCreateInfo-mipLevels-00958). Only the image's own
-        // extent - width, height and shapeInfo.depth, which is 1 for every array - can bound it.
-        // lavapipe has been letting this through unvalidated; a strict driver would not.
-        const IntVec3 mipExtent{texelSize.x(), texelSize.y(), static_cast<Int>(shapeInfo.depth)};
-        const Uint32 fullMipLevels = ComputeFullMipLevelCount(mipExtent);
-        const Uint32 backingMipLevels =
-            isMultisampleTexture ? 1u : (mipLevels > 1 ? std::min(std::max(mipLevels, fullMipLevels), fullMipLevels) : 1u);
+        MOBILEGL_ASSERT(supportedShape,
+                        "SyncTextureResource: unsupported uploadTarget=%s textureTarget=%s textureId=%d size=(%d,%d,%d) "
+                        "mipLevels=%u vkViewType=%d",
+                        MG_Util::ConvertTextureUploadTargetToString(uploadTarget).c_str(),
+                        MG_Util::ConvertTextureTargetToString(texture.GetTarget()).c_str(),
+                        texture.GetExternalIndex(), texelSize.x(), texelSize.y(), texelSize.z(), mipLevels,
+                        static_cast<Int>(MG_Util::ConvertTextureUploadTargetToVkEnum(uploadTarget)));
         if (!supportedShape) {
-            // A gap in this backend's coverage, not a broken invariant: the GL front end accepts
-            // targets this manager has no Vulkan image shape for yet (cube map arrays above all).
-            // Declining the sync leaves the texture unbacked - wrong, but recoverable - where an
-            // assertion would take the whole process down instead.
-            MGLOG_W("SyncTextureResource: unsupported uploadTarget=%s textureTarget=%s textureId=%d size=(%d,%d,%d) "
-                    "mipLevels=%u vkViewType=%d",
-                    MG_Util::ConvertTextureUploadTargetToString(uploadTarget).c_str(),
-                    MG_Util::ConvertTextureTargetToString(texture.GetTarget()).c_str(), texture.GetExternalIndex(),
-                    texelSize.x(), texelSize.y(), texelSize.z(), mipLevels,
-                    static_cast<Int>(MG_Util::ConvertTextureUploadTargetToVkEnum(uploadTarget)));
+            MGLOG_D("%s: not Texture2D, unsupported", __func__);
             return false;
         }
         VkSampleCountFlagBits resolvedSampleCount = VK_SAMPLE_COUNT_1_BIT;
@@ -1589,16 +1516,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     MG_Util::ConvertTextureUploadTargetToString(uploadTarget).c_str());
             return false;
         }
-        // glTexStorage*Multisample(samples = 1) is legal GL, but a one-sample image cannot back a
-        // sampler2DMS: VUID-RuntimeSpirv-samples-08726 forbids an OpTypeImage with MS = 1 from
-        // reading an image created with VK_SAMPLE_COUNT_1_BIT, and the fetch returns undefined data
-        // rather than an error. GL only promises "at least the requested number of samples", so
-        // giving a multisample texture two is both legal and the only way to keep the shader's view
-        // of it honest. GL_TEXTURE_SAMPLES still reports what the application asked for - that is
-        // read off the texture object, not off the image.
-        if (isMultisampleTexture && resolvedSampleCount == VK_SAMPLE_COUNT_1_BIT) {
-            resolvedSampleCount = VK_SAMPLE_COUNT_2_BIT;
-        }
 
         const VkImageAspectFlags aspect = GetAspectMaskForFormat(format);
         VkFormatProperties formatProperties{};
@@ -1625,15 +1542,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) != 0;
         const Bool supportsStorageImage = storageImageCapable && markedAsStorageImage;
         VkImageCreateFlags imageCreateFlags = shapeInfo.imageFlags;
-        // One z slice of a 3D texture can only be attached to a framebuffer through a 2D view over
-        // it, which needs the image to be 2D-array-compatible (Vulkan 1.1 core, promoted from
-        // VK_KHR_maintenance1). Asked for optimistically and withdrawn per format below if the
-        // driver refuses - losing it only costs per-slice attachment, while failing creation would
-        // lose the texture entirely.
-        if (shapeInfo.imageType == VK_IMAGE_TYPE_3D && !isMultisampleTexture &&
-            m_2dArrayCompatibleUnsupported.find(format) == m_2dArrayCompatibleUnsupported.end()) {
-            imageCreateFlags |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT;
-        }
         if (storageImageCapable && IsMutableStorageImageFormat(format) &&
             m_mutableFormatUnsupported.find(format) == m_mutableFormatUnsupported.end()) {
             imageCreateFlags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
@@ -1683,11 +1591,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     }
                 }
                 if (rounded == 0) {
-                    // Never land on one sample: that is the VUID-RuntimeSpirv-samples-08726
-                    // violation the floor above exists to avoid, and it would come back silently
-                    // for any format whose only supported count is 1.
-                    for (Uint32 bit = static_cast<Uint32>(resolvedSampleCount) >> 1;
-                         bit > static_cast<Uint32>(VK_SAMPLE_COUNT_1_BIT); bit >>= 1) {
+                    for (Uint32 bit = static_cast<Uint32>(resolvedSampleCount) >> 1; bit != 0; bit >>= 1) {
                         if ((supported & bit) != 0) {
                             rounded = bit;
                             break;
@@ -1791,8 +1695,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             imageInfo.pNext = &formatListInfo;
         }
 
-        if (isMultisampleTexture || (imageInfo.flags & (VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT |
-                                                        VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT)) != 0) {
+        if (isMultisampleTexture || (imageInfo.flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) != 0) {
             VkImageFormatProperties imageFormatProperties{};
             VkResult imageFormatResult = vkGetPhysicalDeviceImageFormatProperties(
                 m_physicalDevice, format, imageInfo.imageType, imageInfo.tiling, imageInfo.usage,
@@ -1815,22 +1718,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     m_physicalDevice, format, imageInfo.imageType, imageInfo.tiling, imageInfo.usage,
                     imageInfo.flags, &imageFormatProperties);
             }
-            if (imageFormatResult != VK_SUCCESS && !isMultisampleTexture &&
-                (imageInfo.flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT) != 0) {
-                // Losing 2D-array compatibility only costs per-slice framebuffer attachment for this
-                // format; failing creation would lose the texture entirely. Remembered so later syncs
-                // neither reprobe nor flag-mismatch against this image and recreate it.
-                MGLOG_W("%s: VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT is unsupported for format=%d "
-                        "textureId=%d; creating without it (per-slice framebuffer attachment will be "
-                        "unavailable for it)",
-                        __func__, static_cast<Int>(format), texture.GetExternalIndex());
-                m_2dArrayCompatibleUnsupported.insert(format);
-                imageInfo.flags &= ~VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_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 "
@@ -1882,11 +1769,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         resource.syncedTextureParamsVersion = 0;
 
         if (preservedResource) {
-            // The preserve copy reads the OLD image on its own immediately-
-            // submitted-and-waited command buffer; a batched upload into that
-            // image still sitting in the open batch must reach the queue first
-            // or the copy carries pre-upload texels forward.
-            FlushPendingUploads();
             const Bool preserved = PreserveTextureContentsOnRecreate(
                 m_device, m_commandPool, m_graphicsQueue, *preservedResource, resource);
             MOBILEGL_ASSERT(preserved,
@@ -1897,16 +1779,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     void VkTextureManager::DeferResourceRelease(TextureResource&& resource) {
-        // The deferred-release queues are drained under fence/queue-idle proofs
-        // that only cover SUBMITTED work; a recorded-but-unsubmitted upload
-        // batch referencing this image would escape them. Push the batch onto
-        // the queue first so every later proof covers it. Rare (only recreate/
-        // erase of an image uploaded this very frame), so the flush is cheap.
-        if (m_uploadBatchOpen && resource.image != VK_NULL_HANDLE &&
-            std::find(m_uploadBatchImages.begin(), m_uploadBatchImages.end(), resource.image) !=
-                m_uploadBatchImages.end()) {
-            FlushPendingUploads();
-        }
         if (resource.image == VK_NULL_HANDLE && resource.fullView == VK_NULL_HANDLE &&
             resource.sampledView == VK_NULL_HANDLE &&
             resource.perMipViews.empty() && resource.perMipSampledViews.empty() &&
@@ -1957,211 +1829,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             } else if (vkGetFenceStatus(m_device, entry.fence) != VK_SUCCESS) {
                 break;
             }
-            // Recycle, don't destroy: the fence resets into the fence pool,
-            // the command buffer resets into the CB pool (m_uploadCommandPool
-            // carries RESET_COMMAND_BUFFER_BIT), and the staging blocks
-            // return to the block pool for the next batch to bump-allocate.
-            // This is where the mc_tex_stream win comes from: the per-upload
-            // fence create/destroy + command-buffer alloc/free ioctl traffic
-            // was the measured 41%-in-kernel cost, not the submit itself.
-            if (vkResetFences(m_device, 1, &entry.fence) == VK_SUCCESS) {
-                m_freeUploadFences.push_back(entry.fence);
-            } else {
-                vkDestroyFence(m_device, entry.fence, nullptr);
-            }
-            if (vkResetCommandBuffer(entry.commandBuffer, 0) == VK_SUCCESS) {
-                m_freeUploadCommandBuffers.push_back(entry.commandBuffer);
-            } else {
-                vkFreeCommandBuffers(m_device, m_uploadCommandPool, 1, &entry.commandBuffer);
-            }
-            for (auto& block : entry.stagingBlocks) {
-                RecycleUploadStagingBlock(Move(block));
-            }
-            entry.stagingBlocks.clear();
+            vkDestroyFence(m_device, entry.fence, nullptr);
+            vkFreeCommandBuffers(m_device, m_commandPool, 1, &entry.commandBuffer);
+            vmaDestroyBuffer(m_allocator, entry.stagingBuffer, entry.stagingAllocation);
         }
         m_pendingUploadReclaims.erase(m_pendingUploadReclaims.begin(),
                                       m_pendingUploadReclaims.begin() + static_cast<std::ptrdiff_t>(completed));
     }
 
-    void VkTextureManager::RecycleUploadStagingBlock(UploadStagingBlock&& block) {
-        if (block.buffer == VK_NULL_HANDLE) {
-            return;
-        }
-        // Bound the idle pool: a one-off giant upload (initial atlas define)
-        // must not pin its staging memory forever.
-        constexpr VkDeviceSize kMaxFreeUploadStagingBytes = 32u * 1024u * 1024u;
-        if (m_allocator == nullptr || m_freeUploadStagingBytes + block.capacity > kMaxFreeUploadStagingBytes) {
-            vmaDestroyBuffer(m_allocator, block.buffer, block.allocation);
-            return;
-        }
-        block.cursor = 0;
-        m_freeUploadStagingBytes += block.capacity;
-        m_freeUploadStagingBlocks.push_back(Move(block));
-    }
-
-    VkCommandBuffer VkTextureManager::EnsureUploadBatchOpen() {
-        if (m_uploadBatchOpen) {
-            return m_uploadBatchCommandBuffer;
-        }
-        if (!m_freeUploadCommandBuffers.empty()) {
-            m_uploadBatchCommandBuffer = m_freeUploadCommandBuffers.back();
-            m_freeUploadCommandBuffers.pop_back();
-        } else {
-            VkCommandBufferAllocateInfo allocInfo{};
-            allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
-            allocInfo.commandPool = m_uploadCommandPool;
-            allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-            allocInfo.commandBufferCount = 1;
-            VK_VERIFY(vkAllocateCommandBuffers(m_device, &allocInfo, &m_uploadBatchCommandBuffer),
-                      "vkAllocateCommandBuffers(texture upload batch)");
-        }
-        VkCommandBufferBeginInfo beginInfo{};
-        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-        beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
-        VK_VERIFY(vkBeginCommandBuffer(m_uploadBatchCommandBuffer, &beginInfo),
-                  "vkBeginCommandBuffer(texture upload batch)");
-        m_uploadBatchOpen = true;
-        return m_uploadBatchCommandBuffer;
-    }
-
-    Uint8* VkTextureManager::AcquireUploadStagingSpace(VkDeviceSize size, VkBuffer& outBuffer,
-                                                       VkDeviceSize& outBaseOffset) {
-        // 16 covers every uncompressed texel size in use (1..16 bytes) and the
-        // bufferOffset multiple-of-4 rule; per-item offsets inside the span
-        // keep the pre-batching tight packing.
-        constexpr VkDeviceSize kUploadStagingAlignment = 16;
-        constexpr VkDeviceSize kUploadStagingBlockSize = 1u * 1024u * 1024u;
-        UploadStagingBlock* current = m_uploadBatchBlocks.empty() ? nullptr : &m_uploadBatchBlocks.back();
-        VkDeviceSize alignedCursor = 0;
-        if (current != nullptr) {
-            alignedCursor = (current->cursor + (kUploadStagingAlignment - 1)) & ~(kUploadStagingAlignment - 1);
-            if (alignedCursor + size > current->capacity) {
-                current = nullptr;
-            }
-        }
-        if (current == nullptr) {
-            UploadStagingBlock block;
-            for (SizeT i = 0; i < m_freeUploadStagingBlocks.size(); ++i) {
-                if (m_freeUploadStagingBlocks[i].capacity >= size) {
-                    block = Move(m_freeUploadStagingBlocks[i]);
-                    m_freeUploadStagingBytes -= block.capacity;
-                    m_freeUploadStagingBlocks.erase(m_freeUploadStagingBlocks.begin() +
-                                                    static_cast<std::ptrdiff_t>(i));
-                    break;
-                }
-            }
-            if (block.buffer == VK_NULL_HANDLE) {
-                VkBufferCreateInfo bufferInfo{};
-                bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-                bufferInfo.size = std::max(kUploadStagingBlockSize, size);
-                bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
-                bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-                VmaAllocationCreateInfo stagingAllocationInfo{};
-                stagingAllocationInfo.usage = VMA_MEMORY_USAGE_AUTO_PREFER_HOST;
-                stagingAllocationInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
-                                              VMA_ALLOCATION_CREATE_MAPPED_BIT;
-                stagingAllocationInfo.requiredFlags =
-                    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
-                VmaAllocationInfo allocationResult{};
-                VK_VERIFY(vmaCreateBuffer(m_allocator, &bufferInfo, &stagingAllocationInfo, &block.buffer,
-                                          &block.allocation, &allocationResult),
-                          "vmaCreateBuffer(texture upload staging block)");
-                block.mapped = static_cast<Uint8*>(allocationResult.pMappedData);
-                block.capacity = bufferInfo.size;
-                MOBILEGL_ASSERT(block.mapped != nullptr,
-                                "AcquireUploadStagingSpace: staging block is not persistently mapped");
-            }
-            block.cursor = 0;
-            m_uploadBatchBlocks.push_back(Move(block));
-            current = &m_uploadBatchBlocks.back();
-            alignedCursor = 0;
-        }
-        outBuffer = current->buffer;
-        outBaseOffset = alignedCursor;
-        current->cursor = alignedCursor + size;
-        return current->mapped + alignedCursor;
-    }
-
-    void VkTextureManager::FlushPendingUploads() {
-        if (!m_uploadBatchOpen) {
-            return;
-        }
-        VK_VERIFY(vkEndCommandBuffer(m_uploadBatchCommandBuffer), "vkEndCommandBuffer(texture upload batch)");
-
-        VkFence uploadFence = VK_NULL_HANDLE;
-        if (!m_freeUploadFences.empty()) {
-            uploadFence = m_freeUploadFences.back();
-            m_freeUploadFences.pop_back();
-        } else {
-            VkFenceCreateInfo fenceInfo{};
-            fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-            VK_VERIFY(vkCreateFence(m_device, &fenceInfo, nullptr, &uploadFence), "vkCreateFence(texture upload)");
-        }
-
-        VkSubmitInfo submitInfo{};
-        submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
-        submitInfo.commandBufferCount = 1;
-        submitInfo.pCommandBuffers = &m_uploadBatchCommandBuffer;
-        VK_VERIFY(vkQueueSubmit(m_graphicsQueue, 1, &submitInfo, uploadFence), "vkQueueSubmit(texture upload batch)");
-
-        PendingUploadReclaim reclaim;
-        reclaim.fence = uploadFence;
-        reclaim.commandBuffer = m_uploadBatchCommandBuffer;
-        reclaim.stagingBlocks = Move(m_uploadBatchBlocks);
-        m_pendingUploadReclaims.push_back(Move(reclaim));
-        m_uploadBatchCommandBuffer = VK_NULL_HANDLE;
-        m_uploadBatchOpen = false;
-        m_uploadBatchBlocks.clear();
-        m_uploadBatchImages.clear();
-        m_uploadBatchStagingBytes = 0;
-
-        ReclaimCompletedUploads();
-        // Backstop for pathological upload storms: bound in-flight staging
-        // memory by blocking on the oldest batch only once the list is deep.
-        constexpr SizeT kMaxPendingTextureUploads = 16;
-        if (m_pendingUploadReclaims.size() > kMaxPendingTextureUploads) {
-            VK_VERIFY(vkWaitForFences(m_device, 1, &m_pendingUploadReclaims.front().fence, VK_TRUE, UINT64_MAX),
-                      "vkWaitForFences(texture upload backstop)");
-            ReclaimCompletedUploads();
-        }
-    }
-
-    void VkTextureManager::DiscardPendingUploadBatch() {
-        if (!m_uploadBatchOpen) {
-            return;
-        }
-        // The batch was never submitted, so the command buffer is in the
-        // recording state, not pending - freeing it is legal.
-        vkFreeCommandBuffers(m_device, m_uploadCommandPool, 1, &m_uploadBatchCommandBuffer);
-        m_uploadBatchCommandBuffer = VK_NULL_HANDLE;
-        m_uploadBatchOpen = false;
-        for (auto& block : m_uploadBatchBlocks) {
-            RecycleUploadStagingBlock(Move(block));
-        }
-        m_uploadBatchBlocks.clear();
-        m_uploadBatchImages.clear();
-        m_uploadBatchStagingBytes = 0;
-    }
-
-    void VkTextureManager::DestroyUploadPools() {
-        for (auto& block : m_freeUploadStagingBlocks) {
-            if (block.buffer != VK_NULL_HANDLE) {
-                vmaDestroyBuffer(m_allocator, block.buffer, block.allocation);
-            }
-        }
-        m_freeUploadStagingBlocks.clear();
-        m_freeUploadStagingBytes = 0;
-        if (!m_freeUploadCommandBuffers.empty()) {
-            vkFreeCommandBuffers(m_device, m_uploadCommandPool, static_cast<Uint32>(m_freeUploadCommandBuffers.size()),
-                                 m_freeUploadCommandBuffers.data());
-            m_freeUploadCommandBuffers.clear();
-        }
-        for (const VkFence fence : m_freeUploadFences) {
-            vkDestroyFence(m_device, fence, nullptr);
-        }
-        m_freeUploadFences.clear();
-    }
-
     void VkTextureManager::DestroyDeferredReleases() {
         for (auto& deferredReleases : m_deferredReleases) {
             deferredReleases.clear();
@@ -2296,21 +1971,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             const void* source = nullptr;
             Vector<Uint8> expandedData;
             VkDeviceSize offset = 0;
-            // Sub-region upload (a small sprite in a big atlas): only the dirty box
-            // is staged and copied. texelSize keeps the LEVEL extent - the staging
-            // row copy needs it for the shadow's stride. Plain color formats only;
-            // the RGB-expand and depth(+stencil) conversion passes rewrite whole
-            // levels and stay full-size.
-            Bool subRegion = false;
-            IntVec3 regionLo = {0, 0, 0};
-            IntVec3 regionSize = {0, 0, 0};
-            SizeT texelBytes = 0;
-            // Scatter refinement of the single dirty box: when the storage's rect
-            // list reports the writes' true footprint (~100 sprites whose union box
-            // spans the whole atlas), each rect is staged tightly and copied with
-            // its own VkBufferImageCopy in ONE vkCmdCopyBufferToImage. Empty means
-            // "stage the one box above". Only set while subRegion.
-            Vector<MG_State::GLState::MipmapDirtyRegion> rects;
         };
 
         Vector<UploadItem> uploadItems;
@@ -2357,42 +2017,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 uploadItem.source = source;
                 uploadItem.offset = stagingSize;
                 uploadItem.uploadByteSize = byteSize;
-                if (!formatInfo.expandRgbToRgba &&
-                    GetAspectMaskForFormat(outResource.format) == VK_IMAGE_ASPECT_COLOR_BIT) {
-                    const auto region = mipmapTexture.GetStorageDirtyRegion(target, level);
-                    const SizeT texelCount = static_cast<SizeT>(texelSize.x()) *
-                                             static_cast<SizeT>(texelSize.y()) *
-                                             static_cast<SizeT>(std::max(texelSize.z(), 1));
-                    if (!region.Empty() && !region.CoversWholeLevel(texelSize) && texelCount > 0 &&
-                        byteSize % texelCount == 0) {
-                        uploadItem.subRegion = true;
-                        uploadItem.regionLo = region.lo;
-                        uploadItem.regionSize = {region.hi.x() - region.lo.x(), region.hi.y() - region.lo.y(),
-                                                 region.hi.z() - region.lo.z()};
-                        uploadItem.texelBytes = byteSize / texelCount;
-                        uploadItem.uploadByteSize = static_cast<SizeT>(uploadItem.regionSize.x()) *
-                                                    static_cast<SizeT>(uploadItem.regionSize.y()) *
-                                                    static_cast<SizeT>(uploadItem.regionSize.z()) *
-                                                    uploadItem.texelBytes;
-                        // Scatter refinement: the storage only hands out its rect list
-                        // when the rects' summed area is materially smaller than the
-                        // union box (0 otherwise), so taking it always stages fewer
-                        // bytes than the box - the very amplification this path exists
-                        // to avoid paying twice.
-                        MG_State::GLState::MipmapDirtyRegion
-                            dirtyRects[MG_State::GLState::MipmapStorage::kMaxDirtyRects];
-                        const SizeT dirtyRectCount = mipmapTexture.GetStorageDirtyRects(
-                            target, level, dirtyRects, MG_State::GLState::MipmapStorage::kMaxDirtyRects);
-                        if (dirtyRectCount >= 2) {
-                            uploadItem.rects.assign(dirtyRects, dirtyRects + dirtyRectCount);
-                            SizeT rectTexels = 0;
-                            for (const auto& rect : uploadItem.rects) {
-                                rectTexels += rect.TexelCount();
-                            }
-                            uploadItem.uploadByteSize = rectTexels * uploadItem.texelBytes;
-                        }
-                    }
-                }
                 if (formatInfo.expandRgbToRgba) {
                     const Bool expanded = ExpandRgbSourceToRgba(source, byteSize, texelSize, formatInfo,
                                                                 uploadItem.expandedData);
@@ -2529,66 +2153,41 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         }
 
-        // Rare mid-frame hazard, kept at parity with the old per-upload
-        // submits: this image already has an upload recorded in the OPEN batch
-        // and has since been referenced by the frame's open recording (drawn).
-        // Appending here would merge both uploads into the same pre-frame
-        // submission the old code split into two; flush first so the second
-        // upload lands in its own later submission, exactly like before.
-        if (m_uploadBatchOpen && WasTouchedThisRecording(outResource) &&
-            std::find(m_uploadBatchImages.begin(), m_uploadBatchImages.end(), outResource.image) !=
-                m_uploadBatchImages.end()) {
-            FlushPendingUploads();
-        }
-        // Bound the staging bytes a single batch can pin before its fence can
-        // reclaim them.
-        constexpr VkDeviceSize kMaxBatchStagingBytes = 64u * 1024u * 1024u;
-        if (m_uploadBatchOpen && m_uploadBatchStagingBytes + stagingSize > kMaxBatchStagingBytes) {
-            FlushPendingUploads();
-        }
-
-        VkCommandBuffer commandBuffer = EnsureUploadBatchOpen();
         VkBuffer stagingBuffer = VK_NULL_HANDLE;
-        VkDeviceSize stagingBase = 0;
-        Uint8* mapped = AcquireUploadStagingSpace(stagingSize, stagingBuffer, stagingBase);
+        VmaAllocation stagingAllocation = nullptr;
+
+        VkBufferCreateInfo bufferInfo{};
+        bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+        bufferInfo.size = stagingSize;
+        bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+        bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+        VmaAllocationCreateInfo stagingAllocationInfo{};
+        stagingAllocationInfo.usage = VMA_MEMORY_USAGE_AUTO_PREFER_HOST;
+        stagingAllocationInfo.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
+        stagingAllocationInfo.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+        VK_VERIFY(vmaCreateBuffer(m_allocator, &bufferInfo, &stagingAllocationInfo, &stagingBuffer, &stagingAllocation, nullptr),
+                  "vmaCreateBuffer(staging texture)");
+
+        void* mapped = nullptr;
+        VK_VERIFY(vmaMapMemory(m_allocator, stagingAllocation, &mapped), "vmaMapMemory(staging texture)");
         for (const auto& item : uploadItems) {
-            Uint8* dst = mapped + item.offset;
-            if (!item.subRegion) {
-                std::memcpy(dst, item.source, item.uploadByteSize);
-                continue;
-            }
-            // Tight-pack the dirty box(es): the shadow keeps whole-level rows, the
-            // staging slice holds only the region (bufferRowLength stays 0). Multi-
-            // rect items pack their rects back to back in list order; the copy loop
-            // below recomputes the same running offsets.
-            const SizeT levelRowBytes = static_cast<SizeT>(item.texelSize.x()) * item.texelBytes;
-            const SizeT levelSliceBytes = static_cast<SizeT>(item.texelSize.y()) * levelRowBytes;
-            const Uint8* src = static_cast<const Uint8*>(item.source);
-            const auto packBox = [&](Uint8* out, const IntVec3& lo, const IntVec3& boxSize) {
-                const SizeT boxRowBytes = static_cast<SizeT>(boxSize.x()) * item.texelBytes;
-                for (Int z = 0; z < boxSize.z(); ++z) {
-                    for (Int y = 0; y < boxSize.y(); ++y) {
-                        const Uint8* srcRow = src + static_cast<SizeT>(lo.z() + z) * levelSliceBytes +
-                                              static_cast<SizeT>(lo.y() + y) * levelRowBytes +
-                                              static_cast<SizeT>(lo.x()) * item.texelBytes;
-                        std::memcpy(out + (static_cast<SizeT>(z) * static_cast<SizeT>(boxSize.y()) + y) *
-                                              boxRowBytes,
-                                    srcRow, boxRowBytes);
-                    }
-                }
-                return static_cast<SizeT>(boxSize.x()) * static_cast<SizeT>(boxSize.y()) *
-                       static_cast<SizeT>(boxSize.z()) * item.texelBytes;
-            };
-            if (!item.rects.empty()) {
-                for (const auto& rect : item.rects) {
-                    dst += packBox(dst, rect.lo,
-                                   IntVec3{rect.hi.x() - rect.lo.x(), rect.hi.y() - rect.lo.y(),
-                                           rect.hi.z() - rect.lo.z()});
-                }
-                continue;
-            }
-            packBox(dst, item.regionLo, item.regionSize);
+            std::memcpy(static_cast<Uint8*>(mapped) + item.offset, item.source, item.uploadByteSize);
         }
+        vmaUnmapMemory(m_allocator, stagingAllocation);
+
+        VkCommandBufferAllocateInfo allocInfo{};
+        allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+        allocInfo.commandPool = m_commandPool;
+        allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+        allocInfo.commandBufferCount = 1;
+
+        VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
+        VK_VERIFY(vkAllocateCommandBuffers(m_device, &allocInfo, &commandBuffer), "vkAllocateCommandBuffers(texture)");
+
+        VkCommandBufferBeginInfo beginInfo{};
+        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+        beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+        VK_VERIFY(vkBeginCommandBuffer(commandBuffer, &beginInfo), "vkBeginCommandBuffer(texture)");
 
         const VkImageAspectFlags aspectMask = GetAspectMaskForFormat(outResource.format);
         VkPipelineStageFlags uploadSrcStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
@@ -2611,49 +2210,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                             outResource.viewType == VK_IMAGE_VIEW_TYPE_2D_ARRAY ||
                                             outResource.viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
         for (const auto& item : uploadItems) {
-            if (!item.rects.empty()) {
-                // Multi-rect item: one VkBufferImageCopy per rect, all submitted in a
-                // single vkCmdCopyBufferToImage. The rect list is pairwise disjoint by
-                // construction, so no two copies write the same texels. Multi-rect
-                // implies subRegion, which implies a plain color aspect - the combined
-                // depth-stencil split below can never see one of these.
-                VkBufferImageCopy rectCopies[MG_State::GLState::MipmapStorage::kMaxDirtyRects];
-                Uint32 rectCopyCount = 0;
-                VkDeviceSize runningOffset = item.offset;
-                for (const auto& rect : item.rects) {
-                    const IntVec3 rectSize = {rect.hi.x() - rect.lo.x(), rect.hi.y() - rect.lo.y(),
-                                              rect.hi.z() - rect.lo.z()};
-                    const Uint32 rectDepth = static_cast<Uint32>(std::max(rectSize.z(), 1));
-                    VkBufferImageCopy rectCopy{};
-                    rectCopy.bufferOffset = stagingBase + runningOffset;
-                    rectCopy.bufferRowLength = 0;
-                    rectCopy.bufferImageHeight = 0;
-                    rectCopy.imageSubresource.aspectMask = aspectMask;
-                    rectCopy.imageSubresource.mipLevel = item.level;
-                    rectCopy.imageSubresource.baseArrayLayer = item.baseArrayLayer;
-                    rectCopy.imageSubresource.layerCount = 1;
-                    rectCopy.imageOffset = {rect.lo.x(), rect.lo.y(),
-                                            depthSelectsArrayLayer ? 0 : rect.lo.z()};
-                    rectCopy.imageExtent = {static_cast<Uint32>(rectSize.x()),
-                                            static_cast<Uint32>(rectSize.y()),
-                                            depthSelectsArrayLayer ? 1u : rectDepth};
-                    if (depthSelectsArrayLayer) {
-                        // The GL "depth" axis addresses array layers here, so a partial
-                        // z-range narrows the layer span rather than the extent.
-                        rectCopy.imageSubresource.baseArrayLayer =
-                            item.baseArrayLayer + static_cast<Uint32>(rect.lo.z());
-                        rectCopy.imageSubresource.layerCount = rectDepth;
-                    }
-                    rectCopies[rectCopyCount++] = rectCopy;
-                    runningOffset += static_cast<VkDeviceSize>(rect.TexelCount() * item.texelBytes);
-                }
-                vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, outResource.image,
-                                       VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, rectCopyCount, rectCopies);
-                continue;
-            }
             const Uint32 depthOrLayers = item.texelSize.z() > 0 ? static_cast<Uint32>(item.texelSize.z()) : 1u;
             VkBufferImageCopy copy{};
-            copy.bufferOffset = stagingBase + item.offset;
+            copy.bufferOffset = item.offset;
             copy.bufferRowLength = 0;
             copy.bufferImageHeight = 0;
             copy.imageSubresource.aspectMask = aspectMask;
@@ -2663,21 +2222,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             copy.imageOffset = {0, 0, 0};
             copy.imageExtent = {static_cast<Uint32>(item.texelSize.x()), static_cast<Uint32>(item.texelSize.y()),
                                 depthSelectsArrayLayer ? 1u : depthOrLayers};
-            if (item.subRegion) {
-                const Uint32 regionDepth = static_cast<Uint32>(std::max(item.regionSize.z(), 1));
-                copy.imageOffset = {item.regionLo.x(), item.regionLo.y(),
-                                    depthSelectsArrayLayer ? 0 : item.regionLo.z()};
-                copy.imageExtent = {static_cast<Uint32>(item.regionSize.x()),
-                                    static_cast<Uint32>(item.regionSize.y()),
-                                    depthSelectsArrayLayer ? 1u : regionDepth};
-                if (depthSelectsArrayLayer) {
-                    // The GL "depth" axis addresses array layers here, so a partial
-                    // z-range narrows the layer span rather than the extent.
-                    copy.imageSubresource.baseArrayLayer =
-                        item.baseArrayLayer + static_cast<Uint32>(item.regionLo.z());
-                    copy.imageSubresource.layerCount = regionDepth;
-                }
-            }
             if (isCombinedDepthStencil) {
                 const SizeT texelCount = static_cast<SizeT>(item.texelSize.x()) *
                                          static_cast<SizeT>(item.texelSize.y()) *
@@ -2686,7 +2230,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 depthCopy.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
                 VkBufferImageCopy stencilCopy = copy;
                 stencilCopy.imageSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
-                stencilCopy.bufferOffset = stagingBase + item.offset + static_cast<VkDeviceSize>(texelCount) * 4;
+                stencilCopy.bufferOffset = item.offset + static_cast<VkDeviceSize>(texelCount) * 4;
                 const VkBufferImageCopy copies[2] = {depthCopy, stencilCopy};
                 vkCmdCopyBufferToImage(commandBuffer, stagingBuffer, outResource.image,
                                        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 2, copies);
@@ -2702,34 +2246,43 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                    uploadLayout,
                                    finalLayout,
                                    VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                   s_sampledReadStages,
+                                   kSampledReadStages,
                                    VK_ACCESS_TRANSFER_WRITE_BIT,
                                    VK_ACCESS_SHADER_READ_BIT,
                                    aspectMask, 0, outResource.mipLevels, outResource.arrayLayers);
         MOBILEGL_ASSERT(ok, "TransitionImageLayout to sampled read-only layout failed");
         outResource.layout = finalLayout;
 
-        // Ordering argument (replaces the old immediate per-texture submit):
-        // this upload is RECORDED into the shared batch command buffer, which
-        // FlushPendingUploads submits - with one vkQueueSubmit and one pooled
-        // fence for the whole batch - strictly BEFORE any other submission on
-        // the same queue whose commands could consume the image: the renderer
-        // flushes at every frame-command-buffer submit (mid-frame flush,
-        // readback, Present), and the texture manager flushes before the
-        // preserve-on-recreate copy and before deferring an image the batch
-        // references. The frame command buffer therefore still lands behind
-        // the uploads on the queue, so a texture uploaded and then immediately
-        // sampled in the same frame sees its data exactly as it did when each
-        // upload was its own submit. No fence is waited here, for the same
-        // reason as before: the batch queues behind the previous frame's
-        // rendering, and a synchronous wait would drain the GPU; the staging
-        // blocks/command buffer are parked on the reclaim list at flush time
-        // and recycled once the batch fence signals.
-        if (std::find(m_uploadBatchImages.begin(), m_uploadBatchImages.end(), outResource.image) ==
-            m_uploadBatchImages.end()) {
-            m_uploadBatchImages.push_back(outResource.image);
+        VK_VERIFY(vkEndCommandBuffer(commandBuffer), "vkEndCommandBuffer(texture)");
+
+        VkSubmitInfo submitInfo{};
+        submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+        submitInfo.commandBufferCount = 1;
+        submitInfo.pCommandBuffers = &commandBuffer;
+
+        VkFenceCreateInfo fenceInfo{};
+        fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+        VkFence uploadFence = VK_NULL_HANDLE;
+        VK_VERIFY(vkCreateFence(m_device, &fenceInfo, nullptr, &uploadFence), "vkCreateFence(texture upload)");
+
+        VK_VERIFY(vkQueueSubmit(m_graphicsQueue, 1, &submitInfo, uploadFence), "vkQueueSubmit(texture)");
+        // Do NOT wait the fence here: this submit sits behind the previous
+        // frame's rendering on the queue, so a synchronous wait stalls the CPU
+        // until the GPU drains - a per-frame vkQueueWaitIdle for any workload
+        // with animated textures. Ordering against the current frame's draws is
+        // already guaranteed (its command buffer is submitted later, at
+        // present), so only the transient objects need to survive execution;
+        // park them until the fence signals.
+        m_pendingUploadReclaims.push_back({uploadFence, commandBuffer, stagingBuffer, stagingAllocation});
+        ReclaimCompletedUploads();
+        // Backstop for pathological upload storms: bound in-flight staging
+        // memory by blocking on the oldest upload only once the list is deep.
+        constexpr SizeT kMaxPendingTextureUploads = 16;
+        if (m_pendingUploadReclaims.size() > kMaxPendingTextureUploads) {
+            VK_VERIFY(vkWaitForFences(m_device, 1, &m_pendingUploadReclaims.front().fence, VK_TRUE, UINT64_MAX),
+                      "vkWaitForFences(texture upload backstop)");
+            ReclaimCompletedUploads();
         }
-        m_uploadBatchStagingBytes += stagingSize;
 
         if (!ok) {
             MGLOG_D("%s: texture upload cmd failed", __func__);
@@ -2739,17 +2292,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             mipmapTexture.MarkStorageDirty(item.target, item.level, false);
         }
         outResource.layout = finalLayout;
-        // Large batches flush right away instead of riding until the frame
-        // submit: a big copy amortizes its own vkQueueSubmit, submitting it
-        // early lets the GPU overlap the copy with the rest of the frame's
-        // CPU recording (measurably faster than a frame-tail burst), and the
-        // frame-tail burst pattern was observed to leave the GPU in a
-        // latency state that taxes whatever runs next. Small uploads keep
-        // accumulating, so a lightmap+sprite frame still costs one submit.
-        constexpr VkDeviceSize kEagerUploadFlushBytes = 128u * 1024u;
-        if (m_uploadBatchStagingBytes >= kEagerUploadFlushBytes) {
-            FlushPendingUploads();
-        }
         return true;
     }
 

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.h

@@ -59,17 +59,6 @@ public:
         // VK_KHR_image_format_list is enabled: MUTABLE_FORMAT images can name the exact set of
         // formats they will be viewed as, which is what lets a tiler keep them compressed.
         Bool imageFormatListSupported = false;
-        // Union of shader stages sampled-read barriers may name on this device; the renderer
-        // builds it from the enabled features because geometry/tessellation stage bits are
-        // invalid in a barrier when their feature is off.
-        VkPipelineStageFlags sampledReadStageMask = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
-                                                    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                                                    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
-        // Family of `graphicsQueue`; the manager creates its own command pool
-        // on it for the recycled upload-batch command buffers, so their parked
-        // allocations never sit in (and fragment) the renderer's shared pool
-        // that frame command buffers churn through every frame.
-        Uint32 graphicsQueueFamilyIndex = 0;
     };
 
     struct TextureResource {
@@ -313,14 +302,6 @@ public:
     Bool Initialize(const InitInfo& initInfo);
     void Shutdown();
     void BeginFrame(Uint32 frameIndex);
-    // Submits the accumulated texture-upload batch (one command buffer, one
-    // vkQueueSubmit, one pooled fence) if any uploads are pending. MUST run
-    // before any other vkQueueSubmit on the shared graphics queue whose
-    // commands may consume an image the batch writes - the frame command
-    // buffer submit (mid-frame flush, readback, Present) and the
-    // preserve-on-recreate copy are the existing callers. No-op when the
-    // batch is empty.
-    void FlushPendingUploads();
     // Drains every frame slot's deferred image/view releases. Only valid when
     // the caller has proven every queue submission complete; used by the
     // present-less frame-boundary drain.
@@ -466,9 +447,6 @@ private:
     VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
     VmaAllocator m_allocator = nullptr;
     VkCommandPool m_commandPool = VK_NULL_HANDLE;
-    // Dedicated pool for the recycled upload-batch command buffers (see
-    // InitInfo::graphicsQueueFamilyIndex).
-    VkCommandPool m_uploadCommandPool = VK_NULL_HANDLE;
     VkQueue m_graphicsQueue = VK_NULL_HANDLE;
     Bool m_imageFormatListSupported = false;
     Uint32 m_currentFrameIndex = 0;
@@ -509,10 +487,6 @@ private:
     // 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;
-    // Formats whose 3D images refused VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT. Per format+usage,
-    // exactly like the mutable-format verdict above, so it is answered at image creation and
-    // remembered rather than probed once globally.
-    std::unordered_set<VkFormat> m_2dArrayCompatibleUnsupported;
     std::unordered_map<TextureIdentity, WeakPtr<MG_State::GLState::ITextureObject>, TextureIdentityHash> m_aliveObjects;
     std::unordered_map<TextureIdentity, TextureResource, TextureIdentityHash> m_textureResources;
     // Textures that have been bound to a GL image unit (see MarkStorageImageTexture).
@@ -522,58 +496,15 @@ private:
     std::unordered_map<VkFormat, VkSampleCountFlags> m_multisampleCountsByFormat;
     Vector<Vector<TextureResource>> m_deferredReleases;
     Vector<Vector<VkImageView>> m_deferredViewReleases;
-
-    // --- Batched upload machinery ---
-    // Uploads within a frame are recorded into ONE shared command buffer and
-    // submitted with ONE vkQueueSubmit at FlushPendingUploads (the renderer
-    // flushes before every frame-command-buffer submit). Staging memory comes
-    // from a pool of persistently-mapped, reusable blocks instead of a
-    // vmaCreateBuffer per upload.
-    struct UploadStagingBlock {
-        VkBuffer buffer = VK_NULL_HANDLE;
-        VmaAllocation allocation = nullptr;
-        Uint8* mapped = nullptr; // persistently mapped for the block's lifetime
-        VkDeviceSize capacity = 0;
-        VkDeviceSize cursor = 0; // bump cursor while the block backs the open batch
-    };
-    // Opens the batch command buffer lazily (allocates/reuses + begins recording).
-    VkCommandBuffer EnsureUploadBatchOpen();
-    // Bump-allocates `size` staging bytes for the open batch, growing onto a
-    // new/pooled block when the current one cannot fit. Returns the write
-    // pointer; outBuffer/outBaseOffset locate the space for copy commands.
-    Uint8* AcquireUploadStagingSpace(VkDeviceSize size, VkBuffer& outBuffer, VkDeviceSize& outBaseOffset);
-    void RecycleUploadStagingBlock(UploadStagingBlock&& block);
-    // Drops a recorded-but-unsubmitted batch on the floor. Shutdown only: the
-    // device is being torn down, so the lost texel data is unobservable.
-    void DiscardPendingUploadBatch();
-    void DestroyUploadPools();
-
-    Vector<UploadStagingBlock> m_freeUploadStagingBlocks;
-    VkDeviceSize m_freeUploadStagingBytes = 0;
-    Vector<VkCommandBuffer> m_freeUploadCommandBuffers;
-    Vector<VkFence> m_freeUploadFences;
-    Bool m_uploadBatchOpen = false;
-    VkCommandBuffer m_uploadBatchCommandBuffer = VK_NULL_HANDLE;
-    // Blocks whose staging bytes the open batch's copies reference (last =
-    // the block the bump cursor is currently allocating from).
-    Vector<UploadStagingBlock> m_uploadBatchBlocks;
-    // Images the open batch writes; consulted for the rare re-upload-after-
-    // draw flush and by DeferResourceRelease (an unsubmitted command buffer
-    // referencing a deferred-released image would escape every fence-based
-    // destruction proof, so the batch is flushed before the image is parked).
-    Vector<VkImage> m_uploadBatchImages;
-    VkDeviceSize m_uploadBatchStagingBytes = 0;
-
     // Texture uploads are submitted out-of-band but NOT waited on (waiting
     // behind the queue serialized the CPU against the previous frame's GPU
-    // work every time an animated atlas re-uploaded). Each flushed batch's
-    // transients are parked here and RECYCLED (fence reset to the fence pool,
-    // command buffer reset to the CB pool, staging blocks back to the block
-    // pool) once the batch fence signals.
+    // work every time an animated atlas re-uploaded). Their transient objects
+    // are parked here and reclaimed once the upload fence signals.
     struct PendingUploadReclaim {
         VkFence fence = VK_NULL_HANDLE;
         VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
-        Vector<UploadStagingBlock> stagingBlocks;
+        VkBuffer stagingBuffer = VK_NULL_HANDLE;
+        VmaAllocation stagingAllocation = nullptr;
     };
     Vector<PendingUploadReclaim> m_pendingUploadReclaims;
 };

MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.h

@@ -181,10 +181,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value);
         void ClearNamedFramebufferfv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
                                      GLenum buffer, GLint drawbuffer, const GLfloat* value);
-        void ClearNamedFramebufferiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                     GLenum buffer, GLint drawbuffer, const GLint* value);
-        void ClearNamedFramebufferuiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                      GLenum buffer, GLint drawbuffer, const GLuint* value);
         void ClearNamedFramebufferfi(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
                                      GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
         void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
@@ -327,16 +323,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Bool RecreateSwapchain();
 
     private:
-        // Tiered emission for an already-set-up multi-draw batch (state bound, index
-        // buffer bound for the indexed form). Tier 1: VK_EXT_multi_draw. Tier 2: one
-        // vkCmdDraw(Indexed)Indirect over a transient command array. Tier 3: unrolled
-        // vkCmdDraw(Indexed) loop. Tier eligibility is per-batch (uniform instance
-        // state for tier 1, firstInstance/feature legality for tier 2); every tier
-        // consumes the same param span, so contiguous-run merging done by the caller
-        // benefits all of them.
-        void EmitMultiDrawIndexed(VkCommandBuffer commandBuffer, const DrawIndexedCmdParam* pParams, Uint32 drawCount);
-        void EmitMultiDraw(VkCommandBuffer commandBuffer, const DrawCmdParam* pParams, Uint32 drawCount);
-
         struct BlitUniformData {
             float srcRect[4] = {0.f, 0.f, 1.f, 1.f};
             float dstRect[4] = {0.f, 0.f, 1.f, 1.f};
@@ -454,12 +440,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // above (rather than being handed one by the caller), so Shutdown() knows it
         // owns that window and must destroy it.
         Bool m_ownsFallbackXlibWindow = false;
-        // Android has the same shortfall: no Mali/Adreno driver seen so far exposes
-        // VK_EXT_headless_surface, so a windowless (EGL pbuffer) context gets an
-        // AImageReader's ANativeWindow to hand the WSI instead. Nothing is ever
-        // displayed - the reader's images are simply never acquired. Owned here, so
-        // Shutdown() deletes it.
-        void* m_fallbackImageReader = nullptr;
         VulkanRendererConfig m_config;
         Bool m_swapchainResizeRequested = false;
         // Presentation is suspended while the window is zero-area (minimized): the
@@ -487,24 +467,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Bool m_indexTypeUint8ExtensionEnabled = false;
         Bool m_logicOpFeatureEnabled = false;
         Bool m_multiDrawIndirectFeatureEnabled = false;
-        // drawIndirectFirstInstance gates indirect commands whose firstInstance != 0;
-        // cached at device creation because the tier-2 multi-draw path (a transient
-        // VkDrawIndexedIndirectCommand array) is illegal for such a sub-draw without it.
-        Bool m_drawIndirectFirstInstanceFeatureEnabled = false;
-        // VK_EXT_multi_draw: native batched submission for the CPU-side glMultiDraw*
-        // families (tier 1 of the multi-draw dispatch).
-        Bool m_multiDrawExtensionEnabled = false;
-        Uint32 m_maxMultiDrawCount = 0;
-        // Multi-draw dispatch tiers, resolved once at device creation from device support
-        // clamped by MOBILEGL_MAGMA_MULTIDRAW_MODE (a preference, never a demand):
-        //   tier 1 (ext):      one vkCmdDrawMulti(Indexed)EXT           - m_multiDrawAllowExt
-        //   tier 2 (indirect): one vkCmdDraw(Indexed)Indirect batch     - m_multiDrawAllowIndirect
-        //   tier 3 (unroll):   one vkCmdDraw(Indexed) per sub-draw      - always available
-        // m_multiDrawForceUnrollIndirect additionally forces the GPU-parameter
-        // glMultiDraw*Indirect paths onto their per-command loop (mode=unroll only).
-        Bool m_multiDrawAllowExt = false;
-        Bool m_multiDrawAllowIndirect = false;
-        Bool m_multiDrawForceUnrollIndirect = false;
         Bool m_samplerAnisotropyFeatureEnabled = false;
         Bool m_shaderDrawParametersExtensionEnabled = false;
         Bool m_shaderDrawParametersFeatureEnabled = false;
@@ -519,13 +481,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // needs no feature). Both cached at device creation and drive a hard-fail-at-draw when absent.
         Bool m_dualSrcBlendFeatureEnabled = false;
         Bool m_primitiveTopologyListRestartFeatureEnabled = false;
-        // Union of shader stages sampled-read barriers may name; built at device creation
-        // because geometry/tessellation stage bits are invalid in a barrier when their
-        // feature is off (VUID-vkCmdPipelineBarrier-srcStageMask-04090/-04091), and
-        // ALL_GRAPHICS would also serialize against non-shader stages.
-        VkPipelineStageFlags m_sampledReadStageMask = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
-                                                      VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                                                      VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
         // Cached at device creation from the graphics queue family properties
         // and device limits; drives timer-query support.
         Uint32 m_timestampValidBits = 0;
@@ -536,37 +491,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                                  VkDeviceSize countBufferOffset, Uint32 maxDrawCount,
                                                                  Uint32 stride);
         static inline PFNDrawIndexedIndirectCountFunc s_vkCmdDrawIndexedIndirectCount = nullptr;
-        // VK_EXT_multi_draw entry points, loaded at device creation when the extension
-        // (and its multiDraw feature) is enabled; null otherwise.
-        static inline PFN_vkCmdDrawMultiEXT s_vkCmdDrawMultiEXT = nullptr;
-        static inline PFN_vkCmdDrawMultiIndexedEXT s_vkCmdDrawMultiIndexedEXT = nullptr;
 
         // VK_EXT_transform_feedback (GL transform feedback capture)
         Bool m_transformFeedbackFeatureEnabled = false;
-        // VK_EXT_provoking_vertex. Vulkan's built-in convention is "provoking vertex first"; GL's
-        // default is LAST_VERTEX_CONVENTION, and GL derives BOTH flat shading and the transform
-        // feedback vertex order from it. provokingVertexLast alone fixes flat shading and the
-        // input-assembler capture order and has no dependency on transform feedback; only
-        // transformFeedbackPreservesProvokingVertex does.
-        Bool m_provokingVertexLastEnabled = false;
-        // transformFeedbackPreservesProvokingVertex was actually enabled at device creation. Kept
-        // separate because it is the only thing that arms
-        // VUID-VkGraphicsPipelineCreateInfo-topology-04884, the rule that forbids a TRIANGLE_FAN
-        // pipeline from asking for LAST on a device that cannot preserve a fan's provoking vertex.
-        Bool m_provokingVertexXfbPreserveEnabled = false;
-        // provokingVertexModePerPipeline: when VK_FALSE every pipeline in one render pass instance
-        // must agree on the mode, so glProvokingVertex(GL_FIRST_VERTEX_CONVENTION) cannot be honoured
-        // per draw and every pipeline takes GL's default (LAST) instead.
-        Bool m_provokingVertexModePerPipeline = false;
-        // transformFeedbackPreservesTriangleFanProvokingVertex.
-        Bool m_provokingVertexFanPreserved = false;
-        // Per-pipeline provoking-vertex mode. capturesXfbFromGeometryStage must be a LINK-TIME
-        // property of the program, never the dynamic "is transform feedback active" flag: the
-        // 8-entry m_pipelineMemo and the SetupDrawSnapshot fast path key on programObj.hash and
-        // the pipeline-state value hash, neither of which moves when glBeginTransformFeedback is
-        // called, so a dynamic input here would hand back a stale VkPipeline.
-        VkProvokingVertexModeEXT SelectProvokingVertexMode(VkPrimitiveTopology topology,
-                                                          Bool capturesXfbFromGeometryStage) const;
         // VK_EXT_vertex_attribute_divisor: without it every non-zero glVertexAttribDivisor
         // behaves as 1, because that is all Vulkan's instance input rate can express.
         Bool m_vertexAttributeDivisorEnabled = false;
@@ -655,12 +582,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint64 programHash = 0;
             Uint64 vertexInputHash = 0;
             Uint64 renderPassHash = 0;
-            // VALUE hash of the pipeline-relevant fixed-function state (see
-            // ComputePipelineStateHash), not the monotonic pipeline-state version:
-            // the version never repeats, so a per-draw GL_BLEND toggle would miss
-            // all entries forever even though the state alternates between two
-            // values the memo already holds.
-            Uint64 pipelineStateHash = 0;
+            Uint renderStateVersion = 0;
             ProgramFactory::CompileOptionFlags transformFlags = {};
             VkPipeline pipeline = VK_NULL_HANDLE;
         };
@@ -668,40 +590,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         PipelineMemoEntry m_pipelineMemo[kPipelineMemoSize];
         Uint32 m_pipelineMemoCount = 0;
         Uint32 m_pipelineMemoNext = 0;
-        // Hash of every fixed-function GL state the pipeline payload reads that the
-        // memo key's other fields (mode / program / vertex input / render pass /
-        // transform flags) do not already pin down. Equal hash under an equal rest
-        // of key => byte-identical PipelineCreatePayload. Cached per pipeline-state
-        // version: the version is monotonic and bumps on every pipeline-state
-        // change, so an unchanged (version, colorAttachmentCount) proves the state
-        // bytes are unchanged and the hash can be reused without re-reading them.
-        Uint64 ComputePipelineStateHash(Uint32 colorAttachmentCount) const;
-        Uint m_pipelineStateHashVersion = 0;
-        Uint32 m_pipelineStateHashColorCount = 0;
-        Uint64 m_pipelineStateHash = 0;
-        Bool m_pipelineStateHashValid = false;
-        // GetShaderTransformFlags memo. NOT pure in the pre-transform alone: the
-        // function also reads whether the bound DRAW framebuffer is the default one
-        // (only the default framebuffer gets the Y-flip and rotation bits - an FBO
-        // pass renders unflipped). Keyed on BOTH inputs; missing the FBO bit shipped
-        // an upside-down default-framebuffer pass after any render-to-texture
-        // (minecraft-1.17-main-menu retrace, whole frame flipped).
-        VkSurfaceTransformFlagBitsKHR m_baseTransformFlagsPreTransform =
-            VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR;
-        Bool m_baseTransformFlagsIsDefaultFbo = false;
-        Bool m_baseTransformFlagsKeyValid = false;
-        Uint32 m_baseTransformFlagsCache = 0;
-        // isDefaultFbo must be the default-ness of the CURRENTLY bound draw framebuffer;
-        // every caller already has it in hand from its own guards.
-        Uint32 GetBaseTransformFlagsRaw(Bool isDefaultFbo);
         // Drops every memoized pipeline handle. Required at command-buffer
-        // boundaries and whenever any pipeline may have been destroyed. Also drops
-        // the cached pipeline-state hash: the same boundaries can retire the GL
-        // context whose monotonic version the cache is keyed on.
+        // boundaries and whenever any pipeline may have been destroyed.
         void InvalidatePipelineMemo() {
             m_pipelineMemoCount = 0;
             m_pipelineMemoNext = 0;
-            m_pipelineStateHashValid = false;
         }
         UnorderedMap<ProgramFactory::HashType, VkPipeline> m_computePipelines;
         UniquePtr<ProgramFactory> m_programFactory;
@@ -758,12 +651,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint64 programLifetimeId = 0;
             Uint32 programVersion = 0;
             const void* vao = nullptr;
-            // Same rule as VaoDrawMemo::vaoLifetimeId: (address, config version) is not an
-            // identity, because a recycled address can arrive carrying a config version
-            // the dead VAO also had (two mutations to configure one attribute is the
-            // common shape), and "the VAO did not move" would then skip the layout
-            // re-resolve for a different VAO.
-            Uint64 vaoLifetimeId = 0;
             Uint32 vaoConfigVersion = 0;
             const void* drawFbo = nullptr;
             Uint16 fboVersion = 0;
@@ -779,77 +666,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint64 renderbufferImageEpoch = 0;
             Uint64 sampledContentSum = 0;
             Uint64 sampledParamsSum = 0;
-            // Guards the sampler-descriptor reuse hint: bumped by any sampler-object
-            // parameter or texture shape change (see GetSamplingResolutionGeneration),
-            // none of which the sums above cover.
-            Uint64 samplingResolutionGeneration = 0;
-            // Render-pass flavor input (DepthTest || StencilTest at snapshot time).
-            // A pipeline-state change that leaves this equal cannot change which
-            // render pass GetOrCreateRenderPass would pick, so the fast path may
-            // re-resolve just the pipeline against the active pass; a change that
-            // flips it must fall back to the full path's pass selection.
-            Bool drawUsesDepthStencil = false;
             IntVec2 renderPassExtent = {0, 0};
-            // colorAttachmentCount of the snapshotting draw's render pass: the
-            // pipeline-state hash input, so the fast path can refresh that hash and
-            // probe the pipeline memo after a state change without re-fetching the
-            // render-pass entry (the pass itself is pinned by renderPassHash above).
-            Uint32 renderPassColorCount = 0;
             VkPipeline pipeline = VK_NULL_HANDLE;
-            // layoutHash of the snapshotting draw's vertex-input state. The pipeline and
-            // the vertex-input pre-flight depend on the VAO only through this (plus the
-            // program, pinned separately), so a changed VAO whose aux memo carries the
-            // same layoutHash re-uses the snapshot's pipeline and pre-flight verdict
-            // outright - the VAO-cycling case Minecraft chunk rendering hits every draw.
-            Uint64 vaoLayoutHash = 0;
-            // Memoised ProgramFactory entry of the snapshotting draw, valid while
-            // (programLifetimeId, programVersion, resolvedTransformFlags) match - all
-            // checked above - AND the factory's cache structure epoch is unchanged (the
-            // cache is open-addressing and holds entries by value, so any insert/erase
-            // moves them). The fast path must re-stamp use through StampProgramUse when
-            // it bypasses GetOrCreateProgram, or the idle sweep could evict a live entry.
-            const ProgramFactory::VkProgramObject* programObj = nullptr;
-            Uint64 programFactoryEpoch = 0;
-            // Per-entry copies of the snapshotting draw's sampled set (the scratch
-            // vectors below hold only the LAST full-path draw's set, which with more
-            // than one snapshot entry is not necessarily this entry's program).
-            // sampledTextures/sampledResources carry the same epoch-guarded pointer
-            // lifetime rules as the scratch originals: textureEraseEpoch (checked
-            // every probe) declines the entry before any erased resource pointer
-            // could be dereferenced. sampledLayouts is the layout VALUE each
-            // resource held when this entry's descriptors were built (the
-            // descriptor-reuse hint needs the SAME layout, not just a sampleable
-            // one), and sampledBindingRecords feeds SampledBindingsUnchanged when
-            // the bind generation moved.
-            Vector<MG_State::GLState::ITextureObject*> sampledTextures;
-            Vector<VkTextureManager::TextureResource*> sampledResources;
-            Vector<VkImageLayout> sampledLayouts;
-            Vector<UniformManager::SampledBindingRecord> sampledBindingRecords;
         };
-        // Program-keyed snapshot entries: program ping-pong (Sodium switches programs
-        // mid-frame every few draws) would otherwise evict the single snapshot on
-        // every switch and send every draw through the full path. Entries are found
-        // by programLifetimeId (MRU-first probe); every other guard stays per-probe,
-        // so a stale entry declines itself exactly like the old single snapshot did.
-        static constexpr Uint32 kSetupDrawSnapshotCount = 4;
-        SetupDrawSnapshot m_setupDrawSnapshots[kSetupDrawSnapshotCount];
-        Uint32 m_setupDrawSnapshotMru = 0;    // last entry that hit or was filled
-        Uint32 m_setupDrawSnapshotVictim = 0; // round-robin fill cursor when all entries are live
-        void InvalidateSetupDrawSnapshots() {
-            for (auto& snapshot : m_setupDrawSnapshots) {
-                snapshot.valid = false;
-            }
-        }
+        SetupDrawSnapshot m_setupDrawSnapshot;
 
         // Per-draw scratch buffers (clear keeps capacity) — these paths run for every
         // draw call and must not allocate.
         Vector<MG_State::GLState::ITextureObject*> m_sampledTexturesScratch;
-        // Per-binding (texture, effective sampler) lifetime-id records from the same
-        // CollectSampledTextures walk that filled m_sampledTexturesScratch. The fast
-        // path shadow-compares against them (SampledBindingsUnchanged) when the
-        // texture bind generation moved, so a redundant glBindSampler/glBindTexture
-        // storm that resolves to the same bindings keeps the fast path.
-        Vector<UniformManager::SampledBindingRecord> m_sampledBindingRecordsScratch;
         // Parallel to m_sampledTexturesScratch, refilled by every SetupDraw's
         // first sampled-texture loop: the resolved backend resources, so the
         // post-transition loop can skip re-resolving textures whose layout is
@@ -914,138 +738,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         UnorderedMap<ConvertedVertexStreamKey, ConvertedVertexStream, ConvertedVertexStreamKeyHash>
             m_convertedVertexStreams;
 
-        // One VAO's resolved vkCmdBindVertexBuffers arguments, reusable by a later draw
-        // that would resolve them to the same thing. Consecutive draws in a chunk-renderer
-        // frame keep the program and the vertex layout and only swap the VAO, so a
-        // per-VAO memo turns the second and later draws through each VAO into a validate
-        // plus (usually skipped) rebind.
-        //
-        // Only whole-buffer bindings are memoised. Client-memory and format-converted
-        // streams re-upload from a range that depends on the draw's own vertex/index
-        // range, and synthetic bindings carry glVertexAttrib* values that are not part
-        // of any key here; a layout using any of them is never stored.
-        // Field order is hit-path cache locality, hot to cold: the per-draw validate
-        // reads the scalars and the EBO memo head, then only the first bindingCount
-        // elements of vkBuffers/vkOffsets; the per-binding revalidation arrays at the
-        // tail are touched once per frame at most.
-        struct ResolvedVertexBindings {
-            // Must equal DynamicStateShadow::kMaxShadowedVertexBindings (static_assert in
-            // the .cpp): past that width the bind shadow cannot skip a redundant bind
-            // either, so a wider layout resolves per draw. Minecraft-shaped layouts use four.
-            static constexpr Uint32 kMaxBindings = 8;
-
-            // Frame serial of the last completed resolve OR cross-frame revalidation.
-            // Zero until a resolve completes, and reset to zero before one starts, so a
-            // resolve that bails out midway cannot leave a half-filled entry matchable.
-            // Unlike the original frame-scoped memo, an entry whose buffers are all
-            // resident and unmapped is revalidated across frames (per-binding slice
-            // epoch compares) instead of re-resolved - see TryBindResolvedVertexBindings.
-            Uint64 frameSerial = 0;
-            // Identity of the resolved Vulkan layout: the VAO's content hash
-            // (VertexInputStateFactory::GetOrComputeHash - the same value the factory
-            // keys its entries on) fixes bindings.size(), each binding's base offset,
-            // which bindings are client/converted, and (through the mixed-in buffer
-            // addresses) which buffer each binding reads. Compared against the VAO's
-            // own hash memo on the hit path, so a hit never touches the factory entry.
-            VertexInputStateFactory::HashType vertexInputHash = 0;
-            // The program's vertex input layout: decides the synthetic-binding set and
-            // hence the total binding count.
-            Uint32 activeAttribMask = 0;
-            Uint32 bindingCount = 0;
-            // VkBufferManager::GetSliceEpochCounter() at resolve time. Still equal means
-            // no buffer anywhere changed its slice or was persistently mapped since, which
-            // settles every per-binding question below in one compare.
-            Uint64 sliceEpochCounter = 0;
-            // Any bound buffer already carrying a host map when the slice was resolved.
-            // Such a buffer can mutate its shadow with no API call, so it has to be
-            // re-pushed per draw and the one-compare path above cannot apply.
-            Bool anyBufferMapped = true;
-
-            // Resident element-buffer slice memo (skips the per-draw AcquireResidentSlice
-            // for the VAO's EBO, which cold-chases 500+ distinct resources in a
-            // chunk-cycling frame). Self-validating exactly like the bindings above: a hit
-            // requires the LIVE bound EBO pointer to equal indexBuffer AND either an
-            // unmoved manager-wide slice-epoch counter (nothing anywhere changed slices
-            // or gained a host map, the same one-compare rescue the vertex half uses) or
-            // that buffer's resource still carrying indexSliceEpoch (epochs are minted
-            // from a process-lifetime counter, so a recycled address can never
-            // revalidate). Restart-substituted and streamed EBOs are never stored.
-            // indexFrameSerial tracks the last frame the resource's GPU-use serial was
-            // stamped through this memo; 0 means no index memo. Independent of the
-            // vertex half: both are (pointer, epoch)-validated, so neither can serve
-            // stale state for the other.
-            const MG_State::GLState::BufferObject* indexBuffer = nullptr;
-            Uint64 indexSliceEpoch = 0;
-            // GetSliceEpochCounter() when the resource's epoch was last verified; only
-            // meaningful while indexFrameSerial matches the current frame serial.
-            Uint64 indexSliceEpochCounter = 0;
-            VkBuffer indexVkBuffer = VK_NULL_HANDLE;
-            VkDeviceSize indexSliceOffset = 0;
-            Uint64 indexFrameSerial = 0;
-
-            // Bound per draw (first bindingCount elements).
-            VkBuffer vkBuffers[kMaxBindings] = {};
-            VkDeviceSize vkOffsets[kMaxBindings] = {};
-            // Per binding: the VAO attribute location its buffer comes from, that buffer,
-            // and the buffer's VkBufferManager slice epoch when the slice was resolved.
-            // Only read by the per-frame revalidation and the something-moved fallback.
-            Uint8 attributeLocations[kMaxBindings] = {};
-            const MG_State::GLState::BufferObject* buffers[kMaxBindings] = {};
-            Uint64 sliceEpochs[kMaxBindings] = {};
-        };
-        // One direct-mapped slot of the per-VAO draw-memo table below. A slot belongs to
-        // the object whose (vaoKey, vaoLifetimeId) pair it carries: the address alone
-        // only picks the slot, and the never-reused lifetime id is what proves the slot
-        // is THIS VAO's, so the successor allocated onto a destroyed VAO's address
-        // always misses. That identity check is load-bearing and the content-hash
-        // validations below do NOT stand in for it - a recycled address under a
-        // byte-identical configuration reproduces the content hash exactly, which is
-        // how a destroyed VAO's resolved bindings were once handed to its successor's
-        // draw. The slot is still never dereferenced through vaoKey, and every fact it
-        // carries is still validated against live state before use:
-        //  - layoutHash/layoutAuxMasks are valid only while contentHash equals the LIVE
-        //    VAO's own hash memo (which the VAO's config version guards), so a config
-        //    change or a buffer rebind misses even for the same object.
-        //  - bindings revalidates per draw exactly as before (frame serial, content
-        //    hash, per-binding live buffer pointers and slice epochs).
-        struct alignas(64) VaoDrawMemo {
-            const MG_State::GLState::VertexArrayObject* vaoKey = nullptr;
-            // The VAO's never-reused lifetime id, checked alongside vaoKey. The pointer
-            // ALONE is not an identity: a deleted VAO's heap address is handed straight
-            // back by the next glGenVertexArrays-shaped allocation, and the successor then
-            // matched this slot and inherited the dead object's memos. Both stated
-            // defences failed with it, because both reduce to the content hash and the
-            // content hash's buffer-identity component was itself a recycled heap address.
-            Uint64 vaoLifetimeId = 0;
-            // The VAO content hash (VertexInputStateFactory::GetOrComputeHash) the two
-            // layout facts below were derived from; 0 while nothing valid is stored.
-            Uint64 contentHash = 0;
-            Bool layoutFactsValid = false;
-            // The resolved layout identity + packed (unsupported, location) masks -
-            // the exact values GetBackendAuxMemo used to serve, moved here so the
-            // per-draw probe stays inside this table's one hot line instead of
-            // touching a second cold line of every cycled VAO object.
-            Uint64 layoutHash = 0;
-            Uint64 layoutAuxMasks = 0;
-            ResolvedVertexBindings bindings;
-        };
-        // Fixed-size, allocated on first use, never rehashed or swept: entries are
-        // recycled in place on slot collisions (two-slot probe, older frame serial
-        // evicted), and stale entries self-invalidate through the compares above. A
-        // fixed table also makes every VaoDrawMemo/ResolvedVertexBindings pointer
-        // stable for the duration of a draw, which the EBO memo handoff
-        // (m_currentDrawResolvedEntry) relies on.
-        static constexpr Uint32 kVaoDrawMemoSlotCount = 2048; // power of two
-        Vector<VaoDrawMemo> m_vaoDrawMemoTable;
-        // Finds the slot holding `vao`, or recycles the older of its two candidate
-        // slots into an empty memo keyed on `vao`. Never returns null.
-        VaoDrawMemo* LookupVaoDrawMemo(const MG_State::GLState::VertexArrayObject* vao);
-        // The current draw's memo entry, set by UploadAndBindVertexBuffers and consumed
-        // by the same draw's UploadAndBindIndexBuffer (the EBO memo lives in the same
-        // entry). Valid ONLY within that window: the next draw's lookup can recycle the
-        // slot. Null when the draw's layout is not memoisable.
-        ResolvedVertexBindings* m_currentDrawResolvedEntry = nullptr;
-
         void CreateInstance();
         VkResult SetupDebugMessenger();
         VkResult DestroyDebugMessenger();
@@ -1076,25 +768,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             const MG_State::GLState::ProgramObject& program,
             const ProgramFactory::VkProgramObject& programObj);
 
-        // The per-draw dynamic-state tail (viewport, scissor, blend constants, depth
-        // bias, line width, stencil), gated behind one render-state-parameters-version
-        // compare per command buffer - see the gate fields in DynamicStateShadow.
-        void ApplyDynamicDrawStateTail(FrameContext::FrameData& frame, const IntVec2& extent, Bool isDefaultFbo);
-
         Bool UploadAndBindVertexBuffers(VkCommandBuffer commandBuffer, const MG_State::GLState::VertexArrayObject& vao,
                                         const ProgramFactory::VkProgramObject& programObj,
                                         const DrawCmdParam& drawParams,
                                         const IndexBufferView* pIndexBufferView);
-        // Binds `entry`'s memoised buffers when every input it was resolved from is
-        // still live and unchanged, else returns false and leaves nothing bound.
-        // vaoContentHash is the VAO's memoised content hash (GetBackendHashMemo), which
-        // pins the layout AND the bound buffers without resolving the factory entry.
-        // Non-const entry: a cross-frame revalidation refreshes its serial/epoch stamps.
-        Bool TryBindResolvedVertexBindings(VkCommandBuffer commandBuffer,
-                                           const MG_State::GLState::VertexArrayObject& vao,
-                                           ResolvedVertexBindings& entry,
-                                           Uint64 vaoContentHash,
-                                           Uint32 activeAttribMask, Uint64 frameSerial);
         Bool UploadAndBindIndexBuffer(FrameContext::FrameData& frame,
                                      const MG_State::GLState::VertexArrayObject& vao,
                                       const IndexBufferView* pIndexBufferView = nullptr);
@@ -1110,11 +787,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                    GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
                                                    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
                                                    GLenum filter);
-        // Clears one z slice of a VK_IMAGE_TYPE_3D colour image. See the call site in
-        // MaterializePendingClearForTexture for why a transfer clear cannot do this.
-        Bool ClearDepthSliceWithRenderPass(VkCommandBuffer commandBuffer,
-                                           MG_State::GLState::ITextureObject& texture, Uint32 mipLevel,
-                                           Uint32 depthSlice, const VkClearValue& clearValue);
         Bool MaterializePendingClearForTexture(VkCommandBuffer commandBuffer,
                                                MG_State::GLState::ITextureObject& texture);
         Bool MaterializePendingClearForRenderbuffer(

MobileGL/MG_Benchmark/CMakeLists.txt

@@ -41,5 +41,4 @@ add_test(NAME SanityBench COMMAND SanityBench --benchmark_counters_tabular=true)
 set_tests_properties(SanityBench PROPERTIES LABELS benchmark)
 
 add_subdirectory(Program)
-add_subdirectory(Buffer)
-add_subdirectory(Driver)
+add_subdirectory(Buffer)

MobileGL/MG_Benchmark/Driver/CMakeLists.txt

@@ -1,15 +0,0 @@
-cmake_minimum_required(VERSION 3.24)
-
-# A real, headless EGL client, deliberately NOT linked against MobileGL: it
-# dlopens one EGL provider at runtime ($DRIVERBENCH_EGL_LIB - the system
-# libEGL.so.1 for the native driver, or a libMobileGL.so path for either
-# MobileGL backend), so the same binary measures all three stacks.
-if (NOT UNIX OR APPLE OR ANDROID)
-    return()
-endif()
-
-add_executable(DriverBench DriverBench.c)
-target_link_libraries(DriverBench PRIVATE dl)
-
-add_test(NAME DriverBench COMMAND DriverBench draw_tiny)
-set_tests_properties(DriverBench PROPERTIES LABELS benchmark)

MobileGL/MG_Benchmark/Driver/DriverBench.c

@@ -1,501 +0,0 @@
-/* MobileGL - MobileGL/MG_Benchmark/Driver/DriverBench.c
- * 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
- *
- * Headless, EGL-based driver benchmark shaped like Minecraft's GL usage.
- * Unlike the MobileGL_s microbenches next door this exercises a full GL
- * stack: it dlopens ONE EGL provider ($DRIVERBENCH_EGL_LIB - the system
- * libEGL.so.1 for the native driver, or a libMobileGL.so path for either
- * MobileGL backend selected with MOBILEGL_BACKEND_TYPE), creates a desktop-GL
- * context on a small pbuffer, renders into its own FBO and paces frames with
- * glFinish. No window system is required: the default display is tried first
- * so a desktop run reaches the real driver, and a headless box (CI, a build
- * server) falls back to EGL_MESA_platform_surfaceless - see
- * run_driver_bench.sh.
- *
- * Every case models one hot pattern from captured Minecraft traces:
- *   draw_tiny        back-to-back glDrawElements, shared state (chunk batch)
- *   draw_uniform     per-draw vec3 offset uniform + draw (chunk sections)
- *   draw_multi_vao   per-draw VAO/VBO switch + draw (per-section buffers)
- *   tex_pingpong     per-draw texture bind churn on one unit
- *   program_pingpong alternate two programs + mat4 upload (chunk<->entity)
- *   chunk_upload     glBufferData(NULL) orphan + glBufferSubData + draw
- *   atlas_sprite     N 16x16 glTexSubImage2D into a 1024x512 atlas + draw
- *   lightmap         full 16x16 lightmap respecify per frame + draw
- *   scene_mix        composite frame built from the knobs below
- *
- * Output: one CSV line per case:
- *   case,frames,ops_per_frame,median_frame_ms,ns_per_op,fps
- */
-#include <dlfcn.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-/* ---- EGL constants ---- */
-typedef void* EGLDisplay;
-typedef void* EGLConfig;
-typedef void* EGLContext;
-typedef void* EGLSurface;
-typedef int EGLint;
-typedef unsigned int EGLBoolean;
-typedef unsigned int EGLenum;
-#define EGL_DEFAULT_DISPLAY ((void*)0)
-#define EGL_NO_CONTEXT ((EGLContext)0)
-#define EGL_NO_SURFACE ((EGLSurface)0)
-#define EGL_FALSE 0
-#define EGL_SURFACE_TYPE 0x3033
-#define EGL_PBUFFER_BIT 0x0001
-#define EGL_RENDERABLE_TYPE 0x3040
-#define EGL_OPENGL_BIT 0x0008
-#define EGL_RED_SIZE 0x3024
-#define EGL_GREEN_SIZE 0x3023
-#define EGL_BLUE_SIZE 0x3022
-#define EGL_DEPTH_SIZE 0x3025
-#define EGL_WIDTH 0x3057
-#define EGL_HEIGHT 0x3056
-#define EGL_NONE 0x3038
-#define EGL_OPENGL_API 0x30A2
-#define EGL_OPENGL_ES_API 0x30A0
-#define EGL_OPENGL_ES3_BIT 0x0040
-#define EGL_CONTEXT_CLIENT_VERSION 0x3098
-#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 EGL_PLATFORM_SURFACELESS_MESA 0x31DD
-
-/* ---- GL constants ---- */
-#define GL_COLOR_BUFFER_BIT 0x00004000
-#define GL_DEPTH_BUFFER_BIT 0x00000100
-#define GL_TRIANGLES 0x0004
-#define GL_UNSIGNED_INT 0x1405
-#define GL_SHORT 0x1402
-#define GL_FLOAT 0x1406
-#define GL_UNSIGNED_BYTE 0x1401
-#define GL_ARRAY_BUFFER 0x8892
-#define GL_ELEMENT_ARRAY_BUFFER 0x8893
-#define GL_STATIC_DRAW 0x88E4
-#define GL_TEXTURE_2D 0x0DE1
-#define GL_TEXTURE0 0x84C0
-#define GL_RGBA 0x1908
-#define GL_RGBA8 0x8058
-#define GL_DEPTH_COMPONENT24 0x81A6
-#define GL_TEXTURE_MIN_FILTER 0x2801
-#define GL_TEXTURE_MAG_FILTER 0x2800
-#define GL_NEAREST 0x2600
-#define GL_NEAREST_MIPMAP_LINEAR 0x2702
-#define GL_DEPTH_TEST 0x0B71
-#define GL_BLEND 0x0BE2
-#define GL_SRC_ALPHA 0x0302
-#define GL_ONE_MINUS_SRC_ALPHA 0x0303
-#define GL_ONE 1
-#define GL_ZERO 0
-#define GL_VERTEX_SHADER 0x8B31
-#define GL_FRAGMENT_SHADER 0x8B30
-#define GL_COMPILE_STATUS 0x8B81
-#define GL_LINK_STATUS 0x8B82
-#define GL_VERSION 0x1F02
-#define GL_RENDERER 0x1F01
-#define GL_NO_ERROR 0
-#define GL_FRAMEBUFFER 0x8D40
-#define GL_RENDERBUFFER 0x8D41
-#define GL_COLOR_ATTACHMENT0 0x8CE0
-#define GL_DEPTH_ATTACHMENT 0x8D00
-#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
-#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
-#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
-#define GL_UNIFORM_BUFFER 0x8A11
-#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
-#define GL_DYNAMIC_DRAW 0x88E8
-#define GL_STREAM_DRAW 0x88E0
-#define GL_UNPACK_ALIGNMENT 0x0CF5
-#define GL_UNPACK_ROW_LENGTH 0x0CF2
-#define GL_UNPACK_SKIP_ROWS 0x0CF3
-#define GL_UNPACK_SKIP_PIXELS 0x0CF4
-#define GL_TEXTURE_WRAP_S 0x2802
-#define GL_TEXTURE_WRAP_T 0x2803
-#define GL_CLAMP_TO_EDGE 0x812F
-#define GL_REPEAT 0x2901
-
-typedef unsigned int GLuint;
-typedef int GLint;
-typedef int GLsizei;
-typedef unsigned int GLenum;
-typedef char GLchar;
-typedef unsigned char GLboolean;
-typedef long GLsizeiptr;
-typedef long GLintptr;
-
-/* ---- resolved entry points ---- */
-static void* (*g_eglGetProcAddress)(const char*);
-static void* g_provider;
-
-#define GLF(ret, name, args) static ret(*name) args;
-GLF(void, glClear, (unsigned))
-GLF(void, glClearColor, (float, float, float, float))
-GLF(void, glEnable, (GLenum))
-GLF(void, glDisable, (GLenum))
-GLF(void, glBlendFuncSeparate, (GLenum, GLenum, GLenum, GLenum))
-GLF(void, glDrawBuffers, (GLsizei, const GLenum*))
-GLF(void, glViewport, (GLint, GLint, GLsizei, GLsizei))
-GLF(const unsigned char*, glGetString, (GLenum))
-GLF(GLenum, glGetError, (void))
-GLF(void, glFinish, (void))
-GLF(void, glFlush, (void))
-GLF(void, glGenBuffers, (GLsizei, GLuint*))
-GLF(void, glBindBuffer, (GLenum, GLuint))
-GLF(void, glBufferData, (GLenum, GLsizeiptr, const void*, GLenum))
-GLF(void, glBufferSubData, (GLenum, GLintptr, GLsizeiptr, const void*))
-GLF(void, glGenVertexArrays, (GLsizei, GLuint*))
-GLF(void, glBindVertexArray, (GLuint))
-GLF(void, glEnableVertexAttribArray, (GLuint))
-GLF(void, glVertexAttribPointer, (GLuint, GLint, GLenum, GLboolean, GLsizei, const void*))
-GLF(void, glGenTextures, (GLsizei, GLuint*))
-GLF(void, glBindTexture, (GLenum, GLuint))
-GLF(void, glActiveTexture, (GLenum))
-GLF(void, glTexImage2D, (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const void*))
-GLF(void, glTexSubImage2D, (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const void*))
-GLF(void, glTexParameteri, (GLenum, GLenum, GLint))
-GLF(void, glPixelStorei, (GLenum, GLint))
-GLF(void, glGetIntegerv, (GLenum, GLint*))
-GLF(void, glGenerateMipmap, (GLenum))
-GLF(GLuint, glCreateShader, (GLenum))
-GLF(void, glShaderSource, (GLuint, GLsizei, const GLchar* const*, const GLint*))
-GLF(void, glCompileShader, (GLuint))
-GLF(void, glGetShaderiv, (GLuint, GLenum, GLint*))
-GLF(void, glGetShaderInfoLog, (GLuint, GLsizei, GLsizei*, GLchar*))
-GLF(GLuint, glCreateProgram, (void))
-GLF(void, glAttachShader, (GLuint, GLuint))
-GLF(void, glLinkProgram, (GLuint))
-GLF(void, glGetProgramiv, (GLuint, GLenum, GLint*))
-GLF(void, glUseProgram, (GLuint))
-GLF(GLint, glGetUniformLocation, (GLuint, const GLchar*))
-GLF(void, glUniform1i, (GLint, GLint))
-GLF(void, glUniform3f, (GLint, float, float, float))
-GLF(void, glUniformMatrix4fv, (GLint, GLsizei, GLboolean, const float*))
-GLF(void, glDrawElements, (GLenum, GLsizei, GLenum, const void*))
-GLF(void, glBindAttribLocation, (GLuint, GLuint, const GLchar*))
-GLF(void, glUniform3fv, (GLint, GLsizei, const float*))
-GLF(void, glDrawArrays, (GLenum, GLint, GLsizei))
-GLF(void, glDrawElementsBaseVertex, (GLenum, GLsizei, GLenum, const void*, GLint))
-GLF(void, glMultiDrawElementsBaseVertex,
-    (GLenum, const GLsizei*, GLenum, const void* const*, GLsizei, const GLint*))
-GLF(void, glBindBufferRange, (GLenum, GLuint, GLuint, GLintptr, GLsizeiptr))
-GLF(void, glBindBufferBase, (GLenum, GLuint, GLuint))
-GLF(GLuint, glGetUniformBlockIndex, (GLuint, const GLchar*))
-GLF(void, glUniformBlockBinding, (GLuint, GLuint, GLuint))
-GLF(void, glGenSamplers, (GLsizei, GLuint*))
-GLF(void, glBindSampler, (GLuint, GLuint))
-GLF(void, glSamplerParameteri, (GLuint, GLenum, GLint))
-GLF(void, glGenFramebuffers, (GLsizei, GLuint*))
-GLF(void, glBindFramebuffer, (GLenum, GLuint))
-GLF(void, glGenRenderbuffers, (GLsizei, GLuint*))
-GLF(void, glBindRenderbuffer, (GLenum, GLuint))
-GLF(void, glRenderbufferStorage, (GLenum, GLenum, GLsizei, GLsizei))
-GLF(void, glFramebufferRenderbuffer, (GLenum, GLenum, GLenum, GLuint))
-GLF(GLenum, glCheckFramebufferStatus, (GLenum))
-GLF(void*, glFenceSync, (GLenum, unsigned))
-GLF(GLenum, glClientWaitSync, (void*, unsigned, unsigned long long))
-GLF(void, glDeleteSync, (void*))
-
-static uint64_t now_ns(void) {
-    struct timespec ts;
-    clock_gettime(CLOCK_MONOTONIC, &ts);
-    return (uint64_t)ts.tv_sec * 1000000000ull + (uint64_t)ts.tv_nsec;
-}
-
-static int cmp_u64(const void* a, const void* b) {
-    uint64_t x = *(const uint64_t*)a, y = *(const uint64_t*)b;
-    return x < y ? -1 : x > y;
-}
-
-
-/* Scene, cases and the case table live next door so the Android plugin's
- * in-process benchmark runs byte-identical bodies. */
-static void bench_gl_failed(const char* what, const char* detail) {
-    fprintf(stderr, "FAIL: %s %s\n", what, detail ? detail : "");
-    exit(1);
-}
-
-/* GLES has glDrawElementsBaseVertex (3.2 core) but no multi-draw form of it, so
- * against a native mobile driver the multi-draw case issues the same sub-draws
- * one at a time - which is what the extension folds up, and what an application
- * without it would have to write. Desktop GL and MobileGL take the real call. */
-static void bench_multi_draw_elements_base_vertex(GLenum mode, const GLsizei* counts, GLenum type,
-                                                  const void* const* offsets, GLsizei drawCount,
-                                                  const GLint* baseVertices) {
-    if (glMultiDrawElementsBaseVertex) {
-        glMultiDrawElementsBaseVertex(mode, counts, type, offsets, drawCount, baseVertices);
-        return;
-    }
-    for (GLsizei i = 0; i < drawCount; ++i) {
-        glDrawElementsBaseVertex(mode, counts[i], type, offsets[i], baseVertices[i]);
-    }
-}
-
-#include "DriverBenchCases.inc"
-
-/* ---- bench driver: fence-paced frames on the offscreen FBO ----------------
- * Frames are closed with a real fence wait, not glFinish: MobileGL implements
- * glFinish and glFlush as no-ops (MG_Impl/GLImpl/Exporting/Definitions.cpp),
- * so a glFinish-paced loop would time only the CPU-side submit on a MobileGL
- * backend while timing submit-plus-GPU on the native driver - the two numbers
- * would not describe the same work. A sync object is honoured by every stack
- * measured here.
- */
-typedef void (*case_fn)(int frame, long a, long b);
-static int g_warmup = 30, g_frames = 120;
-
-static void end_frame_wait(void) {
-    if (glFenceSync && glClientWaitSync && glDeleteSync) {
-        void* sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
-        if (sync) {
-            glClientWaitSync(sync, GL_SYNC_FLUSH_COMMANDS_BIT, 1000000000ull);
-            glDeleteSync(sync);
-            return;
-        }
-    }
-    glFinish();
-}
-
-static void run_case(const char* name, case_fn body, long a, long b, long opsPerFrame) {
-    static uint64_t samples[4096];
-    if (g_frames > 4096) g_frames = 4096;
-    end_frame_wait();
-    for (int i = 0; i < g_warmup; ++i) {
-        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-        body(i, a, b);
-        end_frame_wait();
-    }
-    for (int i = 0; i < g_frames; ++i) {
-        uint64_t t0 = now_ns();
-        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-        body(i, a, b);
-        end_frame_wait();
-        samples[i] = now_ns() - t0;
-    }
-    qsort(samples, g_frames, sizeof(uint64_t), cmp_u64);
-    uint64_t med = samples[g_frames / 2];
-    double frameMs = med / 1e6;
-    double nsPerOp = opsPerFrame > 0 ? (double)med / (double)opsPerFrame : 0.0;
-    printf("%s,%d,%ld,%.3f,%.1f,%.1f\n", name, g_frames, opsPerFrame, frameMs, nsPerOp,
-           1e9 / (double)med);
-    fflush(stdout);
-    if (glGetError() != GL_NO_ERROR) fprintf(stderr, "WARN: GL error after %s\n", name);
-}
-
-/* A display that needs no window system. eglGetPlatformDisplay is EGL 1.5
- * core and eglGetPlatformDisplayEXT is the EGL_EXT_platform_base spelling
- * older loaders ship; both are client entry points, so they resolve before
- * any display exists. Only the attribute-list types differ between the two
- * and this passes none, so one cast covers both. */
-static EGLDisplay surfaceless_display(void) {
-    void* fn = dlsym(g_provider, "eglGetPlatformDisplay");
-    if (!fn) fn = g_eglGetProcAddress("eglGetPlatformDisplay");
-    if (!fn) fn = dlsym(g_provider, "eglGetPlatformDisplayEXT");
-    if (!fn) fn = g_eglGetProcAddress("eglGetPlatformDisplayEXT");
-    if (!fn) return NULL;
-    return ((EGLDisplay(*)(EGLenum, void*, const void*))fn)(EGL_PLATFORM_SURFACELESS_MESA,
-                                                            EGL_DEFAULT_DISPLAY, NULL);
-}
-
-/* ---- EGL bootstrap: one provider library, pbuffer, desktop-GL context ---- */
-static int boot_egl(void) {
-    const char* libpath = getenv("DRIVERBENCH_EGL_LIB");
-    if (!libpath) libpath = "libEGL.so.1";
-    g_provider = dlopen(libpath, RTLD_LAZY | RTLD_LOCAL);
-    if (!g_provider) {
-        fprintf(stderr, "FAIL: dlopen %s: %s\n", libpath, dlerror());
-        return 1;
-    }
-#define ESYM(name) \
-    void* p_##name = dlsym(g_provider, #name); \
-    if (!p_##name) { fprintf(stderr, "FAIL: dlsym %s\n", #name); return 1; }
-    ESYM(eglGetDisplay)
-    ESYM(eglInitialize)
-    ESYM(eglChooseConfig)
-    ESYM(eglBindAPI)
-    ESYM(eglCreateContext)
-    ESYM(eglCreatePbufferSurface)
-    ESYM(eglMakeCurrent)
-    ESYM(eglGetProcAddress)
-    ESYM(eglGetError)
-    g_eglGetProcAddress = (void* (*)(const char*))p_eglGetProcAddress;
-
-    EGLint (*getError)(void) = (EGLint(*)(void))p_eglGetError;
-    EGLBoolean (*initialize)(EGLDisplay, EGLint*, EGLint*) =
-        (EGLBoolean(*)(EGLDisplay, EGLint*, EGLint*))p_eglInitialize;
-
-    /* The default display first: it is the one a windowed app would get, and
-     * on a desktop it is the one that reaches the real GPU - which is the
-     * driver this bench exists to measure. It does need a window system,
-     * though; Mesa's default platform is X11, so with no $DISPLAY (CI, a
-     * build server, ssh without forwarding) eglInitialize fails. Fall back to
-     * EGL_MESA_platform_surfaceless rather than give up: every case draws into
-     * the FBO built by build_resources(), so no window is needed for any of
-     * the work being timed. */
-    EGLint maj = 0, min = 0;
-    const char* how = "default display";
-    EGLDisplay dpy = ((EGLDisplay(*)(void*))p_eglGetDisplay)(EGL_DEFAULT_DISPLAY);
-    if (!dpy || !initialize(dpy, &maj, &min)) {
-        dpy = surfaceless_display();
-        how = "surfaceless display";
-        if (!dpy || !initialize(dpy, &maj, &min)) {
-            fprintf(stderr, "FAIL: eglInitialize (0x%x)\n", getError());
-            return 1;
-        }
-    }
-    fprintf(stderr, "EGL %d.%d via %s (%s)\n", maj, min, libpath, how);
-
-    // Desktop GL first (that is what MobileGL exposes and what the cases are
-    // written against), GLES 3 second so the same binary can measure a device's
-    // native driver as the baseline. The .inc picks ESSL shader sources when the
-    // context turns out to be ES.
-    EGLBoolean (*chooseConfig)(EGLDisplay, const EGLint*, EGLConfig*, EGLint, EGLint*) =
-        (EGLBoolean(*)(EGLDisplay, const EGLint*, EGLConfig*, EGLint, EGLint*))p_eglChooseConfig;
-    EGLContext (*createContext)(EGLDisplay, EGLConfig, EGLContext, const EGLint*) =
-        (EGLContext(*)(EGLDisplay, EGLConfig, EGLContext, const EGLint*))p_eglCreateContext;
-    EGLBoolean (*bindApi)(EGLenum) = (EGLBoolean(*)(EGLenum))p_eglBindAPI;
-
-    EGLConfig cfg = NULL;
-    EGLint ncfg = 0;
-    EGLContext ctx = EGL_NO_CONTEXT;
-
-    if (bindApi(EGL_OPENGL_API)) {
-        const EGLint cfgAttribs[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RED_SIZE, 8,
-                                     EGL_DEPTH_SIZE, 24, EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT, EGL_NONE};
-        if (chooseConfig(dpy, cfgAttribs, &cfg, 1, &ncfg) && ncfg >= 1) {
-            const EGLint ctxAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 3, EGL_CONTEXT_MINOR_VERSION, 2,
-                                         EGL_CONTEXT_OPENGL_PROFILE_MASK,
-                                         EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT, EGL_NONE};
-            ctx = createContext(dpy, cfg, EGL_NO_CONTEXT, ctxAttribs);
-            if (ctx == EGL_NO_CONTEXT) ctx = createContext(dpy, cfg, EGL_NO_CONTEXT, NULL);
-        }
-    }
-    if (ctx == EGL_NO_CONTEXT) {
-        if (!bindApi(EGL_OPENGL_ES_API)) {
-            fprintf(stderr, "FAIL: neither OpenGL nor OpenGL ES is bindable on this provider\n");
-            return 1;
-        }
-        const EGLint esCfgAttribs[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RED_SIZE, 8,
-                                       EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_DEPTH_SIZE, 24,
-                                       EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, EGL_NONE};
-        ncfg = 0;
-        if (!chooseConfig(dpy, esCfgAttribs, &cfg, 1, &ncfg) || ncfg < 1) {
-            // EGL_SURFACE_TYPE 0 matches any config: a stack that offers no
-            // pbuffer at all is still usable through the surfaceless context
-            // path below.
-            const EGLint relaxed[] = {EGL_SURFACE_TYPE, 0, EGL_RED_SIZE, 8, EGL_NONE};
-            if (!chooseConfig(dpy, relaxed, &cfg, 1, &ncfg) || ncfg < 1) {
-                fprintf(stderr, "FAIL: eglChooseConfig\n");
-                return 1;
-            }
-        }
-        const EGLint esCtxAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
-        ctx = createContext(dpy, cfg, EGL_NO_CONTEXT, esCtxAttribs);
-    }
-    if (ctx == EGL_NO_CONTEXT) {
-        fprintf(stderr, "FAIL: eglCreateContext (0x%x)\n", getError());
-        return 1;
-    }
-
-    /* The pbuffer only exists to have something to make current - nothing is
-     * ever drawn to it. Where there is no pbuffer config, EGL_NO_SURFACE is
-     * exactly what EGL_KHR_surfaceless_context takes, so the same call covers
-     * both. */
-    const EGLint pbAttribs[] = {EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE};
-    EGLSurface surf = ((EGLSurface(*)(EGLDisplay, EGLConfig, const EGLint*))p_eglCreatePbufferSurface)(
-        dpy, cfg, pbAttribs);
-    if (surf == EGL_NO_SURFACE)
-        fprintf(stderr, "no pbuffer (0x%x), using a surfaceless context\n", getError());
-    if (!((EGLBoolean(*)(EGLDisplay, EGLSurface, EGLSurface, EGLContext))p_eglMakeCurrent)(dpy, surf,
-                                                                                          surf, ctx)) {
-        fprintf(stderr, "FAIL: eglMakeCurrent (0x%x)\n", getError());
-        return 1;
-    }
-
-    /* Core GL entry points: eglGetProcAddress first (EGL 1.5 serves core
-     * functions), provider dlsym as fallback (both glvnd and MobileGL export
-     * the gl* symbols directly). */
-#define RESOLVE(name)                                                              \
-    do {                                                                           \
-        *(void**)&name = g_eglGetProcAddress(#name);                               \
-        if (!name) *(void**)&name = dlsym(g_provider, #name);                      \
-        if (!name) { fprintf(stderr, "FAIL: resolve %s\n", #name); return 1; }     \
-    } while (0)
-    RESOLVE(glClear); RESOLVE(glClearColor); RESOLVE(glEnable); RESOLVE(glViewport);
-    RESOLVE(glDisable); RESOLVE(glBlendFuncSeparate); RESOLVE(glDrawBuffers);
-    RESOLVE(glGetString); RESOLVE(glGetError); RESOLVE(glFinish); RESOLVE(glFlush);
-    RESOLVE(glGenBuffers); RESOLVE(glBindBuffer); RESOLVE(glBufferData); RESOLVE(glBufferSubData);
-    RESOLVE(glGenVertexArrays); RESOLVE(glBindVertexArray); RESOLVE(glEnableVertexAttribArray);
-    RESOLVE(glVertexAttribPointer); RESOLVE(glGenTextures); RESOLVE(glBindTexture);
-    RESOLVE(glActiveTexture); RESOLVE(glTexImage2D); RESOLVE(glTexSubImage2D);
-    RESOLVE(glTexParameteri); RESOLVE(glGenerateMipmap); RESOLVE(glCreateShader);
-    RESOLVE(glPixelStorei); RESOLVE(glGetIntegerv);
-    RESOLVE(glShaderSource); RESOLVE(glCompileShader); RESOLVE(glGetShaderiv);
-    RESOLVE(glGetShaderInfoLog); RESOLVE(glCreateProgram); RESOLVE(glAttachShader);
-    RESOLVE(glLinkProgram); RESOLVE(glGetProgramiv); RESOLVE(glUseProgram);
-    RESOLVE(glGetUniformLocation); RESOLVE(glUniform1i); RESOLVE(glUniform3f);
-    RESOLVE(glUniformMatrix4fv); RESOLVE(glDrawElements); RESOLVE(glBindAttribLocation);
-    RESOLVE(glUniform3fv); RESOLVE(glDrawArrays); RESOLVE(glDrawElementsBaseVertex);
-    RESOLVE(glBindBufferRange); RESOLVE(glBindBufferBase);
-    RESOLVE(glGetUniformBlockIndex); RESOLVE(glUniformBlockBinding);
-    RESOLVE(glGenSamplers); RESOLVE(glBindSampler); RESOLVE(glSamplerParameteri);
-    RESOLVE(glGenFramebuffers); RESOLVE(glBindFramebuffer); RESOLVE(glGenRenderbuffers);
-    RESOLVE(glBindRenderbuffer); RESOLVE(glRenderbufferStorage); RESOLVE(glFramebufferRenderbuffer);
-    RESOLVE(glCheckFramebufferStatus);
-    // Optional: end_frame_wait() falls back to glFinish when a stack has no
-    // sync objects, so resolve without failing the run.
-    *(void**)&glFenceSync = g_eglGetProcAddress("glFenceSync");
-    if (!glFenceSync) *(void**)&glFenceSync = dlsym(g_provider, "glFenceSync");
-    *(void**)&glClientWaitSync = g_eglGetProcAddress("glClientWaitSync");
-    if (!glClientWaitSync) *(void**)&glClientWaitSync = dlsym(g_provider, "glClientWaitSync");
-    *(void**)&glDeleteSync = g_eglGetProcAddress("glDeleteSync");
-    if (!glDeleteSync) *(void**)&glDeleteSync = dlsym(g_provider, "glDeleteSync");
-    // Desktop-only: GLES 3.2 has DrawElementsBaseVertex but no multi-draw form,
-    // so bench_multi_draw_elements_base_vertex() emulates it when this is null.
-    *(void**)&glMultiDrawElementsBaseVertex = g_eglGetProcAddress("glMultiDrawElementsBaseVertex");
-    if (!glMultiDrawElementsBaseVertex)
-        *(void**)&glMultiDrawElementsBaseVertex = dlsym(g_provider, "glMultiDrawElementsBaseVertex");
-
-    fprintf(stderr, "renderer: %s\n", glGetString(GL_RENDERER));
-    fprintf(stderr, "version:  %s\n", glGetString(GL_VERSION));
-    return 0;
-}
-
-int main(int argc, char** argv) {
-    long draws = 2048;
-    if (getenv("DRIVERBENCH_DRAWS")) draws = atol(getenv("DRIVERBENCH_DRAWS"));
-    if (getenv("DRIVERBENCH_FRAMES")) g_frames = atoi(getenv("DRIVERBENCH_FRAMES"));
-    if (getenv("DRIVERBENCH_SPRITES")) g_mixSprites = atol(getenv("DRIVERBENCH_SPRITES"));
-
-    if (boot_egl()) return 1;
-    build_resources();
-
-    printf("case,frames,ops_per_frame,median_frame_ms,ns_per_op,fps\n");
-    for (int i = 0; i < kBenchCaseCount; ++i) {
-        const BenchCaseDesc* c = &kBenchCases[i];
-        if (argc > 1) {
-            int wanted = 0;
-            for (int j = 1; j < argc; ++j)
-                if (strcmp(argv[j], c->name) == 0) wanted = 1;
-            if (!wanted) continue;
-        }
-        // The generic cases scale with DRIVERBENCH_DRAWS; the mc_* rates are
-        // measured and must not move, or the numbers stop being comparable.
-        long a = c->a, ops = c->opsPerFrame;
-        if (strncmp(c->name, "mc_", 3) != 0 && a > 100) {
-            a = draws * a / 2048;
-            ops = c->opsPerFrame * draws / 2048;
-        }
-        run_case(c->name, c->fn, a, c->b, ops);
-    }
-    return 0;
-}

MobileGL/MG_Benchmark/Driver/DriverBenchCases.inc

@@ -1,640 +0,0 @@
-/* MobileGL - MobileGL/MG_Benchmark/Driver/DriverBenchCases.inc
- * 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
- *
- * The benchmark scene and its cases, with no harness and no GL loader: the
- * includer supplies both. DriverBench.c drives it through function pointers
- * resolved from one EGL provider; MG_Util/SelfTest/DriverBenchJni.cpp drives
- * it through MobileGL's own frontend entry points inside the Android plugin.
- * Sharing the bodies is the point - a number from the phone and a number from
- * the desktop have to describe the same work.
- *
- * The includer must have declared, before including this file: the GL types
- * and enums used below, and callable gl* entry points with the standard
- * signatures. bench_gl_failed() is called (and must be defined) when shader
- * compilation or linking fails, so a caller can report the failure instead of
- * dying inside a benchmark.
- */
-
-/* ---- shared scene resources (Minecraft-shaped) ---- */
-#define MAX_SECTIONS 512
-static GLuint g_progChunk, g_progEntity;
-static GLint g_uOffsetChunk, g_uMvpChunk, g_uMvpEntity;
-static GLuint g_vao[MAX_SECTIONS], g_vbo[MAX_SECTIONS];
-static GLuint g_sharedIbo;
-static GLuint g_texAtlas, g_texLight, g_texEntity;
-static int g_quadsPerSection = 128; /* 128 quads = 512 verts, 768 indices */
-static unsigned char* g_scratch;
-/* Uniform ring + sampler for the 26.2-shaped cases (see the case block below). */
-static GLuint g_uboRing;
-static GLint g_uboAlign = 256;
-static size_t g_uboSlot = 256;
-static GLuint g_sampler;
-/* Two small offscreen targets for the 26.2-style render-pass churn case. */
-static GLuint g_passFbo[2];
-static GLuint g_passColor[2];
-static float g_mvp[16] = {0.002f, 0, 0, 0, 0, 0.002f, 0, 0, 0, 0, -0.001f, 0, -1.f, -1.f, 0.f, 1.f};
-
-/* Minecraft chunk vertex: pos 3f, color 4ub, uv 2f, packed light 2s -> 32 B */
-#define VERT_STRIDE 32
-static void fill_section_vertices(unsigned char* dst, int quads, unsigned seed) {
-    for (int q = 0; q < quads * 4; ++q) {
-        float* f = (float*)(dst + q * VERT_STRIDE);
-        unsigned r = seed = seed * 1664525u + 1013904223u;
-        f[0] = (float)(q & 31) * 8.0f + (float)(r & 7);
-        f[1] = (float)((q >> 5) & 31) * 8.0f;
-        f[2] = (float)(q % 7) * 0.1f;
-        dst[q * VERT_STRIDE + 12] = (unsigned char)r;
-        dst[q * VERT_STRIDE + 13] = (unsigned char)(r >> 8);
-        dst[q * VERT_STRIDE + 14] = (unsigned char)(r >> 16);
-        dst[q * VERT_STRIDE + 15] = 255;
-        f[4] = (float)(r & 1023) / 1024.0f;
-        f[5] = (float)((r >> 10) & 511) / 512.0f;
-        ((short*)(dst + q * VERT_STRIDE + 24))[0] = 15 << 4;
-        ((short*)(dst + q * VERT_STRIDE + 24))[1] = 15 << 4;
-    }
-}
-
-static GLuint make_shader(GLenum kind, const char* src) {
-    GLuint sh = glCreateShader(kind);
-    glShaderSource(sh, 1, &src, NULL);
-    glCompileShader(sh);
-    GLint ok = 0;
-    glGetShaderiv(sh, GL_COMPILE_STATUS, &ok);
-    if (!ok) {
-        char log[1024];
-        glGetShaderInfoLog(sh, sizeof log, NULL, log);
-        bench_gl_failed("shader compile", log);
-        return 0;
-    }
-    return sh;
-}
-
-static GLuint make_program(const char* vs_src, const char* fs_src) {
-    GLuint prog = glCreateProgram();
-    glAttachShader(prog, make_shader(GL_VERTEX_SHADER, vs_src));
-    glAttachShader(prog, make_shader(GL_FRAGMENT_SHADER, fs_src));
-    glBindAttribLocation(prog, 0, "aPos");
-    glBindAttribLocation(prog, 1, "aColor");
-    glBindAttribLocation(prog, 2, "aUv");
-    glBindAttribLocation(prog, 3, "aLight");
-    glLinkProgram(prog);
-    GLint ok = 0;
-    glGetProgramiv(prog, GL_LINK_STATUS, &ok);
-    if (!ok) {
-        bench_gl_failed("program link", "");
-        return 0;
-    }
-    return prog;
-}
-
-static const char* kChunkVs =
-    "#version 150 core\n"
-    "in vec3 aPos; in vec4 aColor; in vec2 aUv; in vec2 aLight;\n"
-    "uniform mat4 uMvp; uniform vec3 uOffset;\n"
-    "out vec4 vColor; out vec2 vUv; out vec2 vLight;\n"
-    "void main(){ gl_Position = uMvp * vec4(aPos + uOffset, 1.0);\n"
-    "  vColor = aColor; vUv = aUv; vLight = aLight * (1.0/256.0); }\n";
-static const char* kChunkFs =
-    "#version 150 core\n"
-    "in vec4 vColor; in vec2 vUv; in vec2 vLight; out vec4 o;\n"
-    "uniform sampler2D uAtlas; uniform sampler2D uLight;\n"
-    "void main(){ o = texture(uAtlas, vUv) * vColor * texture(uLight, vLight); }\n";
-static const char* kEntityVs =
-    "#version 150 core\n"
-    "in vec3 aPos; in vec4 aColor; in vec2 aUv; in vec2 aLight;\n"
-    "uniform mat4 uMvp; uniform mat4 uModel;\n"
-    "out vec4 vColor; out vec2 vUv;\n"
-    "void main(){ gl_Position = uMvp * uModel * vec4(aPos, 1.0); vColor = aColor; vUv = aUv; }\n";
-static const char* kEntityFs =
-    "#version 150 core\n"
-    "in vec4 vColor; in vec2 vUv; out vec4 o; uniform sampler2D uTex;\n"
-    "void main(){ o = texture(uTex, vUv) * vColor; }\n";
-
-// ESSL 3.20 twins of the four shaders above. The bodies are identical; only the
-// version line and the precision qualifiers differ, so the two paths compile the
-// same work. Needed because this bench also runs against a device's native GLES
-// driver as the baseline MobileGL is measured against, and that driver rejects
-// desktop GLSL - while MobileGL is fed desktop GLSL on purpose, since translating
-// it is the thing under test.
-static const char* kChunkVsEs =
-    "#version 320 es\n"
-    "precision highp float;\n"
-    "in vec3 aPos; in vec4 aColor; in vec2 aUv; in vec2 aLight;\n"
-    "uniform mat4 uMvp; uniform vec3 uOffset;\n"
-    "out vec4 vColor; out vec2 vUv; out vec2 vLight;\n"
-    "void main(){ gl_Position = uMvp * vec4(aPos + uOffset, 1.0);\n"
-    "  vColor = aColor; vUv = aUv; vLight = aLight * (1.0/256.0); }\n";
-static const char* kChunkFsEs =
-    "#version 320 es\n"
-    "precision mediump float;\n"
-    "in vec4 vColor; in vec2 vUv; in vec2 vLight; out vec4 o;\n"
-    "uniform sampler2D uAtlas; uniform sampler2D uLight;\n"
-    "void main(){ o = texture(uAtlas, vUv) * vColor * texture(uLight, vLight); }\n";
-static const char* kEntityVsEs =
-    "#version 320 es\n"
-    "precision highp float;\n"
-    "in vec3 aPos; in vec4 aColor; in vec2 aUv; in vec2 aLight;\n"
-    "uniform mat4 uMvp; uniform mat4 uModel;\n"
-    "out vec4 vColor; out vec2 vUv;\n"
-    "void main(){ gl_Position = uMvp * uModel * vec4(aPos, 1.0); vColor = aColor; vUv = aUv; }\n";
-static const char* kEntityFsEs =
-    "#version 320 es\n"
-    "precision mediump float;\n"
-    "in vec4 vColor; in vec2 vUv; out vec4 o; uniform sampler2D uTex;\n"
-    "void main(){ o = texture(uTex, vUv) * vColor; }\n";
-
-// True once build_resources() has seen a GL_VERSION beginning with "OpenGL ES".
-static int g_isGlesContext = 0;
-
-static void setup_vao(GLuint vao, GLuint vbo, GLuint ibo) {
-    glBindVertexArray(vao);
-    glBindBuffer(GL_ARRAY_BUFFER, vbo);
-    glEnableVertexAttribArray(0);
-    glEnableVertexAttribArray(1);
-    glEnableVertexAttribArray(2);
-    glEnableVertexAttribArray(3);
-    glVertexAttribPointer(0, 3, GL_FLOAT, 0, VERT_STRIDE, (void*)0);
-    glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, 1, VERT_STRIDE, (void*)12);
-    glVertexAttribPointer(2, 2, GL_FLOAT, 0, VERT_STRIDE, (void*)16);
-    glVertexAttribPointer(3, 2, GL_SHORT, 0, VERT_STRIDE, (void*)24);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
-}
-
-static GLuint g_mainFbo;
-
-static void build_resources(void) {
-    /* offscreen render target: 1280x720 RBO FBO, like CTS fbo surface mode */
-    GLuint fbo, rboColor, rboDepth;
-    glGenFramebuffers(1, &fbo);
-    g_mainFbo = fbo;
-    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
-    glGenRenderbuffers(1, &rboColor);
-    glBindRenderbuffer(GL_RENDERBUFFER, rboColor);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 1280, 720);
-    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rboColor);
-    glGenRenderbuffers(1, &rboDepth);
-    glBindRenderbuffer(GL_RENDERBUFFER, rboDepth);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, 1280, 720);
-    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboDepth);
-    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-        bench_gl_failed("FBO incomplete", "");
-        return;
-    }
-
-    const char* versionString = (const char*)glGetString(GL_VERSION);
-    g_isGlesContext = versionString != NULL && strncmp(versionString, "OpenGL ES", 9) == 0;
-    g_progChunk = g_isGlesContext ? make_program(kChunkVsEs, kChunkFsEs) : make_program(kChunkVs, kChunkFs);
-    g_progEntity = g_isGlesContext ? make_program(kEntityVsEs, kEntityFsEs) : make_program(kEntityVs, kEntityFs);
-    glUseProgram(g_progChunk);
-    g_uMvpChunk = glGetUniformLocation(g_progChunk, "uMvp");
-    g_uOffsetChunk = glGetUniformLocation(g_progChunk, "uOffset");
-    glUniform1i(glGetUniformLocation(g_progChunk, "uAtlas"), 0);
-    glUniform1i(glGetUniformLocation(g_progChunk, "uLight"), 2);
-    glUniformMatrix4fv(g_uMvpChunk, 1, 0, g_mvp);
-    glUseProgram(g_progEntity);
-    g_uMvpEntity = glGetUniformLocation(g_progEntity, "uMvp");
-    glUniform1i(glGetUniformLocation(g_progEntity, "uTex"), 0);
-    glUniformMatrix4fv(g_uMvpEntity, 1, 0, g_mvp);
-    glUseProgram(g_progChunk);
-
-    /* shared quad index buffer, like Blaze3D's RenderSystem shared sequences */
-    int maxQuads = 4096;
-    unsigned* idx = (unsigned*)malloc((size_t)maxQuads * 6 * 4);
-    for (int q = 0; q < maxQuads; ++q) {
-        unsigned base = q * 4;
-        unsigned* p = idx + q * 6;
-        p[0] = base; p[1] = base + 1; p[2] = base + 2;
-        p[3] = base + 2; p[4] = base + 3; p[5] = base;
-    }
-    glGenBuffers(1, &g_sharedIbo);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_sharedIbo);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER, maxQuads * 6 * 4, idx, GL_STATIC_DRAW);
-    free(idx);
-
-    g_scratch = (unsigned char*)malloc(4 * 1024 * 1024);
-    memset(g_scratch, 0x5a, 4 * 1024 * 1024);
-
-    glGenVertexArrays(MAX_SECTIONS, g_vao);
-    glGenBuffers(MAX_SECTIONS, g_vbo);
-    int bytes = g_quadsPerSection * 4 * VERT_STRIDE;
-    for (int i = 0; i < MAX_SECTIONS; ++i) {
-        fill_section_vertices(g_scratch, g_quadsPerSection, i * 7919u + 1);
-        glBindBuffer(GL_ARRAY_BUFFER, g_vbo[i]);
-        glBufferData(GL_ARRAY_BUFFER, bytes, g_scratch, GL_STATIC_DRAW);
-        setup_vao(g_vao[i], g_vbo[i], g_sharedIbo);
-    }
-
-    glGenTextures(1, &g_texAtlas);
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, g_texAtlas);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1024, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, g_scratch);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glGenerateMipmap(GL_TEXTURE_2D);
-
-    glGenTextures(1, &g_texLight);
-    glActiveTexture(GL_TEXTURE0 + 2);
-    glBindTexture(GL_TEXTURE_2D, g_texLight);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, g_scratch);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-
-    glGenTextures(1, &g_texEntity);
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, g_texEntity);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, g_scratch);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glBindTexture(GL_TEXTURE_2D, g_texAtlas);
-
-    // Uniform ring the 26.2-style case sub-ranges into, sized like a real
-    // frame's worth of per-draw uniform slots.
-    GLint align = 256;
-    glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &align);
-    g_uboAlign = align > 0 ? align : 256;
-    g_uboSlot = (size_t)g_uboAlign;
-    glGenBuffers(1, &g_uboRing);
-    glBindBuffer(GL_UNIFORM_BUFFER, g_uboRing);
-    glBufferData(GL_UNIFORM_BUFFER, 4 * 1024 * 1024, g_scratch, GL_DYNAMIC_DRAW);
-    glBindBuffer(GL_UNIFORM_BUFFER, 0);
-
-    for (int i = 0; i < 2; ++i) {
-        glGenFramebuffers(1, &g_passFbo[i]);
-        glBindFramebuffer(GL_FRAMEBUFFER, g_passFbo[i]);
-        glGenRenderbuffers(1, &g_passColor[i]);
-        glBindRenderbuffer(GL_RENDERBUFFER, g_passColor[i]);
-        glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 256, 256);
-        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, g_passColor[i]);
-        if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-            bench_gl_failed("pass FBO incomplete", "");
-            return;
-        }
-    }
-    /* back to the main offscreen target the harness set up */
-    glBindFramebuffer(GL_FRAMEBUFFER, g_mainFbo);
-
-    glGenSamplers(1, &g_sampler);
-    glSamplerParameteri(g_sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glSamplerParameteri(g_sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-
-    glEnable(GL_DEPTH_TEST);
-    glClearColor(0.3f, 0.5f, 0.9f, 1.0f);
-    glViewport(0, 0, 1280, 720);
-    const GLenum setupError = glGetError();
-    if (setupError != GL_NO_ERROR) {
-        char message[64];
-        snprintf(message, sizeof message, "0x%04x", setupError);
-        bench_gl_failed("GL error during resource setup", message);
-    }
-}
-
-static void case_draw_tiny(int frame, long a, long b) {
-    (void)frame; (void)b;
-    glBindVertexArray(g_vao[0]);
-    for (long i = 0; i < a; ++i) glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-}
-
-static void case_draw_uniform(int frame, long a, long b) {
-    (void)frame; (void)b;
-    glBindVertexArray(g_vao[0]);
-    for (long i = 0; i < a; ++i) {
-        glUniform3f(g_uOffsetChunk, (float)(i & 15), (float)((i >> 4) & 15), 0.0f);
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-    }
-}
-
-static void case_draw_multi_vao(int frame, long a, long b) {
-    (void)frame; (void)b;
-    for (long i = 0; i < a; ++i) {
-        glBindVertexArray(g_vao[i % MAX_SECTIONS]);
-        glUniform3f(g_uOffsetChunk, (float)(i & 15), (float)((i >> 4) & 15), 0.0f);
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-    }
-}
-
-static void case_tex_pingpong(int frame, long a, long b) {
-    (void)frame; (void)b;
-    glBindVertexArray(g_vao[0]);
-    for (long i = 0; i < a; ++i) {
-        glBindTexture(GL_TEXTURE_2D, (i & 1) ? g_texEntity : g_texAtlas);
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-    }
-    glBindTexture(GL_TEXTURE_2D, g_texAtlas);
-}
-
-static void case_program_pingpong(int frame, long a, long b) {
-    (void)frame; (void)b;
-    glBindVertexArray(g_vao[0]);
-    for (long i = 0; i < a; ++i) {
-        if (i & 1) {
-            glUseProgram(g_progEntity);
-            glUniformMatrix4fv(g_uMvpEntity, 1, 0, g_mvp);
-        } else {
-            glUseProgram(g_progChunk);
-            glUniform3f(g_uOffsetChunk, (float)(i & 15), 0.0f, 0.0f);
-        }
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-    }
-    glUseProgram(g_progChunk);
-}
-
-/* a = uploads per frame, b = bytes per upload (0 => section size) */
-static void case_chunk_upload(int frame, long a, long b) {
-    if (b <= 0) b = g_quadsPerSection * 4 * VERT_STRIDE;
-    if (b > 4 * 1024 * 1024) b = 4 * 1024 * 1024;
-    for (long i = 0; i < a; ++i) {
-        int slot = (int)(((long)frame * a + i) % MAX_SECTIONS);
-        glBindBuffer(GL_ARRAY_BUFFER, g_vbo[slot]);
-        glBufferData(GL_ARRAY_BUFFER, b, NULL, GL_STATIC_DRAW); /* orphan */
-        glBufferSubData(GL_ARRAY_BUFFER, 0, b, g_scratch);
-        glBindVertexArray(g_vao[slot]);
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-    }
-}
-
-/* a = sprite updates per frame */
-static void case_atlas_sprite(int frame, long a, long b) {
-    (void)b;
-    glBindVertexArray(g_vao[0]);
-    glBindTexture(GL_TEXTURE_2D, g_texAtlas);
-    for (long i = 0; i < a; ++i) {
-        int x = (int)((frame * 13 + i * 17) % (1024 - 16));
-        int y = (int)((frame * 7 + i * 29) % (512 - 16));
-        glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, 16, 16, GL_RGBA, GL_UNSIGNED_BYTE, g_scratch);
-    }
-    glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-}
-
-/* a = lightmap updates (+draw) per frame */
-static void case_lightmap(int frame, long a, long b) {
-    (void)frame; (void)b;
-    glBindVertexArray(g_vao[0]);
-    for (long i = 0; i < a; ++i) {
-        glActiveTexture(GL_TEXTURE0 + 2);
-        glBindTexture(GL_TEXTURE_2D, g_texLight);
-        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 16, 16, GL_RGBA, GL_UNSIGNED_BYTE, g_scratch);
-        glActiveTexture(GL_TEXTURE0);
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-    }
-}
-
-/* Composite: a = total draws, b = uploads per frame. Mix modeled on trace
- * analysis: chunk draws with per-draw offset uniform across sections, 10%
- * entity-style program flips, per-frame lightmap + sprite updates, b chunk
- * re-uploads. */
-static long g_mixSprites = 8;
-static void case_scene_mix(int frame, long a, long b) {
-    glActiveTexture(GL_TEXTURE0 + 2);
-    glBindTexture(GL_TEXTURE_2D, g_texLight);
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 16, 16, GL_RGBA, GL_UNSIGNED_BYTE, g_scratch);
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, g_texAtlas);
-    for (long i = 0; i < g_mixSprites; ++i) {
-        int x = (int)((frame * 13 + i * 17) % (1024 - 16));
-        int y = (int)((frame * 7 + i * 29) % (512 - 16));
-        glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, 16, 16, GL_RGBA, GL_UNSIGNED_BYTE, g_scratch);
-    }
-    for (long i = 0; i < b; ++i) {
-        int slot = (int)(((long)frame * b + i) % MAX_SECTIONS);
-        long bytes = g_quadsPerSection * 4 * VERT_STRIDE;
-        glBindBuffer(GL_ARRAY_BUFFER, g_vbo[slot]);
-        glBufferData(GL_ARRAY_BUFFER, bytes, NULL, GL_STATIC_DRAW);
-        glBufferSubData(GL_ARRAY_BUFFER, 0, bytes, g_scratch);
-    }
-    long entityEvery = 10;
-    for (long i = 0; i < a; ++i) {
-        if (i % entityEvery == entityEvery - 1) {
-            glUseProgram(g_progEntity);
-            glUniformMatrix4fv(g_uMvpEntity, 1, 0, g_mvp);
-            glBindTexture(GL_TEXTURE_2D, g_texEntity);
-            glBindVertexArray(g_vao[i % MAX_SECTIONS]);
-            glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-            glUseProgram(g_progChunk);
-            glBindTexture(GL_TEXTURE_2D, g_texAtlas);
-        } else {
-            glBindVertexArray(g_vao[i % MAX_SECTIONS]);
-            glUniform3f(g_uOffsetChunk, (float)(i & 15), (float)((i >> 4) & 15), 0.0f);
-            glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-        }
-    }
-}
-
-/* ---- Trace-derived cases -------------------------------------------------
- * Per-frame call mixes measured from the three captured Minecraft traces
- * (render distance 32, 1280x720, hovering in-world). Each case reproduces one
- * renderer's dominant per-draw sequence at its measured rate, so the number a
- * backend posts here is directly comparable to what that game version asks of
- * the driver every frame.
- *
- *   vanilla 1.21.1 : 5495 glDrawElements, 5490 glBindVertexArray,
- *                    5487 glUniform3fv, 95 glTexSubImage2D (+382 glPixelStorei,
- *                    247 glTexParameteri), 23 glBufferData per frame
- *   fabric+sodium  : 132 glMultiDrawElementsBaseVertex, 279 glBindVertexArray,
- *                    132 glUniform3f, 32 glBufferData per frame
- *   26.2 snapshot  : 3401 glDrawElementsBaseVertex, each preceded by
- *                    glBindBufferRange + glBindBuffer (3639/3412 per frame)
- */
-/* vanilla: bind VAO, push the chunk offset, draw. a = draws per frame. */
-static void case_mc_vanilla_draw(int frame, long a, long b) {
-    (void)frame; (void)b;
-    float offset[3];
-    for (long i = 0; i < a; ++i) {
-        glBindVertexArray(g_vao[i % MAX_SECTIONS]);
-        offset[0] = (float)(i & 15);
-        offset[1] = (float)((i >> 4) & 15);
-        offset[2] = 0.0f;
-        glUniform3fv(g_uOffsetChunk, 1, offset);
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-    }
-}
-
-/* sodium: one multi-draw covers many chunk sections out of a shared buffer.
- * a = multi-draws per frame, b = sub-draws inside each. */
-static void case_mc_sodium_multidraw(int frame, long a, long b) {
-    (void)frame;
-    enum { kMaxSub = 64 };
-    if (b <= 0 || b > kMaxSub) b = 32;
-    GLsizei counts[kMaxSub];
-    const void* offsets[kMaxSub];
-    GLint baseVertices[kMaxSub];
-    for (long s = 0; s < b; ++s) {
-        counts[s] = (GLsizei)(g_quadsPerSection * 6 / b);
-        offsets[s] = (const void*)(uintptr_t)(s * (g_quadsPerSection * 6 / b) * 4);
-        baseVertices[s] = 0;
-    }
-    for (long i = 0; i < a; ++i) {
-        glBindVertexArray(g_vao[i % MAX_SECTIONS]);
-        glBindVertexArray(g_vao[i % MAX_SECTIONS]); /* sodium rebinds ~2x per draw */
-        glUniform3f(g_uOffsetChunk, (float)(i & 15), (float)((i >> 4) & 15), 0.0f);
-        // Routed through the includer: GLES has no multi-draw-with-base-vertex, so
-        // a native-driver harness emulates it with the loop the extension folds up.
-        bench_multi_draw_elements_base_vertex(GL_TRIANGLES, counts, GL_UNSIGNED_INT, offsets,
-                                              (GLsizei)b, baseVertices);
-    }
-}
-
-/* 26.2: every draw rebinds a fresh uniform-buffer range out of a ring.
- * a = draws per frame. */
-static void case_mc_ubo_range(int frame, long a, long b) {
-    (void)b;
-    const size_t slots = (4u * 1024u * 1024u) / g_uboSlot;
-    for (long i = 0; i < a; ++i) {
-        const size_t slot = (size_t)(((long)frame * a + i) % (long)slots);
-        glBindBufferRange(GL_UNIFORM_BUFFER, 0, g_uboRing, (GLintptr)(slot * g_uboSlot),
-                          (GLsizeiptr)g_uboSlot);
-        glBindBuffer(GL_UNIFORM_BUFFER, g_uboRing);
-        glDrawElementsBaseVertex(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0, 0);
-    }
-}
-
-/* vanilla's animated-sprite path: every upload is wrapped in the pixel-store
- * and filter state Blaze3D re-sets around it. a = uploads per frame. */
-static void case_mc_tex_stream(int frame, long a, long b) {
-    (void)b;
-    glBindVertexArray(g_vao[0]);
-    glBindTexture(GL_TEXTURE_2D, g_texAtlas);
-    for (long i = 0; i < a; ++i) {
-        glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
-        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-        glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
-        glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        int x = (int)((frame * 13 + i * 17) % (1024 - 16));
-        int y = (int)((frame * 7 + i * 29) % (512 - 16));
-        glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, 16, 16, GL_RGBA, GL_UNSIGNED_BYTE, g_scratch);
-    }
-    glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-}
-
-/* Blaze3D re-resolves uniform locations by name every frame. a = lookups. */
-static void case_mc_uniform_lookup(int frame, long a, long b) {
-    (void)frame; (void)b;
-    static const char* names[4] = {"uMvp", "uOffset", "uAtlas", "uLight"};
-    volatile GLint sink = 0;
-    for (long i = 0; i < a; ++i) sink += glGetUniformLocation(g_progChunk, names[i & 3]);
-    (void)sink;
-    glBindVertexArray(g_vao[0]);
-    glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-}
-
-/* 26.2 rebinds a sampler object per texture unit switch. a = switches. */
-static void case_mc_sampler_churn(int frame, long a, long b) {
-    (void)frame; (void)b;
-    glBindVertexArray(g_vao[0]);
-    for (long i = 0; i < a; ++i) {
-        glActiveTexture(GL_TEXTURE0 + (GLenum)(i & 3));
-        glBindTexture(GL_TEXTURE_2D, (i & 1) ? g_texEntity : g_texAtlas);
-        glBindSampler((GLuint)(i & 3), g_sampler);
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-    }
-    glActiveTexture(GL_TEXTURE0);
-}
-
-
-/* 26.2 switches render targets constantly: 132 glBindFramebuffer and 198
- * glDrawBuffers per frame. Pass switching is where a Vulkan backend pays for
- * render-pass breaks, so this case is the one to watch on Magma. a = passes. */
-static void case_mc_pass_switch(int frame, long a, long b) {
-    (void)frame; (void)b;
-    static const GLenum kColor0[1] = {GL_COLOR_ATTACHMENT0};
-    glBindVertexArray(g_vao[0]);
-    for (long i = 0; i < a; ++i) {
-        glBindFramebuffer(GL_FRAMEBUFFER, g_passFbo[i & 1]);
-        glDrawBuffers(1, kColor0);
-        glViewport(0, 0, 256, 256);
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-    }
-    glBindFramebuffer(GL_FRAMEBUFFER, g_mainFbo);
-    glViewport(0, 0, 1280, 720);
-}
-
-/* Blaze3D toggles blend around batches: 46 glEnable/glDisable pairs and 28
- * glBlendFuncSeparate per vanilla frame. a = toggle pairs. */
-static void case_mc_state_toggle(int frame, long a, long b) {
-    (void)frame; (void)b;
-    glBindVertexArray(g_vao[0]);
-    for (long i = 0; i < a; ++i) {
-        glEnable(GL_BLEND);
-        glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-        glDisable(GL_BLEND);
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-    }
-}
-
-/* 26.2 re-sets texture parameters relentlessly - 612 glTexParameteri per frame,
- * almost always to the value already in place. Measures redundant-param
- * filtering. a = parameter writes. */
-static void case_mc_tex_param(int frame, long a, long b) {
-    (void)frame; (void)b;
-    glBindVertexArray(g_vao[0]);
-    glBindTexture(GL_TEXTURE_2D, g_texAtlas);
-    for (long i = 0; i < a; i += 4) {
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    }
-    glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-}
-
-/* Sodium switches programs mid-frame far more than vanilla: 62 glUseProgram and
- * 60 mat4 uploads per frame. a = program switches. */
-static void case_mc_use_program(int frame, long a, long b) {
-    (void)frame; (void)b;
-    glBindVertexArray(g_vao[0]);
-    for (long i = 0; i < a; ++i) {
-        if (i & 1) {
-            glUseProgram(g_progEntity);
-            glUniformMatrix4fv(g_uMvpEntity, 1, 0, g_mvp);
-        } else {
-            glUseProgram(g_progChunk);
-            glUniformMatrix4fv(g_uMvpChunk, 1, 0, g_mvp);
-        }
-        glDrawElements(GL_TRIANGLES, g_quadsPerSection * 6, GL_UNSIGNED_INT, 0);
-    }
-    glUseProgram(g_progChunk);
-}
-
-/* ---- the case table both harnesses iterate --------------------------------
- * a/b are the case's own knobs; opsPerFrame is what one bench frame is
- * normalised by, so ns_per_op compares across renderers. The mc_* rates are
- * the per-frame call counts measured from the captured traces.
- */
-typedef void (*bench_case_fn)(int frame, long a, long b);
-
-typedef struct {
-    const char* name;
-    bench_case_fn fn;
-    long a, b, opsPerFrame;
-} BenchCaseDesc;
-
-static const BenchCaseDesc kBenchCases[] = {
-    {"mc_vanilla_draw", case_mc_vanilla_draw, 5495, 0, 5495},
-    {"mc_sodium_multidraw", case_mc_sodium_multidraw, 132, 32, 132},
-    {"mc_ubo_range", case_mc_ubo_range, 3401, 0, 3401},
-    {"mc_tex_stream", case_mc_tex_stream, 95, 0, 95},
-    {"mc_uniform_lookup", case_mc_uniform_lookup, 41, 0, 41},
-    {"mc_sampler_churn", case_mc_sampler_churn, 306, 0, 306},
-    {"mc_pass_switch", case_mc_pass_switch, 132, 0, 132},
-    {"mc_state_toggle", case_mc_state_toggle, 46, 0, 46},
-    {"mc_tex_param", case_mc_tex_param, 612, 0, 612},
-    {"mc_use_program", case_mc_use_program, 62, 0, 62},
-    {"draw_tiny", case_draw_tiny, 2048, 0, 2048},
-    {"draw_uniform", case_draw_uniform, 2048, 0, 2048},
-    {"draw_multi_vao", case_draw_multi_vao, 2048, 0, 2048},
-    {"tex_pingpong", case_tex_pingpong, 1024, 0, 1024},
-    {"program_pingpong", case_program_pingpong, 512, 0, 512},
-    {"chunk_upload", case_chunk_upload, 24, 0, 24},
-    {"atlas_sprite", case_atlas_sprite, 32, 0, 32},
-    {"lightmap", case_lightmap, 4, 0, 4},
-    {"scene_mix", case_scene_mix, 2048, 12, 2048},
-};
-static const int kBenchCaseCount = (int)(sizeof kBenchCases / sizeof kBenchCases[0]);

MobileGL/MG_Benchmark/Driver/run_driver_bench.sh

@@ -1,41 +0,0 @@
-#!/bin/bash
-# Run the headless EGL DriverBench on one renderer:
-#   ./run_driver_bench.sh native            [bench args...]
-#   ./run_driver_bench.sh espryt <libMobileGL.so> [bench args...]
-#   ./run_driver_bench.sh magma  <libMobileGL.so> [bench args...]
-# The bench dlopens exactly one EGL provider (DRIVERBENCH_EGL_LIB): the system
-# libEGL.so.1 for native, or the given libMobileGL.so for a MobileGL backend -
-# no LD_LIBRARY_PATH shadowing, so MobileGL's own loader still finds the real
-# driver underneath.
-#
-# Pin the vendor libraries explicitly. A bare libEGL.so.1 on a glvnd system
-# picks whatever vendor eglGetDisplay(EGL_DEFAULT_DISPLAY) resolves first,
-# which is Mesa/llvmpipe here - a software rasteriser silently replacing the
-# GPU under a benchmark. Override MGL_EGL_VENDOR / MGL_VK_ICD to test another
-# driver.
-set -eu
-HERE=$(cd "$(dirname "$0")" && pwd)
-BENCH=${DRIVERBENCH_BIN:-$HERE/DriverBench}
-EGL_VENDOR=${MGL_EGL_VENDOR:-/usr/share/glvnd/egl_vendor.d/10_nvidia.json}
-VK_ICD=${MGL_VK_ICD:-/usr/share/vulkan/icd.d/nvidia_icd.x86_64.json}
-MODE=$1; shift
-
-export __EGL_VENDOR_LIBRARY_FILENAMES=$EGL_VENDOR
-export EGL_PLATFORM=${EGL_PLATFORM:-x11}
-
-case "$MODE" in
-  native)
-    export DRIVERBENCH_EGL_LIB=${DRIVERBENCH_EGL_LIB:-libEGL.so.1}
-    ;;
-  espryt)
-    export DRIVERBENCH_EGL_LIB=$(readlink -f "$1"); shift
-    export MOBILEGL_BACKEND_TYPE=DirectGLES
-    ;;
-  magma)
-    export DRIVERBENCH_EGL_LIB=$(readlink -f "$1"); shift
-    export MOBILEGL_BACKEND_TYPE=DirectVulkan
-    export VK_ICD_FILENAMES=$VK_ICD
-    ;;
-  *) echo "unknown mode: $MODE (native|espryt|magma)"; exit 1 ;;
-esac
-exec "$BENCH" "$@"

MobileGL/MG_Impl/GLImpl/Buffer/GL_Buffer.cpp

@@ -8,10 +8,6 @@
 
 #include "GL_Buffer.h"
 #include "Validators.h"
-#include "../Texture/GL_Texture.h"
-#include "../Getter/GL_Getter.h"
-#include <MG_Util/Converters/GLToMG/TextureEnumConverter.h>
-#include <MG_Util/Metrics/TextureMetrics.h>
 #include <Config.h>
 #include <MG_State/GLState/Core.h>
 #include <MG_State/GLState/ErrorState/Error.h>
@@ -42,7 +38,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             GetNamedBufferParameteriv,
             GetNamedBufferParameteri64v,
             GetNamedBufferPointerv,
-            GetNamedBufferSubData,
         };
 
         const char* GetBufferOpName(BufferOp op) {
@@ -81,8 +76,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                 return "UnmapNamedBuffer";
             case BufferOp::FlushMappedNamedBufferRange:
                 return "FlushMappedNamedBufferRange";
-            case BufferOp::GetNamedBufferSubData:
-                return "GetNamedBufferSubData";
             case BufferOp::GetNamedBufferParameteriv:
                 return "GetNamedBufferParameteriv";
             case BufferOp::GetNamedBufferParameteri64v:
@@ -96,64 +89,25 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         SharedPtr<MG_State::GLState::BufferObject> GetNamedBufferObject(GLuint buffer, BufferOp op);
 
-        // The size of one cleared element, which is what offset and size must be multiples of
-        // (GL 4.6 core 6.3). `internalformat` is restricted to the buffer-texture format table, and
-        // `format`/`type` describe the client-side pattern, so both are validated here and the
-        // caller only has to know how wide an element is.
         SizeT GetClearPatternSize(GLenum internalformat, GLenum format, GLenum type, BufferOp op) {
-            if (!IsBufferTextureInternalFormat(internalformat)) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", GetBufferOpName(op),
-                        std::format("internalformat 0x{:X} is not one of the sized formats a buffer clear accepts.",
-                                    internalformat)));
-                return 0;
-            }
-
-            // Unlike internalformat, a bad format or type here is INVALID_VALUE rather than
-            // INVALID_ENUM (GL 4.6 core 6.3) - the odd one out among the enum arguments.
-            const TextureInputFormat inputFormat = MG_Util::ConvertGLEnumToTextureInputFormat(format);
-            if (inputFormat == TextureInputFormat::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", GetBufferOpName(op),
-                                                 std::format("format 0x{:X} is not a pixel format.", format)));
-                return 0;
-            }
-
-            const TexturePixelDataType pixelType = MG_Util::ConvertGLEnumToTexturePixelDataType(type);
-            if (pixelType == TexturePixelDataType::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", GetBufferOpName(op),
-                                                 std::format("type 0x{:X} is not a pixel type.", type)));
-                return 0;
-            }
-
-            const TextureInternalFormat internal =
-                MG_Util::ConvertGLEnumToTextureInternalFormat(internalformat);
-            const SizeT elementSize = MG_Util::GetSizedInternalFormatSizeInBytes(internal);
-            if (elementSize == 0) {
+            if (format != GL_RED_INTEGER) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidEnum,
                     MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", GetBufferOpName(op),
-                                                 std::format("internalformat 0x{:X} has no known element size.",
-                                                             internalformat)));
+                                                 "Only GL_RED_INTEGER buffer clears are currently supported."));
                 return 0;
             }
 
-            // The pattern is replicated verbatim, which is only the whole story while the client
-            // layout already matches the internal format - the case every entry point in practice
-            // uses, and the only one the conversion machinery here can express. Say so rather than
-            // quietly writing a differently-sized pattern.
-            const SizeT sourceSize = MG_Util::GetInputBytesPerPixel(inputFormat, pixelType);
-            if (sourceSize != elementSize) {
-                MGLOG_W("%s: clear pattern is %zu bytes but internalformat 0x%X stores %zu; "
-                        "converting between them is not implemented",
-                        GetBufferOpName(op), sourceSize, internalformat, elementSize);
-            }
-            return elementSize;
+            if (internalformat == GL_R8UI && type == GL_UNSIGNED_BYTE) return sizeof(GLubyte);
+            if (internalformat == GL_R32UI && type == GL_UNSIGNED_INT) return sizeof(GLuint);
+
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", GetBufferOpName(op),
+                                             std::format("Unsupported clear format tuple: internalformat=0x{:X}, "
+                                                         "format=0x{:X}, type=0x{:X}",
+                                                         internalformat, format, type)));
+            return 0;
         }
 
         Bool ValidateBufferClearRange(const SharedPtr<MG_State::GLState::BufferObject>& bufferObject, GLintptr offset,
@@ -862,10 +816,6 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         Range1D mappedRange = bufferObject->GetMappedRange();
         auto mappingAccess = bufferObject->GetMappingAccess();
-        // GL 4.6 6.5: the error is on OVERLAP with the mapped range, i.e. a half-open
-        // intersection test. There used to be a second test below this one asking only
-        // `offset + size >= mappedRange.start`, which rejects every write that starts
-        // before a mapped tail as well - it made a legal disjoint glBufferSubData fail.
         if (bufferObject->IsMapped() && !(mappingAccess & BufferMappingAccessBit::Persistent) &&
             (offset < mappedRange.end) && (offset + size > mappedRange.start)) {
             MG_State::pGLContext->RecordError(
@@ -876,6 +826,18 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
+        if (bufferObject->IsMapped() && !(mappingAccess & BufferMappingAccessBit::Persistent)) {
+            Range1D mappedRange = bufferObject->GetMappedRange();
+            if (offset + size >= mappedRange.start) {
+                MG_State::pGLContext->RecordError(
+                    ErrorCode::InvalidOperation,
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BufferSubData_State",
+                                                 "Cannot modify a mapped buffer object unless it was "
+                                                 "mapped with GL_MAP_PERSISTENT_BIT."));
+                return;
+            }
+        }
+
         bufferObject->UploadSubData({(void*)data, (SizeT)size}, offset);
     }
 
@@ -929,44 +891,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         bufferObject->DownloadSubData(data, static_cast<SizeT>(offset), static_cast<SizeT>(size));
     }
 
-    void GetNamedBufferSubData_State(GLuint buffer, GLintptr offset, GLsizeiptr size, void* data) {
-        if (!data) {
-            // Match GetBufferSubData_State: a null pointer is a caller bug, not a GL-specified error.
-            return;
-        }
-
-        if (size < 0 || offset < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetNamedBufferSubData_State",
-                                             "Offset and size must be non-negative."));
-            return;
-        }
-
-        auto bufferObject = GetNamedBufferObject(buffer, BufferOp::GetNamedBufferSubData);
-        if (!bufferObject) return;
-
-        if (static_cast<SizeT>(offset) + static_cast<SizeT>(size) > bufferObject->GetSize()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetNamedBufferSubData_State",
-                                             "Offset and size exceed buffer size."));
-            return;
-        }
-
-        if (bufferObject->IsMapped() &&
-            !(bufferObject->GetMappingAccess() & BufferMappingAccessBit::Persistent)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetNamedBufferSubData_State",
-                                             "Cannot read from a buffer object mapped without GL_MAP_PERSISTENT_BIT."));
-            return;
-        }
-
-        bufferObject->SyncGpuWrites();
-        bufferObject->DownloadSubData(data, static_cast<SizeT>(offset), static_cast<SizeT>(size));
-    }
-
     void BufferData_State(GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
         MGLOG_D("%s: %s, size = %d, data = %p, usage = %s", __func__, MG_Util::ConvertGLEnumToString(target).c_str(),
                 size, data, MG_Util::ConvertGLEnumToString(usage).c_str());
@@ -1006,11 +930,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void BufferStorage_State(GLenum target, GLsizeiptr size, const void* data, GLbitfield flags) {
-        // Error precedence: "no buffer is bound to target" outranks a bad size or bad
-        // flags, so the binding has to be resolved before either is validated.
-        auto bufferObject = GetBoundBufferObject(target, BufferOp::BufferStorage);
-        if (!bufferObject) return;
-
         if (size <= 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
@@ -1019,6 +938,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
         if (!ValidateStorageFlags(flags, BufferOp::BufferStorage)) return;
 
+        auto bufferObject = GetBoundBufferObject(target, BufferOp::BufferStorage);
+        if (!bufferObject) return;
         if (bufferObject->IsImmutableStorage()) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
@@ -1053,10 +974,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void NamedBufferStorage_State(GLuint buffer, GLsizeiptr size, const void* data, GLbitfield flags) {
-        // Same precedence as BufferStorage_State: the buffer-name error comes first.
-        auto bufferObject = GetNamedBufferObject(buffer, BufferOp::NamedBufferStorage);
-        if (!bufferObject) return;
-
         if (size <= 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
@@ -1065,6 +982,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
         if (!ValidateStorageFlags(flags, BufferOp::NamedBufferStorage)) return;
 
+        auto bufferObject = GetNamedBufferObject(buffer, BufferOp::NamedBufferStorage);
+        if (!bufferObject) return;
         if (bufferObject->IsImmutableStorage()) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
@@ -1484,71 +1403,12 @@ namespace MobileGL::MG_Impl::GLImpl {
         GetBufferBindingSlot(bufferTarget).Bind(bufferObject);
     }
 
-    // GL 4.6 core 6.1.1: the constraints glBindBufferRange puts on the (offset, size) pair.
-    // Every one of them is INVALID_VALUE, and all of them are checked before a single piece
-    // of state is written - a rejected bind must leave the binding point exactly as it was.
-    // They apply only to a non-zero buffer: buffer 0 detaches the binding point and ignores
-    // offset and size, which is also how glBindBuffersRange spells "reset this element"
-    // (a NULL buffers array, or a zero entry inside one).
-    static Bool ValidateBufferRangeOffsetAndSize(GLenum target, GLintptr offset, GLsizeiptr size,
-                                                 const char* funcName) {
-        if (size <= 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", funcName,
-                                             std::format("size ({}) must be greater than zero.", size)));
-            return false;
-        }
-        if (offset < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", funcName,
-                                             std::format("offset ({}) must not be negative.", offset)));
-            return false;
-        }
-        // GL_UNIFORM_BUFFER and GL_SHADER_STORAGE_BUFFER each constrain the offset to their own
-        // implementation-defined alignment, which glGetIntegerv already answers.
-        GLenum alignmentQuery = GL_NONE;
-        if (target == GL_SHADER_STORAGE_BUFFER) {
-            alignmentQuery = GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT;
-        } else if (target == GL_UNIFORM_BUFFER) {
-            alignmentQuery = GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT;
-        }
-        if (alignmentQuery != GL_NONE) {
-            GLint alignment = 0;
-            GetIntegerv(alignmentQuery, &alignment);
-            if (alignment > 0 && (offset % static_cast<GLintptr>(alignment)) != 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", funcName,
-                        std::format("offset ({}) must be a multiple of {} ({}).", offset,
-                                    MG_Util::ConvertGLEnumToString(alignmentQuery), alignment)));
-                return false;
-            }
-        }
-        // A transform feedback capture binding is addressed in 32-bit components, so BOTH the
-        // offset and the size must be multiples of 4.
-        if (target == GL_TRANSFORM_FEEDBACK_BUFFER && ((offset % 4) != 0 || (size % 4) != 0)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl", funcName,
-                    std::format("offset ({}) and size ({}) must both be multiples of 4 for "
-                                "GL_TRANSFORM_FEEDBACK_BUFFER.",
-                                offset, size)));
-            return false;
-        }
-        return true;
-    }
-
     void BindBufferRange_State(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {
         MGLOG_D("%s: target = %s, index = %u, buffer = %u, offset = %d, size = %d", __func__,
                 MG_Util::ConvertGLEnumToString(target).c_str(), index, buffer, offset, size);
         BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
         if (!BufferImpl::ValidateBufferBindingPointTarget(bufferTarget)) return;
         if (!BufferImpl::ValidateBufferBindingPointIndex(bufferTarget, index)) return;
-        if (buffer != 0 && !ValidateBufferRangeOffsetAndSize(target, offset, size, __func__)) return;
         if (bufferTarget == BufferTarget::TransformFeedback && MG_State::pGLContext->IsTransformFeedbackActive()) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
@@ -1693,10 +1553,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         BufferSubData_State(target, offset, size, data);
     }
 
-    void GetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, void* data) {
-        GetNamedBufferSubData_State(buffer, offset, size, data);
-    }
-
     void GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void* data) {
         GetBufferSubData_State(target, offset, size, data);
     }
@@ -1722,32 +1578,15 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     // ARB_multi_bind: defined by the spec as equivalent to a loop over the single-bind entry
-    // points (with buffer 0 resetting the binding point) - but only AFTER an up-front check
-    // of the whole [first, first + count) range. Looping straight into the single-bind entry
-    // points reports the single-bind INVALID_VALUE for an out-of-range index instead of the
-    // multi-bind INVALID_OPERATION, and binds the in-range prefix before failing.
-    static Bool ValidateMultiBindBufferRange(GLenum target, GLuint first, GLsizei count, const char* funcName) {
-        BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
-        if (!BufferImpl::ValidateBufferBindingPointTarget(bufferTarget)) return false;
-        return BufferImpl::ValidateBufferBindingPointRange(bufferTarget, first, count, funcName);
-    }
-
+    // points (with buffer 0 resetting the binding point).
     void BindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint* buffers) {
-        if (!ValidateMultiBindBufferRange(target, first, count, __func__)) return;
         for (GLsizei i = 0; i < count; ++i) {
             BindBufferBase_State(target, first + i, buffers ? buffers[i] : 0);
         }
     }
 
-    // The (offset, size) constraints are the one part of glBindBuffersRange that stays
-    // per-element: ARB_multi_bind checks them separately for each binding point, leaves that
-    // point unchanged on failure, and still applies the remaining elements - which is exactly
-    // what looping into BindBufferRange_State does. Only the [first, first + count) range is
-    // an up-front, all-or-nothing check. Elements that name buffer 0 (or a NULL buffers array)
-    // reset the binding point through BindBufferBase_State and carry no offset/size to check.
     void BindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets,
                           const GLsizeiptr* sizes) {
-        if (!ValidateMultiBindBufferRange(target, first, count, __func__)) return;
         for (GLsizei i = 0; i < count; ++i) {
             if (!buffers || buffers[i] == 0) {
                 BindBufferBase_State(target, first + i, 0);

MobileGL/MG_Impl/GLImpl/Buffer/GL_Buffer.h

@@ -41,7 +41,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                            GLsizeiptr size);
     void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
     void GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void* data);
-    void GetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, void* data);
     void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
     void BindBuffer(GLenum target, GLuint buffer);
     void GenBuffers(GLsizei n, GLuint* buffers);

MobileGL/MG_Impl/GLImpl/Buffer/Validators.cpp

@@ -53,46 +53,18 @@ namespace MobileGL::MG_Impl::GLImpl::BufferImpl {
         return true;
     }
 
-    namespace {
-        // The GL-visible number of indexed binding points for `target`.
-        SizeT GetBufferBindingPointLimit(BufferTarget target) {
-            SizeT pointCount = MG_State::pGLContext->GetBufferBindingPointCount(target);
-            if (target == BufferTarget::ShaderStorage && MG_Backend::pActiveBackendObject) {
-                const Int backendCount =
-                    MG_Backend::pActiveBackendObject->GetDynamicParameters().MaxShaderStorageBufferBindings;
-                pointCount = std::min(pointCount, static_cast<SizeT>(std::max(backendCount, 0)));
-            }
-            if (target == BufferTarget::TransformFeedback) {
-                // GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS bounds the indexed capture
-                // binding points in GL 3.3 (no ARB_transform_feedback3).
-                pointCount = std::min<SizeT>(pointCount, 4);
-            }
-            return pointCount;
-        }
-    } // namespace
-
-    Bool ValidateBufferBindingPointRange(BufferTarget target, Uint first, GLsizei count, const char* funcName) {
-        if (count < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl", funcName,
-                                                                      "count must be non-negative."));
-            return false;
-        }
-        const SizeT pointCount = GetBufferBindingPointLimit(target);
-        if (static_cast<Uint64>(first) + static_cast<Uint64>(count) > static_cast<Uint64>(pointCount)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl/BufferImpl", funcName,
-                    std::format("first + count ({} + {}) exceeds the {} indexed binding points of target {}.", first,
-                                count, pointCount, MG_Util::ConvertBufferTargetToString(target))));
-            return false;
-        }
-        return true;
-    }
-
     Bool ValidateBufferBindingPointIndex(BufferTarget target, Uint index) {
-        const SizeT pointCount = GetBufferBindingPointLimit(target);
+        SizeT pointCount = MG_State::pGLContext->GetBufferBindingPointCount(target);
+        if (target == BufferTarget::ShaderStorage && MG_Backend::pActiveBackendObject) {
+            const Int backendCount =
+                MG_Backend::pActiveBackendObject->GetDynamicParameters().MaxShaderStorageBufferBindings;
+            pointCount = std::min(pointCount, static_cast<SizeT>(std::max(backendCount, 0)));
+        }
+        if (target == BufferTarget::TransformFeedback) {
+            // GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS bounds the indexed capture
+            // binding points in GL 3.3 (no ARB_transform_feedback3).
+            pointCount = std::min<SizeT>(pointCount, 4);
+        }
 
         if (index < pointCount) {
             return true;
@@ -140,10 +112,14 @@ namespace MobileGL::MG_Impl::GLImpl::BufferImpl {
     }
 
     Bool ValidateBufferMappingAccess(Flags<BufferMappingAccessBit> accessBits) {
-        // An empty mask is a legal value for a bitfield - it just fails the rule that a mapping
-        // must ask for read or write access, which is INVALID_OPERATION and belongs to the callers
-        // (both of them check it immediately after this). Rejecting it here as INVALID_ENUM
-        // reported the wrong error and hid theirs.
+        if (accessBits == BufferMappingAccessBit::Null) {
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/BufferImpl",
+                                                                           "ValidateBufferMappingAccess",
+                                                                           "Access bits cannot be null."));
+            return false;
+        }
+
         const auto validBits = BufferMappingAccessBit::Read | BufferMappingAccessBit::Write |
                                BufferMappingAccessBit::InvalidateRange | BufferMappingAccessBit::InvalidateBuffer |
                                BufferMappingAccessBit::FlushExplicit | BufferMappingAccessBit::Unsynchronized |

MobileGL/MG_Impl/GLImpl/Buffer/Validators.h

@@ -17,8 +17,4 @@ namespace MobileGL::MG_Impl::GLImpl::BufferImpl {
     Bool ValidateBufferMappingAccess(Flags<BufferMappingAccessBit> accessBits);
     Bool ValidateBufferBindingPointTarget(BufferTarget target);
     Bool ValidateBufferBindingPointIndex(BufferTarget target, Uint index);
-    // ARB_multi_bind: glBindBuffersBase/Range validate the whole [first, first + count) range
-    // up front and report INVALID_OPERATION, where a single out-of-range index would be
-    // INVALID_VALUE. Naively looping the single-bind entry points reports the wrong class.
-    Bool ValidateBufferBindingPointRange(BufferTarget target, Uint first, GLsizei count, const char* funcName);
 } // namespace MobileGL::MG_Impl::GLImpl::BufferImpl

MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.cpp

@@ -15,7 +15,7 @@
 
 namespace MobileGL::MG_Impl::GLImpl {
     static Bool ValidateCurrentProgramForExecution(const char* functionName) {
-        const auto& currentProgram = MG_State::pGLContext->GetProgramForDraw();
+        const auto& currentProgram = MG_State::pGLContext->GetCurrentProgram();
         if (!currentProgram) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
@@ -37,7 +37,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     static Bool ValidateCurrentProgramForCompute(const char* functionName) {
         if (!ValidateCurrentProgramForExecution(functionName)) return false;
 
-        const auto& currentProgram = MG_State::pGLContext->GetProgramForDraw();
+        const auto& currentProgram = MG_State::pGLContext->GetCurrentProgram();
         if (currentProgram->GetShaderIndexByStage(ShaderStage::Compute) < 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
@@ -173,7 +173,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         // input primitive (GL 4.6 core 11.3.1); anything else is INVALID_OPERATION. GL_PATCHES
         // is the tessellation pipeline's input and reaches the geometry stage already
         // converted, so it is not constrained here.
-        const auto& currentProgram = MG_State::pGLContext->GetProgramForDraw();
+        const auto& currentProgram = MG_State::pGLContext->GetCurrentProgram();
         const GLenum gsInput = currentProgram ? currentProgram->GetGeometryInputType() : GL_NONE;
         if (gsInput != GL_NONE && mode != GL_PATCHES) {
             Bool compatible = false;
@@ -474,21 +474,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
         if (!ValidateCurrentProgramForCompute(__func__)) return;
-        // GL 4.6 core 19: each num_groups_* must be within GL_MAX_COMPUTE_WORK_GROUP_COUNT
-        // for its dimension. GetIntegeri_v already floors that at the spec minimum.
-        const GLuint numGroups[3] = {numGroupsX, numGroupsY, numGroupsZ};
-        for (GLuint dimension = 0; dimension < 3; ++dimension) {
-            GLint maxGroups = 0;
-            GetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, dimension, &maxGroups);
-            if (numGroups[dimension] > static_cast<GLuint>(std::max(maxGroups, 0))) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                                 "num_groups exceeds GL_MAX_COMPUTE_WORK_GROUP_COUNT for dimension " +
-                                                     std::to_string(dimension) + "."));
-                return;
-            }
-        }
         dispatchCompute(numGroupsX, numGroupsY, numGroupsZ);
     }
 
@@ -502,24 +487,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
         if (!ValidateCurrentProgramForCompute(__func__)) return;
-        // GL 4.6 core 19: `indirect` is a byte offset into GL_DISPATCH_INDIRECT_BUFFER -
-        // negative or misaligned is INVALID_VALUE, nothing bound is INVALID_OPERATION.
-        if (indirect < 0 || (indirect % 4) != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "indirect must be non-negative and a multiple of 4."));
-            return;
-        }
-        const auto& indirectBuffer =
-            MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DispatchIndirect).GetBoundObject();
-        if (!indirectBuffer) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "No buffer is bound to GL_DISPATCH_INDIRECT_BUFFER."));
-            return;
-        }
         dispatchComputeIndirect(indirect);
     }
 
@@ -740,7 +707,7 @@ namespace MobileGL::MG_Impl::GLImpl {
                 MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "Transform feedback is already active."));
             return;
         }
-        const auto& program = MG_State::pGLContext->GetProgramForDraw();
+        const auto& program = MG_State::pGLContext->GetCurrentProgram();
         if (!program || !program->GetLinkStatus() || program->GetTransformFeedbackVaryingCount() == 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,

MobileGL/MG_Impl/GLImpl/Exporting/Definitions.cpp

@@ -15,7 +15,6 @@
 #include "../Texture/GL_Texture.h"
 #include "../Drawing/GL_Drawing.h"
 #include "../Program/GL_Program.h"
-#include "../Program/GL_ProgramPipeline.h"
 #include "../RenderState/GL_RenderState.h"
 #include "../Framebuffer/GL_Framebuffer.h"
 #include "../VertexArray/GL_VertexArray.h"
@@ -302,8 +301,8 @@ DECLARE_GL_FUNCTION_HEAD(void, ResumeTransformFeedback) DECLARE_GL_FUNCTION_END_
 DECLARE_GL_FUNCTION_HEAD(void, GetProgramBinary, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramBinary, program, bufSize, length, binaryFormat, binary)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramBinary, GLuint program, GLenum binaryFormat, const void* binary, GLsizei length) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramBinary, program, binaryFormat, binary, length)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramParameteri, GLuint program, GLenum pname, GLint value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramParameteri, program, pname, value)
-DECLARE_GL_FUNCTION_HEAD(void, InvalidateFramebuffer, GLenum target, GLsizei numAttachments, const GLenum* attachments) DECLARE_GL_FUNCTION_END_NO_RETURN(void, InvalidateFramebuffer, target, numAttachments, attachments)
-DECLARE_GL_FUNCTION_HEAD(void, InvalidateSubFramebuffer, GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, InvalidateSubFramebuffer, target, numAttachments, attachments, x, y, width, height)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateFramebuffer, GLenum target, GLsizei numAttachments, const GLenum* attachments) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InvalidateFramebuffer, target, numAttachments, attachments)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateSubFramebuffer, GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InvalidateSubFramebuffer, target, numAttachments, attachments, x, y, width, height)
 DECLARE_GL_FUNCTION_HEAD(void, TexStorage2D, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TexStorage2D, target, levels, internalformat, width, height)
 DECLARE_GL_FUNCTION_HEAD(void, TexStorage3D, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TexStorage3D, target, levels, internalformat, width, height, depth)
 DECLARE_GL_FUNCTION_HEAD(void, GetInternalformativ, GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetInternalformativ, target, internalformat, pname, bufSize, params)
@@ -311,21 +310,21 @@ DECLARE_GL_FUNCTION_HEAD(void, DispatchCompute, GLuint num_groups_x, GLuint num_
 DECLARE_GL_FUNCTION_HEAD(void, DispatchComputeIndirect, GLintptr indirect) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DispatchComputeIndirect, indirect)
 DECLARE_GL_FUNCTION_HEAD(void, DrawArraysIndirect, GLenum mode, const void* indirect) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawArraysIndirect, mode, indirect)
 DECLARE_GL_FUNCTION_HEAD(void, DrawElementsIndirect, GLenum mode, GLenum type, const void* indirect) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawElementsIndirect, mode, type, indirect)
-DECLARE_GL_FUNCTION_HEAD(void, FramebufferParameteri, GLenum target, GLenum pname, GLint param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, FramebufferParameteri, target, pname, param)
-DECLARE_GL_FUNCTION_HEAD(void, GetFramebufferParameteriv, GLenum target, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetFramebufferParameteriv, target, pname, params)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, FramebufferParameteri, GLenum target, GLenum pname, GLint param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FramebufferParameteri, target, pname, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetFramebufferParameteriv, GLenum target, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetFramebufferParameteriv, target, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetProgramInterfaceiv, GLuint program, GLenum programInterface, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramInterfaceiv, program, programInterface, pname, params)
 DECLARE_GL_FUNCTION_HEAD(GLuint, GetProgramResourceIndex, GLuint program, GLenum programInterface, const GLchar* name) DECLARE_GL_FUNCTION_END(GLuint, GetProgramResourceIndex, program, programInterface, name)
 DECLARE_GL_FUNCTION_HEAD(void, GetProgramResourceName, GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramResourceName, program, programInterface, index, bufSize, length, name)
 DECLARE_GL_FUNCTION_HEAD(void, GetProgramResourceiv, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramResourceiv, program, programInterface, index, propCount, props, bufSize, length, params)
 DECLARE_GL_FUNCTION_HEAD(GLint, GetProgramResourceLocation, GLuint program, GLenum programInterface, const GLchar* name) DECLARE_GL_FUNCTION_END(GLint, GetProgramResourceLocation, program, programInterface, name)
-DECLARE_GL_FUNCTION_HEAD(void, UseProgramStages, GLuint pipeline, GLbitfield stages, GLuint program) DECLARE_GL_FUNCTION_END_NO_RETURN(void, UseProgramStages, pipeline, stages, program)
-DECLARE_GL_FUNCTION_HEAD(void, ActiveShaderProgram, GLuint pipeline, GLuint program) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ActiveShaderProgram, pipeline, program)
-DECLARE_GL_FUNCTION_HEAD(GLuint, CreateShaderProgramv, GLenum type, GLsizei count, const GLchar* const* strings) DECLARE_GL_FUNCTION_END(GLuint, CreateShaderProgramv, type, count, strings)
-DECLARE_GL_FUNCTION_HEAD(void, BindProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindProgramPipeline, pipeline)
-DECLARE_GL_FUNCTION_HEAD(void, DeleteProgramPipelines, GLsizei n, const GLuint* pipelines) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DeleteProgramPipelines, n, pipelines)
-DECLARE_GL_FUNCTION_HEAD(void, GenProgramPipelines, GLsizei n, GLuint* pipelines) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GenProgramPipelines, n, pipelines)
-DECLARE_GL_FUNCTION_HEAD(GLboolean, IsProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_END(GLboolean, IsProgramPipeline, pipeline)
-DECLARE_GL_FUNCTION_HEAD(void, GetProgramPipelineiv, GLuint pipeline, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramPipelineiv, pipeline, pname, params)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, UseProgramStages, GLuint pipeline, GLbitfield stages, GLuint program) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UseProgramStages, pipeline, stages, program)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ActiveShaderProgram, GLuint pipeline, GLuint program) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ActiveShaderProgram, pipeline, program)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, CreateShaderProgramv, GLenum type, GLsizei count, const GLchar* const* strings) DECLARE_GL_FUNCTION_STUB_END(GLuint, CreateShaderProgramv, type, count, strings)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, BindProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindProgramPipeline, pipeline)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteProgramPipelines, GLsizei n, const GLuint* pipelines) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteProgramPipelines, n, pipelines)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GenProgramPipelines, GLsizei n, GLuint* pipelines) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenProgramPipelines, n, pipelines)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsProgramPipeline, pipeline)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetProgramPipelineiv, GLuint pipeline, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetProgramPipelineiv, pipeline, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform1i, GLuint program, GLint location, GLint v0) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform1i, program, location, v0)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform2i, GLuint program, GLint location, GLint v0, GLint v1) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform2i, program, location, v0, v1)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform3i, GLuint program, GLint location, GLint v0, GLint v1, GLint v2) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform3i, program, location, v0, v1, v2)
@@ -359,8 +358,8 @@ DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix2x4fv, GLuint program, GLint
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix4x2fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix4x2fv, program, location, count, transpose, value)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix3x4fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix3x4fv, program, location, count, transpose, value)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix4x3fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix4x3fv, program, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, ValidateProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ValidateProgramPipeline, pipeline)
-DECLARE_GL_FUNCTION_HEAD(void, GetProgramPipelineInfoLog, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramPipelineInfoLog, pipeline, bufSize, length, infoLog)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ValidateProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ValidateProgramPipeline, pipeline)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetProgramPipelineInfoLog, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetProgramPipelineInfoLog, pipeline, bufSize, length, infoLog)
 DECLARE_GL_FUNCTION_HEAD(void, BindImageTexture, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindImageTexture, unit, texture, level, layered, layer, access, format)
 DECLARE_GL_FUNCTION_HEAD(void, GetBooleani_v, GLenum target, GLuint index, GLboolean* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetBooleani_v, target, index, data)
 DECLARE_GL_FUNCTION_HEAD(void, MemoryBarrier, GLbitfield barriers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MemoryBarrier, barriers)
@@ -977,8 +976,8 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ScissorIndexed, GLuint index, GLint left, GL
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ScissorIndexedv, GLuint index, const GLint* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ScissorIndexedv, index, v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DepthRangeArrayv, GLuint first, GLsizei count, const GLdouble* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DepthRangeArrayv, first, count, v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DepthRangeIndexed, GLuint index, GLdouble n, GLdouble f) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DepthRangeIndexed, index, n, f)
-DECLARE_GL_FUNCTION_HEAD(void, GetFloati_v, GLenum target, GLuint index, GLfloat* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetFloati_v, target, index, data)
-DECLARE_GL_FUNCTION_HEAD(void, GetDoublei_v, GLenum target, GLuint index, GLdouble* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetDoublei_v, target, index, data)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetFloati_v, GLenum target, GLuint index, GLfloat* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetFloati_v, target, index, data)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetDoublei_v, GLenum target, GLuint index, GLdouble* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetDoublei_v, target, index, data)
 DECLARE_GL_FUNCTION_HEAD(void, DrawArraysInstancedBaseInstance, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawArraysInstancedBaseInstance, mode, first, count, instancecount, baseinstance)
 DECLARE_GL_FUNCTION_HEAD(void, DrawElementsInstancedBaseInstance, GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLuint baseinstance) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawElementsInstancedBaseInstance, mode, count, type, indices, instancecount, baseinstance)
 DECLARE_GL_FUNCTION_HEAD(void, DrawElementsInstancedBaseVertexBaseInstance, GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawElementsInstancedBaseVertexBaseInstance, mode, count, type, indices, instancecount, basevertex, baseinstance)
@@ -1026,24 +1025,24 @@ DECLARE_GL_FUNCTION_HEAD(void, FlushMappedNamedBufferRange, GLuint buffer, GLint
 DECLARE_GL_FUNCTION_HEAD(void, GetNamedBufferParameteriv, GLuint buffer, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedBufferParameteriv, buffer, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetNamedBufferParameteri64v, GLuint buffer, GLenum pname, GLint64* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedBufferParameteri64v, buffer, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetNamedBufferPointerv, GLuint buffer, GLenum pname, void** params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedBufferPointerv, buffer, pname, params)
-DECLARE_GL_FUNCTION_HEAD(void, GetNamedBufferSubData, GLuint buffer, GLintptr offset, GLsizeiptr size, void* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedBufferSubData, buffer, offset, size, data)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedBufferSubData, GLuint buffer, GLintptr offset, GLsizeiptr size, void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedBufferSubData, buffer, offset, size, data)
 DECLARE_GL_FUNCTION_HEAD(void, CreateFramebuffers, GLsizei n, GLuint* framebuffers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateFramebuffers, n, framebuffers)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferRenderbuffer, GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferRenderbuffer, framebuffer, attachment, renderbuffertarget, renderbuffer)
-DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferParameteri, GLuint framebuffer, GLenum pname, GLint param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferParameteri, framebuffer, pname, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedFramebufferParameteri, GLuint framebuffer, GLenum pname, GLint param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, NamedFramebufferParameteri, framebuffer, pname, param)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferTexture, GLuint framebuffer, GLenum attachment, GLuint texture, GLint level) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferTexture, framebuffer, attachment, texture, level)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferTextureLayer, GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferTextureLayer, framebuffer, attachment, texture, level, layer)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferDrawBuffer, GLuint framebuffer, GLenum buf) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferDrawBuffer, framebuffer, buf)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferDrawBuffers, GLuint framebuffer, GLsizei n, const GLenum* bufs) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferDrawBuffers, framebuffer, n, bufs)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferReadBuffer, GLuint framebuffer, GLenum src) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferReadBuffer, framebuffer, src)
-DECLARE_GL_FUNCTION_HEAD(void, InvalidateNamedFramebufferData, GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments) DECLARE_GL_FUNCTION_END_NO_RETURN(void, InvalidateNamedFramebufferData, framebuffer, numAttachments, attachments)
-DECLARE_GL_FUNCTION_HEAD(void, InvalidateNamedFramebufferSubData, GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, InvalidateNamedFramebufferSubData, framebuffer, numAttachments, attachments, x, y, width, height)
-DECLARE_GL_FUNCTION_HEAD(void, ClearNamedFramebufferiv, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearNamedFramebufferiv, framebuffer, buffer, drawbuffer, value)
-DECLARE_GL_FUNCTION_HEAD(void, ClearNamedFramebufferuiv, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearNamedFramebufferuiv, framebuffer, buffer, drawbuffer, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateNamedFramebufferData, GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InvalidateNamedFramebufferData, framebuffer, numAttachments, attachments)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateNamedFramebufferSubData, GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InvalidateNamedFramebufferSubData, framebuffer, numAttachments, attachments, x, y, width, height)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearNamedFramebufferiv, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearNamedFramebufferiv, framebuffer, buffer, drawbuffer, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearNamedFramebufferuiv, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearNamedFramebufferuiv, framebuffer, buffer, drawbuffer, value)
 DECLARE_GL_FUNCTION_HEAD(void, ClearNamedFramebufferfv, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearNamedFramebufferfv, framebuffer, buffer, drawbuffer, value)
 DECLARE_GL_FUNCTION_HEAD(void, ClearNamedFramebufferfi, GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearNamedFramebufferfi, framebuffer, buffer, drawbuffer, depth, stencil)
 DECLARE_GL_FUNCTION_HEAD(void, BlitNamedFramebuffer, GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BlitNamedFramebuffer, readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)
 DECLARE_GL_FUNCTION_HEAD(GLenum, CheckNamedFramebufferStatus, GLuint framebuffer, GLenum target) DECLARE_GL_FUNCTION_END(GLenum, CheckNamedFramebufferStatus, framebuffer, target)
-DECLARE_GL_FUNCTION_HEAD(void, GetNamedFramebufferParameteriv, GLuint framebuffer, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedFramebufferParameteriv, framebuffer, pname, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedFramebufferParameteriv, GLuint framebuffer, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedFramebufferParameteriv, framebuffer, pname, param)
 DECLARE_GL_FUNCTION_HEAD(void, GetNamedFramebufferAttachmentParameteriv, GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedFramebufferAttachmentParameteriv, framebuffer, attachment, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, CreateRenderbuffers, GLsizei n, GLuint* renderbuffers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateRenderbuffers, n, renderbuffers)
 DECLARE_GL_FUNCTION_HEAD(void, NamedRenderbufferStorage, GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedRenderbufferStorage, renderbuffer, internalformat, width, height)
@@ -1063,9 +1062,9 @@ DECLARE_GL_FUNCTION_HEAD(void, TextureSubImage3D, GLuint texture, GLint level, G
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureSubImage1D, GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureSubImage1D, texture, level, xoffset, width, format, imageSize, data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureSubImage2D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureSubImage2D, texture, level, xoffset, yoffset, width, height, format, imageSize, data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureSubImage3D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureSubImage3D, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)
-DECLARE_GL_FUNCTION_HEAD(void, CopyTextureSubImage1D, GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CopyTextureSubImage1D, texture, level, xoffset, x, y, width)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, CopyTextureSubImage1D, GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CopyTextureSubImage1D, texture, level, xoffset, x, y, width)
 DECLARE_GL_FUNCTION_HEAD(void, CopyTextureSubImage2D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CopyTextureSubImage2D, texture, level, xoffset, yoffset, x, y, width, height)
-DECLARE_GL_FUNCTION_HEAD(void, CopyTextureSubImage3D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CopyTextureSubImage3D, texture, level, xoffset, yoffset, zoffset, x, y, width, height)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, CopyTextureSubImage3D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CopyTextureSubImage3D, texture, level, xoffset, yoffset, zoffset, x, y, width, height)
 DECLARE_GL_FUNCTION_HEAD(void, TextureParameterf, GLuint texture, GLenum pname, GLfloat param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureParameterf, texture, pname, param)
 DECLARE_GL_FUNCTION_HEAD(void, TextureParameterfv, GLuint texture, GLenum pname, const GLfloat* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureParameterfv, texture, pname, param)
 DECLARE_GL_FUNCTION_HEAD(void, TextureParameteri, GLuint texture, GLenum pname, GLint param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureParameteri, texture, pname, param)
@@ -1075,7 +1074,7 @@ DECLARE_GL_FUNCTION_HEAD(void, TextureParameteriv, GLuint texture, GLenum pname,
 DECLARE_GL_FUNCTION_HEAD(void, GenerateTextureMipmap, GLuint texture) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GenerateTextureMipmap, texture)
 DECLARE_GL_FUNCTION_HEAD(void, BindTextureUnit, GLuint unit, GLuint texture) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindTextureUnit, unit, texture)
 DECLARE_GL_FUNCTION_HEAD(void, GetTextureImage, GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTextureImage, texture, level, format, type, bufSize, pixels)
-DECLARE_GL_FUNCTION_HEAD(void, GetCompressedTextureImage, GLuint texture, GLint level, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetCompressedTextureImage, texture, level, bufSize, pixels)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetCompressedTextureImage, GLuint texture, GLint level, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetCompressedTextureImage, texture, level, bufSize, pixels)
 DECLARE_GL_FUNCTION_HEAD(void, GetTextureLevelParameterfv, GLuint texture, GLint level, GLenum pname, GLfloat* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTextureLevelParameterfv, texture, level, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetTextureLevelParameteriv, GLuint texture, GLint level, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTextureLevelParameteriv, texture, level, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetTextureParameterfv, GLuint texture, GLenum pname, GLfloat* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTextureParameterfv, texture, pname, params)
@@ -1097,12 +1096,12 @@ DECLARE_GL_FUNCTION_HEAD(void, GetVertexArrayiv, GLuint vaobj, GLenum pname, GLi
 DECLARE_GL_FUNCTION_HEAD(void, GetVertexArrayIndexediv, GLuint vaobj, GLuint index, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetVertexArrayIndexediv, vaobj, index, pname, param)
 DECLARE_GL_FUNCTION_HEAD(void, GetVertexArrayIndexed64iv, GLuint vaobj, GLuint index, GLenum pname, GLint64* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetVertexArrayIndexed64iv, vaobj, index, pname, param)
 DECLARE_GL_FUNCTION_HEAD(void, CreateSamplers, GLsizei n, GLuint* samplers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateSamplers, n, samplers)
-DECLARE_GL_FUNCTION_HEAD(void, CreateProgramPipelines, GLsizei n, GLuint* pipelines) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateProgramPipelines, n, pipelines)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, CreateProgramPipelines, GLsizei n, GLuint* pipelines) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CreateProgramPipelines, n, pipelines)
 DECLARE_GL_FUNCTION_HEAD(void, CreateQueries, GLenum target, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateQueries, target, n, ids)
-DECLARE_GL_FUNCTION_HEAD(void, GetQueryBufferObjecti64v, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetQueryBufferObjecti64v, id, buffer, pname, offset)
-DECLARE_GL_FUNCTION_HEAD(void, GetQueryBufferObjectiv, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetQueryBufferObjectiv, id, buffer, pname, offset)
-DECLARE_GL_FUNCTION_HEAD(void, GetQueryBufferObjectui64v, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetQueryBufferObjectui64v, id, buffer, pname, offset)
-DECLARE_GL_FUNCTION_HEAD(void, GetQueryBufferObjectuiv, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetQueryBufferObjectuiv, id, buffer, pname, offset)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryBufferObjecti64v, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryBufferObjecti64v, id, buffer, pname, offset)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryBufferObjectiv, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryBufferObjectiv, id, buffer, pname, offset)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryBufferObjectui64v, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryBufferObjectui64v, id, buffer, pname, offset)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryBufferObjectuiv, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryBufferObjectuiv, id, buffer, pname, offset)
 DECLARE_GL_FUNCTION_HEAD(void, GetTextureSubImage, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTextureSubImage, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetCompressedTextureSubImage, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetCompressedTextureSubImage, texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnCompressedTexImage, GLenum target, GLint lod, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnCompressedTexImage, target, lod, bufSize, pixels)
@@ -1273,7 +1272,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord4ivARB, GLenum target, const GL
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord4sARB, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiTexCoord4sARB, target, s, t, r, q)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord4svARB, GLenum target, const GLshort* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiTexCoord4svARB, target, v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryObjectivARB, GLuint id, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryObjectivARB, id, pname, params)
-DECLARE_GL_FUNCTION_HEAD(void, MaxShaderCompilerThreadsARB, GLuint count) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MaxShaderCompilerThreadsARB, count)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, MaxShaderCompilerThreadsARB, GLuint count) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MaxShaderCompilerThreadsARB, count)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PointParameterfARB, GLenum pname, GLfloat param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PointParameterfARB, pname, param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PointParameterfvARB, GLenum pname, const GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PointParameterfvARB, pname, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnTexImageARB, GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* img) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnTexImageARB, target, level, format, type, bufSize, img)
@@ -1381,7 +1380,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, WindowPos3ivARB, const GLint* v) DECLARE_GL_
 DECLARE_GL_FUNCTION_STUB_HEAD(void, WindowPos3sARB, GLshort x, GLshort y, GLshort z) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, WindowPos3sARB, x, y, z)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, WindowPos3svARB, const GLshort* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, WindowPos3svARB, v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendBarrierKHR, void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendBarrierKHR, )
-DECLARE_GL_FUNCTION_HEAD(void, MaxShaderCompilerThreadsKHR, GLuint count) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MaxShaderCompilerThreadsKHR, count)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, MaxShaderCompilerThreadsKHR, GLuint count) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MaxShaderCompilerThreadsKHR, count)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord1bOES, GLenum texture, GLbyte s) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiTexCoord1bOES, texture, s)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord1bvOES, GLenum texture, const GLbyte* coords) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiTexCoord1bvOES, texture, coords)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord2bOES, GLenum texture, GLbyte s, GLbyte t) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiTexCoord2bOES, texture, s, t)

MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h

@@ -58,19 +58,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     void NamedFramebufferReadBuffer(GLuint framebuffer, GLenum src);
     void ClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat* value);
     void ClearNamedFramebufferfi(GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void InvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments);
-    void InvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments,
-                                           GLint x, GLint y, GLsizei width, GLsizei height);
-    void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments);
-    void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y,
-                                  GLsizei width, GLsizei height);
-    void ClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint* value);
-    void ClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint* value);
     GLenum CheckNamedFramebufferStatus(GLuint framebuffer, GLenum target);
-    void GetFramebufferParameteriv(GLenum target, GLenum pname, GLint* params);
-    void FramebufferParameteri(GLenum target, GLenum pname, GLint param);
-    void GetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint* params);
-    void NamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param);
     void GetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params);
     void BlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1,
                               GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,

MobileGL/MG_Impl/GLImpl/Framebuffer/Validators.cpp

@@ -118,100 +118,4 @@ namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl {
                                          std::format("Renderbuffer name {} is not valid.", index)));
         return false;
     }
-
-    Bool ValidateFramebufferParameterPname(GLenum pname, Bool isDefaultFramebuffer, Bool forSetter,
-                                           const char* caller) {
-        Bool isDefaultParameter = false;
-        switch (pname) {
-        case GL_FRAMEBUFFER_DEFAULT_WIDTH:
-        case GL_FRAMEBUFFER_DEFAULT_HEIGHT:
-        case GL_FRAMEBUFFER_DEFAULT_LAYERS:
-        case GL_FRAMEBUFFER_DEFAULT_SAMPLES:
-        case GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS:
-            isDefaultParameter = true;
-            break;
-        case GL_DOUBLEBUFFER:
-        case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
-        case GL_IMPLEMENTATION_COLOR_READ_TYPE:
-        case GL_SAMPLES:
-        case GL_SAMPLE_BUFFERS:
-        case GL_STEREO:
-            // Queryable only; glFramebufferParameteri sets none of these.
-            if (forSetter) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl/FramebufferImpl", caller,
-                        std::format("pname {} is not settable on a framebuffer.",
-                                    MG_Util::ConvertGLEnumToString(pname))));
-                return false;
-            }
-            break;
-        default:
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl/FramebufferImpl", caller,
-                    std::format("pname {} is not a framebuffer parameter.",
-                                MG_Util::ConvertGLEnumToString(pname))));
-            return false;
-        }
-
-        // The default framebuffer has no DEFAULT_* state of its own - its shape comes from the
-        // surface - so those names are accepted enums it simply cannot answer or accept.
-        if (isDefaultFramebuffer && isDefaultParameter) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl/FramebufferImpl", caller,
-                    std::format("pname {} does not apply to the default framebuffer.",
-                                MG_Util::ConvertGLEnumToString(pname))));
-            return false;
-        }
-        return true;
-    }
-
-    Bool ValidateReadFramebufferForCopy(const char* caller) {
-        auto& framebufferObject =
-            MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Read).GetBoundObject();
-        if (!framebufferObject || !framebufferObject->CheckCompleteness()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidFramebufferOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", caller,
-                                             "Read framebuffer is not framebuffer complete."));
-            return false;
-        }
-
-        const FramebufferAttachmentType readBuffer = framebufferObject->GetReadBuffer();
-        if (readBuffer == FramebufferAttachmentType::None ||
-            !framebufferObject->GetAttachment(readBuffer).IsValid()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", caller,
-                                             "Read buffer names no attachment of the read framebuffer."));
-            return false;
-        }
-
-        // SAMPLE_BUFFERS is one whenever the read buffer resolves to multisample storage. A
-        // multisample texture says so by its target - its sample count can legally be one - while a
-        // renderbuffer says so by having been given a non-zero sample count.
-        const auto& readAttachment = framebufferObject->GetAttachment(readBuffer);
-        Bool isMultisampled = false;
-        if (readAttachment.IsRenderbuffer() && readAttachment.GetRenderbuffer()) {
-            isMultisampled = readAttachment.GetRenderbuffer()->GetSamples() > 0;
-        } else if (readAttachment.IsTexture() && readAttachment.GetTexture()) {
-            const auto target = readAttachment.GetTexture()->GetTarget();
-            isMultisampled = target == TextureTarget::Texture2DMultisample ||
-                             target == TextureTarget::Texture2DMultisampleArray;
-        }
-        if (isMultisampled) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", caller,
-                                             "Cannot copy from a multisampled read framebuffer."));
-            return false;
-        }
-
-        return true;
-    }
 } // namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl

MobileGL/MG_Impl/GLImpl/Framebuffer/Validators.h

@@ -20,15 +20,4 @@ namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl {
     Bool ValidateColorAttachmentInRange(FramebufferAttachmentType attachment, const char* caller);
     Bool ValidateRenderbufferTarget(RenderbufferTarget target);
     Bool ValidateRenderbufferName(Uint index, Bool allowZero = true);
-    // The read-framebuffer preconditions the CopyTexSubImage family shares (GL 4.6 core 8.6): the
-    // read framebuffer must be complete, its read buffer must name a real attachment, and it must
-    // not be multisampled. Incompleteness is INVALID_FRAMEBUFFER_OPERATION, the other two are
-    // INVALID_OPERATION.
-    Bool ValidateReadFramebufferForCopy(const char* caller);
-    // The pname sets of glGet/FramebufferParameteri (GL 4.6 core 9.2.3). Order matters and is part
-    // of the contract: a name outside the table is INVALID_ENUM, and only then is a name that the
-    // DEFAULT framebuffer does not answer INVALID_OPERATION. Testing the framebuffer kind first
-    // would turn GL_FRAMEBUFFER_DEFAULT_WIDTH on framebuffer zero into the wrong error.
-    Bool ValidateFramebufferParameterPname(GLenum pname, Bool isDefaultFramebuffer, Bool forSetter,
-                                           const char* caller);
 } // namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.cpp

@@ -23,7 +23,6 @@
 #include <MG_Util/Converters/MGToGL/RenderStateEnumConverter.h>
 #include <MG_State/GLState/FramebufferState/FramebufferObject.h>
 #include <MG_Util/Texture/TextureFormatProcessor.h>
-#include <MG_Util/Async/ShaderCompilePool.h>
 #include <MG_Backend/BackendObjects.h>
 
 namespace MobileGL::MG_Impl::GLImpl {
@@ -51,14 +50,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         constexpr GLint kFrontendMaxTessControlAtomicCounters = 0;
         constexpr GLint kFrontendMaxTessEvaluationAtomicCounters = 0;
         constexpr GLint kFrontendMaxVertexAtomicCounters = 0;
-        // One atomic counter is a uint, and a buffer never has to hold more counters than the
-        // combined limit the frontend advertises. GL 4.6 table 23.63 floors this at 32 bytes.
-        constexpr GLint kFrontendMaxAtomicCounterBufferSize =
-            kFrontendMaxCombinedAtomicCounters * static_cast<GLint>(sizeof(GLuint));
-        // KHR_debug minima (GL 4.6 table 23.66); the debug entry points are stubs, but the
-        // limits they advertise still have to be legal.
-        constexpr GLint kFrontendMaxDebugGroupStackDepth = 64;
-        constexpr GLint kFrontendMaxDebugLoggedMessages = 1;
         constexpr GLint kFrontendMaxVertexUniformComponents = 4096;
         constexpr GLint kFrontendMaxVertexUniformVectors = 128;
         constexpr GLint kFrontendMaxVertexUniformBlocks = 14;
@@ -272,60 +263,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return true;
         }
 
-        // GL_TEXTURE_BINDING_* is per-texture-unit state: glGetIntegerv answers for the
-        // active unit, glGetIntegeri_v answers for unit `index`. Both need the same
-        // pname -> target decode, so it lives here instead of being spelled out twice.
-        bool TryDecodeTextureUnitBindingPname(GLenum pname, TextureTarget& outTarget) {
-            switch (pname) {
-            case GL_TEXTURE_BINDING_1D: outTarget = TextureTarget::Texture1D; return true;
-            case GL_TEXTURE_BINDING_1D_ARRAY: outTarget = TextureTarget::Texture1DArray; return true;
-            case GL_TEXTURE_BINDING_2D: outTarget = TextureTarget::Texture2D; return true;
-            case GL_TEXTURE_BINDING_2D_ARRAY: outTarget = TextureTarget::Texture2DArray; return true;
-            case GL_TEXTURE_BINDING_2D_MULTISAMPLE: outTarget = TextureTarget::Texture2DMultisample; return true;
-            case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
-                outTarget = TextureTarget::Texture2DMultisampleArray;
-                return true;
-            case GL_TEXTURE_BINDING_3D: outTarget = TextureTarget::Texture3D; return true;
-            case GL_TEXTURE_BINDING_BUFFER: outTarget = TextureTarget::TextureBuffer; return true;
-            case GL_TEXTURE_BINDING_CUBE_MAP: outTarget = TextureTarget::TextureCubeMap; return true;
-            case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY: outTarget = TextureTarget::TextureCubeMapArray; return true;
-            case GL_TEXTURE_BINDING_RECTANGLE: outTarget = TextureTarget::TextureRectangle; return true;
-            default: return false;
-            }
-        }
-
-        GLint QueryTextureBindingOnUnit(Int unit, TextureTarget target) {
-            auto& textureUnit = MG_State::pGLContext->GetTextureUnitObject(unit);
-            const auto& obj = textureUnit.GetBindingSlot(target).GetBoundObject();
-            return obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
-        }
-
-        GLint QuerySamplerBindingOnUnit(Int unit) {
-            const auto& textureUnit = MG_State::pGLContext->GetTextureUnitObject(unit);
-            const auto& sampler = textureUnit.GetSamplerObject();
-            return sampler ? static_cast<GLint>(sampler->GetExternalIndex()) : 0;
-        }
-
-        // The ARB_viewport_array indexed rectangles. MobileGL keeps exactly one viewport, one
-        // scissor box and one depth range, so every in-range index answers with that single
-        // value - but it has to come from the frontend state the non-indexed getters read.
-        // The generic path at the bottom of GetIntegeri_v is a raw backend passthrough that
-        // has no case for these, so routing them through it returned zeros.
-        Bool IsIndexedViewportQuery(GLenum target) {
-            return target == GL_VIEWPORT || target == GL_SCISSOR_BOX || target == GL_DEPTH_RANGE;
-        }
-
-        // ARB_viewport_array: `index` selects a viewport and MAX_VIEWPORTS bounds it.
-        Bool ValidateViewportQueryIndex(GLuint index, const char* caller) {
-            GLint maxViewports = 0;
-            GetIntegerv(GL_MAX_VIEWPORTS, &maxViewports);
-            if (index < static_cast<GLuint>(std::max(maxViewports, 1))) return true;
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", caller, "Viewport index is out of range."));
-            return false;
-        }
-
         void CopyIntsToBooleans(const GLint* src, SizeT count, GLboolean* dst) {
             for (SizeT i = 0; i < count; ++i) {
                 dst[i] = src[i] ? GL_TRUE : GL_FALSE;
@@ -733,37 +670,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
         }
 
-        // Per-texture-unit bindings: GL 4.6 core table 23.19 makes every GL_TEXTURE_BINDING_*
-        // and GL_SAMPLER_BINDING indexed by texture unit. Without this they fell through to
-        // the raw backend passthrough at the bottom, which knows nothing about the
-        // frontend's binding state.
-        if (TextureTarget textureBindingTarget = TextureTarget::Unknown;
-            TryDecodeTextureUnitBindingPname(target, textureBindingTarget) || target == GL_SAMPLER_BINDING) {
-            GLint maxUnits = 0;
-            GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxUnits);
-            maxUnits = std::min<GLint>(maxUnits, MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS);
-            if (index >= static_cast<GLuint>(std::max(maxUnits, 0))) {
-                *data = 0;
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "Texture unit index is out of range."));
-                return;
-            }
-            *data = target == GL_SAMPLER_BINDING
-                ? QuerySamplerBindingOnUnit(static_cast<Int>(index))
-                : QueryTextureBindingOnUnit(static_cast<Int>(index), textureBindingTarget);
-            return;
-        }
-
         switch (target) {
-        // ARB_viewport_array queries the indexed rectangles through glGetIntegeri_v as well
-        // (gl4cMultiBindTests and the viewport_array group both do). The frontend keeps one
-        // viewport and one scissor box, so every in-range index reports that one.
-        case GL_VIEWPORT:
-        case GL_SCISSOR_BOX:
-            if (!ValidateViewportQueryIndex(index, __func__)) return;
-            GetIntegerv(target, data);
-            return;
         // The vertex buffer binding points of the vertex array object that is bound. Indexed by
         // binding point, not by attribute (GL 4.6 core 10.3.1).
         case GL_VERTEX_BINDING_BUFFER:
@@ -875,46 +782,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         getIntegeri(target, index, data);
     }
 
-    // GL_ARB_viewport_array's typed indexed getters. They were no-op stubs, which left the
-    // caller's output buffer holding whatever was on the stack. The multi-component indexed
-    // rectangles are answered from the frontend's own viewport/scissor/depth-range state, via
-    // the non-indexed getter of the matching type - GL_DEPTH_RANGE is float state, so putting
-    // it through the integer query would round it to 0/1. Everything else MobileGL answers
-    // indexed is scalar integer-domain state, where converting the integer query is exact.
-    void GetFloati_v(GLenum target, GLuint index, GLfloat* data) {
-        if (!data) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "data pointer cannot be null"));
-            return;
-        }
-        if (IsIndexedViewportQuery(target)) {
-            if (!ValidateViewportQueryIndex(index, __func__)) return;
-            GetFloatv(target, data);
-            return;
-        }
-        GLint ints[4] = {};
-        GetIntegeri_v(target, index, ints);
-        data[0] = static_cast<GLfloat>(ints[0]);
-    }
-
-    void GetDoublei_v(GLenum target, GLuint index, GLdouble* data) {
-        if (!data) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "data pointer cannot be null"));
-            return;
-        }
-        if (IsIndexedViewportQuery(target)) {
-            if (!ValidateViewportQueryIndex(index, __func__)) return;
-            GetDoublev(target, data);
-            return;
-        }
-        GLint ints[4] = {};
-        GetIntegeri_v(target, index, ints);
-        data[0] = static_cast<GLdouble>(ints[0]);
-    }
-
     void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) {
         if (!data) {
             MG_State::pGLContext->RecordError(
@@ -1091,13 +958,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
-        // Per-texture-unit bindings: the non-indexed query reports the active unit.
-        if (TextureTarget textureBindingTarget = TextureTarget::Unknown;
-            TryDecodeTextureUnitBindingPname(pname, textureBindingTarget)) {
-            *params = QueryTextureBindingOnUnit(MG_State::pGLContext->GetActiveTextureUnit(), textureBindingTarget);
-            return;
-        }
-
         switch (pname) {
         case GL_ACTIVE_TEXTURE:
             *params = MG_State::pGLContext->GetActiveTextureUnit() + GL_TEXTURE0;
@@ -1209,32 +1069,12 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
             return;
         }
-        case GL_MAX_SHADER_COMPILER_THREADS_KHR:
-            // GL_KHR_parallel_shader_compile (GL_MAX_SHADER_COMPILER_THREADS_ARB is the same
-            // 0x91B0). The number of threads MobileGL's compile pool would actually use, so
-            // an application sizing its own submission batches gets a real answer.
-            //
-            // Zero when asynchronous compilation is off, which is the honest reply and the
-            // one the extension defines for an implementation with no compiler threads: the
-            // extension string is withdrawn in that configuration too, so a conforming
-            // application never reaches this query, and one that asks anyway is told there
-            // are none rather than being handed a thread count nothing will use.
-            *params = MG_Util::Async::AsyncShaderCompileEnabled()
-                          ? static_cast<GLint>(MG_Util::Async::ShaderCompilePool::Get().GetThreadCount())
-                          : 0;
-            return;
         case GL_MAX_DEBUG_GROUP_STACK_DEPTH:
-            // KHR_debug floors this at 64 even when the group entry points are stubs: the
-            // limit describes how deep glPushDebugGroup may nest, and 0 is not a legal answer.
-            *params = kFrontendMaxDebugGroupStackDepth;
+            *params = 0; // debug-group entrypoints are stubbed
             return;
         case GL_MAX_DEBUG_MESSAGE_LENGTH:
             *params = 1024; // debug-message entrypoints are stubbed, but KHR_debug requires a valid limit
             return;
-        case GL_MAX_DEBUG_LOGGED_MESSAGES:
-            // Size of the message log ring; KHR_debug requires at least 1.
-            *params = kFrontendMaxDebugLoggedMessages;
-            return;
         case GL_DEBUG_GROUP_STACK_DEPTH:
             *params = 0; // debug-group entrypoints are stubbed
             return;
@@ -1592,7 +1432,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = 0; // program-binary entrypoints are stubbed
             return;
         case GL_PROGRAM_PIPELINE_BINDING:
-            *params = static_cast<GLint>(MG_State::pGLContext->GetBoundProgramPipelineName());
+            *params = 0; // program-pipeline entrypoints are stubbed
             return;
         case GL_PROGRAM_POINT_SIZE:
             *params = MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::ProgramPointSize) ? GL_TRUE : GL_FALSE;
@@ -1676,9 +1516,13 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_SAMPLE_MASK_VALUE:
             *params = static_cast<GLint>(MG_State::pGLContext->GetSampleMaskValue());
             return;
-        case GL_SAMPLER_BINDING:
-            *params = QuerySamplerBindingOnUnit(MG_State::pGLContext->GetActiveTextureUnit());
+        case GL_SAMPLER_BINDING: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            const auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& sampler = tu.GetSamplerObject();
+            *params = sampler ? static_cast<GLint>(sampler->GetExternalIndex()) : 0;
             return;
+        }
         case GL_SAMPLES:
             *params = ResolveDrawFramebufferSampleCount();
             return;
@@ -1774,6 +1618,87 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_STEREO:
             *params = 0; // stereo surfaces are not exposed
             return;
+        case GL_TEXTURE_BINDING_1D: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture1D);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_1D_ARRAY: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture1DArray);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_2D: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture2D);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            MGLOG_D("Get GL_TEXTURE_BINDING_2D: %d", *params);
+            return;
+        }
+        case GL_TEXTURE_BINDING_2D_ARRAY: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture2DArray);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_2D_MULTISAMPLE: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture2DMultisample);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture2DMultisampleArray);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_3D: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture3D);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_BUFFER: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::TextureBuffer);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_CUBE_MAP: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::TextureCubeMap);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_RECTANGLE: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::TextureRectangle);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
         case GL_TEXTURE_COMPRESSION_HINT:
             *params = static_cast<GLint>(MG_State::pGLContext->GetHint(pname));
             return;
@@ -2046,18 +1971,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
             *params = static_cast<GLint>(GetIndexedBufferQueryPointCount(BufferTarget::ShaderStorage));
             break;
-        case GL_MAX_SHADER_STORAGE_BLOCK_SIZE:
-            // 64-bit state (see GetInteger64v); the 32-bit query saturates, per the GL
-            // state-query conversion rules.
-            *params = static_cast<GLint>(std::min<Uint64>(dynamicParameters.MaxShaderStorageBlockSize,
-                                                          static_cast<Uint64>(INT32_MAX)));
-            break;
-        case GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
-            *params = static_cast<GLint>(GetIndexedBufferQueryPointCount(BufferTarget::AtomicCounter));
-            break;
-        case GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE:
-            *params = kFrontendMaxAtomicCounterBufferSize;
-            break;
         case GL_MAX_TEXTURE_BUFFER_SIZE:
             *params = dynamicParameters.MaxTextureBufferSize;
             break;

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.h

@@ -19,8 +19,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     void GetIntegerv(GLenum pname, GLint* params);
     void GetInteger64v(GLenum pname, GLint64* params);
     void GetIntegeri_v(GLenum target, GLuint index, GLint* data);
-    void GetFloati_v(GLenum target, GLuint index, GLfloat* data);
-    void GetDoublei_v(GLenum target, GLuint index, GLdouble* data);
     void GetInteger64i_v(GLenum target, GLuint index, GLint64* data);
     GLenum GetError();
     GLenum GetGraphicsResetStatus();

MobileGL/MG_Impl/GLImpl/Program/GL_Program.h

@@ -42,10 +42,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     GLboolean IsProgram(GLuint program);
     GLboolean IsShader(GLuint shader);
     void LinkProgram(GLuint program);
-    // GL_KHR_parallel_shader_compile / GL_ARB_parallel_shader_compile. Both names are the
-    // same entry point; see MaxShaderCompilerThreadsKHR_State for the semantics of count.
-    void MaxShaderCompilerThreadsKHR(GLuint count);
-    void MaxShaderCompilerThreadsARB(GLuint count);
     void ShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length);
     void UseProgram(GLuint program);
     void Uniform1f(GLint location, GLfloat v0);
@@ -178,7 +174,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     void GetUniformdv(GLuint program, GLint location, GLdouble* params);
     void ValidateProgram(GLuint program);
     void ProgramParameteri(GLuint program, GLenum pname, GLint value);
-    GLuint CreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const* strings);
     void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary);
     void ProgramBinary(GLuint program, GLenum binaryFormat, const void* binary, GLsizei length);
     void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode);

MobileGL/MG_Impl/GLImpl/Program/GL_ProgramPipeline.cpp

@@ -1,231 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/GLImpl/Program/GL_ProgramPipeline.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 "GL_ProgramPipeline.h"
-
-#include <MG_State/GLState/Core.h>
-#include <MG_State/GLState/ErrorState/ErrorInfo.h>
-#include <MG_Util/Converters/GLToStr/GLEnumConverter.h>
-
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace {
-        void RecordPipelineError(ErrorCode code, const char* function, String message) {
-            MG_State::pGLContext->RecordError(
-                code, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", function, Move(message)));
-        }
-
-        // A pipeline name only names an object once it has been bound or created; querying a
-        // reserved-but-unmaterialised name is INVALID_OPERATION (GL 4.6 core 7.4).
-        const SharedPtr<MG_State::GLState::ProgramPipelineObject>* TryGetPipeline(GLuint pipeline,
-                                                                                 const char* function) {
-            if (!MG_State::pGLContext->IsProgramPipelineObject(pipeline)) {
-                RecordPipelineError(ErrorCode::InvalidOperation, function,
-                                    std::format("Program pipeline {} does not exist.", pipeline));
-                return nullptr;
-            }
-            return &MG_State::pGLContext->GetProgramPipelineObject(pipeline);
-        }
-
-        Bool ValidatePipelineCount(GLsizei n, const char* function) {
-            if (n < 0) {
-                RecordPipelineError(ErrorCode::InvalidValue, function, "n must be non-negative.");
-                return false;
-            }
-            return true;
-        }
-
-        // GL 4.6 core table 7.1 maps each stage bit onto a shader stage.
-        Bool TryResolveStageBit(GLbitfield bit, ShaderStage& outStage) {
-            switch (bit) {
-            case GL_VERTEX_SHADER_BIT: outStage = ShaderStage::Vertex; return true;
-            case GL_TESS_CONTROL_SHADER_BIT: outStage = ShaderStage::TessControl; return true;
-            case GL_TESS_EVALUATION_SHADER_BIT: outStage = ShaderStage::TessEval; return true;
-            case GL_GEOMETRY_SHADER_BIT: outStage = ShaderStage::Geometry; return true;
-            case GL_FRAGMENT_SHADER_BIT: outStage = ShaderStage::Fragment; return true;
-            case GL_COMPUTE_SHADER_BIT: outStage = ShaderStage::Compute; return true;
-            default: return false;
-            }
-        }
-
-        constexpr GLbitfield kAllStageBits = GL_VERTEX_SHADER_BIT | GL_TESS_CONTROL_SHADER_BIT |
-                                            GL_TESS_EVALUATION_SHADER_BIT | GL_GEOMETRY_SHADER_BIT |
-                                            GL_FRAGMENT_SHADER_BIT | GL_COMPUTE_SHADER_BIT;
-    } // namespace
-
-    void GenProgramPipelines(GLsizei n, GLuint* pipelines) {
-        if (!ValidatePipelineCount(n, __func__)) return;
-        if (n == 0 || !pipelines) return;
-
-        static thread_local Vector<GLuint> names;
-        MG_State::pGLContext->GenProgramPipelineNames(static_cast<Uint>(n), names);
-        Memcpy(pipelines, names.data(), static_cast<SizeT>(n) * sizeof(GLuint));
-    }
-
-    void CreateProgramPipelines(GLsizei n, GLuint* pipelines) {
-        if (!ValidatePipelineCount(n, __func__)) return;
-        if (n == 0 || !pipelines) return;
-
-        static thread_local Vector<GLuint> names;
-        MG_State::pGLContext->GenProgramPipelineNames(static_cast<Uint>(n), names);
-        for (GLsizei i = 0; i < n; ++i) {
-            pipelines[i] = names[static_cast<SizeT>(i)];
-            MG_State::pGLContext->CreateProgramPipelineObject(names[static_cast<SizeT>(i)]);
-        }
-    }
-
-    void DeleteProgramPipelines(GLsizei n, const GLuint* pipelines) {
-        if (!ValidatePipelineCount(n, __func__)) return;
-        if (!pipelines) return;
-
-        for (GLsizei i = 0; i < n; ++i) {
-            // Deleting zero, an unknown name, or a name that was only reserved is silently ignored.
-            MG_State::pGLContext->MarkProgramPipelineForDeletion(pipelines[i]);
-        }
-    }
-
-    void BindProgramPipeline(GLuint pipeline) {
-        if (pipeline != 0 && !MG_State::pGLContext->ValidateProgramPipelineName(pipeline)) {
-            RecordPipelineError(ErrorCode::InvalidOperation, __func__,
-                                std::format("Program pipeline name {} is not valid.", pipeline));
-            return;
-        }
-        MG_State::pGLContext->BindProgramPipelineObject(pipeline);
-    }
-
-    GLboolean IsProgramPipeline(GLuint pipeline) {
-        return MG_State::pGLContext->IsProgramPipelineObject(pipeline) ? GL_TRUE : GL_FALSE;
-    }
-
-    void GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint* params) {
-        const auto* pipelineObject = TryGetPipeline(pipeline, __func__);
-        if (!pipelineObject || !params) return;
-
-        const auto stageProgramName = [&](ShaderStage stage) -> GLint {
-            const auto& program = (*pipelineObject)->GetStageProgram(stage);
-            return program ? static_cast<GLint>(program->GetExternalIndex()) : 0;
-        };
-
-        switch (pname) {
-        case GL_ACTIVE_PROGRAM: {
-            const auto& active = (*pipelineObject)->GetActiveProgram();
-            *params = active ? static_cast<GLint>(active->GetExternalIndex()) : 0;
-            break;
-        }
-        case GL_VERTEX_SHADER: *params = stageProgramName(ShaderStage::Vertex); break;
-        case GL_TESS_CONTROL_SHADER: *params = stageProgramName(ShaderStage::TessControl); break;
-        case GL_TESS_EVALUATION_SHADER: *params = stageProgramName(ShaderStage::TessEval); break;
-        case GL_GEOMETRY_SHADER: *params = stageProgramName(ShaderStage::Geometry); break;
-        case GL_FRAGMENT_SHADER: *params = stageProgramName(ShaderStage::Fragment); break;
-        case GL_COMPUTE_SHADER: *params = stageProgramName(ShaderStage::Compute); break;
-        case GL_VALIDATE_STATUS: *params = (*pipelineObject)->GetValidateStatus() ? GL_TRUE : GL_FALSE; break;
-        case GL_INFO_LOG_LENGTH: {
-            // GL counts the null terminator, and reports 0 rather than 1 for an empty log.
-            const auto& log = (*pipelineObject)->GetInfoLog();
-            *params = log.empty() ? 0 : static_cast<GLint>(log.length()) + 1;
-            break;
-        }
-        default:
-            RecordPipelineError(ErrorCode::InvalidEnum, __func__,
-                                std::format("pname {} is not a program pipeline parameter.",
-                                            MG_Util::ConvertGLEnumToString(pname)));
-            break;
-        }
-    }
-
-    void GetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) {
-        const auto* pipelineObject = TryGetPipeline(pipeline, __func__);
-        if (!pipelineObject) return;
-        if (bufSize < 0) {
-            RecordPipelineError(ErrorCode::InvalidValue, __func__, "bufSize must be non-negative.");
-            return;
-        }
-        if (bufSize == 0 || !infoLog) {
-            if (length) *length = 0;
-            return;
-        }
-
-        const auto& log = (*pipelineObject)->GetInfoLog();
-        const auto copied = std::min<GLsizei>(bufSize - 1, static_cast<GLsizei>(log.length()));
-        if (copied > 0) Memcpy(infoLog, log.data(), static_cast<SizeT>(copied));
-        infoLog[copied] = '\0';
-        if (length) *length = copied;
-    }
-
-    void UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program) {
-        if (stages != GL_ALL_SHADER_BITS && (stages & ~kAllStageBits) != 0) {
-            RecordPipelineError(ErrorCode::InvalidValue, __func__, "stages names a bit that is not a shader stage.");
-            return;
-        }
-        const auto* pipelineObject = TryGetPipeline(pipeline, __func__);
-        if (!pipelineObject) return;
-
-        SharedPtr<MG_State::GLState::ProgramObject> programObject;
-        if (program != 0) {
-            if (!MG_State::pGLContext->ValidateProgramName(program)) {
-                RecordPipelineError(ErrorCode::InvalidValue, __func__,
-                                    std::format("{} is not the name of a program object.", program));
-                return;
-            }
-            programObject = MG_State::pGLContext->GetProgramObject(program);
-            if (!programObject) {
-                RecordPipelineError(ErrorCode::InvalidValue, __func__,
-                                    std::format("{} is not the name of a program object.", program));
-                return;
-            }
-            if (!programObject->GetLinkStatus()) {
-                RecordPipelineError(ErrorCode::InvalidOperation, __func__,
-                                    std::format("Program {} has not been linked successfully.", program));
-                return;
-            }
-        }
-
-        const GLbitfield selected = stages == GL_ALL_SHADER_BITS ? kAllStageBits : stages;
-        for (GLbitfield bit = 1; bit != 0 && bit <= kAllStageBits; bit <<= 1) {
-            if ((selected & bit) == 0) continue;
-            ShaderStage stage = ShaderStage::Unknown;
-            if (!TryResolveStageBit(bit, stage)) continue;
-            // program == 0 clears the stage, which is what a null program reference means here.
-            (*pipelineObject)->SetStageProgram(stage, programObject);
-        }
-    }
-
-    void ActiveShaderProgram(GLuint pipeline, GLuint program) {
-        const auto* pipelineObject = TryGetPipeline(pipeline, __func__);
-        if (!pipelineObject) return;
-
-        if (program == 0) {
-            (*pipelineObject)->SetActiveProgram(nullptr);
-            return;
-        }
-        if (!MG_State::pGLContext->ValidateProgramName(program)) {
-            RecordPipelineError(ErrorCode::InvalidValue, __func__,
-                                std::format("{} is not the name of a program object.", program));
-            return;
-        }
-        auto programObject = MG_State::pGLContext->GetProgramObject(program);
-        if (!programObject) {
-            RecordPipelineError(ErrorCode::InvalidValue, __func__,
-                                std::format("{} is not the name of a program object.", program));
-            return;
-        }
-        if (!programObject->GetLinkStatus()) {
-            RecordPipelineError(ErrorCode::InvalidOperation, __func__,
-                                std::format("Program {} has not been linked successfully.", program));
-            return;
-        }
-        (*pipelineObject)->SetActiveProgram(programObject);
-    }
-
-    void ValidateProgramPipeline(GLuint pipeline) {
-        const auto* pipelineObject = TryGetPipeline(pipeline, __func__);
-        if (!pipelineObject) return;
-        // Nothing here can fail today: MobileGL links each stage program on its own, so there is no
-        // cross-stage interface to re-check at validation time. The log stays empty, which GL allows.
-        (*pipelineObject)->SetValidateStatus(true);
-    }
-} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Program/GL_ProgramPipeline.h

@@ -1,23 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/GLImpl/Program/GL_ProgramPipeline.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>
-
-namespace MobileGL::MG_Impl::GLImpl {
-    void GenProgramPipelines(GLsizei n, GLuint* pipelines);
-    void CreateProgramPipelines(GLsizei n, GLuint* pipelines);
-    void DeleteProgramPipelines(GLsizei n, const GLuint* pipelines);
-    void BindProgramPipeline(GLuint pipeline);
-    GLboolean IsProgramPipeline(GLuint pipeline);
-    void GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint* params);
-    void GetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
-    void UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void ActiveShaderProgram(GLuint pipeline, GLuint program);
-    void ValidateProgramPipeline(GLuint pipeline);
-} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Program/ProgramInterface.cpp

@@ -1,841 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/GLImpl/Program/ProgramInterface.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 "ProgramInterface.h"
-
-#include <MG_State/GLState/ProgramState/ProgramObject.h>
-#include <MG_Util/ShaderTranspiler/Types.h>
-
-#include <cstring>
-
-namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
-    namespace {
-        // glslang folds atomic counters into synthesized blocks named
-        // "<getAtomicCounterBlockName()>_<binding>" (ParseContextBase.cpp), one per GL
-        // atomic-counter binding point. That block IS the GL_ATOMIC_COUNTER_BUFFER resource
-        // and its trailing number IS GL_BUFFER_BINDING; its members stay GL_UNIFORMs.
-        constexpr const char* kAtomicCounterBlockPrefix = "gl_AtomicCounterBlock";
-
-        enum class BlockKind {
-            Uniform,       // a real GL uniform block
-            GlobalUbo,     // the synthesized MGL_GLOBAL_UBO: GL sees its members as default-block
-            AtomicCounter, // gl_AtomicCounterBlock_<binding>
-            Storage,       // a shader storage block
-        };
-
-        // One row of any interface. Fields a given interface does not have keep the
-        // spec-mandated "not applicable" value, so a prop read never has to special-case
-        // the interface a second time.
-        struct Resource {
-            String name;
-            GLenum type = GL_NONE;
-            GLint arraySize = 1;
-            GLint location = -1;
-            GLint locationIndex = -1;
-            GLint blockIndex = -1;
-            GLint offset = -1;
-            GLint arrayStride = -1;
-            GLint matrixStride = -1;
-            GLint isRowMajor = 0;
-            GLint atomicCounterBufferIndex = -1;
-            GLint topLevelArraySize = 0;
-            GLint topLevelArrayStride = 0;
-            GLint bufferBinding = 0;
-            GLint bufferDataSize = 0;
-            GLint isPerPatch = 0;
-            GLint xfbBufferIndex = 0;
-            Uint32 stages = 0; // EShLanguageMask
-            Vector<GLuint> activeVariables;
-        };
-
-        using ResourceList = Vector<Resource>;
-
-        struct Model {
-            ResourceList uniforms;
-            ResourceList uniformBlocks;
-            ResourceList atomicCounterBuffers;
-            ResourceList bufferVariables;
-            ResourceList storageBlocks;
-            ResourceList programInputs;
-            ResourceList programOutputs;
-            ResourceList xfbVaryings;
-            Bool valid = false;
-        };
-
-        const ResourceList& EmptyList() {
-            static const ResourceList empty;
-            return empty;
-        }
-
-        // ---- name spelling (cluster 6) -------------------------------------------------
-
-        Bool EndsWithZeroSubscript(const String& name) {
-            return name.length() >= 3 && name.compare(name.length() - 3, 3, "[0]") == 0;
-        }
-
-        // The enumerated spelling of an array resource is "name[0]". glslang already applies
-        // that to uniforms and buffer variables (EShReflectionBasicArraySuffix), but never to
-        // stage inputs/outputs, so those get it here.
-        String WithArraySuffix(const String& name, const glslang::TType* type) {
-            if (type == nullptr || !type->isArray() || EndsWithZeroSubscript(name)) return name;
-            return name + "[0]";
-        }
-
-        // GL_ARRAY_SIZE: element count for a sized array, 0 for a runtime-sized one
-        // (a shader storage block's unsized trailing member), 1 for a non-array.
-        GLint ArraySizeOf(const glslang::TType* type, GLint reflectedSize) {
-            if (type != nullptr && type->isArray()) {
-                if (!type->isSizedArray()) return 0;
-                return type->getOuterArraySize();
-            }
-            return reflectedSize < 1 ? 1 : reflectedSize;
-        }
-
-        // Two spellings name the same resource when they are equal, or differ only by the
-        // "[0]" the enumeration appends to an array.
-        Bool NamesMatch(const String& resourceName, const String& query) {
-            if (resourceName == query) return true;
-            if (EndsWithZeroSubscript(resourceName) &&
-                resourceName.compare(0, resourceName.length() - 3, query) == 0) {
-                return true;
-            }
-            return EndsWithZeroSubscript(query) && query.compare(0, query.length() - 3, resourceName) == 0;
-        }
-
-        // Splits "base[k]" into ("base", k). GL 4.6 §7.3.1.1 requires the subscript to be a
-        // decimal integer with no white space and no leading zeros, which is exactly what
-        // separates array-names' "a[1]" (resolves) from "a[01]", "a[0 + 0]" and "a[ 0]" (do
-        // not). Returns false when there is no trailing subscript at all; sets `malformed`
-        // when there is one but it is not a strict decimal.
-        Bool SplitTrailingSubscript(const String& name, String& outBase, Uint& outElement, Bool& outMalformed) {
-            outMalformed = false;
-            if (name.empty() || name.back() != ']') return false;
-            const SizeT bracket = name.rfind('[');
-            if (bracket == String::npos) return false;
-            const SizeT first = bracket + 1;
-            const SizeT last = name.length() - 1; // one past the digits
-            if (first >= last) {
-                outMalformed = true;
-                return false;
-            }
-            // No leading zeros: "0" is the only spelling that may start with '0'.
-            if (name[first] == '0' && last - first > 1) {
-                outMalformed = true;
-                return false;
-            }
-            Uint element = 0;
-            for (SizeT i = first; i < last; ++i) {
-                if (name[i] < '0' || name[i] > '9') {
-                    outMalformed = true;
-                    return false;
-                }
-                element = element * 10 + static_cast<Uint>(name[i] - '0');
-                if (element > 0x0FFFFFFFu) {
-                    outMalformed = true;
-                    return false;
-                }
-            }
-            outBase = name.substr(0, bracket);
-            outElement = element;
-            return true;
-        }
-
-        // ---- block classification ------------------------------------------------------
-
-        Bool IsAtomicCounterBlockName(const String& name) {
-            return name.compare(0, std::strlen(kAtomicCounterBlockPrefix), kAtomicCounterBlockPrefix) == 0;
-        }
-
-        // "gl_AtomicCounterBlock_5" -> 5. The suffix is the GL binding the counters were
-        // declared with, which glslang does NOT keep in the block's own layout qualifier
-        // (that one is remapped to a plain buffer binding).
-        GLint AtomicCounterBlockBinding(const String& name) {
-            const SizeT underscore = name.rfind('_');
-            if (underscore == String::npos || underscore + 1 >= name.length()) return 0;
-            GLint binding = 0;
-            for (SizeT i = underscore + 1; i < name.length(); ++i) {
-                if (name[i] < '0' || name[i] > '9') return 0;
-                binding = binding * 10 + (name[i] - '0');
-            }
-            return binding;
-        }
-
-        // Element index of an arrayed block instance ("TrickyBuffer[1]" -> 1).
-        GLint BlockArrayElement(const String& name) {
-            String base;
-            Uint element = 0;
-            Bool malformed = false;
-            if (!SplitTrailingSubscript(name, base, element, malformed)) return 0;
-            return static_cast<GLint>(element);
-        }
-
-        BlockKind ClassifyBlock(const glslang::TObjectReflection& block) {
-            if (std::strstr(block.name.c_str(), MG_Util::ShaderTranspiler::GLOBAL_UBO_NAME) != nullptr) {
-                return BlockKind::GlobalUbo;
-            }
-            if (IsAtomicCounterBlockName(block.name)) return BlockKind::AtomicCounter;
-            const glslang::TType* type = block.getType();
-            if (type != nullptr && type->getQualifier().storage == glslang::EvqBuffer) return BlockKind::Storage;
-            return BlockKind::Uniform;
-        }
-
-        // std140/std430 column stride, the same vec4-rounded rule ProgramObject applies to
-        // uniform matrices. 0 for a non-matrix.
-        GLint MatrixStrideOf(const glslang::TType* type) {
-            if (type == nullptr || !type->isMatrix()) return 0;
-            const bool rowMajor = type->getQualifier().layoutMatrix == glslang::ElmRowMajor;
-            const int strideVectorComponents = rowMajor ? type->getMatrixCols() : type->getMatrixRows();
-            constexpr int scalarSize = 4;
-            const int vectorAlignment = (strideVectorComponents <= 1)    ? scalarSize
-                                        : (strideVectorComponents == 2) ? 2 * scalarSize
-                                                                        : 4 * scalarSize;
-            return (vectorAlignment + 15) & ~15;
-        }
-
-        GLint IsRowMajorOf(const glslang::TType* type) {
-            if (type == nullptr || !type->isMatrix()) return 0;
-            return type->getQualifier().layoutMatrix == glslang::ElmRowMajor ? 1 : 0;
-        }
-
-        GLint MappedLocation(Int rawLocation) {
-            // glslang parks "no location" at layoutLocationEnd; GL spells it -1.
-            if (rawLocation < 0 || rawLocation >= static_cast<Int>(glslang::TQualifier::layoutLocationEnd)) return -1;
-            return rawLocation;
-        }
-
-        // ---- model construction --------------------------------------------------------
-
-        void BuildBlocks(ProgramObject& program, const glslang::TProgram& reflection, Model& model,
-                         Vector<BlockKind>& blockKind, Vector<Int>& blockInterfaceIndex) {
-            const Int blockCount = const_cast<glslang::TProgram&>(reflection).getNumUniformBlocks();
-            blockKind.assign(blockCount, BlockKind::Uniform);
-            blockInterfaceIndex.assign(blockCount, -1);
-
-            for (Int tIndex = 0; tIndex < blockCount; ++tIndex) {
-                const auto& block = const_cast<glslang::TProgram&>(reflection).getUniformBlock(tIndex);
-                const BlockKind kind = ClassifyBlock(block);
-                blockKind[tIndex] = kind;
-                if (kind == BlockKind::AtomicCounter) {
-                    Resource resource;
-                    // GL_ATOMIC_COUNTER_BUFFER resources have no name (and GetProgramResource
-                    // Index/Name reject the interface outright, which is why this stays empty).
-                    resource.bufferBinding = AtomicCounterBlockBinding(block.name);
-                    resource.bufferDataSize = block.size;
-                    resource.stages = static_cast<Uint32>(block.stages);
-                    blockInterfaceIndex[tIndex] = static_cast<Int>(model.atomicCounterBuffers.size());
-                    model.atomicCounterBuffers.push_back(Move(resource));
-                } else if (kind == BlockKind::Storage) {
-                    Resource resource;
-                    resource.name = block.name;
-                    // glslang reports the DECLARED binding for every instance of an arrayed
-                    // block; GL gives element k the binding base + k. That is only the initial
-                    // value: GL_BUFFER_BINDING must report the CURRENT binding, so a later
-                    // glShaderStorageBlockBinding wins over the declaration (GL 4.6 §7.6.2 -
-                    // exactly the same rule GL_UNIFORM_BLOCK follows through
-                    // GetUniformBlockBinding below).
-                    const GLint declared = block.getBinding();
-                    resource.bufferBinding = declared < 0 ? 0 : declared + BlockArrayElement(block.name);
-                    const Int rebound = program.GetShaderStorageBlockBindingOverride(block.name);
-                    if (rebound >= 0) resource.bufferBinding = static_cast<GLint>(rebound);
-                    resource.bufferDataSize = block.size;
-                    resource.stages = static_cast<Uint32>(block.stages);
-                    blockInterfaceIndex[tIndex] = static_cast<Int>(model.storageBlocks.size());
-                    model.storageBlocks.push_back(Move(resource));
-                }
-            }
-
-            // GL_UNIFORM_BLOCK keeps the index space glUniformBlockBinding and
-            // glGetActiveUniformBlockiv already use, so an index handed out here is usable
-            // with them (which is exactly what the CTS does).
-            const Int glBlockCount = program.GetActiveUniformBlocksCount();
-            for (Int glIndex = 0; glIndex < glBlockCount; ++glIndex) {
-                Resource resource;
-                resource.name = program.GetUniformBlockName(glIndex);
-                resource.bufferBinding = static_cast<GLint>(program.GetUniformBlockBinding(glIndex));
-                resource.bufferDataSize = static_cast<GLint>(program.GetUBOSizeAt(glIndex));
-                const Int tIndex = program.TProgramBlockIndex(static_cast<Uint>(glIndex));
-                if (tIndex >= 0 && tIndex < blockCount) {
-                    resource.stages =
-                        static_cast<Uint32>(const_cast<glslang::TProgram&>(reflection).getUniformBlock(tIndex).stages);
-                }
-                model.uniformBlocks.push_back(Move(resource));
-            }
-        }
-
-        void BuildUniformsAndBufferVariables(ProgramObject& program, const glslang::TProgram& reflection, Model& model,
-                                             const Vector<BlockKind>& blockKind,
-                                             const Vector<Int>& blockInterfaceIndex) {
-            const Uint uniformCount = program.GetUniformCount();
-            for (Uint glIndex = 0; glIndex < uniformCount; ++glIndex) {
-                const Int tIndex = program.TProgramUniformIndex(glIndex);
-                const auto& refl = const_cast<glslang::TProgram&>(reflection).getUniform(tIndex);
-                const glslang::TType* type = refl.getType();
-                const Int owner = refl.index;
-                const BlockKind kind = (owner >= 0 && owner < static_cast<Int>(blockKind.size()))
-                                           ? blockKind[owner]
-                                           : BlockKind::GlobalUbo;
-
-                Resource resource;
-                resource.name = refl.name;
-                resource.type = static_cast<GLenum>(refl.glDefineType);
-                resource.arraySize = ArraySizeOf(type, refl.size);
-                resource.stages = static_cast<Uint32>(refl.stages);
-
-                if (kind == BlockKind::Storage) {
-                    resource.blockIndex = blockInterfaceIndex[owner];
-                    resource.offset = refl.offset;
-                    resource.arrayStride = refl.arrayStride;
-                    resource.matrixStride = MatrixStrideOf(type);
-                    resource.isRowMajor = IsRowMajorOf(type);
-                    // GL requires 1 for a member that is not inside a top-level array (and for
-                    // the top-level array itself); glslang leaves 0/-1 there.
-                    resource.topLevelArraySize = refl.topLevelArraySize > 0 ? refl.topLevelArraySize : 1;
-                    resource.topLevelArrayStride = refl.topLevelArrayStride;
-                    model.bufferVariables.push_back(Move(resource));
-                    continue;
-                }
-
-                if (kind == BlockKind::AtomicCounter) {
-                    // An atomic counter is a default-block uniform with no location and no
-                    // owning uniform block; what it does have is a buffer to point at.
-                    resource.type = GL_UNSIGNED_INT_ATOMIC_COUNTER;
-                    resource.blockIndex = -1;
-                    resource.offset = refl.offset;
-                    resource.arrayStride = refl.arrayStride;
-                    resource.matrixStride = 0;
-                    resource.atomicCounterBufferIndex = blockInterfaceIndex[owner];
-                    resource.location = -1;
-                } else {
-                    resource.blockIndex = program.GetActiveUniformBlockIndex(glIndex);
-                    resource.offset = program.GetActiveUniformOffset(glIndex);
-                    resource.arrayStride = program.GetActiveUniformArrayStride(glIndex);
-                    resource.matrixStride = program.GetActiveUniformMatrixStride(glIndex);
-                    resource.isRowMajor = program.GetActiveUniformIsRowMajor(glIndex);
-                    // A member of a named uniform block has no location, whatever the
-                    // frontend's own location table says (it hands one out to every uniform
-                    // so glUniform* can address block members through the global UBO).
-                    resource.location =
-                        resource.blockIndex >= 0 ? -1 : program.GetUniformLocation(refl.name);
-                }
-                model.uniforms.push_back(Move(resource));
-            }
-
-            // GL_ACTIVE_VARIABLES, both directions.
-            for (SizeT i = 0; i < model.uniforms.size(); ++i) {
-                const Resource& uniform = model.uniforms[i];
-                if (uniform.atomicCounterBufferIndex >= 0 &&
-                    uniform.atomicCounterBufferIndex < static_cast<GLint>(model.atomicCounterBuffers.size())) {
-                    model.atomicCounterBuffers[uniform.atomicCounterBufferIndex].activeVariables.push_back(
-                        static_cast<GLuint>(i));
-                }
-            }
-            for (SizeT blockIndex = 0; blockIndex < model.uniformBlocks.size(); ++blockIndex) {
-                // Members of an arrayed block are reflected once, against instance [0].
-                const Int owner = static_cast<Int>(program.GetUniformBlockMemberOwnerIndex(static_cast<Uint>(blockIndex)));
-                for (SizeT i = 0; i < model.uniforms.size(); ++i) {
-                    if (model.uniforms[i].blockIndex == owner) {
-                        model.uniformBlocks[blockIndex].activeVariables.push_back(static_cast<GLuint>(i));
-                    }
-                }
-            }
-            for (SizeT blockIndex = 0; blockIndex < model.storageBlocks.size(); ++blockIndex) {
-                for (SizeT i = 0; i < model.bufferVariables.size(); ++i) {
-                    if (model.bufferVariables[i].blockIndex == static_cast<GLint>(blockIndex)) {
-                        model.storageBlocks[blockIndex].activeVariables.push_back(static_cast<GLuint>(i));
-                    }
-                }
-            }
-        }
-
-        void BuildStageIO(ProgramObject& program, const glslang::TProgram& reflection, Model& model) {
-            auto& mutableReflection = const_cast<glslang::TProgram&>(reflection);
-
-            const Int inputCount = mutableReflection.getNumPipeInputs();
-            for (Int index = 0; index < inputCount; ++index) {
-                const auto& refl = mutableReflection.getPipeInput(index);
-                const glslang::TType* type = refl.getType();
-                Resource resource;
-                // The Vulkan-semantics parse reflects the vertex builtins under their SPIR-V
-                // names; GL enumerates the GL spellings.
-                const String& glName = ProgramObject::NormalizeBuiltinPipeInputName(refl.name);
-                resource.name = WithArraySuffix(glName, type);
-                resource.type = static_cast<GLenum>(refl.glDefineType);
-                resource.arraySize = ArraySizeOf(type, refl.size);
-                resource.location = program.GetAttributeLocation(refl.name);
-                if (resource.location < 0) resource.location = MappedLocation(static_cast<Int>(refl.layoutLocation()));
-                resource.isPerPatch = (type != nullptr && type->getQualifier().patch) ? 1 : 0;
-                resource.stages = static_cast<Uint32>(refl.stages);
-                model.programInputs.push_back(Move(resource));
-            }
-
-            const Int outputCount = mutableReflection.getNumPipeOutputs();
-            for (Int index = 0; index < outputCount; ++index) {
-                const auto& refl = mutableReflection.getPipeOutput(index);
-                const glslang::TType* type = refl.getType();
-                Resource resource;
-                resource.name = WithArraySuffix(refl.name, type);
-                resource.type = static_cast<GLenum>(refl.glDefineType);
-                resource.arraySize = ArraySizeOf(type, refl.size);
-                resource.location = MappedLocation(program.GetFragmentDataLocation(refl.name.c_str()));
-                if (resource.location < 0) {
-                    // A built-in output (gl_FragDepth, gl_SampleMask) and a non-fragment stage
-                    // output both have no location, and therefore no color index either.
-                    resource.locationIndex = -1;
-                } else {
-                    resource.locationIndex = program.GetFragmentDataIndex(refl.name.c_str());
-                    // glBindFragDataLocationIndexed wins; otherwise the shader's
-                    // layout(index = N), which the frag-data maps never saw.
-                    if (resource.locationIndex == 0 && type != nullptr && type->getQualifier().hasIndex()) {
-                        resource.locationIndex = static_cast<GLint>(type->getQualifier().layoutIndex);
-                    }
-                }
-                resource.isPerPatch = (type != nullptr && type->getQualifier().patch) ? 1 : 0;
-                resource.stages = static_cast<Uint32>(refl.stages);
-                model.programOutputs.push_back(Move(resource));
-            }
-        }
-
-        void BuildXfb(ProgramObject& program, Model& model) {
-            const auto& requested = program.GetTransformFeedbackInterfaceNames();
-            const auto& captured = program.GetTransformFeedbackVaryings();
-            for (const String& name : requested) {
-                Resource resource;
-                resource.name = name;
-                // ARB_transform_feedback3's layout controls are enumerated as resources of
-                // type NONE: gl_NextBuffer with array size 0, gl_SkipComponentsN with N.
-                if (name == "gl_NextBuffer") {
-                    resource.type = GL_NONE;
-                    resource.arraySize = 0;
-                } else if (name.size() == 18 && name.compare(0, 17, "gl_SkipComponents") == 0 && name[17] >= '1' &&
-                           name[17] <= '4') {
-                    resource.type = GL_NONE;
-                    resource.arraySize = name[17] - '0';
-                } else {
-                    resource.type = GL_NONE;
-                    resource.arraySize = 1;
-                    for (const auto& varying : captured) {
-                        if (varying.name != name) continue;
-                        resource.type = varying.type;
-                        resource.arraySize = varying.size < 1 ? 1 : varying.size;
-                        resource.offset = static_cast<GLint>(varying.offsetBytes);
-                        resource.xfbBufferIndex = static_cast<GLint>(varying.bufferIndex);
-                        break;
-                    }
-                }
-                model.xfbVaryings.push_back(Move(resource));
-            }
-        }
-
-        Model BuildModel(ProgramObject& program) {
-            Model model;
-            if (!program.GetLinkStatus()) return model;
-            const glslang::TProgram* reflection = program.GetReflection();
-            if (reflection == nullptr) return model;
-            model.valid = true;
-
-            Vector<BlockKind> blockKind;
-            Vector<Int> blockInterfaceIndex;
-            BuildBlocks(program, *reflection, model, blockKind, blockInterfaceIndex);
-            BuildUniformsAndBufferVariables(program, *reflection, model, blockKind, blockInterfaceIndex);
-            BuildStageIO(program, *reflection, model);
-            BuildXfb(program, model);
-            return model;
-        }
-
-        const ResourceList& Select(const Model& model, GLenum programInterface) {
-            switch (programInterface) {
-            case GL_UNIFORM:
-                return model.uniforms;
-            case GL_UNIFORM_BLOCK:
-                return model.uniformBlocks;
-            case GL_ATOMIC_COUNTER_BUFFER:
-                return model.atomicCounterBuffers;
-            case GL_BUFFER_VARIABLE:
-                return model.bufferVariables;
-            case GL_SHADER_STORAGE_BLOCK:
-                return model.storageBlocks;
-            case GL_PROGRAM_INPUT:
-                return model.programInputs;
-            case GL_PROGRAM_OUTPUT:
-                return model.programOutputs;
-            case GL_TRANSFORM_FEEDBACK_VARYING:
-                return model.xfbVaryings;
-            default:
-                // The subroutine interfaces are accepted by the API but nothing can populate
-                // them: glslang refuses `subroutine` when generating SPIR-V, so a program
-                // using one never links. Zero active resources is the honest answer.
-                return EmptyList();
-            }
-        }
-    } // namespace
-
-    Bool IsInterfaceEnum(GLenum programInterface) {
-        switch (programInterface) {
-        case GL_UNIFORM:
-        case GL_UNIFORM_BLOCK:
-        case GL_PROGRAM_INPUT:
-        case GL_PROGRAM_OUTPUT:
-        case GL_BUFFER_VARIABLE:
-        case GL_SHADER_STORAGE_BLOCK:
-        case GL_ATOMIC_COUNTER_BUFFER:
-        case GL_TRANSFORM_FEEDBACK_VARYING:
-        case GL_TRANSFORM_FEEDBACK_BUFFER:
-        case GL_VERTEX_SUBROUTINE:
-        case GL_TESS_CONTROL_SUBROUTINE:
-        case GL_TESS_EVALUATION_SUBROUTINE:
-        case GL_GEOMETRY_SUBROUTINE:
-        case GL_FRAGMENT_SUBROUTINE:
-        case GL_COMPUTE_SUBROUTINE:
-        case GL_VERTEX_SUBROUTINE_UNIFORM:
-        case GL_TESS_CONTROL_SUBROUTINE_UNIFORM:
-        case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM:
-        case GL_GEOMETRY_SUBROUTINE_UNIFORM:
-        case GL_FRAGMENT_SUBROUTINE_UNIFORM:
-        case GL_COMPUTE_SUBROUTINE_UNIFORM:
-            return true;
-        default:
-            return false;
-        }
-    }
-
-    Bool IsNamedInterface(GLenum programInterface) {
-        // GL 4.6 §7.3.1.2: the two buffer interfaces have no resource names, and asking for
-        // one is INVALID_ENUM (deliberately asymmetric with GetProgramInterfaceiv, which
-        // does count them).
-        return IsInterfaceEnum(programInterface) && programInterface != GL_ATOMIC_COUNTER_BUFFER &&
-               programInterface != GL_TRANSFORM_FEEDBACK_BUFFER;
-    }
-
-    Bool InterfaceHasLocations(GLenum programInterface) {
-        switch (programInterface) {
-        case GL_UNIFORM:
-        case GL_PROGRAM_INPUT:
-        case GL_PROGRAM_OUTPUT:
-        case GL_VERTEX_SUBROUTINE_UNIFORM:
-        case GL_TESS_CONTROL_SUBROUTINE_UNIFORM:
-        case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM:
-        case GL_GEOMETRY_SUBROUTINE_UNIFORM:
-        case GL_FRAGMENT_SUBROUTINE_UNIFORM:
-        case GL_COMPUTE_SUBROUTINE_UNIFORM:
-            return true;
-        default:
-            return false;
-        }
-    }
-
-    Bool IsResourceProp(GLenum prop) {
-        switch (prop) {
-        case GL_NAME_LENGTH:
-        case GL_TYPE:
-        case GL_ARRAY_SIZE:
-        case GL_OFFSET:
-        case GL_BLOCK_INDEX:
-        case GL_ARRAY_STRIDE:
-        case GL_MATRIX_STRIDE:
-        case GL_IS_ROW_MAJOR:
-        case GL_ATOMIC_COUNTER_BUFFER_INDEX:
-        case GL_BUFFER_BINDING:
-        case GL_BUFFER_DATA_SIZE:
-        case GL_NUM_ACTIVE_VARIABLES:
-        case GL_ACTIVE_VARIABLES:
-        case GL_REFERENCED_BY_VERTEX_SHADER:
-        case GL_REFERENCED_BY_TESS_CONTROL_SHADER:
-        case GL_REFERENCED_BY_TESS_EVALUATION_SHADER:
-        case GL_REFERENCED_BY_GEOMETRY_SHADER:
-        case GL_REFERENCED_BY_FRAGMENT_SHADER:
-        case GL_REFERENCED_BY_COMPUTE_SHADER:
-        case GL_TOP_LEVEL_ARRAY_SIZE:
-        case GL_TOP_LEVEL_ARRAY_STRIDE:
-        case GL_LOCATION:
-        case GL_LOCATION_INDEX:
-        case GL_IS_PER_PATCH:
-        case GL_LOCATION_COMPONENT:
-        case GL_TRANSFORM_FEEDBACK_BUFFER_INDEX:
-        case GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE:
-        case GL_NUM_COMPATIBLE_SUBROUTINES:
-        case GL_COMPATIBLE_SUBROUTINES:
-            return true;
-        default:
-            return false;
-        }
-    }
-
-    // GL 4.6 Table 7.2, transcribed row by row: which interfaces each property applies to.
-    // Too tight a table turns a currently-answered prop into a fresh INVALID_OPERATION, so
-    // the rows below are deliberately no narrower than the spec's.
-    Bool InterfaceSupportsProp(GLenum programInterface, GLenum prop) {
-        const Bool isSubroutine =
-            programInterface == GL_VERTEX_SUBROUTINE || programInterface == GL_TESS_CONTROL_SUBROUTINE ||
-            programInterface == GL_TESS_EVALUATION_SUBROUTINE || programInterface == GL_GEOMETRY_SUBROUTINE ||
-            programInterface == GL_FRAGMENT_SUBROUTINE || programInterface == GL_COMPUTE_SUBROUTINE;
-        const Bool isSubroutineUniform =
-            programInterface == GL_VERTEX_SUBROUTINE_UNIFORM ||
-            programInterface == GL_TESS_CONTROL_SUBROUTINE_UNIFORM ||
-            programInterface == GL_TESS_EVALUATION_SUBROUTINE_UNIFORM ||
-            programInterface == GL_GEOMETRY_SUBROUTINE_UNIFORM ||
-            programInterface == GL_FRAGMENT_SUBROUTINE_UNIFORM || programInterface == GL_COMPUTE_SUBROUTINE_UNIFORM;
-
-        switch (prop) {
-        case GL_NAME_LENGTH:
-            return programInterface != GL_ATOMIC_COUNTER_BUFFER && programInterface != GL_TRANSFORM_FEEDBACK_BUFFER;
-        case GL_TYPE:
-        case GL_ARRAY_SIZE:
-            return programInterface == GL_UNIFORM || programInterface == GL_PROGRAM_INPUT ||
-                   programInterface == GL_PROGRAM_OUTPUT || programInterface == GL_BUFFER_VARIABLE ||
-                   programInterface == GL_TRANSFORM_FEEDBACK_VARYING ||
-                   (prop == GL_ARRAY_SIZE && isSubroutineUniform);
-        case GL_OFFSET:
-            return programInterface == GL_UNIFORM || programInterface == GL_BUFFER_VARIABLE ||
-                   programInterface == GL_TRANSFORM_FEEDBACK_VARYING;
-        case GL_BLOCK_INDEX:
-        case GL_ARRAY_STRIDE:
-        case GL_MATRIX_STRIDE:
-        case GL_IS_ROW_MAJOR:
-            return programInterface == GL_UNIFORM || programInterface == GL_BUFFER_VARIABLE;
-        case GL_ATOMIC_COUNTER_BUFFER_INDEX:
-            return programInterface == GL_UNIFORM;
-        case GL_BUFFER_BINDING:
-        case GL_NUM_ACTIVE_VARIABLES:
-        case GL_ACTIVE_VARIABLES:
-            // Table 7.2 lists GL_TRANSFORM_FEEDBACK_BUFFER on these three rows too. This
-            // implementation enumerates no resources on that interface, so the query still
-            // ends in an error - but INVALID_VALUE for the out-of-range index, not the
-            // INVALID_OPERATION a narrower table would invent.
-            return programInterface == GL_UNIFORM_BLOCK || programInterface == GL_ATOMIC_COUNTER_BUFFER ||
-                   programInterface == GL_SHADER_STORAGE_BLOCK ||
-                   programInterface == GL_TRANSFORM_FEEDBACK_BUFFER;
-        case GL_BUFFER_DATA_SIZE:
-            return programInterface == GL_UNIFORM_BLOCK || programInterface == GL_ATOMIC_COUNTER_BUFFER ||
-                   programInterface == GL_SHADER_STORAGE_BLOCK;
-        case GL_REFERENCED_BY_VERTEX_SHADER:
-        case GL_REFERENCED_BY_TESS_CONTROL_SHADER:
-        case GL_REFERENCED_BY_TESS_EVALUATION_SHADER:
-        case GL_REFERENCED_BY_GEOMETRY_SHADER:
-        case GL_REFERENCED_BY_FRAGMENT_SHADER:
-        case GL_REFERENCED_BY_COMPUTE_SHADER:
-            return programInterface == GL_UNIFORM || programInterface == GL_UNIFORM_BLOCK ||
-                   programInterface == GL_ATOMIC_COUNTER_BUFFER || programInterface == GL_BUFFER_VARIABLE ||
-                   programInterface == GL_SHADER_STORAGE_BLOCK || programInterface == GL_PROGRAM_INPUT ||
-                   programInterface == GL_PROGRAM_OUTPUT || isSubroutineUniform;
-        case GL_TOP_LEVEL_ARRAY_SIZE:
-        case GL_TOP_LEVEL_ARRAY_STRIDE:
-            return programInterface == GL_BUFFER_VARIABLE;
-        case GL_LOCATION:
-            return InterfaceHasLocations(programInterface);
-        case GL_LOCATION_INDEX:
-            return programInterface == GL_PROGRAM_OUTPUT;
-        case GL_IS_PER_PATCH:
-        case GL_LOCATION_COMPONENT:
-            return programInterface == GL_PROGRAM_INPUT || programInterface == GL_PROGRAM_OUTPUT;
-        case GL_TRANSFORM_FEEDBACK_BUFFER_INDEX:
-            return programInterface == GL_TRANSFORM_FEEDBACK_VARYING;
-        case GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE:
-            return programInterface == GL_TRANSFORM_FEEDBACK_BUFFER;
-        case GL_NUM_COMPATIBLE_SUBROUTINES:
-        case GL_COMPATIBLE_SUBROUTINES:
-            return isSubroutineUniform;
-        default:
-            (void)isSubroutine;
-            return false;
-        }
-    }
-
-    Int GetActiveResourceCount(ProgramObject& program, GLenum programInterface) {
-        const Model model = BuildModel(program);
-        return static_cast<Int>(Select(model, programInterface).size());
-    }
-
-    Int GetMaxNameLength(ProgramObject& program, GLenum programInterface) {
-        if (!IsNamedInterface(programInterface)) return 0;
-        const Model model = BuildModel(program);
-        SizeT longest = 0;
-        for (const Resource& resource : Select(model, programInterface)) {
-            longest = std::max(longest, resource.name.length() + 1);
-        }
-        return static_cast<Int>(longest);
-    }
-
-    Int GetMaxNumActiveVariables(ProgramObject& program, GLenum programInterface) {
-        const Model model = BuildModel(program);
-        SizeT longest = 0;
-        for (const Resource& resource : Select(model, programInterface)) {
-            longest = std::max(longest, resource.activeVariables.size());
-        }
-        return static_cast<Int>(longest);
-    }
-
-    GLuint GetResourceIndex(ProgramObject& program, GLenum programInterface, const char* name) {
-        if (name == nullptr || name[0] == '\0') return GL_INVALID_INDEX;
-        const Model model = BuildModel(program);
-        const ResourceList& resources = Select(model, programInterface);
-        const String query = name;
-        // The layout controls of an interleaved capture are enumerable but not addressable
-        // by name (GL 4.6 §7.3.1.1).
-        if (programInterface == GL_TRANSFORM_FEEDBACK_VARYING &&
-            (query == "gl_NextBuffer" ||
-             (query.size() == 18 && query.compare(0, 17, "gl_SkipComponents") == 0))) {
-            return GL_INVALID_INDEX;
-        }
-        for (SizeT i = 0; i < resources.size(); ++i) {
-            if (NamesMatch(resources[i].name, query)) return static_cast<GLuint>(i);
-        }
-        return GL_INVALID_INDEX;
-    }
-
-    Bool GetResourceName(ProgramObject& program, GLenum programInterface, GLuint index, String& outName) {
-        const Model model = BuildModel(program);
-        const ResourceList& resources = Select(model, programInterface);
-        if (index >= resources.size()) return false;
-        outName = resources[index].name;
-        return true;
-    }
-
-    Bool GetResourceProp(ProgramObject& program, GLenum programInterface, GLuint index, GLenum prop,
-                         Vector<GLint>& outValues) {
-        const Model model = BuildModel(program);
-        const ResourceList& resources = Select(model, programInterface);
-        if (index >= resources.size()) return false;
-        const Resource& resource = resources[index];
-
-        const auto referencedBy = [&resource](EShLanguage stage) {
-            return (resource.stages & static_cast<Uint32>(1u << stage)) != 0 ? GL_TRUE : GL_FALSE;
-        };
-
-        switch (prop) {
-        case GL_NAME_LENGTH:
-            outValues.push_back(static_cast<GLint>(resource.name.length() + 1));
-            break;
-        case GL_TYPE:
-            outValues.push_back(static_cast<GLint>(resource.type));
-            break;
-        case GL_ARRAY_SIZE:
-            outValues.push_back(resource.arraySize);
-            break;
-        case GL_OFFSET:
-            outValues.push_back(resource.offset);
-            break;
-        case GL_BLOCK_INDEX:
-            outValues.push_back(resource.blockIndex);
-            break;
-        case GL_ARRAY_STRIDE:
-            outValues.push_back(resource.arrayStride);
-            break;
-        case GL_MATRIX_STRIDE:
-            outValues.push_back(resource.matrixStride);
-            break;
-        case GL_IS_ROW_MAJOR:
-            outValues.push_back(resource.isRowMajor);
-            break;
-        case GL_ATOMIC_COUNTER_BUFFER_INDEX:
-            outValues.push_back(resource.atomicCounterBufferIndex);
-            break;
-        case GL_BUFFER_BINDING:
-            outValues.push_back(resource.bufferBinding);
-            break;
-        case GL_BUFFER_DATA_SIZE:
-            outValues.push_back(resource.bufferDataSize);
-            break;
-        case GL_NUM_ACTIVE_VARIABLES:
-            outValues.push_back(static_cast<GLint>(resource.activeVariables.size()));
-            break;
-        case GL_ACTIVE_VARIABLES:
-            for (const GLuint variable : resource.activeVariables) outValues.push_back(static_cast<GLint>(variable));
-            break;
-        case GL_REFERENCED_BY_VERTEX_SHADER:
-            outValues.push_back(referencedBy(EShLangVertex));
-            break;
-        case GL_REFERENCED_BY_TESS_CONTROL_SHADER:
-            outValues.push_back(referencedBy(EShLangTessControl));
-            break;
-        case GL_REFERENCED_BY_TESS_EVALUATION_SHADER:
-            outValues.push_back(referencedBy(EShLangTessEvaluation));
-            break;
-        case GL_REFERENCED_BY_GEOMETRY_SHADER:
-            outValues.push_back(referencedBy(EShLangGeometry));
-            break;
-        case GL_REFERENCED_BY_FRAGMENT_SHADER:
-            outValues.push_back(referencedBy(EShLangFragment));
-            break;
-        case GL_REFERENCED_BY_COMPUTE_SHADER:
-            outValues.push_back(referencedBy(EShLangCompute));
-            break;
-        case GL_TOP_LEVEL_ARRAY_SIZE:
-            outValues.push_back(resource.topLevelArraySize);
-            break;
-        case GL_TOP_LEVEL_ARRAY_STRIDE:
-            outValues.push_back(resource.topLevelArrayStride);
-            break;
-        case GL_LOCATION:
-            outValues.push_back(resource.location);
-            break;
-        case GL_LOCATION_INDEX:
-            outValues.push_back(resource.locationIndex);
-            break;
-        case GL_IS_PER_PATCH:
-            outValues.push_back(resource.isPerPatch);
-            break;
-        case GL_LOCATION_COMPONENT:
-            outValues.push_back(0);
-            break;
-        case GL_TRANSFORM_FEEDBACK_BUFFER_INDEX:
-            outValues.push_back(resource.xfbBufferIndex);
-            break;
-        default:
-            outValues.push_back(0);
-            break;
-        }
-        return true;
-    }
-
-    GLint GetResourceLocation(ProgramObject& program, GLenum programInterface, const char* name) {
-        if (name == nullptr || name[0] == '\0') return -1;
-        const String query = name;
-
-        String base;
-        Uint element = 0;
-        Bool malformed = false;
-        const Bool subscripted = SplitTrailingSubscript(query, base, element, malformed);
-        if (malformed) return -1;
-
-        const Model model = BuildModel(program);
-        const ResourceList& resources = Select(model, programInterface);
-        for (const Resource& resource : resources) {
-            if (NamesMatch(resource.name, query)) return resource.location;
-        }
-        if (!subscripted || element == 0) return -1;
-        // "d[1]" addresses the second element of an array resource enumerated as "d[0]".
-        for (const Resource& resource : resources) {
-            if (!NamesMatch(resource.name, base)) continue;
-            if (resource.location < 0 || static_cast<GLint>(element) >= resource.arraySize) return -1;
-            return resource.location + static_cast<GLint>(element);
-        }
-        return -1;
-    }
-
-    GLint GetResourceLocationIndex(ProgramObject& program, GLenum programInterface, const char* name) {
-        if (programInterface != GL_PROGRAM_OUTPUT || name == nullptr || name[0] == '\0') return -1;
-        const String query = name;
-        String base;
-        Uint element = 0;
-        Bool malformed = false;
-        const Bool subscripted = SplitTrailingSubscript(query, base, element, malformed);
-        if (malformed) return -1;
-
-        const Model model = BuildModel(program);
-        for (const Resource& resource : model.programOutputs) {
-            if (NamesMatch(resource.name, query)) return resource.locationIndex;
-        }
-        if (!subscripted) return -1;
-        for (const Resource& resource : model.programOutputs) {
-            if (!NamesMatch(resource.name, base)) continue;
-            if (resource.location < 0 || static_cast<GLint>(element) >= resource.arraySize) return -1;
-            return resource.locationIndex;
-        }
-        return -1;
-    }
-} // namespace MobileGL::MG_Impl::GLImpl::ProgramInterface

MobileGL/MG_Impl/GLImpl/Program/ProgramInterface.h

@@ -1,66 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/GLImpl/Program/ProgramInterface.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>
-
-namespace MobileGL::MG_State::GLState {
-    class ProgramObject;
-}
-
-// The GL program interface (ARB_program_interface_query / GL 4.3 §7.3.1) as a frontend
-// resource model.
-//
-// WHY IT IS HERE AND NOT IN A BACKEND. glGetProgramResource* describes the program the
-// APPLICATION wrote, in the application's namespace. Neither backend program is in that
-// namespace: DirectGLES compiles SPIRV-Cross-generated ESSL where default-block uniforms
-// live inside the synthesized MGL_GLOBAL_UBO (so a GL_UNIFORM location query against it is
-// structurally -1) and stage in/out names are rewritten; DirectVulkan has no GL-level
-// reflection at all and can only re-derive a partial, diverging copy. The one authoritative
-// source is the frontend glslang reflection a link already produced, which is the same
-// place glGetActiveUniform answers from. This layer generalizes that rule to every
-// interface, so the six entry points never consult gBackendFunctionsTable.
-//
-// NAMING RULES LIVE HERE, NOT IN ProgramObject. The interface query spells resources
-// differently from glGetActiveUniform / glGetActiveAttrib (an array is "name[0]", a lookup
-// accepts both "name" and "name[0]", a subscript must be a strict decimal). Those two
-// getters are what GL30-33 exercises and they must not move, so every normalization is
-// applied on the way in and out of THIS file.
-namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
-    using ProgramObject = MG_State::GLState::ProgramObject;
-
-    // <programInterface> is one of the GL 4.6 Table 7.1 interfaces.
-    Bool IsInterfaceEnum(GLenum programInterface);
-    // Interfaces whose resources have names (everything except GL_ATOMIC_COUNTER_BUFFER).
-    Bool IsNamedInterface(GLenum programInterface);
-    // <prop> is a property token GetProgramResourceiv knows at all (else GL_INVALID_ENUM).
-    Bool IsResourceProp(GLenum prop);
-    // <prop> applies to <programInterface> (else GL_INVALID_OPERATION).
-    Bool InterfaceSupportsProp(GLenum programInterface, GLenum prop);
-    // Interfaces GetProgramResourceLocation accepts (else GL_INVALID_ENUM).
-    Bool InterfaceHasLocations(GLenum programInterface);
-
-    // GL_ACTIVE_RESOURCES / GL_MAX_NAME_LENGTH / GL_MAX_NUM_ACTIVE_VARIABLES. All three
-    // report zero for an interface this implementation cannot enumerate and for a program
-    // that has not linked successfully - which is what the spec requires of a program with
-    // no active resources.
-    Int GetActiveResourceCount(ProgramObject& program, GLenum programInterface);
-    Int GetMaxNameLength(ProgramObject& program, GLenum programInterface);
-    Int GetMaxNumActiveVariables(ProgramObject& program, GLenum programInterface);
-
-    // GL_INVALID_INDEX when <name> names no active resource of the interface.
-    GLuint GetResourceIndex(ProgramObject& program, GLenum programInterface, const char* name);
-    // False when <index> is out of range for the interface (the caller raises INVALID_VALUE).
-    Bool GetResourceName(ProgramObject& program, GLenum programInterface, GLuint index, String& outName);
-    // Appends the value(s) of <prop> for the resource; GL_ACTIVE_VARIABLES appends several.
-    // False when <index> is out of range.
-    Bool GetResourceProp(ProgramObject& program, GLenum programInterface, GLuint index, GLenum prop,
-                         Vector<GLint>& outValues);
-    GLint GetResourceLocation(ProgramObject& program, GLenum programInterface, const char* name);
-    GLint GetResourceLocationIndex(ProgramObject& program, GLenum programInterface, const char* name);
-} // namespace MobileGL::MG_Impl::GLImpl::ProgramInterface

MobileGL/MG_Impl/GLImpl/Query/GL_Query.cpp

@@ -62,34 +62,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                                               MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", function, message));
         }
 
-        // The by-buffer query getters write the result into a buffer object instead of client
-        // memory. Everything about the query itself - the name, whether it is still active, the
-        // parameter - is checked by GetQueryObjectValue; what is left is the destination, so this
-        // resolves the buffer and confirms the write lands inside it (GL 4.6 core 4.2.1).
-        Bool ResolveQueryResultDestination(GLuint buffer, GLintptr offset, SizeT writeSize, const char* function,
-                                           SharedPtr<MG_State::GLState::BufferObject>& outBuffer) {
-            if (offset < 0) {
-                RecordQueryError(ErrorCode::InvalidValue, function, "Offset cannot be negative.");
-                return false;
-            }
-            if (!MG_State::pGLContext->ValidateBufferObject(buffer)) {
-                RecordQueryError(ErrorCode::InvalidOperation, function, "Buffer object does not exist.");
-                return false;
-            }
-            auto bufferObject = MG_State::pGLContext->GetBufferObject(buffer);
-            if (!bufferObject) {
-                RecordQueryError(ErrorCode::InvalidOperation, function, "Buffer object does not exist.");
-                return false;
-            }
-            if (static_cast<SizeT>(offset) + writeSize > bufferObject->GetSize()) {
-                RecordQueryError(ErrorCode::InvalidOperation, function,
-                                 "The query result does not fit in the buffer object at this offset.");
-                return false;
-            }
-            outBuffer = bufferObject;
-            return true;
-        }
-
         // Callers must hold g_queryObjectsMutex.
         QueryObject* FindQueryObjectLocked(GLuint id) {
             const auto it = g_liveQueryObjects.find(id);
@@ -123,13 +95,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
 
         // Shared GetQueryObject* implementation. Returns false when an error
-        // was recorded and no value should be written back. `outValueProduced`, when given,
-        // additionally distinguishes "succeeded with a value" from "succeeded but the result is not
-        // ready" - the GL_QUERY_RESULT_NO_WAIT case, where GL_ARB_query_buffer_object says the
-        // destination is left alone rather than written with a placeholder.
-        Bool GetQueryObjectValue(GLuint id, GLenum pname, const char* function, Uint64& outValue,
-                                 Bool* outValueProduced = nullptr) {
-            if (outValueProduced) *outValueProduced = true;
+        // was recorded and no value should be written back.
+        Bool GetQueryObjectValue(GLuint id, GLenum pname, const char* function, Uint64& outValue) {
             const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
             auto* queryObject = FindQueryObjectLocked(id);
             if (!queryObject) {
@@ -142,41 +109,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
 
             switch (pname) {
-            case GL_QUERY_TARGET:
-                // The target a query was begun with (or created with, for glCreateQueries) - state
-                // the object has carried all along, GL 4.6 core table 23.35.
-                outValue = queryObject->target;
-                return true;
-            case GL_QUERY_RESULT_NO_WAIT: {
-                if (queryObject->resultCached) {
-                    outValue = queryObject->cachedResult;
-                    return true;
-                }
-                Uint64 result = 0;
-                const auto getQueryResult64 = MG_Backend::gBackendFunctionsTable.GL.GetQueryResult64;
-                if (queryObject->backendHandle && getQueryResult64 &&
-                    !getQueryResult64(queryObject->backendHandle, /*wait=*/false, &result)) {
-                    // Not ready. The whole point of the no-wait form is that the caller's
-                    // destination keeps whatever it already held.
-                    if (outValueProduced) *outValueProduced = false;
-                    outValue = 0;
-                    return true;
-                }
-                if (queryObject->target == GL_ANY_SAMPLES_PASSED ||
-                    queryObject->target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
-                    result = result != 0 ? 1 : 0;
-                }
-                if (queryObject->backendHandle) {
-                    if (const auto deleteBackendQuery = MG_Backend::gBackendFunctionsTable.GL.DeleteBackendQuery) {
-                        deleteBackendQuery(queryObject->backendHandle);
-                    }
-                    queryObject->backendHandle = nullptr;
-                }
-                queryObject->cachedResult = result;
-                queryObject->resultCached = true;
-                outValue = result;
-                return true;
-            }
             case GL_QUERY_RESULT_AVAILABLE: {
                 if (queryObject->resultCached || !queryObject->backendHandle) {
                     outValue = 1;
@@ -228,21 +160,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                 return false;
             }
         }
-
-        template <typename T>
-        void GetQueryBufferObject(GLuint id, GLuint buffer, GLenum pname, GLintptr offset, const char* function) {
-            SharedPtr<MG_State::GLState::BufferObject> bufferObject;
-            if (!ResolveQueryResultDestination(buffer, offset, sizeof(T), function, bufferObject)) return;
-
-            Uint64 value = 0;
-            Bool valueProduced = false;
-            if (!GetQueryObjectValue(id, pname, function, value, &valueProduced)) return;
-            // GL_QUERY_RESULT_NO_WAIT on a result that has not landed writes nothing at all.
-            if (!valueProduced) return;
-
-            const T narrowed = static_cast<T>(value);
-            bufferObject->UploadSubData({const_cast<T*>(&narrowed), sizeof(T)}, static_cast<SizeT>(offset));
-        }
     } // namespace
 
     void GenQueries(GLsizei n, GLuint* ids) {
@@ -558,26 +475,9 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
     }
 
-    void GetQueryBufferObjectiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
-        GetQueryBufferObject<GLint>(id, buffer, pname, offset, __FUNCTION__);
-    }
-
-    void GetQueryBufferObjectuiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
-        GetQueryBufferObject<GLuint>(id, buffer, pname, offset, __FUNCTION__);
-    }
-
-    void GetQueryBufferObjecti64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
-        GetQueryBufferObject<GLint64>(id, buffer, pname, offset, __FUNCTION__);
-    }
-
-    void GetQueryBufferObjectui64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
-        GetQueryBufferObject<GLuint64>(id, buffer, pname, offset, __FUNCTION__);
-    }
-
     void GetQueryObjectiv(GLuint id, GLenum pname, GLint* params) {
         Uint64 value = 0;
-        Bool valueProduced = false;
-        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value, &valueProduced) || !valueProduced || !params) {
+        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value) || !params) {
             return;
         }
         constexpr Uint64 kMaxInt = static_cast<Uint64>(INT_MAX);
@@ -586,8 +486,7 @@ namespace MobileGL::MG_Impl::GLImpl {
 
     void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) {
         Uint64 value = 0;
-        Bool valueProduced = false;
-        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value, &valueProduced) || !valueProduced || !params) {
+        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value) || !params) {
             return;
         }
         *params = static_cast<GLuint>(value & 0xFFFFFFFFull);
@@ -595,8 +494,7 @@ namespace MobileGL::MG_Impl::GLImpl {
 
     void GetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) {
         Uint64 value = 0;
-        Bool valueProduced = false;
-        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value, &valueProduced) || !valueProduced || !params) {
+        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value) || !params) {
             return;
         }
         *params = static_cast<GLint64>(value);
@@ -604,8 +502,7 @@ namespace MobileGL::MG_Impl::GLImpl {
 
     void GetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) {
         Uint64 value = 0;
-        Bool valueProduced = false;
-        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value, &valueProduced) || !valueProduced || !params) {
+        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value) || !params) {
             return;
         }
         *params = static_cast<GLuint64>(value);

MobileGL/MG_Impl/GLImpl/Query/GL_Query.h

@@ -24,9 +24,5 @@ namespace MobileGL::MG_Impl::GLImpl {
     void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params);
     void GetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params);
     void GetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params);
-    void GetQueryBufferObjectiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
-    void GetQueryBufferObjectuiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
-    void GetQueryBufferObjecti64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
-    void GetQueryBufferObjectui64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
     void QueryCounter(GLuint id, GLenum target);
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Sampler/GL_Sampler.cpp

@@ -8,7 +8,6 @@
 
 #include "GL_Sampler.h"
 #include "Validators.h"
-#include "../Getter/GL_Getter.h"
 #include <MG_State/GLState/Core.h>
 #include <MG_Util/Converters/GLToMG/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToGL/TextureEnumConverter.h>
@@ -29,11 +28,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             case GL_TEXTURE_MAX_LOD:
             case GL_TEXTURE_LOD_BIAS:
                 return true;
-            // Four components, and GL puts no range on them - a border colour outside [0,1] is
-            // clamped when a fixed-point format is sampled, not rejected here. The scalar readers
-            // below would look at one component and invent an error.
-            case GL_TEXTURE_BORDER_COLOR:
-                return true;
             case GL_TEXTURE_MAX_ANISOTROPY_EXT:
                 if (ReadSamplerScalar(param, isFloat, isUnsignedInteger) >= 1.0f) return true;
                 MG_State::pGLContext->RecordError(
@@ -105,20 +99,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_TEXTURE_COMPARE_FUNC:
             samplerObj->SetSamplerCompareFunc(MG_Util::ConvertGLEnumToSamplerCompareFunc(*(const GLint*)param));
             break;
-        case GL_TEXTURE_BORDER_COLOR:
-            // The only four-component sampler parameter: the caller's form decides which
-            // representation is authoritative, and SamplerObject keeps the other two in step.
-            if (isFloat) {
-                const auto* values = (const GLfloat*)param;
-                samplerObj->SetBorderColor(FloatVec4(values[0], values[1], values[2], values[3]));
-            } else if (isUnsignedInteger) {
-                const auto* values = (const GLuint*)param;
-                samplerObj->SetBorderColorUI(UintVec4(values[0], values[1], values[2], values[3]));
-            } else {
-                const auto* values = (const GLint*)param;
-                samplerObj->SetBorderColorI(IntVec4(values[0], values[1], values[2], values[3]));
-            }
-            break;
         default:
             MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
                                               MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "SetSamplerParam_State",
@@ -182,31 +162,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_TEXTURE_COMPARE_FUNC:
             *(GLuint*)params = MG_Util::ConvertSamplerCompareFuncToGLEnum(samplerObj->GetSamplerCompareFunc());
             break;
-        case GL_TEXTURE_BORDER_COLOR: {
-            if (isFloat) {
-                const auto& color = samplerObj->GetBorderColor();
-                auto* out = (GLfloat*)params;
-                out[0] = color.x();
-                out[1] = color.y();
-                out[2] = color.z();
-                out[3] = color.w();
-            } else if (isUnsignedInteger) {
-                const auto& color = samplerObj->GetBorderColorUI();
-                auto* out = (GLuint*)params;
-                out[0] = color.x();
-                out[1] = color.y();
-                out[2] = color.z();
-                out[3] = color.w();
-            } else {
-                const auto& color = samplerObj->GetBorderColorI();
-                auto* out = (GLint*)params;
-                out[0] = color.x();
-                out[1] = color.y();
-                out[2] = color.z();
-                out[3] = color.w();
-            }
-            break;
-        }
         default:
             MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
                                               MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetSamplerParam_State",
@@ -269,20 +224,9 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
     }
 
-    // The number of texture units a sampler may be bound to. GL 3.3 core 3.8.2 names
-    // GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, which is what the backend advertises; the frontend's
-    // MAX_TEXTURE_IMAGE_UNITS is only the capacity of the unit array, so it is a clamp on the
-    // answer and never the answer itself - gating on it alone accepts every unit up to 192 no
-    // matter what the driver reports.
-    static GLint GetSamplerBindableTextureUnitCount() {
-        GLint maxTextureUnits = 0;
-        GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
-        return std::min<GLint>(std::max(maxTextureUnits, 0), MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS);
-    }
-
     void BindSampler_State(GLuint unit, GLuint sampler) {
         MGLOG_D("BindSampler_State: unit = %u, sampler = %u", unit, sampler);
-        if (static_cast<Uint64>(unit) >= static_cast<Uint64>(GetSamplerBindableTextureUnitCount())) {
+        if (unit >= MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
                 MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BindSampler", "texture unit out of range"));
@@ -321,20 +265,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                 MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BindSamplers", "count must be non-negative"));
             return;
         }
-        // ARB_multi_bind: the whole [first, first + count) range is checked up front and a
-        // range that runs past the last texture unit is INVALID_OPERATION - not the
-        // INVALID_VALUE the single-bind BindSampler_State reports per element, and nothing is
-        // bound when it fails. Both gates read the same limit (see
-        // GetSamplerBindableTextureUnitCount), so an out-of-range multi-bind can no longer slip
-        // past this check and be caught one element at a time with the wrong error class.
-        const GLint maxTextureUnits = GetSamplerBindableTextureUnitCount();
-        if (static_cast<Uint64>(first) + static_cast<Uint64>(count) > static_cast<Uint64>(maxTextureUnits)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BindSamplers",
-                                             "first + count exceeds the number of texture units."));
-            return;
-        }
 
         for (GLsizei i = 0; i < count; ++i) {
             BindSampler_State(first + i, samplers ? samplers[i] : 0);

MobileGL/MG_Impl/GLImpl/Sampler/Validators.cpp

@@ -75,11 +75,7 @@ namespace MobileGL::MG_Impl::GLImpl::SamplerImpl {
             break;
 
         case GL_TEXTURE_COMPARE_FUNC:
-            // The eight depth-compare functions are contiguous from GL_NEVER (0x0200) to
-            // GL_ALWAYS (0x0207); GL_LEQUAL sits in the middle of that block, so starting
-            // the range there rejected NEVER/LESS/EQUAL and let GREATER/NOTEQUAL/GEQUAL
-            // through only by accident of them being above LEQUAL.
-            if (param < GL_NEVER || param > GL_ALWAYS) {
+            if (param < GL_LEQUAL || param > GL_ALWAYS) {
                 MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
                                                   MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerParam",
                                                                                "Invalid compare function parameter"));

MobileGL/MG_Impl/GLImpl/Texture/GL_Texture.h

@@ -11,10 +11,6 @@
 
 namespace MobileGL::MG_Impl::GLImpl {
     /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
-    // The sized internal formats a buffer texture accepts (GL 4.6 core table 8.16). The buffer
-    // clears take the same list, so it is shared rather than written out twice.
-    Bool IsBufferTextureInternalFormat(GLenum internalformat);
-
     void ClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void* data);
     void ClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width,
                           GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* data);
@@ -46,7 +42,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     void GenerateTextureMipmap(GLuint texture);
     void BindTextureUnit(GLuint unit, GLuint texture);
     void GetTextureImage(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* pixels);
-    void GetCompressedTextureImage(GLuint texture, GLint level, GLsizei bufSize, void* pixels);
     void TexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
     void TextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer);
     void TextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
@@ -106,9 +101,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                            GLsizei width, GLsizei height);
     void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
                            GLsizei height);
-    void CopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void CopyTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x,
-                               GLint y, GLsizei width, GLsizei height);
     void CopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
                                GLsizei width, GLsizei height);
     void CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);

MobileGL/MG_Impl/GLImpl/Texture/Validators.cpp

@@ -226,9 +226,6 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
             case TextureInternalFormat::Depth24Stencil8:
             case TextureInternalFormat::Depth32FStencil8:
             case TextureInternalFormat::DepthStencil:
-            // Stencil-only is not a colour format either: a colour client format read against a
-            // STENCIL_INDEX8 texture has to be the same INVALID_OPERATION as against a depth one.
-            case TextureInternalFormat::StencilIndex8:
                 return true;
             default:
                 return false;
@@ -353,7 +350,7 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
         return true;
     }
 
-    Bool ValidateTextureObject(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject) {
+    Bool ValidateTextureObject(SharedPtr<MG_State::GLState::ITextureObject> textureObject) {
         if (!textureObject) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
@@ -376,7 +373,7 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
         return true;
     }
 
-    Bool ValidateTextureTargetUniformity(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject,
+    Bool ValidateTextureTargetUniformity(SharedPtr<MG_State::GLState::ITextureObject> textureObject,
                                          TextureTarget target) {
         if (!textureObject) return true; // should be created later
         TextureTarget prevTarget = textureObject->GetTarget();
@@ -390,7 +387,7 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
         return true;
     }
 
-    Bool ValidateTextureSubImageOffsets(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject, Int xoffset,
+    Bool ValidateTextureSubImageOffsets(SharedPtr<MG_State::GLState::ITextureObject> textureObject, Int xoffset,
                                         Int width, Int yoffset, Int height, Int zoffset, Int depth) {
         auto baseSize = textureObject->GetBaseSize();
         if (xoffset < 0 || (xoffset + width) > baseSize.x()) {

MobileGL/MG_Impl/GLImpl/Texture/Validators.h

@@ -30,15 +30,15 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
                                                           TextureInternalFormat internalFormat,
                                                           TexturePixelDataType type);
     Bool ValidateTextureLevelWithUploadTarget(TextureUploadTarget target, Int level);
-    Bool ValidateTextureObject(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject);
+    Bool ValidateTextureObject(SharedPtr<MG_State::GLState::ITextureObject> textureObject);
     // Rejects the per-target default texture objects (name 0) with GL_INVALID_OPERATION for entry
     // points that require a GenTextures-created texture, e.g. TexStorage* ("An INVALID_OPERATION
     // error is generated if zero is bound to target", ARB_texture_storage).
     Bool ValidateTextureNotDefault(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject,
                                    const char* caller);
-    Bool ValidateTextureTargetUniformity(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject,
+    Bool ValidateTextureTargetUniformity(SharedPtr<MG_State::GLState::ITextureObject> textureObject,
                                          TextureTarget target);
-    Bool ValidateTextureSubImageOffsets(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject, Int xoffset,
+    Bool ValidateTextureSubImageOffsets(SharedPtr<MG_State::GLState::ITextureObject> textureObject, Int xoffset,
                                         Int width, Int yoffset = 0, Int height = 0, Int zoffset = 0, Int depth = 0);
     Bool ValidateBaseInternalFormatMatch(TextureInternalFormat format1, TextureInternalFormat format2);
 } // namespace MobileGL::MG_Impl::GLImpl::TextureImpl

MobileGL/MG_Impl/GLImpl/VertexArray/GL_VertexArray.cpp

@@ -8,7 +8,6 @@
 
 #include "GL_VertexArray.h"
 #include "Validators.h"
-#include <MG_Backend/BackendObjects.h>
 #include <MG_Impl/GLImpl/Buffer/Validators.h>
 #include <MG_State/GLState/Core.h>
 #include <MG_State/GLState/ErrorState/Error.h>
@@ -106,21 +105,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return pname == GL_CURRENT_VERTEX_ATTRIB;
         }
 
-        // The two ARB_vertex_attrib_binding per-attribute queries. They do not live on the
-        // resolved VertexAttribute (which is the flat, already-combined view) but on the VAO's
-        // binding-point mapping, so they need the object, not the attribute.
-        static bool TryGetVertexAttribBindingQuery(GLuint index, GLenum pname, GLint& out) {
-            if (pname != GL_VERTEX_ATTRIB_BINDING && pname != GL_VERTEX_ATTRIB_RELATIVE_OFFSET) return false;
-            const auto& vao = MG_State::pGLContext->GetBoundVertexArray();
-            if (!vao) {
-                out = 0;
-                return true;
-            }
-            out = pname == GL_VERTEX_ATTRIB_BINDING ? static_cast<GLint>(vao->GetAttributeBindingIndex(index))
-                                                    : static_cast<GLint>(vao->GetAttributeRelativeOffset(index));
-            return true;
-        }
-
         // The stride a pointer-style call gives its binding point: the argument when it is non-zero,
         // otherwise the tightly packed element size (GL 4.6 core 10.3.2). A packed 2_10_10_10 or
         // 10F_11F_11F attribute is one 32-bit word regardless of its component count.
@@ -189,16 +173,8 @@ namespace MobileGL::MG_Impl::GLImpl {
             case GL_CURRENT_VERTEX_ATTRIB:
             case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
             case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
-            // Core since GL 4.1 (ARB_vertex_attrib_64bit). It was rejected while no attribute could
-            // ever be long; now that IsLong is real state the pname has to be accepted.
-            case GL_VERTEX_ATTRIB_ARRAY_LONG:
             case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
             case GL_VERTEX_ATTRIB_ARRAY_POINTER:
-            // ARB_vertex_attrib_binding (core since GL 4.3). The binding-point view is real
-            // state on the VAO (GetAttributeBindingIndex / GetAttributeRelativeOffset), so
-            // both of its per-attribute queries are answerable.
-            case GL_VERTEX_ATTRIB_BINDING:
-            case GL_VERTEX_ATTRIB_RELATIVE_OFFSET:
                 return true;
             default:
                 MG_State::pGLContext->RecordError(
@@ -484,38 +460,19 @@ namespace MobileGL::MG_Impl::GLImpl {
                                         relativeoffset, isBgra);
     }
 
-    // The long (64-bit) attribute format: the values reach the shader as doubles, unconverted
-    // (GL 4.6 core 10.3.2). ValidateVertexAttribLFormat has already pinned type to GL_DOUBLE, so the
-    // recorded DataType is always Float64 - what IsLong adds is that this is the *unconverted* form,
-    // as opposed to VertexAttribFormat(GL_DOUBLE), which asks for a float conversion.
-    //
-    // Whether the backend can feed it is detected, not assumed: DirectVulkan needs shaderFloat64,
-    // and DirectGLES can never have it at all. A backend without it declines here, loudly - GL error
-    // plus a log line naming the reason - rather than accepting state no draw could honour and
-    // rendering garbage. The matching startup POST row is in MG_Util/SelfTest/DriverPost.cpp.
-    static void VertexAttribLFormatSeparate_State(const SharedPtr<MG_State::GLState::VertexArrayObject>& vao,
-                                                  GLuint attribindex, GLint size, GLenum type,
+    // The long (64-bit) attribute format. MobileGL has no 64-bit vertex attributes, so nothing is
+    // recorded; what the entry point owes the application is the parameter validation, which is
+    // observable through glGetError regardless of whether the format could be used in a draw.
+    static void VertexAttribLFormatSeparate_State(GLuint attribindex, GLint size, GLenum type,
                                                   GLuint relativeoffset) {
         if (!VertexArrayImpl::ValidateVertexAttributeIndex(attribindex)) return;
         if (!VertexArrayImpl::ValidateVertexAttribLFormat(attribindex, size, type)) return;
         if (!VertexArrayImpl::ValidateVertexAttribRelativeOffset(relativeoffset)) return;
 
-        if (!MG_Backend::pActiveBackendObject ||
-            !MG_Backend::pActiveBackendObject->GetDynamicParameters().SupportsFloat64VertexAttributes) {
-            MGLOG_I("VertexAttribLFormat: attribute %u asked for a 64-bit (GL_DOUBLE) format, but this "
-                    "backend has no double-precision vertex attribute support - see the "
-                    "\"64-bit vertex attributes\" / \"shaderFloat64\" POST row for what that costs",
-                    attribindex);
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "VertexAttribLFormat",
-                                             "64-bit vertex attributes are not supported by this backend."));
-            return;
-        }
-
-        vao->SetAttributeFormatSeparate(attribindex, size, MG_Util::ConvertGLEnumToDataType(type),
-                                        /*normalized: */ false, /*isInteger: */ false, relativeoffset,
-                                        /*isBgra: */ false, /*isLong: */ true);
+        MG_State::pGLContext->RecordError(
+            ErrorCode::InvalidOperation,
+            MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "VertexAttribLFormat",
+                                         "64-bit vertex attributes are not supported."));
     }
 
     void VertexArrayAttribFormat_State(GLuint vaobj, GLuint attribindex, GLint size, GLenum type,
@@ -958,19 +915,9 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
             params[0] = attr->IsInteger ? 1.0f : 0.0f;
             return;
-        case GL_VERTEX_ATTRIB_ARRAY_LONG:
-            params[0] = attr->IsLong ? 1.0f : 0.0f;
-            return;
         case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
             params[0] = static_cast<GLfloat>(attr->Divisor);
             return;
-        case GL_VERTEX_ATTRIB_BINDING:
-        case GL_VERTEX_ATTRIB_RELATIVE_OFFSET: {
-            GLint value = 0;
-            TryGetVertexAttribBindingQuery(index, pname, value);
-            params[0] = static_cast<GLfloat>(value);
-            return;
-        }
         default:
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
@@ -1028,19 +975,9 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
             params[0] = attr->IsInteger ? 1.0 : 0.0;
             return;
-        case GL_VERTEX_ATTRIB_ARRAY_LONG:
-            params[0] = attr->IsLong ? 1.0 : 0.0;
-            return;
         case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
             params[0] = static_cast<GLdouble>(attr->Divisor);
             return;
-        case GL_VERTEX_ATTRIB_BINDING:
-        case GL_VERTEX_ATTRIB_RELATIVE_OFFSET: {
-            GLint value = 0;
-            TryGetVertexAttribBindingQuery(index, pname, value);
-            params[0] = static_cast<GLdouble>(value);
-            return;
-        }
         default:
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
@@ -1094,16 +1031,9 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
             params[0] = attr->IsInteger ? GL_TRUE : GL_FALSE;
             return;
-        case GL_VERTEX_ATTRIB_ARRAY_LONG:
-            params[0] = attr->IsLong ? GL_TRUE : GL_FALSE;
-            return;
         case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
             params[0] = static_cast<GLint>(attr->Divisor);
             return;
-        case GL_VERTEX_ATTRIB_BINDING:
-        case GL_VERTEX_ATTRIB_RELATIVE_OFFSET:
-            TryGetVertexAttribBindingQuery(index, pname, params[0]);
-            return;
         default:
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
@@ -1234,7 +1164,8 @@ namespace MobileGL::MG_Impl::GLImpl {
             *param = attr.IsInteger ? GL_TRUE : GL_FALSE;
             return;
         case GL_VERTEX_ATTRIB_ARRAY_LONG:
-            *param = attr.IsLong ? GL_TRUE : GL_FALSE;
+            // 64-bit attributes are not supported, so no attribute is ever a long one.
+            *param = GL_FALSE;
             return;
         case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
             *param = static_cast<GLint>(attr.Divisor);
@@ -1242,9 +1173,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_VERTEX_ATTRIB_RELATIVE_OFFSET:
             *param = static_cast<GLint>(vao->GetAttributeRelativeOffset(index));
             return;
-        case GL_VERTEX_ATTRIB_BINDING:
-            *param = static_cast<GLint>(vao->GetAttributeBindingIndex(index));
-            return;
         default:
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
@@ -1331,13 +1259,13 @@ namespace MobileGL::MG_Impl::GLImpl {
     void VertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) {
         auto vao = GetBoundVertexArrayOrError("VertexAttribLFormat");
         if (!vao) return;
-        VertexAttribLFormatSeparate_State(vao, attribindex, size, type, relativeoffset);
+        VertexAttribLFormatSeparate_State(attribindex, size, type, relativeoffset);
     }
 
     void VertexArrayAttribLFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) {
         auto vao = GetNamedVertexArrayObject_State(vaobj, "VertexArrayAttribLFormat");
         if (!vao) return;
-        VertexAttribLFormatSeparate_State(vao, attribindex, size, type, relativeoffset);
+        VertexAttribLFormatSeparate_State(attribindex, size, type, relativeoffset);
     }
 
     void VertexAttribBinding(GLuint attribindex, GLuint bindingindex) {

MobileGL/MG_Impl/GLImpl/VertexArray/Validators.cpp

@@ -147,30 +147,6 @@ namespace MobileGL::MG_Impl::GLImpl::VertexArrayImpl {
             return false;
         }
 
-        // The integer path takes exactly the six signed/unsigned integer types (GL 4.6
-        // core 10.3.2): BYTE, UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT.
-        // A blacklist could not express that: GL_FLOAT, GL_HALF_FLOAT,
-        // GL_DOUBLE and GL_FIXED all convert to a perfectly valid DataType, so they slipped
-        // through and were recorded as integer attributes.
-        if (integerPath) {
-            switch (type) {
-            case DataType::Int8:
-            case DataType::Uint8:
-            case DataType::Int16:
-            case DataType::Uint16:
-            case DataType::Int32:
-            case DataType::Uint32:
-                break;
-            default:
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", fn,
-                        std::format("Type is not an integer vertex attribute type (attribute {}).", index)));
-                return false;
-            }
-        }
-
         if (sizeRaw == static_cast<GLint>(GL_BGRA)) {
             // GL_BGRA is a float-path-only size: it needs GL_UNSIGNED_BYTE or a 2_10_10_10 type and
             // normalized == GL_TRUE. On the integer path it is simply an out-of-range size.

MobileGL/MG_Impl/GLXImpl/Exporting/Definitions.cpp

@@ -15,257 +15,4 @@ MOBILEGL_GLX_API void* glXGetProcAddress(const char* name) {
 
 MOBILEGL_GLX_API void* glXGetProcAddressARB(const char* name) {
     return MG_Impl::GLXImpl::GetProcAddressARB(name);
-}
-
-#if defined(__linux__) && !defined(__ANDROID__)
-#include "../GLXImpl.h"
-
-namespace GLXImpl = MobileGL::MG_Impl::GLXImpl;
-
-// GLX handle/type spellings from GL/glx.h, expressed without including it:
-// GLXContext/GLXFBConfig are opaque pointers, drawables are XIDs, Bool is int,
-// and XVisualInfo* crosses as void*.
-
-MOBILEGL_GLX_API int glXQueryExtension(Display* dpy, int* errorBase, int* eventBase) {
-    return GLXImpl::QueryExtension(dpy, errorBase, eventBase);
-}
-
-MOBILEGL_GLX_API int glXQueryVersion(Display* dpy, int* major, int* minor) {
-    return GLXImpl::QueryVersion(dpy, major, minor);
-}
-
-MOBILEGL_GLX_API const char* glXQueryExtensionsString(Display* dpy, int screen) {
-    return GLXImpl::QueryExtensionsString(dpy, screen);
-}
-
-MOBILEGL_GLX_API const char* glXGetClientString(Display* dpy, int name) {
-    return GLXImpl::GetClientString(dpy, name);
-}
-
-MOBILEGL_GLX_API const char* glXQueryServerString(Display* dpy, int screen, int name) {
-    return GLXImpl::QueryServerString(dpy, screen, name);
-}
-
-MOBILEGL_GLX_API void** glXGetFBConfigs(Display* dpy, int screen, int* nelements) {
-    return GLXImpl::GetFBConfigs(dpy, screen, nelements);
-}
-
-MOBILEGL_GLX_API void** glXChooseFBConfig(Display* dpy, int screen, const int* attribList,
-                                          int* nelements) {
-    return GLXImpl::ChooseFBConfig(dpy, screen, attribList, nelements);
-}
-
-MOBILEGL_GLX_API int glXGetFBConfigAttrib(Display* dpy, void* config, int attribute, int* value) {
-    return GLXImpl::GetFBConfigAttrib(dpy, config, attribute, value);
-}
-
-MOBILEGL_GLX_API void* glXGetVisualFromFBConfig(Display* dpy, void* config) {
-    return GLXImpl::GetVisualFromFBConfig(dpy, config);
-}
-
-MOBILEGL_GLX_API void* glXChooseVisual(Display* dpy, int screen, int* attribList) {
-    return GLXImpl::ChooseVisual(dpy, screen, attribList);
-}
-
-MOBILEGL_GLX_API int glXGetConfig(Display* dpy, void* visualInfo, int attribute, int* value) {
-    return GLXImpl::GetConfig(dpy, visualInfo, attribute, value);
-}
-
-MOBILEGL_GLX_API void* glXCreateContext(Display* dpy, void* visualInfo, void* shareList, int direct) {
-    return GLXImpl::CreateContext(dpy, visualInfo, shareList, direct);
-}
-
-MOBILEGL_GLX_API void* glXCreateNewContext(Display* dpy, void* config, int renderType,
-                                           void* shareList, int direct) {
-    return GLXImpl::CreateNewContext(dpy, config, renderType, shareList, direct);
-}
-
-MOBILEGL_GLX_API void* glXCreateContextAttribsARB(Display* dpy, void* config, void* shareContext,
-                                                  int direct, const int* attribList) {
-    return GLXImpl::CreateContextAttribsARB(dpy, config, shareContext, direct, attribList);
-}
-
-MOBILEGL_GLX_API void glXDestroyContext(Display* dpy, void* context) {
-    GLXImpl::DestroyContext(dpy, context);
-}
-
-MOBILEGL_GLX_API int glXMakeCurrent(Display* dpy, unsigned long drawable, void* context) {
-    return GLXImpl::MakeCurrent(dpy, drawable, context);
-}
-
-MOBILEGL_GLX_API int glXMakeContextCurrent(Display* dpy, unsigned long draw, unsigned long read,
-                                           void* context) {
-    return GLXImpl::MakeContextCurrent(dpy, draw, read, context);
-}
-
-MOBILEGL_GLX_API void glXSwapBuffers(Display* dpy, unsigned long drawable) {
-    GLXImpl::SwapBuffers(dpy, drawable);
-}
-
-MOBILEGL_GLX_API unsigned long glXCreateWindow(Display* dpy, void* config, unsigned long window,
-                                               const int* attribList) {
-    return GLXImpl::CreateWindow(dpy, config, window, attribList);
-}
-
-MOBILEGL_GLX_API void glXDestroyWindow(Display* dpy, unsigned long window) {
-    GLXImpl::DestroyWindow(dpy, window);
-}
-
-MOBILEGL_GLX_API void* glXGetCurrentContext() {
-    return GLXImpl::GetCurrentContext();
-}
-
-MOBILEGL_GLX_API unsigned long glXGetCurrentDrawable() {
-    return GLXImpl::GetCurrentDrawable();
-}
-
-MOBILEGL_GLX_API unsigned long glXGetCurrentReadDrawable() {
-    return GLXImpl::GetCurrentReadDrawable();
-}
-
-MOBILEGL_GLX_API Display* glXGetCurrentDisplay() {
-    return GLXImpl::GetCurrentDisplay();
-}
-
-MOBILEGL_GLX_API int glXIsDirect(Display* dpy, void* context) {
-    return GLXImpl::IsDirect(dpy, context);
-}
-
-MOBILEGL_GLX_API void glXWaitGL() {
-    GLXImpl::WaitGL();
-}
-
-MOBILEGL_GLX_API void glXWaitX() {
-    GLXImpl::WaitX();
-}
-
-MOBILEGL_GLX_API int glXQueryContext(Display* dpy, void* context, int attribute, int* value) {
-    return GLXImpl::QueryContext(dpy, context, attribute, value);
-}
-
-MOBILEGL_GLX_API void glXQueryDrawable(Display* dpy, unsigned long drawable, int attribute,
-                                       unsigned int* value) {
-    GLXImpl::QueryDrawable(dpy, drawable, attribute, value);
-}
-
-MOBILEGL_GLX_API void glXSwapIntervalEXT(Display* dpy, unsigned long drawable, int interval) {
-    GLXImpl::SwapIntervalEXT(dpy, drawable, interval);
-}
-
-MOBILEGL_GLX_API int glXSwapIntervalMESA(unsigned int interval) {
-    return GLXImpl::SwapIntervalMESA(interval);
-}
-
-MOBILEGL_GLX_API int glXGetSwapIntervalMESA() {
-    return GLXImpl::GetSwapIntervalMESA();
-}
-
-MOBILEGL_GLX_API int glXSwapIntervalSGI(int interval) {
-    return GLXImpl::SwapIntervalSGI(interval);
-}
-
-// Legacy entry points some loaders probe for; harmless no-op stubs.
-MOBILEGL_GLX_API void glXCopyContext(Display*, void*, void*, unsigned long) {
-    MGLOG_W("glx: glXCopyContext is not supported");
-}
-
-MOBILEGL_GLX_API unsigned long glXCreateGLXPixmap(Display*, void*, unsigned long) {
-    MGLOG_W("glx: glXCreateGLXPixmap is not supported");
-    return 0;
-}
-
-MOBILEGL_GLX_API void glXDestroyGLXPixmap(Display*, unsigned long) {}
-
-MOBILEGL_GLX_API unsigned long glXCreatePixmap(Display*, void*, unsigned long, const int*) {
-    MGLOG_W("glx: glXCreatePixmap is not supported");
-    return 0;
-}
-
-MOBILEGL_GLX_API void glXDestroyPixmap(Display*, unsigned long) {}
-
-MOBILEGL_GLX_API unsigned long glXCreatePbuffer(Display*, void*, const int*) {
-    MGLOG_W("glx: glXCreatePbuffer is not supported");
-    return 0;
-}
-
-MOBILEGL_GLX_API void glXDestroyPbuffer(Display*, unsigned long) {}
-
-MOBILEGL_GLX_API void glXUseXFont(unsigned long, int, int, int) {
-    MGLOG_W("glx: glXUseXFont is not supported");
-}
-
-MOBILEGL_GLX_API void glXSelectEvent(Display*, unsigned long, unsigned long) {}
-
-MOBILEGL_GLX_API void glXGetSelectedEvent(Display*, unsigned long, unsigned long* eventMask) {
-    if (eventMask) {
-        *eventMask = 0;
-    }
-}
-
-namespace MobileGL::MG_Impl::GLXImpl {
-    namespace {
-        struct GLXEntryPoint {
-            const char* Name;
-            void* Proc;
-        };
-
-        const GLXEntryPoint kGLXEntryPoints[] = {
-            {"glXChooseFBConfig", reinterpret_cast<void*>(glXChooseFBConfig)},
-            {"glXChooseVisual", reinterpret_cast<void*>(glXChooseVisual)},
-            {"glXCopyContext", reinterpret_cast<void*>(glXCopyContext)},
-            {"glXCreateContext", reinterpret_cast<void*>(glXCreateContext)},
-            {"glXCreateContextAttribsARB", reinterpret_cast<void*>(glXCreateContextAttribsARB)},
-            {"glXCreateGLXPixmap", reinterpret_cast<void*>(glXCreateGLXPixmap)},
-            {"glXCreateNewContext", reinterpret_cast<void*>(glXCreateNewContext)},
-            {"glXCreatePbuffer", reinterpret_cast<void*>(glXCreatePbuffer)},
-            {"glXCreatePixmap", reinterpret_cast<void*>(glXCreatePixmap)},
-            {"glXCreateWindow", reinterpret_cast<void*>(glXCreateWindow)},
-            {"glXDestroyContext", reinterpret_cast<void*>(glXDestroyContext)},
-            {"glXDestroyGLXPixmap", reinterpret_cast<void*>(glXDestroyGLXPixmap)},
-            {"glXDestroyPbuffer", reinterpret_cast<void*>(glXDestroyPbuffer)},
-            {"glXDestroyPixmap", reinterpret_cast<void*>(glXDestroyPixmap)},
-            {"glXDestroyWindow", reinterpret_cast<void*>(glXDestroyWindow)},
-            {"glXGetClientString", reinterpret_cast<void*>(glXGetClientString)},
-            {"glXGetConfig", reinterpret_cast<void*>(glXGetConfig)},
-            {"glXGetCurrentContext", reinterpret_cast<void*>(glXGetCurrentContext)},
-            {"glXGetCurrentDisplay", reinterpret_cast<void*>(glXGetCurrentDisplay)},
-            {"glXGetCurrentDrawable", reinterpret_cast<void*>(glXGetCurrentDrawable)},
-            {"glXGetCurrentReadDrawable", reinterpret_cast<void*>(glXGetCurrentReadDrawable)},
-            {"glXGetFBConfigAttrib", reinterpret_cast<void*>(glXGetFBConfigAttrib)},
-            {"glXGetFBConfigs", reinterpret_cast<void*>(glXGetFBConfigs)},
-            {"glXGetProcAddress", reinterpret_cast<void*>(glXGetProcAddress)},
-            {"glXGetProcAddressARB", reinterpret_cast<void*>(glXGetProcAddressARB)},
-            {"glXGetSelectedEvent", reinterpret_cast<void*>(glXGetSelectedEvent)},
-            {"glXGetSwapIntervalMESA", reinterpret_cast<void*>(glXGetSwapIntervalMESA)},
-            {"glXGetVisualFromFBConfig", reinterpret_cast<void*>(glXGetVisualFromFBConfig)},
-            {"glXIsDirect", reinterpret_cast<void*>(glXIsDirect)},
-            {"glXMakeContextCurrent", reinterpret_cast<void*>(glXMakeContextCurrent)},
-            {"glXMakeCurrent", reinterpret_cast<void*>(glXMakeCurrent)},
-            {"glXQueryContext", reinterpret_cast<void*>(glXQueryContext)},
-            {"glXQueryDrawable", reinterpret_cast<void*>(glXQueryDrawable)},
-            {"glXQueryExtension", reinterpret_cast<void*>(glXQueryExtension)},
-            {"glXQueryExtensionsString", reinterpret_cast<void*>(glXQueryExtensionsString)},
-            {"glXQueryServerString", reinterpret_cast<void*>(glXQueryServerString)},
-            {"glXQueryVersion", reinterpret_cast<void*>(glXQueryVersion)},
-            {"glXSelectEvent", reinterpret_cast<void*>(glXSelectEvent)},
-            {"glXSwapBuffers", reinterpret_cast<void*>(glXSwapBuffers)},
-            {"glXSwapIntervalEXT", reinterpret_cast<void*>(glXSwapIntervalEXT)},
-            {"glXSwapIntervalMESA", reinterpret_cast<void*>(glXSwapIntervalMESA)},
-            {"glXSwapIntervalSGI", reinterpret_cast<void*>(glXSwapIntervalSGI)},
-            {"glXUseXFont", reinterpret_cast<void*>(glXUseXFont)},
-            {"glXWaitGL", reinterpret_cast<void*>(glXWaitGL)},
-            {"glXWaitX", reinterpret_cast<void*>(glXWaitX)},
-        };
-    } // namespace
-
-    void* GetGLXEntryPoint(const char* name) {
-        for (const auto& entry : kGLXEntryPoints) {
-            if (std::strcmp(entry.Name, name) == 0) {
-                return entry.Proc;
-            }
-        }
-        return nullptr;
-    }
-} // namespace MobileGL::MG_Impl::GLXImpl
-
-#endif // __linux__ && !__ANDROID__
+}

MobileGL/MG_Impl/GLXImpl/GLXImpl.h

@@ -1,69 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/GLXImpl/GLXImpl.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(__linux__) && !defined(__ANDROID__)
-
-namespace MobileGL::MG_Impl::GLXImpl {
-    // GLX layered on MobileGL's own EGL, mirroring WGLImpl/CGLImpl. Handles are
-    // opaque to callers; XVisualInfo crosses the ABI as void* so this header
-    // needs no Xlib includes (Includes.h forward-declares Display/XID/Window).
-    using GLXFBConfigHandle = void*;
-    using GLXContextHandle = void*;
-    using GLXDrawableHandle = unsigned long; // XID
-
-    int QueryExtension(Display* dpy, int* errorBase, int* eventBase);
-    int QueryVersion(Display* dpy, int* major, int* minor);
-    const char* QueryExtensionsString(Display* dpy, int screen);
-    const char* GetClientString(Display* dpy, int name);
-    const char* QueryServerString(Display* dpy, int screen, int name);
-
-    GLXFBConfigHandle* GetFBConfigs(Display* dpy, int screen, int* nelements);
-    GLXFBConfigHandle* ChooseFBConfig(Display* dpy, int screen, const int* attribList, int* nelements);
-    int GetFBConfigAttrib(Display* dpy, GLXFBConfigHandle config, int attribute, int* value);
-    void* GetVisualFromFBConfig(Display* dpy, GLXFBConfigHandle config);
-    void* ChooseVisual(Display* dpy, int screen, int* attribList);
-    int GetConfig(Display* dpy, void* visualInfo, int attribute, int* value);
-
-    GLXContextHandle CreateContext(Display* dpy, void* visualInfo, GLXContextHandle share, int direct);
-    GLXContextHandle CreateNewContext(Display* dpy, GLXFBConfigHandle config, int renderType,
-                                      GLXContextHandle share, int direct);
-    GLXContextHandle CreateContextAttribsARB(Display* dpy, GLXFBConfigHandle config, GLXContextHandle share,
-                                             int direct, const int* attribList);
-    void DestroyContext(Display* dpy, GLXContextHandle context);
-    int MakeCurrent(Display* dpy, GLXDrawableHandle drawable, GLXContextHandle context);
-    int MakeContextCurrent(Display* dpy, GLXDrawableHandle draw, GLXDrawableHandle read,
-                           GLXContextHandle context);
-    void SwapBuffers(Display* dpy, GLXDrawableHandle drawable);
-
-    GLXDrawableHandle CreateWindow(Display* dpy, GLXFBConfigHandle config, GLXDrawableHandle window,
-                                   const int* attribList);
-    void DestroyWindow(Display* dpy, GLXDrawableHandle window);
-
-    GLXContextHandle GetCurrentContext();
-    GLXDrawableHandle GetCurrentDrawable();
-    GLXDrawableHandle GetCurrentReadDrawable();
-    Display* GetCurrentDisplay();
-    int IsDirect(Display* dpy, GLXContextHandle context);
-    void WaitGL();
-    void WaitX();
-    int QueryContext(Display* dpy, GLXContextHandle context, int attribute, int* value);
-    void QueryDrawable(Display* dpy, GLXDrawableHandle drawable, int attribute, unsigned int* value);
-
-    void SwapIntervalEXT(Display* dpy, GLXDrawableHandle drawable, int interval);
-    int SwapIntervalMESA(unsigned int interval);
-    int GetSwapIntervalMESA();
-    int SwapIntervalSGI(int interval);
-
-    // Name -> exported glX entry point (table lives with the exports).
-    void* GetGLXEntryPoint(const char* name);
-} // namespace MobileGL::MG_Impl::GLXImpl
-
-#endif // __linux__ && !__ANDROID__

MobileGL/MG_Impl/GLXImpl/LookUp/LookUp.cpp

@@ -8,27 +8,11 @@
 
 #include "LookUp.h"
 
-#if defined(__linux__) && !defined(__ANDROID__)
-#include "../GLXImpl.h"
-#endif
-
 namespace MG_Impl::GLXImpl {
+    // TODO: implement complete GLX functionality
+
     void* GetProcAddress(const char* name) {
-        if (!name) {
-            return nullptr;
-        }
         MGLOG_D("glXGetProcAddress(\"%s\")", name);
-#if defined(__linux__) && !defined(__ANDROID__)
-        if (name[0] == 'g' && name[1] == 'l' && name[2] == 'X') {
-            // glX entry points resolve from the GLX layer's own table; GL/EGL
-            // names fall through to the shared resolver below.
-            void* proc = MobileGL::MG_Impl::GLXImpl::GetGLXEntryPoint(name);
-            if (!proc) {
-                MGLOG_D("glXGetProcAddress: unknown glX entry point %s", name);
-            }
-            return proc;
-        }
-#endif
         void* proc = MobileGL::MG_Impl::GetProcAddress(name);
         if (!proc) {
             MGLOG_W("Failed to get function: %s", (const char*)name);
@@ -41,4 +25,4 @@ namespace MG_Impl::GLXImpl {
     void* GetProcAddressARB(const char* name) {
         return GetProcAddress(name);
     }
-} // namespace MG_Impl::GLXImpl
+} // namespace MG_Impl::GLXImpl

MobileGL/MG_IntegrationTest/CMakeLists.txt

@@ -1,270 +0,0 @@
-cmake_minimum_required(VERSION 3.24)
-
-# MobileGL headless GPU integration tests.
-#
-# These are not unit tests: each scenario brings up a real EGL context on a
-# pbuffer, renders real frames through a real backend and asserts on
-# glReadPixels output. They need a GPU, so the module is OFF by default
-# (MOBILEGL_BUILD_INTEGRATION_TEST) and every scenario skips cleanly - never
-# fails, never hangs - on a machine without one. "Cleanly" is not a hope: the
-# harness runs the whole bring-up in a forked child first, because MobileGL
-# ABORTS rather than returning an error on an unusable platform (HeadlessGL.cpp).
-#
-# A clean skip is also indistinguishable from a pass, so set
-# MOBILEGL_ITEST_REQUIRE_GPU wherever the machine is supposed to have a GPU.
-#
-# Backend selection is latched at initialization from MOBILEGL_BACKEND_TYPE, so
-# one process is one backend: the same binary is registered twice, once per
-# backend, under the `integration-gpu` label.
-
-message(STATUS "Generating build files for MobileGL Integration Test...")
-
-set(CMAKE_CXX_STANDARD 23)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-set(MGL_ITEST_ROOT ${CMAKE_CURRENT_LIST_DIR}/../..)
-
-# Only meaningful where MobileGL_s exists (i.e. not Android).
-if (NOT TARGET MobileGL_s)
-    message(STATUS "MobileGL_s is not available; skipping the integration test module")
-    return()
-endif()
-
-# MG_Test already pulls googletest in when MOBILEGL_BUILD_TEST is ON. Stand on
-# our own feet when it is not, so this module can be built by itself.
-if (NOT TARGET GTest::gtest)
-    include(FetchContent)
-    FetchContent_Declare(
-        googletest
-        GIT_REPOSITORY https://github.com/google/googletest.git
-        GIT_TAG        v1.17.0
-    )
-    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-    FetchContent_MakeAvailable(googletest)
-endif()
-
-add_executable(MobileGLIntegrationTest
-    Main.cpp
-    Harness/HeadlessGL.cpp
-    Scenarios/OrientationScenario.cpp
-    Scenarios/CrossFrameBufferScenario.cpp
-    Scenarios/ResidentIndexScenario.cpp
-    Scenarios/MultiDrawScenario.cpp
-    Scenarios/AsyncCompileScenario.cpp
-    Scenarios/XfbAfterClipDistanceScenario.cpp
-    Scenarios/ThreeChannelAttachmentScenario.cpp
-)
-
-target_include_directories(MobileGLIntegrationTest PRIVATE
-    ${MGL_ITEST_ROOT}/include
-    ${MGL_ITEST_ROOT}/MobileGL
-)
-
-# gtest, not gtest_main: Main.cpp installs the harness banner itself.
-target_link_libraries(MobileGLIntegrationTest PRIVATE
-    GTest::gtest
-    MobileGL_s
-)
-
-if (MSVC)
-    # Same reason as MG_Test/Backend/DirectVulkan: the GLES headers declare gl*
-    # as dllimport on Windows, so the in-library GL entry-point definitions only
-    # resolve if the whole static library is part of the link.
-    target_link_options(MobileGLIntegrationTest PRIVATE /WHOLEARCHIVE:MobileGL_s)
-endif()
-target_compile_definitions(MobileGLIntegrationTest PRIVATE -DNOMINMAX)
-
-# --- ctest wiring --------------------------------------------------------
-# A bare libEGL on a glvnd box resolves to whatever vendor comes first, which is
-# usually Mesa/llvmpipe - a software rasteriser silently replacing the GPU under
-# a GPU test. Pin the vendor/ICD json the same way MG_Benchmark's
-# run_driver_bench.sh does.
-#
-# Leaving these empty is not a neutral default, it is the failure mode: an
-# unpinned libEGL lands on llvmpipe and the suite goes green having tested a
-# software rasteriser. So they are DETECTED here rather than defaulted to empty,
-# and an empty result is a loud warning.
-#
-# mgl_itest_find_driver_json(<outVar> <description> <glob> [<glob>...])
-#   Picks the first json a real hardware vendor owns, in preference order, and
-#   never picks a software rasteriser (llvmpipe / lavapipe / swrast) - landing on
-#   one of those silently is the exact accident this pinning exists to prevent.
-function(mgl_itest_find_driver_json outVar)
-    set(candidates "")
-    foreach(pattern IN LISTS ARGN)
-        file(GLOB matches "${pattern}")
-        list(APPEND candidates ${matches})
-    endforeach()
-    list(SORT candidates)
-    # Vendors ship an i686 json beside the x86_64 one and it sorts first. Pinning
-    # the wrong word size is worse than not pinning at all - the loader finds no
-    # driver and the whole suite skips - so drop the mismatched ones outright.
-    if (CMAKE_SIZEOF_VOID_P EQUAL 8)
-        list(FILTER candidates EXCLUDE REGEX "i686|i386")
-    else()
-        list(FILTER candidates EXCLUDE REGEX "x86_64|aarch64")
-    endif()
-    set(software "")
-    foreach(vendor IN ITEMS nvidia amdgpu amd radeon intel_hasvk intel broadcom freedreno panfrost)
-        foreach(candidate IN LISTS candidates)
-            get_filename_component(leaf "${candidate}" NAME)
-            string(TOLOWER "${leaf}" leaf)
-            if (leaf MATCHES "${vendor}")
-                set(${outVar} "${candidate}" PARENT_SCOPE)
-                return()
-            endif()
-        endforeach()
-    endforeach()
-    # Nothing recognised as hardware. Report the first non-software entry if there
-    # is one; otherwise report nothing, so the warning below fires.
-    foreach(candidate IN LISTS candidates)
-        get_filename_component(leaf "${candidate}" NAME)
-        string(TOLOWER "${leaf}" leaf)
-        if (NOT leaf MATCHES "lvp|llvmpipe|lavapipe|swrast|softpipe")
-            set(${outVar} "${candidate}" PARENT_SCOPE)
-            return()
-        endif()
-        set(software "${candidate}")
-    endforeach()
-    set(${outVar} "" PARENT_SCOPE)
-endfunction()
-
-set(MGL_ITEST_DETECTED_EGL_VENDOR "")
-set(MGL_ITEST_DETECTED_VK_ICD "")
-if (UNIX AND NOT APPLE AND NOT ANDROID)
-    mgl_itest_find_driver_json(MGL_ITEST_DETECTED_EGL_VENDOR
-        "/usr/share/glvnd/egl_vendor.d/*.json"
-        "/etc/glvnd/egl_vendor.d/*.json")
-    mgl_itest_find_driver_json(MGL_ITEST_DETECTED_VK_ICD
-        "/usr/share/vulkan/icd.d/*.json"
-        "/etc/vulkan/icd.d/*.json")
-endif()
-
-set(MOBILEGL_ITEST_EGL_VENDOR "${MGL_ITEST_DETECTED_EGL_VENDOR}" CACHE FILEPATH
-    "glvnd EGL vendor json to pin for the integration tests (empty: leave the loader alone)")
-set(MOBILEGL_ITEST_VK_ICD "${MGL_ITEST_DETECTED_VK_ICD}" CACHE FILEPATH
-    "Vulkan ICD json to pin for the DirectVulkan integration tests (empty: leave the loader alone)")
-
-if (MOBILEGL_ITEST_EGL_VENDOR)
-    message(STATUS "Integration tests: pinning EGL vendor ${MOBILEGL_ITEST_EGL_VENDOR}")
-else()
-    message(WARNING
-        "Integration tests: no EGL vendor json found or configured (MOBILEGL_ITEST_EGL_VENDOR is empty). "
-        "An unpinned libEGL on a glvnd system resolves to whichever vendor comes first, which is usually "
-        "Mesa/llvmpipe - the scenarios would then go green against a software rasteriser instead of the GPU. "
-        "Set -DMOBILEGL_ITEST_EGL_VENDOR=/usr/share/glvnd/egl_vendor.d/<vendor>.json.")
-endif()
-if (MOBILEGL_ITEST_VK_ICD)
-    message(STATUS "Integration tests: pinning Vulkan ICD ${MOBILEGL_ITEST_VK_ICD}")
-else()
-    message(WARNING
-        "Integration tests: no Vulkan ICD json found or configured (MOBILEGL_ITEST_VK_ICD is empty). "
-        "DirectVulkan would then load whichever ICD the loader enumerates first, quite possibly lavapipe. "
-        "Set -DMOBILEGL_ITEST_VK_ICD=/usr/share/vulkan/icd.d/<vendor>.json.")
-endif()
-
-# Turns "no usable GPU" from a clean skip into a failure - see ScenarioFixture.h.
-# Without it the integration-gpu label is unfalsifiable: a run that skipped every
-# scenario and a run that passed every scenario are the same green in ctest.
-option(MOBILEGL_ITEST_REQUIRE_GPU
-    "Fail (rather than skip) the integration scenarios when the headless harness is unusable" OFF)
-
-# DirectGLES asks the system EGL for a pbuffer config, and on Mesa the default
-# platform is not X11 unless it is said out loud (run_driver_bench.sh sets the
-# same variable). Wrong platform here is not a soft failure: eglCreatePbuffer
-# fails and every scenario skips.
-if (UNIX AND NOT APPLE AND NOT ANDROID)
-    set(MOBILEGL_ITEST_EGL_PLATFORM "x11" CACHE STRING
-        "EGL_PLATFORM for the integration tests (empty: leave the loader alone)")
-else()
-    set(MOBILEGL_ITEST_EGL_PLATFORM "" CACHE STRING
-        "EGL_PLATFORM for the integration tests (empty: leave the loader alone)")
-endif()
-
-set(MGL_ITEST_COMMON_ENV "")
-if (MOBILEGL_ITEST_EGL_VENDOR)
-    list(APPEND MGL_ITEST_COMMON_ENV "__EGL_VENDOR_LIBRARY_FILENAMES=${MOBILEGL_ITEST_EGL_VENDOR}")
-endif()
-if (MOBILEGL_ITEST_EGL_PLATFORM)
-    list(APPEND MGL_ITEST_COMMON_ENV "EGL_PLATFORM=${MOBILEGL_ITEST_EGL_PLATFORM}")
-endif()
-if (MOBILEGL_ITEST_REQUIRE_GPU)
-    list(APPEND MGL_ITEST_COMMON_ENV "MOBILEGL_ITEST_REQUIRE_GPU=1")
-endif()
-
-set(MGL_ITEST_VULKAN_ENV ${MGL_ITEST_COMMON_ENV})
-if (MOBILEGL_ITEST_VK_ICD)
-    list(APPEND MGL_ITEST_VULKAN_ENV "VK_ICD_FILENAMES=${MOBILEGL_ITEST_VK_ICD}")
-endif()
-
-# The ENVIRONMENT test property is itself a `;`-list, and gtest_discover_tests
-# forwards PROPERTIES as a flat list - so a plain `;`-joined value arrives as
-# four separate arguments and everything after the first is silently read as
-# another property name. Escaping the separators keeps the whole thing one list
-# element until set_tests_properties expands it back. Without this only
-# MOBILEGL_BACKEND_TYPE reaches the test and the vendor/ICD pinning is lost.
-function(mgl_itest_join_environment outVar)
-    set(joined "")
-    foreach(entry IN LISTS ARGN)
-        if (joined)
-            string(APPEND joined "\\;${entry}")
-        else()
-            set(joined "${entry}")
-        endif()
-    endforeach()
-    set(${outVar} "${joined}" PARENT_SCOPE)
-endfunction()
-
-mgl_itest_join_environment(MGL_ITEST_GLES_ENVIRONMENT
-    "MOBILEGL_BACKEND_TYPE=DirectGLES" ${MGL_ITEST_COMMON_ENV})
-mgl_itest_join_environment(MGL_ITEST_VULKAN_ENVIRONMENT
-    "MOBILEGL_BACKEND_TYPE=DirectVulkan" ${MGL_ITEST_VULKAN_ENV})
-mgl_itest_join_environment(MGL_ITEST_VULKAN_ASYNC_ENVIRONMENT
-    "MOBILEGL_BACKEND_TYPE=DirectVulkan" "MOBILEGL_ASYNC_SHADER_COMPILE=1" ${MGL_ITEST_VULKAN_ENV})
-
-# TIMEOUT on every entry: a GPU test that wedges must fail the run, not hang it.
-set(MGL_ITEST_TIMEOUT 120)
-
-include(GoogleTest)
-
-# Discovery runs `--gtest_list_tests`, which does not construct the harness and
-# so needs no GPU. One registration per backend; TEST_PREFIX keeps the two sets
-# of ctest names apart.
-gtest_discover_tests(MobileGLIntegrationTest
-    TEST_PREFIX "DirectGLES."
-    DISCOVERY_TIMEOUT 30
-    PROPERTIES
-        LABELS integration-gpu
-        TIMEOUT ${MGL_ITEST_TIMEOUT}
-        ENVIRONMENT "${MGL_ITEST_GLES_ENVIRONMENT}"
-)
-
-gtest_discover_tests(MobileGLIntegrationTest
-    TEST_PREFIX "DirectVulkan."
-    DISCOVERY_TIMEOUT 30
-    PROPERTIES
-        LABELS integration-gpu
-        TIMEOUT ${MGL_ITEST_TIMEOUT}
-        ENVIRONMENT "${MGL_ITEST_VULKAN_ENVIRONMENT}"
-)
-
-# A third registration, of ONE scenario, with asynchronous shader compilation
-# pinned on. Not a second code path in the renderer: a second ALLOCATION pattern.
-# The async pipeline's job objects change which of the freed blocks the capture
-# phase is handed, and that is what decides whether the destroyed-VAO address is
-# reached at all - on the ablated (pre-fix) tree async=1 reproduced 3 runs out of
-# 3 where the ambient default reproduced 2 of 3. Pinning it here means the
-# high-signal configuration runs whatever the shipped default becomes, instead of
-# the suite quietly weakening the day that default flips. It must be process-wide
-# (the ENVIRONMENT property), not an in-process scope: the compile pool and its
-# threads are stood up at initialization, and their allocations are half the
-# point. DirectVulkan only - the memo this pins is DirectVulkan's.
-gtest_discover_tests(MobileGLIntegrationTest
-    TEST_PREFIX "DirectVulkan.AsyncCompile."
-    TEST_FILTER "XfbAfterClipDistanceScenario.*"
-    DISCOVERY_TIMEOUT 30
-    PROPERTIES
-        LABELS integration-gpu
-        TIMEOUT ${MGL_ITEST_TIMEOUT}
-        ENVIRONMENT "${MGL_ITEST_VULKAN_ASYNC_ENVIRONMENT}"
-)

MobileGL/MG_IntegrationTest/Harness/HeadlessGL.cpp

@@ -1,587 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Harness/HeadlessGL.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 "HeadlessGL.h"
-
-#include <algorithm>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <ostream>
-#include <sstream>
-
-// MobileGL's own headers, in the order MobileGL/Includes.h uses them: GL/gl.h
-// first, then glcorearb.h for the 3.x+ entry points. This binary links
-// MobileGL_s, so every gl*/egl* below binds to MobileGL's implementation, not
-// to a system loader.
-#ifdef GLAPI
-#undef GLAPI
-#endif
-#include <EGL/egl.h>
-#define GL_GLEXT_PROTOTYPES
-#include <GL/gl.h>
-#include <GL/glcorearb.h>
-#undef GL_GLEXT_PROTOTYPES
-
-// The pre-flight below runs the whole EGL bring-up in a forked child, which is
-// the only construction that is actually predictive here: MobileGL ABORTS
-// (MOBILEGL_ASSERT -> SIGTRAP) rather than returning an error on an unusable
-// platform, so nothing the parent can call in-process is allowed to be wrong.
-#if !defined(_WIN32) && !defined(__APPLE__) && __has_include(<sys/wait.h>)
-#define MGITEST_HAVE_FORK_PREFLIGHT 1
-#include <csignal>
-#include <ctime>
-#include <sys/resource.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-#else
-#define MGITEST_HAVE_FORK_PREFLIGHT 0
-#endif
-
-namespace MGITest {
-
-    namespace {
-        // Small enough that a readback is cheap, big enough that "top third" and
-        // "bottom third" are unambiguous. Non-square on purpose: a transposing
-        // bug cannot hide behind a square.
-        constexpr int kSurfaceWidth = 128;
-        constexpr int kSurfaceHeight = 96;
-
-        std::string EnvOr(const char* name, const char* fallback) {
-            const char* value = std::getenv(name);
-            return (value != nullptr && value[0] != '\0') ? std::string(value) : std::string(fallback);
-        }
-
-        // A skip reason is only useful if it says which call failed AND why, so
-        // every bring-up step reports the EGL error it left behind.
-        std::string WithEglError(const char* what) {
-            std::ostringstream out;
-            out << what << " (eglGetError=0x" << std::hex << eglGetError() << ")";
-            return out.str();
-        }
-
-        // The EGL objects one bring-up produces.
-        struct EglBringUp {
-            void* display = nullptr;
-            void* surface = nullptr;
-            void* context = nullptr;
-            std::string renderer;
-        };
-
-        // THE bring-up, in one function so the pre-flight child and the parent run
-        // literally the same sequence - a pre-flight that tests something narrower
-        // than what the parent will do is exactly the kind of "predictive" check
-        // that is not.
-        //
-        // Returns 0 on success, or the 1-based index of the step that failed, and
-        // fills outReason either way.
-        int RunEglBringUp(EglBringUp& out, std::string& outReason) {
-            EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-            if (display == EGL_NO_DISPLAY) {
-                outReason = WithEglError("eglGetDisplay(EGL_DEFAULT_DISPLAY) returned EGL_NO_DISPLAY");
-                return 1;
-            }
-            EGLint major = 0, minor = 0;
-            if (eglInitialize(display, &major, &minor) != EGL_TRUE) {
-                outReason = WithEglError("eglInitialize failed: no usable display/driver on this machine");
-                return 2;
-            }
-            if (eglBindAPI(EGL_OPENGL_API) != EGL_TRUE) {
-                outReason = WithEglError("eglBindAPI(EGL_OPENGL_API) failed");
-                return 3;
-            }
-
-            const EGLint configAttribs[] = {EGL_SURFACE_TYPE,
-                                            EGL_PBUFFER_BIT,
-                                            EGL_RED_SIZE,
-                                            8,
-                                            EGL_GREEN_SIZE,
-                                            8,
-                                            EGL_BLUE_SIZE,
-                                            8,
-                                            EGL_ALPHA_SIZE,
-                                            8,
-                                            EGL_DEPTH_SIZE,
-                                            24,
-                                            EGL_RENDERABLE_TYPE,
-                                            EGL_OPENGL_BIT,
-                                            EGL_NONE};
-            EGLConfig config = nullptr;
-            EGLint configCount = 0;
-            if (eglChooseConfig(display, configAttribs, &config, 1, &configCount) != EGL_TRUE || configCount < 1) {
-                outReason = WithEglError("eglChooseConfig found no pbuffer-capable RGBA8/D24 config");
-                return 4;
-            }
-
-            const EGLint contextAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 3, EGL_CONTEXT_MINOR_VERSION, 3, EGL_NONE};
-            EGLContext context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs);
-            if (context == EGL_NO_CONTEXT) {
-                context = eglCreateContext(display, config, EGL_NO_CONTEXT, nullptr);
-            }
-            if (context == EGL_NO_CONTEXT) {
-                outReason = WithEglError("eglCreateContext failed: no desktop-GL context available");
-                return 5;
-            }
-
-            const EGLint pbufferAttribs[] = {EGL_WIDTH, kSurfaceWidth, EGL_HEIGHT, kSurfaceHeight, EGL_NONE};
-            EGLSurface surface = eglCreatePbufferSurface(display, config, pbufferAttribs);
-            if (surface == EGL_NO_SURFACE) {
-                outReason = WithEglError("eglCreatePbufferSurface failed");
-                return 6;
-            }
-            // The step that brings the whole backend up (DirectVulkan creates its
-            // instance, device and surface in here) and therefore the step that
-            // aborts instead of returning an error on an unusable platform.
-            if (eglMakeCurrent(display, surface, surface, context) != EGL_TRUE) {
-                outReason = WithEglError("eglMakeCurrent failed");
-                return 7;
-            }
-
-            const GLubyte* renderer = glGetString(GL_RENDERER);
-            if (renderer == nullptr) {
-                outReason = "glGetString(GL_RENDERER) returned null after eglMakeCurrent";
-                return 8;
-            }
-
-            out.display = display;
-            out.surface = surface;
-            out.context = context;
-            out.renderer = reinterpret_cast<const char*>(renderer);
-            outReason.clear();
-            return 0;
-        }
-
-        // Platform pre-flight, and the reason this module can claim to skip
-        // cleanly rather than merely hope to.
-        //
-        // MobileGL does not return errors when the platform is unusable - it
-        // ABORTS. MOBILEGL_ASSERT raises SIGTRAP, and the DirectVulkan bring-up
-        // asserts its way through instance, physical-device and surface creation
-        // inside eglMakeCurrent. So there is no in-process question the harness
-        // can ask that is guaranteed to be survivable, and the old form (dlopen
-        // the Vulkan loader, count physical devices, look for
-        // VK_EXT_headless_surface) was a guess at the abort conditions rather
-        // than a test of them: it named three of the ways bring-up can die and
-        // was silent about every other one, including every DirectGLES one.
-        //
-        // What is actually predictive is to run the bring-up itself somewhere a
-        // SIGTRAP is a datum instead of a crash. fork() gives exactly that: the
-        // child performs the identical sequence and _exit(0)s on success, and
-        // ANY non-zero exit or ANY signal in the parent's waitpid() means "this
-        // platform is unusable" - whatever the reason, including reasons nobody
-        // has thought of. Only then does the parent do the real bring-up.
-        //
-        // Returns an empty string when the platform survived a full bring-up.
-        std::string PreflightBringUp() {
-#if !MGITEST_HAVE_FORK_PREFLIGHT
-            // No fork(): let the in-process bring-up speak for itself, which is
-            // what this module did before. Windows/macOS are not CI targets for
-            // the headless scenarios.
-            return {};
-#else
-            int channel[2] = {-1, -1};
-            if (pipe(channel) != 0) {
-                return {}; // cannot pre-flight; fall through to the in-process attempt
-            }
-            // The child inherits our stdio buffers; flush so nothing is printed twice.
-            std::fflush(nullptr);
-            const pid_t child = fork();
-            if (child < 0) {
-                close(channel[0]);
-                close(channel[1]);
-                return {};
-            }
-            if (child == 0) {
-                close(channel[0]);
-                // The child is EXPECTED to die on a signal on an unusable
-                // platform; that is the measurement. Do not let each such
-                // measurement drop a core file next to the test binary.
-                const rlimit noCore{0, 0};
-                setrlimit(RLIMIT_CORE, &noCore);
-                std::fprintf(stderr, "[itest] pre-flight child: attempting a full EGL bring-up\n");
-                EglBringUp local;
-                std::string reason;
-                const int step = RunEglBringUp(local, reason);
-                if (!reason.empty()) {
-                    const std::size_t bytes = std::min<std::size_t>(reason.size(), 480);
-                    const ssize_t written = write(channel[1], reason.data(), bytes);
-                    (void)written;
-                }
-                close(channel[1]);
-                // _exit, never exit(): every atexit handler and static destructor
-                // in this address space belongs to the parent's copy of the world,
-                // and the child is holding a live context it must not tear down.
-                _exit(step);
-            }
-
-            close(channel[1]);
-            // Reap first, read after: the message is bounded well below the pipe
-            // buffer so the child can never block writing it, and polling the exit
-            // status is what lets a wedged child be killed instead of hanging the
-            // parent on a read that will never return.
-            constexpr int kPreflightTimeoutMs = 30000;
-            int status = 0;
-            int waitedMs = 0;
-            for (;;) {
-                const pid_t reaped = waitpid(child, &status, WNOHANG);
-                if (reaped == child) break;
-                if (reaped < 0) {
-                    close(channel[0]);
-                    return "waitpid on the EGL bring-up pre-flight child failed";
-                }
-                if (waitedMs >= kPreflightTimeoutMs) {
-                    kill(child, SIGKILL);
-                    (void)waitpid(child, &status, 0);
-                    close(channel[0]);
-                    std::ostringstream out;
-                    out << "the EGL bring-up wedged: a forked pre-flight child made no progress in "
-                        << kPreflightTimeoutMs / 1000 << "s and was killed";
-                    return out.str();
-                }
-                timespec nap{0, 10 * 1000 * 1000};
-                nanosleep(&nap, nullptr);
-                waitedMs += 10;
-            }
-
-            std::string childSays;
-            char buffer[512];
-            for (;;) {
-                const ssize_t got = read(channel[0], buffer, sizeof(buffer));
-                if (got <= 0) break;
-                childSays.append(buffer, static_cast<std::size_t>(got));
-            }
-            close(channel[0]);
-
-            if (WIFSIGNALED(status)) {
-                const int signalNumber = WTERMSIG(status);
-                const char* signalName = strsignal(signalNumber);
-                std::ostringstream out;
-                out << "the EGL bring-up ABORTS on this platform: a forked pre-flight child died on signal "
-                    << signalNumber << " (" << (signalName != nullptr ? signalName : "?") << ")";
-                if (!childSays.empty()) out << " after: " << childSays;
-                out << ". MobileGL asserts rather than returning an error here, so the scenarios would "
-                       "have taken the whole test binary down with them";
-                return out.str();
-            }
-            if (!WIFEXITED(status)) {
-                return "the EGL bring-up pre-flight child neither exited nor was signalled";
-            }
-            const int exitStatus = WEXITSTATUS(status);
-            if (exitStatus != 0) {
-                std::ostringstream out;
-                out << (childSays.empty() ? "the EGL bring-up failed" : childSays)
-                    << " (forked pre-flight child exit status " << exitStatus << ")";
-                return out.str();
-            }
-            return {};
-#endif
-        }
-    } // namespace
-
-    bool RequireGpu() {
-        const char* value = std::getenv("MOBILEGL_ITEST_REQUIRE_GPU");
-        return value != nullptr && value[0] != '\0' && std::strcmp(value, "0") != 0;
-    }
-
-    std::ostream& operator<<(std::ostream& os, const Rgba8& c) {
-        os << "rgba(" << int(c.r) << "," << int(c.g) << "," << int(c.b) << "," << int(c.a) << ")";
-        return os;
-    }
-
-    Rgba8 Image::At(int x, int y) const {
-        if (x < 0 || y < 0 || x >= m_width || y >= m_height) {
-            return Rgba8{};
-        }
-        const std::size_t index = (static_cast<std::size_t>(y) * m_width + x) * 4;
-        return Rgba8{m_pixels[index], m_pixels[index + 1], m_pixels[index + 2], m_pixels[index + 3]};
-    }
-
-    const char* Image::ColorName(int x, int y) const {
-        const Rgba8 c = At(x, y);
-        const bool r = c.r > 160, g = c.g > 160, b = c.b > 160;
-        const bool nr = c.r < 96, ng = c.g < 96, nb = c.b < 96;
-        if (nr && ng && nb) return "black";
-        if (r && g && b) return "white";
-        if (r && ng && nb) return "red";
-        if (nr && g && nb) return "green";
-        if (nr && ng && b) return "blue";
-        if (r && g && nb) return "yellow";
-        return "other";
-    }
-
-    std::size_t Image::ByteDiffCount(const Image& other) const {
-        if (m_width != other.m_width || m_height != other.m_height) {
-            return std::max(m_pixels.size(), other.m_pixels.size());
-        }
-        std::size_t differing = 0;
-        for (std::size_t i = 0; i < m_pixels.size(); ++i) {
-            if (m_pixels[i] != other.m_pixels[i]) ++differing;
-        }
-        return differing;
-    }
-
-    std::string Image::QuadrantSignature() const {
-        if (m_width < 2 || m_height < 2) return "<empty>";
-        // Quadrant CENTRES, so a one-pixel rounding difference at a quadrant edge
-        // never decides the answer. Order is fixed and load-bearing: bottom-left,
-        // bottom-right, top-left, top-right.
-        const int leftX = m_width / 4;
-        const int rightX = m_width * 3 / 4;
-        const int bottomY = m_height / 4;
-        const int topY = m_height * 3 / 4;
-        std::ostringstream out;
-        out << ColorName(leftX, bottomY) << "," << ColorName(rightX, bottomY) << "," << ColorName(leftX, topY) << ","
-            << ColorName(rightX, topY);
-        return out.str();
-    }
-
-    RegionScan ScanRegion(const Image& image, int x0, int x1, int y0, int y1, const char* expectedColor) {
-        RegionScan scan;
-        x0 = std::max(x0, 0);
-        y0 = std::max(y0, 0);
-        x1 = std::min(x1, image.Width() - 1);
-        y1 = std::min(y1, image.Height() - 1);
-        for (int y = y0; y <= y1; ++y) {
-            for (int x = x0; x <= x1; ++x) {
-                ++scan.total;
-                const char* name = image.ColorName(x, y);
-                if (std::strcmp(name, expectedColor) == 0) continue;
-                ++scan.offenders;
-                if (scan.firstX < 0) {
-                    scan.firstX = x;
-                    scan.firstY = y;
-                    scan.firstColor = image.At(x, y);
-                    scan.firstColorName = name;
-                }
-            }
-        }
-        return scan;
-    }
-
-    ::testing::AssertionResult RegionIsMostly(const Image& image, int x0, int x1, int y0, int y1,
-                                              const char* expectedColor, double tolerance,
-                                              const std::string& when) {
-        const RegionScan scan = ScanRegion(image, x0, x1, y0, y1, expectedColor);
-        if (scan.total == 0) {
-            return ::testing::AssertionFailure()
-                   << when << ": region x[" << x0 << "," << x1 << "] y[" << y0 << "," << y1
-                   << "] is empty against a " << image.Width() << "x" << image.Height() << " readback";
-        }
-        const double offendingFraction = static_cast<double>(scan.offenders) / scan.total;
-        if (offendingFraction <= tolerance) {
-            return ::testing::AssertionSuccess();
-        }
-        return ::testing::AssertionFailure()
-               << when << ": region x[" << x0 << "," << x1 << "] y[" << y0 << "," << y1 << "] should be all "
-               << expectedColor << ", but " << scan.offenders << " of " << scan.total << " pixels ("
-               << static_cast<int>(offendingFraction * 100.0 + 0.5) << "%) are not; first offender at (" << scan.firstX
-               << "," << scan.firstY << ") is " << scan.firstColorName << " " << scan.firstColor;
-    }
-
-    HeadlessGL& HeadlessGL::Get() {
-        static HeadlessGL instance;
-        return instance;
-    }
-
-    HeadlessGL::HeadlessGL() {
-        m_backendName = EnvOr("MOBILEGL_BACKEND_TYPE", "<unset>");
-        m_usable = BringUp();
-    }
-
-    bool HeadlessGL::BringUp() {
-        // Ask a disposable copy of this process first. Only if it survived does
-        // the real one try - see PreflightBringUp for why nothing weaker is
-        // predictive against a stack that aborts instead of returning errors.
-        const std::string preflightProblem = PreflightBringUp();
-        if (!preflightProblem.empty()) {
-            m_skipReason = preflightProblem;
-            return false;
-        }
-
-        // Same shape as DriverBench's boot_egl(), minus the dlopen: the provider
-        // is this binary. A pbuffer needs no window system, but MobileGL's own
-        // loader still has to reach a real driver underneath - and the child
-        // above just proved it can.
-        EglBringUp brought;
-        std::string reason;
-        if (RunEglBringUp(brought, reason) != 0) {
-            // The pre-flight passed and the parent's identical attempt did not.
-            // That is a real result, not a machine without a GPU, so say so: it
-            // means something is different between the two attempts (a leaked
-            // exclusive device, an environment the child did not have).
-            m_skipReason = reason + " - although an identical bring-up in a forked pre-flight child succeeded";
-            return false;
-        }
-
-        m_display = brought.display;
-        m_surface = brought.surface;
-        m_context = brought.context;
-        m_width = kSurfaceWidth;
-        m_height = kSurfaceHeight;
-        m_renderer = std::move(brought.renderer);
-        return true;
-    }
-
-    void HeadlessGL::EndFrame() {
-        if (!m_usable) return;
-        eglSwapBuffers(static_cast<EGLDisplay>(m_display), static_cast<EGLSurface>(m_surface));
-        ++m_frameIndex;
-    }
-
-    void HeadlessGL::ShutDown() {
-        if (!m_usable) return;
-        EGLDisplay display = static_cast<EGLDisplay>(m_display);
-        eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-        if (m_context != nullptr) eglDestroyContext(display, static_cast<EGLContext>(m_context));
-        if (m_surface != nullptr) eglDestroySurface(display, static_cast<EGLSurface>(m_surface));
-        eglTerminate(display);
-        m_context = nullptr;
-        m_surface = nullptr;
-        m_display = nullptr;
-        m_usable = false;
-        m_skipReason = "the headless context has already been torn down";
-    }
-
-    // ---- scenario vocabulary ------------------------------------------------
-
-    namespace {
-        unsigned int CompileStage(GLenum stage, const char* source, std::string* outError) {
-            const GLuint shader = glCreateShader(stage);
-            glShaderSource(shader, 1, &source, nullptr);
-            glCompileShader(shader);
-            GLint compiled = 0;
-            glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
-            if (compiled == GL_FALSE) {
-                char log[2048] = {};
-                GLsizei length = 0;
-                glGetShaderInfoLog(shader, sizeof(log) - 1, &length, log);
-                if (outError != nullptr) {
-                    *outError = std::string(stage == GL_VERTEX_SHADER ? "vertex" : "fragment") +
-                                " shader failed to compile: " + log;
-                }
-                glDeleteShader(shader);
-                return 0;
-            }
-            return shader;
-        }
-    } // namespace
-
-    unsigned int CompileProgram(const char* vertexSource, const char* fragmentSource, std::string* outError) {
-        const GLuint vs = CompileStage(GL_VERTEX_SHADER, vertexSource, outError);
-        if (vs == 0) return 0;
-        const GLuint fs = CompileStage(GL_FRAGMENT_SHADER, fragmentSource, outError);
-        if (fs == 0) {
-            glDeleteShader(vs);
-            return 0;
-        }
-        const GLuint program = glCreateProgram();
-        glAttachShader(program, vs);
-        glAttachShader(program, fs);
-        // Pinned rather than queried so the scenarios can set up a VAO without a
-        // round trip, and so a driver that reorders attributes cannot change what
-        // the test means.
-        glBindAttribLocation(program, 0, "aPos");
-        glBindAttribLocation(program, 1, "aColor");
-        glLinkProgram(program);
-        glDeleteShader(vs);
-        glDeleteShader(fs);
-        GLint linked = 0;
-        glGetProgramiv(program, GL_LINK_STATUS, &linked);
-        if (linked == GL_FALSE) {
-            char log[2048] = {};
-            GLsizei length = 0;
-            glGetProgramInfoLog(program, sizeof(log) - 1, &length, log);
-            if (outError != nullptr) *outError = std::string("program failed to link: ") + log;
-            glDeleteProgram(program);
-            return 0;
-        }
-        return program;
-    }
-
-    ColorFbo MakeColorFbo(int width, int height) {
-        ColorFbo target;
-        target.width = width;
-        target.height = height;
-        glGenTextures(1, &target.texture);
-        glBindTexture(GL_TEXTURE_2D, target.texture);
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        glBindTexture(GL_TEXTURE_2D, 0);
-
-        glGenFramebuffers(1, &target.fbo);
-        glBindFramebuffer(GL_FRAMEBUFFER, target.fbo);
-        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, target.texture, 0);
-        const GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-        glBindFramebuffer(GL_FRAMEBUFFER, 0);
-        if (status != GL_FRAMEBUFFER_COMPLETE) {
-            DestroyColorFbo(target);
-        }
-        return target;
-    }
-
-    void DestroyColorFbo(ColorFbo& target) {
-        if (target.fbo != 0) glDeleteFramebuffers(1, &target.fbo);
-        if (target.texture != 0) glDeleteTextures(1, &target.texture);
-        target.fbo = 0;
-        target.texture = 0;
-    }
-
-    void BindDefaultFramebuffer() {
-        glBindFramebuffer(GL_FRAMEBUFFER, 0);
-        glViewport(0, 0, HeadlessGL::Get().Width(), HeadlessGL::Get().Height());
-    }
-
-    void BindFbo(const ColorFbo& target) {
-        glBindFramebuffer(GL_FRAMEBUFFER, target.fbo);
-        glViewport(0, 0, target.width, target.height);
-    }
-
-    void ClearTo(float r, float g, float b, float a) {
-        glClearColor(r, g, b, a);
-        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    }
-
-    Image ReadPixels(int width, int height) {
-        Image image(width, height);
-        glPixelStorei(GL_PACK_ALIGNMENT, 1);
-        glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, image.Data());
-        return image;
-    }
-
-    unsigned int FirstGLError() {
-        const GLenum first = glGetError();
-        if (first == GL_NO_ERROR) return GL_NO_ERROR;
-        // Drain, bounded: a broken stack must not turn an error check into a hang.
-        for (int i = 0; i < 64 && glGetError() != GL_NO_ERROR; ++i) {}
-        return first;
-    }
-
-    const char* GLErrorName(unsigned int error) {
-        switch (error) {
-        case GL_NO_ERROR:
-            return "GL_NO_ERROR";
-        case GL_INVALID_ENUM:
-            return "GL_INVALID_ENUM";
-        case GL_INVALID_VALUE:
-            return "GL_INVALID_VALUE";
-        case GL_INVALID_OPERATION:
-            return "GL_INVALID_OPERATION";
-        case GL_OUT_OF_MEMORY:
-            return "GL_OUT_OF_MEMORY";
-        case GL_INVALID_FRAMEBUFFER_OPERATION:
-            return "GL_INVALID_FRAMEBUFFER_OPERATION";
-        default:
-            return "GL_<unknown>";
-        }
-    }
-
-} // namespace MGITest

MobileGL/MG_IntegrationTest/Harness/HeadlessGL.h

@@ -1,218 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Harness/HeadlessGL.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
-//
-// A headless GL context and the small vocabulary the scenarios are written in.
-//
-// The scenarios in this module are end-to-end: they drive MobileGL's own GL and
-// EGL entry points (this binary links MobileGL_s, so gl*/egl* resolve straight
-// into the implementation) and assert on glReadPixels output. Nothing here
-// inspects backend state - both bugs this module pins were invisible to
-// state-level assertions and visible only in pixels.
-//
-// Headless by construction, following MG_Benchmark/Driver/DriverBench.c: an EGL
-// context on a PBUFFER surface. No window, no window manager, no human. Unlike
-// DriverBench the scenarios do draw to the DEFAULT framebuffer (that is where
-// the Y-flip lives) and do call eglSwapBuffers (that is the frame boundary the
-// cross-frame scenarios need to be real).
-//
-// One process is one backend: MOBILEGL_BACKEND_TYPE is latched at
-// initialization, so the CMake wiring runs this binary once per backend rather
-// than trying to switch in-process.
-
-#pragma once
-
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-namespace MGITest {
-
-    // True when MOBILEGL_ITEST_REQUIRE_GPU is set in the environment: the runner
-    // is asserting that this machine HAS a usable GPU, so "no GPU" stops being a
-    // clean skip and becomes a failure. Without it the integration-gpu label is
-    // unfalsifiable - a CI job that ran nothing reports exactly the same green as
-    // a job that ran everything.
-    bool RequireGpu();
-
-    struct Rgba8 {
-        std::uint8_t r = 0, g = 0, b = 0, a = 0;
-
-        bool operator==(const Rgba8& other) const {
-            return r == other.r && g == other.g && b == other.b && a == other.a;
-        }
-        bool operator!=(const Rgba8& other) const { return !(*this == other); }
-    };
-
-    // Prints as "rgba(255,0,0,255)" so a gtest failure names the colour it saw.
-    std::ostream& operator<<(std::ostream& os, const Rgba8& c);
-
-    // An RGBA8 readback. Row 0 is the BOTTOM row: that is GL's convention for
-    // glReadPixels and it is what "correctly oriented" means everywhere below.
-    class Image {
-    public:
-        Image() = default;
-        Image(int width, int height)
-            : m_width(width), m_height(height), m_pixels(static_cast<std::size_t>(width) * height * 4, 0) {}
-
-        int Width() const { return m_width; }
-        int Height() const { return m_height; }
-        bool Empty() const { return m_pixels.empty(); }
-        std::uint8_t* Data() { return m_pixels.data(); }
-        const std::uint8_t* Data() const { return m_pixels.data(); }
-
-        Rgba8 At(int x, int y) const;
-        // Nearest of {black, red, green, blue, white, other} - the scenarios only
-        // ever draw those, so this turns a pixel into something readable.
-        const char* ColorName(int x, int y) const;
-
-        bool operator==(const Image& other) const {
-            return m_width == other.m_width && m_height == other.m_height && m_pixels == other.m_pixels;
-        }
-
-        // Count of differing bytes, for a failure message that says how wrong.
-        std::size_t ByteDiffCount(const Image& other) const;
-
-        // The four quadrant centres, in the fixed order
-        // bottom-left, bottom-right, top-left, top-right.
-        //
-        // This replaces the old VerticalSignature(bandCount), which read three
-        // full-width horizontal stripes down the centre line and was therefore
-        // blind to an X flip, to a transpose, and to a 180 rotation composed with
-        // a Y flip - all of those left the stripe order alone. Four quadrant
-        // colours are asymmetric in BOTH axes, so each of the eight square
-        // symmetries produces a different string (see OrientationScenario, which
-        // spells all eight out).
-        std::string QuadrantSignature() const;
-
-    private:
-        int m_width = 0;
-        int m_height = 0;
-        std::vector<std::uint8_t> m_pixels;
-    };
-
-    // The process-wide headless context. Brought up lazily on the first Get() so
-    // that `--gtest_list_tests` (which CMake runs at build time to discover the
-    // cases) never touches a GPU.
-    class HeadlessGL {
-    public:
-        static HeadlessGL& Get();
-
-        // False on a machine with no usable GPU/display/ICD. SkipReason() then
-        // says which step failed; every fixture turns that into GTEST_SKIP().
-        bool Usable() const { return m_usable; }
-        const std::string& SkipReason() const { return m_skipReason; }
-
-        // Backend actually in use, as reported by MOBILEGL_BACKEND_TYPE.
-        const std::string& BackendName() const { return m_backendName; }
-        const std::string& RendererString() const { return m_renderer; }
-
-        int Width() const { return m_width; }
-        int Height() const { return m_height; }
-
-        // THE frame boundary. eglSwapBuffers is what retires a frame in the
-        // renderer, and the cross-frame scenarios are meaningless without it.
-        void EndFrame();
-
-        // Frames completed so far, for failure messages.
-        int FrameIndex() const { return m_frameIndex; }
-
-        // Releases the context and surface and terminates the display. Called
-        // once, after the last scenario: MobileGL frees its backend objects
-        // through eglTerminate, and letting a process simply exit on top of a
-        // live context leaves those objects to be torn down from a static
-        // destructor with no driver left underneath.
-        void ShutDown();
-
-    private:
-        HeadlessGL();
-        HeadlessGL(const HeadlessGL&) = delete;
-        HeadlessGL& operator=(const HeadlessGL&) = delete;
-
-        bool BringUp();
-
-        bool m_usable = false;
-        std::string m_skipReason;
-        std::string m_backendName;
-        std::string m_renderer;
-        int m_width = 0;
-        int m_height = 0;
-        int m_frameIndex = 0;
-        void* m_display = nullptr;
-        void* m_surface = nullptr;
-        void* m_context = nullptr;
-    };
-
-    // ---- the scenario vocabulary -------------------------------------------
-    // Deliberately tiny. A scenario should read like a story; anything that
-    // needs a comment about GL mechanics belongs here instead.
-
-    // Compiles and links vs+fs, pinning attribute 0 to "aPos" and 1 to "aColor".
-    // Returns 0 and fills outError on failure.
-    unsigned int CompileProgram(const char* vertexSource, const char* fragmentSource, std::string* outError);
-
-    struct ColorFbo {
-        unsigned int fbo = 0;
-        unsigned int texture = 0;
-        int width = 0;
-        int height = 0;
-    };
-
-    // A complete RGBA8 render target. Returns fbo==0 on failure.
-    ColorFbo MakeColorFbo(int width, int height);
-    void DestroyColorFbo(ColorFbo& target);
-
-    // Binds a target and sets the viewport to match. Passing fbo 0 means the
-    // default (presentable) framebuffer.
-    void BindDefaultFramebuffer();
-    void BindFbo(const ColorFbo& target);
-
-    void ClearTo(float r, float g, float b, float a);
-
-    // Reads back the whole currently bound READ framebuffer. width/height must
-    // be the target's full size - DirectVulkan's default-framebuffer readback
-    // only re-orients a full-extent read.
-    Image ReadPixels(int width, int height);
-
-    // Drains any GL error queue and returns the first error, or 0.
-    unsigned int FirstGLError();
-    const char* GLErrorName(unsigned int error);
-
-    // ---- whole-region readback predicates ----------------------------------
-    // The scenarios used to assert on two or three individual pixels, which is
-    // provably too weak: a draw in which 3 of a quad's 4 vertices carry stale
-    // data still paints the sampled centre the expected colour (that exact case
-    // is a standing negative-control test - see CrossFrameBufferScenario). The
-    // readback is already fully in memory, so counting every pixel in a region
-    // costs nothing and turns "the middle looks right" into "all of it is right".
-
-    // Everything a caller needs to say what was wrong and where.
-    struct RegionScan {
-        int total = 0;     // pixels examined
-        int offenders = 0; // pixels whose ColorName() != expected
-        int firstX = -1;   // first offender in bottom-to-top, left-to-right order
-        int firstY = -1;
-        Rgba8 firstColor{};
-        std::string firstColorName;
-    };
-
-    // Inclusive pixel bounds, clamped to the image. Row 0 is the bottom row.
-    RegionScan ScanRegion(const Image& image, int x0, int x1, int y0, int y1, const char* expectedColor);
-
-    // gtest predicate wrapper: EXPECT_TRUE(RegionIsMostly(...)) reports the
-    // offender count, the offender fraction and the FIRST offending pixel's
-    // coordinates and colour. `tolerance` is the fraction of the region allowed
-    // to disagree; pass 0.0 to demand every pixel (which is what the scenarios
-    // do - they inset their regions away from primitive edges so exactness is
-    // achievable).
-    ::testing::AssertionResult RegionIsMostly(const Image& image, int x0, int x1, int y0, int y1,
-                                              const char* expectedColor, double tolerance,
-                                              const std::string& when);
-
-} // namespace MGITest

MobileGL/MG_IntegrationTest/Harness/ScenarioFixture.h

@@ -1,84 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Harness/ScenarioFixture.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
-//
-// The base fixture every scenario derives from. Its only jobs are to bring the
-// headless context up once per process and to decide what "this machine has no
-// usable GPU" means.
-//
-// By default it means a clean GTEST_SKIP() - never a failure, never a hang -
-// because a developer box or a container without a GPU should not fail a run it
-// was never able to perform. But a skip is indistinguishable from a pass in
-// every CI summary, so the `integration-gpu` label on its own is unfalsifiable:
-// a runner whose driver pinning silently broke reports the same green as one
-// that rendered every frame. MOBILEGL_ITEST_REQUIRE_GPU is the caller saying
-// "this machine HAS a GPU and I am relying on these scenarios actually running";
-// with it set, an unusable harness is a FAILURE carrying the pre-flight's reason.
-
-#pragma once
-
-#include <gtest/gtest.h>
-
-#include "HeadlessGL.h"
-
-namespace MGITest {
-
-    class ScenarioTest : public ::testing::Test {
-    protected:
-        void SetUp() override {
-            m_ready = false;
-            HeadlessGL& gl = HeadlessGL::Get();
-            if (!gl.Usable()) {
-                if (RequireGpu()) {
-                    // FAIL() is a FATAL failure but does NOT mark the test skipped,
-                    // so a derived SetUp that guards on IsSkipped() alone would run
-                    // straight into GL calls with no current context and SIGSEGV -
-                    // that exact crash shipped from the first version of this guard.
-                    // Derived fixtures must gate on Ready() (below), which is false
-                    // on BOTH the skip path and this failure path.
-                    FAIL() << "MOBILEGL_ITEST_REQUIRE_GPU is set, so an unusable harness is a failure, not a skip. "
-                           << "Backend " << gl.BackendName() << " could not be brought up: " << gl.SkipReason();
-                }
-                GTEST_SKIP() << "no usable GPU/display/ICD for backend " << gl.BackendName() << ": " << gl.SkipReason();
-            }
-            if (RequireGpu() && LooksLikeSoftwareRasterizer(gl.RendererString())) {
-                // "Ran on llvmpipe" must not be able to pass as "ran on the GPU":
-                // a misconfigured vendor pin silently lands on the software
-                // rasterizer, and REQUIRE_GPU exists precisely to make that loud.
-                FAIL() << "MOBILEGL_ITEST_REQUIRE_GPU is set but the context landed on a software rasterizer: "
-                       << gl.RendererString();
-            }
-            // A scenario starts from a clean slate but shares the context (and so
-            // the renderer's memos) with every other scenario in this process -
-            // which is exactly the situation both shipped bugs needed.
-            RecordProperty("backend", gl.BackendName());
-            RecordProperty("renderer", gl.RendererString());
-            m_ready = true;
-        }
-
-        // The ONLY gate a derived SetUp/TearDown may use: `if (!Ready()) return;`.
-        // True only when the base SetUp brought the context up and neither skipped
-        // nor failed. IsSkipped() alone is WRONG here (see the comment at FAIL()).
-        bool Ready() const { return m_ready; }
-
-        static HeadlessGL& Gl() { return HeadlessGL::Get(); }
-
-    private:
-        static bool LooksLikeSoftwareRasterizer(const std::string& renderer) {
-            static const char* kNames[] = {"llvmpipe", "lavapipe", "softpipe", "SwiftShader", "swrast"};
-            for (const char* name : kNames) {
-                if (renderer.find(name) != std::string::npos) {
-                    return true;
-                }
-            }
-            return false;
-        }
-
-        bool m_ready = false;
-    };
-
-} // namespace MGITest

MobileGL/MG_IntegrationTest/Main.cpp

@@ -1,53 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Main.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
-//
-// Entry point for the headless GPU integration scenarios.
-//
-// The banner lives in a gtest Environment rather than in main() on purpose:
-// Environment::SetUp does not run for `--gtest_list_tests`, which is what CMake
-// invokes at build time to discover the cases. Discovery therefore never brings
-// up EGL, never needs a GPU and cannot hang.
-
-#include <gtest/gtest.h>
-#include <cstdio>
-
-#include "Harness/HeadlessGL.h"
-
-namespace {
-
-    class HarnessBanner : public ::testing::Environment {
-    public:
-        void SetUp() override {
-            const MGITest::HeadlessGL& gl = MGITest::HeadlessGL::Get();
-            std::fprintf(stderr, "MobileGL integration scenarios: backend=%s\n", gl.BackendName().c_str());
-            if (gl.Usable()) {
-                std::fprintf(stderr, "  renderer: %s\n  surface:  %dx%d pbuffer (headless)\n",
-                             gl.RendererString().c_str(), gl.Width(), gl.Height());
-            } else if (MGITest::RequireGpu()) {
-                std::fprintf(stderr,
-                             "  FAILING every scenario (MOBILEGL_ITEST_REQUIRE_GPU is set): %s\n",
-                             gl.SkipReason().c_str());
-            } else {
-                std::fprintf(stderr,
-                             "  SKIPPING every scenario: %s\n"
-                             "  (set MOBILEGL_ITEST_REQUIRE_GPU=1 to make this a failure instead - a run that\n"
-                             "   skipped everything is otherwise indistinguishable from one that passed)\n",
-                             gl.SkipReason().c_str());
-            }
-        }
-
-        void TearDown() override { MGITest::HeadlessGL::Get().ShutDown(); }
-    };
-
-} // namespace
-
-int main(int argc, char** argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    ::testing::AddGlobalTestEnvironment(new HarnessBanner());
-    return RUN_ALL_TESTS();
-}

MobileGL/MG_IntegrationTest/Scenarios/AsyncCompileScenario.cpp

@@ -1,467 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/AsyncCompileScenario.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
-//
-// Scenario E - asynchronous shader compilation and GL_KHR_parallel_shader_compile
-// on a REAL driver.
-//
-// WHY THIS EXISTS ALONGSIDE THE UNIT SUITES. MG_Test/Program's async suites already
-// drive the same GL entry points, but they stop at the frontend: nothing there ever
-// reaches a driver, so nothing there can catch the failure this scenario is built for
-// - artifacts produced on a worker thread that the BACKEND then rejects, mis-binds or
-// renders differently from the ones the GL thread produced. The frontend cannot tell
-// the two apart; a pixel can.
-//
-// The five things it pins, in order:
-//
-//   (a) 64 heavy compiles are enqueued and polled through GL_COMPLETION_STATUS_KHR.
-//       At least one must be observed GL_FALSE - i.e. the query really answers while
-//       work is outstanding rather than silently joining. Skipped, never failed, when
-//       the machine drained the whole batch before the first poll: a fast box must not
-//       be able to turn this into a red.
-//   (b) Forcing the join afterwards produces the right answer for every one of them:
-//       GL_COMPILE_STATUS true, an empty info log, and a program that links.
-//   (c) The extension string matches the configuration. This is the half a recorded
-//       trace can never cover - Iris and Sodium change their submission schedule the
-//       moment they see the string - so it is asserted against a real backend's real
-//       GL_EXTENSIONS, through both glGetString and glGetStringi.
-//   (d) glMaxShaderCompilerThreadsKHR(0) leaves nothing in flight: every subsequent
-//       GL_COMPLETION_STATUS_KHR reads GL_TRUE immediately, and compilation after it
-//       is synchronous. That is what the extension requires of a zero count.
-//   (e) THE ONE THAT NEEDS A GPU: the same frame, drawn with programs compiled and
-//       linked asynchronously and then with programs compiled and linked inline, must
-//       come out byte-identical under glReadPixels. Anything the worker thread got
-//       wrong about the compile environment, the reflection or the SPIR-V shows up
-//       here as a pixel difference and nowhere else.
-//
-// Backend selection is the module's usual one process, one backend (MOBILEGL_BACKEND_TYPE),
-// so this file runs twice per ctest invocation.
-
-#include <string>
-#include <vector>
-
-#include "../Harness/HeadlessGL.h"
-#include "../Harness/ScenarioFixture.h"
-
-#include "Config.h"
-#include "MG_Util/Async/ShaderCompilePool.h"
-
-#ifdef GLAPI
-#undef GLAPI
-#endif
-#define GL_GLEXT_PROTOTYPES
-#include <GL/gl.h>
-#include <GL/glcorearb.h>
-#undef GL_GLEXT_PROTOTYPES
-
-// GL_KHR_parallel_shader_compile. Spelled out rather than relying on the host's
-// glext.h: this module is built against whatever GL headers the machine has, and an
-// older one has neither token. Both are also GL_*_ARB with identical values.
-#ifndef GL_MAX_SHADER_COMPILER_THREADS_KHR
-#define GL_MAX_SHADER_COMPILER_THREADS_KHR 0x91B0
-#endif
-#ifndef GL_COMPLETION_STATUS_KHR
-#define GL_COMPLETION_STATUS_KHR 0x91B1
-#endif
-
-// The entry point under test, resolved by the linker straight into MobileGL_s like
-// every other gl* call in this module. Declared here for the same reason as the
-// tokens above.
-extern "C" void glMaxShaderCompilerThreadsKHR(GLuint count);
-
-namespace MGITest {
-    namespace {
-
-        using MobileGL::MG_Config::QuirkOverride;
-
-        // Same shape as the other scenarios: a two-attribute pass-through, so the only
-        // thing that can differ between the two compilation modes is the compilation.
-        constexpr const char* kVertexSource = R"(#version 330 core
-in vec2 aPos;
-in vec3 aColor;
-out vec3 vColor;
-void main() {
-    vColor = aColor;
-    gl_Position = vec4(aPos, 0.0, 1.0);
-}
-)";
-
-        constexpr const char* kFragmentSource = R"(#version 330 core
-in vec3 vColor;
-out vec4 oColor;
-void main() {
-    oColor = vec4(vColor, 1.0);
-}
-)";
-
-        // Asymmetric in both axes, so a mode difference that also happens to be a
-        // symmetry of the image cannot hide (the same reason OrientationScenario draws
-        // quadrants rather than stripes).
-        struct Vertex {
-            float x, y;
-            float r, g, b;
-        };
-
-        void AppendQuad(std::vector<Vertex>& out, float x0, float x1, float y0, float y1, float r, float g, float b) {
-            const Vertex bl{x0, y0, r, g, b};
-            const Vertex br{x1, y0, r, g, b};
-            const Vertex tr{x1, y1, r, g, b};
-            const Vertex tl{x0, y1, r, g, b};
-            out.insert(out.end(), {bl, br, tr, bl, tr, tl});
-        }
-
-        std::vector<Vertex> QuadrantGeometry() {
-            std::vector<Vertex> vertices;
-            vertices.reserve(24);
-            AppendQuad(vertices, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f); // bottom-left: blue
-            AppendQuad(vertices, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f);  // bottom-right: green
-            AppendQuad(vertices, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f);  // top-left: red
-            AppendQuad(vertices, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f);   // top-right: white
-            return vertices;
-        }
-
-        // Expensive enough that a compile is not instantaneous, and distinct per index so
-        // the source-hash memo never turns one into a no-op: without both properties the
-        // pool has no backlog and (a) has nothing to observe.
-        std::string BulkyFragmentSource(int index) {
-            std::string source = "#version 330 core\n";
-            source += "in vec3 vColor;\nout vec4 oColor;\n";
-            source += "uniform float uSeed" + std::to_string(index) + ";\n";
-            source += "void main() {\n    float acc = uSeed" + std::to_string(index) + ";\n";
-            for (int i = 0; i < 320; ++i) {
-                source += "    acc = acc * 1.0001 + sin(acc + " + std::to_string(i) + ".0) * cos(acc);\n";
-            }
-            source += "    oColor = vec4(vColor * acc, 1.0);\n}\n";
-            return source;
-        }
-
-        // MOBILEGL_ASYNC_SHADER_COMPILE decides the ambient mode; a scenario that wants
-        // the other one says so here and gets the ambient one back on scope exit. Forcing
-        // it in-process is what lets ONE ctest run compare the two modes against each
-        // other - the whole point of (e).
-        class AsyncModeScope {
-        public:
-            explicit AsyncModeScope(bool async) : m_saved(MobileGL::MG_Config::Features.AsyncShaderCompile) {
-                MobileGL::MG_Config::Features.AsyncShaderCompile =
-                    async ? QuirkOverride::ForceOn : QuirkOverride::ForceOff;
-            }
-            ~AsyncModeScope() { MobileGL::MG_Config::Features.AsyncShaderCompile = m_saved; }
-            AsyncModeScope(const AsyncModeScope&) = delete;
-            AsyncModeScope& operator=(const AsyncModeScope&) = delete;
-
-        private:
-            const QuirkOverride m_saved;
-        };
-
-        // glMaxShaderCompilerThreadsKHR writes process-wide state; a scenario that calls
-        // it has to put the pool back or it changes how every scenario after it compiles.
-        class CompilerThreadScope {
-        public:
-            CompilerThreadScope() = default;
-            ~CompilerThreadScope() {
-                MobileGL::MG_Util::Async::SetAsyncShaderCompileSuspended(false);
-                auto& pool = MobileGL::MG_Util::Async::ShaderCompilePool::Get();
-                pool.SetMaxConcurrency(pool.GetThreadCount());
-            }
-            CompilerThreadScope(const CompilerThreadScope&) = delete;
-            CompilerThreadScope& operator=(const CompilerThreadScope&) = delete;
-        };
-
-        GLint ShaderCompletion(GLuint shader) {
-            GLint status = -1;
-            glGetShaderiv(shader, GL_COMPLETION_STATUS_KHR, &status);
-            return status;
-        }
-
-        GLint ShaderCompileStatus(GLuint shader) {
-            GLint status = GL_FALSE;
-            glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
-            return status;
-        }
-
-        std::string ShaderInfoLog(GLuint shader) {
-            GLint length = 0;
-            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
-            if (length <= 0) return std::string();
-            std::vector<char> buffer(static_cast<std::size_t>(length));
-            GLsizei written = 0;
-            glGetShaderInfoLog(shader, length, &written, buffer.data());
-            return std::string(buffer.data(), static_cast<std::size_t>(written));
-        }
-
-        class AsyncCompileScenario : public ScenarioTest {
-        protected:
-            void SetUp() override {
-                ScenarioTest::SetUp();
-                if (!Ready()) return;
-
-                const std::vector<Vertex> vertices = QuadrantGeometry();
-                m_vertexCount = static_cast<int>(vertices.size());
-                glGenVertexArrays(1, &m_vao);
-                glBindVertexArray(m_vao);
-                glGenBuffers(1, &m_vbo);
-                glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-                glBufferData(GL_ARRAY_BUFFER, GLsizeiptr(vertices.size() * sizeof(Vertex)), vertices.data(),
-                             GL_STATIC_DRAW);
-                glEnableVertexAttribArray(0);
-                glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(0));
-                glEnableVertexAttribArray(1);
-                glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(8));
-                glBindVertexArray(0);
-
-                ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR)) << "setup left a GL error behind";
-            }
-
-            void TearDown() override {
-                if (!Ready()) return;
-                if (m_vbo != 0) glDeleteBuffers(1, &m_vbo);
-                if (m_vao != 0) glDeleteVertexArrays(1, &m_vao);
-            }
-
-            // A fresh program every time, compiled and linked in whatever mode is in
-            // force. Reusing one would defeat the comparison: the second mode would just
-            // read the first mode's artifacts back out of the memo.
-            GLuint BuildProgram() {
-                std::string error;
-                const GLuint program = CompileProgram(kVertexSource, kFragmentSource, &error);
-                EXPECT_NE(program, 0u) << error;
-                return program;
-            }
-
-            Image DrawFrameWith(GLuint program) {
-                BindDefaultFramebuffer();
-                ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
-                glDisable(GL_DEPTH_TEST);
-                glDisable(GL_BLEND);
-                glUseProgram(program);
-                glBindVertexArray(m_vao);
-                glDrawArrays(GL_TRIANGLES, 0, m_vertexCount);
-                glBindVertexArray(0);
-                Image image = ReadPixels(Gl().Width(), Gl().Height());
-                Gl().EndFrame();
-                return image;
-            }
-
-            // Enqueues `count` distinct heavy compiles and returns their names WITHOUT
-            // reading anything back, so the pool is left with a real backlog.
-            std::vector<GLuint> EnqueueBacklog(int count, int seedBase) {
-                std::vector<GLuint> shaders;
-                shaders.reserve(static_cast<std::size_t>(count));
-                m_sources.reserve(m_sources.size() + static_cast<std::size_t>(count));
-                for (int i = 0; i < count; ++i) {
-                    m_sources.push_back(BulkyFragmentSource(seedBase + i));
-                    const char* text = m_sources.back().c_str();
-                    const GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);
-                    glShaderSource(shader, 1, &text, nullptr);
-                    glCompileShader(shader);
-                    shaders.push_back(shader);
-                }
-                return shaders;
-            }
-
-            GLuint m_vao = 0;
-            GLuint m_vbo = 0;
-            int m_vertexCount = 0;
-            // Kept alive for the whole case: glShaderSource copies, but keeping the
-            // strings makes a failure message able to name the source it came from.
-            std::vector<std::string> m_sources;
-        };
-
-        // ---- (a) + (b) ------------------------------------------------------------
-        // A backlog is enqueued, polled without joining, then forced to settle and
-        // checked for correctness. Both halves in one case on purpose: (b) is only
-        // interesting for shaders that (a) proved were genuinely still outstanding.
-        TEST_F(AsyncCompileScenario, CompletionStatusPollingThenForcedJoin) {
-            if (!Ready()) return;
-            const AsyncModeScope async(true);
-            const CompilerThreadScope threads;
-            // One worker, so the queue behind it is what the poll observes.
-            glMaxShaderCompilerThreadsKHR(1);
-
-            const std::vector<GLuint> shaders = EnqueueBacklog(64, 6000);
-
-            int outstanding = 0;
-            for (const GLuint shader : shaders) {
-                const GLint completion = ShaderCompletion(shader);
-                ASSERT_TRUE(completion == GL_TRUE || completion == GL_FALSE)
-                    << "GL_COMPLETION_STATUS_KHR returned " << completion;
-                if (completion == GL_FALSE) ++outstanding;
-            }
-            if (outstanding == 0) {
-                GTEST_SKIP() << "this machine drained 64 heavy compiles before the first poll; "
-                                "nothing was outstanding to observe";
-            }
-
-            // (b) Forced join: every one of them is correct, and usable.
-            for (const GLuint shader : shaders) {
-                EXPECT_EQ(ShaderCompileStatus(shader), GL_TRUE) << ShaderInfoLog(shader);
-                EXPECT_TRUE(ShaderInfoLog(shader).empty());
-                EXPECT_EQ(ShaderCompletion(shader), GL_TRUE) << "GL_COMPILE_STATUS must have joined";
-            }
-
-            // And a link over one of them really produces a usable program on this driver.
-            const GLuint vs = glCreateShader(GL_VERTEX_SHADER);
-            glShaderSource(vs, 1, &kVertexSource, nullptr);
-            glCompileShader(vs);
-            const GLuint program = glCreateProgram();
-            glAttachShader(program, vs);
-            glAttachShader(program, shaders.front());
-            glBindAttribLocation(program, 0, "aPos");
-            glBindAttribLocation(program, 1, "aColor");
-            glLinkProgram(program);
-            GLint linked = GL_FALSE;
-            glGetProgramiv(program, GL_LINK_STATUS, &linked);
-            EXPECT_EQ(linked, GL_TRUE);
-            EXPECT_GE(glGetUniformLocation(program, "uSeed6000"), 0);
-
-            glDeleteProgram(program);
-            glDeleteShader(vs);
-            for (const GLuint shader : shaders) glDeleteShader(shader);
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-        // ---- (c) ------------------------------------------------------------------
-        // The extension string, read from a real backend that really brought a driver
-        // up. No mode forcing here: a backend builds its advertised list once, from the
-        // configuration in force at its first use, so the meaningful assertion is
-        // against the AMBIENT configuration - which is exactly what makes this case
-        // worth running in both of the suite's flag states.
-        TEST_F(AsyncCompileScenario, ExtensionStringMatchesTheConfiguration) {
-            if (!Ready()) return;
-            const bool expected = MobileGL::MG_Util::Async::AsyncShaderCompileEnabled();
-
-            const char* extensions = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
-            ASSERT_NE(extensions, nullptr);
-            const std::string extensionString(extensions);
-            const bool inString = extensionString.find("GL_KHR_parallel_shader_compile") != std::string::npos;
-            EXPECT_EQ(inString, expected)
-                << "backend " << Gl().BackendName() << " GL_EXTENSIONS = " << extensionString;
-
-            // LWJGL builds GLCapabilities from the INDEXED form on a core profile, so the
-            // two spellings disagreeing would be invisible to the check above and fatal
-            // to a real application.
-            GLint count = 0;
-            glGetIntegerv(GL_NUM_EXTENSIONS, &count);
-            ASSERT_GT(count, 0);
-            bool inIndexed = false;
-            for (GLint i = 0; i < count; ++i) {
-                const char* name = reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, GLuint(i)));
-                if (name != nullptr && std::string(name) == "GL_KHR_parallel_shader_compile") inIndexed = true;
-            }
-            EXPECT_EQ(inIndexed, expected);
-
-            // The companion query, which an application reads right after the string.
-            GLint maxThreads = -1;
-            glGetIntegerv(GL_MAX_SHADER_COMPILER_THREADS_KHR, &maxThreads);
-            if (expected) {
-                EXPECT_GE(maxThreads, 1);
-            } else {
-                EXPECT_EQ(maxThreads, 0);
-            }
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-        // ---- (d) ------------------------------------------------------------------
-        // A zero count must leave nothing in flight and keep it that way.
-        TEST_F(AsyncCompileScenario, ZeroCompilerThreadsSettlesEverythingImmediately) {
-            if (!Ready()) return;
-            const AsyncModeScope async(true);
-            const CompilerThreadScope threads;
-            glMaxShaderCompilerThreadsKHR(1);
-
-            const std::vector<GLuint> backlog = EnqueueBacklog(48, 6200);
-            glMaxShaderCompilerThreadsKHR(0);
-
-            for (const GLuint shader : backlog) {
-                EXPECT_EQ(ShaderCompletion(shader), GL_TRUE)
-                    << "glMaxShaderCompilerThreadsKHR(0) must join everything still in flight";
-                EXPECT_EQ(ShaderCompileStatus(shader), GL_TRUE) << ShaderInfoLog(shader);
-            }
-
-            // Compilation after the zero count is synchronous too.
-            const std::vector<GLuint> serial = EnqueueBacklog(6, 6300);
-            for (const GLuint shader : serial) {
-                EXPECT_EQ(ShaderCompletion(shader), GL_TRUE) << "a compile after a zero count must be synchronous";
-            }
-
-            for (const GLuint shader : backlog) glDeleteShader(shader);
-            for (const GLuint shader : serial) glDeleteShader(shader);
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-        // ---- (e) ------------------------------------------------------------------
-        // The one that needs the GPU. Two programs, identical source, one built with
-        // compilation and linking on worker threads and one built inline; the frames
-        // they draw must be byte-identical.
-        //
-        // Compared through the DEFAULT framebuffer deliberately: that is where the
-        // backend's orientation and present path live, so the comparison covers the
-        // whole pipeline rather than the reflection tables alone.
-        TEST_F(AsyncCompileScenario, AsyncAndSyncProgramsRenderIdenticalFrames) {
-            if (!Ready()) return;
-
-            Image asyncImage;
-            {
-                const AsyncModeScope async(true);
-                const GLuint program = BuildProgram();
-                ASSERT_NE(program, 0u);
-                asyncImage = DrawFrameWith(program);
-                glDeleteProgram(program);
-            }
-
-            Image syncImage;
-            {
-                const AsyncModeScope async(false);
-                const GLuint program = BuildProgram();
-                ASSERT_NE(program, 0u);
-                syncImage = DrawFrameWith(program);
-                glDeleteProgram(program);
-            }
-
-            ASSERT_FALSE(asyncImage.Empty());
-            ASSERT_FALSE(syncImage.Empty());
-            // The frame is the expected one in the first place - two identically WRONG
-            // frames would otherwise pass.
-            EXPECT_EQ(asyncImage.QuadrantSignature(), "blue,green,red,white")
-                << "the asynchronously compiled program did not draw the expected frame";
-            EXPECT_EQ(asyncImage, syncImage)
-                << "asynchronous and synchronous compilation rendered different frames ("
-                << asyncImage.ByteDiffCount(syncImage) << " bytes differ); backend " << Gl().BackendName();
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-        // The same comparison over a batch, which is the shape a shaderpack load has:
-        // many programs enqueued before any of them is read back, then each one drawn.
-        // A per-worker state leak (glslang's thread-local pools are the obvious
-        // candidate) shows up here and not in the single-program case above.
-        TEST_F(AsyncCompileScenario, ABatchOfAsyncProgramsAllRenderCorrectly) {
-            if (!Ready()) return;
-            constexpr int kPrograms = 12;
-
-            std::vector<GLuint> programs;
-            {
-                const AsyncModeScope async(true);
-                const CompilerThreadScope threads;
-                glMaxShaderCompilerThreadsKHR(1);
-                // Everything enqueued before anything is read: the only shape in which
-                // more than one job is in flight at a time.
-                for (int i = 0; i < kPrograms; ++i) {
-                    programs.push_back(BuildProgram());
-                }
-            }
-
-            for (int i = 0; i < kPrograms; ++i) {
-                ASSERT_NE(programs[static_cast<std::size_t>(i)], 0u) << "program " << i;
-                const Image image = DrawFrameWith(programs[static_cast<std::size_t>(i)]);
-                EXPECT_EQ(image.QuadrantSignature(), "blue,green,red,white") << "program " << i;
-            }
-            for (const GLuint program : programs) glDeleteProgram(program);
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-    } // namespace
-} // namespace MGITest

MobileGL/MG_IntegrationTest/Scenarios/CrossFrameBufferScenario.cpp

@@ -1,761 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/CrossFrameBufferScenario.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
-//
-// Scenario B - "the draw rendered last frame's buffer".
-//
-// The shipped bug (DirectVulkan, TryBindResolvedVertexBindings and the EBO
-// memo in UploadAndBindIndexBuffer): both memos revalidated themselves ACROSS a
-// frame boundary by comparing recorded per-buffer slice epochs, and on a match
-// skipped the per-frame buffer acquire. The acquire is the frame's content-sync
-// point; skipping it trusted the BumpSliceEpoch call-site inventory to cover
-// every way a buffer's GPU copy can go stale, and at least one path escaped it.
-// Result: a draw in a later frame renders from a STALE buffer slice - random
-// triangles in Minecraft/Sodium on Adreno, corrupted journeymap and
-// common-mods retraces.
-//
-// What pins it: mutate a buffer AFTER a frame boundary and BEFORE the next
-// draw, then prove the pixels show the NEW content. Every mutation API gets its
-// own test case, so a failure names the culprit rather than saying "buffers".
-// The index buffer is covered too: the EBO memo had exactly the same hole.
-//
-// The scene is deliberately trivial and entirely buffer-driven:
-//
-//     vertices 0..3   left half of the viewport,  RED
-//     vertices 4..7   right half of the viewport, GREEN
-//     indices  A      {0,1,2, 0,2,3}  -> the left, red quad
-//     indices  B      {4,5,6, 4,6,7}  -> the right, green quad
-//
-// A vertex-buffer test rewrites the left quad's colour red -> green and expects
-// the left half to turn green. An index-buffer test rewrites the indices
-// A -> B and expects the picture to jump from a red left half to a green right
-// half. Either way "stale" and "fresh" are different colours in different
-// places; no thresholds, no interpretation.
-//
-// Two families of scenario live here, and they catch different halves of the
-// same rule:
-//
-//   CrossFrameBufferScenario - one case per buffer-mutation API. Every one of
-//     these APIs is supposed to retire the memo; today they all do (each notify
-//     path bumps the slice epoch), so these pass on the buggy revision too.
-//     They are the standing statement of the contract: whatever a future memo
-//     keys on, a write through ANY of these APIs must reach the next frame's
-//     draw. They are also where a coherent persistent write - the one shape
-//     that changes a buffer with no GL call at all - is pinned.
-//
-//   StreamedArenaScenario - the case that actually caught the shipped bug. It
-//     attacks the other half of the rule: a buffer nobody wrote at all, whose
-//     GPU-side bytes moved out from under the memo anyway.
-
-#include <cstdio>
-#include <cstring>
-#include <functional>
-#include <string>
-#include <vector>
-
-#include "../Harness/HeadlessGL.h"
-#include "../Harness/ScenarioFixture.h"
-
-#ifdef GLAPI
-#undef GLAPI
-#endif
-#define GL_GLEXT_PROTOTYPES
-#include <GL/gl.h>
-#include <GL/glcorearb.h>
-#undef GL_GLEXT_PROTOTYPES
-
-namespace MGITest {
-    namespace {
-
-        constexpr const char* kVertexSource = R"(#version 330 core
-in vec2 aPos;
-in vec3 aColor;
-out vec3 vColor;
-void main() {
-    vColor = aColor;
-    gl_Position = vec4(aPos, 0.0, 1.0);
-}
-)";
-
-        constexpr const char* kFragmentSource = R"(#version 330 core
-in vec3 vColor;
-out vec4 oColor;
-void main() {
-    oColor = vec4(vColor, 1.0);
-}
-)";
-
-        struct Vertex {
-            float x, y;
-            float r, g, b;
-        };
-
-        constexpr int kLeftQuadFirstVertex = 0;
-        constexpr int kLeftQuadVertexCount = 4;
-        constexpr int kIndexCount = 6;
-
-        // Enough consecutive frames drawing the same VAO that any per-(VAO, frame)
-        // memo is fully armed before the mutation lands.
-        constexpr int kWarmupFrames = 3;
-
-        std::vector<Vertex> SceneVertices(bool leftQuadIsGreen) {
-            const float lr = leftQuadIsGreen ? 0.0f : 1.0f;
-            const float lg = leftQuadIsGreen ? 1.0f : 0.0f;
-            return {
-                // 0..3: left half
-                {-1.0f, -1.0f, lr, lg, 0.0f},
-                {0.0f, -1.0f, lr, lg, 0.0f},
-                {0.0f, 1.0f, lr, lg, 0.0f},
-                {-1.0f, 1.0f, lr, lg, 0.0f},
-                // 4..7: right half
-                {0.0f, -1.0f, 0.0f, 1.0f, 0.0f},
-                {1.0f, -1.0f, 0.0f, 1.0f, 0.0f},
-                {1.0f, 1.0f, 0.0f, 1.0f, 0.0f},
-                {0.0f, 1.0f, 0.0f, 1.0f, 0.0f},
-            };
-        }
-
-        const GLuint kIndicesLeftQuad[kIndexCount] = {0, 1, 2, 0, 2, 3};
-        const GLuint kIndicesRightQuad[kIndexCount] = {4, 5, 6, 4, 6, 7};
-
-        // How far inside each half the whole-region checks start. The two quads
-        // meet on a pixel boundary, so a couple of pixels of margin makes "every
-        // single pixel in the region" an achievable demand.
-        constexpr int kHalfInset = 2;
-
-        // Asserts the left and right halves of the viewport, with a message that
-        // says what the app had asked GL to draw by then.
-        //
-        // This counts EVERY pixel in each half rather than sampling its centre.
-        // Sampling two pixels was demonstrably too weak: a draw in which three of
-        // the left quad's four vertices still carry stale data paints a centre
-        // pixel of exactly the expected colour and passed the old assertion. That
-        // case is now a standing negative control - see
-        // PartialStalenessIsCaughtByWholeRegionChecks below, which constructs it
-        // deliberately and proves the region scan reports it.
-        void ExpectHalves(const Image& image, const char* expectedLeft, const char* expectedRight,
-                          const std::string& when) {
-            const int w = image.Width();
-            const int h = image.Height();
-            EXPECT_TRUE(RegionIsMostly(image, kHalfInset, w / 2 - kHalfInset, kHalfInset, h - kHalfInset, expectedLeft,
-                                       0.0, when + " [left half]"));
-            EXPECT_TRUE(RegionIsMostly(image, w / 2 + kHalfInset, w - kHalfInset, kHalfInset, h - kHalfInset,
-                                       expectedRight, 0.0, when + " [right half]"));
-        }
-
-        // How the app hands the new bytes to GL. Each is its own test case.
-        enum class Mutation {
-            SubData,            // glBufferSubData
-            MapWriteUnmap,      // glMapBufferRange(WRITE) + glUnmapBuffer
-            PersistentFlush,    // write through a persistent map + glFlushMappedBufferRange
-            PersistentCoherent, // write through a COHERENT persistent map, no GL call at all
-            OrphanReupload,     // glBufferData(NULL) then a full re-upload
-            CopySubData,        // glCopyBufferSubData from a staging buffer
-        };
-
-        bool NeedsImmutableStorage(Mutation mutation) {
-            return mutation == Mutation::PersistentFlush || mutation == Mutation::PersistentCoherent;
-        }
-
-        // The coherent variant is the one shape in which an application changes a
-        // buffer's contents with NO GL call whatsoever - the write lands in the
-        // mapping and that is the end of it. Sodium's chunk streaming is written
-        // this way, and it is the case a per-buffer "has anything changed?" epoch
-        // cannot see on its own.
-        bool NeedsCoherentMapping(Mutation mutation) {
-            return mutation == Mutation::PersistentCoherent;
-        }
-
-        class CrossFrameBufferScenario : public ScenarioTest {
-        protected:
-            void SetUp() override {
-                ScenarioTest::SetUp();
-                if (!Ready()) return;
-                std::string error;
-                m_program = CompileProgram(kVertexSource, kFragmentSource, &error);
-                ASSERT_NE(m_program, 0u) << error;
-                ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR)) << "program setup left a GL error behind";
-            }
-
-            void TearDown() override {
-                if (!Ready()) return;
-                ReleaseBuffers();
-                if (m_program != 0) glDeleteProgram(m_program);
-            }
-
-            // Builds the VAO/VBO/EBO. `immutable` switches to glBufferStorage plus a
-            // persistent mapping of both buffers, which is the only shape in which the
-            // persistent-write mutation is legal.
-            void BuildScene(bool immutable, bool coherent = false) {
-                const std::vector<Vertex> vertices = SceneVertices(/*leftQuadIsGreen=*/false);
-                m_vertexBytes = GLsizeiptr(vertices.size() * sizeof(Vertex));
-                m_indexBytes = GLsizeiptr(sizeof(kIndicesLeftQuad));
-
-                glGenVertexArrays(1, &m_vao);
-                glBindVertexArray(m_vao);
-
-                glGenBuffers(1, &m_vbo);
-                glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-                glGenBuffers(1, &m_ebo);
-                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
-
-                if (immutable) {
-                    const GLbitfield storageFlags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_DYNAMIC_STORAGE_BIT |
-                                                    (coherent ? GL_MAP_COHERENT_BIT : 0);
-                    glBufferStorage(GL_ARRAY_BUFFER, m_vertexBytes, vertices.data(), storageFlags);
-                    glBufferStorage(GL_ELEMENT_ARRAY_BUFFER, m_indexBytes, kIndicesLeftQuad, storageFlags);
-                    const GLenum storageError = FirstGLError();
-                    if (storageError != GL_NO_ERROR) {
-                        m_storageUnsupported = true;
-                        m_storageError = storageError;
-                        return;
-                    }
-                    const GLbitfield mapFlags = GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT |
-                                                (coherent ? GL_MAP_COHERENT_BIT : GL_MAP_FLUSH_EXPLICIT_BIT);
-                    m_vertexMap =
-                        static_cast<unsigned char*>(glMapBufferRange(GL_ARRAY_BUFFER, 0, m_vertexBytes, mapFlags));
-                    m_indexMap = static_cast<unsigned char*>(
-                        glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, m_indexBytes, mapFlags));
-                    if (m_vertexMap == nullptr || m_indexMap == nullptr) {
-                        m_storageUnsupported = true;
-                        m_storageError = FirstGLError();
-                        return;
-                    }
-                } else {
-                    glBufferData(GL_ARRAY_BUFFER, m_vertexBytes, vertices.data(), GL_STATIC_DRAW);
-                    glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_indexBytes, kIndicesLeftQuad, GL_STATIC_DRAW);
-                }
-
-                glEnableVertexAttribArray(0);
-                glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(0));
-                glEnableVertexAttribArray(1);
-                glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(8));
-                glBindVertexArray(0);
-
-                glGenBuffers(1, &m_staging);
-                ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR)) << "scene setup left a GL error behind";
-            }
-
-            void ReleaseBuffers() {
-                if (m_vertexMap != nullptr || m_indexMap != nullptr) {
-                    glBindVertexArray(m_vao);
-                    if (m_vertexMap != nullptr) {
-                        glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-                        glUnmapBuffer(GL_ARRAY_BUFFER);
-                    }
-                    if (m_indexMap != nullptr) {
-                        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
-                        glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
-                    }
-                    glBindVertexArray(0);
-                    m_vertexMap = nullptr;
-                    m_indexMap = nullptr;
-                }
-                if (m_staging != 0) glDeleteBuffers(1, &m_staging);
-                if (m_ebo != 0) glDeleteBuffers(1, &m_ebo);
-                if (m_vbo != 0) glDeleteBuffers(1, &m_vbo);
-                if (m_vao != 0) glDeleteVertexArrays(1, &m_vao);
-                m_staging = m_ebo = m_vbo = m_vao = 0;
-            }
-
-            void DrawScene() {
-                glDisable(GL_DEPTH_TEST);
-                glDisable(GL_BLEND);
-                glUseProgram(m_program);
-                glBindVertexArray(m_vao);
-                glDrawElements(GL_TRIANGLES, kIndexCount, GL_UNSIGNED_INT, nullptr);
-                glBindVertexArray(0);
-            }
-
-            void BeginFrame() {
-                BindDefaultFramebuffer();
-                ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
-            }
-
-            Image ReadFrame() { return ReadPixels(Gl().Width(), Gl().Height()); }
-
-            // ---- the mutations ---------------------------------------------
-            // Each writes `newBytes` over the first `rangeBytes` of `buffer`;
-            // `wholeBytes`/`wholeSize` are the full contents an orphan+re-upload
-            // needs. `target` is the binding point the buffer normally lives at.
-            void ApplyMutation(Mutation mutation, GLenum target, GLuint buffer, unsigned char* persistentMap,
-                               const void* newBytes, GLsizeiptr rangeBytes, const void* wholeBytes,
-                               GLsizeiptr wholeSize) {
-                // The element-array binding is VAO state, so mutating the EBO happens
-                // with the scene's VAO bound - exactly as an application would.
-                glBindVertexArray(m_vao);
-                switch (mutation) {
-                case Mutation::SubData: {
-                    glBindBuffer(target, buffer);
-                    glBufferSubData(target, 0, rangeBytes, newBytes);
-                    break;
-                }
-                case Mutation::MapWriteUnmap: {
-                    glBindBuffer(target, buffer);
-                    void* mapped =
-                        glMapBufferRange(target, 0, rangeBytes, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT);
-                    ASSERT_NE(mapped, nullptr) << "glMapBufferRange(WRITE) returned null";
-                    std::memcpy(mapped, newBytes, std::size_t(rangeBytes));
-                    ASSERT_EQ(glUnmapBuffer(target), GLboolean(GL_TRUE)) << "glUnmapBuffer reported data loss";
-                    break;
-                }
-                case Mutation::PersistentFlush: {
-                    ASSERT_NE(persistentMap, nullptr) << "no persistent mapping for this buffer";
-                    std::memcpy(persistentMap, newBytes, std::size_t(rangeBytes));
-                    glBindBuffer(target, buffer);
-                    glFlushMappedBufferRange(target, 0, rangeBytes);
-                    break;
-                }
-                case Mutation::PersistentCoherent: {
-                    // Deliberately no GL call: a coherent persistent mapping is a
-                    // promise that the write alone is enough.
-                    ASSERT_NE(persistentMap, nullptr) << "no persistent mapping for this buffer";
-                    std::memcpy(persistentMap, newBytes, std::size_t(rangeBytes));
-                    break;
-                }
-                case Mutation::OrphanReupload: {
-                    glBindBuffer(target, buffer);
-                    glBufferData(target, wholeSize, nullptr, GL_STATIC_DRAW);
-                    glBufferSubData(target, 0, wholeSize, wholeBytes);
-                    break;
-                }
-                case Mutation::CopySubData: {
-                    glBindBuffer(GL_COPY_READ_BUFFER, m_staging);
-                    glBufferData(GL_COPY_READ_BUFFER, rangeBytes, newBytes, GL_STATIC_DRAW);
-                    glBindBuffer(GL_COPY_WRITE_BUFFER, buffer);
-                    glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, rangeBytes);
-                    glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
-                    glBindBuffer(GL_COPY_READ_BUFFER, 0);
-                    break;
-                }
-                }
-                glBindVertexArray(0);
-                ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR)) << "the mutation itself raised a GL error";
-            }
-
-            // ---- the story -------------------------------------------------
-            // Steady state for a few frames, one frame boundary, then the
-            // mutation, then the draw that must show the new content.
-            void RunAcrossFrameBoundary(Mutation mutation, const std::function<void()>& mutate,
-                                        const char* expectedLeftAfter, const char* expectedRightAfter) {
-                ASSERT_NO_FATAL_FAILURE(BuildScene(NeedsImmutableStorage(mutation), NeedsCoherentMapping(mutation)));
-                if (m_storageUnsupported) {
-                    GTEST_SKIP() << "immutable/persistent buffer storage is unavailable on this stack ("
-                                 << GLErrorName(m_storageError) << "); the persistent-map mutation cannot "
-                                 << "be expressed here";
-                }
-
-                for (int frame = 0; frame < kWarmupFrames; ++frame) {
-                    BeginFrame();
-                    DrawScene();
-                    Gl().EndFrame();
-                }
-
-                BeginFrame();
-                DrawScene();
-                const Image before = ReadFrame();
-                ExpectHalves(before, "red", "black", "steady state before the mutation");
-                ASSERT_FALSE(::testing::Test::HasFailure())
-                    << "the scenario never reached its steady state, so nothing after this means anything";
-
-                // >>> a genuine frame boundary. Everything below happens in the NEXT
-                // frame, which is the whole point: a mutation inside one frame proves
-                // nothing about a memo that revalidates itself across frames.
-                Gl().EndFrame();
-
-                BeginFrame();
-                ASSERT_NO_FATAL_FAILURE(mutate());
-                DrawScene();
-                const Image after = ReadFrame();
-                Gl().EndFrame();
-
-                ExpectHalves(after, expectedLeftAfter, expectedRightAfter,
-                             "the draw after the mutation drew STALE buffer content");
-                EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-            }
-
-            // The two things a scenario mutates.
-            void MutateVertexColorsToGreen(Mutation mutation) {
-                const std::vector<Vertex> updated = SceneVertices(/*leftQuadIsGreen=*/true);
-                const GLsizeiptr leftQuadBytes = GLsizeiptr(kLeftQuadVertexCount * sizeof(Vertex));
-                ApplyMutation(mutation, GL_ARRAY_BUFFER, m_vbo, m_vertexMap, updated.data() + kLeftQuadFirstVertex,
-                              leftQuadBytes, updated.data(), m_vertexBytes);
-            }
-
-            void MutateIndicesToRightQuad(Mutation mutation) {
-                ApplyMutation(mutation, GL_ELEMENT_ARRAY_BUFFER, m_ebo, m_indexMap, kIndicesRightQuad, m_indexBytes,
-                              kIndicesRightQuad, m_indexBytes);
-            }
-
-            unsigned int m_program = 0;
-            unsigned int m_vao = 0;
-            unsigned int m_vbo = 0;
-            unsigned int m_ebo = 0;
-            unsigned int m_staging = 0;
-            GLsizeiptr m_vertexBytes = 0;
-            GLsizeiptr m_indexBytes = 0;
-            unsigned char* m_vertexMap = nullptr;
-            unsigned char* m_indexMap = nullptr;
-            bool m_storageUnsupported = false;
-            unsigned int m_storageError = 0;
-        };
-
-        // ---- vertex buffer: the left quad must turn green ------------------
-
-        TEST_F(CrossFrameBufferScenario, VertexBufferSubData) {
-            RunAcrossFrameBoundary(
-                Mutation::SubData, [&] { MutateVertexColorsToGreen(Mutation::SubData); }, "green", "black");
-        }
-
-        TEST_F(CrossFrameBufferScenario, VertexMapWriteUnmap) {
-            RunAcrossFrameBoundary(
-                Mutation::MapWriteUnmap, [&] { MutateVertexColorsToGreen(Mutation::MapWriteUnmap); }, "green", "black");
-        }
-
-        TEST_F(CrossFrameBufferScenario, VertexPersistentMapFlush) {
-            RunAcrossFrameBoundary(
-                Mutation::PersistentFlush, [&] { MutateVertexColorsToGreen(Mutation::PersistentFlush); }, "green",
-                "black");
-        }
-
-        TEST_F(CrossFrameBufferScenario, VertexPersistentCoherentWrite) {
-            RunAcrossFrameBoundary(
-                Mutation::PersistentCoherent, [&] { MutateVertexColorsToGreen(Mutation::PersistentCoherent); }, "green",
-                "black");
-        }
-
-        TEST_F(CrossFrameBufferScenario, VertexOrphanAndReupload) {
-            RunAcrossFrameBoundary(
-                Mutation::OrphanReupload, [&] { MutateVertexColorsToGreen(Mutation::OrphanReupload); }, "green",
-                "black");
-        }
-
-        TEST_F(CrossFrameBufferScenario, VertexCopyBufferSubData) {
-            RunAcrossFrameBoundary(
-                Mutation::CopySubData, [&] { MutateVertexColorsToGreen(Mutation::CopySubData); }, "green", "black");
-        }
-
-        // ---- index buffer: the picture must jump to the right, green quad --
-        // The EBO memo had the same cross-frame hole as the vertex one, and no
-        // vertex-only test can see it.
-
-        TEST_F(CrossFrameBufferScenario, IndexBufferSubData) {
-            RunAcrossFrameBoundary(
-                Mutation::SubData, [&] { MutateIndicesToRightQuad(Mutation::SubData); }, "black", "green");
-        }
-
-        TEST_F(CrossFrameBufferScenario, IndexMapWriteUnmap) {
-            RunAcrossFrameBoundary(
-                Mutation::MapWriteUnmap, [&] { MutateIndicesToRightQuad(Mutation::MapWriteUnmap); }, "black", "green");
-        }
-
-        TEST_F(CrossFrameBufferScenario, IndexPersistentMapFlush) {
-            RunAcrossFrameBoundary(
-                Mutation::PersistentFlush, [&] { MutateIndicesToRightQuad(Mutation::PersistentFlush); }, "black",
-                "green");
-        }
-
-        // Kept, with its coverage stated exactly, because it is the one case in
-        // this file that is served a stale slice by the buggy revision and passes
-        // anyway - and a test that reads as coverage without being coverage is
-        // worse than no test.
-        //
-        // COVERS: the coherent-persistent index contract - a write into a coherent
-        // persistent mapping, with no GL call at all, must reach the next frame's
-        // draw. That is a real contract and this is the only case that states it
-        // for indices.
-        //
-        // DOES NOT COVER: the EBO cross-frame memo. Instrumented against the
-        // re-enabled buggy path, it enters the cross-frame branch 4 times and is
-        // served its recorded slice all 4 times - and still passes, because the
-        // backend adopted the persistent map into that very storage
-        // (AcquirePersistentMap succeeded), so the application's writes landed in
-        // the bytes the "stale" slice names. It would only discriminate on a stack
-        // where that adoption is declined and the CPU shadow stays authoritative;
-        // measured over this whole module, 50 of 50 coherent persistent write maps
-        // were adopted. See ResidentIndexScenario.cpp for the full account.
-        TEST_F(CrossFrameBufferScenario, IndexPersistentCoherentWrite) {
-            RunAcrossFrameBoundary(
-                Mutation::PersistentCoherent, [&] { MutateIndicesToRightQuad(Mutation::PersistentCoherent); }, "black",
-                "green");
-        }
-
-        TEST_F(CrossFrameBufferScenario, IndexOrphanAndReupload) {
-            RunAcrossFrameBoundary(
-                Mutation::OrphanReupload, [&] { MutateIndicesToRightQuad(Mutation::OrphanReupload); }, "black",
-                "green");
-        }
-
-        TEST_F(CrossFrameBufferScenario, IndexCopyBufferSubData) {
-            RunAcrossFrameBoundary(
-                Mutation::CopySubData, [&] { MutateIndicesToRightQuad(Mutation::CopySubData); }, "black", "green");
-        }
-
-        // ---- a self-test of the assertions, not of MobileGL ------------------
-        //
-        // Every case above leans on ExpectHalves. ExpectHalves used to sample the
-        // centre pixel of each half - two pixels for a 12288-pixel readback - and
-        // that is measurably too weak to stand behind a claim about buffer
-        // freshness: a quad whose four vertices are only PARTLY updated still
-        // paints a sampled centre the expected colour, because the centre is a
-        // barycentric blend dominated by the vertices that DID update.
-        //
-        // So construct that case on purpose. Update the left quad's colour to
-        // green in the buffer but leave exactly one of its four vertices holding
-        // the old red, once for each vertex, and check two things:
-        //
-        //   - the whole-region scan reports every one of the four (the tightening
-        //     is real, and this test fails the moment someone loosens it back to
-        //     sampling);
-        //   - at least one of the four is invisible to a single centre sample
-        //     (the blind spot was real, and this records which vertices it hid).
-        //
-        // Nothing here calls a memo path; it is the assertion itself under test.
-        TEST_F(CrossFrameBufferScenario, PartialStalenessIsCaughtByWholeRegionChecks) {
-            ASSERT_NO_FATAL_FAILURE(BuildScene(/*immutable=*/false));
-
-            const std::vector<Vertex> allGreen = SceneVertices(/*leftQuadIsGreen=*/true);
-            const std::vector<Vertex> allRed = SceneVertices(/*leftQuadIsGreen=*/false);
-            const GLsizeiptr leftQuadBytes = GLsizeiptr(kLeftQuadVertexCount * sizeof(Vertex));
-
-            int centreSampleMissed = 0;
-            std::string missedVertices;
-            for (int staleVertex = 0; staleVertex < kLeftQuadVertexCount; ++staleVertex) {
-                // Every left-quad vertex turns green except this one.
-                std::vector<Vertex> partial(allGreen.begin(), allGreen.begin() + kLeftQuadVertexCount);
-                partial[std::size_t(staleVertex)] = allRed[std::size_t(staleVertex)];
-
-                glBindVertexArray(m_vao);
-                glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-                glBufferSubData(GL_ARRAY_BUFFER, 0, leftQuadBytes, partial.data());
-                glBindVertexArray(0);
-                ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR)) << "the partial update itself raised a GL error";
-
-                BeginFrame();
-                DrawScene();
-                const Image image = ReadFrame();
-                Gl().EndFrame();
-
-                const int w = image.Width();
-                const int h = image.Height();
-                const RegionScan scan =
-                    ScanRegion(image, kHalfInset, w / 2 - kHalfInset, kHalfInset, h - kHalfInset, "green");
-                EXPECT_GT(scan.offenders, 0)
-                    << "vertex " << staleVertex << " of the left quad kept its stale red colour and the "
-                    << "whole-region scan saw nothing wrong across " << scan.total << " pixels - the assertion "
-                    << "is not tight enough to stand behind any freshness claim in this file";
-
-                // What the old two-pixel form of ExpectHalves would have concluded.
-                if (std::strcmp(image.ColorName(w / 4, h / 2), "green") == 0) {
-                    ++centreSampleMissed;
-                    if (!missedVertices.empty()) missedVertices += ",";
-                    missedVertices += std::to_string(staleVertex);
-                }
-            }
-
-            EXPECT_GT(centreSampleMissed, 0)
-                << "no single-vertex staleness was invisible to a centre sample, so this negative control "
-                << "is no longer demonstrating anything - re-derive it before trusting it";
-            if (centreSampleMissed > 0) {
-                RecordProperty("centre_sample_blind_to_stale_vertices", missedVertices);
-                std::fprintf(stderr,
-                             "[itest] whole-region scan caught all %d single-stale-vertex cases; a centre "
-                             "sample alone was blind to %d of them (vertices %s)\n",
-                             kLeftQuadVertexCount, centreSampleMissed, missedVertices.c_str());
-            }
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-        // ---- the same bug, seen from the other side --------------------------
-        //
-        // The mutation cases above ask "did the new bytes reach the GPU?". This
-        // one asks the question a STREAMED buffer forces: "do the old bytes even
-        // still exist?".
-        //
-        // A GL_STREAM_DRAW / GL_DYNAMIC_DRAW buffer is not given permanent GPU
-        // storage. Every frame its contents are copied into that frame's
-        // transient upload arena, which is a bump allocator reset at the start of
-        // each frame slot - so a slice handed out in frame N names bytes that
-        // frame N+frames-in-flight hands to whoever uploads first. A memo that
-        // revalidates across a frame boundary and skips the acquire never
-        // re-uploads, so it keeps binding an offset the arena has since given
-        // away: the draw reads whatever the next tenant put there. That is the
-        // "random triangles" shape of this bug - the buffer nobody touched is the
-        // one that renders wrong.
-        //
-        // The scene makes the next tenant deterministic instead of arbitrary: a
-        // second streamed object of exactly the same size is uploaded and drawn
-        // FIRST in every frame, so it lands on precisely the bytes the memo still
-        // points at. A draw that renders the decoy's geometry instead of its own
-        // is unmissable.
-
-        class StreamedArenaScenario : public ScenarioTest {
-        protected:
-            static constexpr int kQuietFrames = 2; // frames in which only the subject draws
-            static constexpr int kChurnFrames = 8; // > frames-in-flight, so the ring wraps
-
-            struct StreamedObject {
-                unsigned int vao = 0;
-                unsigned int vbo = 0;
-                unsigned int ebo = 0;
-            };
-
-            void SetUp() override {
-                ScenarioTest::SetUp();
-                if (!Ready()) return;
-                std::string error;
-                m_program = CompileProgram(kVertexSource, kFragmentSource, &error);
-                ASSERT_NE(m_program, 0u) << error;
-                ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-            }
-
-            void TearDown() override {
-                if (!Ready()) return;
-                for (StreamedObject* object : {&m_subject, &m_decoy}) {
-                    if (object->ebo != 0) glDeleteBuffers(1, &object->ebo);
-                    if (object->vbo != 0) glDeleteBuffers(1, &object->vbo);
-                    if (object->vao != 0) glDeleteVertexArrays(1, &object->vao);
-                    *object = StreamedObject{};
-                }
-                if (m_program != 0) glDeleteProgram(m_program);
-            }
-
-            // GL_STREAM_DRAW is what puts a buffer on the transient arena
-            // (ShouldUseTransientVertexIndexBuffer) - and what Minecraft uses for
-            // exactly this kind of geometry.
-            void BuildStreamedObject(StreamedObject& object, const std::vector<Vertex>& vertices,
-                                     const GLuint (&indices)[kIndexCount]) {
-                glGenVertexArrays(1, &object.vao);
-                glBindVertexArray(object.vao);
-                glGenBuffers(1, &object.vbo);
-                glBindBuffer(GL_ARRAY_BUFFER, object.vbo);
-                glBufferData(GL_ARRAY_BUFFER, GLsizeiptr(vertices.size() * sizeof(Vertex)), vertices.data(),
-                             GL_STREAM_DRAW);
-                glGenBuffers(1, &object.ebo);
-                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, object.ebo);
-                glBufferData(GL_ELEMENT_ARRAY_BUFFER, GLsizeiptr(sizeof(indices)), indices, GL_STREAM_DRAW);
-                glEnableVertexAttribArray(0);
-                glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(0));
-                glEnableVertexAttribArray(1);
-                glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(8));
-                glBindVertexArray(0);
-            }
-
-            void Draw(const StreamedObject& object) {
-                glDisable(GL_DEPTH_TEST);
-                glDisable(GL_BLEND);
-                glUseProgram(m_program);
-                glBindVertexArray(object.vao);
-                glDrawElements(GL_TRIANGLES, kIndexCount, GL_UNSIGNED_INT, nullptr);
-                glBindVertexArray(0);
-            }
-
-            // Re-uploading the decoy is what forces it onto a fresh arena slice
-            // this frame - i.e. what makes it the arena's next tenant.
-            void RestreamDecoy(const std::vector<Vertex>& vertices, const GLuint (&indices)[kIndexCount]) {
-                glBindVertexArray(m_decoy.vao);
-                glBindBuffer(GL_ARRAY_BUFFER, m_decoy.vbo);
-                glBufferSubData(GL_ARRAY_BUFFER, 0, GLsizeiptr(vertices.size() * sizeof(Vertex)), vertices.data());
-                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_decoy.ebo);
-                glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, GLsizeiptr(sizeof(indices)), indices);
-                glBindVertexArray(0);
-            }
-
-            unsigned int m_program = 0;
-            StreamedObject m_subject;
-            StreamedObject m_decoy;
-        };
-
-        // Vertex data. Subject and decoy differ in geometry AND colour, so a
-        // subject draw that reads the decoy's arena bytes paints the decoy's quad.
-        TEST_F(StreamedArenaScenario, StreamedVertexDataSurvivesArenaRecycling) {
-            const std::vector<Vertex> full = SceneVertices(/*leftQuadIsGreen=*/false);
-            const std::vector<Vertex> subjectVertices(full.begin(), full.begin() + 4);   // left, red
-            const std::vector<Vertex> decoyVertices(full.begin() + 4, full.begin() + 8); // right, green
-            ASSERT_EQ(subjectVertices.size(), decoyVertices.size());                     // same arena footprint
-
-            BuildStreamedObject(m_subject, subjectVertices, kIndicesLeftQuad);
-            BuildStreamedObject(m_decoy, decoyVertices, kIndicesLeftQuad);
-            ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR)) << "scene setup left a GL error behind";
-
-            // Quiet frames: the subject is the only thing uploading, so its data
-            // sits at the head of the arena and its memo records that offset.
-            for (int frame = 0; frame < kQuietFrames; ++frame) {
-                BindDefaultFramebuffer();
-                ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
-                Draw(m_subject);
-                Gl().EndFrame();
-            }
-
-            // Churn frames: the decoy re-streams and draws first every frame. The
-            // subject is never touched again - it must still render itself.
-            for (int frame = 0; frame < kChurnFrames; ++frame) {
-                BindDefaultFramebuffer();
-                ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
-                RestreamDecoy(decoyVertices, kIndicesLeftQuad);
-                Draw(m_decoy);
-                Draw(m_subject);
-                const Image image = ReadPixels(Gl().Width(), Gl().Height());
-                ExpectHalves(image, "red", "green",
-                             "churn frame " + std::to_string(frame) +
-                                 ": the untouched streamed vertex buffer rendered someone else's arena bytes");
-                Gl().EndFrame();
-            }
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-        // Index data. Both objects carry the SAME eight vertices, so only the
-        // element buffer can decide which half is drawn - this isolates the EBO
-        // memo, which had its own copy of the cross-frame hole.
-        //
-        // COVERS: that an untouched streamed index buffer still renders its own
-        // geometry after the arena it lives in has been recycled by another
-        // object - the index-side statement of the invariant the vertex case
-        // above actually catches.
-        //
-        // DOES NOT COVER: the EBO cross-frame memo. Instrumented against the
-        // re-enabled buggy path this case reaches that branch ZERO times: the memo
-        // is recorded only on the RESIDENT index path (UploadAndBindIndexBuffer
-        // stores it in the arm after AcquireResidentSlice), and a streamed EBO
-        // never gets there. So it passes on the buggy revision exactly as it does
-        // on the fixed one, and it is not evidence about the fix.
-        //
-        // It stays because it is the tripwire for the change that would make the
-        // EBO memo dangerous: memoise the streamed index path - the obvious next
-        // step for the same optimisation - and the reach stops being zero and this
-        // test fails on the first churn frame. See ResidentIndexScenario.cpp.
-        TEST_F(StreamedArenaScenario, StreamedIndexDataSurvivesArenaRecycling) {
-            const std::vector<Vertex> shared = SceneVertices(/*leftQuadIsGreen=*/false);
-
-            BuildStreamedObject(m_subject, shared, kIndicesLeftQuad); // draws the left, red quad
-            BuildStreamedObject(m_decoy, shared, kIndicesRightQuad);  // draws the right, green quad
-            ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR)) << "scene setup left a GL error behind";
-
-            for (int frame = 0; frame < kQuietFrames; ++frame) {
-                BindDefaultFramebuffer();
-                ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
-                Draw(m_subject);
-                Gl().EndFrame();
-            }
-
-            for (int frame = 0; frame < kChurnFrames; ++frame) {
-                BindDefaultFramebuffer();
-                ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
-                RestreamDecoy(shared, kIndicesRightQuad);
-                Draw(m_decoy);
-                Draw(m_subject);
-                const Image image = ReadPixels(Gl().Width(), Gl().Height());
-                ExpectHalves(image, "red", "green",
-                             "churn frame " + std::to_string(frame) +
-                                 ": the untouched streamed index buffer rendered someone else's arena bytes");
-                Gl().EndFrame();
-            }
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-    } // namespace
-} // namespace MGITest

MobileGL/MG_IntegrationTest/Scenarios/MultiDrawScenario.cpp

@@ -1,522 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/MultiDrawScenario.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
-//
-// Scenario D - glMultiDrawElements(BaseVertex) against the draws it stands for.
-//
-// Neither entry point exists in OpenGL ES, so DirectGLES emulates both through a
-// ladder of tiers (MG_Backend/DirectGLES/MultiDraw.cpp): a native
-// glMultiDrawElementsBaseVertexEXT, synthesized indirect commands drawn one at a
-// time or in one batch, a per-sub-draw replay, a CPU rewrite of the index stream,
-// and a compute shader that flattens the whole batch into a single draw. They
-// share nothing but their contract, which is the one thing asserted here:
-//
-//     a multi-draw must paint exactly what the unrolled single draws paint.
-//
-// The reference side never enters the emulation - it is a loop of
-// glDrawElementsBaseVertex / glDrawElements - so a tier cannot make itself look
-// right by breaking both sides the same way.
-//
-// The Minecraft retraces already cover the common shape (GL_UNSIGNED_INT indices
-// in a bound element array buffer, small base vertices, GL_TRIANGLES) on every
-// tier. What they contain none of, and what these cases are for, is the set of
-// shapes where a tier has to decline or compensate rather than replay:
-//
-//   * narrow index types, where a rewritten stream has to widen (BYTE/SHORT);
-//   * a base vertex past the index type's range, where folding it into the
-//     indices at the source width silently wraps - GL adds base vertices at full
-//     precision, so `ushort index 10 + baseVertex 70000` is vertex 70010 and not
-//     vertex 4474;
-//   * primitive restart, where a rewritten stream must carry the sentinel across
-//     unrebased or the restart is lost and the strip welds shut;
-//   * client-memory index arrays, which have no buffer for the indirect tiers to
-//     address or for the compute tier to read;
-//   * a strip mode, which the flattening tier must decline outright because
-//     concatenation would weld one sub-draw's last primitive to the next
-//     sub-draw's first.
-//
-// One process is one tier (MOBILEGL_ESPRYT_MULTIDRAW_MODE is read once at
-// startup), so a single run exercises whichever tier this driver resolved to.
-// Running the binary once per mode is what covers the ladder; each run is a
-// complete, self-contained proof for the tier it landed on.
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include "../Harness/HeadlessGL.h"
-#include "../Harness/ScenarioFixture.h"
-
-#ifdef GLAPI
-#undef GLAPI
-#endif
-#define GL_GLEXT_PROTOTYPES
-#include <GL/gl.h>
-#include <GL/glext.h>
-
-namespace MGITest {
-    namespace {
-
-        constexpr const char* kVertexSource = R"(#version 330 core
-layout(location = 0) in vec2 aPos;
-layout(location = 1) in vec3 aColor;
-out vec3 vColor;
-void main() {
-    vColor = aColor;
-    gl_Position = vec4(aPos, 0.0, 1.0);
-}
-)";
-
-        constexpr const char* kFragmentSource = R"(#version 330 core
-in vec3 vColor;
-out vec4 oColor;
-void main() {
-    oColor = vec4(vColor, 1.0);
-}
-)";
-
-        struct Vertex {
-            float x, y;
-            float r, g, b;
-        };
-
-        // Four column quads spanning the viewport left to right, in four colours,
-        // so a sub-draw that lands in the wrong place, draws the wrong vertices or
-        // does not draw at all changes the picture rather than hiding inside it.
-        constexpr int kColumns = 4;
-
-        const Rgba8 kColumnColors[kColumns] = {
-            {255, 0, 0, 255},
-            {0, 255, 0, 255},
-            {0, 0, 255, 255},
-            {255, 255, 255, 255},
-        };
-
-        // `padVertices` leading dummies force every sub-draw to need its own base
-        // vertex: without one applied, a draw reads the padding and paints black.
-        std::vector<Vertex> ColumnVertices(int padVertices) {
-            std::vector<Vertex> vertices(static_cast<std::size_t>(padVertices), Vertex{0.0f, 0.0f, 0.0f, 0.0f, 0.0f});
-            for (int column = 0; column < kColumns; ++column) {
-                const float x0 = -1.0f + 2.0f * static_cast<float>(column) / kColumns;
-                const float x1 = -1.0f + 2.0f * static_cast<float>(column + 1) / kColumns;
-                const Rgba8 color = kColumnColors[column];
-                const float r = color.r / 255.0f;
-                const float g = color.g / 255.0f;
-                const float b = color.b / 255.0f;
-                vertices.push_back({x0, -1.0f, r, g, b});
-                vertices.push_back({x1, -1.0f, r, g, b});
-                vertices.push_back({x1, 1.0f, r, g, b});
-                vertices.push_back({x0, 1.0f, r, g, b});
-            }
-            return vertices;
-        }
-
-        // Every sub-draw uses the SAME six indices, 0..3 relative to its own quad;
-        // only the base vertex tells the columns apart. That makes the base vertex
-        // the load-bearing part of the batch.
-        const std::uint32_t kQuadIndices[6] = {0, 1, 2, 0, 2, 3};
-
-        // One column, as a restart-separated pair of triangle strips. Two strips in
-        // one sub-draw means the sentinel is genuinely interior: drop it and the two
-        // halves weld into a single strip that paints across the gap between them.
-        // Indices are relative to the sub-draw's own quad, like kQuadIndices.
-        template <typename Index>
-        std::vector<Index> RestartStripIndices(Index restartSentinel) {
-            // 3,0,2,1 is the strip winding of the quad; splitting it around the
-            // sentinel gives two degenerate-free halves that redraw the same area.
-            return {Index{3}, Index{0}, Index{2}, restartSentinel, Index{0}, Index{2}, Index{1}};
-        }
-
-        class MultiDrawScenario : public ScenarioTest {
-        protected:
-            void SetUp() override {
-                ScenarioTest::SetUp();
-                if (!Ready()) return;
-                std::string error;
-                m_program = CompileProgram(kVertexSource, kFragmentSource, &error);
-                ASSERT_NE(m_program, 0u) << error;
-                ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR)) << "program setup left a GL error behind";
-            }
-
-            void TearDown() override {
-                if (!Ready()) return;
-                ReleaseBuffers();
-                if (m_program != 0) glDeleteProgram(m_program);
-            }
-
-            // VAO + VBO, and an EBO only when `indexBytes` is non-null: a null one
-            // leaves GL_ELEMENT_ARRAY_BUFFER unbound so the sub-draws address client
-            // memory, which is the shape that forces the buffer-reading tiers out.
-            void BuildScene(int padVertices, const void* indexBytes, std::size_t indexByteCount) {
-                ReleaseBuffers();
-                const std::vector<Vertex> vertices = ColumnVertices(padVertices);
-
-                glGenVertexArrays(1, &m_vao);
-                glBindVertexArray(m_vao);
-                glGenBuffers(1, &m_vbo);
-                glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-                glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(vertices.size() * sizeof(Vertex)),
-                             vertices.data(), GL_STATIC_DRAW);
-                glEnableVertexAttribArray(0);
-                glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<const void*>(0));
-                glEnableVertexAttribArray(1);
-                glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-                                      reinterpret_cast<const void*>(sizeof(float) * 2));
-
-                if (indexBytes != nullptr) {
-                    glGenBuffers(1, &m_ebo);
-                    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
-                    glBufferData(GL_ELEMENT_ARRAY_BUFFER, static_cast<GLsizeiptr>(indexByteCount), indexBytes,
-                                 GL_STATIC_DRAW);
-                }
-                ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR)) << "scene setup left a GL error behind";
-            }
-
-            void ReleaseBuffers() {
-                if (m_ebo != 0) glDeleteBuffers(1, &m_ebo);
-                if (m_vbo != 0) glDeleteBuffers(1, &m_vbo);
-                if (m_vao != 0) glDeleteVertexArrays(1, &m_vao);
-                m_ebo = 0;
-                m_vbo = 0;
-                m_vao = 0;
-            }
-
-            GLuint m_program = 0;
-            GLuint m_vao = 0;
-            GLuint m_vbo = 0;
-            GLuint m_ebo = 0;
-        };
-
-        // Runs `draw`, reads the default framebuffer back and returns the image.
-        template <typename DrawFn>
-        Image RenderPass(GLuint program, GLuint vao, DrawFn&& draw) {
-            BindDefaultFramebuffer();
-            glViewport(0, 0, HeadlessGL::Get().Width(), HeadlessGL::Get().Height());
-            ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
-            glUseProgram(program);
-            glBindVertexArray(vao);
-            draw();
-            return ReadPixels(HeadlessGL::Get().Width(), HeadlessGL::Get().Height());
-        }
-
-        // The whole point of the file: two renderings of the same geometry, one
-        // through the multi-draw emulation and one through the single-draw entry
-        // points it stands for, must be identical to the byte.
-        void ExpectSameImage(const Image& multiDraw, const Image& unrolled, const std::string& what) {
-            ASSERT_FALSE(multiDraw.Empty()) << what << ": multi-draw readback was empty";
-            ASSERT_FALSE(unrolled.Empty()) << what << ": reference readback was empty";
-            EXPECT_EQ(multiDraw, unrolled)
-                << what << ": glMultiDraw* painted something else than the draws it stands for ("
-                << multiDraw.ByteDiffCount(unrolled) << " bytes differ; multi-draw quadrants "
-                << multiDraw.QuadrantSignature() << ", unrolled quadrants " << unrolled.QuadrantSignature() << ")";
-            // A pair of blank frames would satisfy the comparison above and prove
-            // nothing at all - the failure mode a multi-draw path most often has is
-            // drawing NOTHING (see the shipped glMultiDrawElementsBaseVertexEXT stub
-            // that silently dropped every draw). Demand the columns really landed.
-            EXPECT_NE(multiDraw.QuadrantSignature(), "black,black,black,black") << what << ": nothing was drawn at all";
-        }
-
-        // ---- GL_UNSIGNED_INT indices in a buffer, per-sub-draw base vertices ----
-
-        TEST_F(MultiDrawScenario, BaseVertexBatchMatchesUnrolledDraws) {
-            if (!Ready()) return;
-            constexpr int kPad = 5; // odd, so nothing lines up by accident
-            BuildScene(kPad, kQuadIndices, sizeof(kQuadIndices));
-
-            GLsizei counts[kColumns];
-            const void* offsets[kColumns];
-            GLint baseVertices[kColumns];
-            for (int i = 0; i < kColumns; ++i) {
-                counts[i] = 6;
-                offsets[i] = reinterpret_cast<const void*>(0);
-                baseVertices[i] = kPad + i * 4;
-            }
-
-            const Image batched = RenderPass(m_program, m_vao, [&] {
-                glMultiDrawElementsBaseVertex(GL_TRIANGLES, counts, GL_UNSIGNED_INT, offsets, kColumns, baseVertices);
-            });
-            const Image unrolled = RenderPass(m_program, m_vao, [&] {
-                for (int i = 0; i < kColumns; ++i) {
-                    glDrawElementsBaseVertex(GL_TRIANGLES, counts[i], GL_UNSIGNED_INT, offsets[i], baseVertices[i]);
-                }
-            });
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-            ExpectSameImage(batched, unrolled, "GL_UNSIGNED_INT indices, per-sub-draw base vertices");
-        }
-
-        // ---- glMultiDrawElements: no base vertices, distinct index offsets ----
-
-        TEST_F(MultiDrawScenario, PlainBatchMatchesUnrolledDraws) {
-            if (!Ready()) return;
-            // No padding and no base vertices: each sub-draw reaches its own column
-            // through its index offset instead.
-            std::vector<std::uint32_t> indices;
-            for (int column = 0; column < kColumns; ++column) {
-                for (const std::uint32_t index : kQuadIndices) {
-                    indices.push_back(index + static_cast<std::uint32_t>(column * 4));
-                }
-            }
-            BuildScene(0, indices.data(), indices.size() * sizeof(std::uint32_t));
-
-            GLsizei counts[kColumns];
-            const void* offsets[kColumns];
-            for (int i = 0; i < kColumns; ++i) {
-                counts[i] = 6;
-                offsets[i] = reinterpret_cast<const void*>(static_cast<std::uintptr_t>(i * 6 * sizeof(std::uint32_t)));
-            }
-
-            const Image batched = RenderPass(m_program, m_vao, [&] {
-                glMultiDrawElements(GL_TRIANGLES, counts, GL_UNSIGNED_INT, offsets, kColumns);
-            });
-            const Image unrolled = RenderPass(m_program, m_vao, [&] {
-                for (int i = 0; i < kColumns; ++i) {
-                    glDrawElements(GL_TRIANGLES, counts[i], GL_UNSIGNED_INT, offsets[i]);
-                }
-            });
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-            ExpectSameImage(batched, unrolled, "glMultiDrawElements with no base vertices");
-        }
-
-        // ---- narrow index types ----
-        // A tier that rewrites the stream emits GL_UNSIGNED_INT whatever came in,
-        // so these two say the widening reproduces the original draw exactly.
-
-        TEST_F(MultiDrawScenario, UnsignedShortBatchMatchesUnrolledDraws) {
-            if (!Ready()) return;
-            constexpr int kPad = 3;
-            std::uint16_t indices[6];
-            for (int i = 0; i < 6; ++i)
-                indices[i] = static_cast<std::uint16_t>(kQuadIndices[i]);
-            BuildScene(kPad, indices, sizeof(indices));
-
-            GLsizei counts[kColumns];
-            const void* offsets[kColumns];
-            GLint baseVertices[kColumns];
-            for (int i = 0; i < kColumns; ++i) {
-                counts[i] = 6;
-                offsets[i] = reinterpret_cast<const void*>(0);
-                baseVertices[i] = kPad + i * 4;
-            }
-
-            const Image batched = RenderPass(m_program, m_vao, [&] {
-                glMultiDrawElementsBaseVertex(GL_TRIANGLES, counts, GL_UNSIGNED_SHORT, offsets, kColumns, baseVertices);
-            });
-            const Image unrolled = RenderPass(m_program, m_vao, [&] {
-                for (int i = 0; i < kColumns; ++i) {
-                    glDrawElementsBaseVertex(GL_TRIANGLES, counts[i], GL_UNSIGNED_SHORT, offsets[i], baseVertices[i]);
-                }
-            });
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-            ExpectSameImage(batched, unrolled, "GL_UNSIGNED_SHORT indices");
-        }
-
-        TEST_F(MultiDrawScenario, UnsignedByteBatchMatchesUnrolledDraws) {
-            if (!Ready()) return;
-            constexpr int kPad = 3;
-            std::uint8_t indices[6];
-            for (int i = 0; i < 6; ++i)
-                indices[i] = static_cast<std::uint8_t>(kQuadIndices[i]);
-            // 24 bytes: a word multiple, which the compute tier needs of the source
-            // buffer when the index type is narrower than a word.
-            std::uint8_t padded[24] = {};
-            for (int i = 0; i < 6; ++i)
-                padded[i] = indices[i];
-            BuildScene(kPad, padded, sizeof(padded));
-
-            GLsizei counts[kColumns];
-            const void* offsets[kColumns];
-            GLint baseVertices[kColumns];
-            for (int i = 0; i < kColumns; ++i) {
-                counts[i] = 6;
-                offsets[i] = reinterpret_cast<const void*>(0);
-                baseVertices[i] = kPad + i * 4;
-            }
-
-            const Image batched = RenderPass(m_program, m_vao, [&] {
-                glMultiDrawElementsBaseVertex(GL_TRIANGLES, counts, GL_UNSIGNED_BYTE, offsets, kColumns, baseVertices);
-            });
-            const Image unrolled = RenderPass(m_program, m_vao, [&] {
-                for (int i = 0; i < kColumns; ++i) {
-                    glDrawElementsBaseVertex(GL_TRIANGLES, counts[i], GL_UNSIGNED_BYTE, offsets[i], baseVertices[i]);
-                }
-            });
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-            ExpectSameImage(batched, unrolled, "GL_UNSIGNED_BYTE indices");
-        }
-
-        // ---- a base vertex the index type cannot spell ----
-        // GL adds the base vertex at full precision, so folding it into a
-        // GL_UNSIGNED_SHORT index stream at the source width wraps and addresses the
-        // wrong vertex. The columns here start past 65535, which no ushort index can
-        // reach on its own.
-
-        TEST_F(MultiDrawScenario, BaseVertexBeyondIndexTypeRangeMatchesUnrolledDraws) {
-            if (!Ready()) return;
-            constexpr int kPad = 70000; // > 0xFFFF
-            std::uint16_t indices[6];
-            for (int i = 0; i < 6; ++i)
-                indices[i] = static_cast<std::uint16_t>(kQuadIndices[i]);
-            BuildScene(kPad, indices, sizeof(indices));
-
-            GLsizei counts[kColumns];
-            const void* offsets[kColumns];
-            GLint baseVertices[kColumns];
-            for (int i = 0; i < kColumns; ++i) {
-                counts[i] = 6;
-                offsets[i] = reinterpret_cast<const void*>(0);
-                baseVertices[i] = kPad + i * 4;
-            }
-
-            const Image batched = RenderPass(m_program, m_vao, [&] {
-                glMultiDrawElementsBaseVertex(GL_TRIANGLES, counts, GL_UNSIGNED_SHORT, offsets, kColumns, baseVertices);
-            });
-            const Image unrolled = RenderPass(m_program, m_vao, [&] {
-                for (int i = 0; i < kColumns; ++i) {
-                    glDrawElementsBaseVertex(GL_TRIANGLES, counts[i], GL_UNSIGNED_SHORT, offsets[i], baseVertices[i]);
-                }
-            });
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-            ExpectSameImage(batched, unrolled, "base vertex past the GL_UNSIGNED_SHORT range");
-        }
-
-        // ---- client-memory index arrays ----
-        // No element array buffer, so the indirect tiers have nothing to address and
-        // the compute tier nothing to read; both must decline and hand the batch to
-        // a tier that can replay it.
-
-        TEST_F(MultiDrawScenario, ClientSideIndicesBatchMatchesUnrolledDraws) {
-            if (!Ready()) return;
-            constexpr int kPad = 5;
-            BuildScene(kPad, nullptr, 0);
-
-            GLsizei counts[kColumns];
-            const void* offsets[kColumns];
-            GLint baseVertices[kColumns];
-            for (int i = 0; i < kColumns; ++i) {
-                counts[i] = 6;
-                offsets[i] = kQuadIndices;
-                baseVertices[i] = kPad + i * 4;
-            }
-
-            const Image batched = RenderPass(m_program, m_vao, [&] {
-                glMultiDrawElementsBaseVertex(GL_TRIANGLES, counts, GL_UNSIGNED_INT, offsets, kColumns, baseVertices);
-            });
-            const Image unrolled = RenderPass(m_program, m_vao, [&] {
-                for (int i = 0; i < kColumns; ++i) {
-                    glDrawElementsBaseVertex(GL_TRIANGLES, counts[i], GL_UNSIGNED_INT, offsets[i], baseVertices[i]);
-                }
-            });
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-            ExpectSameImage(batched, unrolled, "client-memory index arrays");
-        }
-
-        // ---- primitive restart inside a strip ----
-        // Two things at once: a strip mode, which the flattening tier must decline
-        // because concatenation would weld sub-draws together, and a restart
-        // sentinel, which any tier that rewrites indices must carry across without
-        // adding the base vertex to it.
-
-        TEST_F(MultiDrawScenario, PrimitiveRestartStripBatchMatchesUnrolledDraws) {
-            if (!Ready()) return;
-            constexpr int kPad = 5;
-            const std::vector<std::uint32_t> indices = RestartStripIndices<std::uint32_t>(0xFFFFFFFFu);
-            BuildScene(kPad, indices.data(), indices.size() * sizeof(std::uint32_t));
-
-            GLsizei counts[kColumns];
-            const void* offsets[kColumns];
-            GLint baseVertices[kColumns];
-            for (int i = 0; i < kColumns; ++i) {
-                counts[i] = static_cast<GLsizei>(indices.size());
-                offsets[i] = reinterpret_cast<const void*>(0);
-                baseVertices[i] = kPad + i * 4;
-            }
-
-            glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
-            const Image batched = RenderPass(m_program, m_vao, [&] {
-                glMultiDrawElementsBaseVertex(GL_TRIANGLE_STRIP, counts, GL_UNSIGNED_INT, offsets, kColumns,
-                                              baseVertices);
-            });
-            const Image unrolled = RenderPass(m_program, m_vao, [&] {
-                for (int i = 0; i < kColumns; ++i) {
-                    glDrawElementsBaseVertex(GL_TRIANGLE_STRIP, counts[i], GL_UNSIGNED_INT, offsets[i],
-                                             baseVertices[i]);
-                }
-            });
-            glDisable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-            ExpectSameImage(batched, unrolled, "GL_TRIANGLE_STRIP with primitive restart");
-        }
-
-        // Same, with GL_UNSIGNED_SHORT: the sentinel a rewritten stream has to
-        // recognise is the index TYPE's all-ones value, not the rewritten stream's.
-        TEST_F(MultiDrawScenario, PrimitiveRestartUnsignedShortBatchMatchesUnrolledDraws) {
-            if (!Ready()) return;
-            constexpr int kPad = 5;
-            const std::vector<std::uint16_t> indices = RestartStripIndices<std::uint16_t>(0xFFFFu);
-            BuildScene(kPad, indices.data(), indices.size() * sizeof(std::uint16_t));
-
-            GLsizei counts[kColumns];
-            const void* offsets[kColumns];
-            GLint baseVertices[kColumns];
-            for (int i = 0; i < kColumns; ++i) {
-                counts[i] = static_cast<GLsizei>(indices.size());
-                offsets[i] = reinterpret_cast<const void*>(0);
-                baseVertices[i] = kPad + i * 4;
-            }
-
-            glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
-            const Image batched = RenderPass(m_program, m_vao, [&] {
-                glMultiDrawElementsBaseVertex(GL_TRIANGLE_STRIP, counts, GL_UNSIGNED_SHORT, offsets, kColumns,
-                                              baseVertices);
-            });
-            const Image unrolled = RenderPass(m_program, m_vao, [&] {
-                for (int i = 0; i < kColumns; ++i) {
-                    glDrawElementsBaseVertex(GL_TRIANGLE_STRIP, counts[i], GL_UNSIGNED_SHORT, offsets[i],
-                                             baseVertices[i]);
-                }
-            });
-            glDisable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-            ExpectSameImage(batched, unrolled, "GL_TRIANGLE_STRIP with GL_UNSIGNED_SHORT primitive restart");
-        }
-
-        // ---- a batch with holes ----
-        // Zero-count sub-draws draw nothing. The flattening tier's binary search
-        // finds a sub-draw by prefix sum, and a zero-count entry repeats the
-        // previous sum - so a search that resolves ties the other way would attribute
-        // indices to the empty draw and paint the wrong column.
-
-        TEST_F(MultiDrawScenario, ZeroCountSubDrawsMatchUnrolledDraws) {
-            if (!Ready()) return;
-            constexpr int kPad = 5;
-            BuildScene(kPad, kQuadIndices, sizeof(kQuadIndices));
-
-            GLsizei counts[kColumns];
-            const void* offsets[kColumns];
-            GLint baseVertices[kColumns];
-            for (int i = 0; i < kColumns; ++i) {
-                // Columns 1 and 2 are skipped, leaving the outer two painted.
-                counts[i] = (i == 1 || i == 2) ? 0 : 6;
-                offsets[i] = reinterpret_cast<const void*>(0);
-                baseVertices[i] = kPad + i * 4;
-            }
-
-            const Image batched = RenderPass(m_program, m_vao, [&] {
-                glMultiDrawElementsBaseVertex(GL_TRIANGLES, counts, GL_UNSIGNED_INT, offsets, kColumns, baseVertices);
-            });
-            const Image unrolled = RenderPass(m_program, m_vao, [&] {
-                for (int i = 0; i < kColumns; ++i) {
-                    if (counts[i] == 0) continue;
-                    glDrawElementsBaseVertex(GL_TRIANGLES, counts[i], GL_UNSIGNED_INT, offsets[i], baseVertices[i]);
-                }
-            });
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-            ExpectSameImage(batched, unrolled, "a batch with zero-count sub-draws");
-        }
-
-    } // namespace
-} // namespace MGITest

MobileGL/MG_IntegrationTest/Scenarios/OrientationScenario.cpp

@@ -1,381 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/OrientationScenario.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
-//
-// Scenario A - "the frame came out upside down".
-//
-// The shipped bug (DirectVulkan, GetBaseTransformFlagsRaw): the shader
-// transform flags - the Y-flip and surface-rotation bits that apply ONLY when
-// the bound draw framebuffer is the default one - were memoized on the
-// swapchain pre-transform alone. The is-default-framebuffer input was not part
-// of the key, so whichever kind of pass evaluated the memo first decided the
-// orientation of every pass after it. In a real frame that meant: after any
-// render-to-texture pass, the next default-framebuffer pass inherited the FBO's
-// unflipped flags and the whole frame rendered upside down (retrace SSIM 0.052,
-// deterministic; flickering clouds on device).
-//
-// What pins it: a pattern asymmetric in BOTH axes - four quadrants, coloured
-//
-//        top-left  RED  | WHITE  top-right
-//     bottom-left BLUE  | GREEN  bottom-right
-//
-// - drawn to a target, read back with glReadPixels, and reduced to the four
-// quadrant-centre colours in the fixed order bottom-left, bottom-right,
-// top-left, top-right.
-//
-// Four quadrants rather than the three horizontal stripes this scenario used to
-// draw, because stripes only pin ONE axis. Stripes read down the centre line
-// are unchanged by an X flip, by a transpose, and by a 180 rotation composed
-// with a Y flip: all three of those bugs would have rendered a green stripe
-// between a blue one and a red one and passed. Every one of the eight
-// symmetries of the square now produces a different string:
-//
-//     identity       blue,green,red,white     <- correct
-//     Y flip         red,white,blue,green     <- the shipped bug
-//     X flip         green,blue,white,red
-//     180 rotation   white,red,green,blue
-//     transpose      blue,red,green,white
-//     anti-transpose white,green,red,blue
-//     rotate 90 CCW  red,blue,white,green
-//     rotate 90 CW   green,white,blue,red
-//
-// The assertions then go further than the signature: every quadrant is checked
-// pixel by pixel over its whole area (RegionIsMostly), so a partial or torn
-// draw cannot pass by having the four sampled centres come out right.
-//
-// Both orderings are covered, because the memo is poisoned by whichever pass
-// runs first and these tests share one process:
-//   - default -> FBO -> default   (the FBO pass inherits the default's flip)
-//   - FBO -> default              (the shipped symptom: the default pass
-//                                  inherits the FBO's lack of flip)
-
-#include <algorithm>
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include "../Harness/HeadlessGL.h"
-#include "../Harness/ScenarioFixture.h"
-
-#ifdef GLAPI
-#undef GLAPI
-#endif
-#define GL_GLEXT_PROTOTYPES
-#include <GL/gl.h>
-#include <GL/glcorearb.h>
-#undef GL_GLEXT_PROTOTYPES
-
-namespace MGITest {
-    namespace {
-
-        constexpr const char* kVertexSource = R"(#version 330 core
-in vec2 aPos;
-in vec3 aColor;
-out vec3 vColor;
-void main() {
-    vColor = aColor;
-    gl_Position = vec4(aPos, 0.0, 1.0);
-}
-)";
-
-        constexpr const char* kFragmentSource = R"(#version 330 core
-in vec3 vColor;
-out vec4 oColor;
-void main() {
-    oColor = vec4(vColor, 1.0);
-}
-)";
-
-        // The correctly-oriented answer, in glReadPixels order (row 0 is the
-        // bottom row) and in QuadrantSignature's order: bottom-left, bottom-right,
-        // top-left, top-right. Plain GL semantics; holds for every framebuffer,
-        // default or not.
-        constexpr const char* kUprightSignature = "blue,green,red,white";
-
-        // How far inside each quadrant the whole-region checks start. The quadrant
-        // seam sits on a pixel boundary, so one pixel of margin is enough to make
-        // "every single pixel" an achievable (and therefore useful) demand.
-        constexpr int kQuadrantInset = 2;
-
-        struct Vertex {
-            float x, y;
-            float r, g, b;
-        };
-
-        void AppendQuad(std::vector<Vertex>& out, float x0, float x1, float y0, float y1, float r, float g, float b) {
-            const Vertex bl{x0, y0, r, g, b};
-            const Vertex br{x1, y0, r, g, b};
-            const Vertex tr{x1, y1, r, g, b};
-            const Vertex tl{x0, y1, r, g, b};
-            out.insert(out.end(), {bl, br, tr, bl, tr, tl});
-        }
-
-        std::vector<Vertex> QuadrantGeometry() {
-            std::vector<Vertex> vertices;
-            vertices.reserve(24);
-            AppendQuad(vertices, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f); // bottom-left: blue
-            AppendQuad(vertices, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f);  // bottom-right: green
-            AppendQuad(vertices, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f);  // top-left: red
-            AppendQuad(vertices, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f);   // top-right: white
-            return vertices;
-        }
-
-        class OrientationScenario : public ScenarioTest {
-        protected:
-            void SetUp() override {
-                ScenarioTest::SetUp();
-                if (!Ready()) return;
-
-                std::string error;
-                m_program = CompileProgram(kVertexSource, kFragmentSource, &error);
-                ASSERT_NE(m_program, 0u) << error;
-
-                const std::vector<Vertex> vertices = QuadrantGeometry();
-                m_vertexCount = static_cast<int>(vertices.size());
-                glGenVertexArrays(1, &m_vao);
-                glBindVertexArray(m_vao);
-                glGenBuffers(1, &m_vbo);
-                glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-                glBufferData(GL_ARRAY_BUFFER, GLsizeiptr(vertices.size() * sizeof(Vertex)), vertices.data(),
-                             GL_STATIC_DRAW);
-                glEnableVertexAttribArray(0);
-                glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(0));
-                glEnableVertexAttribArray(1);
-                glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(8));
-                glBindVertexArray(0);
-
-                m_offscreen = MakeColorFbo(Gl().Width(), Gl().Height());
-                ASSERT_NE(m_offscreen.fbo, 0u) << "offscreen FBO is not framebuffer-complete";
-
-                ASSERT_EQ(FirstGLError(), GLenum(GL_NO_ERROR)) << "setup left a GL error behind";
-            }
-
-            void TearDown() override {
-                if (!Ready()) return;
-                DestroyColorFbo(m_offscreen);
-                if (m_vbo != 0) glDeleteBuffers(1, &m_vbo);
-                if (m_vao != 0) glDeleteVertexArrays(1, &m_vao);
-                if (m_program != 0) glDeleteProgram(m_program);
-            }
-
-            void DrawQuadrants() {
-                glDisable(GL_DEPTH_TEST);
-                glDisable(GL_BLEND);
-                glUseProgram(m_program);
-                glBindVertexArray(m_vao);
-                glDrawArrays(GL_TRIANGLES, 0, m_vertexCount);
-                glBindVertexArray(0);
-            }
-
-            // One pass to the default (presentable) framebuffer.
-            Image DefaultFramebufferPass() {
-                BindDefaultFramebuffer();
-                ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
-                DrawQuadrants();
-                return ReadPixels(Gl().Width(), Gl().Height());
-            }
-
-            // One render-to-texture pass. Real frames do this constantly
-            // (shadow maps, post-processing, Minecraft's main render target).
-            Image OffscreenPass() {
-                BindFbo(m_offscreen);
-                ClearTo(0.0f, 0.0f, 0.0f, 1.0f);
-                DrawQuadrants();
-                return ReadPixels(m_offscreen.width, m_offscreen.height);
-            }
-
-            // The signature says WHICH transform went wrong; this says the whole
-            // image is right, not merely its four sampled centres.
-            void ExpectUprightQuadrants(const Image& image, const std::string& when) {
-                const int w = image.Width();
-                const int h = image.Height();
-                const int inset = kQuadrantInset;
-                EXPECT_TRUE(RegionIsMostly(image, inset, w / 2 - inset, inset, h / 2 - inset, "blue", 0.0, when));
-                EXPECT_TRUE(RegionIsMostly(image, w / 2 + inset, w - inset, inset, h / 2 - inset, "green", 0.0, when));
-                EXPECT_TRUE(RegionIsMostly(image, inset, w / 2 - inset, h / 2 + inset, h - inset, "red", 0.0, when));
-                EXPECT_TRUE(RegionIsMostly(image, w / 2 + inset, w - inset, h / 2 + inset, h - inset, "white", 0.0,
-                                           when));
-            }
-
-            unsigned int m_program = 0;
-            unsigned int m_vao = 0;
-            unsigned int m_vbo = 0;
-            int m_vertexCount = 0;
-            ColorFbo m_offscreen;
-        };
-
-        // The plain statement of GL semantics that everything else leans on: an
-        // FBO pass is never flipped.
-        TEST_F(OrientationScenario, OffscreenPassRendersUpright) {
-            const Image offscreen = OffscreenPass();
-            EXPECT_EQ(offscreen.QuadrantSignature(), kUprightSignature)
-                << "a render-to-texture pass must render unflipped";
-            ExpectUprightQuadrants(offscreen, "render-to-texture pass");
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-        // The same for the default framebuffer: whatever the backend does with
-        // the swapchain internally, glReadPixels owes the caller GL orientation.
-        TEST_F(OrientationScenario, DefaultFramebufferPassRendersUpright) {
-            const Image presented = DefaultFramebufferPass();
-            EXPECT_EQ(presented.QuadrantSignature(), kUprightSignature)
-                << "a default-framebuffer pass must read back in GL orientation";
-            ExpectUprightQuadrants(presented, "default-framebuffer pass");
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-        // Scenario A proper: default -> FBO -> default in one frame. The third
-        // pass must be pixel-identical to the first; the FBO pass in between
-        // must not have moved anything.
-        TEST_F(OrientationScenario, DefaultFramebufferSurvivesAnOffscreenPass) {
-            const Image before = DefaultFramebufferPass();
-            const Image offscreen = OffscreenPass();
-            const Image after = DefaultFramebufferPass();
-
-            EXPECT_EQ(before.QuadrantSignature(), kUprightSignature)
-                << "first default-framebuffer pass is already misoriented";
-            EXPECT_EQ(offscreen.QuadrantSignature(), kUprightSignature)
-                << "the render-to-texture pass in the middle rendered flipped - the "
-                   "default framebuffer's transform flags leaked into it";
-            EXPECT_EQ(after.QuadrantSignature(), kUprightSignature)
-                << "the default-framebuffer pass AFTER a render-to-texture pass is "
-                   "misoriented - it inherited the FBO's transform flags";
-            ExpectUprightQuadrants(after, "default-framebuffer pass after a render-to-texture pass");
-            EXPECT_TRUE(after == before) << "the third pass differs from the first in " << after.ByteDiffCount(before)
-                                         << " bytes; first=" << before.QuadrantSignature()
-                                         << " third=" << after.QuadrantSignature();
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-        // The shipped symptom, in its shipped order: an FBO pass, then the
-        // default framebuffer. This is the one that flipped whole Minecraft
-        // frames.
-        TEST_F(OrientationScenario, DefaultFramebufferAfterOffscreenIsNotFlipped) {
-            const Image offscreen = OffscreenPass();
-            const Image presented = DefaultFramebufferPass();
-
-            EXPECT_EQ(offscreen.QuadrantSignature(), kUprightSignature)
-                << "render-to-texture pass rendered flipped";
-            EXPECT_EQ(presented.QuadrantSignature(), kUprightSignature)
-                << "the default-framebuffer pass that follows a render-to-texture pass "
-                   "rendered upside down";
-            ExpectUprightQuadrants(presented, "default-framebuffer pass following a render-to-texture pass");
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-        // And across a real frame boundary, which is how a game actually
-        // alternates the two kinds of pass.
-        TEST_F(OrientationScenario, OrientationIsStableAcrossFrames) {
-            const Image firstFrame = DefaultFramebufferPass();
-            ExpectUprightQuadrants(firstFrame, "frame 0");
-            Gl().EndFrame();
-
-            for (int frame = 0; frame < 3; ++frame) {
-                const Image offscreen = OffscreenPass();
-                EXPECT_EQ(offscreen.QuadrantSignature(), kUprightSignature)
-                    << "frame " << frame + 1 << "'s render-to-texture pass is misoriented";
-                const Image presented = DefaultFramebufferPass();
-                EXPECT_EQ(presented.QuadrantSignature(), kUprightSignature)
-                    << "frame " << frame + 1 << " of the alternating FBO/default loop is misoriented";
-                ExpectUprightQuadrants(presented, "frame " + std::to_string(frame + 1));
-                EXPECT_TRUE(presented == firstFrame) << "frame " << frame + 1 << " differs from frame 0 in "
-                                                     << presented.ByteDiffCount(firstFrame) << " bytes";
-                Gl().EndFrame();
-            }
-            EXPECT_EQ(FirstGLError(), GLenum(GL_NO_ERROR));
-        }
-
-        // A standing self-test of the signature, not of MobileGL: it proves the
-        // four-quadrant reduction really does separate all eight symmetries of
-        // the square, so a future "simplify the pattern" change cannot quietly
-        // reintroduce the blind spot the three-stripe version had (X flip,
-        // transpose and 180+Y-flip all left the stripe signature alone).
-        TEST_F(OrientationScenario, QuadrantSignatureSeparatesEverySquareSymmetry) {
-            const Image upright = OffscreenPass();
-            ASSERT_EQ(upright.QuadrantSignature(), kUprightSignature) << "the reference image is not upright";
-
-            const int w = upright.Width();
-            const int h = upright.Height();
-            // Transposes are expressed on the largest centred square the readback
-            // contains, which is enough for the four quadrant centres to move.
-            const int side = std::min(w, h);
-            const int ox = (w - side) / 2;
-            const int oy = (h - side) / 2;
-
-            struct Symmetry {
-                const char* name;
-                const char* expected;
-                int (*mapX)(int x, int y, int w, int h);
-                int (*mapY)(int x, int y, int w, int h);
-            };
-            const Symmetry symmetries[] = {
-                {"Y flip", "red,white,blue,green", [](int x, int, int, int) { return x; },
-                 [](int, int y, int, int hh) { return hh - 1 - y; }},
-                {"X flip", "green,blue,white,red", [](int x, int, int ww, int) { return ww - 1 - x; },
-                 [](int, int y, int, int) { return y; }},
-                {"180 rotation", "white,red,green,blue", [](int x, int, int ww, int) { return ww - 1 - x; },
-                 [](int, int y, int, int hh) { return hh - 1 - y; }},
-            };
-
-            for (const Symmetry& symmetry : symmetries) {
-                Image transformed(w, h);
-                for (int y = 0; y < h; ++y) {
-                    for (int x = 0; x < w; ++x) {
-                        const Rgba8 source = upright.At(symmetry.mapX(x, y, w, h), symmetry.mapY(x, y, w, h));
-                        std::uint8_t* out = transformed.Data() + (std::size_t(y) * w + x) * 4;
-                        out[0] = source.r;
-                        out[1] = source.g;
-                        out[2] = source.b;
-                        out[3] = source.a;
-                    }
-                }
-                EXPECT_EQ(transformed.QuadrantSignature(), symmetry.expected)
-                    << symmetry.name << " must produce its own signature, or the pattern cannot see it";
-                EXPECT_NE(transformed.QuadrantSignature(), kUprightSignature)
-                    << symmetry.name << " is INDISTINGUISHABLE from an upright frame - the pattern is too symmetric";
-            }
-
-            // The four symmetries that move the axes into each other. They only
-            // make sense on a square, so they run on the largest centred one.
-            struct SquareSymmetry {
-                const char* name;
-                const char* expected;
-                int (*sourceX)(int x, int y, int side);
-                int (*sourceY)(int x, int y, int side);
-            };
-            const SquareSymmetry squareSymmetries[] = {
-                {"transpose", "blue,red,green,white", [](int, int y, int) { return y; },
-                 [](int x, int, int) { return x; }},
-                {"anti-transpose", "white,green,red,blue", [](int, int y, int s) { return s - 1 - y; },
-                 [](int x, int, int s) { return s - 1 - x; }},
-                {"rotate 90 CCW", "red,blue,white,green", [](int, int y, int) { return y; },
-                 [](int x, int, int s) { return s - 1 - x; }},
-                {"rotate 90 CW", "green,white,blue,red", [](int, int y, int s) { return s - 1 - y; },
-                 [](int x, int, int) { return x; }},
-            };
-            for (const SquareSymmetry& symmetry : squareSymmetries) {
-                Image square(side, side);
-                for (int y = 0; y < side; ++y) {
-                    for (int x = 0; x < side; ++x) {
-                        const Rgba8 source =
-                            upright.At(ox + symmetry.sourceX(x, y, side), oy + symmetry.sourceY(x, y, side));
-                        std::uint8_t* out = square.Data() + (std::size_t(y) * side + x) * 4;
-                        out[0] = source.r;
-                        out[1] = source.g;
-                        out[2] = source.b;
-                        out[3] = source.a;
-                    }
-                }
-                EXPECT_EQ(square.QuadrantSignature(), symmetry.expected)
-                    << symmetry.name << " must produce its own signature, or the pattern cannot see it";
-                EXPECT_NE(square.QuadrantSignature(), kUprightSignature)
-                    << symmetry.name << " is INDISTINGUISHABLE from an upright frame";
-            }
-        }
-
-    } // namespace
-} // namespace MGITest

MobileGL/MG_IntegrationTest/Scenarios/ResidentIndexScenario.cpp

@@ -1,383 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/ResidentIndexScenario.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
-//
-// Scenario C - RESIDENT index buffers across frame boundaries.
-//
-// WHAT THIS FILE DOES AND DOES NOT COVER, stated plainly because the answer is
-// not the one it was written to find.
-//
-// The shipped fix (d7976326) removed cross-frame slice trust from TWO memos: the
-// vertex-binding one and the EBO one. StreamedArenaScenario pins the vertex
-// half - re-enable that half alone and it fails. Nothing pinned the EBO half,
-// and these cases are the result of trying to build something that does.
-//
-// The EBO memo lives in UploadAndBindIndexBuffer and is recorded ONLY on the
-// resident branch, keyed on (BufferObject*, VkBufferResource::sliceEpoch,
-// frame serial). To fail with only the EBO revalidation re-enabled, a scenario
-// needs a RESIDENT index buffer whose recorded slice stops describing the right
-// bytes while the pointer and the epoch still match. Every case below is an
-// attempt at that, run against the re-enabled buggy path with the branch
-// instrumented to count reaches, acceptances, and - critically - what the
-// skipped AcquireResidentSlice WOULD have done. The measurement, over this file
-// plus every other scenario in the module:
-//
-//     reached=89 accepted=81 sliceMoved=0 bytesChanged=0 epochBumped=0
-//
-// The buggy branch is entered 89 times and serves its recorded slice 81 times,
-// and in NOT ONE of those 81 would the acquire have moved the slice, changed a
-// byte of it, or bumped the epoch. The skipped work was a no-op every time.
-//
-// That is not luck, it is the shape of the code. A resident slice is
-// `resource->buffer.GetSlice(0, size)` of a dedicated VkBuffer, so it can only
-// move when CreateResidentStorage mints new storage - which bumps the epoch. Its
-// bytes can only change through Respecify / SubData / FlushMappedRange - each of
-// which bumps the epoch as its first act - or through
-// BufferObject::SyncPersistentMappedRange, which the acquire calls and the memo
-// skips. That last one is the real escape, and it is dead here: it early-outs
-// when the backend has adopted the map into coherent GPU storage, and
-// AcquirePersistentMap only declines when a host-visible coherent allocation
-// FAILS. Instrumented across the whole module: 50 persistent coherent write
-// maps, 50 adopted, 0 dispatches. A 96 MiB EBO did not change that either.
-//
-// So on DirectVulkan as it stands, the EBO half of the fix is not reachable from
-// a GL-level test - not because the guard is sound in principle (it is the same
-// unsound idea the vertex half shipped corruption with) but because the two
-// mechanisms that made the vertex half observable are both absent for indices:
-//
-//   1. ARENA RELOCATION. The vertex memo records STREAMED slices too, and a
-//      streamed slice moves to a new arena block every frame BY DESIGN - the
-//      epoch that catches it is bumped inside the very acquire the memo skips.
-//      That is what StreamedVertexDataSurvivesArenaRecycling exploits. The index
-//      memo is never recorded on the streamed branch, so no index memo ever
-//      names an arena offset. Measured: StreamedIndexDataSurvivesArenaRecycling
-//      reaches the branch 0 times, and so does PromotedDynamicEbo below (a
-//      promoted DYNAMIC_DRAW buffer is SERVED by AcquireResidentSlice but still
-//      ROUTED as streamed, so it is not memoised either).
-//   2. HOST-MAP SYNC. Dead, as above.
-//
-// These cases therefore stay as what they honestly are: end-to-end regression
-// tests for resident index-buffer freshness across frame boundaries, and the
-// standing tripwire for change (1). The moment anyone memoises the streamed or
-// promoted index path - the natural next step for the same optimisation - these
-// stop being redundant and start failing. Each case says below what it covers.
-
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <vector>
-
-#include "../Harness/HeadlessGL.h"
-#include "../Harness/ScenarioFixture.h"
-
-#ifdef GLAPI
-#undef GLAPI
-#endif
-#define GL_GLEXT_PROTOTYPES
-#include <GL/gl.h>
-#include <GL/glcorearb.h>
-#undef GL_GLEXT_PROTOTYPES
-
-namespace MGITest {
-    namespace {
-
-        constexpr const char* kVS = R"(#version 330 core
-in vec2 aPos;
-in vec3 aColor;
-out vec3 vColor;
-void main() { vColor = aColor; gl_Position = vec4(aPos, 0.0, 1.0); }
-)";
-        constexpr const char* kFS = R"(#version 330 core
-in vec3 vColor;
-out vec4 oColor;
-void main() { oColor = vec4(vColor, 1.0); }
-)";
-
-        struct V {
-            float x, y, r, g, b;
-        };
-        constexpr int kIdx = 6;
-        const GLuint kLeft[kIdx] = {0, 1, 2, 0, 2, 3};
-        const GLuint kRight[kIdx] = {4, 5, 6, 4, 6, 7};
-
-        std::vector<V> Scene() {
-            return {{-1, -1, 1, 0, 0}, {0, -1, 1, 0, 0}, {0, 1, 1, 0, 0}, {-1, 1, 1, 0, 0},
-                    {0, -1, 0, 1, 0},  {1, -1, 0, 1, 0}, {1, 1, 0, 1, 0},  {0, 1, 0, 1, 0}};
-        }
-
-        class ResidentIndexScenario : public ScenarioTest {
-        protected:
-            void SetUp() override {
-                ScenarioTest::SetUp();
-                if (!Ready()) return;
-                std::string err;
-                m_program = CompileProgram(kVS, kFS, &err);
-                ASSERT_NE(m_program, 0u) << err;
-            }
-            void TearDown() override {
-                if (!Ready()) return;
-                if (m_program != 0) glDeleteProgram(m_program);
-            }
-
-            // A VAO whose VBO is STATIC_DRAW (so it resolves resident and the
-            // vertex memo is recorded) and whose EBO is `eboName`.
-            unsigned int MakeVao(unsigned int vbo, unsigned int ebo) {
-                unsigned int vao = 0;
-                glGenVertexArrays(1, &vao);
-                glBindVertexArray(vao);
-                glBindBuffer(GL_ARRAY_BUFFER, vbo);
-                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-                glEnableVertexAttribArray(0);
-                glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(V), reinterpret_cast<void*>(0));
-                glEnableVertexAttribArray(1);
-                glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(V), reinterpret_cast<void*>(8));
-                glBindVertexArray(0);
-                return vao;
-            }
-
-            unsigned int MakeStaticVbo() {
-                const std::vector<V> vertices = Scene();
-                unsigned int vbo = 0;
-                glGenBuffers(1, &vbo);
-                glBindBuffer(GL_ARRAY_BUFFER, vbo);
-                glBufferData(GL_ARRAY_BUFFER, GLsizeiptr(vertices.size() * sizeof(V)), vertices.data(),
-                             GL_STATIC_DRAW);
-                return vbo;
-            }
-
-            void Draw(unsigned int vao) {
-                glDisable(GL_DEPTH_TEST);
-                glDisable(GL_BLEND);
-                glUseProgram(m_program);
-                glBindVertexArray(vao);
-                glDrawElements(GL_TRIANGLES, kIdx, GL_UNSIGNED_INT, nullptr);
-                glBindVertexArray(0);
-            }
-            void Begin() {
-                BindDefaultFramebuffer();
-                ClearTo(0, 0, 0, 1);
-            }
-            Image Read() { return ReadPixels(Gl().Width(), Gl().Height()); }
-            void Halves(const Image& image, const char* left, const char* right, const std::string& when) {
-                const int w = image.Width(), h = image.Height();
-                EXPECT_TRUE(RegionIsMostly(image, 2, w / 2 - 2, 2, h - 2, left, 0.0, when + " [left]"));
-                EXPECT_TRUE(RegionIsMostly(image, w / 2 + 2, w - 2, 2, h - 2, right, 0.0, when + " [right]"));
-            }
-
-            unsigned int m_program = 0;
-        };
-
-        // A: a coherent persistent EBO rewritten on EVERY frame, with no GL call
-        // between the write and the draw. This is the only shape in which an
-        // application changes index data with nothing for the backend to notice.
-        //
-        // COVERS: the coherent-persistent index contract end to end.
-        // DOES NOT COVER: the EBO memo. Instrumented it reaches the cross-frame
-        // branch 11 times and is served its recorded slice all 11 - but the
-        // backend adopted the map into that same storage, so the "stale" slice IS
-        // where the application's writes landed. It would only discriminate on a
-        // stack where AcquirePersistentMap declines (see the file header). A
-        // 96 MiB variant was tried to force that and did not: it cost 40s and
-        // measured the same zero, so it is not kept.
-        TEST_F(ResidentIndexScenario, PersistentCoherentEboWrittenEveryFrame) {
-            const unsigned int vbo = MakeStaticVbo();
-            unsigned int ebo = 0;
-            glGenBuffers(1, &ebo);
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-            const GLbitfield storageFlags =
-                GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | GL_DYNAMIC_STORAGE_BIT;
-            glBufferStorage(GL_ELEMENT_ARRAY_BUFFER, GLsizeiptr(sizeof(kLeft)), kLeft, storageFlags);
-            if (FirstGLError() != GL_NO_ERROR) GTEST_SKIP() << "no immutable storage";
-            auto* map = static_cast<unsigned char*>(glMapBufferRange(
-                GL_ELEMENT_ARRAY_BUFFER, 0, GLsizeiptr(sizeof(kLeft)),
-                GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT));
-            ASSERT_NE(map, nullptr);
-            const unsigned int vao = MakeVao(vbo, ebo);
-
-            for (int frame = 0; frame < 12; ++frame) {
-                Begin();
-                const bool wantRight = (frame % 2) == 1;
-                std::memcpy(map, wantRight ? kRight : kLeft, sizeof(kLeft));
-                Draw(vao);
-                const Image image = Read();
-                Halves(image, wantRight ? "black" : "red", wantRight ? "green" : "black",
-                       "frame " + std::to_string(frame) + " of a per-frame coherent EBO rewrite");
-                Gl().EndFrame();
-            }
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-            glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
-            glDeleteVertexArrays(1, &vao);
-            glDeleteBuffers(1, &ebo);
-            glDeleteBuffers(1, &vbo);
-        }
-
-        // B: usage escalation. The EBO is memoised as an index buffer, then bound
-        // as a VERTEX buffer in a later frame, which forces the backend to
-        // recreate its resident storage carrying the extra usage bit. A memo that
-        // survived that recreate would name a destroyed VkBuffer.
-        //
-        // COVERS: that a storage recreate driven by a DIFFERENT binding point
-        // retires the index memo. Reaches the branch 5 times.
-        TEST_F(ResidentIndexScenario, EboAlsoBoundAsVertexBufferLater) {
-            const unsigned int vbo = MakeStaticVbo();
-            unsigned int ebo = 0;
-            glGenBuffers(1, &ebo);
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-            // Big enough to be a legal (if nonsensical) vertex source too.
-            std::vector<GLuint> indices(64, 0);
-            std::memcpy(indices.data(), kLeft, sizeof(kLeft));
-            glBufferData(GL_ELEMENT_ARRAY_BUFFER, GLsizeiptr(indices.size() * 4), indices.data(), GL_STATIC_DRAW);
-            const unsigned int vao = MakeVao(vbo, ebo);
-
-            unsigned int vertexUseVao = 0;
-            glGenVertexArrays(1, &vertexUseVao);
-            glBindVertexArray(vertexUseVao);
-            glBindBuffer(GL_ARRAY_BUFFER, ebo); // the EBO, as a vertex source
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-            glEnableVertexAttribArray(0);
-            glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(V), reinterpret_cast<void*>(0));
-            glEnableVertexAttribArray(1);
-            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(V), reinterpret_cast<void*>(8));
-            glBindVertexArray(0);
-
-            for (int frame = 0; frame < 6; ++frame) {
-                Begin();
-                Draw(vao);
-                if (frame == 2) Draw(vertexUseVao); // forces the usage escalation
-                const Image image = Read();
-                if (frame != 2) {
-                    Halves(image, "red", "black", "frame " + std::to_string(frame) + " around a usage escalation");
-                }
-                Gl().EndFrame();
-            }
-            glDeleteVertexArrays(1, &vertexUseVao);
-            glDeleteVertexArrays(1, &vao);
-            glDeleteBuffers(1, &ebo);
-            glDeleteBuffers(1, &vbo);
-        }
-
-        // C: delete the EBO and immediately recreate it, so the frontend
-        // BufferObject may well land at the same address - which is all the memo's
-        // identity check compares. What stops it is that a fresh resource cannot
-        // reproduce an epoch from the process-lifetime counter; this is the test
-        // that says so out loud.
-        //
-        // COVERS: address reuse of a deleted index buffer. Reaches 7, accepts 6 -
-        // the one decline is the post-recreate draw.
-        TEST_F(ResidentIndexScenario, EboDeletedAndRecreatedAtTheSameName) {
-            const unsigned int vbo = MakeStaticVbo();
-            unsigned int ebo = 0;
-            glGenBuffers(1, &ebo);
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-            glBufferData(GL_ELEMENT_ARRAY_BUFFER, GLsizeiptr(sizeof(kLeft)), kLeft, GL_STATIC_DRAW);
-            unsigned int vao = MakeVao(vbo, ebo);
-
-            for (int frame = 0; frame < 4; ++frame) {
-                Begin();
-                Draw(vao);
-                Halves(Read(), "red", "black", "warmup frame " + std::to_string(frame));
-                Gl().EndFrame();
-            }
-
-            // Same VAO, same GL name, different contents.
-            glDeleteVertexArrays(1, &vao);
-            glDeleteBuffers(1, &ebo);
-            glGenBuffers(1, &ebo);
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-            glBufferData(GL_ELEMENT_ARRAY_BUFFER, GLsizeiptr(sizeof(kRight)), kRight, GL_STATIC_DRAW);
-            vao = MakeVao(vbo, ebo);
-
-            for (int frame = 0; frame < 4; ++frame) {
-                Begin();
-                Draw(vao);
-                Halves(Read(), "black", "green", "post-recreate frame " + std::to_string(frame));
-                Gl().EndFrame();
-            }
-            glDeleteVertexArrays(1, &vao);
-            glDeleteBuffers(1, &ebo);
-            glDeleteBuffers(1, &vbo);
-        }
-
-        // D: one resident EBO shared by two VAOs, so two independent memo entries
-        // hold the same recorded slice, mutated through one of them and drawn
-        // through both across frames.
-        //
-        // COVERS: that a mutation retires EVERY memo naming the buffer, not just
-        // the one whose VAO issued it. Reaches 8, accepts 6.
-        TEST_F(ResidentIndexScenario, OneEboTwoVaosMutatedAcrossFrames) {
-            const unsigned int vbo = MakeStaticVbo();
-            unsigned int ebo = 0;
-            glGenBuffers(1, &ebo);
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-            glBufferData(GL_ELEMENT_ARRAY_BUFFER, GLsizeiptr(sizeof(kLeft)), kLeft, GL_STATIC_DRAW);
-            const unsigned int vaoA = MakeVao(vbo, ebo);
-            const unsigned int vaoB = MakeVao(vbo, ebo);
-
-            for (int frame = 0; frame < 10; ++frame) {
-                Begin();
-                const bool wantRight = frame >= 5;
-                if (frame == 5) {
-                    glBindVertexArray(vaoA);
-                    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-                    glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, GLsizeiptr(sizeof(kRight)), kRight);
-                    glBindVertexArray(0);
-                }
-                Draw((frame % 2) == 0 ? vaoA : vaoB);
-                Halves(Read(), wantRight ? "black" : "red", wantRight ? "green" : "black",
-                       "shared-EBO frame " + std::to_string(frame));
-                Gl().EndFrame();
-            }
-            glDeleteVertexArrays(1, &vaoB);
-            glDeleteVertexArrays(1, &vaoA);
-            glDeleteBuffers(1, &ebo);
-            glDeleteBuffers(1, &vbo);
-        }
-
-        // E: a DYNAMIC_DRAW EBO left untouched long enough for the streaming path
-        // to PROMOTE it onto resident storage, then mutated.
-        //
-        // COVERS: promoted-buffer index freshness across a frame boundary.
-        // DOES NOT COVER: the EBO memo, and this is the useful part - instrumented,
-        // it reaches the cross-frame branch ZERO times. A promoted buffer is SERVED
-        // by AcquireResidentSlice but still ROUTED through the streamed branch of
-        // UploadAndBindIndexBuffer, which never records a memo. That asymmetry is
-        // exactly what makes the EBO half of the shipped fix unobservable, and this
-        // case is the tripwire: memoise the streamed/promoted index path and the
-        // reach stops being zero.
-        TEST_F(ResidentIndexScenario, PromotedDynamicEbo) {
-            const unsigned int vbo = MakeStaticVbo();
-            unsigned int ebo = 0;
-            glGenBuffers(1, &ebo);
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-            glBufferData(GL_ELEMENT_ARRAY_BUFFER, GLsizeiptr(sizeof(kLeft)), kLeft, GL_DYNAMIC_DRAW);
-            const unsigned int vao = MakeVao(vbo, ebo);
-
-            for (int frame = 0; frame < 10; ++frame) {
-                Begin();
-                Draw(vao);
-                Halves(Read(), "red", "black", "promotion warmup frame " + std::to_string(frame));
-                Gl().EndFrame();
-            }
-            for (int frame = 0; frame < 6; ++frame) {
-                Begin();
-                if (frame == 0) {
-                    glBindVertexArray(vao);
-                    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-                    glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, GLsizeiptr(sizeof(kRight)), kRight);
-                    glBindVertexArray(0);
-                }
-                Draw(vao);
-                Halves(Read(), "black", "green", "post-promotion frame " + std::to_string(frame));
-                Gl().EndFrame();
-            }
-            glDeleteVertexArrays(1, &vao);
-            glDeleteBuffers(1, &ebo);
-            glDeleteBuffers(1, &vbo);
-        }
-
-    } // namespace
-} // namespace MGITest

MobileGL/MG_IntegrationTest/Scenarios/ThreeChannelAttachmentScenario.cpp

@@ -1,300 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/ThreeChannelAttachmentScenario.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
-//
-// Scenario - THREE-CHANNEL COLOUR ATTACHMENTS, on a live driver.
-//
-// The bug: no OpenGL ES driver renders to a three-channel image. EXT_render_snorm covers
-// R/RG/RGBA only, EXT_color_buffer_float excludes RGB16F, and RGB integer formats are not
-// colour-renderable anywhere. Complementary Reimagined declares colortex1 = RGB8_SNORM and
-// colortex2 = RGB16F, so every framebuffer Iris built from them answered
-// GL_FRAMEBUFFER_UNSUPPORTED and Iris refused to load the shaderpack. DirectGLES now stores such
-// an attachment in its four-channel sibling (GL_RGB8_SNORM -> GL_RGBA16F) and reports the
-// substitution as a caveat capability, which is what makes glCheckFramebufferStatus say COMPLETE.
-//
-// WHY THIS SCENARIO EXISTS RATHER THAN A UNIT TEST. The unit tests in
-// MG_Test/Framebuffer/FramebufferTest.cpp drive a HAND-BUILT capability cache: they prove the
-// frontend accepts a caveat capability, and prove the colour-mask/clear discipline that keeps a
-// widened attachment's stored alpha at 1.0, but they cannot prove that a real driver's probe
-// actually PRODUCES that caveat. Only a live glCheckFramebufferStatus can, and the answer is
-// per-driver, not per-platform:
-//
-//   Mesa llvmpipe (the headless CI driver), ES 3.2, GL_TEXTURE_2D colour attachment:
-//     COMPLETE               GL_RGB8, GL_RGB16F, GL_R11F_G11F_B10F, every RGBA*
-//     INCOMPLETE_ATTACHMENT  GL_RGB8_SNORM, GL_SRGB8, every RGB integer format
-//     UNSUPPORTED            GL_RGB32F
-//
-// So the widening is LIVE on llvmpipe - "the desktop build is unaffected" was simply wrong, and
-// the CI retraces were green before the fix only because retrace ignores what
-// glCheckFramebufferStatus returns. This scenario is the gate that actually looks.
-//
-// DirectGLES only. DirectVulkan's format story is its own (Vulkan exposes R8G8B8_SNORM on almost
-// nothing, and Magma substitutes on different terms); asserting Espryt's answers there would
-// only pin a coincidence.
-
-#include <cmath>
-#include <string>
-#include <vector>
-
-#include "../Harness/HeadlessGL.h"
-#include "../Harness/ScenarioFixture.h"
-
-#ifdef GLAPI
-#undef GLAPI
-#endif
-#define GL_GLEXT_PROTOTYPES
-#include <GL/gl.h>
-#include <GL/glcorearb.h>
-#undef GL_GLEXT_PROTOTYPES
-
-namespace MGITest {
-    namespace {
-
-        constexpr const char* kVS = R"(#version 330 core
-in vec2 aPos;
-void main() {
-    gl_Position = vec4(aPos, 0.0, 1.0);
-}
-)";
-
-        // Two outputs so the mixed case is covered: draw buffer 0 is a natively renderable
-        // four-channel format whose alpha the application owns, draw buffer 1 is the widened
-        // three-channel one whose alpha the format says is 1.0. Both alphas are deliberately
-        // NOT 1.0 in the shader, so an implementation that simply passed the value through would
-        // fail the second assertion.
-        constexpr const char* kFS = R"(#version 330 core
-layout(location = 0) out vec4 oNative;
-layout(location = 1) out vec4 oWidened;
-void main() {
-    oNative  = vec4(1.0, 0.0, 0.0, 0.25);
-    oWidened = vec4(0.0, 1.0, 0.0, 0.75);
-}
-)";
-
-        constexpr int kSize = 16;
-
-        class ThreeChannelAttachmentScenario : public ScenarioTest {
-        protected:
-            void SetUp() override {
-                ScenarioTest::SetUp();
-                if (!Ready()) return;
-                if (Gl().BackendName() != "DirectGLES") {
-                    GTEST_SKIP() << "three-channel widening is a DirectGLES substitution; backend is "
-                                 << Gl().BackendName();
-                }
-            }
-
-            // A single-level 2D texture in `internalFormat`, or 0 when the driver rejects the
-            // storage outright (which is a different failure from rejecting the ATTACHMENT).
-            static GLuint MakeTexture(GLenum internalFormat) {
-                GLuint texture = 0;
-                glGenTextures(1, &texture);
-                glBindTexture(GL_TEXTURE_2D, texture);
-                glTexStorage2D(GL_TEXTURE_2D, 1, internalFormat, kSize, kSize);
-                if (glGetError() != GL_NO_ERROR) {
-                    glDeleteTextures(1, &texture);
-                    return 0;
-                }
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-                glBindTexture(GL_TEXTURE_2D, 0);
-                return texture;
-            }
-
-            static GLenum SingleAttachmentStatus(GLenum internalFormat) {
-                const GLuint texture = MakeTexture(internalFormat);
-                if (texture == 0) return GL_NONE;
-                GLuint fbo = 0;
-                glGenFramebuffers(1, &fbo);
-                glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
-                glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
-                const GLenum status = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
-                glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-                glDeleteFramebuffers(1, &fbo);
-                glDeleteTextures(1, &texture);
-                return status;
-            }
-        };
-
-        // THE regression gate for the frontend's answer: this is the exact call Iris makes, and
-        // GL_FRAMEBUFFER_UNSUPPORTED here is the whole shaderpack load failure.
-        TEST_F(ThreeChannelAttachmentScenario, ThreeChannelColorAttachmentsReportComplete) {
-            if (!Ready() || IsSkipped()) return;
-
-            // GL_RGB8 is the control: colour-renderable in ES core, so it must pass with or
-            // without any substitution. If it ever fails, nothing below means anything.
-            EXPECT_EQ(SingleAttachmentStatus(GL_RGB8), static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE))
-                << "GL_RGB8 is ES-core colour-renderable";
-
-            // Complementary Reimagined's colortex1 and colortex2.
-            EXPECT_EQ(SingleAttachmentStatus(GL_RGB8_SNORM), static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE))
-                << "colortex1 (RGB8_SNORM) must be renderable through the four-channel widening";
-            EXPECT_EQ(SingleAttachmentStatus(GL_RGB16F), static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE))
-                << "colortex2 (RGB16F) must be renderable, natively or through the widening";
-
-            // The other formats the widening covers. GL_RGB32F only reaches a renderable
-            // four-channel form when EXT_color_buffer_float is present, so a half-float-only
-            // driver legitimately answers UNSUPPORTED for it - see the POST's per-format row.
-            EXPECT_EQ(SingleAttachmentStatus(GL_SRGB8), static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE));
-            EXPECT_EQ(SingleAttachmentStatus(GL_RGB8UI), static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE));
-
-            EXPECT_EQ(FirstGLError(), 0u) << GLErrorName(FirstGLError());
-        }
-
-        // The other half: the substitution has to be INVISIBLE. A three-channel format has no
-        // alpha, so GL answers 1.0 for it - and that answer has to hold after a draw that wrote
-        // something else into the widened storage's real alpha channel, which is what the
-        // colour-mask discipline in SyncRenderState is for. GL_DST_ALPHA blending and
-        // glBlitFramebuffer read that stored alpha inside the driver, where no readback fixup can
-        // reach it, so "the storage really holds 1.0" is the only workable invariant.
-        TEST_F(ThreeChannelAttachmentScenario, WidenedAttachmentReadsBackOpaqueWhileItsNeighbourKeepsItsAlpha) {
-            if (!Ready() || IsSkipped()) return;
-
-            std::string error;
-            const GLuint program = CompileProgram(kVS, kFS, &error);
-            ASSERT_NE(program, 0u) << error;
-
-            const GLuint nativeTexture = MakeTexture(GL_RGBA16F);
-            const GLuint widenedTexture = MakeTexture(GL_RGB8_SNORM);
-            ASSERT_NE(nativeTexture, 0u);
-            ASSERT_NE(widenedTexture, 0u);
-
-            GLuint fbo = 0;
-            glGenFramebuffers(1, &fbo);
-            glBindFramebuffer(GL_FRAMEBUFFER, fbo);
-            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, nativeTexture, 0);
-            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, widenedTexture, 0);
-            const GLenum drawBuffers[2] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
-            glDrawBuffers(2, drawBuffers);
-            ASSERT_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE));
-
-            glViewport(0, 0, kSize, kSize);
-            // Alpha 0.0 on purpose: the widened attachment must come back 1.0 anyway, and the
-            // native one must come back 0.0 where the draw does not cover it.
-            glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-            glClear(GL_COLOR_BUFFER_BIT);
-
-            const float quad[] = {-1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f};
-            GLuint vao = 0;
-            GLuint vbo = 0;
-            glGenVertexArrays(1, &vao);
-            glBindVertexArray(vao);
-            glGenBuffers(1, &vbo);
-            glBindBuffer(GL_ARRAY_BUFFER, vbo);
-            glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);
-            glEnableVertexAttribArray(0);
-            glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), nullptr);
-            glUseProgram(program);
-            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-
-            std::vector<float> pixels(static_cast<std::size_t>(kSize) * kSize * 4, -1.0f);
-
-            glReadBuffer(GL_COLOR_ATTACHMENT1);
-            glReadPixels(0, 0, kSize, kSize, GL_RGBA, GL_FLOAT, pixels.data());
-            EXPECT_NEAR(pixels[0], 0.0f, 0.02f) << "widened attachment red";
-            EXPECT_NEAR(pixels[1], 1.0f, 0.02f) << "widened attachment green";
-            EXPECT_NEAR(pixels[2], 0.0f, 0.02f) << "widened attachment blue";
-            EXPECT_NEAR(pixels[3], 1.0f, 0.001f)
-                << "a three-channel format has no alpha channel, so GL must report 1.0 for it";
-
-            glReadBuffer(GL_COLOR_ATTACHMENT0);
-            glReadPixels(0, 0, kSize, kSize, GL_RGBA, GL_FLOAT, pixels.data());
-            EXPECT_NEAR(pixels[0], 1.0f, 0.02f) << "native attachment red";
-            EXPECT_NEAR(pixels[3], 0.25f, 0.02f)
-                << "the alpha discipline must not leak onto a natively renderable attachment";
-
-            glBindFramebuffer(GL_FRAMEBUFFER, 0);
-            glDeleteFramebuffers(1, &fbo);
-            glDeleteBuffers(1, &vbo);
-            glDeleteVertexArrays(1, &vao);
-            glDeleteTextures(1, &nativeTexture);
-            glDeleteTextures(1, &widenedTexture);
-            glDeleteProgram(program);
-            EXPECT_EQ(FirstGLError(), 0u) << GLErrorName(FirstGLError());
-        }
-
-        // The case above can be satisfied by the readback fixup alone (ForceWideReadAlphaToOne
-        // rewrites glReadPixels' alpha), so it does NOT prove the STORED alpha is 1.0. This one
-        // does, by asking the driver to read that alpha itself: GL_DST_ALPHA blending multiplies
-        // by the destination alpha inside the raster pipeline, where nothing MobileGL does can
-        // intervene. Same reason GL_ONE_MINUS_DST_ALPHA and glBlitFramebuffer are covered for
-        // free once this holds - and the reason the discipline is a write mask rather than a
-        // readback patch.
-        //
-        // Ablation-checked on llvmpipe, each half separately: disable the alpha doctoring in
-        // SyncRenderState and the opaque draw leaves 0.25 in the stored alpha; disable the clear
-        // substitution in Clear() and it stays at the application's 0.0. Either way this case
-        // reads back the wrong number, which is what makes it a gate rather than a description.
-        TEST_F(ThreeChannelAttachmentScenario, DstAlphaBlendingSeesOneInAWidenedAttachment) {
-            if (!Ready() || IsSkipped()) return;
-
-            static constexpr const char* kSingleOutFS = R"(#version 330 core
-out vec4 oColor;
-uniform vec4 uColor;
-void main() { oColor = uColor; }
-)";
-            std::string error;
-            const GLuint program = CompileProgram(kVS, kSingleOutFS, &error);
-            ASSERT_NE(program, 0u) << error;
-            const GLint colorLocation = glGetUniformLocation(program, "uColor");
-            ASSERT_GE(colorLocation, 0);
-
-            const GLuint widenedTexture = MakeTexture(GL_RGB8_SNORM);
-            ASSERT_NE(widenedTexture, 0u);
-            GLuint fbo = 0;
-            glGenFramebuffers(1, &fbo);
-            glBindFramebuffer(GL_FRAMEBUFFER, fbo);
-            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, widenedTexture, 0);
-            ASSERT_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE));
-
-            const float quad[] = {-1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f};
-            GLuint vao = 0;
-            GLuint vbo = 0;
-            glGenVertexArrays(1, &vao);
-            glBindVertexArray(vao);
-            glGenBuffers(1, &vbo);
-            glBindBuffer(GL_ARRAY_BUFFER, vbo);
-            glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);
-            glEnableVertexAttribArray(0);
-            glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), nullptr);
-            glUseProgram(program);
-            glViewport(0, 0, kSize, kSize);
-
-            // The clear's alpha is 0.0 and the draw's is 0.25 - neither is the 1.0 the format
-            // implies, so both halves of the discipline have to fire for the blend below to see
-            // 1.0: the clear substitutes it, and the draw is masked away from it.
-            glDisable(GL_BLEND);
-            glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-            glClear(GL_COLOR_BUFFER_BIT);
-            glUniform4f(colorLocation, 0.0f, 1.0f, 0.0f, 0.25f);
-            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-
-            // dst = stored alpha; src factor GL_DST_ALPHA, dst factor GL_ZERO, source white
-            // => the destination colour becomes (storedAlpha, storedAlpha, storedAlpha).
-            glEnable(GL_BLEND);
-            glBlendFunc(GL_DST_ALPHA, GL_ZERO);
-            glUniform4f(colorLocation, 1.0f, 1.0f, 1.0f, 1.0f);
-            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-            glDisable(GL_BLEND);
-
-            std::vector<float> pixels(static_cast<std::size_t>(kSize) * kSize * 4, -1.0f);
-            glReadBuffer(GL_COLOR_ATTACHMENT0);
-            glReadPixels(0, 0, kSize, kSize, GL_RGBA, GL_FLOAT, pixels.data());
-            EXPECT_NEAR(pixels[0], 1.0f, 0.02f)
-                << "GL_DST_ALPHA read the stored alpha of a three-channel attachment; it must be 1.0";
-
-            glBindFramebuffer(GL_FRAMEBUFFER, 0);
-            glDeleteFramebuffers(1, &fbo);
-            glDeleteBuffers(1, &vbo);
-            glDeleteVertexArrays(1, &vao);
-            glDeleteTextures(1, &widenedTexture);
-            glDeleteProgram(program);
-            EXPECT_EQ(FirstGLError(), 0u) << GLErrorName(FirstGLError());
-        }
-
-    } // namespace
-} // namespace MGITest

MobileGL/MG_IntegrationTest/Scenarios/XfbAfterClipDistanceScenario.cpp

@@ -1,584 +0,0 @@
-// MobileGL - MobileGL/MG_IntegrationTest/Scenarios/XfbAfterClipDistanceScenario.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
-//
-// Scenario F - a draw must never read a destroyed object's memoised state.
-//
-// Distilled from the order-triggered CTS failure: on DirectVulkan, once
-// KHR-GLxx.clip_distance.functional had run in the same process, every later
-// transform_feedback CAPTURE case failed. It looked like a transform feedback
-// bug and is not one. The capture works; the DRAW being captured fetched its
-// vertices from the WRONG BUFFER - the one the clip workload had just deleted.
-//
-// The mechanism, and why the sequence matters. DirectVulkan memoises a VAO's
-// resolved Vulkan vertex bindings in a table keyed on the VertexArrayObject's
-// heap ADDRESS, validated by a content hash that folds in the bound
-// BufferObject's heap ADDRESS. Both are recycled by the allocator, so when the
-// workload's VAO and vertex buffer are destroyed and the capture phase's own
-// VAO and vertex buffer are allocated onto their addresses under a
-// byte-identical attribute layout (one vec4 float array at location 0 - which
-// is what both phases use), the key matches, the hash matches, and the memo
-// hands the new draw the dead buffer's GPU slice. Nothing about transform
-// feedback is involved: capture just makes the wrong vertices legible, because
-// the captured record IS the vertex data. The fix gives VertexArrayObject and
-// BufferObject never-reused lifetime ids and keys the memo on those.
-//
-// MOBILEGL_ASYNC_SHADER_COMPILE is not part of the defect. It shifts the
-// allocation pattern, so it changes WHICH stop points below land on a recycled
-// address - which is why the CTS saw ~100% incidence with it on and ~2% with it
-// off, and why the sweep case matters more than any single stop point.
-//
-// The shapes are the two CTS cases verbatim in structure:
-//   * the workload is glcClipDistance.cpp FunctionalTest's inner loop (a program
-//     per (redeclaration, clip count), glEnable(GL_CLIP_DISTANCEi), an FBO per
-//     primitive type, a draw and a readback), including its early-return
-//     behaviour: on failure the test returns WITHOUT running its "clip clean"
-//     loop, so GL_CLIP_DISTANCE0..N-1 stay enabled for the rest of the process.
-//     That leftover enable state is NOT the carrier (one of the cases below pins
-//     that); the object churn is.
-//   * the victim is gl3cTransformFeedback3Tests.cpp's skip_components: a
-//     gl_SkipComponents capture layout under GL_RASTERIZER_DISCARD, read back
-//     out of a buffer pre-filled with -1-i so that "captured nothing" is
-//     distinguishable from "captured the wrong thing".
-
-#include <cmath>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <string>
-#include <vector>
-
-#include "../Harness/HeadlessGL.h"
-#include "../Harness/ScenarioFixture.h"
-
-#ifdef GLAPI
-#undef GLAPI
-#endif
-#define GL_GLEXT_PROTOTYPES
-#include <GL/gl.h>
-#include <GL/glcorearb.h>
-#undef GL_GLEXT_PROTOTYPES
-
-#ifndef GL_CLIP_DISTANCE0
-#define GL_CLIP_DISTANCE0 0x3000
-#endif
-
-namespace MGITest {
-    namespace {
-
-        GLuint CompileShader(GLenum type, const std::string& source, std::string* log) {
-            const GLuint shader = glCreateShader(type);
-            const char* text = source.c_str();
-            glShaderSource(shader, 1, &text, nullptr);
-            glCompileShader(shader);
-            GLint status = GL_FALSE;
-            glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
-            if (status == GL_FALSE) {
-                GLint length = 0;
-                glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
-                std::vector<char> buffer(static_cast<std::size_t>(length) + 1, '\0');
-                glGetShaderInfoLog(shader, length + 1, nullptr, buffer.data());
-                if (log != nullptr) *log = buffer.data();
-                glDeleteShader(shader);
-                return 0;
-            }
-            return shader;
-        }
-
-        // Links a vertex/fragment pair, optionally declaring transform feedback
-        // varyings first (glTransformFeedbackVaryings takes effect at the next link,
-        // exactly as the CTS uses it).
-        GLuint BuildProgram(const std::string& vertexSource, const std::string& fragmentSource,
-                            const std::vector<const char*>& xfbVaryings, GLenum bufferMode, std::string* log) {
-            const GLuint vertexShader = CompileShader(GL_VERTEX_SHADER, vertexSource, log);
-            if (vertexShader == 0) return 0;
-            const GLuint fragmentShader = CompileShader(GL_FRAGMENT_SHADER, fragmentSource, log);
-            if (fragmentShader == 0) {
-                glDeleteShader(vertexShader);
-                return 0;
-            }
-            const GLuint program = glCreateProgram();
-            glAttachShader(program, vertexShader);
-            glAttachShader(program, fragmentShader);
-            if (!xfbVaryings.empty()) {
-                glTransformFeedbackVaryings(program, static_cast<GLsizei>(xfbVaryings.size()), xfbVaryings.data(),
-                                            bufferMode);
-            }
-            glLinkProgram(program);
-            glDeleteShader(vertexShader);
-            glDeleteShader(fragmentShader);
-            GLint status = GL_FALSE;
-            glGetProgramiv(program, GL_LINK_STATUS, &status);
-            if (status == GL_FALSE) {
-                GLint length = 0;
-                glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length);
-                std::vector<char> buffer(static_cast<std::size_t>(length) + 1, '\0');
-                glGetProgramInfoLog(program, length + 1, nullptr, buffer.data());
-                if (log != nullptr) *log = buffer.data();
-                glDeleteProgram(program);
-                return 0;
-            }
-            return program;
-        }
-
-        // ---------------------------------------------------------------- poison
-
-        // glcClipDistance.cpp FunctionalTest::m_vertex_shader_code with the same
-        // three substitutions (redeclaration, clip function, array setter).
-        std::string ClipVertexSource(bool redeclaration, unsigned clipCount, unsigned clipFunction,
-                                     unsigned vertexCount) {
-            const std::string count = std::to_string(clipCount);
-            std::string source = "#version 400 core\n\n";
-            if (redeclaration) {
-                source += "out float gl_ClipDistance[" + count + "];\n";
-            }
-            source += "\n";
-            switch (clipFunction) {
-            case 0:
-                source += "float f(int i)\n{\n    return 0.0;\n}\n";
-                break;
-            case 1:
-                source += "float f(int i)\n{\n    return 0.25 + 0.75 * (float(i) + 1.0) * (float(gl_VertexID) + 1.0)"
-                          " / (float(" + count + ") * float(" + std::to_string(vertexCount) + "));\n}\n";
-                break;
-            default:
-                source += "float f(int i)\n{\n    return - 0.25 - 0.75 * (float(i) + 1.0) * (float(gl_VertexID) + 1.0)"
-                          " / (float(" + count + ") * float(" + std::to_string(vertexCount) + "));\n}\n";
-                break;
-            }
-            source += "\nin vec4 position;\n\nvoid main()\n{\n";
-            if (redeclaration) {
-                // Dynamic array setter.
-                source += "    for(int i = 0; i < " + count + "; i++)\n    {\n"
-                          "        gl_ClipDistance[i] = f(i);\n    }\n";
-            } else {
-                // Static array setter, at the highest index this iteration enables.
-                const std::string index = std::to_string(clipCount - 1);
-                source += "    gl_ClipDistance[" + index + "] = f(" + index + ");\n";
-            }
-            source += "\n    gl_Position  = position;\n}\n";
-            return source;
-        }
-
-        const char* kClipFragmentSource = R"(#version 400 core
-
-out vec4 color;
-
-void main()
-{
-    color = vec4(1.0, 0.0, 0.0, 1.0);
-}
-)";
-
-        // How far into FunctionalTest's loop nest to get before bailing out the way
-        // the CTS does on a failed check: return immediately, skipping the "clip
-        // clean" loop that would have disabled GL_CLIP_DISTANCEi again.
-        struct ClipStopPoint {
-            unsigned primitiveIndex = 0; // 0 = POINTS, 1 = LINES, 2 = TRIANGLES
-            unsigned clipFunction = 0;
-            bool redeclaration = false;
-            unsigned clipCount = 1; // 1..8, the iteration that "fails"
-        };
-
-        // Runs FunctionalTest's loop nest up to and including `stop`, then returns
-        // leaving exactly the state the CTS leaves behind on a failure.
-        void RunClipDistanceWorkload(const ClipStopPoint& stop) {
-            static const GLenum kPrimitiveTypes[] = {GL_POINTS, GL_LINES, GL_TRIANGLES};
-            static const GLsizei kPrimitiveIndices[] = {1, 2, 3};
-            static const float kPositions[3][12] = {
-                {0.0f, 0.0f, 0.0f, 1.0f},
-                {-1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f},
-                {-1.0f, -1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f},
-            };
-
-            for (unsigned primitiveIndex = 0; primitiveIndex <= stop.primitiveIndex; ++primitiveIndex) {
-                const GLenum primitiveType = kPrimitiveTypes[primitiveIndex];
-                const GLsizei vertexCount = kPrimitiveIndices[primitiveIndex];
-                const GLsizei framebufferSize = (primitiveType == GL_POINTS) ? 1 : 32;
-
-                GLuint colorBuffer = 0;
-                GLuint framebuffer = 0;
-                glGenRenderbuffers(1, &colorBuffer);
-                glBindRenderbuffer(GL_RENDERBUFFER, colorBuffer);
-                glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, framebufferSize, framebufferSize);
-                glGenFramebuffers(1, &framebuffer);
-                glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
-                glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorBuffer);
-                glViewport(0, 0, framebufferSize, framebufferSize);
-
-                const unsigned lastFunction =
-                    (primitiveIndex == stop.primitiveIndex) ? stop.clipFunction : 2u;
-                for (unsigned clipFunction = 0; clipFunction <= lastFunction; ++clipFunction) {
-                    const bool atStopFunction =
-                        primitiveIndex == stop.primitiveIndex && clipFunction == stop.clipFunction;
-                    for (unsigned redeclaration = 0; redeclaration < 2; ++redeclaration) {
-                        const bool atStopRedeclaration =
-                            atStopFunction && (redeclaration != 0) == stop.redeclaration;
-                        const unsigned lastCount = atStopRedeclaration ? stop.clipCount : 8u;
-                        for (unsigned clipCount = 1; clipCount <= lastCount; ++clipCount) {
-                            std::string log;
-                            const GLuint program =
-                                BuildProgram(ClipVertexSource(redeclaration != 0, clipCount, clipFunction,
-                                                              static_cast<unsigned>(vertexCount)),
-                                             kClipFragmentSource, {}, GL_INTERLEAVED_ATTRIBS, &log);
-                            if (program == 0) continue;
-                            glUseProgram(program);
-
-                            glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-                            glClear(GL_COLOR_BUFFER_BIT);
-
-                            glEnable(GL_CLIP_DISTANCE0 + clipCount - 1);
-
-                            GLuint vao = 0;
-                            GLuint vbo = 0;
-                            glGenVertexArrays(1, &vao);
-                            glBindVertexArray(vao);
-                            glGenBuffers(1, &vbo);
-                            glBindBuffer(GL_ARRAY_BUFFER, vbo);
-                            glBufferData(GL_ARRAY_BUFFER,
-                                         static_cast<GLsizeiptr>(sizeof(float) * 4 * vertexCount),
-                                         kPositions[primitiveIndex], GL_STATIC_DRAW);
-                            const GLint location = glGetAttribLocation(program, "position");
-                            if (location >= 0) {
-                                glEnableVertexAttribArray(static_cast<GLuint>(location));
-                                glVertexAttribPointer(static_cast<GLuint>(location), 4, GL_FLOAT, GL_FALSE, 0,
-                                                      nullptr);
-                            }
-
-                            glDrawArrays(primitiveType, 0, vertexCount);
-
-                            std::vector<unsigned char> pixels(
-                                static_cast<std::size_t>(framebufferSize) * framebufferSize * 4, 0);
-                            glReadPixels(0, 0, framebufferSize, framebufferSize, GL_RGBA, GL_UNSIGNED_BYTE,
-                                         pixels.data());
-
-                            glBindBuffer(GL_ARRAY_BUFFER, 0);
-                            glBindVertexArray(0);
-                            glUseProgram(0);
-                            // MGL_REPRO_KEEPCLIPOBJ leaks the per-iteration objects so
-                            // no GL name and no heap address can be recycled into the
-                            // capture phase.
-                            // Deleting all three is load-bearing, not tidiness: the defect
-                            // this scenario pins needs the VAO's AND its vertex buffer's heap
-                            // addresses to be freed here so the capture phase's own objects
-                            // can be handed the same ones back.
-                            glDeleteBuffers(1, &vbo);
-                            glDeleteVertexArrays(1, &vao);
-                            glDeleteProgram(program);
-
-                            if (atStopRedeclaration && clipCount == stop.clipCount) {
-                                // The CTS's early return: the "clip clean" loop below
-                                // never runs, so the enables survive.
-                                glBindFramebuffer(GL_FRAMEBUFFER, 0);
-                                glDeleteFramebuffers(1, &framebuffer);
-                                glDeleteRenderbuffers(1, &colorBuffer);
-                                return;
-                            }
-                        }
-                        for (unsigned i = 0; i < 8; ++i) {
-                            glDisable(GL_CLIP_DISTANCE0 + i);
-                        }
-                    }
-                }
-
-                glBindFramebuffer(GL_FRAMEBUFFER, 0);
-                glDeleteFramebuffers(1, &framebuffer);
-                glDeleteRenderbuffers(1, &colorBuffer);
-            }
-        }
-
-        // ---------------------------------------------------------------- victim
-
-        // gl3cTransformFeedback3Tests.cpp TransformFeedbackBaseTestCase::m_shader_vert.
-        const char* kXfbVertexSource = R"(#version 400 core
-in vec4 vertex;
-out vec4 value1;
-out vec4 value2;
-out vec4 value3;
-out vec4 value4;
-
-void main (void)
-{
-    vec4 temp = vertex;
-
-    gl_Position = temp;
-
-    value1 = abs(temp) * 1.0;
-    value2 = abs(temp) * 2.0;
-    value3 = abs(temp) * 3.0;
-    value4 = abs(temp) * 4.0;
-}
-)";
-
-        const char* kXfbFragmentSource = R"(#version 400 core
-out vec4 color;
-void main (void)
-{
-    color = vec4(0.0, 0.0, 0.0, 1.0);
-}
-)";
-
-        // The skip_components capture layout, verbatim.
-        std::vector<const char*> SkipComponentsVaryings() {
-            return {"gl_SkipComponents1", "value1",  "gl_SkipComponents2", "gl_SkipComponents1", "value2",
-                    "gl_SkipComponents3", "gl_SkipComponents2", "value3", "gl_SkipComponents4", "value4"};
-        }
-
-        constexpr unsigned kSkipComponentCount = 4 * 4 + (1 + 2 + 3 + 4 + 1 + 2); // 16 values + 13 skipped
-        constexpr unsigned kSkipVertexCount = 6;
-
-        // Runs skip_components and reports what came back. `outCaptured` is the raw
-        // readback so a failure can say whether anything was written at all.
-        void RunSkipComponentsCapture(std::vector<float>& outCaptured, std::string* buildLog) {
-            outCaptured.clear();
-
-            const GLuint program = BuildProgram(kXfbVertexSource, kXfbFragmentSource, SkipComponentsVaryings(),
-                                                GL_INTERLEAVED_ATTRIBS, buildLog);
-            ASSERT_NE(program, 0u) << "skip_components program failed to link: " << (buildLog ? *buildLog : "");
-            glUseProgram(program);
-
-            const std::vector<float> vertices = {
-                -1.0f, -1.0f, -1.0f, 1.0f, 1.0f,  -1.0f, -2.0f, 1.0f, -1.0f, 1.0f, -3.0f, 1.0f,
-                1.0f,  1.0f,  4.0f,  1.0f, -1.0f, 1.0f,  5.0f,  1.0f, 1.0f,  -1.0f, 6.0f, 1.0f,
-            };
-
-            GLuint vao = 0;
-            GLuint vbo = 0;
-            glGenVertexArrays(1, &vao);
-            glBindVertexArray(vao);
-            glGenBuffers(1, &vbo);
-            glBindBuffer(GL_ARRAY_BUFFER, vbo);
-            glBufferData(GL_ARRAY_BUFFER, static_cast<GLsizeiptr>(sizeof(float) * vertices.size()), vertices.data(),
-                         GL_STATIC_DRAW);
-            const GLint location = glGetAttribLocation(program, "vertex");
-            if (location >= 0) {
-                glEnableVertexAttribArray(static_cast<GLuint>(location));
-                glVertexAttribPointer(static_cast<GLuint>(location), 4, GL_FLOAT, GL_FALSE, 0, nullptr);
-            }
-
-            const unsigned floatCount = kSkipVertexCount * kSkipComponentCount;
-            const GLsizeiptr byteSize = static_cast<GLsizeiptr>(sizeof(float) * floatCount);
-
-            GLuint captureBuffer = 0;
-            glGenBuffers(1, &captureBuffer);
-            glBindBuffer(GL_ARRAY_BUFFER, captureBuffer);
-            glBufferData(GL_ARRAY_BUFFER, byteSize, nullptr, GL_STATIC_READ);
-            glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, captureBuffer);
-            glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-            // The pre-fill that makes "nothing was captured" recognisable.
-            std::vector<float> prefill(floatCount);
-            for (unsigned i = 0; i < floatCount; ++i) {
-                prefill[i] = -1.0f - static_cast<float>(i);
-            }
-            glBindBuffer(GL_ARRAY_BUFFER, captureBuffer);
-            glBufferData(GL_ARRAY_BUFFER, byteSize, prefill.data(), GL_STATIC_DRAW);
-            glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-            glEnable(GL_RASTERIZER_DISCARD);
-            glClearColor(0.1f, 0.0f, 0.5f, 1.0f);
-            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-            glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, captureBuffer);
-            glBeginTransformFeedback(GL_TRIANGLES);
-            glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(kSkipVertexCount));
-            glEndTransformFeedback();
-            glDisable(GL_RASTERIZER_DISCARD);
-
-            outCaptured.resize(floatCount);
-            glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, captureBuffer, 0, byteSize);
-            const void* mapped = glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, byteSize, GL_MAP_READ_BIT);
-            if (mapped != nullptr) {
-                std::memcpy(outCaptured.data(), mapped, static_cast<std::size_t>(byteSize));
-                glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
-            }
-
-            glDisableVertexAttribArray(0);
-            glBindBuffer(GL_ARRAY_BUFFER, 0);
-            glDeleteBuffers(1, &vbo);
-            glDeleteBuffers(1, &captureBuffer);
-            glBindVertexArray(0);
-            glDeleteVertexArrays(1, &vao);
-            glUseProgram(0);
-            glDeleteProgram(program);
-            glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
-        }
-
-        // skip_components' expected buffer: the 13 skipped components keep their
-        // pre-fill, the 16 captured ones carry |vertex| * n.
-        std::vector<float> SkipComponentsExpected() {
-            const std::vector<float> vertices = {
-                -1.0f, -1.0f, -1.0f, 1.0f, 1.0f,  -1.0f, -2.0f, 1.0f, -1.0f, 1.0f, -3.0f, 1.0f,
-                1.0f,  1.0f,  4.0f,  1.0f, -1.0f, 1.0f,  5.0f,  1.0f, 1.0f,  -1.0f, 6.0f, 1.0f,
-            };
-            const unsigned floatCount = kSkipVertexCount * kSkipComponentCount;
-            std::vector<float> expected(floatCount);
-            for (unsigned i = 0; i < floatCount; ++i) {
-                expected[i] = -1.0f - static_cast<float>(i);
-            }
-            // Record layout, in floats:
-            //   [0]      skip1
-            //   [1..4]   value1
-            //   [5..7]   skip2 + skip1
-            //   [8..11]  value2
-            //   [12..16] skip3 + skip2
-            //   [17..20] value3
-            //   [21..24] skip4
-            //   [25..28] value4
-            static const unsigned kValueOffsets[4] = {1, 8, 17, 25};
-            for (unsigned v = 0; v < kSkipVertexCount; ++v) {
-                const unsigned base = v * kSkipComponentCount;
-                for (unsigned value = 0; value < 4; ++value) {
-                    for (unsigned component = 0; component < 4; ++component) {
-                        const float source = vertices[v * 4 + component];
-                        expected[base + kValueOffsets[value] + component] =
-                            std::fabs(source) * static_cast<float>(value + 1);
-                    }
-                }
-            }
-            return expected;
-        }
-
-        // Reports the first mismatch, and whether the readback is byte-for-byte the
-        // pre-fill (i.e. the capture never happened).
-        ::testing::AssertionResult CheckSkipComponents(const std::vector<float>& captured) {
-            const std::vector<float> expected = SkipComponentsExpected();
-            if (captured.size() != expected.size()) {
-                return ::testing::AssertionFailure()
-                       << "readback size " << captured.size() << " != " << expected.size();
-            }
-            bool anyWritten = false;
-            for (std::size_t i = 0; i < captured.size(); ++i) {
-                if (captured[i] != -1.0f - static_cast<float>(i)) {
-                    anyWritten = true;
-                    break;
-                }
-            }
-            for (std::size_t i = 0; i < expected.size(); ++i) {
-                if (std::fabs(captured[i] - expected[i]) > 0.0125f) {
-                    return ::testing::AssertionFailure()
-                           << "capture mismatch at index " << i << ": got " << captured[i] << ", expected "
-                           << expected[i] << (anyWritten ? "" : " (the whole buffer is still the pre-fill: "
-                                                               "NOTHING was captured)");
-                }
-            }
-            return ::testing::AssertionSuccess();
-        }
-
-        // The harness turns "no context came up" into a clean skip, and a skip is
-        // indistinguishable from a pass in a ctest summary. For this scenario that
-        // is a hole rather than a courtesy: the defect it pins is DirectVulkan's
-        // alone, and DirectVulkan now comes up headless on any machine at all - a
-        // surfaceless EGL platform over a software ICD (lavapipe) is enough. So
-        // "DirectVulkan did not initialise" here means the run is MISCONFIGURED,
-        // not that the machine has no GPU, and it must not report green.
-        //
-        // Local on purpose: the harness-wide skip semantics are deliberate
-        // (ScenarioFixture.h states the reasoning), and MOBILEGL_ITEST_REQUIRE_GPU
-        // is the harness-wide lever for the same intent - but that lever also
-        // demands a HARDWARE renderer, which is exactly what a lavapipe-only box
-        // cannot offer. This overrides nothing else: only this scenario, only for
-        // the backend that can regress, and only for the unusable-harness case.
-        class XfbAfterClipDistanceScenario : public ScenarioTest {
-        protected:
-            void SetUp() override {
-                ScenarioTest::SetUp();
-                // Ready() is false on the base's skip path AND on its REQUIRE_GPU
-                // failure path; the second one has already failed, so leave it alone
-                // rather than burying its reason under a second message.
-                if (Ready() || HasFatalFailure()) return;
-                if (Gl().BackendName() == "DirectVulkan") {
-                    FAIL() << "DirectVulkan could not be brought up, so the regression this scenario guards - a "
-                              "draw served a destroyed VAO's memoised vertex bindings - was never exercised, and "
-                              "that must be a failure rather than a silent skip. Headless bring-up needs only a "
-                              "Vulkan ICD and a surfaceless EGL platform (a software ICD such as lavapipe "
-                              "qualifies: VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/lvp_icd.x86_64.json with "
-                              "EGL_PLATFORM=surfaceless). Harness reason: "
-                           << Gl().SkipReason();
-                }
-            }
-        };
-
-        // Control: the capture on its own must work.
-        TEST_F(XfbAfterClipDistanceScenario, SkipComponentsCaptureAlone) {
-            if (!Ready()) return;
-            std::vector<float> captured;
-            std::string log;
-            RunSkipComponentsCapture(captured, &log);
-            EXPECT_TRUE(CheckSkipComponents(captured));
-        }
-
-        // Bisection step 1: only the leftover GL_CLIP_DISTANCEi enables.
-        TEST_F(XfbAfterClipDistanceScenario, SkipComponentsCaptureAfterClipDistanceEnables) {
-            if (!Ready()) return;
-            for (unsigned i = 0; i < 8; ++i) {
-                glEnable(GL_CLIP_DISTANCE0 + i);
-            }
-            std::vector<float> captured;
-            std::string log;
-            RunSkipComponentsCapture(captured, &log);
-            for (unsigned i = 0; i < 8; ++i) {
-                glDisable(GL_CLIP_DISTANCE0 + i);
-            }
-            EXPECT_TRUE(CheckSkipComponents(captured));
-        }
-
-        // Bisection step 2: the whole clip_distance.functional workload, stopped
-        // where the CTS stopped in the runs that went on to break the capture.
-        TEST_F(XfbAfterClipDistanceScenario, SkipComponentsCaptureAfterClipDistanceWorkloadLines8) {
-            if (!Ready()) return;
-            RunClipDistanceWorkload({.primitiveIndex = 1, .clipFunction = 0, .redeclaration = false, .clipCount = 8});
-            std::vector<float> captured;
-            std::string log;
-            RunSkipComponentsCapture(captured, &log);
-            for (unsigned i = 0; i < 8; ++i) {
-                glDisable(GL_CLIP_DISTANCE0 + i);
-            }
-            EXPECT_TRUE(CheckSkipComponents(captured));
-        }
-
-        TEST_F(XfbAfterClipDistanceScenario, SkipComponentsCaptureAfterClipDistanceWorkloadPoints1) {
-            if (!Ready()) return;
-            RunClipDistanceWorkload({.primitiveIndex = 0, .clipFunction = 0, .redeclaration = true, .clipCount = 1});
-            std::vector<float> captured;
-            std::string log;
-            RunSkipComponentsCapture(captured, &log);
-            for (unsigned i = 0; i < 8; ++i) {
-                glDisable(GL_CLIP_DISTANCE0 + i);
-            }
-            EXPECT_TRUE(CheckSkipComponents(captured));
-        }
-
-        // A single stop point is not a regression test for this defect: whether the
-        // capture phase's VAO and vertex buffer land on the addresses the workload just
-        // freed is a function of how much the workload allocated, so the two cases above
-        // pin two draws of a lottery. Sweep the grid instead - before the fix, roughly a
-        // third of these stop points came back holding the workload's vertex data.
-        TEST_F(XfbAfterClipDistanceScenario, SkipComponentsCaptureSurvivesEveryClipWorkloadStopPoint) {
-            if (!Ready()) return;
-            for (unsigned primitiveIndex = 0; primitiveIndex < 3; ++primitiveIndex) {
-                for (unsigned redeclaration = 0; redeclaration < 2; ++redeclaration) {
-                    for (const unsigned clipCount : {1u, 4u, 8u}) {
-                        RunClipDistanceWorkload({.primitiveIndex = primitiveIndex,
-                                                 .clipFunction = 0,
-                                                 .redeclaration = redeclaration != 0,
-                                                 .clipCount = clipCount});
-                        std::vector<float> captured;
-                        std::string log;
-                        RunSkipComponentsCapture(captured, &log);
-                        for (unsigned i = 0; i < 8; ++i) {
-                            glDisable(GL_CLIP_DISTANCE0 + i);
-                        }
-                        EXPECT_TRUE(CheckSkipComponents(captured))
-                            << " (stop point: primitive " << primitiveIndex << ", redeclaration " << redeclaration
-                            << ", clip count " << clipCount << ")";
-                    }
-                }
-            }
-        }
-
-    } // namespace
-} // namespace MGITest

MobileGL/MG_IntegrationTest/run_integration_test.sh

@@ -1,47 +0,0 @@
-#!/bin/bash
-# Run the headless MobileGL integration scenarios on one backend:
-#   ./run_integration_test.sh espryt [gtest args...]     -> DirectGLES
-#   ./run_integration_test.sh magma  [gtest args...]     -> DirectVulkan
-#
-# The backend is latched at initialization from MOBILEGL_BACKEND_TYPE, so one
-# process is one backend; this script is the dev-box equivalent of the two ctest
-# registrations in CMakeLists.txt.
-#
-# Pin the vendor libraries explicitly, for the same reason
-# MG_Benchmark/Driver/run_driver_bench.sh does: a bare libEGL on a glvnd system
-# resolves to whatever vendor comes first, which is usually Mesa/llvmpipe - a
-# software rasteriser silently replacing the GPU under a GPU test. Override
-# MGL_EGL_VENDOR / MGL_VK_ICD to test another driver.
-#
-# Set MOBILEGL_ITEST_REQUIRE_GPU=1 to turn "the harness is unusable" from a clean
-# skip into a failure. Do that anywhere the machine is supposed to have a GPU: a
-# run that skipped everything and a run that passed everything are otherwise the
-# same green, so without it a broken driver pinning is invisible.
-set -eu
-HERE=$(cd "$(dirname "$0")" && pwd)
-BIN=${MOBILEGL_ITEST_BIN:-$HERE/MobileGLIntegrationTest}
-EGL_VENDOR=${MGL_EGL_VENDOR:-/usr/share/glvnd/egl_vendor.d/10_nvidia.json}
-VK_ICD=${MGL_VK_ICD:-/usr/share/vulkan/icd.d/nvidia_icd.x86_64.json}
-MODE=$1; shift
-
-if [ ! -x "$BIN" ]; then
-  echo "MobileGLIntegrationTest not found at $BIN"
-  echo "configure with -DMOBILEGL_BUILD_INTEGRATION_TEST=ON and set MOBILEGL_ITEST_BIN"
-  exit 1
-fi
-
-[ -r "$EGL_VENDOR" ] && export __EGL_VENDOR_LIBRARY_FILENAMES=$EGL_VENDOR
-export EGL_PLATFORM=${EGL_PLATFORM:-x11}
-
-case "$MODE" in
-  espryt|DirectGLES)
-    export MOBILEGL_BACKEND_TYPE=DirectGLES
-    ;;
-  magma|DirectVulkan)
-    export MOBILEGL_BACKEND_TYPE=DirectVulkan
-    [ -r "$VK_ICD" ] && export VK_ICD_FILENAMES=$VK_ICD
-    ;;
-  *) echo "unknown mode: $MODE (espryt|magma)"; exit 1 ;;
-esac
-export MOBILEGL_ITEST_REQUIRE_GPU=${MOBILEGL_ITEST_REQUIRE_GPU:-}
-exec "$BIN" "$@"

MobileGL/MG_State/GLState/BufferState/BufferObject.cpp

@@ -8,17 +8,9 @@
 
 #include "BufferObject.h"
 
-#include <atomic>
-
 namespace MobileGL::MG_State::GLState {
     namespace {
         const BufferBackendOps* g_bufferBackendOps = nullptr;
-        // Starts at 1 so a zero-initialized cache slot can never carry a live buffer's id.
-        std::atomic<Uint64> g_nextBufferLifetimeId{1};
-    }
-
-    Uint64 BufferObject::AllocateLifetimeId() {
-        return g_nextBufferLifetimeId.fetch_add(1, std::memory_order_relaxed);
     }
 
     void SetBufferBackendOps(const BufferBackendOps* ops) {
@@ -49,7 +41,6 @@ namespace MobileGL::MG_State::GLState {
     void BufferObject::NotifySubData(SizeT offset, SizeT size) {
         ++m_changeSerial;
         if (size == 0) return;
-        m_hasDefinedContent = true;
         if (g_bufferBackendOps && g_bufferBackendOps->SubData) {
             g_bufferBackendOps->SubData(*this, offset, size);
         }
@@ -58,14 +49,12 @@ namespace MobileGL::MG_State::GLState {
     void BufferObject::NotifyFlushMappedRange(Range1D range, Flags<BufferMappingAccessBit> appAccess) {
         ++m_changeSerial;
         if (range.start >= range.end) return;
-        m_hasDefinedContent = true;
         if (g_bufferBackendOps && g_bufferBackendOps->FlushMappedRange) {
             g_bufferBackendOps->FlushMappedRange(*this, range, appAccess);
         }
     }
 
     void BufferObject::NotifyContentWrite(SizeT offset, SizeT size) {
-        m_hasDefinedContent = true;
         if (m_resource.IsGpuResident()) {
             // The write already landed in coherent GPU memory; the backend has no separate
             // copy to sync. Only bump the serial so cached transient slices invalidate.
@@ -82,9 +71,6 @@ namespace MobileGL::MG_State::GLState {
         if (data && size > 0) {
             Memcpy(m_resource.Bytes(), data, size);
         }
-        // A NULL-data respecify (the orphaning idiom) leaves the store undefined;
-        // record that so backends skip uploading the stale shadow bytes.
-        m_hasDefinedContent = (data != nullptr) || size == 0;
         m_isImmutableStorage = false;
         m_storageFlags = 0;
         NotifyRespecify();
@@ -103,7 +89,6 @@ namespace MobileGL::MG_State::GLState {
         } else if (size > 0) {
             Memset(m_resource.Bytes(), 0, size);
         }
-        m_hasDefinedContent = true;
         m_isImmutableStorage = true;
         m_storageFlags = storageFlags;
         NotifyRespecify();
@@ -190,7 +175,6 @@ namespace MobileGL::MG_State::GLState {
     }
 
     void BufferObject::MarkGpuWritten() {
-        m_hasDefinedContent = true;
         m_gpuWritePending = true;
     }
 
@@ -206,11 +190,8 @@ namespace MobileGL::MG_State::GLState {
     }
 
     void BufferObject::UploadSubData(DataPtr data, SizeT atOffset) {
-        // GL 4.6 core 6.5 forbids only the OVERLAPPING write: a glBufferSubData that stays
-        // clear of a non-persistent mapping is legal, and the frontend lets it through.
-        MOBILEGL_ASSERT(!m_isMapped || (m_mappingAccess & BufferMappingAccessBit::Persistent) ||
-                            atOffset >= m_mappedRange.end || atOffset + data.size <= m_mappedRange.start,
-                        "Cannot upload sub data overlapping a non-persistent mapping.");
+        MOBILEGL_ASSERT(!m_isMapped || (m_mappingAccess & BufferMappingAccessBit::Persistent),
+                        "Cannot upload sub data while buffer is non-persistently mapped.");
         MOBILEGL_ASSERT(atOffset + data.size <= m_size,
                         "UploadSubData out of bounds: atOffset (%zu) + data.size (%zu) > m_size (%zu)", atOffset,
                         data.size, m_size);
@@ -351,10 +332,6 @@ namespace MobileGL::MG_State::GLState {
         return m_changeSerial;
     }
 
-    Bool BufferObject::HasDefinedContent() const {
-        return m_hasDefinedContent;
-    }
-
     const SharedPtr<BackendBufferResource>& BufferObject::GetBackendResource() const {
         return m_resource.Backend();
     }

MobileGL/MG_State/GLState/BufferState/BufferObject.h

@@ -185,21 +185,9 @@ namespace MobileGL {
             Flags<BufferMappingAccessBit> GetMappingAccess() const;
             GLbitfield GetStorageFlags() const;
             Uint GetExternalIndex() const;
-            // Globally-unique, never-reused id for THIS object's lifetime - same contract
-            // and same motivation as ProgramObject::GetLifetimeId() and
-            // VertexArrayObject::GetLifetimeId(). A backend that folds a buffer's IDENTITY
-            // into a cache key must use this, never the GL name (LIFO-recycled by
-            // glGenBuffers) and never the heap address (recycled by the allocator): both
-            // let a deleted-and-recreated buffer answer to a dead one's cache entry.
-            Uint64 GetLifetimeId() const { return m_lifetimeId; }
             // Monotonic counter bumped on every shadow mutation; backends use it to
             // validate cached transient slices.
             Uint64 GetChangeSerial() const;
-            // False after a NULL-data (re)specification until the first content
-            // write: the app's orphaning idiom (glBufferData with nullptr) leaves
-            // the store undefined, so backends may (re)allocate GPU storage without
-            // uploading the stale CPU shadow.
-            Bool HasDefinedContent() const;
 
             const SharedPtr<BackendBufferResource>& GetBackendResource() const;
             void SetBackendResource(SharedPtr<BackendBufferResource> resource);
@@ -214,10 +202,7 @@ namespace MobileGL {
             // SubData transfer to sync the backend's separate GPU copy.
             void NotifyContentWrite(SizeT offset, SizeT size);
 
-            static Uint64 AllocateLifetimeId();
-
             const Uint m_externalIndex = 0;
-            const Uint64 m_lifetimeId = AllocateLifetimeId();
             SizeT m_size = 0;
             BufferUsage m_usage = BufferUsage::StaticDraw;
             // Owns the buffer's bytes (CPU shadow or backend persistent GPU map) and
@@ -228,8 +213,6 @@ namespace MobileGL {
             Bool m_isImmutableStorage = false;
             GLbitfield m_storageFlags = 0;
             Uint64 m_changeSerial = 0;
-            // See HasDefinedContent().
-            Bool m_hasDefinedContent = true;
             // Set by MarkGpuWritten, cleared by SyncGpuWrites once the shadow is refreshed.
             Bool m_gpuWritePending = false;
             Range1D m_mappedRange;

MobileGL/MG_State/GLState/Core.cpp

@@ -9,9 +9,6 @@
 #include "Core.h"
 #include "MG_State/GLState/RenderbufferState/RenderbufferObject.h"
 #include "MG_State/EGLState/Core.h"
-#include <MG_Backend/BackendObjects.h>
-#include <MG_Util/Async/ShaderCompilePool.h>
-#include <MG_Util/ShaderTranspiler/CompileEnv.h>
 #include <Config.h>
 
 namespace MobileGL::MG_State {
@@ -27,27 +24,8 @@ namespace MobileGL::MG_State {
     }
 
     namespace GLState {
-        const SharedPtr<const MG_Util::ShaderTranspiler::CompileEnv>& GLContext::GetCompileEnv() {
-            const void* backend = static_cast<const void*>(MG_Backend::pActiveBackendObject.get());
-            if (!m_compileEnv || m_compileEnvBackend != backend) {
-                // First use, or the backend was swapped underneath us. Re-capturing rolls the
-                // fingerprint, so every P0b preprocess memo computed against the old backend's
-                // limits becomes structurally unreachable instead of silently reusable.
-                m_compileEnv = MG_Util::ShaderTranspiler::CaptureCompileEnv();
-                m_compileEnvBackend = backend;
-            }
-            return m_compileEnv;
-        }
-
         // Error
         void GLContext::RecordError(ErrorCode code, UniquePtr<ErrorInfo> info) {
-            // Invariant I1, mechanically enforced: the GL error state is GL-thread-owned.
-            // A compile or link body that needs to raise an error must append to its node's
-            // JobDiagnostics and let the join replay it here (see the P1 design section 6);
-            // reaching this from a worker would corrupt the sticky-flag set that
-            // glGetError's ordering depends on.
-            MOBILEGL_ASSERT(!MG_Util::Async::ShaderCompilePool::IsPoolThread(),
-                            "GLContext::RecordError() called from a shader-compile pool thread");
             m_errorState.RecordError(code, Move(info));
         }
 
@@ -357,10 +335,6 @@ namespace MobileGL::MG_State {
             return m_programState.GetShaderObject(index);
         }
 
-        void GLContext::JoinAllPendingShaderWork() {
-            m_programState.JoinAllPendingWork();
-        }
-
         void GLContext::UseProgram(Uint program) {
             return m_programState.UseProgram(program);
         }
@@ -369,88 +343,7 @@ namespace MobileGL::MG_State {
             return m_programState.GetCurrentProgram();
         }
 
-        const SharedPtr<ProgramObject>& GLContext::GetProgramForDraw() {
-            static const SharedPtr<ProgramObject> nullProgram = nullptr;
-            const auto& currentProgram = m_programState.GetCurrentProgram();
-            if (currentProgram) {
-                // P1 join site J1, plain glUseProgram half. The backends read a program's
-                // lifetimeId / backendStateVersion / UBO content version to decide whether
-                // their per-program caches are still valid, and none of those pass through
-                // ProgramObject's join gate - so a draw could sample a version, join later
-                // inside the same draw when it finally touched an artifact, and cache under a
-                // version the publish had already superseded. Settling here means every
-                // version a backend reads during a draw describes the program it is drawing.
-                // One null check in steady state.
-                currentProgram->JoinLink();
-                return currentProgram;
-            }
-            if (m_boundProgramPipeline == 0) return nullProgram;
-            const auto& pipeline = GetBoundProgramPipeline();
-            if (!pipeline) return nullProgram;
-
-            // P1 join site J1. ComputeDrawProgramSignature() keys the composite cache on each
-            // stage program's lifetimeId and backendStateVersion - NON-artifact fields, so
-            // they do not pass through ProgramObject's join gate and a pending link would
-            // stay pending right through the signature. Since the version is bumped both at
-            // enqueue and at publish, the signature computed inside a pending window is one
-            // that will never be produced again: every draw would miss the cache and rebuild
-            // (and relink) the composite. Join first, so the signature describes settled
-            // programs. In steady state this is a null check per stage.
-            for (SizeT stage = 0; stage < static_cast<SizeT>(ShaderStage::ShaderStageCount); ++stage) {
-                const auto& stageProgram = pipeline->GetStageProgram(static_cast<ShaderStage>(stage));
-                if (stageProgram) stageProgram->JoinLink();
-            }
-
-            const auto signature = pipeline->ComputeDrawProgramSignature();
-            if (const auto& cached = pipeline->GetCachedDrawProgram(signature)) return cached;
-
-            // Everything downstream of here - the backends, the uniform plumbing, the draw
-            // validation - is written against a single linked program, so the pipeline is
-            // flattened into one. Each stage contributes only the shaders that serve it, so a
-            // program bound to two stages is not pulled in twice and a program bound to a
-            // stage it does not implement contributes nothing.
-            // Deliberately not a named program: it is reachable only through the pipeline, it
-            // must not answer glIsProgram, and it must not consume a name the application
-            // could otherwise be handed. Backend registries key on the object, not the name.
-            auto composite = MakeShared<ProgramObject>(0u);
-
-            Bool anyStage = false;
-            for (SizeT stage = 0; stage < static_cast<SizeT>(ShaderStage::ShaderStageCount); ++stage) {
-                const auto& stageProgram = pipeline->GetStageProgram(static_cast<ShaderStage>(stage));
-                if (!stageProgram) continue;
-                for (const auto& shader : stageProgram->GetAttachedShaders()) {
-                    if (!shader || static_cast<SizeT>(shader->GetShaderStage()) != stage) continue;
-                    composite->AttachShader(shader);
-                    anyStage = true;
-                }
-            }
-            if (!anyStage) return nullProgram;
-            // A pipeline with no fragment stage still rasterises, so the default fragment
-            // shader is wanted here even though the separable stage programs never get one.
-            composite->Link(true);
-            // P1 join site J2. The draw that asked for this program is the very next thing to
-            // happen, so enqueueing the composite's link buys nothing and only moves the wait
-            // to whichever backend accessor happens to touch its artifacts first.
-            composite->JoinLink();
-            pipeline->SetCachedDrawProgram(signature, Move(composite));
-            return pipeline->GetCachedDrawProgram(signature);
-        }
-
-        const SharedPtr<ProgramObject>& GLContext::GetProgramForUniform() {
-            const auto& currentProgram = m_programState.GetCurrentProgram();
-            if (currentProgram) return currentProgram;
-            static const SharedPtr<ProgramObject> nullProgram = nullptr;
-            if (m_boundProgramPipeline == 0) return nullProgram;
-            const auto& pipeline = GetBoundProgramPipeline();
-            if (!pipeline) return nullProgram;
-            return pipeline->GetActiveProgram();
-        }
-
         // RenderState
-        Uint GLContext::GetPipelineStateVersion() const {
-            return m_renderState.GetPipelineStateVersion();
-        }
-
         Uint GLContext::GetRenderStateParametersVersion() const {
             return m_renderState.GetVersion();
         }
@@ -909,53 +802,6 @@ namespace MobileGL::MG_State {
                 m_transformFeedbackObjects[id] = {};
             }
         }
-        // Program pipeline
-        void GLContext::GenProgramPipelineNames(Uint number, Vector<Uint>& pipelines) {
-            pipelines.resize(number);
-            // Names only: glIsProgramPipeline must answer GL_FALSE until one is bound or created.
-            m_programPipelineNames.Generate(number, pipelines.data());
-        }
-
-        void GLContext::CreateProgramPipelineObject(Uint index) {
-            m_programPipelines[index] = MakeShared<ProgramPipelineObject>(index);
-        }
-
-        Bool GLContext::ValidateProgramPipelineName(Uint index) const {
-            return index == 0 || m_programPipelineNames.IsValid(index);
-        }
-
-        Bool GLContext::IsProgramPipelineObject(Uint index) const {
-            if (index == 0 || !m_programPipelineNames.IsValid(index)) return false;
-            return m_programPipelines.find(index) != m_programPipelines.end();
-        }
-
-        void GLContext::BindProgramPipelineObject(Uint index) {
-            if (index != 0 && m_programPipelines.find(index) == m_programPipelines.end()) {
-                // First bind is what turns a reserved name into an object.
-                m_programPipelines[index] = MakeShared<ProgramPipelineObject>(index);
-            }
-            m_boundProgramPipeline = index;
-        }
-
-        void GLContext::MarkProgramPipelineForDeletion(Uint index) {
-            if (index == 0 || !m_programPipelineNames.IsValid(index)) return;
-            if (index == m_boundProgramPipeline) {
-                m_boundProgramPipeline = 0;
-            }
-            m_programPipelines.erase(index);
-            m_programPipelineNames.Delete(index);
-        }
-
-        const SharedPtr<ProgramPipelineObject>& GLContext::GetProgramPipelineObject(Uint index) const {
-            static const SharedPtr<ProgramPipelineObject> kNone;
-            const auto it = m_programPipelines.find(index);
-            return it == m_programPipelines.end() ? kNone : it->second;
-        }
-
-        const SharedPtr<ProgramPipelineObject>& GLContext::GetBoundProgramPipeline() const {
-            return GetProgramPipelineObject(m_boundProgramPipeline);
-        }
-
 
         Bool GLContext::ValidateTransformFeedbackName(Uint index) const {
             return index == 0 || m_transformFeedbackNames.IsValid(index);

MobileGL/MG_State/GLState/Core.h

@@ -14,17 +14,12 @@
 #include "MG_State/GLState/RenderbufferState/RenderbufferState.h"
 #include "RenderState/RenderState.h"
 #include "ProgramState/ProgramState.h"
-#include "ProgramState/ProgramPipelineObject.h"
 #include "SamplerState/SamplerState.h"
 #include "TextureState/TextureState.h"
 #include "FramebufferState/FramebufferState.h"
 #include "VertexArrayState/VertexArrayState.h"
 #include "RenderbufferState/RenderbufferState.h"
 
-namespace MobileGL::MG_Util::ShaderTranspiler {
-    struct CompileEnv;
-}
-
 namespace MobileGL {
     namespace MG_State {
         void Init();
@@ -115,27 +110,13 @@ namespace MobileGL {
                 TextureUnit& GetTextureUnitObject(Int unit);
                 ImageTextureBinding& GetImageTextureBinding(Int unit);
                 const ImageTextureBinding& GetImageTextureBinding(Int unit) const;
-                void NoteTextureUnitTouched(Int unit, Bool bindingChanged = true) {
-                    m_textureState.NoteUnitTouched(unit, bindingChanged);
-                }
+                void NoteTextureUnitTouched(Int unit) { m_textureState.NoteUnitTouched(unit); }
                 Int GetMaxTouchedTextureUnit() const { return m_textureState.GetMaxTouchedUnit(); }
                 // Monotonic counter bumped whenever a texture bind/unbind/delete changes which
                 // texture is bound at a unit; lets a backend skip re-resolving an unchanged
                 // per-draw sampled-texture set.
                 Uint64 GetTextureBindGeneration() const { return m_textureState.GetTextureBindGeneration(); }
                 void BumpTextureBindGeneration() { m_textureState.BumpTextureBindGeneration(); }
-                // Monotonic counter bumped whenever a texture's shape or a sampler object's
-                // parameters change, i.e. whenever a bound texture's mipmap-completeness (and so
-                // whether a backend binds it at all) can have flipped without any bind moving;
-                // see TextureState::GetSamplingResolutionGeneration.
-                Uint64 GetSamplingResolutionGeneration() const {
-                    return m_textureState.GetSamplingResolutionGeneration();
-                }
-                void BumpSamplingResolutionGeneration() { m_textureState.BumpSamplingResolutionGeneration(); }
-                // Never-reused id of this context, for backend memos keyed on the two counters
-                // above: both restart at 0 in a new context, and a recreated context can land on
-                // the old heap address. See TextureState::GetContextId.
-                Uint64 GetTextureContextId() const { return m_textureState.GetContextId(); }
                 Bool ValidateTextureName(Uint index) const;
                 Bool ValidateTextureObject(Uint index) const;
                 Int GetActiveTextureUnit() const;
@@ -153,40 +134,11 @@ namespace MobileGL {
                 Bool ValidateShaderName(Uint index) const;
                 const SharedPtr<ProgramObject>& GetProgramObject(Uint index);
                 const SharedPtr<ShaderObject>& GetShaderObject(Uint index);
-                // Settles every compile and link this context still owns; see
-                // ProgramState::JoinAllPendingWork. Called by glMaxShaderCompilerThreadsKHR(0).
-                void JoinAllPendingShaderWork();
-                // P1 stage 6: the per-context index of adoptable compile nodes, for its
-                // adoption counter. Diagnostics and tests only - no GL entry point reads it.
-                ShaderCompileAdoptionMap& GetShaderCompileAdoptionMap() {
-                    return m_programState.GetShaderCompileAdoptionMap();
-                }
                 void UseProgram(Uint program);
                 const SharedPtr<ProgramObject>& GetCurrentProgram();
-                // What a draw or dispatch actually executes: the program in use, or - when
-                // there is none - the bound pipeline's stages composited into one program.
-                const SharedPtr<ProgramObject>& GetProgramForDraw();
-                // What glUniform* addresses: the program in use, or the bound pipeline's
-                // active program (GL 4.6 core 7.6.1).
-                const SharedPtr<ProgramObject>& GetProgramForUniform();
-
-                // Program pipeline (GL_ARB_separate_shader_objects, GL 4.6 core 7.4). Like queries
-                // and transform feedbacks, glGenProgramPipelines only RESERVES a name - the object
-                // appears on first bind - while glCreateProgramPipelines makes it immediately.
-                void GenProgramPipelineNames(Uint number, Vector<Uint>& pipelines);
-                void CreateProgramPipelineObject(Uint index);
-                Bool ValidateProgramPipelineName(Uint index) const;
-                Bool IsProgramPipelineObject(Uint index) const;
-                void BindProgramPipelineObject(Uint index);
-                void MarkProgramPipelineForDeletion(Uint index);
-                const SharedPtr<ProgramPipelineObject>& GetProgramPipelineObject(Uint index) const;
-                Uint GetBoundProgramPipelineName() const { return m_boundProgramPipeline; }
-                const SharedPtr<ProgramPipelineObject>& GetBoundProgramPipeline() const;
 
                 // RenderState
                 Uint GetRenderStateParametersVersion() const;
-                // Only the pipeline-relevant subset - see RenderState::m_pipelineStateVersion.
-                Uint GetPipelineStateVersion() const;
                 const RenderStateParameters& GetRenderStateParameters() const;
                 void SetViewport(IntVec4 viewport); // x, y, width, height
                 const IntVec4& GetViewport() const; // x, y, width, height
@@ -392,15 +344,6 @@ namespace MobileGL {
                 Bool ValidateRenderbufferName(Uint index) const;
                 Bool ValidateRenderbufferObject(Uint index) const;
 
-                // P1: the shader compile/link pipeline's snapshot of everything it reads from
-                // outside its own (stage, source) inputs. Captured lazily here because it
-                // cannot be captured in MG_State::Init() - that runs BEFORE MG_Backend::Init(),
-                // so there is no backend to query yet. Re-captured whenever the active backend
-                // object changes, which also rolls the fingerprint and therefore invalidates
-                // every P0b preprocess memo keyed against the old one.
-                // GL thread only.
-                const SharedPtr<const MG_Util::ShaderTranspiler::CompileEnv>& GetCompileEnv();
-
             private:
                 // State Components
                 ErrorState m_errorState;
@@ -447,22 +390,12 @@ namespace MobileGL {
                 UnorderedMap<Uint, TransformFeedbackObjectState> m_transformFeedbackObjects;
                 IndexGenerator<Uint> m_transformFeedbackNames;
                 Uint m_boundTransformFeedback = 0;
-                // Map membership IS object existence here: a pipeline has no stateful default
-                // object 0, so no everBound flag is needed.
-                UnorderedMap<Uint, SharedPtr<ProgramPipelineObject>> m_programPipelines;
-                IndexGenerator<Uint> m_programPipelineNames;
-                Uint m_boundProgramPipeline = 0;
                 TextureState m_textureState;
                 ProgramState m_programState;
                 RenderState m_renderState;
                 FramebufferState m_framebufferState;
                 SamplerState m_samplerState;
                 RenderbufferState m_renderbufferState;
-
-                mutable SharedPtr<const MG_Util::ShaderTranspiler::CompileEnv> m_compileEnv;
-                // Identity of the backend object m_compileEnv was captured against; a plain
-                // pointer compare, never dereferenced.
-                const void* m_compileEnvBackend = nullptr;
             };
         } // namespace GLState
 

MobileGL/MG_State/GLState/FramebufferState/FramebufferObject.cpp

@@ -185,20 +185,6 @@ namespace MobileGL::MG_State::GLState {
         return m_externalIndex;
     }
 
-#define MOBILEGL_DEFINE_FRAMEBUFFER_DEFAULT_SETTER(name, member, type)                                                \
-    void FramebufferObject::Set##name(type value) {                                                                    \
-        if (member == value) return;                                                                                    \
-        member = value;                                                                                                 \
-        ++m_objectVersion;                                                                                              \
-    }
-
-    MOBILEGL_DEFINE_FRAMEBUFFER_DEFAULT_SETTER(DefaultWidth, m_defaultWidth, Int)
-    MOBILEGL_DEFINE_FRAMEBUFFER_DEFAULT_SETTER(DefaultHeight, m_defaultHeight, Int)
-    MOBILEGL_DEFINE_FRAMEBUFFER_DEFAULT_SETTER(DefaultLayers, m_defaultLayers, Int)
-    MOBILEGL_DEFINE_FRAMEBUFFER_DEFAULT_SETTER(DefaultSamples, m_defaultSamples, Int)
-    MOBILEGL_DEFINE_FRAMEBUFFER_DEFAULT_SETTER(DefaultFixedSampleLocations, m_defaultFixedSampleLocations, Bool)
-#undef MOBILEGL_DEFINE_FRAMEBUFFER_DEFAULT_SETTER
-
     void FramebufferObject::BumpAttachmentVersion(FramebufferAttachmentType type) {
         ++m_attachmentVersions[static_cast<SizeT>(type)];
         ++m_objectVersion;

MobileGL/MG_State/GLState/FramebufferState/FramebufferObject.h

@@ -129,19 +129,6 @@ namespace MobileGL {
             void SetReadBuffer(FramebufferAttachmentType buf);
             FramebufferAttachmentType GetReadBuffer() const { return m_readBuffer; }
 
-            // GL_ARB_framebuffer_no_attachments state (GL 4.6 core table 23.24). The shape a
-            // framebuffer with no attachments would rasterize at; all zero / FALSE until set.
-            Int GetDefaultWidth() const { return m_defaultWidth; }
-            Int GetDefaultHeight() const { return m_defaultHeight; }
-            Int GetDefaultLayers() const { return m_defaultLayers; }
-            Int GetDefaultSamples() const { return m_defaultSamples; }
-            Bool GetDefaultFixedSampleLocations() const { return m_defaultFixedSampleLocations; }
-            void SetDefaultWidth(Int value);
-            void SetDefaultHeight(Int value);
-            void SetDefaultLayers(Int value);
-            void SetDefaultSamples(Int value);
-            void SetDefaultFixedSampleLocations(Bool value);
-
             FramebufferAttachmentVersionArray GetAllFramebufferAttachmentVersions() const {
                 return m_attachmentVersions;
             }
@@ -161,12 +148,6 @@ namespace MobileGL {
             FramebufferAttachmentArray m_drawBuffers; // Probably no versioning needed for this, just check equality
             FramebufferAttachmentType m_readBuffer = FramebufferAttachmentType::None;
 
-            Int m_defaultWidth = 0;
-            Int m_defaultHeight = 0;
-            Int m_defaultLayers = 0;
-            Int m_defaultSamples = 0;
-            Bool m_defaultFixedSampleLocations = false;
-
             // This version will bump when draw/read buffer changes (by `glDrawBuffer(s)`/`glReadBuffer`)
             Uint16 m_objectVersion = 0;
         };