[Perf, Test] (MG_Util): libfork execution engine for the shader compile pool, runtime-selectable

Adds libfork v3.8.0 (3rdparty submodule, header-only, wired like the asio
precedent) as a second execution engine behind ShaderCompilePool, selected
per process by MOBILEGL_ASYNC_POOL=asio|libfork (default asio; unknown
values warn and fall back). The engine boundary is deliberately tiny: the
queue, the concurrency budget and its clamping, the suspension latch,
cancel request-vs-outcome, the stopped-is-synchronous fallback and the
drain all stay in the shared Impl - an engine only answers how a
budget-cleared job reaches a worker.

The libfork engine runs detached root tasks as CHAINS: a finished body
takes the next queued job in the same coroutine on the same worker, so
the refills a worker posts are absorbed without a scheduler round trip
(the naive dispatch-thread shape measured 4x worse than asio on short
jobs). Absorption is bounded at one job per live chain - unbounded
absorption serialized bursts posted from inside the pool, which is the
shipped shape (one compile settling fans out link jobs via SubmitAfter
and the adoption map), caught by the review and pinned by a permanent
peak-concurrency regression test (pre-fix: libfork peak 1 vs asio peak 4
on a 16-job worker-posted burst). External submissions go through a
round-robin adaptor instead of lf::lazy_pool::schedule, which both
avoids a data race on lazy_pool's unsynchronized xoshiro under
concurrent submits and beats birthday-collision placement by ~1.3x at
budget == thread count.

The measured answer to "does asio scale poorly": no - the executor was
never the bottleneck. On real pack corpora extracted from the trace
fixtures (BSL 61 shaders, Complementary 277), interleaved best-of-5 per
cell, the engines are within noise of each other at every thread count
(complementary: 4965/2506/1376/824 ms at 1/2/4/8 threads for asio;
libfork within 1%), both ~6x at 8 threads. perf counters show the
flattening past 4 threads is machine-level (instructions flat at 22.1e9
from 1 to 16 threads - no added work, no lock spinning - while cycles
and LLC misses double: memory-stall bound), and the separating control
- N fully independent single-threaded processes with no shared
scheduler at all - scales WORSE than the pool (5.27x vs 5.94x at 8).
The pool microbenchmark does favor libfork on pure dispatch (518 vs
530 ns/job at 1 worker, growing with worker count), but a real compile
body is 1-100 ms, so dispatch is under 0.1% either way. asio therefore
stays the default; this branch exists to make the comparison
reproducible (MG_Test/Util/AsyncPoolBench drives either engine over a
corpus directory) and to keep the alternative viable.

613/613 unit tests in all four combos ({asio, libfork} x {async default
on, kill switch}), integration scenarios byte-identical between engines
on both backends.

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

@@ -1,10 +1,6 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=trace-fixture-lib.sh
-. "${script_dir}/trace-fixture-lib.sh"
-
 if [ "$#" -lt 1 ] || [ "$#" -gt 2 ]; then
   echo "usage: $0 <trace-case> [fixture-dir]" >&2
   exit 2
@@ -66,6 +62,57 @@ if [ "${case_name}" = "OpenRA" ]; then
   exit 0
 fi
 
+get_lfs_metadata() {
+  local file="$1"
+  local pointer
+  local expected_oid
+  local expected_size
+
+  if ! pointer="$(git show "HEAD:${file}" 2>/dev/null)"; then
+    echo "failed to read tracked fixture metadata: ${file}" >&2
+    return 1
+  fi
+  if ! grep -q '^version https://git-lfs.github.com/spec/v1$' <<< "${pointer}"; then
+    echo "tracked fixture is not a Git LFS pointer: ${file}" >&2
+    return 1
+  fi
+
+  expected_oid="$(awk '$1 == "oid" && $2 ~ /^sha256:/ { sub(/^sha256:/, "", $2); print $2 }' <<< "${pointer}")"
+  expected_size="$(awk '$1 == "size" { print $2 }' <<< "${pointer}")"
+  if ! [[ "${expected_oid}" =~ ^[0-9a-f]{64}$ ]] || ! [[ "${expected_size}" =~ ^[0-9]+$ ]]; then
+    echo "invalid Git LFS pointer metadata: ${file}" >&2
+    return 1
+  fi
+
+  printf '%s %s\n' "${expected_oid}" "${expected_size}"
+}
+
+verify_fixture_file() {
+  local downloaded_file="$1"
+  local display_name="$2"
+  local expected_oid="$3"
+  local expected_size="$4"
+  local actual_oid
+  local actual_size
+
+  if [ ! -f "${downloaded_file}" ]; then
+    echo "fixture file is missing: ${display_name}" >&2
+    return 1
+  fi
+
+  actual_size="$(wc -c < "${downloaded_file}" | tr -d '[:space:]')"
+  if [ "${actual_size}" != "${expected_size}" ]; then
+    echo "fixture size mismatch for ${display_name}: expected ${expected_size}, got ${actual_size}" >&2
+    return 1
+  fi
+
+  actual_oid="$(sha256sum "${downloaded_file}" | awk '{ print $1 }')"
+  if [ "${actual_oid}" != "${expected_oid}" ]; then
+    echo "fixture SHA-256 mismatch for ${display_name}: expected ${expected_oid}, got ${actual_oid}" >&2
+    return 1
+  fi
+}
+
 fetch_file_from_mirror() {
   local file="$1"
   local url="$2"

.github/scripts/trace-fixture-cache.sh

@@ -1,117 +0,0 @@
-#!/usr/bin/env bash
-# Cache-side helper for trace fixtures.
-#
-#   key <case> [fixture-dir]     derive the actions/cache key and path list
-#   verify <case> [fixture-dir]  check restored fixtures against their pointers
-#   reset <case> [fixture-dir]   drop restored fixtures, leaving the pointers
-#
-# The cache key is content-addressed on the Git LFS pointer oids tracked at
-# HEAD, which are readable from a plain checkout without smudging. Fixture
-# content therefore maps 1:1 onto a key: unchanged content hits, changed
-# content is a new key and thus a miss, and the download path handles it. The
-# key deliberately carries no restore-keys prefix in the workflow - a fixture
-# that does not match the pointer exactly must never be restored.
-set -euo pipefail
-
-script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=trace-fixture-lib.sh
-. "${script_dir}/trace-fixture-lib.sh"
-
-# Bump when the key derivation changes in a way that must invalidate old
-# entries; the content digest alone would not notice a format change.
-key_schema="v1"
-
-if [ "$#" -lt 2 ] || [ "$#" -gt 3 ]; then
-  echo "usage: $0 <key|verify|reset> <trace-case> [fixture-dir]" >&2
-  exit 2
-fi
-
-command_name="$1"
-case_name="$2"
-fixture_dir="${3:-tools/trace_replay/fixtures}"
-python_bin="${PYTHON:-python3}"
-
-if ! command -v "${python_bin}" >/dev/null 2>&1 && command -v python >/dev/null 2>&1; then
-  python_bin=python
-fi
-
-mapfile -t files < <(trace_fixture_files "${case_name}" "${fixture_dir}" "${python_bin}")
-if [ "${#files[@]}" -eq 0 ]; then
-  echo "no fixture files declared for trace case: ${case_name}" >&2
-  exit 1
-fi
-
-# Writes "name=value" to $GITHUB_OUTPUT when running under Actions, and to
-# stdout otherwise so the script stays runnable (and testable) off-CI.
-emit_output() {
-  local name="$1"
-  local value="$2"
-  if [ -n "${GITHUB_OUTPUT:-}" ]; then
-    if [[ "${value}" == *$'\n'* ]]; then
-      local delimiter="ghadelim_$(date +%s%N)_$$"
-      {
-        printf '%s<<%s\n' "${name}" "${delimiter}"
-        printf '%s\n' "${value}"
-        printf '%s\n' "${delimiter}"
-      } >> "${GITHUB_OUTPUT}"
-    else
-      printf '%s=%s\n' "${name}" "${value}" >> "${GITHUB_OUTPUT}"
-    fi
-  fi
-  printf '%s=%s\n' "${name}" "${value}"
-}
-
-sanitize_case() {
-  printf '%s' "$1" | sed 's/[^A-Za-z0-9._-]/_/g'
-}
-
-case "${command_name}" in
-  key)
-    manifest=""
-    for file in "${files[@]}"; do
-      # A case whose fixtures are committed directly rather than through Git LFS
-      # (OpenRA) has no pointer oid to key on, and nothing to download either.
-      # Report it as uncacheable so the workflow skips the cache entirely.
-      if ! metadata="$(get_lfs_metadata "${file}" 2>/dev/null)"; then
-        echo "trace case ${case_name} is not stored in Git LFS; skipping fixture cache" >&2
-        emit_output "cacheable" "false"
-        emit_output "key" ""
-        exit 0
-      fi
-      read -r expected_oid expected_size <<< "${metadata}"
-      manifest+="$(basename "${file}") ${expected_oid} ${expected_size}"$'\n'
-    done
-
-    digest="$(printf '%s' "${manifest}" | sha256sum | awk '{ print substr($1, 1, 16) }')"
-    safe_case="$(sanitize_case "${case_name}")"
-
-    emit_output "cacheable" "true"
-    emit_output "key" "trace-fixture-${key_schema}-${safe_case}-${digest}"
-    emit_output "paths" "$(printf '%s\n' "${files[@]}")"
-    ;;
-
-  verify)
-    for file in "${files[@]}"; do
-      metadata="$(get_lfs_metadata "${file}")"
-      read -r expected_oid expected_size <<< "${metadata}"
-      verify_fixture_file "${file}" "${file}" "${expected_oid}" "${expected_size}"
-    done
-    echo "Verified ${#files[@]} fixture file(s) for ${case_name} against the tracked Git LFS pointers."
-    ;;
-
-  reset)
-    # Put the working tree back to the pointer files a fresh checkout would
-    # have, so that a rejected cache entry falls through to exactly the same
-    # download path a cache miss takes.
-    for file in "${files[@]}"; do
-      rm -f "${file}" "${file}.tmp"
-    done
-    git checkout -- "${files[@]}"
-    echo "Reset ${#files[@]} fixture file(s) for ${case_name} to their tracked Git LFS pointers."
-    ;;
-
-  *)
-    echo "unknown command: ${command_name}" >&2
-    exit 2
-    ;;
-esac

.github/scripts/trace-fixture-lib.sh

@@ -1,73 +0,0 @@
-#!/usr/bin/env bash
-# Shared helpers for trace-fixture handling: reading the in-tree Git LFS pointer
-# metadata and verifying a fixture file against it. Sourced by
-# fetch-trace-fixture-lfs.sh (verify after download) and by
-# trace-fixture-cache.sh (cache key derivation and verify after cache restore),
-# so both paths agree on what a valid fixture is.
-
-# Reads the Git LFS pointer tracked at HEAD for a fixture path and prints
-# "<oid> <size>". Fails if the tracked blob is not a well-formed LFS pointer.
-get_lfs_metadata() {
-  local file="$1"
-  local pointer
-  local expected_oid
-  local expected_size
-
-  if ! pointer="$(git show "HEAD:${file}" 2>/dev/null)"; then
-    echo "failed to read tracked fixture metadata: ${file}" >&2
-    return 1
-  fi
-  if ! grep -q '^version https://git-lfs.github.com/spec/v1$' <<< "${pointer}"; then
-    echo "tracked fixture is not a Git LFS pointer: ${file}" >&2
-    return 1
-  fi
-
-  expected_oid="$(awk '$1 == "oid" && $2 ~ /^sha256:/ { sub(/^sha256:/, "", $2); print $2 }' <<< "${pointer}")"
-  expected_size="$(awk '$1 == "size" { print $2 }' <<< "${pointer}")"
-  if ! [[ "${expected_oid}" =~ ^[0-9a-f]{64}$ ]] || ! [[ "${expected_size}" =~ ^[0-9]+$ ]]; then
-    echo "invalid Git LFS pointer metadata: ${file}" >&2
-    return 1
-  fi
-
-  printf '%s %s\n' "${expected_oid}" "${expected_size}"
-}
-
-# Checks an on-disk fixture against the size and SHA-256 from its LFS pointer.
-verify_fixture_file() {
-  local downloaded_file="$1"
-  local display_name="$2"
-  local expected_oid="$3"
-  local expected_size="$4"
-  local actual_oid
-  local actual_size
-
-  if [ ! -f "${downloaded_file}" ]; then
-    echo "fixture file is missing: ${display_name}" >&2
-    return 1
-  fi
-
-  actual_size="$(wc -c < "${downloaded_file}" | tr -d '[:space:]')"
-  if [ "${actual_size}" != "${expected_size}" ]; then
-    echo "fixture size mismatch for ${display_name}: expected ${expected_size}, got ${actual_size}" >&2
-    return 1
-  fi
-
-  actual_oid="$(sha256sum "${downloaded_file}" | awk '{ print $1 }')"
-  if [ "${actual_oid}" != "${expected_oid}" ]; then
-    echo "fixture SHA-256 mismatch for ${display_name}: expected ${expected_oid}, got ${actual_oid}" >&2
-    return 1
-  fi
-}
-
-# Prints the fixture file paths of a trace case, one per line. Strips CR so the
-# result is usable when python emits CRLF (Git Bash on Windows).
-trace_fixture_files() {
-  local case_name="$1"
-  local fixture_dir="$2"
-  local python_bin="${3:-python3}"
-
-  "${python_bin}" tools/trace_replay/trace_cases.py \
-    --format fixture-files \
-    --case "${case_name}" \
-    --fixture-root "${fixture_dir}" | tr -d '\r'
-}

.github/scripts/validate-plugin-apks.sh

@@ -44,12 +44,12 @@ require 'key:MOBILEGL_BACKEND_TYPE' "$plugin_resource_text" 'V2 backend variable
 require 'defaultValue:DirectGLES' "$plugin_resource_text" 'V2 DirectGLES default'
 require 'DirectVulkan' "$plugin_resource_text" 'V2 DirectVulkan option'
 require 'key:MOBILEGL_DISABLE_TIMERQUERY' "$plugin_resource_text" 'V2 timer-query toggle'
-require 'key:MOBILEGL_MAGMA_DISABLE_SUBGROUP' "$plugin_resource_text" 'V2 Vulkan subgroup toggle'
+require 'key:MOBILEGL_DISABLE_SUBGROUP' "$plugin_resource_text" 'V2 Vulkan subgroup toggle'
 require 'key:MOBILEGL_MAGMA_R11G11B10F_FALLBACK' "$plugin_resource_text" 'V2 Magma format fallback toggle'
 require 'key:MOBILEGL_MAGMA_FRAMESINFLIGHT' "$plugin_resource_text" 'V2 Magma frames-in-flight setting'
-require 'key:MOBILEGL_ESPRYT_AVOID_SAMPLER_MIPMAP_MIN_FILTER' "$plugin_resource_text" 'V2 sampler workaround toggle'
+require 'key:MOBILEGL_AVOID_SAMPLER_MIPMAP_MIN_FILTER' "$plugin_resource_text" 'V2 sampler workaround toggle'
 require 'key:MOBILEGL_COHERENT_AS_FLUSH' "$plugin_resource_text" 'V2 coherent-as-flush toggle'
-require 'key:MOBILEGL_ESPRYT_USE_ANGLE' "$plugin_resource_text" 'V2 ANGLE toggle'
+require 'key:MOBILEGL_USE_ANGLE' "$plugin_resource_text" 'V2 ANGLE toggle'
 
 if [[ $(grep -Fc 'fclPlugin_V2' <<<"$plugin_manifest") -ne 1 ]]; then
   echo '::error::Plugin manifest must expose exactly one V2 descriptor' >&2

.github/workflows/apk.yml

@@ -6,18 +6,11 @@ on:
       - dev
       - Feat/Backend-Direct-GLES
       - Feat/Backend-Direct-Vulkan
-      # TEMPORARY, remove before merging the MGPipe work into dev: the disaggregation
-      # branch runs the full lane on every push so a phase's landing is not gated on
-      # someone remembering to dispatch the workflow by hand.
-      - feat/disaggregated
   workflow_dispatch:
 
 jobs:
   build:
     runs-on: ubuntu-latest
-    permissions:
-      actions: write
-      contents: read
     env:
       CCACHE_BASEDIR: ${{ github.workspace }}
       CCACHE_COMPRESS: "true"
@@ -48,11 +41,12 @@ jobs:
           gradle-version: 8.10.2
 
       - name: Restore ccache
-        uses: actions/cache/restore@v5
+        uses: actions/cache@v5
         with:
           path: .ccache
-          key: ${{ runner.os }}-apk-${{ github.job }}-ccache-v1
+          key: ${{ runner.os }}-apk-${{ github.job }}-ccache-${{ github.ref_name }}-${{ github.run_id }}
           restore-keys: |
+            ${{ runner.os }}-apk-${{ github.job }}-ccache-${{ github.ref_name }}-
             ${{ runner.os }}-apk-${{ github.job }}-ccache-
 
       - name: Install ccache
@@ -131,28 +125,6 @@ jobs:
         if: always()
         run: ccache --show-stats
 
-      # Rewrite one rolling entry per job on the default branch. The upload stays
-      # cumulative - it carries every object restored at the top of this run plus
-      # the few TUs that actually changed - but Actions cache keys are immutable,
-      # so the superseded blob has to be released before the same key can be
-      # re-uploaded. Running after the build means a failed build leaves the
-      # existing entry untouched. The other trigger branches restore this entry
-      # rather than each writing a ~4 GB one of their own.
-      - name: Release superseded ccache entry
-        if: github.ref_name == github.event.repository.default_branch
-        env:
-          GH_TOKEN: ${{ github.token }}
-          CACHE_KEY: ${{ runner.os }}-apk-${{ github.job }}-ccache-v1
-        run: gh cache delete "${CACHE_KEY}" || true
-
-      - name: Save ccache
-        if: github.ref_name == github.event.repository.default_branch
-        continue-on-error: true
-        uses: actions/cache/save@v5
-        with:
-          path: .ccache
-          key: ${{ runner.os }}-apk-${{ github.job }}-ccache-v1
-
       - name: Verify APK metadata and packaging
         run: |
           AAPT2="$(find "$ANDROID_HOME/build-tools" -name aapt2 -type f | sort -V | tail -n 1)"
@@ -213,7 +185,7 @@ jobs:
       - name: Load trace cases
         id: trace-cases
         run: |
-          echo "android=$(python3 tools/trace_replay/trace_cases.py --ci --format github-apk-matrix)" >> "$GITHUB_OUTPUT"
+          echo "android=$(python3 tools/trace_replay/trace_cases.py --ci --format github-apk)" >> "$GITHUB_OUTPUT"
           echo "names=$(python3 tools/trace_replay/trace_cases.py --ci --format names)" >> "$GITHUB_OUTPUT"
 
   trace-fixtures:
@@ -229,41 +201,9 @@ jobs:
       - name: Checkout repo
         uses: actions/checkout@v6
 
-      - name: Derive trace fixture cache key
-        id: fixture-key
-        run: bash .github/scripts/trace-fixture-cache.sh key '${{ matrix.case }}'
-
-      - name: Restore trace fixture cache
-        id: fixture-cache
-        if: steps.fixture-key.outputs.cacheable == 'true'
-        uses: actions/cache/restore@v5
-        with:
-          path: ${{ steps.fixture-key.outputs.paths }}
-          key: ${{ steps.fixture-key.outputs.key }}
-
-      - name: Verify restored trace fixture
-        id: fixture-verify
-        if: steps.fixture-cache.outputs.cache-hit == 'true'
-        run: |
-          if bash .github/scripts/trace-fixture-cache.sh verify '${{ matrix.case }}'; then
-            echo "ok=true" >> "$GITHUB_OUTPUT"
-          else
-            echo "ok=false" >> "$GITHUB_OUTPUT"
-            echo "::warning::Cached fixture for ${{ matrix.case }} failed verification; falling back to the download path"
-            bash .github/scripts/trace-fixture-cache.sh reset '${{ matrix.case }}'
-          fi
-
       - name: Fetch trace fixture
-        if: steps.fixture-verify.outputs.ok != 'true'
         run: bash .github/scripts/fetch-trace-fixture-lfs.sh '${{ matrix.case }}'
 
-      - name: Save trace fixture cache
-        if: steps.fixture-key.outputs.cacheable == 'true' && steps.fixture-cache.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v5
-        with:
-          path: ${{ steps.fixture-key.outputs.paths }}
-          key: ${{ steps.fixture-key.outputs.key }}
-
       - name: Stage trace fixture
         run: |
           safe_case="$(printf '%s' '${{ matrix.case }}' | sed 's/[^A-Za-z0-9._-]/_/g')"
@@ -341,7 +281,13 @@ jobs:
     strategy:
       fail-fast: false
       max-parallel: 4
-      matrix: ${{ fromJSON(needs.trace-cases.outputs.android) }}
+      matrix:
+        backend:
+          - name: DirectGLES
+            gpu: software
+          - name: DirectVulkan
+            gpu: lavapipe
+        case: ${{ fromJSON(needs.trace-cases.outputs.android) }}
     steps:
       - name: Set Swap Space
         uses: pierotofy/set-swap-space@v1.0
@@ -421,12 +367,9 @@ jobs:
 
       - name: Retrace and validate
         env:
-          MOBILEGL_ESPRYT_USE_ANGLE: ${{ matrix.backend.name == 'DirectGLES' && '1' || '0' }}
+          MOBILEGL_USE_ANGLE: ${{ matrix.backend.name == 'DirectGLES' && '1' || '0' }}
           MOBILEGL_TRACE_ANGLE_VARIANT: ${{ matrix.case.name == 'minecraft-1.21.4-fabric-iris-bliss-in-world' && '90a62123d794' || 'ec889e6ea831' }}
           MOBILEGL_MAGMA_R11G11B10F_FALLBACK: ${{ matrix.backend.name == 'DirectVulkan' && '1' || '0' }}
-          MOBILEGL_MAGMA_FIX_ITERATIONRP_SUBGROUP_SCRATCH: ${{ matrix.backend.name == 'DirectVulkan' && matrix.case.name == 'minecraft-1.21.4-fabric-iris-iterationrp-in-world' && '1' || '0' }}
-          MOBILEGL_MAGMA_DERIVE_NUM_SUBGROUPS: ${{ matrix.backend.name == 'DirectVulkan' && matrix.case.name == 'minecraft-1.21.4-fabric-iris-iterationrp-in-world' && '1' || '0' }}
-          MOBILEGL_MAGMA_ITERATIONRP_FIX_BARRIER: ${{ matrix.backend.name == 'DirectVulkan' && matrix.case.name == 'minecraft-1.21.4-fabric-iris-iterationrp-in-world' && '1' || '0' }}
         run: |
           apk_file="android-retrace-apks/MobileGL-plugin-trace-release-${GITHUB_SHA}.apk"
           test -f "${apk_file}"
@@ -436,9 +379,6 @@ jobs:
           if [ "${{ matrix.backend.name }}" = "DirectGLES" ] && [ "${{ matrix.case.name }}" = "minecraft-1.21.4-fabric-iris-bliss-in-world" ]; then
             extra_retrace_args+=(--avoid-angle-llvmpipe-sampler-mipmap-min-filter)
           fi
-          if [ "${{ matrix.backend.name }}" = "DirectGLES" ] && [ "${{ matrix.case.avoid_angle_llvmpipe_explicit_lod_bias || false }}" = "true" ]; then
-            extra_retrace_args+=(--avoid-angle-llvmpipe-explicit-lod-bias)
-          fi
           if [ "${{ matrix.case.coherent_as_flush || false }}" = "true" ]; then
             extra_retrace_args+=(--coherent-as-flush)
           fi
@@ -471,24 +411,6 @@ jobs:
           run_retrace || retrace_status=$?
           if [ "${retrace_status}" -eq 75 ]; then
             echo "::warning::Android emulator infrastructure failed; restarting it and retrying this retrace once."
-            # Surface-lost is retried rather than failed, so it would otherwise
-            # be invisible. Report it per job - a healthy run prints nothing and
-            # a rate spike shows up as a row per affected case.
-            reason_file="android-retrace-result/infrastructure-failure-reason.txt"
-            surface_lost_retries=0
-            if [ -f "${reason_file}" ]; then
-              surface_lost_retries="$(grep -c 'angle-surface-lost' "${reason_file}" || true)"
-            fi
-            if [ "${surface_lost_retries}" -gt 0 ]; then
-              echo "surface-lost retries: ${surface_lost_retries} (${{ matrix.backend.name }}, ${{ matrix.case.name }})" \
-                >> "${GITHUB_STEP_SUMMARY}"
-            fi
-            # The restart truncates EMULATOR_LOG, and the attempt that lost the
-            # emulator is the one worth reading - the retry usually only shows
-            # the wreckage. Keep the first attempt's log before it is clobbered.
-            if [ -f "${EMULATOR_LOG}" ]; then
-              cp "${EMULATOR_LOG}" "${EMULATOR_LOG}.first-attempt" || true
-            fi
             sh android-plugin/run-avd-ci.sh stop \
               --avd-name "${AVD_NAME}" \
               --emulator-log "${EMULATOR_LOG}" \
@@ -528,13 +450,6 @@ jobs:
           if [ -f "${EMULATOR_LOG}" ]; then
             cp "${EMULATOR_LOG}" android-retrace-result/diagnostics/emulator.log
           fi
-          if [ -f "${EMULATOR_LOG}.first-attempt" ]; then
-            cp "${EMULATOR_LOG}.first-attempt" android-retrace-result/diagnostics/emulator-first-attempt.log
-          fi
-          # A vanished emulator looks identical whether the host OOM killer took
-          # qemu or the renderer faulted. These two say which.
-          free -h > android-retrace-result/diagnostics/host-memory.txt 2>&1 || true
-          sudo dmesg -T 2>/dev/null | tail -300 > android-retrace-result/diagnostics/host-dmesg.txt || true
 
       - name: Stop Emulator
         if: always()
@@ -616,41 +531,22 @@ jobs:
           )
 
           if ((${#failed_cases[@]})); then
-            echo "Retaining fixtures and results for failed retrace case(s):"
+            echo "Retaining fixtures for failed retrace case(s):"
             printf '  %s\n' "${!failed_cases[@]}"
           else
-            echo "All retrace jobs succeeded; nothing needs to be retained."
+            echo "All retrace jobs succeeded; no fixtures need to be retained."
           fi
 
           deleted=0
           retained=0
           while IFS=$'\t' read -r artifact_id artifact_name; do
-            keep=0
             if [[ "${artifact_name}" == MobileGL-trace-fixture-* ]]; then
               case_name="${artifact_name#MobileGL-trace-fixture-}"
               if [[ -v "failed_cases[${case_name}]" ]]; then
-                keep=1
+                echo "Retaining ${artifact_name} (${artifact_id}) for failed retrace."
+                ((retained += 1))
+                continue
               fi
-            elif [[ "${artifact_name}" == MobileGL-android-retrace-result-* ]]; then
-              # The result artifact carries mobilegl.log, retrace.log, logcat,
-              # the emulator log and the actual/diff images - the only record of
-              # why a retrace failed. Its name ends in -<backend>-<case>, so a
-              # suffix match on the case name keeps both backends' results for a
-              # case that failed on either of them, which is what a comparison
-              # needs. The match is anchored at the end, so a case name that is a
-              # prefix of a longer one does not retain the longer one's results.
-              for case_name in "${!failed_cases[@]}"; do
-                if [[ "${artifact_name}" == *-"${case_name}" ]]; then
-                  keep=1
-                  break
-                fi
-              done
-            fi
-
-            if ((keep)); then
-              echo "Retaining ${artifact_name} (${artifact_id}) for failed retrace."
-              ((retained += 1))
-              continue
             fi
 
             echo "Deleting ${artifact_name} (${artifact_id})"

.gitignore

@@ -27,4 +27,3 @@ MobileGL/MG*/cmake-build*
 tools/trace_replay/work/
 __pycache__/
 *.py[cod]
-/.gradle

.gitmodules

@@ -7,6 +7,9 @@
 [submodule "3rdparty/SPIRV-Cross"]
 	path = 3rdparty/SPIRV-Cross
 	url = https://github.com/KhronosGroup/SPIRV-Cross.git
+[submodule "include/FastSTL"]
+	path = include/FastSTL
+	url = https://github.com/MobileGL-Dev/FastSTL.git
 [submodule "3rdparty/tracy"]
 	path = 3rdparty/tracy
 	url = https://github.com/wolfpld/tracy.git
@@ -31,9 +34,6 @@
 [submodule "3rdparty/asio"]
 	path = 3rdparty/asio
 	url = https://github.com/chriskohlhoff/asio.git
-[submodule "include/ska"]
-	path = include/ska
-	url = https://github.com/MobileGL-Dev/flat_hash_map.git
-[submodule "3rdparty/flatbuffers"]
-	path = 3rdparty/flatbuffers
-	url = https://github.com/google/flatbuffers.git
+[submodule "3rdparty/libfork"]
+	path = 3rdparty/libfork
+	url = https://github.com/ConorWilliams/libfork.git

CMakeLists.txt

@@ -14,100 +14,12 @@ option(MOBILEGL_ENABLE_TRACY      "Enable tracy for profiling"
 option(MOBILEGL_BUILD_TRACE_REPLAY "Build desktop apitrace replay runner"            OFF)
 option(MOBILEGL_TRACE_ANGLE_VARIANTS "Enable signed trace-APK ANGLE variant loading" OFF)
 option(MOBILEGL_IOS               "Build MobileGL for iOS instead of macOS when APPLE is set" OFF)
-# The disaggregated (two-process) shape. OFF is the shipping default and OFF
-# must stay byte-comparable to a tree without MG_Remote at all: nothing under
-# MobileGL/MG_Remote/ is compiled, no include path is added, and no library is
-# linked, so `nm --defined-only libMobileGL.so | grep -i MG_Remote` is empty.
-# That emptiness is one of the two byte-level equalities the plan's validation
-# gates keep (section 10.3).
-option(MOBILEGL_BUILD_DISAGGREGATED "Build the MG_Remote transport layer (two-process shape)" OFF)
-option(MOBILEGL_BUILD_SERVER_SPIKE "Build the P0 spike-A MobileGLServer delivery-chain executable (Android only)" OFF)
-# The PipeInputs strangler (ARCHITECTURE.md 9.2). OFF is the pull build and must stay
-# byte-identical to a tree without either option: MGB_CTX is the live GLContext, no
-# MGPipe/PipeInputs source is compiled, every MGP_FILL is ((void)0).
-option(MOBILEGL_PIPE_PUSH "Backends read frontend state through the MGPipe PipeInputs block instead of MG_State::pGLContext (ARCHITECTURE.md 9.2 phase A)" OFF)
-option(MOBILEGL_PIPE_VERIFY "Compile SnapshotFromGLContext() and the G4 per-verb shadow comparator; implies MOBILEGL_PIPE_PUSH; never shipped" OFF)
 set(MOBILEGL_LOG_ACTIVE_LEVEL "MOBILEGL_LOG_LEVEL_INFO" CACHE STRING "MobileGL active log level macro")
 set(MOBILEGL_VULKAN_LIBRARY "" CACHE FILEPATH "Vulkan loader/MoltenVK library to link for iOS builds")
 
 if (ANDROID)
     set(MOBILEGL_BUILD_TEST       OFF CACHE BOOL "Build MobileGL tests"      FORCE)
     set(MOBILEGL_BUILD_BENCHMARK  OFF CACHE BOOL "Build MobileGL benchmarks" FORCE)
-
-    # ------- Android API level policy: minimum 26, decided here and only here -------
-    # MobileGL ships against API 26: the codebase must not use any API introduced
-    # after 26. That usage constraint is enforced where it is real - the shipping
-    # gradle build compiles at minSdk 26, where a newer API is simply undeclared
-    # and fails to compile. Configuring at a HIGHER level is therefore allowed
-    # (nothing in the tree may rely on it), but a LOWER level would change the
-    # libc contract underneath the shipped library and is refused.
-    #
-    # This has to live at configure time because the level cannot be corrected
-    # from a source header. A `#define __ANDROID_API__ 26` in a common header
-    # only rewrites the macro for the bionic headers that happen to be included
-    # after it; any libc++ header pulled in earlier has already latched its
-    # feature macros at the real configure-time level. libc++ and bionic then
-    # disagree about which symbols exist - libc++ calls e.g.
-    # pthread_cond_clockwait while bionic, re-read at the lowered level, has
-    # hidden its declaration. MobileGL/Defines.h carried exactly that pin from
-    # the first commit until it was removed; this guard is what replaces it.
-    #
-    # Read the level back from the compiler target triple first. Its trailing
-    # number (aarch64-none-linux-android26) is precisely what clang turns into
-    # __ANDROID_API__, so it cannot disagree with the compile itself, and it is
-    # already past every NDK normalisation step - codename aliases, "latest",
-    # and per-ABI minimum pull-ups. ANDROID_PLATFORM_LEVEL is the fallback for
-    # generators/languages where the triple variable is not populated.
-    #
-    # Note CMAKE_SYSTEM_VERSION is deliberately NOT consulted: it holds the API
-    # level only under the NDK's newer toolchain path, and is a meaningless 1
-    # when ANDROID_USE_LEGACY_TOOLCHAIN_FILE is on (which is what AGP has been
-    # defaulting to). Reading it would fail every legacy-mode build.
-    set(MOBILEGL_ANDROID_API_LEVEL 26)
-
-    set(_mobilegl_android_api "")
-    foreach (_mobilegl_api_triple "${CMAKE_CXX_COMPILER_TARGET}"
-                                  "${CMAKE_C_COMPILER_TARGET}")
-        if (NOT _mobilegl_android_api AND
-            _mobilegl_api_triple MATCHES "-android([0-9]+)$")
-            set(_mobilegl_android_api "${CMAKE_MATCH_1}")
-        endif()
-    endforeach()
-
-    foreach (_mobilegl_api_var ANDROID_PLATFORM_LEVEL ANDROID_NATIVE_API_LEVEL
-                               ANDROID_PLATFORM)
-        if (NOT _mobilegl_android_api AND ${_mobilegl_api_var})
-            string(REGEX REPLACE "^android-" ""
-                   _mobilegl_android_api "${${_mobilegl_api_var}}")
-        endif()
-    endforeach()
-
-    if (NOT _mobilegl_android_api MATCHES "^[0-9]+$")
-        message(FATAL_ERROR
-            "MobileGL: could not determine the Android API level (got "
-            "\"${_mobilegl_android_api}\"). Configure with the NDK toolchain "
-            "file and -DANDROID_PLATFORM=android-${MOBILEGL_ANDROID_API_LEVEL}.")
-    elseif (_mobilegl_android_api LESS MOBILEGL_ANDROID_API_LEVEL)
-        message(FATAL_ERROR
-            "MobileGL requires at least Android API ${MOBILEGL_ANDROID_API_LEVEL}, "
-            "but this build resolved to API ${_mobilegl_android_api}.\n"
-            "Configure with -DANDROID_PLATFORM=android-${MOBILEGL_ANDROID_API_LEVEL} "
-            "(gradle builds get this from minSdk ${MOBILEGL_ANDROID_API_LEVEL}, so "
-            "check that minSdk instead of adding an override).")
-    elseif (_mobilegl_android_api GREATER MOBILEGL_ANDROID_API_LEVEL)
-        message(STATUS
-            "MobileGL: configuring at Android API ${_mobilegl_android_api} "
-            "(> shipping minimum ${MOBILEGL_ANDROID_API_LEVEL}). Allowed, but the "
-            "tree must not use post-${MOBILEGL_ANDROID_API_LEVEL} APIs - the "
-            "minSdk-${MOBILEGL_ANDROID_API_LEVEL} gradle build is the enforcing "
-            "compile.")
-    endif()
-
-    message(STATUS "MobileGL: Android API level ${_mobilegl_android_api}")
-
-    unset(_mobilegl_android_api)
-    unset(_mobilegl_api_var)
-    unset(_mobilegl_api_triple)
 endif()
 
 option(MOBILEGL_ENABLE_LTO "Build with ThinLTO/IPO" OFF)
@@ -195,7 +107,6 @@ set(ENABLE_SPVREMAPPER         OFF CACHE BOOL "Enable SPVRemapper" FORCE)
 set(ENABLE_OPT                 ON  CACHE BOOL "Enable SPIRV-Tools opt usage in glslang" FORCE)
 set(BUILD_EXTERNAL             ON  CACHE BOOL "Build external deps in External/" FORCE)
 set(ENABLE_GLSLANG_INSTALL     OFF CACHE BOOL "Install glslang targets" FORCE)
-set(SPIRV_SKIP_EXECUTABLES     ON  CACHE BOOL "Skip building SPIRV-Tools executables" FORCE)
 
 set(SPIRV_CROSS_C_API          ON  CACHE BOOL "Enable C API" FORCE)
 set(SPIRV_CROSS_ENABLE_GLSL    ON  CACHE BOOL "Enable GLSL backend" FORCE)
@@ -251,8 +162,6 @@ set(SOURCE_FILES
 
     MobileGL/MG_Util/Metrics/BufferMetrics.cpp
 
-    MobileGL/MG_Util/Metrics/PipeStats.cpp
-
     MobileGL/MG_Util/Converters/GLToStr/GLEnumConverter.cpp
     MobileGL/MG_Util/Converters/EGLToStr/EGLEnumConverter.cpp
     MobileGL/MG_Util/Converters/MGToStr/DataTypeConverter.cpp
@@ -285,7 +194,6 @@ set(SOURCE_FILES
     MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpvcSession.cpp
     MobileGL/MG_Util/ShaderTranspiler/ShaderSourceProcessor.cpp
-    MobileGL/MG_Util/ShaderTranspiler/TranslationCache.cpp
     MobileGL/MG_Util/ShaderTranspiler/glslang/TMglGlslIoResolver.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FlattenInterfaceStructPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EliminateFloatEqualsZeroPass.cpp
@@ -293,44 +201,18 @@ set(SOURCE_FILES
     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/DemoteFloat64Pass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FlattenFloat64StorageBlockPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerDrawParametersPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerViewportIndexPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/PackDoubleVertexInputsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FlattenXfbInterfaceBlocksPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/UniquifyIoBlockNamesPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripIoBlockLocationsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/SplitArrayVertexInputsPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RebaseInstanceIndexPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/ZeroBaseVertexPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DeriveNumSubgroupsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FixIterationRPBarrierPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FixIterationRPSubgroupScratchPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EmulateSubgroupsPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/NormalizeRectCoordinatesPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/Lower1DArrayImagesPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/Lower1DSampledImagesPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/BakeImageFormatsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/WidenImageFormatsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/ClampMultisampleFetchPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/PrivateToEntryLocalPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripUniformLocationsPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripUboMemberRelaxedPrecisionPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripNoPerspectivePass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EmulateNoPerspectivePass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LegalizeFragmentOutputIndexPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LegalizeResourceArrayIndexPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FlattenAtomicCounterBlockPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemotePointSizePass.cpp
 
     MobileGL/MG_Util/BackendLoaders/OpenGL/Loader.cpp
     MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.cpp
 
-    MobileGL/MG_Util/SelfTest/DriverBugProbes.cpp
     MobileGL/MG_Util/SelfTest/DriverPost.cpp
-    MobileGL/MG_Util/SelfTest/DriverPostIterationRPWitness.cpp
-    MobileGL/MG_Util/SelfTest/PrimitivesGeneratedNoXfbProbe.cpp
 
     MobileGL/MG_Util/Texture/PixelStoreProcessor.cpp
     MobileGL/MG_Util/Texture/TextureFormatProcessor.cpp
@@ -353,7 +235,6 @@ set(SOURCE_FILES
     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/Debug/GL_Debug.cpp
     MobileGL/MG_Impl/GLImpl/Texture/Validators.cpp
     MobileGL/MG_Impl/GLImpl/Texture/ProxyTexture.cpp
     MobileGL/MG_Impl/GLImpl/VertexArray/GL_VertexArray.cpp
@@ -411,13 +292,10 @@ set(SOURCE_FILES
     MobileGL/MG_State/GLState/TextureState/TextureObject2DCube.cpp
     MobileGL/MG_State/GLState/TextureState/TextureObject3D.cpp
     MobileGL/MG_State/GLState/TextureState/TextureObjectBuffer.cpp
-    MobileGL/MG_State/GLState/TextureState/TextureObjectView.cpp
     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/ProgramTranslationCache.cpp
-    MobileGL/MG_State/GLState/ProgramState/ProgramSpirvTask.cpp
     MobileGL/MG_State/GLState/ProgramState/ShaderCompileTask.cpp
     MobileGL/MG_State/GLState/ProgramState/ShaderObject.cpp
     MobileGL/MG_State/GLState/ProgramState/ShaderPreprocessCache.cpp
@@ -432,65 +310,6 @@ set(SOURCE_FILES
     MobileGL/MG_State/GLState/RenderbufferState/RenderbufferState.cpp
 )
 
-# ---------------------------------------------------------------------------
-# MG_Remote (disaggregated transport). Everything below is gated: with the
-# option OFF not one file here is compiled and no include path is added.
-# ---------------------------------------------------------------------------
-
-# FlatBuffers is a submodule and its runtime is header-only. Guard both ways:
-# a checkout without the submodule must configure and build, just without the
-# disaggregated shape, rather than fail with a missing-header error a hundred
-# lines later. Note this only checks for the RUNTIME headers - flatc is never
-# built here (see scripts/gen_protocol.py).
-if (MOBILEGL_BUILD_DISAGGREGATED AND
-    NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/flatbuffers/include/flatbuffers/flatbuffers.h")
-    message(WARNING
-        "MOBILEGL_BUILD_DISAGGREGATED=ON but 3rdparty/flatbuffers/include is missing. "
-        "Run `git submodule update --init 3rdparty/flatbuffers`. Building without the "
-        "disaggregated shape for this configure; the cached ON takes effect once the "
-        "submodule is present.")
-    # A NORMAL variable, deliberately not `CACHE BOOL ... FORCE`: forcing OFF into the cache
-    # made the plain re-configure after `git submodule update` stay OFF with no message at
-    # all. Shadowing the cache entry for this configure only keeps the operator's ON where it
-    # was, so the next configure - with the submodule there - honours it.
-    set(MOBILEGL_BUILD_DISAGGREGATED OFF)
-endif()
-
-# MOBILEGL_PIPE_VERIFY implies MOBILEGL_PIPE_PUSH: the comparator compares the pushed block
-# against a snapshot, so there has to be a pushed block. A normal variable, not a forced
-# cache write, for the same reason as the disaggregated fallback above.
-if (MOBILEGL_PIPE_VERIFY AND NOT MOBILEGL_PIPE_PUSH)
-    message(STATUS "MobileGL: MOBILEGL_PIPE_VERIFY=ON forces MOBILEGL_PIPE_PUSH ON for this configure")
-    set(MOBILEGL_PIPE_PUSH ON)
-endif()
-
-if (MOBILEGL_PIPE_PUSH)
-    message(STATUS "MobileGL: PipeInputs push ON, appending the MGPipe fill sources")
-    list(APPEND SOURCE_FILES
-        MobileGL/MG_Backend/MGPipe/PipeInputs.cpp
-        MobileGL/MG_Impl/Pipe/PipeFill.cpp
-    )
-endif()
-
-if (MOBILEGL_BUILD_DISAGGREGATED)
-    message(STATUS "MobileGL: disaggregated transport ON, appending MG_Remote sources")
-    list(APPEND SOURCE_FILES
-        MobileGL/MG_Remote/Transport/Ring.cpp
-        MobileGL/MG_Remote/Transport/Doorbell.cpp
-        MobileGL/MG_Remote/Transport/ShmSegment.cpp
-        # Both platform halves are listed unconditionally and each is empty on
-        # the other OS, so neither can rot behind an `if (WIN32)` nobody
-        # configures.
-        MobileGL/MG_Remote/Transport/ShmSegmentPosix.cpp
-        MobileGL/MG_Remote/Transport/ShmSegmentWin32.cpp
-        MobileGL/MG_Remote/Transport/FdPassing.cpp
-        MobileGL/MG_Remote/Transport/InProcessTransport.cpp
-        # Keeps MG_Util/Debug/Log.h - and through it the GL frontend's
-        # umbrella header - out of the header-only wire code (WireLog.h).
-        MobileGL/MG_Remote/Transport/WireLog.cpp
-    )
-endif()
-
 if (APPLE AND NOT MOBILEGL_IOS)
     list(APPEND SOURCE_FILES
         MobileGL/MG_Impl/CGLImpl/CGLImpl.cpp
@@ -541,26 +360,11 @@ set(MOBILEGL_COMPILE_DEF
         -DASIO_NO_DEPRECATED
 )
 
-if (MOBILEGL_BUILD_DISAGGREGATED)
-    list(APPEND MOBILEGL_COMPILE_DEF -DMOBILEGL_BUILD_DISAGGREGATED=1)
-endif()
-
-if (MOBILEGL_PIPE_PUSH)
-    list(APPEND MOBILEGL_COMPILE_DEF -DMOBILEGL_PIPE_PUSH=1)
-endif()
-if (MOBILEGL_PIPE_VERIFY)
-    list(APPEND MOBILEGL_COMPILE_DEF -DMOBILEGL_PIPE_VERIFY=1)
-endif()
-
 message(STATUS "MOBILEGL_COMPILE_DEF=${MOBILEGL_COMPILE_DEF}")
 
 set(MOBILEGL_INCLUDE_DIR
         ${CMAKE_SOURCE_DIR}/include
         ${CMAKE_SOURCE_DIR}/MobileGL
-        # The MGPipe boundary headers. They are reachable as <MG_Pipe/MGPipe.h> through the
-        # line above too; this entry lets the client, the backends and MG_Remote spell them
-        # as <MGPipe.h> once MG_Pipe stops being a leaf of the frontend tree.
-        ${CMAKE_SOURCE_DIR}/MobileGL/MG_Pipe
         ${spirv-tools_SOURCE_DIR}
         ${spirv-tools_SOURCE_DIR}/include
         ${spirv-tools_BINARY_DIR}
@@ -568,16 +372,16 @@ set(MOBILEGL_INCLUDE_DIR
         # 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/include
+        ${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
 )
 
-if (MOBILEGL_BUILD_DISAGGREGATED)
-    # Header-only runtime: an include path, no add_subdirectory, no link
-    # target, and above all no flatc in the build graph. protocol_generated.h
-    # is committed and regenerated by scripts/gen_protocol.py.
-    list(APPEND MOBILEGL_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/3rdparty/flatbuffers/include)
-endif()
-
 add_library(${CMAKE_PROJECT_NAME} SHARED
     ${SOURCE_FILES}
 )
@@ -787,50 +591,3 @@ if (NOT ANDROID)
         add_subdirectory(tools/trace_replay)
     endif()
 endif()
-
-# The integration binary is also useful as a standalone adb-shell executable.
-# Android cannot use the desktop-only MobileGL_s target, so its CMake module
-# links libMobileGL.so and creates an AImageReader-backed window instead.
-if (ANDROID AND MOBILEGL_BUILD_INTEGRATION_TEST)
-    add_subdirectory(MobileGL/MG_IntegrationTest)
-endif()
-
-# ---------------------------------------------------------------------------
-# P0 spike A: the Android delivery chain for a second native executable.
-#
-# The disaggregated design needs a server process on Android (PLAN-B.md §8.1,
-# inheriting PLAN.md §11.1-§11.6). An APK's only exec-able install location is
-# lib/<abi>/, and the packager only puts a file there if it is named lib*.so -
-# so a second executable has to be built with an .so name and exec'd out of
-# getApplicationInfo().nativeLibraryDir. This target is the stub that proves the
-# chain end to end: it is packaged like a library, exec'd from the app's own
-# untrusted_app process, and writes a marker the parent reads back.
-#
-# Off by default and ANDROID-only, so no shipping configuration builds it. The
-# trace flavour of the plugin APK turns it on (android-plugin/build.gradle).
-# ---------------------------------------------------------------------------
-if (ANDROID AND MOBILEGL_BUILD_SERVER_SPIKE)
-    add_executable(MobileGLServer
-        ${CMAKE_CURRENT_SOURCE_DIR}/tools/spikes/server_stub/main.cpp)
-
-    # An executable that is named like a shared library still has to be a real
-    # PIE executable: Android has refused non-PIE executables since API 21, and
-    # the name alone does not change what the loader demands of the file.
-    set_target_properties(MobileGLServer PROPERTIES
-        PREFIX "lib"
-        SUFFIX ".so"
-        OUTPUT_NAME "MobileGLServer"
-        POSITION_INDEPENDENT_CODE ON)
-    target_compile_options(MobileGLServer PRIVATE -fPIE)
-    target_link_options(MobileGLServer PRIVATE -pie)
-
-    # AGP packages what the external native build drops into the per-ABI output
-    # directory, and it selects by the .so extension. CMake puts executables in
-    # CMAKE_RUNTIME_OUTPUT_DIRECTORY, which is not the directory AGP hands to
-    # CMAKE_LIBRARY_OUTPUT_DIRECTORY, so point this target's runtime output at
-    # the library directory when the generator gave us one.
-    if (CMAKE_LIBRARY_OUTPUT_DIRECTORY)
-        set_target_properties(MobileGLServer PROPERTIES
-            RUNTIME_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
-    endif()
-endif()

MobileGL/Config.h

@@ -66,105 +66,30 @@ 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;
-        // MOBILEGL_ESPRYT_ENABLE_TEXTURE_VIEW: advertise GL_ARB_texture_view on DirectGLES when
-        // the host ES driver has EXT/OES_texture_view. Off by default: the host extension is
-        // present on Adreno 830 and the functional half of KHR-GL4{2,3}.texture_view still fails
-        // there, because the view's ES internalformat is normalized independently of the storage
-        // it aliases (see BackendObject_DirectGLES::BuildAdvertisedExtensions). The flag exists
-        // so that work can be done without editing the gate.
-        Bool EsprytEnableTextureView = false;
-        // MOBILEGL_ENABLE_SPIRV_VALIDATION: validate generated and transformed SPIR-V.
-        // Disabled by default because validation is a diagnostics-only cost.
-        Bool EnableSpirvValidation = false;
-        // MOBILEGL_ESPRYT_USE_ANGLE: load ANGLE EGL/GLES libraries.
-        Bool EsprytUseAngle = false;
+        // MOBILEGL_USE_ANGLE: load ANGLE EGL/GLES libraries.
+        Bool UseAngle = false;
 #if defined(MOBILEGL_TRACE_ANGLE_VARIANTS)
         // MOBILEGL_TRACE_ANGLE_VARIANT: signed trace-APK ANGLE build short hash.
         String TraceAngleVariant;
 #endif
-        // MOBILEGL_MAGMA_DISABLE_SUBGROUP: force-disable Vulkan shader subgroup support,
-        // including the opt-in emulated compute path below.
-        Bool MagmaDisableSubgroup = false;
-        // MOBILEGL_MAGMA_EMULATE_SUBGROUP: implement GL_KHR_shader_subgroup's compute
-        // stage on a 32-lane VIRTUAL subgroup lowered to workgroup-shared memory
-        // (ShaderTranspiler::EmulateSubgroupsPass). Strictly a last resort: it only ever
-        // engages when this flag is set AND the device has no native subgroup support at
-        // all - a device with real subgroup operations always uses them natively,
-        // whatever their width (the known iterationRP defect is patched by
-        // MagmaFixIterationRPSubgroupScratch below instead). Off by default.
-        Bool MagmaEmulateSubgroup = false;
-        // MOBILEGL_MAGMA_FIX_ITERATIONRP_SUBGROUP_SCRATCH: patch iterationRP's own bug - the
-        // pack declares `shared vec2 prefixSumCache[32]` for a 512-invocation exposure
-        // reduction and indexes it by gl_SubgroupID, so any device with sub-16-lane
-        // subgroups (8-lane lavapipe -> 64 subgroups) writes shared memory out of
-        // bounds. The pass grows that one array to what the device's topology needs and
-        // touches nothing else; it only rewrites modules positively matching the pack's
-        // reduction fingerprint (ShaderTranspiler::FixIterationRPSubgroupScratchPass),
-        // so every other shader passes through byte-identical - as does iterationRP
-        // itself on >= 16-lane devices. Auto is ON; ForceOff replays the pack's bug
-        // verbatim.
-        QuirkOverride MagmaFixIterationRPSubgroupScratch = QuirkOverride::Auto;
-        // MOBILEGL_MAGMA_ITERATIONRP_FIX_BARRIER: repair Program 203's missing workgroup
-        // rendezvous between its two reductions over prefixSumCache. Off by default and
-        // fingerprint-gated by FixIterationRPBarrierPass when enabled.
-        Bool MagmaIterationRPFixBarrier = false;
-        // MOBILEGL_MAGMA_DERIVE_NUM_SUBGROUPS: replace compute gl_NumSubgroups loads with
-        // ceil(workgroup invocations / gl_SubgroupSize) on the NATIVE subgroup path
-        // (ShaderTranspiler::DeriveNumSubgroupsPass). Auto is ON: GL requires
-        // gl_SubgroupID < gl_NumSubgroups, Adreno's builtin reports 1 while the same
-        // dispatch emits IDs 0..7, and the derived value is the one Vulkan guarantees
-        // whenever the pipeline can request REQUIRE_FULL_SUBGROUPS (which the renderer
-        // does whenever local_size_x is a multiple of the native width). ForceOff returns
-        // to the raw driver builtin.
-        QuirkOverride MagmaDeriveNumSubgroups = QuirkOverride::Auto;
-        // MOBILEGL_ADVERTISE_FP64: add GL_ARB_gpu_shader_fp64 to the advertised extension
-        // string. `double` in a shader always WORKS - it is narrowed to 32 bits before any
-        // module reaches a backend (ShaderTranspiler::DemoteFloat64Pass) - but the extension
-        // promises 64-bit precision, and that is the one thing the narrowing cannot deliver.
-        // Off by default so an application that checks the string before using doubles keeps
-        // its float path; on for measuring what the conformance suite makes of the demoted
-        // precision. See the DemoteFloat64Pass header and the "fp64" POST row.
-        Bool AdvertiseFp64 = false;
+        // MOBILEGL_DISABLE_SUBGROUP: force-disable Vulkan shader subgroup support.
+        Bool DisableSubgroup = false;
         // MOBILEGL_MAGMA_R11G11B10F_FALLBACK: use fallback format for R11G11B10F on Vulkan.
         Bool MagmaR11G11B10FFallback = false;
         // MOBILEGL_MAGMA_FRAMESINFLIGHT: requested Magma frames in flight, defaulting to 3.
         Uint32 MagmaFramesInFlight = 3;
-        // MOBILEGL_ESPRYT_AVOID_SAMPLER_MIPMAP_MIN_FILTER: avoid mipmap min filters in samplers,
+        // MOBILEGL_AVOID_SAMPLER_MIPMAP_MIN_FILTER: avoid mipmap min filters in samplers,
         // resolves certain rendering bugs on ANGLE + llvmpipe.
-        Bool EsprytAvoidSamplerMipmapMinFilter = false;
-        // MOBILEGL_ESPRYT_AVOID_EXPLICIT_LOD_BIAS: leave an already-explicit LOD argument alone when
-        // emulating GL_TEXTURE_LOD_BIAS, instead of adding the bias uniform to it. Injecting
-        // the uniform turns a compile-time-constant LOD into a runtime expression, which
-        // sends ANGLE + llvmpipe down a mip-selection path that dereferences a NULL
-        // descriptor and kills the process. Deviates from spec (Vulkan adds the bias to
-        // OpImageSampleExplicitLod), so it is an avoidance for that stack only.
-        Bool EsprytAvoidExplicitLodBias = false;
-        // MOBILEGL_ESPRYT_UNLOCATED_IO_BLOCKS: emit a tessellation/geometry program's
-        // inter-stage interface blocks WITHOUT their layout(location=) qualifier, letting ES
-        // match them by block name and member sequence instead. The Mali ES driver delivers
-        // nothing at all through a located block once a tessellation or geometry stage is in
-        // the pipeline; the driver POST measures that and turns this on by itself, so Auto is
-        // the right setting everywhere. ForceOn exists so the emulation can be exercised on a
-        // healthy driver - which is what the integration lane does, since llvmpipe and
-        // lavapipe carry a located block correctly and would otherwise never run this code -
-        // and ForceOff is the negative control. See StripIoBlockLocationsPass.
-        QuirkOverride EsprytUnlocatedIoBlocks = QuirkOverride::Auto;
-        // MOBILEGL_POINT_SIZE_DEMOTION: demote gl_PointSize out of tessellation/geometry
-        // stages into an ordinary varying (ShaderCompiler::
-        // DemoteTessellationGeometryPointSizeForProgram) instead of declining such programs
-        // on a device that advertises neither EXT/OES_tessellation_point_size /
-        // geometry_point_size (DirectGLES) nor shaderTessellationAndGeometryPointSize
-        // (DirectVulkan). Auto arms it exactly where the detection says the capability is
-        // absent, which is the right setting everywhere. ForceOn exists so the demotion can
-        // be exercised on a healthy driver - llvmpipe and lavapipe host the built-in
-        // natively and would otherwise never run this code, which is what the pinned
-        // integration lane uses - and ForceOff restores the plain declines (escape hatch /
-        // negative control). Cross-backend by design: the demotion runs in the shared
-        // phase-B chain, so one switch covers both. See DemotePointSizePass.
-        QuirkOverride PointSizeDemotion = QuirkOverride::Auto;
+        Bool AvoidSamplerMipmapMinFilter = false;
         // MOBILEGL_COHERENT_AS_FLUSH: app-compat for engines (e.g. Flywheel) that write
         // GPU-read data through persistent GL_MAP_FLUSH_EXPLICIT_BIT maps they never
         // flush. Persistent FLUSH_EXPLICIT map requests are rewritten to coherent
@@ -174,51 +99,20 @@ namespace MobileGL::MG_Config {
         Bool CoherentAsFlush = false;
         // MOBILEGL_TRACE_SKIP_AUTODESTROY: skip teardown in the ELF destructor (Init.cpp).
         Bool TraceSkipAutodestroy = false;
-        // MOBILEGL_ESPRYT_DISABLE_UBO_RING: force the DirectGLES global-UBO upload back to the
+        // MOBILEGL_DISABLE_UBO_RING: force the DirectGLES global-UBO upload back to the
         // per-draw glBufferSubData path instead of the persistent-mapped ring allocator
         // (negative control / driver-bug escape hatch).
-        Bool EsprytDisableUboRing = false;
-        // MOBILEGL_ESPRYT_DISABLE_UNPACK_RING: force DirectGLES texture uploads back to
-        // glTexSubImage from the client pointer instead of staging them through the
-        // persistent-mapped unpack-PBO ring (negative control / driver-bug escape
-        // hatch).
-        Bool EsprytDisableUnpackRing = false;
-        // MOBILEGL_ESPRYT_DISABLE_UPLOAD_RING: force DirectGLES app buffer updates
-        // (glBufferSubData / map flushes) back to the immediate driver upload instead
-        // of queueing them for the staged-copy flush through the persistent-mapped
-        // upload ring (negative control / driver-bug escape hatch; the immediate
-        // upload stalls on drivers that resolve the WAR hazard on the CPU, e.g. Mali).
-        Bool EsprytDisableUploadRing = false;
-        // MOBILEGL_ESPRYT_DISABLE_INVALIDATE_FLUSH: skip the glMapBufferRange(WRITE |
-        // INVALIDATE_RANGE) tier of the DirectGLES pending-range flush and go straight
-        // to the upload ring's staged glCopyBufferSubData (negative control / escape
-        // hatch for a driver whose range-invalidating map misbehaves). The map tier is
-        // what keeps a partial write into a large in-flight buffer priced by the RANGE:
-        // on Mali both the immediate glBufferSubData and a staged copy into a busy
-        // mutable store ghost the whole destination on the CPU.
-        Bool EsprytDisableInvalidateFlush = false;
-        // MOBILEGL_DISABLE_LARGE_BUFFER_ADOPTION: keep mesh-arena-sized buffer stores
-        // (>= 16MiB) on the CPU-shadow model instead of backing them with the backend's
-        // persistently+coherently mapped storage at definition time (negative control /
-        // escape hatch). Frontend-scoped: it engages only where the active backend
-        // provides AcquirePersistentMap. With adoption on, an app SubData into a busy
-        // 128MB arena is a plain memcpy into GPU-visible memory; every driver-mediated
-        // route for the same write stalls the thread or ghost-copies the whole arena on
-        // this class of Mali driver, and the arena stops costing its size again in RAM.
-        Bool DisableLargeBufferAdoption = false;
-        // MOBILEGL_ESPRYT_FORCE_DS_READBACK_EMULATION: make DirectGLES skip the native ES
-        // depth/stencil reads and always go through the shader-sampling emulation. Core GL
-        // ES has no depth or stencil readback, but some drivers accept it anyway (Mesa does,
-        // Adreno does not), which means the emulation is dead code on exactly the stack the
-        // headless suite runs on. This forces it live so the scenarios and the CTS can
-        // exercise the path, and gives the device an A/B lever over the same choice.
-        Bool EsprytForceDepthStencilReadbackEmulation = false;
+        Bool DisableUboRing = false;
         // MOBILEGL_RELAXED_SEMANTICS: relax strict core-profile rules (e.g. VAO-0 draws,
         // texture-name reuse after delete) even on contexts that explicitly requested a core
         // profile. Without it, relaxed semantics still apply to every context that did not
         // explicitly request a core profile via EGL_CONTEXT_OPENGL_PROFILE_MASK / a >=3.1
         // version request.
         Bool RelaxedSemantics = false;
+        // MOBILEGL_QUIRK_SUBGROUP_PREFIX_SCAN: overrides the shader-source quirk that
+        // rewrites the recognized workgroup prefix-scan template on Qualcomm devices with
+        // subgroups wider than 32 lanes (see ShaderSourceProcessor's quirk registry).
+        QuirkOverride SubgroupPrefixScanQuirk = QuirkOverride::Auto;
         // MOBILEGL_MAGMA_DISABLE_BLENDED_DEPTH_WRITE: overrides the DirectVulkan quirk that
         // strips depth writes from accumulation-blended pipelines (MIN/MAX or additive
         // ONE+ONE - the multi-pass depth-equality signature) on drivers without
@@ -226,10 +120,10 @@ namespace MobileGL::MG_Config {
         // gl_FragDepth writers, and fully color-masked attachments are exempt (see
         // PipelineFactory::ShouldSuppressDepthWrite). Auto detects Qualcomm.
         QuirkOverride MagmaDisableBlendedDepthWriteQuirk = QuirkOverride::Auto;
-        // MOBILEGL_MAGMA_DISABLE_ROBUST_BUFFER_ACCESS: leave the Vulkan robustBufferAccess device
+        // MOBILEGL_DISABLE_ROBUST_BUFFER_ACCESS: leave the Vulkan robustBufferAccess device
         // feature off. It is enabled by default to match GL's defined out-of-range fetch
         // behavior; this escape hatch exists to measure or dodge its GPU cost on a device.
-        Bool MagmaDisableRobustBufferAccess = false;
+        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.
@@ -248,134 +142,6 @@ namespace MobileGL::MG_Config {
         // 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;
-        // MOBILEGL_ASYNC_OPTIMISTIC_SHADER_STATUS: while a compile job is still in flight,
-        // glGetShaderiv(GL_COMPILE_STATUS) answers GL_TRUE and the shader info log reads
-        // empty, WITHOUT joining the job (latched per compile - see
-        // ShaderObject::TakeOptimisticCompileAnswer). A deliberate, bounded spec violation:
-        // a real failure still fails the program link with the compile log quoted. It
-        // exists for applications that compile hundreds of shaders serially and read the
-        // status right after each glCompileShader - Iris's shader-pack load - where those
-        // per-shader joins are what serializes the batch on its main path (Iris's gbuffer
-        // phase issues no program-level query between programs; program-level LINK_STATUS
-        // and the program info log still join truthfully, so paths that check each link
-        // immediately stay serial by their own construction). Off by default; never
-        // advertise it.
-        QuirkOverride AsyncOptimisticShaderStatus = QuirkOverride::Auto;
-        // MOBILEGL_SHADER_CACHE: the three-level, in-memory shader translation memo
-        // (MG_Util/ShaderTranspiler/TranslationCache.h). The levels follow the GL
-        // entry points - L1c memoizes one glCompileShader's PARSE VERDICT, L1 a
-        // linked program's whole front end, L2 DirectGLES's emitted ESSL. Auto is
-        // ON; ForceOff turns ALL THREE off and makes every translation run from
-        // scratch. The escape hatch exists because a wrong cache hit is a silently
-        // miscompiled shader: if a device ever renders differently with the cache
-        // on, one run with this falsy says so.
-        QuirkOverride ShaderTranslationCache = QuirkOverride::Auto;
-        // MOBILEGL_ESPRYT_FORCE_VIEWPORT_ARRAY_EMULATION: DirectGLES' gl_ViewportIndex routing
-        // emulation - the builtin becomes a flat varying, the fragment stage gets a
-        // per-pass gate, and a routed draw is REPLAYED once per distinct viewport state
-        // with the real glViewport/glScissor/glDepthRangef set for it. Auto is ON, and
-        // it is ON even where the driver advertises GL_OES_viewport_array, because that
-        // extension only ever gave the SHADER a compilable name: MobileGL has never
-        // programmed a driver's INDEXED viewport state (SyncRenderState pushes index 0
-        // and nothing else), so on an extension-capable driver every index rasterized as
-        // index 0 exactly as it did without one. ForceOff returns to that behaviour -
-        // the pre-emulation path, extension passthrough where it exists and
-        // LowerViewportIndexPass' demote-to-a-plain-global where it does not - and is
-        // the negative control the emulation is measured against.
-        QuirkOverride EsprytViewportArrayEmulation = QuirkOverride::Auto;
-        // MOBILEGL_ESPRYT_WIDEN_PACKED16_STORAGE: DirectGLES stores GL_RGB565/GL_RGB5(A1)/GL_RGBA4
-        // images as 8-bit-per-channel ES storage (GL_RGB8/GL_RGBA8) instead of the driver's
-        // native 16-bit packed formats. Auto defers to a POST driver-bug probe
-        // (SelfTest::CopyImageMirrorsPacked16FieldOrder): some Mali drivers store SOME
-        // packed16 allocations with a MIRRORED field order (allocation-scoped and
-        // shape/context dependent - the failing 30x30x12 GL_TEXTURE_2D_ARRAYs are mirrored
-        // at every level), so glCopyImageSubData - a raw texel-block move - lands R/G/B/A
-        // reversed whenever exactly one endpoint sits in a mirrored allocation
-        // (KHR-GL4x.copy_image.functional rgb5/rgb5_a1/rgba4 x every *2d_array* pair).
-        // With no 16-bit packed ES image left there is no field order to disagree about; the
-        // client word still round-trips exactly, because the canonical shadow is already
-        // UNorm8 and an n-bit field encodes to UNorm8 and back losslessly for n <= 8.
-        // ForceOn widens on any driver (the llvmpipe suites use it to exercise the widened
-        // path); ForceOff keeps the native narrow storage even where the probe fires - the
-        // negative control that replays the corruption. Costs 2x the memory of the affected
-        // formats where it engages, which is why Auto is probe-gated rather than always-on.
-        QuirkOverride EsprytWidenPacked16Storage = QuirkOverride::Auto;
-        // MOBILEGL_MAGMA_PRIMGEN_QUERY_REROUTE: DirectVulkan's GL_PRIMITIVES_GENERATED
-        // reroute for draws made while transform feedback is INACTIVE. The stream query
-        // (VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT primitivesNeeded) is defined to count
-        // them, but a Mali driver - and Mesa lavapipe - answers 0 unless a capture span is
-        // open, which is exactly the shape the CTS uses to measure the tessellator, so ~29
-        // tessellation tests per tree size a capture buffer from the 0 and die on the
-        // zero-length map. Auto defers to a device probe at renderer bring-up
-        // (SelfTest::RunPrimitivesGeneratedNoXfbProbe), which measures two substitutes on
-        // the same capture-less draws and arms the best proven one: the dedicated
-        // VK_EXT_primitives_generated_query (exact semantics by definition; lavapipe passes
-        // it, rasterizer discard included), else a clipping-invocations pipeline-statistics
-        // pool (see the verdict vocabulary for its rasterizer-discard split). ForceOn pins
-        // the reroute structurally wherever a pool can exist (the arming-observable lane,
-        // immune to the probe's verdict moving), and ForceOff is the negative control that
-        // replays the driver's silence.
-        QuirkOverride MagmaPrimGenQueryReroute = QuirkOverride::Auto;
-        // --- MGPipe (the disaggregation plan's explicit frontend/backend boundary) ---
-        // MOBILEGL_PIPE_PUSH: per-subsystem bitmask selecting which state the frontend
-        // PUSHES over MGPipe instead of leaving the backend to pull it out of GLContext.
-        // 0 - the default and the only shipped value until the migration lands - is "pull
-        // everything", i.e. exactly today's behaviour. One bit of it also turns OFF
-        // client-side content addressing of CSOs, which is the negative control the CSO
-        // design is measured against. Accepts decimal or 0x-prefixed hex.
-        Uint64 PipePush = 0;
-        // MOBILEGL_PIPE_VERIFY: per-draw, per-FIELD shadow comparison of the pushed state
-        // against a snapshot taken from GLContext the old way, printing the first field
-        // that differs and the draw serial. Roughly 5-10x slower and never shipped; it is
-        // the semantic gate that replaces byte identity, and it catches the dangerous
-        // direction - a dirty bit that fires too RARELY - which no purity gate can see.
-        Bool PipeVerify = false;
-#if MOBILEGL_PIPE_PUSH
-        // The three knobs of the MOBILEGL_PIPE_VERIFY build (P1 brief D2). Compiled only
-        // under MOBILEGL_PIPE_PUSH so the pull build's FeaturesTable does not change size.
-        // MOBILEGL_PIPE_VERIFY_FATAL: the first divergence aborts (default). 0 logs and
-        // counts instead, for triage and for the lane that must survive to read its own
-        // log. Tri-state parse like PipeLegacyMemos: only an explicit falsy value turns it
-        // off.
-        Bool PipeVerifyFatal = true;
-        // MOBILEGL_PIPE_VERIFY_CORRUPT: a field name from kMGPipeInputFieldNames[]; the
-        // comparator perturbs that field in the SNAPSHOT arm before the entry compare, so a
-        // green verify run goes red naming it (negative control A). Unknown name is
-        // Fatal{PipeVerifyBadKnob}.
-        String PipeVerifyCorrupt;
-        // MOBILEGL_PIPE_POISON_OMIT: <Verb>:<FieldName>; the filler skips the STAMP (not
-        // the value) of that field for that verb, an omission indistinguishable from a
-        // forgotten FillPoints.def row, so that verb's read of it is
-        // Fatal{UnmigratedPipeInput} (negative control B). Unknown name is
-        // Fatal{PipeVerifyBadKnob}.
-        String PipePoisonOmit;
-#endif
-        // MOBILEGL_PIPE_STATS: dump the boundary counters (bytes, calls, roundtrips,
-        // texture pulls, upload shapes, residual-block bytes, index mirror bytes).
-        Bool PipeStats = false;
-        // MOBILEGL_PIPE_LEGACY_MEMOS: keep the pre-handle registries and TwinLookupMemos
-        // alive so the first handle waves have a real old-versus-new arm to be compared
-        // against. ON by default for the whole migration window, deleted with the pull
-        // path itself.
-        Bool PipeLegacyMemos = true;
-        // MOBILEGL_PIPE_TEXEL_RETAIN_MB: LRU budget for texels retained against a
-        // server-initiated texture re-send. Default 0, i.e. OFF: MipmapStorage already
-        // holds a complete CPU shadow, so this cache buys latency, never correctness.
-        Uint32 PipeTexelRetainMb = 0;
-        // MOBILEGL_PIPE_INDEX_MIRROR_MB: budget for the server-side index host mirror,
-        // which is what lets primitive-restart rewriting and multi-draw flattening stay on
-        // the server without shipping index bytes per draw. Over budget it degrades to
-        // per-draw staging, counted separately in the stats.
-        Uint32 PipeIndexMirrorMb = 64;
-        // MOBILEGL_PIPE_STATS_PERIOD: frames per boundary-counter summary line. 120 is the
-        // steady-state cadence; the device retrace harness never reaches the teardown dump
-        // and a trimmed fixture (create-indirect) is shorter than 120 frames, so a run that
-        // needs its numbers at all sets this low enough to land at least one window.
-        Uint32 PipeStatsPeriod = 120;
-        // MOBILEGL_PIPE_STATS_FILE: where the boundary counters' teardown JSON dump goes.
-        // Empty (the default) means no dump; the per-120-frame summary line still goes to
-        // the log whenever PipeStats is on, so a device run needs no writable path.
-        String PipeStatsFile;
     };
     extern FeaturesTable Features;
 } // namespace MobileGL::MG_Config

MobileGL/ConfigLoader.cpp

@@ -159,108 +159,30 @@ namespace MobileGL::MG_ConfigLoader {
         return static_cast<Uint32>(parsedValue);
     }
 
-    // Same contract as QueryEnvUint32, over 64 bits and accepting an explicit 0x prefix: the
-    // one consumer is a subsystem BITMASK, and a bitmask written in decimal is unreadable.
-    // Decimal otherwise - never strtoull's base 0, whose "leading zero means octal" rule
-    // silently read MOBILEGL_PIPE_PUSH=010 as 8 - and a '-' anywhere is rejected rather than
-    // wrapped, which strtoull would otherwise do without complaint (-1 -> every bit set).
-    inline Uint64 QueryEnvUint64(const String& key, Uint64 defaultValue) {
-        auto it = acceptedEnvVariablesMap->find(key);
-        if (it == acceptedEnvVariablesMap->end()) {
-            return defaultValue;
-        }
-
-        const String& value = it->second;
-        const char* text = value.c_str();
-        int base = 10;
-        if (value.size() > 2 && text[0] == '0' && (text[1] == 'x' || text[1] == 'X')) {
-            text += 2;
-            base = 16;
-        }
-        char* parseEnd = nullptr;
-        errno = 0;
-        const bool negative = value.find('-') != String::npos;
-        const unsigned long long parsedValue = negative ? 0 : std::strtoull(text, &parseEnd, base);
-        if (negative || parseEnd == text || *parseEnd != '\0' || errno == ERANGE) {
-            MGLOG_W("Config: Ignoring invalid env variable %s='%s'; expected a non-negative integer "
-                    "(decimal, or 0x-prefixed hexadecimal), using default %llu",
-                    key.c_str(), value.c_str(), static_cast<unsigned long long>(defaultValue));
-            return defaultValue;
-        }
-
-        return static_cast<Uint64>(parsedValue);
-    }
-
     inline void InitFeatures() {
         auto& features = MG_Config::Features;
         features.DisableTimerQuery = QueryEnvFlag("MOBILEGL_DISABLE_TIMERQUERY");
-        features.EsprytEnableTextureView = QueryEnvFlag("MOBILEGL_ESPRYT_ENABLE_TEXTURE_VIEW");
-        features.EnableSpirvValidation = QueryEnvFlag("MOBILEGL_ENABLE_SPIRV_VALIDATION");
-        features.EsprytUseAngle = QueryEnvFlag("MOBILEGL_ESPRYT_USE_ANGLE");
+        features.UseAngle = QueryEnvFlag("MOBILEGL_USE_ANGLE");
 #if defined(MOBILEGL_TRACE_ANGLE_VARIANTS)
         QueryEnvVariable("MOBILEGL_TRACE_ANGLE_VARIANT", features.TraceAngleVariant, "");
 #endif
-        features.MagmaDisableSubgroup = QueryEnvFlag("MOBILEGL_MAGMA_DISABLE_SUBGROUP");
-        features.MagmaEmulateSubgroup = QueryEnvFlag("MOBILEGL_MAGMA_EMULATE_SUBGROUP");
-        features.MagmaFixIterationRPSubgroupScratch =
-            QueryEnvQuirkOverride("MOBILEGL_MAGMA_FIX_ITERATIONRP_SUBGROUP_SCRATCH");
-        features.MagmaIterationRPFixBarrier = QueryEnvFlag("MOBILEGL_MAGMA_ITERATIONRP_FIX_BARRIER");
-        features.MagmaDeriveNumSubgroups = QueryEnvQuirkOverride("MOBILEGL_MAGMA_DERIVE_NUM_SUBGROUPS");
-        features.AdvertiseFp64 = QueryEnvFlag("MOBILEGL_ADVERTISE_FP64");
+        features.DisableSubgroup = QueryEnvFlag("MOBILEGL_DISABLE_SUBGROUP");
         features.MagmaR11G11B10FFallback = QueryEnvFlag("MOBILEGL_MAGMA_R11G11B10F_FALLBACK");
         features.MagmaFramesInFlight = QueryEnvUint32("MOBILEGL_MAGMA_FRAMESINFLIGHT", 3, 1, 64);
-        features.EsprytAvoidSamplerMipmapMinFilter =
-            QueryEnvFlag("MOBILEGL_ESPRYT_AVOID_SAMPLER_MIPMAP_MIN_FILTER");
-        features.EsprytAvoidExplicitLodBias = QueryEnvFlag("MOBILEGL_ESPRYT_AVOID_EXPLICIT_LOD_BIAS");
-        features.EsprytUnlocatedIoBlocks = QueryEnvQuirkOverride("MOBILEGL_ESPRYT_UNLOCATED_IO_BLOCKS");
-        features.PointSizeDemotion = QueryEnvQuirkOverride("MOBILEGL_POINT_SIZE_DEMOTION");
+        features.AvoidSamplerMipmapMinFilter =
+            QueryEnvFlag("MOBILEGL_AVOID_SAMPLER_MIPMAP_MIN_FILTER");
         features.CoherentAsFlush = QueryEnvFlag("MOBILEGL_COHERENT_AS_FLUSH");
         features.TraceSkipAutodestroy = QueryEnvFlag("MOBILEGL_TRACE_SKIP_AUTODESTROY");
-        features.EsprytDisableUboRing = QueryEnvFlag("MOBILEGL_ESPRYT_DISABLE_UBO_RING");
-        features.EsprytDisableUnpackRing = QueryEnvFlag("MOBILEGL_ESPRYT_DISABLE_UNPACK_RING");
-        features.EsprytDisableUploadRing = QueryEnvFlag("MOBILEGL_ESPRYT_DISABLE_UPLOAD_RING");
-        features.EsprytDisableInvalidateFlush = QueryEnvFlag("MOBILEGL_ESPRYT_DISABLE_INVALIDATE_FLUSH");
-        features.DisableLargeBufferAdoption = QueryEnvFlag("MOBILEGL_DISABLE_LARGE_BUFFER_ADOPTION");
-        features.EsprytForceDepthStencilReadbackEmulation =
-            QueryEnvFlag("MOBILEGL_ESPRYT_FORCE_DS_READBACK_EMULATION");
+        features.DisableUboRing = QueryEnvFlag("MOBILEGL_DISABLE_UBO_RING");
         features.RelaxedSemantics = QueryEnvFlag("MOBILEGL_RELAXED_SEMANTICS");
+        features.SubgroupPrefixScanQuirk = QueryEnvQuirkOverride("MOBILEGL_QUIRK_SUBGROUP_PREFIX_SCAN");
         features.MagmaDisableBlendedDepthWriteQuirk =
             QueryEnvQuirkOverride("MOBILEGL_MAGMA_DISABLE_BLENDED_DEPTH_WRITE");
-        features.MagmaDisableRobustBufferAccess = QueryEnvFlag("MOBILEGL_MAGMA_DISABLE_ROBUST_BUFFER_ACCESS");
+        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);
-        features.AsyncOptimisticShaderStatus =
-            QueryEnvQuirkOverride("MOBILEGL_ASYNC_OPTIMISTIC_SHADER_STATUS");
-        features.ShaderTranslationCache = QueryEnvQuirkOverride("MOBILEGL_SHADER_CACHE");
-        features.EsprytViewportArrayEmulation =
-            QueryEnvQuirkOverride("MOBILEGL_ESPRYT_FORCE_VIEWPORT_ARRAY_EMULATION");
-        features.EsprytWidenPacked16Storage =
-            QueryEnvQuirkOverride("MOBILEGL_ESPRYT_WIDEN_PACKED16_STORAGE");
-        features.MagmaPrimGenQueryReroute = QueryEnvQuirkOverride("MOBILEGL_MAGMA_PRIMGEN_QUERY_REROUTE");
-        // MGPipe. Nothing here needs adding to an allow-list: InitializeAcceptedEnvVariables
-        // accepts every MOBILEGL_ / LIBGL_ prefixed variable in the environment, so a name
-        // that starts with MOBILEGL_ is visible to these queries by construction.
-        features.PipePush = QueryEnvUint64("MOBILEGL_PIPE_PUSH", 0);
-        features.PipeVerify = QueryEnvFlag("MOBILEGL_PIPE_VERIFY");
-#if MOBILEGL_PIPE_PUSH
-        // Defaults ON: read as a tri-state so only an explicitly falsy value turns it off.
-        features.PipeVerifyFatal =
-            QueryEnvQuirkOverride("MOBILEGL_PIPE_VERIFY_FATAL") != MG_Config::QuirkOverride::ForceOff;
-        QueryEnvVariable("MOBILEGL_PIPE_VERIFY_CORRUPT", features.PipeVerifyCorrupt, "");
-        QueryEnvVariable("MOBILEGL_PIPE_POISON_OMIT", features.PipePoisonOmit, "");
-#endif
-        features.PipeStats = QueryEnvFlag("MOBILEGL_PIPE_STATS");
-        // Defaults ON, so the flag has to be read as a tri-state rather than as a plain
-        // truthy check: unset must keep the memos, and only an explicitly falsy value may
-        // drop them.
-        features.PipeLegacyMemos =
-            QueryEnvQuirkOverride("MOBILEGL_PIPE_LEGACY_MEMOS") != MG_Config::QuirkOverride::ForceOff;
-        features.PipeTexelRetainMb = QueryEnvUint32("MOBILEGL_PIPE_TEXEL_RETAIN_MB", 0, 0, 4096);
-        features.PipeIndexMirrorMb = QueryEnvUint32("MOBILEGL_PIPE_INDEX_MIRROR_MB", 64, 0, 4096);
-        features.PipeStatsPeriod = QueryEnvUint32("MOBILEGL_PIPE_STATS_PERIOD", 120, 1, 1000000);
-        QueryEnvVariable("MOBILEGL_PIPE_STATS_FILE", features.PipeStatsFile, "");
     }
 
     inline void InitBackendType() {

MobileGL/Defines.h

@@ -9,20 +9,10 @@
 #pragma once
 
 // ============== Platform-specific definitions and macros ============== //
-// No __ANDROID_API__ pin here on purpose. The effective API level is owned by
-// the build system (gradle minSdk 26 -> -DANDROID_PLATFORM=android-26, enforced
-// by the configure-time guard in CMakeLists.txt), not by a macro.
-//
-// History: this used to `#define __ANDROID_API__ 26` to *raise* the level back
-// when the build configured something lower, so that pthread_getname_np (which
-// bionic guards with __INTRODUCED_IN(26)) would be declared. Once a later
-// change added an `#undef` in front of it, the same line started *lowering* the
-// level whenever the build configured higher than 26 - and that is an
-// include-order split-brain, not a compatibility knob: a TU that includes any
-// libc++ header before Includes.h latches libc++'s feature macros at the
-// configure-time level, and only the bionic headers pulled in afterwards see
-// the lowered value. The two halves then disagree (e.g. libc++ believes
-// pthread_cond_clockwait exists while bionic has since hidden its declaration).
+#ifdef __ANDROID__
+#undef __ANDROID_API__
+#define __ANDROID_API__ 26 // force Android API level to 26 for compatibility
+#endif
 
 #ifdef _WIN32
 #ifndef NOMINMAX
@@ -47,23 +37,6 @@
 #define MOBILEGL_WGL_API MOBILEGL_API
 
 // ====================== MobileGL configurations ======================= //
-// The numeric log levels live here, not only in Log.h: MOBILEGL_ASSERT below compares
-// MOBILEGL_LOG_ACTIVE_LEVEL against MOBILEGL_LOG_LEVEL_DEBUG, and in a translation unit
-// that includes Defines.h without Log.h both tokens would silently evaluate to 0 in the
-// preprocessor conditional - enabling the assert in exactly the INFO-level builds it is
-// documented to be compiled out of. Log.h redefines them identically, which is legal.
-//
-// Severity order, ascending: DEBUG < INFO < WARN < ERROR < FATAL. MOBILEGL_LOG_ACTIVE_LEVEL
-// names the lowest severity compiled in, so the production default INFO keeps I/W/E/F and
-// drops only D. Any edit here must be mirrored in Log.h.
-#ifndef MOBILEGL_LOG_LEVEL_DEBUG
-#define MOBILEGL_LOG_LEVEL_DEBUG 0
-#define MOBILEGL_LOG_LEVEL_INFO 1
-#define MOBILEGL_LOG_LEVEL_WARN 2
-#define MOBILEGL_LOG_LEVEL_ERROR 3
-#define MOBILEGL_LOG_LEVEL_FATAL 4
-#endif
-
 #ifndef MOBILEGL_LOG_ACTIVE_LEVEL
 #define MOBILEGL_LOG_ACTIVE_LEVEL MOBILEGL_LOG_LEVEL_INFO
 #endif
@@ -95,12 +68,6 @@
 #endif
 
 // =============================== Utils ================================ //
-// Asserts are live in exactly the builds where MGLOG_D is live, i.e. DEBUG builds only;
-// an INFO build (the production default) compiles them out. DEBUG is the lowest severity
-// in the ordering above, so "ACTIVE <= DEBUG" is true only for ACTIVE == DEBUG - the same
-// gate MGLOG_D uses in Log.h. That equivalence is what makes this gate survive the
-// 2026-08-13 renumbering unchanged; the contract is and stays
-// "INFO builds: asserts OFF; DEBUG builds: asserts ON".
 #if MOBILEGL_LOG_ACTIVE_LEVEL <= MOBILEGL_LOG_LEVEL_DEBUG
     #define MOBILEGL_ASSERT(condition, ...)                                                                                \
         do {                                                                                                               \

MobileGL/Includes.h

@@ -49,8 +49,8 @@
 #include <stacktrace>
 #endif
 
-// Include ska::flat_hash_map
-#include <ska/flat_hash_map.hpp>
+// Include FastSTL
+#include <FastSTL/UnorderedMap.h>
 
 // Include xxHash
 #include <xxhash.h>

MobileGL/Init.cpp

@@ -15,12 +15,8 @@
 #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_Impl/GLImpl/Query/GL_Query.h>
 #include <MG_Util/Async/ShaderCompilePool.h>
-#include <MG_Util/Metrics/PipeStats.h>
 #include <MG_Util/ShaderTranspiler/ShaderCompiler.h>
-#include <MG_State/GLState/ProgramState/ProgramTranslationCache.h>
-#include <MG_Util/ShaderTranspiler/TranslationCache.h>
 
 #include <atomic>
 #include <mutex>
@@ -43,11 +39,6 @@ namespace MobileGL {
             if (logLifecycle) {
                 MGLOG_I("MobileGL closing...");
             }
-            // Before any subsystem the counters name goes away, and before the last frame's
-            // numbers can be lost: emits the final summary line and, when
-            // MOBILEGL_PIPE_STATS_FILE is set, the JSON dump. A no-op when the counters are
-            // off, and idempotent.
-            MG_Util::PipeStats::Shutdown();
             // 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,
@@ -60,11 +51,6 @@ namespace MobileGL {
             // before a re-initialized library could pair them with the wrong
             // backend's DeleteSync).
             MG_Impl::GLImpl::DestroyAllSyncObjects();
-            // Queries die with their contexts for the same reason, and their registry
-            // is the same shape of process-global map: drain it here too, while the
-            // function table can still pair each backend handle with the backend that
-            // minted it.
-            MG_Impl::GLImpl::DestroyAllQueryObjects();
             MG_Backend::pActiveBackendObject.reset();
             MG_State::pGLContext.reset();
             MG_State::pEGLContext.reset();
@@ -80,14 +66,6 @@ namespace MobileGL {
             // 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();
-            // The two-level translation memo. Nothing in it references a glslang object -
-            // both levels hold plain bytes - so this is RSS hygiene rather than a lifetime
-            // requirement, and it is safe either side of FinalizeProcess. Stats first: an
-            // fordebug build gets one line per level saying how the run went.
-            MG_Util::ShaderTranspiler::LogShaderTranslationCacheStats();
-            MG_Util::ShaderTranspiler::ClearShaderTranslationCaches();
-            MG_State::GLState::LogProgramTranslationCacheStats();
-            MG_State::GLState::ClearProgramTranslationCache();
             MG_Backend::gBackendFunctionsTable = {};
             g_isInitialized = false;
             if (logLifecycle) {
@@ -108,10 +86,6 @@ namespace MobileGL {
         MGLOG_I("Initializing MobileGL...");
         MG_ConfigLoader::Init();
         MGLOG_I("Config loaded");
-        // Immediately after the config load and before anything can count: the MGPipe
-        // boundary counters latch their enable flag here, so every counting site in the
-        // two backends is a load of an already-settled global for the rest of the run.
-        MG_Util::PipeStats::Init();
         MG_State::Init();
         MGLOG_D("MG_State initialized");
         MG_Backend::Init();

MobileGL/MG_Backend/BackendObject.h

@@ -14,7 +14,6 @@ namespace MobileGL {
     namespace MG_State::GLState {
         class FramebufferObject;
         class ITextureObject;
-        class RenderbufferObject;
     }
 
     enum class BackendType {
@@ -25,19 +24,6 @@ namespace MobileGL {
     };
 
     namespace MG_Backend {
-        // One endpoint of a glCopyImageSubData. GL 4.6 core 18.3.2 accepts GL_RENDERBUFFER
-        // alongside the ten whole-image texture targets, and a renderbuffer name lives in a
-        // namespace of its own - so an endpoint is a sum type, not an ITextureObject. At most
-        // one of the two pointers is set; neither is set when the name named nothing, which is
-        // the INVALID_VALUE the frontend validator reports.
-        struct CopyImageEndpoint {
-            SharedPtr<MG_State::GLState::ITextureObject> Texture;
-            SharedPtr<MG_State::GLState::RenderbufferObject> Renderbuffer;
-
-            Bool IsRenderbuffer() const { return Renderbuffer != nullptr; }
-            Bool Exists() const { return Texture != nullptr || Renderbuffer != nullptr; }
-        };
-
         enum class FormatCapability : Uint64 {
             Creatable = 1ull << 0,
 
@@ -174,9 +160,9 @@ namespace MobileGL {
                                    GLsizei height, GLint border);
             void (*CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
                                       GLsizei width, GLsizei height);
-            void (*CopyImageSubData)(const CopyImageEndpoint& src,
+            void (*CopyImageSubData)(const SharedPtr<MG_State::GLState::ITextureObject>& srcTexture,
                                      GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ,
-                                     const CopyImageEndpoint& dst,
+                                     const SharedPtr<MG_State::GLState::ITextureObject>& dstTexture,
                                      GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ,
                                      GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
             void (*GenerateMipmap)(GLenum target);
@@ -192,23 +178,9 @@ namespace MobileGL {
             void (*MemoryBarrierByRegion)(GLbitfield barriers);
             void (*BindImageTexture)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer,
                                      GLenum access, GLenum format);
-            // The ONLY indexed query that is genuinely a backend one, and only for the pnames
-            // MG_Impl/GLImpl/Getter/GL_Getter.cpp does not already own. Every indexed pname that
-            // names FRONTEND state - the indexed buffer bindings, the per-unit texture/sampler
-            // bindings, the image-unit bindings, the viewport rectangles, the indexed capabilities
-            // - is answered in GL_Getter::GetIntegeri_v and never reaches this entry; the
-            // 64-bit and float/double widths are derived there from the same answer, which is why
-            // no GetInteger64i_v/GetFloati_v/GetDoublei_v table entry exists. In practice this
-            // leaves GL_MAX_COMPUTE_WORK_GROUP_COUNT / _SIZE (also asked directly by
-            // MG_Util/ShaderTranspiler/CompileEnv.cpp) plus whatever pname the frontend has no
-            // case for at all.
             void (*GetIntegeri_v)(GLenum target, GLuint index, GLint* data);
-            // There is deliberately NO GetProgramiv entry: glGetProgramiv describes the program
-            // the APPLICATION wrote - link status, the transform-feedback mode, the compute local
-            // size - all of which are frontend link artifacts on ProgramObject, and
-            // MG_Impl/GLImpl/Program/GL_Program.cpp answers every one of them from there. Asking a
-            // backend would mean asking about a DIFFERENT program (a SPIRV-Cross-generated ESSL
-            // one, or a SPIR-V module), in a namespace the application never sees.
+            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
@@ -264,14 +236,6 @@ namespace MobileGL {
             // (optional; null = frontend falls back to CPU accounting).
             BackendQueryHandle (*BeginXfbPrimitivesQuery)(Bool generated);
             void (*EndXfbPrimitivesQuery)(BackendQueryHandle query);
-            // Whether GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN should be answered from the
-            // frontend's own accounting wherever that accounting is exact - a capture with no
-            // geometry stage - instead of from the query above. Set by DirectGLES, whose result
-            // is whatever the ES driver's PRIMITIVES_WRITTEN counter says: Adreno reports twice
-            // the written count for a vertex-only capture that follows a large render pass,
-            // where the desktop-exact answer is the one the frontend already computed. Defaults
-            // to false, so a backend that never sets it keeps using its GPU result.
-            Bool PrefersCpuXfbPrimitiveAccounting = false;
             // Transform feedback capture spans, for backends whose own GL/ES driver
             // performs the capture (DirectGLES). Both optional; null means the backend
             // drives capture from its draw recording instead (DirectVulkan). End is
@@ -315,12 +279,6 @@ namespace MobileGL {
 
         struct DynamicBackendParameters {
             SizeT UniformBufferOffsetAlignment = 256;
-            // GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, which is a SEPARATE limit from the
-            // uniform one and is routinely larger: Adreno 830 reports 32 for uniform buffers and
-            // 64 for storage buffers. Answering the storage query with the uniform value let an
-            // application bind a storage range at an offset the driver cannot address, which it
-            // accepted without error and then wrote somewhere else entirely.
-            SizeT ShaderStorageBufferOffsetAlignment = 256;
             // GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT. 1.0 means the backend cannot filter anisotropically,
             // which is also why the extension is not advertised in that case.
             Float MaxTextureMaxAnisotropy = 1.0f;
@@ -360,37 +318,8 @@ namespace MobileGL {
             Int MaxVertexAttribs = 16;
             Int MaxComputeShaderStorageBlocks = 8;
             Int MaxCombinedShaderStorageBlocks = 32;
-            // Per-stage GL_MAX_*_SHADER_STORAGE_BLOCKS. Zero is a legal answer for the four
-            // non-compute, non-fragment stages and these defaults are the spec minimums, not
-            // placeholders: GL 4.6 table 23.64 and ES 3.2 table 21.44 both set the minimum for
-            // vertex, tessellation control, tessellation evaluation and geometry at 0, and only
-            // fragment (8 in GL, 4 in ES) and compute are guaranteed to have any. Every real ARM
-            // GLES driver takes that allowance - a Mali-G925 reports 0 for all four - so a
-            // backend that cannot honour a graphics-stage storage block MUST report 0 here
-            // rather than a hopeful number. Advertising a non-zero count the driver will refuse
-            // does not make the block work; it only moves the failure from an honest
-            // "unsupported" at query time to a backend link error the frontend never surfaces,
-            // after which every draw with that program silently renders nothing.
-            Int MaxVertexShaderStorageBlocks = 0;
-            Int MaxTessControlShaderStorageBlocks = 0;
-            Int MaxTessEvaluationShaderStorageBlocks = 0;
-            Int MaxGeometryShaderStorageBlocks = 0;
-            Int MaxFragmentShaderStorageBlocks = 8;
             Int MaxComputeUniformBlocks = 12;
             Int MaxComputeWorkGroupInvocations = 128;
-            // GL_MAX_COMPUTE_WORK_GROUP_COUNT / GL_MAX_COMPUTE_WORK_GROUP_SIZE, one value per
-            // axis. These six, with the invocations limit above, are the only indexed limits a
-            // backend genuinely OWNS - the device answers them (glGetIntegeri_v on DirectGLES,
-            // VkPhysicalDeviceLimits::maxComputeWorkGroupCount/Size on DirectVulkan) - and so
-            // the only ones that survive the retirement of the GetIntegeri_v table entry: they
-            // cross the MGPipe boundary inside MGPCaps, by inclusion of this struct (plan B
-            // section 4.4.1). Every other indexed pname names frontend state. RAW driver
-            // answers, like the invocations limit: GL_Getter and the compile environment floor
-            // them at the shared MIN_COMPUTE_WORK_GROUP_* minimums themselves. The defaults are
-            // the GL 4.3 core minimums (table 23.60) and describe the no-backend case, as
-            // MaxClipDistances' does.
-            Int MaxComputeWorkGroupCount[3] = {65535, 65535, 65535};
-            Int MaxComputeWorkGroupSize[3] = {1024, 1024, 64};
             Int MaxShaderStorageBufferBindings = 8;
             Int MaxTextureBufferSize = 65536;
             // GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT; 1 means the offset is unconstrained.
@@ -405,45 +334,8 @@ namespace MobileGL {
             Int MaxComputeImageUniforms = 8;
             Int MaxDrawBuffers = 8;
             Int MaxColorAttachments = 8;
-            // GL_MAX_CLIP_DISTANCES. Zero is a legal answer here, not a placeholder, and a
-            // backend that cannot host a clip distance MUST report it: advertising eight the
-            // backend will refuse does not make gl_ClipDistance work, it only moves the failure
-            // from an honest "unsupported" at query time to a backend shader-compile error the
-            // frontend never surfaces, after which every draw with that program silently renders
-            // nothing. DirectGLES fills it from GL_EXT_clip_cull_distance, DirectVulkan from the
-            // shaderClipDistance device feature. The DEFAULT stays at the GL 4.3 core minimum
-            // because it describes the no-backend case (standalone shader compiles, unit tests),
-            // where there is no device to be honest about and BuildTBuiltInResource still has to
-            // hand glslang a workable gl_MaxClipDistances.
             Int MaxClipDistances = 8;
-            // GL_MAX_CULL_DISTANCES and GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES, under exactly
-            // the contract stated for MaxClipDistances above: ZERO IS A LEGAL ANSWER and a
-            // backend that cannot host a cull distance MUST report it. The failure this prevents
-            // is worse than the clip one, because cull distance discards the whole primitive:
-            // glslang bounds gl_CullDistance[i] against maxCullDistances and expands
-            // gl_MaxCullDistances from it, SPIRV-Cross then emits
-            // `#extension GL_EXT_clip_cull_distance : require` into the ESSL, and a host driver
-            // without that extension rejects the program in an info log nobody surfaces. These
-            // used to be bare 8s inside BuildTBuiltInResource with no backend consulted at all.
-            // The DEFAULTS are the GL 4.5 core minimums for the same reason MaxClipDistances'
-            // is: they describe the no-backend case (standalone compiles, unit tests).
-            Int MaxCullDistances = 8;
-            Int MaxCombinedClipAndCullDistances = 8;
             Int MaxViewports = 16;
-            // GL_LAYER_PROVOKING_VERTEX / GL_VIEWPORT_INDEX_PROVOKING_VERTEX: which vertex of a
-            // primitive supplies gl_Layer and gl_ViewportIndex. GL 4.6 table 23.65 makes
-            // GL_UNDEFINED_VERTEX a legal answer for both, and it is the honest default - naming
-            // a convention is a statement about behaviour, so a backend that does not pin one
-            // must not claim it does. DirectGLES fills the layer one from the ES 3.2 query and
-            // the viewport one from GL_OES_viewport_array, and leaves UNDEFINED where the
-            // capability is absent: without the viewport array extension only viewport 0 is ever
-            // rasterized, so no convention selects anything. DirectVulkan keeps UNDEFINED for
-            // both - which vertex provokes is decided per pipeline by
-            // VulkanRenderer::SelectProvokingVertexMode out of VK_EXT_provoking_vertex,
-            // provokingVertexModePerPipeline and the topology, so no single convention is true
-            // of the backend.
-            GLenum LayerProvokingVertex = GL_UNDEFINED_VERTEX;
-            GLenum ViewportIndexProvokingVertex = GL_UNDEFINED_VERTEX;
             Int MaxViewportWidth = 16384;
             Int MaxViewportHeight = 16384;
             Float ViewportBoundsRangeMin = 0.0f;
@@ -491,55 +383,13 @@ namespace MobileGL {
                 const Uint32 bit = PerLayerFramebufferAttachmentBit(target);
                 return bit != 0 && (PerLayerFramebufferAttachmentTargets & bit) != 0;
             }
-            // Whether this backend can CONSUME a shader module that still declares 64-bit floats,
-            // i.e. whether `double` survives the transpile instead of being narrowed to `float`
-            // (ShaderTranspiler::DemoteFloat64Pass). Detected, never assumed:
-            //   * DirectVulkan sets it from VkPhysicalDeviceFeatures::shaderFloat64, the feature
-            //     VUID-VkShaderModuleCreateInfo-pCode-08740 requires before a module declaring
-            //     OpCapability Float64 may be created at all. lavapipe has it; Adreno and Mali
-            //     both report VK_FALSE, so no real mobile device does.
-            //   * DirectGLES can NEVER have it. GLSL ES has no 64-bit float type in any version
-            //     or extension, so SPIRV-Cross cannot emit one ("FP64 not supported in ES
-            //     profile") and the demotion there is mathematically mandatory, always.
-            // Defaults to false so a backend that never sets it - and the no-backend case, which
-            // is what standalone shader compiles and the unit tests run under - keeps the
-            // demotion, which is the behaviour that works everywhere.
-            Bool SupportsShaderFloat64 = false;
             // 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.
-            //
-            // INDEPENDENT of SupportsShaderFloat64, and it has to be: this flag decides a VkFormat
-            // from the VAO ATTRIBUTE alone, which does not know what type the shader declared, and
-            // glVertexAttribFormat(GL_DOUBLE) feeding a plain `in vec4` is both legal and common
-            // (KHR-GL43.vertex_attrib_binding.basic-input-case4/5, advanced-bindingUpdate). A
-            // backend with native fp64 that still cannot FETCH 64 bits keeps this false and relies
-            // on the per-MODULE rule in ShaderCompiler::SanitizeAndOptimizeBinary instead: a vertex
-            // module that declares a 64-bit float INPUT is demoted whole, so the two shader-side
-            // halves (PackDoubleVertexInputsPass and VertexInputStateFactory::ToVkVertexFormat)
-            // still see one consistent world.
             Bool SupportsFloat64VertexAttributes = false;
-            // Whether a TESSELLATION stage of this backend may access gl_PointSize - i.e.
-            // whether a module declaring OpCapability TessellationPointSize can reach the
-            // driver at all. DirectVulkan sets both this and the geometry twin from the one
-            // shaderTessellationAndGeometryPointSize feature; DirectGLES sets them
-            // independently from the EXT/OES_tessellation_point_size /
-            // geometry_point_size extension pairs (PointSizeTier), which really do come
-            // separately. When absent, ProgramSpirvTask demotes the built-in to an ordinary
-            // varying program-wide (ShaderCompiler::
-            // DemoteTessellationGeometryPointSizeForProgram); MOBILEGL_POINT_SIZE_DEMOTION
-            // overrides the detection in either direction at backend init.
-            //
-            // Defaults TRUE, deliberately against the house "assume absent" rule: false
-            // ARMS a rewrite, so the conservative no-backend answer (standalone compiles,
-            // unit tests) is the one that leaves modules untouched. A backend that never
-            // sets it gets standard modules and, at worst, the old honest declines.
-            Bool SupportsTessellationPointSize = true;
-            // The geometry-stage twin (OpCapability GeometryPointSize).
-            Bool SupportsGeometryPointSize = true;
             SizeT MaxShaderStorageBlockSize = 128 * 1024 * 1024;
             Uint32 SubgroupSize = 0;
             Uint32 SubgroupSupportedStages = 0;

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp

@@ -8,7 +8,6 @@
 
 #include "BackendObject_DirectGLES.h"
 #include "MG_Backend/BackendObject.h"
-#include "MG_Backend/BackendObjects.h"
 #include <MG_Backend/DirectGLES/DirectGLES.h>
 #include <MG_Backend/DirectGLES/Managers.h>
 #include <MG_Backend/DirectGLES/Utils.h>
@@ -213,10 +212,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             if (options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget) {
                 reasons.push_back("no colour-renderable three-channel format on OpenGL ES");
             }
-            // A format is either 8- or 16-bit signed normalized, so at most one of the two ever
-            // survives GetApplicablePixelFormatNormalizeOptions and the reason is not duplicated.
-            if ((options & PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget) ||
-                (options & PixelFormatNormalizeOptionBit::NoSnorm8RenderTarget)) {
+            if (options & PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget) {
                 reasons.push_back("EXT_render_snorm not supported");
             }
 
@@ -307,23 +303,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return capabilities.MaxColorTextureSamples;
         }
 
-        // The RENDERBUFFER twin, and it is a different set of pnames on purpose.
-        // GL_MAX_{COLOR,DEPTH}_TEXTURE_SAMPLES bound multisample TEXTURES; a renderbuffer is
-        // bounded by GL_MAX_SAMPLES (GL 4.6 core 9.2.4), with GL_MAX_INTEGER_SAMPLES for the
-        // integer formats. Using the texture ceilings here - which is what the renderbuffer probe
-        // did - is not merely untidy: the two texture pnames are ES 3.1 state, so on an ES 3.0
-        // context the loader's rejected-probe clamp leaves them at 1 (see the multisample clamps
-        // in the GLES loader) and the walk below would never run past one sample, recording {1}
-        // for EVERY colour format while GL_MAX_SAMPLES - ES 3.0 core, so genuinely answered -
-        // reports 4. Once the frontend validates against this list, that would reject every
-        // multisample renderbuffer on such a context.
-        Int GetGLESRenderbufferFormatMaxSamples(const MG_External::GLESCapabilities& capabilities,
-                                                GLenum imageFormat) {
-            const Bool isInteger = imageFormat == GL_RED_INTEGER || imageFormat == GL_RG_INTEGER ||
-                                   imageFormat == GL_RGB_INTEGER || imageFormat == GL_RGBA_INTEGER;
-            return isInteger ? capabilities.MaxIntegerSamples : capabilities.MaxSamples;
-        }
-
         Bool ProbeFramebufferCompletenessForTexture(const MG_External::GLESFunctionsTable& gl, TextureTarget target,
                                                     GLuint texture, TextureInternalFormat format) {
             GLuint framebuffer = 0;
@@ -427,12 +406,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return complete;
         }
 
-        // `samples` only reaches the multisample targets; every other target ignores it. The
-        // descending sample walk (ProbeTextureSampleCounts) reuses this whole routine rather than
-        // repeating the gen/bind/completeness/delete dance.
         Bool ProbeTexture(const MG_External::GLESFunctionsTable& gl, TextureTarget target, GLenum internalFormat,
                           GLenum imageFormat, GLenum imageType, TextureInternalFormat logicalFormat,
-                          Bool* outRenderable, Int samples = 1) {
+                          Bool* outRenderable) {
             if (!IsGLESProbeTextureTarget(target) || !gl.glGenTextures || !gl.glBindTexture || !gl.glDeleteTextures) {
                 return false;
             }
@@ -452,11 +428,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
             const Bool isMultisample = IsGLESProbeMultisampleTarget(target);
             if (isMultisample) {
-                const auto probeSamples = static_cast<GLsizei>(std::max(samples, 1));
                 if (target == TextureTarget::Texture2DMultisample && gl.glTexStorage2DMultisample) {
-                    gl.glTexStorage2DMultisample(glTarget, probeSamples, internalFormat, 1, 1, GL_TRUE);
+                    gl.glTexStorage2DMultisample(glTarget, 1, internalFormat, 1, 1, GL_TRUE);
                 } else if (target == TextureTarget::Texture2DMultisampleArray && gl.glTexStorage3DMultisample) {
-                    gl.glTexStorage3DMultisample(glTarget, probeSamples, internalFormat, 1, 1, 1, GL_TRUE);
+                    gl.glTexStorage3DMultisample(glTarget, 1, internalFormat, 1, 1, 1, GL_TRUE);
                 } else {
                     gl.glBindTexture(glTarget, static_cast<GLuint>(previousBinding));
                     gl.glDeleteTextures(1, &texture);
@@ -552,29 +527,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return sampleCounts;
         }
 
-        // The multisample TEXTURE twin of ProbeRenderbufferSampleCounts. It used to be a
-        // hardcoded {1}, which made glGetInternalformativ(GL_SAMPLES) claim a one-sample maximum
-        // for every format on the multisample targets even where glTexImage2DMultisample happily
-        // accepts four - GL 4.6 core 8.8 makes that query the definition of the maximum, so the
-        // two answers cannot both be right. Completeness is required at every count, exactly as
-        // the renderbuffer walk requires it; the caller only reaches here once the one-sample
-        // probe has already succeeded, so 1 terminates the list without being re-probed.
-        Vector<Int> ProbeTextureSampleCounts(const MG_External::GLESFunctionsTable& gl, TextureTarget target,
-                                             GLenum internalFormat, GLenum imageFormat, GLenum imageType,
-                                             TextureInternalFormat logicalFormat, Int maxSamples) {
-            Vector<Int> sampleCounts;
-            for (Int samples = std::max(maxSamples, 1); samples > 1; samples >>= 1) {
-                Bool renderable = false;
-                const Bool created = ProbeTexture(gl, target, internalFormat, imageFormat, imageType, logicalFormat,
-                                                  &renderable, samples);
-                if (created && renderable) {
-                    sampleCounts.push_back(samples);
-                }
-            }
-            sampleCounts.push_back(1);
-            return sampleCounts;
-        }
-
         void PopulateFormatCapabilitiesImpl(const MG_External::GLESFunctionsTable& gl,
                                             const MG_External::GLESCapabilities& capabilities,
                                             FormatCapabilityCache& cache) {
@@ -675,11 +627,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                             AddFullFormatCaps(cache, targetIndex, formatIndex,
                                               BuildTextureCapsFromProbe(logicalFormat, target, nativeRenderable));
                             if (IsGLESProbeMultisampleTarget(target)) {
-                                const Int maxSamples =
-                                    GetGLESFormatMaxSamples(capabilities, logicalFormat, nativeInfo.ImageFormat);
-                                cache.SampleCounts[targetIndex][formatIndex] = ProbeTextureSampleCounts(
-                                    gl, probeTarget, nativeInfo.InternalFormat, nativeInfo.ImageFormat,
-                                    nativeInfo.ImageType, logicalFormat, maxSamples);
+                                cache.SampleCounts[targetIndex][formatIndex] = {1};
                             }
                         }
                         shouldProbeFallback = !nativeCreated || !nativeRenderable;
@@ -697,11 +645,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                 LogGLESFormatCaveat(logicalFormat, targetIndex, fallbackInfo);
                             }
                             if (IsGLESProbeMultisampleTarget(target)) {
-                                const Int maxSamples =
-                                    GetGLESFormatMaxSamples(capabilities, logicalFormat, fallbackInfo.ImageFormat);
-                                cache.SampleCounts[targetIndex][formatIndex] = ProbeTextureSampleCounts(
-                                    gl, probeTarget, fallbackInfo.InternalFormat, fallbackInfo.ImageFormat,
-                                    fallbackInfo.ImageType, logicalFormat, maxSamples);
+                                cache.SampleCounts[targetIndex][formatIndex] = {1};
                             }
                         }
                     }
@@ -734,7 +678,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                         AddFullFormatCaps(cache, renderbufferTargetIndex, formatIndex,
                                           GetRenderbufferFeatureCaps(logicalFormat));
                         const Int maxSamples =
-                            GetGLESRenderbufferFormatMaxSamples(capabilities, nativeInfo.ImageFormat);
+                            GetGLESFormatMaxSamples(capabilities, logicalFormat, nativeInfo.ImageFormat);
                         cache.SampleCounts[renderbufferTargetIndex][formatIndex] =
                             ProbeRenderbufferSampleCounts(gl, nativeInfo.InternalFormat, logicalFormat, maxSamples);
                     } else {
@@ -748,7 +692,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                         LogGLESFormatCaveat(logicalFormat, renderbufferTargetIndex, renderbufferFallbackInfo);
                     }
                     const Int maxSamples =
-                        GetGLESRenderbufferFormatMaxSamples(capabilities, renderbufferFallbackInfo.ImageFormat);
+                        GetGLESFormatMaxSamples(capabilities, logicalFormat, renderbufferFallbackInfo.ImageFormat);
                     cache.SampleCounts[renderbufferTargetIndex][formatIndex] = ProbeRenderbufferSampleCounts(
                         gl, renderbufferFallbackInfo.InternalFormat, logicalFormat, maxSamples);
                 }
@@ -766,11 +710,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 .ExtraVendor = Nullopt,              // Extra vendor
                 .RendererGLInfo =
                     {
-                        .TargetGLVersion = {4, 6, 0},   // GL target version
+                        .TargetGLVersion = {4, 0, 0},   // GL target version
                         .TargetGLSLVersion = {4, 6, 0}, // Target Shading Language Version
-                        // Baseline advertisement (no runtime capabilities yet); reconciled once
-                        // the ES capabilities exist, see UpdateAdvertisedCapabilityExtensions.
-                        .Extensions = BuildAdvertisedExtensions(false, false, false, false, false, false),
+                        // Baseline advertisement (no timer queries / anisotropy yet); reconciled
+                        // once the ES capabilities exist, see UpdateAdvertisedCapabilityExtensions.
+                        .Extensions = BuildAdvertisedExtensions(false, false),
                         .IsCompatibilityProfile = false // Is Compatibility Profile
                     },
                 .StaticBackendCapability = {.AllowVSOnlyPrograms = false} // Backend Capability
@@ -790,12 +734,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
         // thread can only observe the extension string after the
         // advertisement for its context has settled; rebuilding the whole
         // list keeps the re-run after a context recreation idempotent.
-        void UpdateAdvertisedCapabilityExtensions(const MG_External::GLESCapabilities& capabilities) {
-            MutableRendererInfo().RendererGLInfo.Extensions = BuildAdvertisedExtensions(
-                AreTimerQueriesSupported(), capabilities.SupportsTextureFilterAnisotropy,
-                capabilities.SupportsDrawIndirect,
-                capabilities.SupportsDrawIndirect && capabilities.SupportsBaseInstance,
-                capabilities.SupportsTextureView, capabilities.SupportsTextureCubeMapArray);
+        void UpdateAdvertisedCapabilityExtensions(Bool anisotropicFilteringSupported) {
+            MutableRendererInfo().RendererGLInfo.Extensions =
+                BuildAdvertisedExtensions(AreTimerQueriesSupported(), anisotropicFilteringSupported);
         }
     } // namespace
 
@@ -804,29 +745,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         PopulateFormatCapabilitiesImpl(gl, capabilities, cache);
     }
 
-    Int ClampSamplesToBackendSupport(SizeT targetIndex, TextureInternalFormat logicalFormat, GLenum imageFormat,
-                                     Int samples) {
-        if (samples <= 1) {
-            return samples;
-        }
-
-        Int maxSamples = 0;
-        const SizeT formatIndex = static_cast<SizeT>(logicalFormat);
-        if (pActiveBackendObject && targetIndex < kFormatCapabilityTargetCount &&
-            formatIndex < kFormatCapabilityFormatCount) {
-            // Descending, so the head is the largest count this device actually allocated.
-            const Vector<Int>& probedCounts =
-                pActiveBackendObject->GetFormatCapabilities().SampleCounts[targetIndex][formatIndex];
-            if (!probedCounts.empty()) {
-                maxSamples = probedCounts.front();
-            }
-        }
-        if (maxSamples <= 0) {
-            maxSamples = GetGLESFormatMaxSamples(g_GLESCapabilities, logicalFormat, imageFormat);
-        }
-        return std::min(samples, std::max(maxSamples, 1));
-    }
-
     BackendObject_DirectGLES::~BackendObject_DirectGLES() {
         DestroyEGLContext();
     }
@@ -861,11 +779,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return false;
         }
         DirectGLES::SetGLESCapabilities(m_GLESCapabilities);
-        // Now that g_GLESCapabilities knows the host extensions, entry points, and ES version,
-        // reconcile every runtime-gated advertisement (see the comment on
-        // UpdateAdvertisedCapabilityExtensions for why this cannot happen when the list is first
-        // built).
-        UpdateAdvertisedCapabilityExtensions(m_GLESCapabilities);
+        // Now that g_GLESCapabilities knows about GL_EXT_disjoint_timer_query and
+        // GL_EXT_texture_filter_anisotropic, reconcile the advertisement (see the comment on
+        // UpdateAdvertisedCapabilityExtensions for why it cannot happen when the extension
+        // list is first built).
+        UpdateAdvertisedCapabilityExtensions(m_GLESCapabilities.SupportsTextureFilterAnisotropy);
         UpdateDynamicBackendParameters();
         PopulateFormatCapabilities(m_GLESFunctions, m_GLESCapabilities, MutableFormatCapabilities());
         PrintFormatCapabilities(GetFormatCapabilities());
@@ -1006,20 +924,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
         return MutableRendererInfo();
     }
 
-    Vector<GLExtension> BuildAdvertisedExtensions(Bool timerQueriesSupported, Bool anisotropicFilteringSupported,
-                                                  Bool drawIndirectSupported,
-                                                  Bool nonZeroIndirectBaseInstanceSupported,
-                                                  Bool textureViewSupported, Bool cubeMapArraySupported) {
+    Vector<GLExtension> BuildAdvertisedExtensions(Bool timerQueriesSupported, Bool anisotropicFilteringSupported) {
         Vector<GLExtension> extensions = {
-            // The version tokens have to reach the version the backend actually claims:
-            // TargetGLVersion is {4,6,0}, and a list that stopped at OpenGL40 told an
-            // application feature-detecting off these tokens the opposite of what
-            // GL_MAJOR_VERSION / GL_MINOR_VERSION told it.
-            V_OpenGL30, V_OpenGL31, V_OpenGL32, V_OpenGL33, V_OpenGL40, V_OpenGL41, V_OpenGL42, V_OpenGL43,
-            V_OpenGL44, V_OpenGL45, V_OpenGL46,
-            E_GL_ARB_draw_buffers_blend,
+            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_clear_buffer_object, E_GL_ARB_program_interface_query, E_GL_ARB_framebuffer_object, E_GL_EXT_framebuffer_object,
+            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,
@@ -1031,105 +940,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
             // 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,
-            // Core since GL 3.1 and implemented for every version advertised here. The string
-            // matters because applications gate the ENTRY POINTS on it rather than on the
-            // version: a caller that finds the extension missing never resolves
-            // glGetUniformBlockIndex / glUniformBlockBinding, and one that then uses uniform
-            // blocks anyway calls through a null pointer.
-            E_GL_ARB_uniform_buffer_object,
-            // Sampling the stencil aspect through DEPTH_STENCIL_TEXTURE_MODE. Core from 4.3,
-            // so on a 4.0 context the string is the only way to reach it. The host ES driver
-            // has had the same texture parameter since ES 3.1, which every device MobileGL
-            // runs on provides.
-            E_GL_ARB_stencil_texturing,
-            // Core since 3.2 and implemented here on both backends - glDrawElementsBaseVertex,
-            // glDrawRangeElementsBaseVertex, glDrawElementsInstancedBaseVertex and
-            // glMultiDrawElementsBaseVertex all reach real per-draw vertex rebasing. The string
-            // was simply never emitted, which left KHR-GL4*.draw_elements_base_vertex_tests
-            // NotSupported on a feature that works.
-            E_GL_ARB_draw_elements_base_vertex,
-            // The whole sync-object family is real and core since 3.2: glFenceSync, glIsSync,
-            // glDeleteSync, glClientWaitSync, glWaitSync and glGetSynciv all live in GLImpl over a
-            // backend fence (a host GLsync here, a VkFence on DirectVulkan), and glGetInteger64v
-            // answers GL_MAX_SERVER_WAIT_TIMEOUT. The string matters for the same reason
-            // ARB_uniform_buffer_object's does: LWJGL builds GLCapabilities from the extension
-            // list, and a caller that finds GL_ARB_sync missing never resolves the entry points -
-            // then calls through null if it uses fences anyway. Nothing in the CTS gates on this
-            // string, so it is advertised on the strength of the implementation, not a test unlock.
-            E_GL_ARB_sync,
-            // Atomic counters, core since 4.2. glGetActiveAtomicCounterBufferiv and the whole
-            // GL_ATOMIC_COUNTER_BUFFER_* query family are real in GLImpl, and SyncAtomicCounterBuffers
-            // re-issues the counter buffer as an SSBO binding in the range reserved at the top of
-            // the ES driver's shader-storage points, so a counter dispatch reads and writes the
-            // buffer the application bound. DirectVulkan reaches the same place through its own
-            // descriptor resolution, so the string is symmetric.
-            E_GL_ARB_shader_atomic_counters,
-            // glVertexAttribDivisor, core since 3.3 and real on both backends. Applications
-            // (Better Clouds' GLCompat among them) accept the extension string as an
-            // ALTERNATIVE to a 3.3 context when deciding whether instanced rendering is
-            // available, so withholding it makes MobileGL look less capable than it is.
-            E_GL_ARB_instanced_arrays,
-            // The whole of KHR_debug lives in GLImpl - the message log, the group stack and the
-            // object-label table are MobileGL's own state, not the host driver's - so it is as
-            // available here as it is on DirectVulkan, which has advertised it all along.
-            E_GL_KHR_debug,
-            // Core GL 3.0-4.3 plumbing that has been real here for as long as the backend has
-            // existed, and that was simply never named. None of these unlocks a single CTS case -
-            // the conformance suite reaches all of them through the version - so they are
-            // advertised for the OTHER consumer of this list: LWJGL builds GLCapabilities from the
-            // string set, and an application that gates its ENTRY POINTS on the string rather than
-            // on the version never resolves them and then calls through null. Each is backed by
-            // the entry points named beside it.
-            //
-            // glBindVertexArray / glGenVertexArrays / glDeleteVertexArrays / glIsVertexArray.
-            E_GL_ARB_vertex_array_object,
-            // The 14 glSamplerParameter* / glGetSamplerParameter* entry points, including the
-            // integer-valued Iiv/Iuiv forms.
-            E_GL_ARB_sampler_objects,
-            // glMapBufferRange + glFlushMappedBufferRange, which ARB_buffer_storage's persistent
-            // maps are already built on top of.
-            E_GL_ARB_map_buffer_range,
-            // glCopyBufferSubData plus the GL_COPY_READ_BUFFER / GL_COPY_WRITE_BUFFER targets.
-            E_GL_ARB_copy_buffer,
-            // glCopyImageSubData, wired to a real backend hook on both backends.
-            E_GL_ARB_copy_image,
-            // GL_TEXTURE_SWIZZLE_{R,G,B,A,RGBA}, which this backend syncs through to the ES
-            // driver's identical parameters.
-            E_GL_ARB_texture_swizzle,
-            // GL_INT_2_10_10_10_REV / GL_UNSIGNED_INT_2_10_10_10_REV on glVertexAttribPointer plus
-            // the eight glVertexAttribP* entry points.
-            E_GL_ARB_vertex_type_2_10_10_10_rev,
-            // The R/RG internal formats. Named separately from the float ones because an
-            // application may check either.
-            E_GL_ARB_texture_rg,
-            // GL_DEPTH_COMPONENT32F and GL_DEPTH32F_STENCIL8.
-            E_GL_ARB_depth_buffer_float,
-            // The floating-point colour formats. Unlike the rest of this block this string DOES
-            // gate CTS cases - KHR-GL4*.internalformat.texture2d.*{16f,32f} is keyed on it with no
-            // core-version fallback, so eight cases per version list were NotSupported on formats
-            // the backend has always had.
-            E_GL_ARB_texture_float,
-            // glViewportArrayv / glViewportIndexedf{,v} / glScissorArrayv / glScissorIndexed{,v} /
-            // glDepthRangeArrayv / glDepthRangeIndexed / glGetFloati_v / glGetDoublei_v, over the
-            // 16 viewports GL_MAX_VIEWPORTS reports and the per-viewport routing emulation.
-            E_GL_ARB_viewport_array,
             // 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};
-        // Minecraft 26.3 checks this prerequisite before it even considers
-        // GL_ARB_multi_draw_indirect. ES 3.1 supplies both single-draw entry points; the loader
-        // folds the version and pointer checks into SupportsDrawIndirect.
-        if (drawIndirectSupported) {
-            extensions.push_back(E_GL_ARB_draw_indirect);
-        }
-        // ARB_base_instance also defines the last word of an indirect command. Direct calls are
-        // emulated on every Espryt device, but without host GL_EXT_base_instance a native indirect
-        // draw cannot shift divisor attributes by a GPU-authored non-zero value, so do not promise
-        // that incomplete case.
-        if (drawIndirectSupported && nonZeroIndirectBaseInstanceSupported) {
-            extensions.push_back(E_GL_ARB_base_instance);
-        }
         // 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
@@ -1146,62 +960,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
         if (MG_Util::Async::AsyncShaderCompileEnabled()) {
             extensions.push_back(E_GL_KHR_parallel_shader_compile);
         }
-        // GL_ARB_gpu_shader_fp64 is opt-in (MOBILEGL_ADVERTISE_FP64). Every `double` in a
-        // shader compiles and runs already - it is narrowed to 32 bits before the module
-        // reaches this backend - so an application that simply uses doubles needs nothing
-        // advertised. What the extension additionally promises is 64-bit PRECISION, which no
-        // mobile GPU has and the narrowing cannot fake, so advertising it by default would
-        // make an application that checks the string take a path MobileGL cannot honour.
-        if (MG_Config::Features.AdvertiseFp64) {
-            extensions.push_back(E_GL_ARB_gpu_shader_fp64);
-        }
         // 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.
         if (timerQueriesSupported && !MG_Config::Features.DisableTimerQuery) {
             extensions.push_back(E_GL_ARB_timer_query);
         }
-        // Cube map arrays are core from GL 4.0 and from ES 3.2, but on a pre-ES-3.2 driver without
-        // EXT/OES_texture_cube_map_array there is nothing underneath: the texture gets no storage
-        // and a samplerCubeArray shader does not even compile, which is exactly what the POST
-        // reports. So the string follows the host capability rather than the version.
-        //
-        // Named for the application's benefit rather than the suite's: measured on Adreno 830,
-        // KHR-GL43.texture_gather.plain-gather-*-cube-array already passed without the string, so
-        // this unlocks no conformance case. It is advertised because the feature is real and
-        // because an application that feature-detects cube map arrays off the string (rather than
-        // off the 4.0 version) would otherwise decline a path this backend serves.
-        if (cubeMapArraySupported) {
-            extensions.push_back(E_GL_ARB_texture_cube_map_array);
-        }
-        // Only advertised when the host ES driver has EXT/OES_texture_view. ES has no core
-        // texture views at any version and no honest emulation exists: a view is a SECOND NAME
-        // over the SAME storage, so that writes through either are visible through the other and
-        // the two carry independent per-texture parameters at the same time - which is exactly
-        // what applications use it for (Better Clouds samples one D24S8 through its own name with
-        // DEPTH_STENCIL_TEXTURE_MODE = STENCIL_INDEX and through a view with DEPTH_COMPONENT, in
-        // a single shading pass). A copy-based fallback satisfies neither half, and fails
-        // silently; withholding the string and answering glTextureView with INVALID_OPERATION is
-        // the only behaviour that cannot be mistaken for success.
-        //
-        // The host extension is necessary and NOT sufficient, which is why this second gate
-        // exists. Adreno 830 has EXT_texture_view, and on it the whole functional half of
-        // KHR-GL4{2,3}.texture_view fails: base_and_max_levels, reference_counting and
-        // view_sampling Fail and view_classes crashes, while only the two pure-API cases
-        // (errors, gettexparameter - neither of which touches the host view) pass. The cause is
-        // known and is MobileGL's, not the driver's: SyncTextureViewToBackend normalizes the
-        // VIEW's ES internalformat independently of the storage it aliases, so whenever the two
-        // land on different renderability carriers the host rejects the pair, the error is
-        // swallowed, and the view is left as a storage-less name that samples as zeros.
-        // DirectVulkan builds the view as a second VkImageView over one VkImage and has no such
-        // seam - it passes 5 of the 7 cases on the same device - so the string stays there.
-        //
-        // Until that reconciliation exists, advertising here would be the same lie the comment
-        // above refuses to tell, just with an extra prerequisite met. Set
-        // MOBILEGL_ESPRYT_ENABLE_TEXTURE_VIEW=1 to re-enable it for that work.
-        if (textureViewSupported && MG_Config::Features.EsprytEnableTextureView) {
-            extensions.push_back(E_GL_ARB_texture_view);
-        }
         // Only advertised when the host ES driver actually filters anisotropically: the sampler
         // state is accepted regardless, but forwarding it would be a no-op without the extension,
         // and an app that trusts the string (LWJGL builds GLCapabilities from it) would silently
@@ -1238,7 +1002,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             funcsTable.GL.MultiDrawElementsIndirect = MultiDrawElementsIndirect;
             funcsTable.GL.MultiDrawElementsIndirectCount = MultiDrawElementsIndirectCount;
             funcsTable.GL.MultiDrawArraysIndirect = MultiDrawArraysIndirect;
-            funcsTable.GL.MultiDrawArraysIndirectCount = MultiDrawArraysIndirectCount;
             funcsTable.GL.DrawRangeElementsBaseVertex = DrawRangeElementsBaseVertex;
             funcsTable.GL.DrawRangeElements = DrawRangeElements;
             funcsTable.GL.DrawElementsInstancedBaseVertexBaseInstance = DrawElementsInstancedBaseVertexBaseInstance;
@@ -1255,6 +1018,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
             funcsTable.GL.MemoryBarrierByRegion = MemoryBarrierByRegion;
             funcsTable.GL.BindImageTexture = BindImageTexture;
             funcsTable.GL.GetIntegeri_v = GetIntegeri_v;
+            funcsTable.GL.GetInteger64i_v = GetInteger64i_v;
+            funcsTable.GL.GetProgramiv = GetProgramiv;
             funcsTable.GL.ShaderStorageBlockBinding = ShaderStorageBlockBinding;
             funcsTable.GL.Clear = Clear;
             funcsTable.GL.ClearBufferfi = ClearBufferfi;
@@ -1304,12 +1069,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             // geometry shader's amplification.
             funcsTable.GL.BeginXfbPrimitivesQuery = BeginXfbPrimitivesQuery;
             funcsTable.GL.EndXfbPrimitivesQuery = EndXfbPrimitivesQuery;
-            // ...but where it CAN see the whole capture - no geometry stage - the frontend's
-            // own count is the desktop-exact one and the ES driver's is only as good as the
-            // vendor made it (Adreno doubles PRIMITIVES_WRITTEN for a vertex-only capture that
-            // follows a large render pass). The query above stays installed: it is still what
-            // answers an amplifying span, and PRIMITIVES_GENERATED always.
-            funcsTable.GL.PrefersCpuXfbPrimitiveAccounting = true;
             funcsTable.GL.IsQueryResultAvailable = IsQueryResultAvailable;
             funcsTable.GL.GetQueryResult64 = GetQueryResult64;
             funcsTable.GL.DeleteBackendQuery = DeleteBackendQuery;
@@ -1339,8 +1098,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
     void BackendObject_DirectGLES::UpdateDynamicBackendParameters() {
         m_dynamicParameters.UniformBufferOffsetAlignment = m_GLESCapabilities.UniformBufferOffsetAlignment;
-        m_dynamicParameters.ShaderStorageBufferOffsetAlignment =
-            m_GLESCapabilities.ShaderStorageBufferOffsetAlignment;
         m_dynamicParameters.MaxTextureMaxAnisotropy = m_GLESCapabilities.MaxTextureMaxAnisotropy;
         m_dynamicParameters.AliasedLineWidthRangeMin = m_GLESCapabilities.AliasedLineWidthRangeMin;
         m_dynamicParameters.AliasedLineWidthRangeMax = m_GLESCapabilities.AliasedLineWidthRangeMax;
@@ -1391,48 +1148,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
                      static_cast<Int>(MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS));
         m_dynamicParameters.MaxComputeShaderStorageBlocks = m_GLESCapabilities.MaxComputeShaderStorageBlocks;
         m_dynamicParameters.MaxCombinedShaderStorageBlocks = m_GLESCapabilities.MaxCombinedShaderStorageBlocks;
-        // Per-stage storage-block counts, forwarded from the host driver rather than invented.
-        // A stage the driver cannot serve reports 0, which is a legal answer everywhere these
-        // limits appear (GL 4.6 table 23.64, ES 3.2 table 21.44 - the minimum is 0 for every
-        // graphics stage except fragment) and is the only answer that lets an application take
-        // its own fallback instead of building a program the driver will refuse to link. The
-        // stage limit cannot exceed the combined limit or the number of binding points there
-        // are to bind buffers to, so clamp to both.
-        const auto clampStageStorageBlocks = [this](Int stageLimit) {
-            return std::min({std::max(stageLimit, 0), std::max(m_dynamicParameters.MaxCombinedShaderStorageBlocks, 0),
-                             std::max(m_dynamicParameters.MaxShaderStorageBufferBindings, 0)});
-        };
-        m_dynamicParameters.MaxShaderStorageBufferBindings = m_GLESCapabilities.MaxShaderStorageBufferBindings;
-        m_dynamicParameters.MaxVertexShaderStorageBlocks =
-            clampStageStorageBlocks(m_GLESCapabilities.MaxVertexShaderStorageBlocks);
-        m_dynamicParameters.MaxTessControlShaderStorageBlocks =
-            clampStageStorageBlocks(m_GLESCapabilities.MaxTessControlShaderStorageBlocks);
-        m_dynamicParameters.MaxTessEvaluationShaderStorageBlocks =
-            clampStageStorageBlocks(m_GLESCapabilities.MaxTessEvaluationShaderStorageBlocks);
-        m_dynamicParameters.MaxGeometryShaderStorageBlocks =
-            clampStageStorageBlocks(m_GLESCapabilities.MaxGeometryShaderStorageBlocks);
-        m_dynamicParameters.MaxFragmentShaderStorageBlocks =
-            clampStageStorageBlocks(m_GLESCapabilities.MaxFragmentShaderStorageBlocks);
         m_dynamicParameters.MaxComputeUniformBlocks = m_GLESCapabilities.MaxComputeUniformBlocks;
         m_dynamicParameters.MaxComputeWorkGroupInvocations = m_GLESCapabilities.MaxComputeWorkGroupInvocations;
-        // The six per-axis compute limits: the driver's raw glGetIntegeri_v answers, the same
-        // numbers GLFunctionsTable::GetIntegeri_v forwards live. Carried here so that MGPCaps has
-        // them once the table entry retires (plan B section 4.4.1); GL_Getter floors them.
-        for (SizeT axis = 0; axis < 3; ++axis) {
-            m_dynamicParameters.MaxComputeWorkGroupCount[axis] = m_GLESCapabilities.MaxComputeWorkGroupCount[axis];
-            m_dynamicParameters.MaxComputeWorkGroupSize[axis] = m_GLESCapabilities.MaxComputeWorkGroupSize[axis];
-        }
-        // (MaxShaderStorageBufferBindings is assigned above, before the per-stage clamp reads it.)
-        // This is the number glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE) hands the application, and
-        // on a host without buffer textures it is knowingly a floor MobileGL cannot honour rather
-        // than a driver answer (m_GLESCapabilities.MaxTextureBufferSizeIsDriverReported says
-        // which). Reporting 0 instead was considered and rejected: MobileGL advertises an OpenGL
-        // 4.x context, where buffer textures are core and the limit has a spec minimum of 65536,
-        // so 0 is not a legal answer and applications are not written to survive it. GL offers no
-        // way to say "this core feature is missing", so the honesty is carried outside the limit:
-        // FillInGLESCapabilities logs the tier, glTexBuffer and the program build each name the
-        // missing capability at MGLOG_I, and the driver POST carries a "Buffer textures" row that
-        // FAILs on this tier.
+        m_dynamicParameters.MaxShaderStorageBufferBindings = m_GLESCapabilities.MaxShaderStorageBufferBindings;
         m_dynamicParameters.MaxTextureBufferSize = m_GLESCapabilities.MaxTextureBufferSize;
         m_dynamicParameters.TextureBufferOffsetAlignment = m_GLESCapabilities.TextureBufferOffsetAlignment;
         m_dynamicParameters.MaxUniformBufferBindings = m_GLESCapabilities.MaxUniformBufferBindings;
@@ -1475,61 +1193,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::TextureCubeMapArray);
             }
         }
-        // Not a driver question and never will be: GLSL ES has no 64-bit float type in ANY version
-        // or extension, so SPIRV-Cross cannot emit one ("FP64 not supported in ES profile") and a
-        // module that still declared Float64 would never reach the driver at all. The demotion is
-        // mathematically mandatory here, on every device, forever - which is why this stays false
-        // regardless of what the driver underneath happens to support.
-        m_dynamicParameters.SupportsShaderFloat64 = false;
-        // Follows the line above, and must: OpenGL ES has no double-precision vertex format and no
-        // fp64 type to consume one with, so a 64-bit vertex attribute has nowhere to land here.
+        // 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;
-        // Whether a tessellation / geometry stage's ESSL may name gl_PointSize at all: the two
-        // extension pairs the loader probed, independently, because they really do come
-        // separately. False arms the shared phase-B demotion
-        // (ShaderCompiler::DemoteTessellationGeometryPointSizeForProgram), whose ESSL then
-        // never names the built-in in those stages and needs no extension.
-        // MOBILEGL_POINT_SIZE_DEMOTION=1 pretends both are absent so the demotion can be
-        // exercised on a healthy driver (the pinned integration lane); =0 restores the
-        // detected answer's declines.
-        m_dynamicParameters.SupportsTessellationPointSize =
-            m_GLESCapabilities.TessellationPointSizeSupport !=
-            MG_External::GLESCapabilities::PointSizeTier::None;
-        m_dynamicParameters.SupportsGeometryPointSize =
-            m_GLESCapabilities.GeometryPointSizeSupport !=
-            MG_External::GLESCapabilities::PointSizeTier::None;
-        switch (MG_Config::Features.PointSizeDemotion) {
-        case MG_Config::QuirkOverride::ForceOn:
-            MGLOG_I("DirectGLES: MOBILEGL_POINT_SIZE_DEMOTION=1 - treating tessellation/geometry "
-                    "gl_PointSize as unhosted so the demotion runs on this driver");
-            m_dynamicParameters.SupportsTessellationPointSize = false;
-            m_dynamicParameters.SupportsGeometryPointSize = false;
-            break;
-        case MG_Config::QuirkOverride::ForceOff:
-            MGLOG_I("DirectGLES: MOBILEGL_POINT_SIZE_DEMOTION=0 - keeping the built-in and the "
-                    "plain declines regardless of the driver's extensions");
-            m_dynamicParameters.SupportsTessellationPointSize = true;
-            m_dynamicParameters.SupportsGeometryPointSize = true;
-            break;
-        case MG_Config::QuirkOverride::Auto:
-            break;
-        }
         m_dynamicParameters.MaxDrawBuffers = m_GLESCapabilities.MaxDrawBuffers;
         m_dynamicParameters.MaxColorAttachments = m_GLESCapabilities.MaxColorAttachments;
         m_dynamicParameters.MaxClipDistances = m_GLESCapabilities.MaxClipDistances;
-        // The loader already gated both on GL_EXT_clip_cull_distance and left 0 without it, which
-        // is the answer that keeps glslang from accepting a gl_CullDistance the ESSL compiler
-        // would reject.
-        m_dynamicParameters.MaxCullDistances = m_GLESCapabilities.MaxCullDistances;
-        m_dynamicParameters.MaxCombinedClipAndCullDistances = m_GLESCapabilities.MaxCombinedClipAndCullDistances;
         m_dynamicParameters.MaxViewports = m_GLESCapabilities.MaxViewports;
-        // Whatever the driver said about which vertex supplies gl_Layer, and GL_UNDEFINED_VERTEX
-        // for gl_ViewportIndex on every driver without GL_OES_viewport_array - which is both test
-        // devices. That is not a shortfall being hidden: without the extension only viewport 0 is
-        // ever rasterized, so no vertex "selects" a viewport index and naming a convention would
-        // describe behaviour this backend does not implement.
-        m_dynamicParameters.LayerProvokingVertex = m_GLESCapabilities.LayerProvokingVertex;
-        m_dynamicParameters.ViewportIndexProvokingVertex = m_GLESCapabilities.ViewportIndexProvokingVertex;
         m_dynamicParameters.MaxViewportWidth = m_GLESCapabilities.MaxViewportWidth;
         m_dynamicParameters.MaxViewportHeight = m_GLESCapabilities.MaxViewportHeight;
         m_dynamicParameters.ViewportBoundsRangeMin = m_GLESCapabilities.ViewportBoundsRangeMin;

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.h

@@ -18,16 +18,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                     const MG_External::GLESCapabilities& capabilities,
                                     FormatCapabilityCache& cache);
 
-    // Clamps a requested sample count down to what the ES driver can really deliver for this
-    // format on this format-capability target: the probed per-format list when there is one, the
-    // driver's per-class GL_MAX_*_SAMPLES otherwise. The frontend deliberately validates against
-    // the count MobileGL advertises instead (GL_Getter's GetAdvertisedMaxSamples), which on a
-    // driver reporting GL_MAX_INTEGER_SAMPLES 1 is higher than the driver accepts, so every ES
-    // allocation call has to come through here. The shadow state keeps the requested count, so
-    // GL_TEXTURE_SAMPLES and framebuffer completeness still answer what the application asked for.
-    Int ClampSamplesToBackendSupport(SizeT targetIndex, TextureInternalFormat logicalFormat, GLenum imageFormat,
-                                     Int samples);
-
     class BackendObject_DirectGLES : public BackendObject {
     public:
         ~BackendObject_DirectGLES() override;
@@ -77,13 +67,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
     const RendererInfo& GetRendererIdentity();
 
     // The full OpenGL extension list Espryt advertises (glGetString(GL_EXTENSIONS))
-    // for a device whose timer queries / anisotropic filtering / native indirect draws /
-    // non-zero indirect baseInstance semantics / EXT-OES texture views are (or are not) usable.
+    // for a device whose timer queries / anisotropic filtering are (or are not) usable.
     // The MOBILEGL_DISABLE_TIMERQUERY escape hatch is applied inside.
-    Vector<GLExtension> BuildAdvertisedExtensions(Bool timerQueriesSupported, Bool anisotropicFilteringSupported,
-                                                  Bool drawIndirectSupported,
-                                                  Bool nonZeroIndirectBaseInstanceSupported,
-                                                  Bool textureViewSupported, Bool cubeMapArraySupported);
+    Vector<GLExtension> BuildAdvertisedExtensions(Bool timerQueriesSupported, Bool anisotropicFilteringSupported);
 
     // Format: <OpenGL ES Renderer>, OpenGL ES <Major>.<Minor> — the exact string an
     // initialized backend returns from GetBackendAPIVersionString (and that ends up

MobileGL/MG_Backend/DirectGLES/DirectGLES.h

@@ -40,8 +40,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
     void MultiDrawElementsIndirectCount(GLenum mode, GLenum type, const void* indirect, GLintptr drawcount,
                                         GLsizei maxdrawcount, GLsizei stride);
     void MultiDrawArraysIndirect(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride);
-    void MultiDrawArraysIndirectCount(GLenum mode, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount,
-                                      GLsizei stride);
     void DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type,
                                      const void* indices, GLint basevertex);
     void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices);
@@ -76,9 +74,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
                         GLsizei height, GLint border);
     void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
                            GLsizei height);
-    void CopyImageSubData(const CopyImageEndpoint& src,
+    void CopyImageSubData(const SharedPtr<MG_State::GLState::ITextureObject>& srcTexture,
                           GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ,
-                          const CopyImageEndpoint& dst,
+                          const SharedPtr<MG_State::GLState::ITextureObject>& dstTexture,
                           GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ,
                           GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
     void GenerateMipmap(GLenum target);
@@ -92,6 +90,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
     void BindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access,
                           GLenum format);
     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);
     Bool InitWindowSurface(NativeWindowType window);
     Bool InitPbufferSurface(EGLint width, EGLint height);
@@ -117,24 +117,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
     // capability read needs no current ES context, and it stays false until
     // the ES capabilities have been filled in.
     Bool AreTimerQueriesSupported();
-    // True when the host ES driver can back a GL_TEXTURE_BUFFER at all - ES 3.2 core, or
-    // EXT/OES_texture_buffer, with glTexBuffer resolved. Desktop GL has had buffer textures as
-    // core since 3.1, so the frontend advertises them unconditionally and an app may call
-    // glTexBuffer whenever it likes; this is the only thing standing between that call and a
-    // null entry point. False also means every shader declaring a samplerBuffer is
-    // uncompilable on this driver, which the program build reports by name.
-    Bool AreBufferTexturesSupported();
-    // Human-readable name of the buffer-texture tier for diagnostics and the driver POST:
-    // "core (ES 3.2)", "GL_EXT_texture_buffer", "GL_OES_texture_buffer" or "unsupported".
-    const char* GetBufferTextureTierName();
-    // glTexBuffer / glTexBufferRange through whichever spelling this driver's buffer-texture
-    // support actually ships: the unsuffixed names are ES 3.2 core, while an EXT/OES driver
-    // exports glTexBuffer{,Range}EXT / OES. Callers must have checked
-    // AreBufferTexturesSupported() first. CallTexBufferRange reports whether it could honour
-    // the range - no tier is required to expose the range form, and the whole-buffer form is
-    // the documented fallback.
-    void CallTexBuffer(GLenum target, GLenum internalFormat, GLuint buffer);
-    Bool CallTexBufferRange(GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size);
     // GL timer-query objects, backed by GL_EXT_disjoint_timer_query. The
     // creators return null (the frontend then falls back to an immediately
     // available zero result) when the calling thread does not own the ES

MobileGL/MG_Backend/DirectGLES/MultiDraw.cpp

@@ -9,8 +9,6 @@
 #include "MultiDraw.h"
 #include "Managers.h"
 #include <MG_State/GLState/Core.h>
-#include <MG_Pipe/PipeInputsSwitch.h>
-#include <MG_Util/Metrics/PipeStats.h>
 #include <cstring>
 #include <limits>
 
@@ -31,26 +29,21 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
             }
         }
 
-        // The index value this batch restarts on, compared at 32 bits against the zero-extended
-        // source index. Normally the all-ones value of the source type, which is what
-        // GL_PRIMITIVE_RESTART_FIXED_INDEX and GLES both restart on; with desktop
-        // GL_PRIMITIVE_RESTART it is instead whatever glPrimitiveRestartIndex named. The rebased
-        // tier turns whichever it is into 0xFFFFFFFF in its widened stream, which is what the
-        // driver restarts on.
-        //
-        // No truncation, deliberately, and the same rule ResolveRestartSubstitution applies: a
-        // restart index the source type cannot hold simply matches nothing, so returning it
-        // verbatim is already "this batch restarts nowhere".
+        // 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) {
-            if (ResolveRestartSubstitution(type) != RestartSubstitutionKind::None) {
-                return MGB_CTX->GetPrimitiveRestartIndex();
+            switch (type) {
+            case GL_UNSIGNED_BYTE: return 0xFFu;
+            case GL_UNSIGNED_SHORT: return 0xFFFFu;
+            default: return 0xFFFFFFFFu;
             }
-            return MG_Util::FixedRestartIndexForGLType(type);
         }
 
         Bool RestartActive() {
-            return MGB_CTX->IsCapabilityEnabled(CapabilityInput::PrimitiveRestart) ||
-                   MGB_CTX->IsCapabilityEnabled(CapabilityInput::PrimitiveRestartFixedIndex);
+            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
@@ -85,7 +78,7 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
 
         Uint BoundDrawIndirectBufferId() {
             const auto& indirect =
-                MGB_CTX->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
+                MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
             if (!indirect) return 0;
             const auto* resource = BufferImpl::EnsureBufferResource(indirect);
             return resource ? resource->id : 0;
@@ -93,7 +86,7 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
 
         const SharedPtr<MG_State::GLState::BufferObject>& BoundIndexBuffer() {
             static const SharedPtr<MG_State::GLState::BufferObject> none;
-            const auto& vao = MGB_CTX->GetBoundVertexArray();
+            const auto& vao = MG_State::pGLContext->GetBoundVertexArray();
             if (!vao) return none;
             return vao->GetIndexBufferBindingSlot().GetBoundObject();
         }
@@ -158,10 +151,7 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
         // 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.
-        // statsClass: which MGPipe byte population these bytes belong to. Counted here
-        // rather than at the four call sites so a new tier cannot forget it.
-        Bool UploadScratch(ScratchBuffer& buffer, SizeT bytes, const void* data,
-                           MG_Util::PipeStats::ByteClass statsClass) {
+        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);
@@ -174,9 +164,6 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
             buffer.cursor = 0;
             if (data) {
                 g_GLESFuncs.glBufferSubData(BufferImpl::TempBufferTarget, 0, static_cast<GLsizeiptr>(bytes), data);
-                if (MG_Util::PipeStats::Enabled()) {
-                    MG_Util::PipeStats::AddBytes(statsClass, static_cast<Uint64>(bytes));
-                }
             }
             return true;
         }
@@ -191,8 +178,7 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
         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,
-                               MG_Util::PipeStats::ByteClass statsClass, SizeT& outOffset) {
+        Bool UploadScratchRing(ScratchBuffer& buffer, SizeT bytes, const void* data, SizeT& outOffset) {
             outOffset = 0;
             if (bytes == 0) return true;
             if (!EnsureScratchName(buffer)) return false;
@@ -216,9 +202,6 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
             if (data) {
                 g_GLESFuncs.glBufferSubData(BufferImpl::TempBufferTarget, static_cast<GLintptr>(outOffset),
                                             static_cast<GLsizeiptr>(bytes), data);
-                if (MG_Util::PipeStats::Enabled()) {
-                    MG_Util::PipeStats::AddBytes(statsClass, static_cast<Uint64>(bytes));
-                }
             }
             buffer.cursor += aligned;
             return true;
@@ -269,7 +252,7 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
             g_resolvedTier =
                 ResolveTier(g_GLESCapabilities, g_GLESFuncs, MG_Config::Features.EsprytMultiDrawMode,
                             &g_tierResolution);
-            MGLOG_D("DirectGLES multi-draw: %s", g_tierResolution.c_str());
+            MGLOG_I("DirectGLES multi-draw: %s", g_tierResolution.c_str());
         }
 
         // Which tiers have already announced themselves, one bit per GLESMultiDrawMode.
@@ -284,39 +267,24 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
             const Uint32 bit = 1u << static_cast<Uint32>(tier);
             if (g_announcedTiers & bit) return;
             g_announcedTiers |= bit;
-            MGLOG_D("DirectGLES multi-draw: first batch executed via tier \"%s\"", TierName(tier));
+            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 perSubDrawBaseVertex,
-                                              Bool hasIndexBuffer, Bool arbitraryRestart) {
+        GLESMultiDrawMode ResolveTierForBatch(Bool programReadsDrawID, Bool hasIndexBuffer) {
             ResolveTierOnce();
             GLESMultiDrawMode tier = g_resolvedTier;
 
-            // Desktop GL_PRIMITIVE_RESTART restarts on an application-chosen index; the driver
-            // only ever restarts on the all-ones value. Every tier but the rebased one hands
-            // the application's own index data to the driver, which would then see no restarts
-            // at all and weld the primitives together. The rebased tier is the one that
-            // REWRITES the stream, and RestartSentinelFor already tells it which value to
-            // translate, so it is the only tier this batch can take.
-            if (arbitraryRestart) {
-                return GLESMultiDrawMode::DrawElements;
-            }
-
             // 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. The
-            // emulated gl_BaseVertex is one uniform for the same reason, so a batch whose
-            // sub-draws carry their own base vertices unrolls too - even the Ext tier,
-            // which hands the driver the whole basevertex array, can only leave ONE value
-            // in the uniform the shader reads.
+            // 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 || perSubDrawBaseVertex)) {
+            if (batched && programReadsDrawID) {
                 tier = SupportsTier(GLESMultiDrawMode::BaseVertex) ? GLESMultiDrawMode::BaseVertex
                                                                    : GLESMultiDrawMode::DrawElements;
             }
@@ -403,8 +371,7 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
         // ---------------------------------------------------------------------------
 
         Bool RunIndirect(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                         GLsizei drawcount, const GLint* basevertex, Bool batched, Bool feedDrawID,
-                         Bool feedBaseVertex) {
+                         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;
@@ -429,8 +396,7 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
 
             const SizeT commandBytes = g_commandStaging.size() * sizeof(DrawElementsIndirectCommand);
             SizeT commandBase = 0;
-            if (!UploadScratchRing(g_indirectCommands, commandBytes, g_commandStaging.data(),
-                                   MG_Util::PipeStats::ByteClass::StageIndirectCmd, commandBase)) {
+            if (!UploadScratchRing(g_indirectCommands, commandBytes, g_commandStaging.data(), commandBase)) {
                 return false;
             }
 
@@ -442,21 +408,15 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
             const Uint previousIndirectBinding = BoundDrawIndirectBufferId();
             BufferImpl::BindBufferId(GL_DRAW_INDIRECT_BUFFER, g_indirectCommands.id);
             if (batched) {
-                ForEachViewportRoutingPass([&] {
-                    g_GLESFuncs.glMultiDrawElementsIndirectEXT(mode, type, reinterpret_cast<const void*>(commandBase),
-                                                               drawcount, 0);
-                });
+                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));
-                    if (feedBaseVertex) SetCurrentBaseVertex(basevertex ? basevertex[i] : 0);
                     const SizeT commandOffset = commandBase + static_cast<SizeT>(i) * sizeof(DrawElementsIndirectCommand);
-                    ForEachViewportRoutingPass([&] {
-                        g_GLESFuncs.glDrawElementsIndirect(mode, type, reinterpret_cast<const void*>(commandOffset));
-                    });
+                    g_GLESFuncs.glDrawElementsIndirect(mode, type, reinterpret_cast<const void*>(commandOffset));
                 }
                 if (feedDrawID) SetCurrentDrawID(0);
-                if (feedBaseVertex) SetCurrentBaseVertex(0);
             }
             BufferImpl::BindBufferId(GL_DRAW_INDIRECT_BUFFER, previousIndirectBinding);
             NoteTierExecuted(batched ? GLESMultiDrawMode::MultiIndirect : GLESMultiDrawMode::Indirect);
@@ -468,19 +428,15 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
         // ---------------------------------------------------------------------------
 
         Bool RunBaseVertexLoop(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                               GLsizei drawcount, const GLint* basevertex, Bool feedDrawID, Bool feedBaseVertex) {
+                               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));
-                if (feedBaseVertex) SetCurrentBaseVertex(basevertex ? basevertex[i] : 0);
-                ForEachViewportRoutingPass([&] {
-                    g_GLESFuncs.glDrawElementsBaseVertex(mode, count[i], type, indices[i],
-                                                         basevertex ? basevertex[i] : 0);
-                });
+                g_GLESFuncs.glDrawElementsBaseVertex(mode, count[i], type, indices[i],
+                                                     basevertex ? basevertex[i] : 0);
             }
             if (feedDrawID) SetCurrentDrawID(0);
-            if (feedBaseVertex) SetCurrentBaseVertex(0);
             NoteTierExecuted(GLESMultiDrawMode::BaseVertex);
             return true;
         }
@@ -490,8 +446,7 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
         // ---------------------------------------------------------------------------
 
         Bool RunRebasedDrawElements(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                                    GLsizei drawcount, const GLint* basevertex, Bool feedDrawID,
-                                    Bool feedBaseVertex) {
+                                    GLsizei drawcount, const GLint* basevertex, Bool feedDrawID) {
             const SizeT indexSize = IndexTypeSize(type);
             if (indexSize == 0) return false;
 
@@ -516,16 +471,6 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
 
             const Bool restartActive = RestartActive();
             const Uint32 restartSentinel = RestartSentinelFor(type);
-            // Widening to GL_UNSIGNED_INT gives a UBYTE/USHORT source a sentinel it can never
-            // spell, so those batches are lossless. A UINT source that already uses 0xFFFFFFFF as
-            // a real vertex index while restarting on a different one is the one shape 32 bits
-            // cannot express - the same corner the single-draw substitution reports.
-            if (restartActive && indexSize == 4 && restartSentinel != 0xFFFFFFFFu) {
-                MGLOG_E_ONCE("GL_PRIMITIVE_RESTART with restart index %u over GL_UNSIGNED_INT multi-draw indices: "
-                             "any index that is already 0xFFFFFFFF will restart too, because the rewritten stream "
-                             "has no wider sentinel to move to.",
-                             restartSentinel);
-            }
             g_indexStaging.resize(total);
             SizeT cursor = 0;
             for (GLsizei i = 0; i < drawcount; ++i) {
@@ -534,7 +479,7 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
                 const Uint8* source = ResolveSubDrawIndices(indexBuffer, indexBufferBytes, indexBufferSize, indices[i],
                                                             subDrawCount, indexSize);
                 if (!source) {
-                    MGLOG_E_ONCE("DirectGLES multi-draw (drawelements tier): sub-draw %d reads outside the bound index "
+                    MGLOG_E("DirectGLES multi-draw (drawelements tier): sub-draw %d reads outside the bound index "
                             "buffer; skipping the batch",
                             i);
                     return false;
@@ -545,8 +490,7 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
             }
 
             SizeT indexBase = 0;
-            if (!UploadScratchRing(g_rebasedIndices, total * sizeof(Uint32), g_indexStaging.data(),
-                                   MG_Util::PipeStats::ByteClass::StageIndexClient, indexBase)) {
+            if (!UploadScratchRing(g_rebasedIndices, total * sizeof(Uint32), g_indexStaging.data(), indexBase)) {
                 return false;
             }
 
@@ -556,18 +500,11 @@ namespace MobileGL::MG_Backend::DirectGLES::MultiDrawImpl {
             for (GLsizei i = 0; i < drawcount; ++i) {
                 if (count[i] <= 0) continue;
                 if (feedDrawID) SetCurrentDrawID(static_cast<Uint32>(i));
-                // The base vertex is folded into the rewritten index stream here, so the
-                // driver sees none - but gl_BaseVertex still has to report the value the
-                // application passed for this sub-draw.
-                if (feedBaseVertex) SetCurrentBaseVertex(basevertex ? basevertex[i] : 0);
-                ForEachViewportRoutingPass([&] {
-                    g_GLESFuncs.glDrawElements(mode, count[i], GL_UNSIGNED_INT,
-                                               reinterpret_cast<const void*>(indexBase + cursor * sizeof(Uint32)));
-                });
+                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);
-            if (feedBaseVertex) SetCurrentBaseVertex(0);
             BufferImpl::BindBufferId(GL_ELEMENT_ARRAY_BUFFER, previousIndexBinding);
             NoteTierExecuted(GLESMultiDrawMode::DrawElements);
             return true;
@@ -643,7 +580,7 @@ void main() {
 
             const GLuint shader = g_GLESFuncs.glCreateShader(GL_COMPUTE_SHADER);
             if (shader == 0) {
-                MGLOG_E_ONCE("DirectGLES multi-draw (compute tier): glCreateShader(GL_COMPUTE_SHADER) failed");
+                MGLOG_E("DirectGLES multi-draw (compute tier): glCreateShader(GL_COMPUTE_SHADER) failed");
                 return false;
             }
             const char* source = kFlattenComputeSource;
@@ -654,14 +591,14 @@ void main() {
             if (status != GL_TRUE) {
                 char log[1024] = {};
                 g_GLESFuncs.glGetShaderInfoLog(shader, sizeof(log) - 1, nullptr, log);
-                MGLOG_E_ONCE("DirectGLES multi-draw (compute tier): index-flattening shader failed to compile: %s", 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_ONCE("DirectGLES multi-draw (compute tier): glCreateProgram failed");
+                MGLOG_E("DirectGLES multi-draw (compute tier): glCreateProgram failed");
                 g_GLESFuncs.glDeleteShader(shader);
                 return false;
             }
@@ -672,7 +609,7 @@ void main() {
             if (status != GL_TRUE) {
                 char log[1024] = {};
                 g_GLESFuncs.glGetProgramInfoLog(program, sizeof(log) - 1, nullptr, log);
-                MGLOG_E_ONCE("DirectGLES multi-draw (compute tier): index-flattening program failed to link: %s", log);
+                MGLOG_E("DirectGLES multi-draw (compute tier): index-flattening program failed to link: %s", log);
                 g_GLESFuncs.glDeleteProgram(program);
                 return false;
             }
@@ -682,7 +619,7 @@ void main() {
             g_uDrawCount = g_GLESFuncs.glGetUniformLocation(program, "uDrawCount");
             g_uTotalIndices = g_GLESFuncs.glGetUniformLocation(program, "uTotalIndices");
             g_computeProgramFailed = false;
-            MGLOG_D("DirectGLES multi-draw: index-flattening compute program ready (id %u)", program);
+            MGLOG_I("DirectGLES multi-draw: index-flattening compute program ready (id %u)", program);
             return true;
         }
 
@@ -751,16 +688,10 @@ void main() {
             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(),
-                               MG_Util::PipeStats::ByteClass::StageIndirectCmd)) {
-                return;
-            }
-            // data == nullptr: pure respecify, the compute pass writes the contents, so no
-            // host bytes cross here and nothing is counted.
-            if (!UploadScratch(g_flattenedIndices, total * sizeof(Uint32), nullptr,
-                               MG_Util::PipeStats::ByteClass::StageIndexClient)) {
+            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);
@@ -897,14 +828,8 @@ void main() {
     void DrawElementsBatch(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
                            GLsizei drawcount, const GLint* basevertex) {
         if (drawcount <= 0 || !count || !indices) return;
-        // Read before any GL work, because it decides the tier below: a desktop restart index
-        // the driver does not know about can only be honoured by the tier that rewrites the
-        // index stream (see ResolveTierForBatch). A restart index this index type cannot hold
-        // needs no rewrite at all - nothing can match it - but it does need the driver's own
-        // fixed-index restart held off for the batch, which is what the scope below does.
-        const RestartSubstitutionKind restartKind = ResolveRestartSubstitution(type);
-        const Bool arbitraryRestart = restartKind == RestartSubstitutionKind::RewriteIndices;
-        const ScopedSuppressedPrimitiveRestart restartCapOverride(restartKind);
+        // State-independent and possibly throwing, so it runs before any GL work.
+        CheckPrimitiveRestartSupported(type);
 
         const Bool hasIndexBuffer = BoundIndexBuffer() != nullptr;
 
@@ -912,15 +837,8 @@ void main() {
         // 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.
-        // A batch whose sub-draws carry their own base vertices cannot be flattened either
-        // when the program reads gl_BaseVertex: one draw call leaves one uniform value.
-        // Asked conservatively because this decision precedes PrepareForDraw - see
-        // CurrentProgramMayNeedPerSubDrawBuiltins. Flattening is the irreversible half:
-        // once the batch is one draw the values are gone, whereas declining to flatten only
-        // costs the unrolled tier.
         FlattenedStream flattened;
-        if (ResolvedTier() == GLESMultiDrawMode::Compute &&
-            !CurrentProgramMayNeedPerSubDrawBuiltins(basevertex != nullptr)) {
+        if (ResolvedTier() == GLESMultiDrawMode::Compute && !CurrentProgramReadsDrawID()) {
             FlattenWithCompute(mode, count, type, indices, drawcount, basevertex, flattened);
         }
 
@@ -929,19 +847,13 @@ void main() {
         if (flattened.indexCount != 0) {
             const Uint previousIndexBinding = BoundIndexBufferId();
             BufferImpl::BindBufferId(GL_ELEMENT_ARRAY_BUFFER, flattened.bufferId);
-            ForEachViewportRoutingPass([&] {
-                g_GLESFuncs.glDrawElements(mode, static_cast<GLsizei>(flattened.indexCount), GL_UNSIGNED_INT, nullptr);
-            });
+            g_GLESFuncs.glDrawElements(mode, static_cast<GLsizei>(flattened.indexCount), GL_UNSIGNED_INT, nullptr);
             BufferImpl::BindBufferId(GL_ELEMENT_ARRAY_BUFFER, previousIndexBinding);
             return;
         }
 
-        // Now that PrepareForDraw has synced the program, both questions have real answers;
-        // the tier choice and the per-sub-draw feeds use those, not the guess above.
         const Bool feedDrawID = CurrentProgramReadsDrawID();
-        const Bool feedBaseVertex = basevertex != nullptr && CurrentProgramReadsBaseVertex();
-        const GLESMultiDrawMode tier =
-            ResolveTierForBatch(feedDrawID, feedBaseVertex, hasIndexBuffer, arbitraryRestart);
+        const GLESMultiDrawMode tier = ResolveTierForBatch(feedDrawID, hasIndexBuffer);
 
         Bool drawn = false;
         switch (tier) {
@@ -949,19 +861,16 @@ void main() {
             drawn = RunExt(mode, count, type, indices, drawcount, basevertex);
             break;
         case GLESMultiDrawMode::MultiIndirect:
-            drawn = RunIndirect(mode, count, type, indices, drawcount, basevertex, /*batched=*/true, feedDrawID,
-                                feedBaseVertex);
+            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,
-                                feedBaseVertex);
+            drawn = RunIndirect(mode, count, type, indices, drawcount, basevertex, /*batched=*/false, feedDrawID);
             break;
         case GLESMultiDrawMode::BaseVertex:
-            drawn = RunBaseVertexLoop(mode, count, type, indices, drawcount, basevertex, feedDrawID, feedBaseVertex);
+            drawn = RunBaseVertexLoop(mode, count, type, indices, drawcount, basevertex, feedDrawID);
             break;
         case GLESMultiDrawMode::DrawElements:
-            drawn = RunRebasedDrawElements(mode, count, type, indices, drawcount, basevertex, feedDrawID,
-                                           feedBaseVertex);
+            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.
@@ -973,18 +882,11 @@ void main() {
         // 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 - except that the base-vertex replay hands the
-        // application's own indices to the driver, which cannot restart on a desktop
-        // restart index, so that batch has only the rewriting floor.
-        if (!drawn && !arbitraryRestart) {
-            drawn = RunBaseVertexLoop(mode, count, type, indices, drawcount, basevertex, feedDrawID, feedBaseVertex);
-        }
+        // 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) {
-            drawn = RunRebasedDrawElements(mode, count, type, indices, drawcount, basevertex, feedDrawID,
-                                           feedBaseVertex);
-        }
-        if (!drawn) {
-            MGLOG_E_ONCE("DirectGLES multi-draw: no usable tier for a %d sub-draw batch (mode 0x%x, type 0x%x); "
+            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);
         }

MobileGL/MG_Backend/DirectGLES/Utils.h

@@ -46,15 +46,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         Flags<PixelFormatNormalizeOptionBit> GetRenderTargetNormalizeOptions(
             const MG_External::GLESCapabilities& capabilities, SizeT targetIndex);
 
-        // Whether this format's ES storage is widened to 8-bit-per-channel because the
-        // driver stores some packed16 allocations with a mirrored field order
-        // (PixelFormatNormalizeOptionBit::WidenPacked16Norm). True only for
-        // GL_RGB565/GL_RGB5(_A1)/GL_RGBA4, and only where the POST probe measured the
-        // divergence (or MOBILEGL_ESPRYT_WIDEN_PACKED16_STORAGE forces it). The transfer paths
-        // consult it too: the packed-norm re-upload leg must stand down when the ES storage
-        // is no longer 16-bit packed.
-        Bool UsesWidenedPacked16NormStorage(TextureInternalFormat internalFormat);
-
         void GenerateTextureFormatInfo(TextureInternalFormat internalFormat, GLenum* outInternalFormat,
                                        GLenum* outFormat, GLenum* outType,
                                        TextureTarget target = TextureTarget::Unknown);
@@ -69,115 +60,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         Bool BackendTextureFormatAddsAlpha(TextureInternalFormat internalFormat, TextureTarget target);
         Bool BackendRenderbufferFormatAddsAlpha(TextureInternalFormat internalFormat);
         Bool ShouldUseCaveatRenderbufferFormat(TextureInternalFormat internalFormat);
-
-        // The CHANNEL WIDENING an image-bindable texture's ES storage takes, so that a format
-        // GLSL ES cannot spell as an image is carried by one it can.
-        //
-        // GL has forty image formats, GLSL ES core has thirteen, and no test device advertises
-        // GL_NV_image_formats - so a shader declaring one of the other twenty-six has no legal
-        // ESSL at all and glBindImageTexture rejects the narrow format outright for most of them
-        // (GL_INVALID_VALUE for nineteen of twenty-six on Adreno, twenty-five on both Malis).
-        // Seventeen have a core format of the SAME per-channel width and component type,
-        // differing only in channel count, and in one of those the emulation is EXACT: GL already
-        // defines an imageLoad from a narrower format as (r, 0, 0, 1) and an imageStore as
-        // dropping the components the format does not have, so the carrier's surplus channels
-        // hold values GL has already named. WidenImageFormatsPass pins them in the shader; this
-        // is the storage half, and DirectGLES::TextureImpl::SyncImageTextureBinding the bind
-        // half. All three ask WidenedCoreEsslImageFormat, so they cannot pick different carriers.
-        //
-        // Reports nothing (InternalFormat == GL_UNKNOWN_MGL) for a format that is core already,
-        // for the nine with no exact carrier (r11f_g11f_b10f, rgb10_a2, rgb10_a2ui, rgba16, rg16,
-        // r16, rgba16_snorm, rg16_snorm, r16_snorm - those keep the honest "no GLSL ES spelling"
-        // diagnostic rather than a silent approximation), and on a driver that HAS
-        // GL_NV_image_formats, where the shader keeps the declared format and no widening may
-        // happen behind it.
-        //
-        // The widened triple REPLACES what GenerateTextureFormatInfo chose, including any
-        // renderability substitution: an image that cannot be image-bound is useless whatever its
-        // attachment behaviour, so the image constraint wins. In practice that only bites
-        // RG8_SNORM/R8_SNORM on a driver without EXT_render_snorm, where the storage stays
-        // signed-normalized instead of becoming the half float that fallback would have picked -
-        // so an image-bound texture in one of those two formats is no longer attachable, and
-        // glGetTexImage on it falls through to the CPU shadow, which a shader-side imageStore
-        // does not update. Accepted deliberately: before the widening, an image binding in either
-        // format was refused outright by every driver tested and the stage that declared it never
-        // compiled at all, so nothing that works today is being given up.
-        //
-        // KNOWN GAP, for the same "all three layers move together" reason: a widened texture that
-        // is ALSO an FBO colour attachment gains one to three writable channels, and a draw into
-        // it can leave values in channels GL says are 0 and 1. Sampling and imageLoad are covered
-        // (the swizzle composition in SyncTextureParamsToBackend and the shader-side mask), but a
-        // glReadPixels/glGetTexImage that asks for more channels than the frontend format has
-        // would see them. Closing it needs the per-draw-buffer colour mask the three-channel
-        // widening already carries (FramebufferImpl::g_alphaWidenedDrawBufferMask) generalized
-        // from "alpha" to a channel count, which is its own change.
-        // How the FRONTEND's CPU shadow for a widened format is laid out relative to the carrier's
-        // transfer, i.e. what the upload has to do to it. Almost every entry is `Components`: the
-        // shadow already holds SourceChannels components of exactly the carrier's own type, so
-        // padding it out to four is the whole conversion. The packed entries do not - their shadow
-        // is ONE 32-bit word per texel - and reading such a word as components of the carrier's
-        // type takes twelve or sixteen bytes out of four and shears the level.
-        enum class ImageWidenSourceEncoding : Uint8 {
-            Components = 0,
-            // r11f_g11f_b10f: GL_UNSIGNED_INT_10F_11F_11F_REV -> four GL_FLOATs of an rgba16f.
-            PackedFloat11f11f10f,
-            // rgb10_a2 and rgb10_a2ui: GL_UNSIGNED_INT_2_10_10_10_REV -> four GL_UNSIGNED_SHORT
-            // channel CODES of an rgba16ui. The same split serves both: the two formats differ
-            // only in what the codes MEAN, which is the shader's business and not the transfer's.
-            PackedInt2101010Rev,
-        };
-
-        struct ImageBindableStorageWidening {
-            GLenum InternalFormat = GL_UNKNOWN_MGL;
-            GLenum Format = GL_UNKNOWN_MGL;
-            GLenum Type = GL_UNKNOWN_MGL;
-            // Channels the FRONTEND format has, i.e. how many of the carrier's four the client
-            // data fills. The rest are uploaded as 0, and the fourth as the format's implied 1.
-            Uint SourceChannels = 0;
-            // Whether that implied 1 is the integer one or a saturated normalized field - the
-            // transfer type cannot tell the two apart (GL_UNSIGNED_BYTE serves both RG8 and
-            // RG8UI), so the carrier decides.
-            Bool IntegerData = false;
-            // What the upload has to do to the frontend shadow before it describes the level to
-            // the driver (PrepareImageWidenedUpload).
-            ImageWidenSourceEncoding SourceEncoding = ImageWidenSourceEncoding::Components;
-            // Non-zero when the carrier holds this format's channels as the INTEGER CODES of a
-            // NORMALIZED value - the seven 16-bit and 10-bit normalized formats, which core ESSL
-            // has no image format of any width for and which a float carrier would requantise.
-            // Each entry is the largest code that channel can hold, i.e. the denominator of GL 4.6
-            // 2.3.5; SignedNormalized picks which of the two conversions it is the denominator of.
-            //
-            // Two things depend on it, both because the ES storage no longer shares the frontend
-            // format's component class: the upload pads a missing alpha with ChannelMax[3] instead
-            // of the transfer type's own "one" (through a uint carrier the saturated field IS the
-            // one), and glGetTexImage divides the codes back out into the floats the application
-            // is still owed.
-            Uint ChannelMax[4] = {0u, 0u, 0u, 0u};
-            Bool SignedNormalized = false;
-
-            Bool CarriesNormalizedCodes() const { return ChannelMax[0] != 0u; }
-            explicit operator Bool() const { return InternalFormat != GL_UNKNOWN_MGL; }
-        };
-        ImageBindableStorageWidening GetImageBindableStorageWidening(TextureInternalFormat internalFormat);
-
-        // The single-channel core format an image-bindable BUFFER texture's view is SPLIT into, or
-        // GL_UNKNOWN_MGL for a format that needs no split (or has no core base).
-        //
-        // A buffer texture cannot be widened: its texels are the application's buffer object, at
-        // the size and layout the application gave it, and it is usually also a vertex, index or
-        // storage buffer whose bytes are not ours to restride. But an rg32f view of N texels and
-        // an r32f view of 2N texels describe exactly the SAME bytes, so the split changes only
-        // how the shader subscripts them - component j of texel i is texel 2i + j of the base
-        // view - which WidenImageFormatsPass rewrites every access to do. The same rule as the
-        // widening decides WHETHER: a driver that can spell rg32f for an imageBuffer needs
-        // nothing.
-        //
-        // KNOWN GAP, and the reason this is not applied to a texture that is merely sampled: a
-        // buffer texture that is BOTH image-bound and read through a samplerBuffer would have its
-        // sampled view split too, and the sampler side is not rewritten. Accepted for the same
-        // reason the storage widening's gaps are - on a driver where the split applies at all
-        // there is no legal ESSL for the image declaration, so such a program did not compile.
-        GLenum GetImageBindableBufferSplitFormat(TextureInternalFormat internalFormat);
     } // namespace TextureImpl
 
     namespace FramebufferImpl {} // namespace FramebufferImpl
@@ -233,16 +115,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         Bool StoreWideRowsToClient(const Uint8* wide, GLenum wideType, GLsizei width, GLsizei sliceHeight,
                                    GLsizei sliceCount, const ReadbackChannelMapping& mapping, GLenum type,
                                    void* pixels, Bool applyPackImageParams);
-
-        // Stores packed 32-bit source words verbatim, with the same destination addressing, PACK
-        // parameters and pixel-pack-buffer handling as StoreWideRowsToClient. For the sources whose
-        // storage word already IS the client word (MG_Util::IsRawPackedPixelTransfer): routing those
-        // through the wide float intermediate re-encodes them, and the RGB9_E5 encoder canonicalizes
-        // the shared exponent, so glGetTexImage would answer with different bits than were stored.
-        // `srcWords` holds sliceHeight * sliceCount tightly stacked rows of `width` 32-bit words.
-        // False when `type` is not a 4-byte packed type.
-        Bool StorePackedWordsToClient(const Uint8* srcWords, GLsizei width, GLsizei sliceHeight, GLsizei sliceCount,
-                                      GLenum type, void* pixels, Bool applyPackImageParams);
     } // namespace ReadbackImpl
 
     namespace PrgramImpl {
@@ -258,265 +130,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         // drawBufferCount <= 1, i.e. for everything but a framebuffer that actually
         // enables several draw buffers, so the ordinary single-target shader is untouched.
         String BroadcastLegacyFragColor(String glslCode, GLenum shaderType, Uint drawBufferCount);
-        // SPIRV-Cross emits `#extension GL_EXT_texture_buffer : require` for every buffer-texture
-        // sampler when it targets ESSL below 320, and offers no way to ask for the OES spelling.
-        // On a driver that advertises only GL_OES_texture_buffer that directive is a compile
-        // error, so the name is retargeted in the emitted source. A no-op on every other tier:
-        // ES 3.2 needs no directive at all and an EXT driver already has the right one.
-        String RetargetTextureBufferExtension(String glslCode,
-                                              MG_External::GLESCapabilities::TextureBufferTier tier);
-        // Adds `#extension GL_NV_image_formats : require` when the shader carries an image
-        // format qualifier GLSL ES has no core spelling for. SPIRV-Cross prints the format and
-        // asks for nothing, so the request has to be made here. `needed` is the caller's answer,
-        // because only it knows which formats are in play AND whether the driver advertises the
-        // extension - requesting an unadvertised extension is itself a compile error, so this is
-        // never emitted speculatively. A no-op when not needed or already present.
-        String RequestExtendedImageFormats(String glslCode, Bool needed);
-        // Adds `#extension GL_OES_viewport_array : require` when the emitted ESSL names
-        // gl_ViewportIndex. SPIRV-Cross prints that identifier and asks for nothing (unlike
-        // gl_Layer, which it backs with GL_NV_viewport_array2 on ES) and ESSL has no core
-        // spelling for it at any version, so the request has to be made here or the stage does
-        // not compile - which loses the whole program, not just the multi-viewport routing.
-        // `needed` is the caller's answer for the same reason as above: only it knows whether the
-        // driver advertises the extension, and requesting an unadvertised one is itself a compile
-        // error, so this is never emitted speculatively. A no-op when not needed or already
-        // present.
-        String RequestViewportArrayExtension(String glslCode, Bool needed);
-        // Adds `#extension <extensionName> : require` when a TESSELLATION or GEOMETRY stage's
-        // emitted ESSL names gl_PointSize. Desktop GL has that built-in in gl_PerVertex for every
-        // vertex-processing stage; ESSL does NOT have it in those two at any version - not even
-        // 320, where the stages themselves are core - until EXT/OES_tessellation_point_size resp.
-        // EXT/OES_geometry_point_size is requested. SPIRV-Cross prints the identifier bare and
-        // asks for nothing, exactly as it does for gl_ViewportIndex, so without this the stage
-        // fails to compile with "`gl_PointSize' undeclared" and the WHOLE program is replaced by
-        // program 0 - the draw renders nothing and any transform-feedback capture it was carrying
-        // is rejected outright. `extensionName` is the caller's answer, nullptr when the driver
-        // advertises neither spelling, because requesting an unadvertised extension is itself a
-        // compile error. A no-op when nullptr or already present.
-        String RequestPointSizeExtension(String glslCode, const char* extensionName);
-        // The extension name RequestPointSizeExtension should be given for `tier`, or nullptr for
-        // PointSizeTier::None. `tessellation` picks the tessellation spellings over the geometry
-        // ones; the two extensions are separate and neither implies the other.
-        const char* PointSizeExtensionName(MG_External::GLESCapabilities::PointSizeTier tier, Bool tessellation);
-        // Writes a format layout qualifier into the image declarations named in
-        // `esslFormatByUniformName` that still have none. The completion half of the image-format
-        // bake, and ONLY that: the SPIR-V pass (BakeImageFormatsPass) is what normally puts the
-        // format in, but SPIRV-Cross throws rather than printing the formats it calls
-        // desktop-only when it targets ESSL - r8ui among them, which is what the stencil half of
-        // KHR-GL4x.packed_depth_stencil.stencil_texturing binds - and a throw loses the whole
-        // stage. So those formats stay out of the module and are spelled here instead, on the
-        // emitted text, where nothing can refuse them.
-        //
-        // Declarations that already carry a format are left exactly as they are, whoever wrote
-        // it. Must run before RemoveLayoutBinding, which is where an image's layout qualifier
-        // stops being safe to edit by hand.
-        String BakeImageFormatQualifiers(String glslCode, const UnorderedMap<String, String>& esslFormatByUniformName);
         String RemoveLayoutBinding(const String& glslCode);
-        // Prefix of the per-element scalar declarations RemapImageArrayElementUnits splits an
-        // image array into; the suffix is the array's own name and the element's index.
-        constexpr const char* IMAGE_ARRAY_ELEMENT_PREFIX = "mg_imageElem_";
-        // One image ARRAY whose elements the application pointed at units that are not
-        // consecutive-from-element-zero.
-        struct ImageArrayUnitPlan {
-            String name;       // the array's name, exactly as the emitted ESSL declares it
-            Vector<Int> units; // the frontend image unit element k has to reach
-        };
-        // Desktop GL lets an application give each element of an image array an ARBITRARY unit
-        // (glUniform1i per element). ES has no such call at all - "ES image units come
-        // exclusively from the layout(binding=N) qualifier" - and one declaration carries one
-        // binding, so ESSL nails an array's elements to the CONSECUTIVE units N, N+1, N+2, ...
-        // MobileGL used to stamp element [0]'s unit as the binding and let the rest fall where
-        // they fell: KHR-GL4x.shader_image_load_store.advanced-sso-simple assigns 0,2,4,6 and
-        // 1,3,5,7, so its two programs actually addressed 0,1,2,3 and 1,2,3,4 - one layer got the
-        // wrong value and three were never written, with no GL error and no link log. The same
-        // defect for SAMPLER arrays was fixed API-side (SubscriptUniformNameForElement); an image
-        // array has no API side to fix, because ES makes glUniform1i on an image uniform an
-        // INVALID_OPERATION.
-        //
-        // Repaired by SPLITTING the array into one SCALAR image uniform per element, each with
-        // its own layout(binding = N), and rewriting `name[k]` to the scalar declared for
-        // element k. One declaration carries one binding, so one declaration per unit is the
-        // only spelling that reaches an arbitrary set of them.
-        //
-        // That rewrite needs every k in the emitted text to be a LITERAL, and it is:
-        // LegalizeResourceArrayIndexingForEssl has already folded or lowered every dynamic
-        // image-array subscript in the module, because ESSL forbids one outright ("image arrays
-        // indexed with non-constant expressions are forbidden in GLSL ES", Mesa 26.1.4 at
-        // ES 3.2, on a raw GLES probe with no MobileGL in the loop). The earlier shape here -
-        // widening the array to cover the whole span of units and routing each subscript through
-        // a `const highp int` offset table - was written before that pass covered images, and
-        // the table lookup was itself one of the non-constant expressions the same probe refuses.
-        // The split also costs exactly the image uniforms the application declared, where the
-        // widening cost the whole SPAN (seven for the four elements of
-        // KHR-GL42.shader_image_load_store.advanced-sso-simple), so there is no budget for it to
-        // fail to fit in.
-        //
-        // Declines - leaving the array exactly as it was, and naming it in `outDeclined` for the
-        // caller to report - when the emitted extent disagrees with the reflection, when the
-        // array is reached by anything other than a subscript, or when a subscript is not a
-        // literal element index. Silence was the whole defect here, so a decline must be audible.
-        //
-        // Must run AFTER RebindImageUniformsToFrontendUnits and BakeImageFormatQualifiers (both
-        // key on the GL uniform name and on a binding already being stamped) and BEFORE
-        // SplitReadWriteImageUniforms (so each element that is both read and written is split
-        // with its own binding already on it) and RemoveLayoutBinding (which is what preserves
-        // image bindings). Like them, it is downstream of the L2 shader-translation memo, so the
-        // per-program units it reads need no entry in BuildEsslTranslationKey.
-        String RemapImageArrayElementUnits(const String& glslCode, const Vector<ImageArrayUnitPlan>& plans,
-                                           Vector<String>* outDeclined = nullptr);
-        // The member list of a `gl_PerVertex { ... }` redeclaration in already-emitted ESSL -
-        // the text between the braces, verbatim - or nullopt when the shader does not redeclare
-        // the block in that direction. `input` selects the `in gl_PerVertex` form over the
-        // `out` one.
-        //
-        // Exists so BuildPassthroughTessControlEssl can MIRROR the stages it has to sit between
-        // rather than guess at them. Whether SPIRV-Cross redeclares the built-in block, and with
-        // which members, depends on what the application's shader touched; a synthesized stage
-        // that redeclares a different shape than its neighbours is an ES link error against a
-        // program that has no other problem.
-        std::optional<String> ExtractPerVertexBlockMembers(const String& essl, Bool input);
-        // The pass-through tessellation control stage GL 4.6 core 11.2.2 describes: "the input
-        // patch is passed through unmodified", the output patch has PATCH_VERTICES vertices, and
-        // the levels come from the PATCH_DEFAULT_OUTER_LEVEL / PATCH_DEFAULT_INNER_LEVEL state.
-        //
-        // Desktop GL makes the control stage OPTIONAL. OpenGL ES 3.2 does not: it has no
-        // PATCH_DEFAULT_*_LEVEL state at all (only glPatchParameteri, for PATCH_VERTICES) and
-        // rejects a program that has an evaluation stage without a control stage - with an EMPTY
-        // info log, verified on an Adreno 830 with no MobileGL in the process. MobileGL's own
-        // frontend link succeeds, so the program reports GL_LINK_STATUS = TRUE, program 0 is
-        // bound in its place, and every draw silently renders nothing.
-        //
-        // `inPerVertexMembers` / `outPerVertexMembers` are the member lists to redeclare gl_in
-        // and gl_out with - normally taken from the neighbouring stages' own emitted ESSL via
-        // ExtractPerVertexBlockMembers, and empty to leave the driver's built-in declaration
-        // alone, which is what matching a neighbour that did not redeclare requires.
-        //
-        // All four outer levels and both inner levels are written unconditionally: writing a
-        // level the evaluation stage's domain does not use is legal and ignored, and it saves
-        // this from having to know the domain. They are the GL_PATCH_DEFAULT_OUTER_LEVEL /
-        // GL_PATCH_DEFAULT_INNER_LEVEL state, baked in as literals - ES has no such state and no
-        // glPatchParameterfv to forward to, so compiling them in is the only way to honour them.
-        // That makes them part of what a built program is stale against, exactly as PATCH_VERTICES
-        // is: see the staleness clause in DirectGLES.cpp's SyncCurrentProgram, which compares both.
-        //
-        // The same stage, for the same reason, that DirectVulkan synthesizes in
-        // ProgramFactory::BuildPassthroughTessControlSource - Vulkan likewise requires both
-        // tessellation stages. Kept as two generators rather than one because the two targets
-        // disagree on everything but the algorithm: desktop GLSL 450 against ESSL, a fixed
-        // gl_PerVertex shape that Vulkan matches structurally against a mirrored one, and a
-        // VkShaderModule against a driver shader object.
-        String BuildPassthroughTessControlEssl(Uint esslVersion, Uint patchVertices,
-                                               const String& inPerVertexMembers,
-                                               const String& outPerVertexMembers,
-                                               const FloatVec4& defaultOuterLevel,
-                                               const FloatVec2& defaultInnerLevel);
-        // Prefix of the writeonly half a read+write image uniform is split into (see
-        // SplitReadWriteImageUniforms); the suffix is the image's own (already access-tagged) name.
-        constexpr const char* IMAGE_WRITE_ALIAS_PREFIX = "mg_imageWrite_";
-        // The three names SplitReadWriteImageUniforms renames a rewritten image declaration
-        // under, one per REPAIR it can apply. Which one a stage picks is decided by that stage's
-        // own accesses, so two stages that use an image the same way arrive at the SAME name and
-        // two that use it differently arrive at different ones - which is exactly the property
-        // the rename exists for, at no cost to the stages that agree. Exposed for the tests.
-        constexpr const char* IMAGE_READONLY_ALIAS_PREFIX = "mg_imageRo_";
-        constexpr const char* IMAGE_WRITEONLY_ALIAS_PREFIX = "mg_imageWo_";
-        constexpr const char* IMAGE_SPLIT_READ_ALIAS_PREFIX = "mg_imageRw_";
-        // ESSL refuses an image variable that carries a format qualifier other than r32f /
-        // r32i / r32ui unless it also carries `readonly` or `writeonly` (GLSL ES 3.10 4.9 /
-        // 3.20 4.10; glslang enforces it verbatim in ParseHelper.cpp's layoutObjectCheck).
-        // SPIRV-Cross emits NEITHER for an image the shader both reads and writes: it
-        // speculatively decorates every storage image NonWritable+NonReadable
-        // (fixup_image_load_store_access), then OpImageRead clears NonReadable and
-        // OpImageWrite clears NonWritable, and to_qualifiers_glsl only prints `readonly`
-        // from NonWritable and `writeonly` from NonReadable. Desktop GLSL is happy with the
-        // bare declaration, so the frontend raises no error and the illegal ESSL only shows
-        // up as a device compile failure - and then as a silently no-op draw.
-        //
-        // Restores a legal declaration, and RENAMES it after the repair it applied while doing so:
-        //  * loaded only            -> add `readonly`, rename under IMAGE_READONLY_ALIAS_PREFIX
-        //  * stored only            -> add `writeonly`, rename under IMAGE_WRITEONLY_ALIAS_PREFIX
-        //  * both                   -> emit TWO declarations on the same binding and of the
-        //                              same type, `coherent readonly
-        //                              <IMAGE_SPLIT_READ_ALIAS_PREFIX><name>` and `coherent
-        //                              writeonly <IMAGE_WRITE_ALIAS_PREFIX><that name>`, point
-        //                              every imageStore at the second one, and follow each of
-        //                              those stores with `memoryBarrierImage();`. Several image
-        //                              variables may share an image unit as long as they have
-        //                              the same type and format, which is exactly what the pair
-        //                              is.
-        //
-        // The rename is the other half of the repair and applies to all three cases. The qualifier
-        // chosen above is a decision about ONE STAGE's accesses, and GLSL requires a uniform
-        // declared in two stages to be declared identically - so a shader that stores an image from
-        // the vertex stage and loads it from the fragment stage came out of here `writeonly` in one
-        // and `readonly` in the other. Adreno merges the two same-named declarations and silently
-        // drops the vertex-stage STORES: no GL error, no link log, LINK_STATUS = 1, and the image
-        // still reads back its initial contents
-        // (KHR-GL4x.shader_image_load_store.advanced-memory-dependentInvocation; a raw-ES probe
-        // isolated the trigger to the same-name/mismatched-qualifier pair, and only when both
-        // carry `coherent`). Renaming leaves no cross-stage variable to merge.
-        //
-        // The name is keyed on the REPAIR, not on the stage, and that distinction is the whole
-        // point: two stages that use an image the same way emit byte-identical declarations, so
-        // letting them keep one shared name costs nothing and merging them is correct, while two
-        // stages that use it differently land on different prefixes and cannot be merged at all.
-        // A per-STAGE tag also satisfied the first requirement but violated the second: it made
-        // the SAME image a distinct uniform in every stage that named it, and Adreno allocates
-        // image LOCATIONS per distinct uniform. KHR-GL43.shading_language_420pack.
-        // binding_images_texture_type_* declares three read+write images in each of its five
-        // stages; merged that is 6 image uniforms, per-stage-tagged it is 30, and the Adreno 830
-        // linker answered "Error: Image Image location or component exceeds max allowed. Error:
-        // Linking failed." - which, the frontend having already published LINK_STATUS = TRUE from
-        // glslang's link, surfaced only as every draw silently doing nothing and the images
-        // reading back zero. Mali and Mesa link the same text, so nothing but a device gate
-        // catches this.
-        //
-        // A declaration SPIRV-Cross already tagged `readonly` or `writeonly` needs no qualifier
-        // repair, but it is NOT stage-independent: that tag is derived from the accesses of the
-        // stage being emitted, so an image stored in the vertex stage and loaded in the fragment
-        // stage arrives here as `coherent writeonly g_image` and `coherent readonly g_image` -
-        // one name, two spellings, which is exactly the pair Adreno merges. Those declarations
-        // are therefore renamed too, keyed on the qualifier they already carry (readonly ->
-        // IMAGE_READONLY_ALIAS_PREFIX, writeonly -> IMAGE_WRITEONLY_ALIAS_PREFIX) and with
-        // nothing but the identifier changed. Stages that agree still reach the same alias and
-        // stay merged, so this costs no shader an extra image uniform.
-        //
-        // The declarations this pass still leaves untouched keep their names: one carrying BOTH
-        // readonly and writeonly (a spelling no access analysis produces, so it came from the
-        // application and is identical everywhere), and one carrying NEITHER, which is legal only
-        // for the r32f/r32i/r32ui formats and is likewise spelled the same in every stage.
-        //
-        // The `coherent` on both halves of the pair is load-bearing, not decoration: GLSL only
-        // guarantees a write through one image variable is visible to a read through a DIFFERENT
-        // one when both are coherent, and the split is what makes a same-variable
-        // read-after-write cross-variable. The single-declaration repairs above do not get it -
-        // nothing aliases them.
-        //
-        // The barrier is the other half of the same problem, and coherent alone did not cover it:
-        // visibility is not ORDER. Within one invocation the ES compiler sees a write to one
-        // variable and a read of another it has no reason to believe alias, and is free to serve
-        // the read from before the write - which is what advanced-memory-order's store/load/
-        // compare loop measured on Adreno. memoryBarrierImage() orders exactly those two, is core
-        // GLSL ES 3.10 in every stage, and is not an execution barrier, so it is legal in
-        // non-uniform control flow. It costs something in a shader that stores to a read+write
-        // image in a loop, which is why it is confined to the split pair.
-        //
-        // Budget note: the split DOUBLES the image-uniform count of the stage it fires in, so
-        // a driver advertising a tight GL_MAX_{FRAGMENT,VERTEX,...}_IMAGE_UNIFORMS can turn a
-        // shader that used to compile into a link failure. ES only guarantees 4 fragment image
-        // uniforms, so a shader with more than half the limit in read+write images is the case
-        // to watch.
-        //
-        // Runs on the transpiled ESSL, so it must see the bindings the frontend units were
-        // already rewritten to and must run before those bindings are stripped - see the call
-        // site in Managers.cpp. Its output is a function of the emitted text alone - it needs no
-        // stage and no per-program state - so it adds nothing to BuildEsslTranslationKey either.
-        //
-        // `outSplitCount`, when given, receives the number of declarations that were actually
-        // doubled - i.e. exactly how many image uniforms this stage gained over what the
-        // application declared. Zero for every shader but a handful, and the only number the
-        // budget note above can be reported with.
-        String SplitReadWriteImageUniforms(const String& glslCode, Uint* outSplitCount = nullptr);
         // Prefix of the per-sampler float uniform that carries GL_TEXTURE_LOD_BIAS into
         // the shader (see EmulateTextureLodBias); the suffix is the sampler's own name.
         constexpr const char* LOD_BIAS_UNIFORM_PREFIX = "mg_lodBias_";
@@ -528,12 +142,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         // the bound texture's (or sampler object's) value into it; a shader whose samplers
         // all have a zero bias is therefore unaffected. Returns the source unchanged when
         // there is nothing to rewrite.
-        //
-        // avoidExplicitLodBias leaves lookups that already carry an explicit LOD untouched,
-        // so their constant level stays constant; only the implicit-LOD forms take the bias.
-        // Off by default and only ever set on ANGLE + llvmpipe, where injecting the uniform
-        // into a constant LOD crashes the driver (MOBILEGL_ESPRYT_AVOID_EXPLICIT_LOD_BIAS).
-        String EmulateTextureLodBias(const String& glslCode, Bool avoidExplicitLodBias = false);
+        String EmulateTextureLodBias(const String& glslCode);
     } // namespace PrgramImpl
 
     namespace Utils {

MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.cpp

@@ -9,10 +9,7 @@
 #include "BackendObject_DirectVulkan.h"
 #include "MG_Backend/BackendObject.h"
 #include "DirectVulkan.h"
-#include "SubgroupSupportPolicy.h"
 #include "MG_State/GLState/FramebufferState/FramebufferObject.h"
-#include "MG_State/GLState/Core.h"
-#include <MG_Pipe/PipeInputsSwitch.h>
 #include "MG_State/GLState/TextureState/TextureState.h"
 #include "MG_Util/Classifiers/TextureEnumClassifier.h"
 #include "MG_Util/Converters/MGToGL/TextureEnumConverter.h"
@@ -386,9 +383,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
         UpdateDynamicBackendParameters();
         UpdateAdvertisedExtensions();
-        if (MGB_CTX_LIVE) {
-            MGB_CTX->InvalidateCompileEnv();
-        }
         PopulateFormatCapabilities(physicalDevice.handle, vkGetPhysicalDeviceFormatProperties, m_vulkanCaps,
                                    MutableFormatCapabilities());
         PrintFormatCapabilities(GetFormatCapabilities());
@@ -501,131 +495,33 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             .RendererName = "Magma",
             .BackendName = "Direct (Vulkan)",
             .ExtraVendor = Nullopt,
-            .RendererGLInfo = {.TargetGLVersion = {4, 6, 0},
+            .RendererGLInfo = {.TargetGLVersion = {4, 0, 0},
                                .TargetGLSLVersion = {4, 6, 0},
-                               // Baseline advertisement (no runtime-gated capabilities); a live
-                               // backend reconciles its copy in UpdateAdvertisedExtensions.
-                               .Extensions = BuildAdvertisedExtensions(false, false, false, false, false),
+                               // 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,
-                                                  Bool nonZeroIndirectBaseInstanceSupported,
-                                                  Bool cubeMapArraySupported) {
+                                                  Bool anisotropicFilteringSupported) {
         Vector<GLExtension> extensions = {
-            // The version tokens have to reach the version the backend actually claims:
-            // TargetGLVersion is {4,6,0}, and a list that stopped at OpenGL40 told an
-            // application feature-detecting off these tokens the opposite of what
-            // GL_MAJOR_VERSION / GL_MINOR_VERSION told it.
-            V_OpenGL30, V_OpenGL31, V_OpenGL32, V_OpenGL33, V_OpenGL40, V_OpenGL41, V_OpenGL42, V_OpenGL43,
-            V_OpenGL44, V_OpenGL45, V_OpenGL46,
-            E_GL_ARB_draw_buffers_blend,
+            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_clear_buffer_object, E_GL_ARB_program_interface_query, E_GL_ARB_framebuffer_object, E_GL_ARB_draw_indirect,
-            E_GL_ARB_multi_draw_indirect,
+            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,
-            // Core since GL 3.1 and implemented for every version advertised here. The string
-            // matters because applications gate the ENTRY POINTS on it rather than on the
-            // version: a caller that finds the extension missing never resolves
-            // glGetUniformBlockIndex / glUniformBlockBinding, and one that then uses uniform
-            // blocks anyway calls through a null pointer.
-            E_GL_ARB_uniform_buffer_object,
-            // Sampling the stencil aspect through DEPTH_STENCIL_TEXTURE_MODE. Core from 4.3,
-            // so on a 4.0 context the string is the only way to reach it.
-            E_GL_ARB_stencil_texturing,
-            // Unconditional, unlike DirectGLES: a GL texture view is a second set of VkImageViews
-            // over the same VkImage with a sub-range and possibly a reinterpreted VkFormat, which
-            // is core Vulkan on every device MobileGL runs on. Format-reinterpreting views need
-            // VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT on the image, which SyncTextureResource sets for
-            // every immutable-storage texture (see the comment there).
-            E_GL_ARB_texture_view,
-            // Core since 3.2 and implemented here on both backends - glDrawElementsBaseVertex,
-            // glDrawRangeElementsBaseVertex, glDrawElementsInstancedBaseVertex and
-            // glMultiDrawElementsBaseVertex all reach real per-draw vertex rebasing. The string
-            // was simply never emitted, which left KHR-GL4*.draw_elements_base_vertex_tests
-            // NotSupported on a feature that works.
-            E_GL_ARB_draw_elements_base_vertex,
-            // The whole sync-object family is real and core since 3.2: glFenceSync, glIsSync,
-            // glDeleteSync, glClientWaitSync, glWaitSync and glGetSynciv all live in GLImpl over a
-            // backend fence (a VkFence here, an EGLSync/GLsync on DirectGLES), and glGetInteger64v
-            // answers GL_MAX_SERVER_WAIT_TIMEOUT. The string matters for the same reason
-            // ARB_uniform_buffer_object's does: LWJGL builds GLCapabilities from the extension
-            // list, and a caller that finds GL_ARB_sync missing never resolves the entry points -
-            // then calls through null if it uses fences anyway. Nothing in the CTS gates on this
-            // string, so it is advertised on the strength of the implementation, not a test unlock.
-            E_GL_ARB_sync,
-            // Atomic counters, core since 4.2. glGetActiveAtomicCounterBufferiv and the whole
-            // GL_ATOMIC_COUNTER_BUFFER_* query family are real in GLImpl, and the counter buffer
-            // now reaches the shader on BOTH backends - Magma resolves the lowered
-            // gl_AtomicCounterBlock_<N> from the atomic-counter binding points rather than the
-            // shader-storage ones (see ResolveStorageBufferDescriptor). Withheld here until that
-            // landed, because the counter silently read whatever was bound as SSBO N instead.
-            E_GL_ARB_shader_atomic_counters,
-            // glVertexAttribDivisor, core since 3.3 and real on both backends. Applications
-            // (Better Clouds' GLCompat among them) accept the extension string as an
-            // ALTERNATIVE to a 3.3 context when deciding whether instanced rendering is
-            // available, so withholding it makes MobileGL look less capable than it is.
-            E_GL_ARB_instanced_arrays,
-            // Core GL 3.0-4.3 plumbing that has been real here for as long as the backend has
-            // existed, and that was simply never named. None of these unlocks a single CTS case -
-            // the conformance suite reaches all of them through the version - so they are
-            // advertised for the OTHER consumer of this list: LWJGL builds GLCapabilities from the
-            // string set, and an application that gates its ENTRY POINTS on the string rather than
-            // on the version never resolves them and then calls through null. Each is backed by
-            // the entry points named beside it. Kept identical to the DirectGLES block so the two
-            // backends do not disagree about what MobileGL is.
-            //
-            // glBindVertexArray / glGenVertexArrays / glDeleteVertexArrays / glIsVertexArray.
-            E_GL_ARB_vertex_array_object,
-            // The 14 glSamplerParameter* / glGetSamplerParameter* entry points, including the
-            // integer-valued Iiv/Iuiv forms.
-            E_GL_ARB_sampler_objects,
-            // glMapBufferRange + glFlushMappedBufferRange, which ARB_buffer_storage's persistent
-            // maps are already built on top of.
-            E_GL_ARB_map_buffer_range,
-            // glCopyBufferSubData plus the GL_COPY_READ_BUFFER / GL_COPY_WRITE_BUFFER targets.
-            E_GL_ARB_copy_buffer,
-            // glCopyImageSubData, wired to a real backend hook on both backends.
-            E_GL_ARB_copy_image,
-            // GL_TEXTURE_SWIZZLE_{R,G,B,A,RGBA}, which map onto a VkImageView's component swizzle.
-            E_GL_ARB_texture_swizzle,
-            // GL_INT_2_10_10_10_REV / GL_UNSIGNED_INT_2_10_10_10_REV on glVertexAttribPointer plus
-            // the eight glVertexAttribP* entry points.
-            E_GL_ARB_vertex_type_2_10_10_10_rev,
-            // The R/RG internal formats. Named separately from the float ones because an
-            // application may check either.
-            E_GL_ARB_texture_rg,
-            // GL_DEPTH_COMPONENT32F and GL_DEPTH32F_STENCIL8.
-            E_GL_ARB_depth_buffer_float,
-            // The floating-point colour formats. Unlike the rest of this block this string DOES
-            // gate CTS cases - KHR-GL4*.internalformat.texture2d.*{16f,32f} is keyed on it with no
-            // core-version fallback, so eight cases per version list were NotSupported on formats
-            // the backend has always had.
-            E_GL_ARB_texture_float,
-            // glViewportArrayv / glViewportIndexedf{,v} / glScissorArrayv / glScissorIndexed{,v} /
-            // glDepthRangeArrayv / glDepthRangeIndexed / glGetFloati_v / glGetDoublei_v, over the
-            // 16 viewports GL_MAX_VIEWPORTS reports.
-            E_GL_ARB_viewport_array,
             // 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};
-        // Vulkan's drawIndirectFirstInstance feature is optional. Direct base-instance calls work
-        // without it, but ARB_base_instance also promises non-zero firstInstance in GPU indirect
-        // commands; the renderer supplies true only when that word is legal and gl_InstanceID can
-        // be rebased to OpenGL's zero-based semantics.
-        if (nonZeroIndirectBaseInstanceSupported) {
-            extensions.push_back(E_GL_ARB_base_instance);
-        }
-        if (shaderSubgroupSupported && !MG_Config::Features.MagmaDisableSubgroup) {
+        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
@@ -643,16 +539,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (MG_Util::Async::AsyncShaderCompileEnabled()) {
             extensions.push_back(E_GL_KHR_parallel_shader_compile);
         }
-        // GL_ARB_gpu_shader_fp64 is opt-in (MOBILEGL_ADVERTISE_FP64), and stays opt-in even on a
-        // device that HAS shaderFloat64. Every `double` in a shader compiles and runs either way
-        // - narrowed to 32 bits where the device has no 64-bit floats, kept whole where it does -
-        // so an application that simply uses doubles needs nothing advertised. What the extension
-        // additionally promises is the whole GL_ARB_gpu_shader_fp64 SURFACE (glUniform*d
-        // conformance, the fp64 built-ins, the state queries), and turning the string on is a
-        // decision about all of it rather than about the shader path alone.
-        if (MG_Config::Features.AdvertiseFp64) {
-            extensions.push_back(E_GL_ARB_gpu_shader_fp64);
-        }
         // 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.
@@ -666,18 +552,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             extensions.push_back(E_GL_EXT_texture_filter_anisotropic);
             extensions.push_back(E_GL_ARB_texture_filter_anisotropic);
         }
-        // A cube map array is a 6n-layer VkImage viewed as VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, and that
-        // view type cannot be created without the imageCubeArray device feature - so the string
-        // follows the feature, not the version, exactly as the per-layer attachment bit does.
-        //
-        // Named for the application's benefit rather than the suite's: measured on Adreno 830,
-        // KHR-GL43.texture_gather.plain-gather-*-cube-array already passed without the string, so
-        // this unlocks no conformance case. It is advertised because the feature is real and
-        // because an application that feature-detects cube map arrays off the string (rather than
-        // off the 4.0 version) would otherwise decline a path this backend serves.
-        if (cubeMapArraySupported) {
-            extensions.push_back(E_GL_ARB_texture_cube_map_array);
-        }
         return extensions;
     }
 
@@ -741,6 +615,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             funcsTable.GL.MemoryBarrierByRegion = MemoryBarrierByRegion;
             funcsTable.GL.BindImageTexture = BindImageTexture;
             funcsTable.GL.GetIntegeri_v = GetIntegeri_v;
+            funcsTable.GL.GetInteger64i_v = GetInteger64i_v;
+            funcsTable.GL.GetProgramiv = GetProgramiv;
             funcsTable.GL.ShaderStorageBlockBinding = ShaderStorageBlockBinding;
             funcsTable.GL.FenceSync = FenceSync;
             funcsTable.GL.ClientWaitSync = ClientWaitSync;
@@ -784,9 +660,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_vulkanCaps = capabilities;
         UpdateDynamicBackendParameters();
         UpdateAdvertisedExtensions();
-        if (MGB_CTX_LIVE) {
-            MGB_CTX->InvalidateCompileEnv();
-        }
         MutableFormatCapabilities().Clear();
     }
 
@@ -797,17 +670,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // real device timestamp support. ApplyVulkanCapabilitiesForTesting may
         // run without a renderer; no timer query is advertised then. Rebuilding
         // the whole list keeps re-runs idempotent.
-        // The opt-in emulated compute path (SubgroupSupportPolicy.h) carries the
-        // extension by itself on devices with no native subgroup support at all; a
-        // device with native subgroups always advertises - and uses - those.
-        const Bool subgroupSupportAdvertised =
-            m_vulkanCaps.SupportsShaderSubgroup ||
-            ShouldEmulateSubgroups(m_vulkanCaps.SupportsShaderSubgroup);
         m_rendererInfo.RendererGLInfo.Extensions = BuildAdvertisedExtensions(
-            subgroupSupportAdvertised, pVulkanRenderer && pVulkanRenderer->IsTimerQuerySupported(),
-            pVulkanRenderer && pVulkanRenderer->IsSamplerAnisotropySupported(),
-            pVulkanRenderer && pVulkanRenderer->IsNonZeroIndirectBaseInstanceSupported(),
-            m_vulkanCaps.SupportsImageCubeArray);
+            m_vulkanCaps.SupportsShaderSubgroup, pVulkanRenderer && pVulkanRenderer->IsTimerQuerySupported(),
+            pVulkanRenderer && pVulkanRenderer->IsSamplerAnisotropySupported());
     }
 
     void BackendObject_DirectVulkan::UpdateDynamicBackendParameters() {
@@ -855,7 +720,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         static constexpr SizeT kMaxAdvertisedShaderStorageBlockSize = 512ull * 1024ull * 1024ull;
         m_dynamicParameters.UniformBufferOffsetAlignment = m_vulkanCaps.UniformBufferOffsetAlignment;
-        m_dynamicParameters.ShaderStorageBufferOffsetAlignment = m_vulkanCaps.ShaderStorageBufferOffsetAlignment;
         m_dynamicParameters.AliasedLineWidthRangeMin = m_vulkanCaps.AliasedLineWidthRangeMin;
         m_dynamicParameters.AliasedLineWidthRangeMax = m_vulkanCaps.AliasedLineWidthRangeMax;
         // Without the samplerAnisotropy feature the limit is unusable, so report 1.0 (no anisotropy)
@@ -904,89 +768,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // 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));
-        // Vulkan descriptor limits are not GL limits, and a GL application reads an advertised
-        // limit as an amount it may actually USE. Adreno answers the per-stage/per-set descriptor
-        // queries at descriptor-indexing scale - the same driver whose
-        // GL_MAX_SHADER_STORAGE_BLOCK_SIZE is clamped from 2147483647 further down - so
-        // KHR-GL44.multi_bind.dispatch_bind_buffers_base read GL_MAX_COMPUTE_UNIFORM_BLOCKS,
-        // created that many buffers and spliced that many UBO declarations into a single compute
-        // shader: ~14 s of allocation, then death on std::bad_alloc. Its sibling
-        // dispatch_bind_buffers_range hard-codes 4 buffers and passes, which is the clean
-        // discriminator. Every ceiling below is far above what any desktop driver advertises for
-        // these (84-96 for the binding families) and far below a descriptor-indexing count, so it
-        // can only lower a limit that was never usable in the first place. The zero floor is not
-        // decoration: a driver reporting UINT32_MAX used to arrive here as -1.
-        const auto clampLimit = [](const char* name, Int reported, Int ceiling) {
-            const Int clamped = std::min(std::max(reported, 0), ceiling);
-            if (clamped != reported) {
-                MGLOG_I("DirectVulkan: clamped %s from %d to %d", name, reported, clamped);
-            }
-            return clamped;
-        };
-        // GL 4.6 required minimums, for the record: MAX_COMPUTE_UNIFORM_BLOCKS 12,
-        // MAX_COMPUTE/COMBINED_SHADER_STORAGE_BLOCKS 8, MAX_SHADER_STORAGE_BUFFER_BINDINGS 8,
-        // MAX_UNIFORM_BUFFER_BINDINGS 84, MAX_TEXTURE_BUFFER_SIZE 65536.
-        constexpr Int kMaxAdvertisedBufferBlocks = 256;
-        constexpr Int kMaxAdvertisedTextureBufferSize = 1 << 27; // texels; what desktop GL reports
-        m_dynamicParameters.MaxComputeShaderStorageBlocks =
-            clampLimit("GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS", m_vulkanCaps.MaxComputeShaderStorageBlocks,
-                       kMaxAdvertisedBufferBlocks);
-        m_dynamicParameters.MaxCombinedShaderStorageBlocks =
-            clampLimit("GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS", m_vulkanCaps.MaxCombinedShaderStorageBlocks,
-                       kMaxAdvertisedBufferBlocks);
-        m_dynamicParameters.MaxComputeUniformBlocks =
-            clampLimit("GL_MAX_COMPUTE_UNIFORM_BLOCKS", m_vulkanCaps.MaxComputeUniformBlocks,
-                       kMaxAdvertisedBufferBlocks);
+        m_dynamicParameters.MaxComputeShaderStorageBlocks = m_vulkanCaps.MaxComputeShaderStorageBlocks;
+        m_dynamicParameters.MaxCombinedShaderStorageBlocks = m_vulkanCaps.MaxCombinedShaderStorageBlocks;
+        m_dynamicParameters.MaxComputeUniformBlocks = m_vulkanCaps.MaxComputeUniformBlocks;
         m_dynamicParameters.MaxComputeWorkGroupInvocations = m_vulkanCaps.MaxComputeWorkGroupInvocations;
-        // The six per-axis compute limits, from the same VkPhysicalDeviceLimits fields
-        // GLFunctionsTable::GetIntegeri_v (DirectVulkan.cpp) reads live. Carried here so that
-        // MGPCaps has them once the table entry retires (plan B section 4.4.1); GL_Getter floors
-        // them. Not clamped: unlike the block counts these are not amounts an application
-        // allocates, and the frontend already raises them to the GL minimum.
-        for (SizeT axis = 0; axis < 3; ++axis) {
-            m_dynamicParameters.MaxComputeWorkGroupCount[axis] = m_vulkanCaps.MaxComputeWorkGroupCount[axis];
-            m_dynamicParameters.MaxComputeWorkGroupSize[axis] = m_vulkanCaps.MaxComputeWorkGroupSize[axis];
-        }
-        m_dynamicParameters.MaxShaderStorageBufferBindings =
-            clampLimit("GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS", m_vulkanCaps.MaxShaderStorageBufferBindings,
-                       kMaxAdvertisedBufferBlocks);
-        // Per-stage GL_MAX_*_SHADER_STORAGE_BLOCKS. Vulkan has one descriptor limit for every
-        // stage (maxPerStageDescriptorStorageBuffers, which is what MaxComputeShaderStorageBlocks
-        // carries), so the stage limits differ only by whether the stage can have blocks at all.
-        //
-        // Deliberately NOT gated on vertexPipelineStoresAndAtomics, unlike the per-stage image
-        // uniforms below. That gate reads as the obvious one and is wrong here in practice: a
-        // Mali-G925-Immortalis reports vertexPipelineStoresAndAtomics=false (supported AND
-        // enabled) and yet runs all 433 KHR-GL43.constant_expressions.*_tess_* cases correctly
-        // through this backend - those write their result through a storage block declared in a
-        // tessellation stage. Gating would report 0 and turn 433 passing cases into
-        // "unsupported", removing function that demonstrably works.
-        //
-        // The asymmetry with DirectGLES is real and is the point. There, 0 prevents a program
-        // the driver refuses outright at link time; the honest limit converts a silent
-        // wrong-render into a capability an application can route around. Here there is no such
-        // failure to prevent, so the limit stays at what the device can address. If a Vulkan
-        // device is ever found that genuinely rejects such a pipeline, the gate belongs at
-        // pipeline creation where the rejection is observable, not on a feature bit this driver
-        // reports inaccurately.
-        {
-            const Int maxPerStageStorageBlocks =
-                std::min(std::max(m_dynamicParameters.MaxComputeShaderStorageBlocks, 0),
-                         std::min(std::max(m_dynamicParameters.MaxCombinedShaderStorageBlocks, 0),
-                                  std::max(m_dynamicParameters.MaxShaderStorageBufferBindings, 0)));
-            m_dynamicParameters.MaxVertexShaderStorageBlocks = maxPerStageStorageBlocks;
-            m_dynamicParameters.MaxTessControlShaderStorageBlocks = maxPerStageStorageBlocks;
-            m_dynamicParameters.MaxTessEvaluationShaderStorageBlocks = maxPerStageStorageBlocks;
-            // The one hard capability in the set: no geometry stage means no blocks in it.
-            m_dynamicParameters.MaxGeometryShaderStorageBlocks =
-                m_vulkanCaps.SupportsGeometryShader ? maxPerStageStorageBlocks : 0;
-            m_dynamicParameters.MaxFragmentShaderStorageBlocks = maxPerStageStorageBlocks;
-        }
-        m_dynamicParameters.MaxTextureBufferSize = clampLimit(
-            "GL_MAX_TEXTURE_BUFFER_SIZE", m_vulkanCaps.MaxTextureBufferSize, kMaxAdvertisedTextureBufferSize);
+        m_dynamicParameters.MaxShaderStorageBufferBindings = m_vulkanCaps.MaxShaderStorageBufferBindings;
+        m_dynamicParameters.MaxTextureBufferSize = m_vulkanCaps.MaxTextureBufferSize;
         m_dynamicParameters.TextureBufferOffsetAlignment = m_vulkanCaps.TextureBufferOffsetAlignment;
-        m_dynamicParameters.MaxUniformBufferBindings = clampLimit(
-            "GL_MAX_UNIFORM_BUFFER_BINDINGS", m_vulkanCaps.MaxUniformBufferBindings, kMaxAdvertisedBufferBlocks);
+        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.MaxCombinedImageUniforms = std::max(m_vulkanCaps.MaxCombinedImageUniforms, 0);
@@ -1008,35 +797,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         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);
-        // Same shape as the image-uniform limits three lines above: maxClipDistances is reported
-        // by every device, but declaring ClipDistance in a module needs the shaderClipDistance
-        // FEATURE, which VulkanRenderer enables exactly where the physical device has it. Without
-        // it the limit describes a capacity no shader may use, so report none.
-        m_dynamicParameters.MaxClipDistances =
-            m_vulkanCaps.SupportsShaderClipDistance ? std::max(m_vulkanCaps.MaxClipDistances, 0) : 0;
-        // The cull pair, gated on its own feature. shaderCullDistance is separate from
-        // shaderClipDistance and VulkanRenderer enables it independently, so it gets its own
-        // gate rather than riding on the clip one.
-        m_dynamicParameters.MaxCullDistances =
-            m_vulkanCaps.SupportsShaderCullDistance ? std::max(m_vulkanCaps.MaxCullDistances, 0) : 0;
-        // GL 4.6 core 11.1.3.10: the combined limit is at least as large as either half. A device
-        // with only one of the two features must not report a combined capacity that implies the
-        // other, so the gate is "either feature" and the value never drops below what is enabled.
-        m_dynamicParameters.MaxCombinedClipAndCullDistances =
-            (m_vulkanCaps.SupportsShaderClipDistance || m_vulkanCaps.SupportsShaderCullDistance)
-                ? std::max({m_vulkanCaps.MaxCombinedClipAndCullDistances, m_dynamicParameters.MaxClipDistances,
-                            m_dynamicParameters.MaxCullDistances})
-                : 0;
+        m_dynamicParameters.MaxClipDistances = m_vulkanCaps.MaxClipDistances;
         m_dynamicParameters.MaxViewports = m_vulkanCaps.MaxViewports;
-        // Assigned explicitly rather than left to the struct's defaults, like every other
-        // parameter here, so a second fill cannot inherit a stale value. GL_UNDEFINED_VERTEX is
-        // the truthful answer for DirectVulkan and a legal one (GL 4.6 table 23.65): which vertex
-        // provokes is chosen per pipeline by VulkanRenderer::SelectProvokingVertexMode out of
-        // VK_EXT_provoking_vertex, provokingVertexModePerPipeline and the topology, so there is no
-        // one convention to name. Vulkan's own default is FIRST, which is the opposite of the
-        // GL_LAST_VERTEX_CONVENTION this used to claim unconditionally.
-        m_dynamicParameters.LayerProvokingVertex = GL_UNDEFINED_VERTEX;
-        m_dynamicParameters.ViewportIndexProvokingVertex = GL_UNDEFINED_VERTEX;
         m_dynamicParameters.MaxViewportWidth = m_vulkanCaps.MaxViewportWidth;
         m_dynamicParameters.MaxViewportHeight = m_vulkanCaps.MaxViewportHeight;
         m_dynamicParameters.ViewportBoundsRangeMin = m_vulkanCaps.ViewportBoundsRangeMin;
@@ -1081,60 +843,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::TextureCubeMapArray);
             }
         }
-        // The device feature the whole fp64 story hangs off. With it, a module keeps its
-        // OpCapability Float64 and real doubles reach the driver; without it the transpile
-        // narrows every 64-bit float to 32 (ShaderTranspiler::DemoteFloat64Pass), because
-        // VUID-VkShaderModuleCreateInfo-pCode-08740 forbids the capability outright and no
-        // pipeline could be built from such a module. lavapipe reports it; Adreno and Mali both
-        // report VK_FALSE, so on every real mobile device this is false and the demotion runs
-        // exactly as it always has.
-        m_dynamicParameters.SupportsShaderFloat64 = m_vulkanCaps.SupportsShaderFloat64;
-        // shaderTessellationAndGeometryPointSize, both stage families from the one feature.
-        // False arms the shared phase-B point-size demotion, whose modules then carry no
-        // TessellationPointSize/GeometryPointSize capability and build without the feature.
-        // MOBILEGL_POINT_SIZE_DEMOTION=1 pretends it is absent so the demotion can be
-        // exercised on a healthy driver (lavapipe advertises the feature); =0 restores the
-        // detected answer's declines.
-        {
-            Bool supportsStagePointSize = m_vulkanCaps.SupportsTessellationAndGeometryPointSize;
-            switch (MG_Config::Features.PointSizeDemotion) {
-            case MG_Config::QuirkOverride::ForceOn:
-                MGLOG_I("DirectVulkan: MOBILEGL_POINT_SIZE_DEMOTION=1 - treating tessellation/geometry "
-                        "gl_PointSize as unhosted so the demotion runs on this driver");
-                supportsStagePointSize = false;
-                break;
-            case MG_Config::QuirkOverride::ForceOff:
-                MGLOG_I("DirectVulkan: MOBILEGL_POINT_SIZE_DEMOTION=0 - keeping the built-in and the "
-                        "plain declines regardless of the device feature");
-                supportsStagePointSize = true;
-                break;
-            case MG_Config::QuirkOverride::Auto:
-                break;
-            }
-            m_dynamicParameters.SupportsTessellationPointSize = supportsStagePointSize;
-            m_dynamicParameters.SupportsGeometryPointSize = supportsStagePointSize;
-        }
-        // Never, on any device, and DELIBERATELY NOT COUPLED to the line above even though it
-        // once tracked the same feature. It used to, because a `dvec` input needed Float64 to
-        // exist in the module at all; a 64-bit vertex FETCH was already impossible
-        // (VK_FORMAT_R64*_SFLOAT is optional and lavapipe reports zero bufferFeatures for all
-        // four), so the attribute arrived as its 32-bit word pair and PackDoubleVertexInputsPass
-        // bitcast it back.
-        //
-        // Re-coupling it does not work, and the reason is worth recording because it is not
-        // obvious: this flag decides the VkFormat from the VAO ATTRIBUTE alone, and the attribute
-        // does not know what the shader declared. glVertexAttribFormat(GL_DOUBLE) against a plain
-        // `in vec4` is not only legal but the common case
-        // (KHR-GL43.vertex_attrib_binding.basic-input-case4 does exactly that, and case5 adds
-        // normalized=GL_TRUE), and advanced-bindingUpdate feeds a dvec3 the same way - GL defines
-        // all of them as "doubles in memory, converted to float". Turning the flag on turns the
-        // narrowing OFF for every one of them and the attributes come back unfetched.
-        //
-        // What keeps the two halves honest instead is a per-MODULE decision: a vertex module that
-        // declares a 64-bit float INPUT is demoted whole, even where the backend has native fp64,
-        // so `dvec` inputs are `vec` inputs on this backend exactly as they always were. See
-        // ShaderCompiler::SanitizeAndOptimizeBinary.
-        m_dynamicParameters.SupportsFloat64VertexAttributes = false;
+        m_dynamicParameters.SupportsFloat64VertexAttributes = m_vulkanCaps.SupportsShaderFloat64;
         m_dynamicParameters.MaxShaderStorageBlockSize =
             std::min(m_vulkanCaps.MaxShaderStorageBlockSize, kMaxAdvertisedShaderStorageBlockSize);
         if (m_vulkanCaps.SupportsShaderSubgroup) {
@@ -1143,18 +852,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_dynamicParameters.SubgroupSupportedFeatures =
                 mapSubgroupFeatures(m_vulkanCaps.SubgroupSupportedOperations);
             m_dynamicParameters.SubgroupQuadOperationsInAllStages = m_vulkanCaps.SubgroupQuadOperationsInAllStages;
-        } else if (ShouldEmulateSubgroups(m_vulkanCaps.SupportsShaderSubgroup)) {
-            // MOBILEGL_MAGMA_EMULATE_SUBGROUP on a device with no native subgroups: the
-            // advertised values describe the 32-lane virtual subgroup the compute
-            // lowering implements (SubgroupSupportPolicy.h / EmulateSubgroupsPass).
-            // GL requires the advertisement and the execution to agree, and on this
-            // path the emulation is what executes; only the compute stage is offered.
-            m_dynamicParameters.SubgroupSize = kEmulatedSubgroupSize;
-            m_dynamicParameters.SubgroupSupportedStages = kEmulatedSubgroupStages;
-            m_dynamicParameters.SubgroupSupportedFeatures = kEmulatedSubgroupFeatures;
-            m_dynamicParameters.SubgroupQuadOperationsInAllStages = false;
-            MGLOG_I("DirectVulkan: emulating 32-lane compute subgroups "
-                    "(MOBILEGL_MAGMA_EMULATE_SUBGROUP, no native subgroup support)");
         } else {
             m_dynamicParameters.SubgroupSize = 0;
             m_dynamicParameters.SubgroupSupportedStages = 0;

MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.h

@@ -62,21 +62,19 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     // POST screen shows.
 
     // Static identity of the Magma renderer (renderer/backend names, target GL/GLSL
-    // versions, ExtraVendor) with the baseline extension advertisement (no runtime-gated
-    // capabilities). A live backend copies this in its constructor and
+    // versions, ExtraVendor) with the baseline extension advertisement (no shader
+    // subgroup, no timer queries). A live backend copies this in its constructor and
     // reconciles the Extensions in UpdateAdvertisedExtensions once real capabilities
     // exist; callers that need the advertised list for a known capability set must
     // use BuildAdvertisedExtensions instead.
     const RendererInfo& GetRendererIdentity();
 
     // The full OpenGL extension list Magma advertises (glGetString(GL_EXTENSIONS)) for
-    // a device with the given raw capabilities. The MOBILEGL_MAGMA_DISABLE_SUBGROUP and
+    // a device with the given raw capabilities. The MOBILEGL_DISABLE_SUBGROUP and
     // MOBILEGL_DISABLE_TIMERQUERY escape hatches are applied inside, so callers pass
     // the detected device support (passing an already-gated value is harmless).
     Vector<GLExtension> BuildAdvertisedExtensions(Bool shaderSubgroupSupported, Bool timerQueriesSupported,
-                                                  Bool anisotropicFilteringSupported,
-                                                  Bool nonZeroIndirectBaseInstanceSupported,
-                                                  Bool cubeMapArraySupported);
+                                                  Bool anisotropicFilteringSupported);
 
     // Format: <GPU Name>, Vulkan <Vulkan Version>, Driver <Driver Version> — the exact
     // string an initialized backend returns from GetBackendAPIVersionString (and that

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.cpp

@@ -10,11 +10,9 @@
 #include "DirectVulkanResourceState.h"
 #include "MG_Backend/BackendObjects.h"
 #include "MG_State/GLState/Core.h"
-#include <MG_Pipe/PipeInputsSwitch.h>
 #include "MG_State/GLState/ErrorState/ErrorInfo.h"
 #include "MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h"
 #include "MG_Util/Converters/GLToMG/TextureEnumConverter.h"
-#include "MG_Util/Metrics/PipeStats.h"
 #include "MG_Util/Metrics/TextureMetrics.h"
 #include "MG_Util/Miscellany/IndexGenerator.h"
 #include <atomic>
@@ -71,14 +69,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // slot's ownership unambiguous.
             Uint64 programLifetimeId = 0;
             Uint32 backendStateVersion = 0;
-            // glShaderStorageBlockBinding deliberately does NOT bump the backend state
-            // version, and the pipeline composite is unnamed so the in-place patch in
-            // DirectVulkan::ShaderStorageBlockBinding can never reach its slot - the
-            // mirror replay bumps only the program's block-binding version. Without this
-            // key the composite's slot kept serving the pre-rebind block.binding.
-            Uint32 blockBindingVersion = 0;
             Vector<StorageBlockResource> storageBlocks;
             Vector<BufferVariableResource> bufferVariables;
+            GLint computeWorkGroupSize[3] = {1, 1, 1};
         };
 
         struct DrawElementsIndirectCommand {
@@ -163,33 +156,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             auto& cache = g_programResourceCaches[program.GetExternalIndex()];
             const Uint64 programLifetimeId = program.GetLifetimeId();
             const Uint32 backendStateVersion = program.GetBackendStateVersion();
-            const Uint32 blockBindingVersion = program.GetBlockBindingVersion();
             // The lifetime id must match too: a new program that reuses a deleted
             // program's name and happens to land on the same backendStateVersion (both
             // count from zero) would otherwise be served the dead program's reflection.
             if (cache.programLifetimeId == programLifetimeId &&
                 cache.backendStateVersion == backendStateVersion &&
                 (!cache.storageBlocks.empty() || !cache.bufferVariables.empty())) {
-                if (cache.blockBindingVersion != blockBindingVersion) {
-                    // Only the block bindings moved (glShaderStorageBlockBinding, or the
-                    // pipeline composite's mirror replay - neither touches the backend
-                    // state version): the reflection itself is unchanged, so re-apply the
-                    // overrides by name instead of re-running spirv-reflect. Overrides
-                    // only ever accumulate, so a block without one still holds its
-                    // declared binding.
-                    for (auto& block : cache.storageBlocks) {
-                        const Int rebound = program.GetShaderStorageBlockBindingOverride(block.name);
-                        if (rebound >= 0) block.binding = static_cast<Uint32>(rebound);
-                    }
-                    cache.blockBindingVersion = blockBindingVersion;
-                }
                 return cache;
             }
 
             cache = {};
             cache.programLifetimeId = programLifetimeId;
             cache.backendStateVersion = backendStateVersion;
-            cache.blockBindingVersion = blockBindingVersion;
 
             Vector<SpvReflectShaderModule> modules;
             Vector<Bool> validModules;
@@ -209,6 +187,16 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
 
             for (auto& module : modules) {
+                for (Uint32 entryIndex = 0; entryIndex < module.entry_point_count; ++entryIndex) {
+                    const auto& entryPoint = module.entry_points[entryIndex];
+                    if ((entryPoint.shader_stage & SPV_REFLECT_SHADER_STAGE_COMPUTE_BIT) == 0) {
+                        continue;
+                    }
+                    cache.computeWorkGroupSize[0] = static_cast<GLint>(std::max<Uint32>(entryPoint.local_size.x, 1));
+                    cache.computeWorkGroupSize[1] = static_cast<GLint>(std::max<Uint32>(entryPoint.local_size.y, 1));
+                    cache.computeWorkGroupSize[2] = static_cast<GLint>(std::max<Uint32>(entryPoint.local_size.z, 1));
+                }
+
                 uint32_t bindingCount = 0;
                 SpvReflectResult result = spvReflectEnumerateDescriptorBindings(&module, &bindingCount, nullptr);
                 if (result != SPV_REFLECT_RESULT_SUCCESS || bindingCount == 0) {
@@ -268,27 +256,27 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
 
         MG_State::GLState::ProgramObject* TryGetDirectVulkanProgram(GLuint program) {
-            if (!MGB_CTX->ValidateProgramName(program)) {
+            if (!MG_State::pGLContext->ValidateProgramName(program)) {
                 return nullptr;
             }
-            auto& programObject = MGB_CTX->GetProgramObject(program);
+            auto& programObject = MG_State::pGLContext->GetProgramObject(program);
             return programObject.get();
         }
 
         const Uint8* ResolveIndirectCommandBytes(const void* indirect, SizeT requiredBytes, const char* label) {
-            auto drawBuffer = MGB_CTX->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
+            auto drawBuffer = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
             if (drawBuffer) {
                 drawBuffer->SyncPersistentMappedRange();
                 const SizeT commandOffset = reinterpret_cast<SizeT>(indirect);
                 if (drawBuffer->MappedData() == nullptr || commandOffset + requiredBytes > drawBuffer->GetSize()) {
-                    MGLOG_E_ONCE("%s skipped: invalid GL_DRAW_INDIRECT_BUFFER binding or range", label);
+                    MGLOG_E("%s skipped: invalid GL_DRAW_INDIRECT_BUFFER binding or range", label);
                     return nullptr;
                 }
                 return drawBuffer->MappedData() + commandOffset;
             }
 
             if (!indirect) {
-                MGLOG_E_ONCE("%s skipped: indirect pointer is null", label);
+                MGLOG_E("%s skipped: indirect pointer is null", label);
                 return nullptr;
             }
 
@@ -335,64 +323,64 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::ClearBufferfi called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::ClearBufferfi called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::ClearBufferfi called with null GL context");
         pVulkanRenderer->ClearBufferfi(buffer, drawbuffer, depth, stencil);
     }
 
     void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::ClearBufferfv called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::ClearBufferfv called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::ClearBufferfv called with null GL context");
         pVulkanRenderer->ClearBufferfv(buffer, drawbuffer, value);
     }
 
     void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::ClearBufferuiv called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::ClearBufferuiv called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::ClearBufferuiv called with null GL context");
         pVulkanRenderer->ClearBufferuiv(buffer, drawbuffer, value);
     }
 
     void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::ClearBufferiv called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::ClearBufferiv called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::ClearBufferiv called with null GL context");
         pVulkanRenderer->ClearBufferiv(buffer, drawbuffer, value);
     }
 
     void ClearNamedFramebufferfv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
                                  GLint drawbuffer, const GLfloat* value) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::ClearNamedFramebufferfv called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::ClearNamedFramebufferfv called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::ClearNamedFramebufferfv called with null GL context");
         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(MGB_CTX_LIVE, "DirectVulkan::ClearNamedFramebufferiv called with null GL context");
+        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(MGB_CTX_LIVE, "DirectVulkan::ClearNamedFramebufferuiv called with null GL context");
+        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");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::ClearNamedFramebufferfi called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::ClearNamedFramebufferfi called with null GL context");
         pVulkanRenderer->ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);
     }
 
     void MultiDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::MultiDrawElementsIndirect called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::MultiDrawElementsIndirect called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::MultiDrawElementsIndirect called with null GL context");
         pVulkanRenderer->MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
     }
     void MultiDrawArraysIndirect(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::MultiDrawArraysIndirect called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::MultiDrawArraysIndirect called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::MultiDrawArraysIndirect called with null GL context");
 
         if (drawcount <= 0) {
             return;
@@ -400,7 +388,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         // With a bound GL_DRAW_INDIRECT_BUFFER the command parameters may be GPU-written
         // (e.g. by a compute shader), so consume them natively on the GPU.
-        auto drawBuffer = MGB_CTX->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
+        auto drawBuffer = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
         if (drawBuffer) {
             pVulkanRenderer->MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
             return;
@@ -410,7 +398,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             stride = sizeof(DrawArraysIndirectCommand);
         }
         if (stride < static_cast<GLsizei>(sizeof(DrawArraysIndirectCommand))) {
-            MGLOG_E_ONCE("MultiDrawArraysIndirect skipped: stride %d is smaller than command size %zu",
+            MGLOG_E("MultiDrawArraysIndirect skipped: stride %d is smaller than command size %zu",
                     stride, sizeof(DrawArraysIndirectCommand));
             return;
         }
@@ -443,13 +431,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void MultiDrawElementsIndirectCount(GLenum mode, GLenum type, const void* indirect, GLintptr drawcount,
                                         GLsizei maxdrawcount, GLsizei stride) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::MultiDrawElementsIndirectCount called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::MultiDrawElementsIndirectCount called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::MultiDrawElementsIndirectCount called with null GL context");
         pVulkanRenderer->MultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride);
     }
     void MultiDrawArraysIndirectCount(GLenum mode, const void* indirect, GLintptr drawcount,
                                       GLsizei maxdrawcount, GLsizei stride) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::MultiDrawArraysIndirectCount called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::MultiDrawArraysIndirectCount called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::MultiDrawArraysIndirectCount called with null GL context");
 
         if (maxdrawcount <= 0) {
             return;
@@ -458,20 +446,20 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             stride = sizeof(DrawArraysIndirectCommand);
         }
         if (stride < static_cast<GLsizei>(sizeof(DrawArraysIndirectCommand))) {
-            MGLOG_E_ONCE("MultiDrawArraysIndirectCount skipped: stride %d is smaller than command size %zu",
+            MGLOG_E("MultiDrawArraysIndirectCount skipped: stride %d is smaller than command size %zu",
                     stride, sizeof(DrawArraysIndirectCommand));
             return;
         }
 
-        auto parameterBuffer = MGB_CTX->GetBufferBindingSlot(BufferTarget::Parameter).GetBoundObject();
+        auto parameterBuffer = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::Parameter).GetBoundObject();
         if (!parameterBuffer || drawcount < 0 || static_cast<SizeT>(drawcount) + sizeof(Uint32) > parameterBuffer->GetSize()) {
-            MGLOG_E_ONCE("MultiDrawArraysIndirectCount skipped: invalid GL_PARAMETER_BUFFER binding or range");
+            MGLOG_E("MultiDrawArraysIndirectCount skipped: invalid GL_PARAMETER_BUFFER binding or range");
             return;
         }
 
         parameterBuffer->SyncPersistentMappedRange();
         if (parameterBuffer->MappedData() == nullptr) {
-            MGLOG_E_ONCE("MultiDrawArraysIndirectCount skipped: CPU fallback cannot read parameter buffer");
+            MGLOG_E("MultiDrawArraysIndirectCount skipped: CPU fallback cannot read parameter buffer");
             return;
         }
 
@@ -494,7 +482,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void DrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void* indices,
                                                      GLsizei instancecount, GLint basevertex, GLuint baseinstance) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DrawElementsInstancedBaseVertexBaseInstance called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::DrawElementsInstancedBaseVertexBaseInstance called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DrawElementsInstancedBaseVertexBaseInstance called with null GL context");
 
         DrawIndexedCmd payload{};
         payload.mode = mode;
@@ -521,17 +509,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
     void DrawElementsIndirect(GLenum mode, GLenum type, const void* indirect) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DrawElementsIndirect called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::DrawElementsIndirect called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DrawElementsIndirect called with null GL context");
 
         const SizeT indexSize = MG_Util::GetGLTypeSize(type);
         if (indexSize == 0) {
-            MGLOG_E_ONCE("DrawElementsIndirect skipped: unsupported index type 0x%x", type);
+            MGLOG_E("DrawElementsIndirect skipped: unsupported index type 0x%x", type);
             return;
         }
 
         // With a bound GL_DRAW_INDIRECT_BUFFER the command parameters may be GPU-written
         // (e.g. by a compute shader), so consume them natively on the GPU.
-        auto drawBuffer = MGB_CTX->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
+        auto drawBuffer = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
         if (drawBuffer) {
             pVulkanRenderer->MultiDrawElementsIndirect(mode, type, indirect, 1, 0);
             return;
@@ -565,7 +553,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void DrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount,
                                          GLuint baseinstance) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DrawArraysInstancedBaseInstance called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::DrawArraysInstancedBaseInstance called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DrawArraysInstancedBaseInstance called with null GL context");
 
         DrawCmd payload{};
         payload.mode = mode;
@@ -580,11 +568,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
     void DrawArraysIndirect(GLenum mode, const void* indirect) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DrawArraysIndirect called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::DrawArraysIndirect called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DrawArraysIndirect called with null GL context");
 
         // With a bound GL_DRAW_INDIRECT_BUFFER the command parameters may be GPU-written
         // (e.g. by a compute shader), so consume them natively on the GPU.
-        auto drawBuffer = MGB_CTX->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
+        auto drawBuffer = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
         if (drawBuffer) {
             pVulkanRenderer->MultiDrawArraysIndirect(mode, indirect, 1, 0);
             return;
@@ -614,47 +602,47 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
                         GLsizei height, GLint border) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::CopyTexImage2D called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::CopyTexImage2D called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::CopyTexImage2D called with null GL context");
         pVulkanRenderer->CopyTexSubImage2D(target, level, 0, 0, x, y, width, height);
     }
     void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
                            GLsizei height) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::CopyTexSubImage2D called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::CopyTexSubImage2D called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::CopyTexSubImage2D called with null GL context");
         pVulkanRenderer->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
     }
-    void CopyImageSubData(const CopyImageEndpoint& src,
+    void CopyImageSubData(const SharedPtr<MG_State::GLState::ITextureObject>& srcTexture,
                           GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ,
-                          const CopyImageEndpoint& dst,
+                          const SharedPtr<MG_State::GLState::ITextureObject>& dstTexture,
                           GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ,
                           GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::CopyImageSubData called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::CopyImageSubData called with null GL context");
-        pVulkanRenderer->CopyImageSubData(src, srcTarget, srcLevel, srcX, srcY, srcZ,
-                                          dst, dstTarget, dstLevel, dstX, dstY, dstZ,
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::CopyImageSubData called with null GL context");
+        pVulkanRenderer->CopyImageSubData(srcTexture, srcTarget, srcLevel, srcX, srcY, srcZ,
+                                          dstTexture, dstTarget, dstLevel, dstX, dstY, dstZ,
                                           srcWidth, srcHeight, srcDepth);
     }
     void GenerateMipmap(GLenum target) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::GenerateMipmap called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::GenerateMipmap called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::GenerateMipmap called with null GL context");
         pVulkanRenderer->GenerateMipmap(target);
     }
 
     void DispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DispatchCompute called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::DispatchCompute called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DispatchCompute called with null GL context");
         pVulkanRenderer->DispatchCompute(numGroupsX, numGroupsY, numGroupsZ);
     }
 
     void DispatchComputeIndirect(GLintptr indirect) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DispatchComputeIndirect called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::DispatchComputeIndirect called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DispatchComputeIndirect called with null GL context");
         pVulkanRenderer->DispatchComputeIndirect(indirect);
     }
 
     void MemoryBarrier(GLbitfield barriers) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::MemoryBarrier called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::MemoryBarrier called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::MemoryBarrier called with null GL context");
         pVulkanRenderer->MemoryBarrier(barriers);
     }
 
@@ -673,40 +661,130 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         (void)format;
     }
 
-    // The two compute limits are the only indexed pnames a backend genuinely owns: they come
-    // from the physical device, and MG_Impl/GLImpl/Getter/GL_Getter.cpp asks for them here so it
-    // can raise the answer to the GL required minimum. The same six numbers are carried in
-    // DynamicBackendParameters::MaxComputeWorkGroupCount/Size (filled at capability init from
-    // the same limits), which is their MGPCaps carrier once this entry retires - the
-    // AdvertisedLimitsScenario pins the two against each other. Every other indexed pname names FRONTEND
-    // state (the indexed buffer bindings, the per-unit texture/sampler bindings, the image-unit
-    // bindings, the viewport rectangles, the indexed capabilities) and is answered there before
-    // the table is consulted, so the arms this function used to carry for
-    // GL_SHADER_STORAGE_BUFFER_* and GL_IMAGE_BINDING_* were unreachable duplicates - and not
-    // even faithful ones: the frontend reports the range glBindBufferRange was ASKED for,
-    // verbatim, while these clamped it to the buffer's current storage.
     void GetIntegeri_v(GLenum target, GLuint index, GLint* data) {
         if (!data) return;
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::GetIntegeri_v called with null VulkanRenderer");
-        if (index >= 3) {
-            *data = 0;
-            return;
-        }
         switch (target) {
         case GL_MAX_COMPUTE_WORK_GROUP_COUNT:
+            if (index >= 3) {
+                *data = 0;
+                return;
+            }
             *data = static_cast<GLint>(
                 pVulkanRenderer->GetPhysicalDevice().properties.limits.maxComputeWorkGroupCount[index]);
             return;
         case GL_MAX_COMPUTE_WORK_GROUP_SIZE:
+            if (index >= 3) {
+                *data = 0;
+                return;
+            }
             *data = static_cast<GLint>(
                 pVulkanRenderer->GetPhysicalDevice().properties.limits.maxComputeWorkGroupSize[index]);
             return;
+        case GL_SHADER_STORAGE_BUFFER_BINDING: {
+            auto& point = MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::ShaderStorage, index);
+            auto& obj = point.GetBoundObject();
+            *data = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_SHADER_STORAGE_BUFFER_START: {
+            auto& point = MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::ShaderStorage, index);
+            *data = static_cast<GLint>(point.GetRange().start);
+            return;
+        }
+        case GL_SHADER_STORAGE_BUFFER_SIZE: {
+            auto& point = MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::ShaderStorage, index);
+            auto& obj = point.GetBoundObject();
+            if (!obj) {
+                *data = 0;
+                return;
+            }
+            const auto& range = point.GetRange();
+            const auto start = std::min(range.start, obj->GetSize());
+            const auto end = std::min(range.end, obj->GetSize());
+            *data = static_cast<GLint>(end - start);
+            return;
+        }
+        case GL_IMAGE_BINDING_NAME:
+        case GL_IMAGE_BINDING_LEVEL:
+        case GL_IMAGE_BINDING_LAYERED:
+        case GL_IMAGE_BINDING_LAYER:
+        case GL_IMAGE_BINDING_ACCESS:
+        case GL_IMAGE_BINDING_FORMAT: {
+            if (index >= MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS) {
+                *data = 0;
+                return;
+            }
+            auto& imageBinding = MG_State::pGLContext->GetImageTextureBinding(static_cast<Int>(index));
+            if (target == GL_IMAGE_BINDING_NAME) {
+                *data = imageBinding.Texture ? static_cast<GLint>(imageBinding.Texture->GetExternalIndex()) : 0;
+            } else if (target == GL_IMAGE_BINDING_LEVEL) {
+                *data = imageBinding.Level;
+            } else if (target == GL_IMAGE_BINDING_LAYERED) {
+                *data = imageBinding.Layered;
+            } else if (target == GL_IMAGE_BINDING_LAYER) {
+                *data = imageBinding.Layer;
+            } else if (target == GL_IMAGE_BINDING_ACCESS) {
+                *data = static_cast<GLint>(imageBinding.Access);
+            } else {
+                *data = static_cast<GLint>(imageBinding.Format);
+            }
+            return;
+        }
         default:
             *data = 0;
             return;
         }
     }
 
+    void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) {
+        if (!data) return;
+        switch (target) {
+        case GL_SHADER_STORAGE_BUFFER_START: {
+            auto& point = MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::ShaderStorage, index);
+            *data = static_cast<GLint64>(point.GetRange().start);
+            return;
+        }
+        case GL_SHADER_STORAGE_BUFFER_SIZE: {
+            auto& point = MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::ShaderStorage, index);
+            auto& obj = point.GetBoundObject();
+            if (!obj) {
+                *data = 0;
+                return;
+            }
+            const auto& range = point.GetRange();
+            const auto start = std::min(range.start, obj->GetSize());
+            const auto end = std::min(range.end, obj->GetSize());
+            *data = static_cast<GLint64>(end - start);
+            return;
+        }
+        default:
+            *data = 0;
+            return;
+        }
+    }
+
+    void GetProgramiv(GLuint program, GLenum pname, GLint* params) {
+        if (!params) return;
+        auto* programObject = TryGetDirectVulkanProgram(program);
+        if (!programObject) {
+            params[0] = 0;
+            return;
+        }
+        switch (pname) {
+        case GL_COMPUTE_WORK_GROUP_SIZE: {
+            auto& cache = GetProgramResourceCache(*programObject);
+            params[0] = cache.computeWorkGroupSize[0];
+            params[1] = cache.computeWorkGroupSize[1];
+            params[2] = cache.computeWorkGroupSize[2];
+            return;
+        }
+        default:
+            params[0] = 0;
+            return;
+        }
+    }
+
     void ShaderStorageBlockBinding(GLuint program, const GLchar* storageBlockName, GLuint storageBlockBinding) {
         auto* programObject = TryGetDirectVulkanProgram(program);
         if (!programObject || storageBlockName == nullptr) return;
@@ -714,7 +792,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             ? pActiveBackendObject->GetDynamicParameters().MaxShaderStorageBufferBindings
             : 0;
         if (storageBlockBinding >= static_cast<GLuint>(maxBindings)) {
-            MGB_CTX->RecordError(
+            MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
                 MakeUnique<GenericErrorInfo>("DirectVulkan", __func__, "Shader storage binding is out of range."));
             return;
@@ -723,40 +801,31 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // 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.
-        //
-        // Resolve the index BEFORE taking the reference, and bounds-check the way the
-        // sibling getter does. GetShaderStorageBlockIndex re-enters GetProgramResourceCache,
-        // which indexes g_programResourceCaches and can therefore insert - and that map is
-        // open-addressed, so a rehash MOVES its entries and a reference taken before the
-        // call is left dangling. Binding a program's storage block
-        // while another program's entry was still absent from the cache was a reproducible
-        // segfault (ProgramPipelineScenario's two storage-block cases, in one process).
+        auto& cache = GetProgramResourceCache(*programObject);
         const GLuint blockIndex = GetShaderStorageBlockIndex(*programObject, storageBlockName);
         if (blockIndex == GL_INVALID_INDEX) return;
-        auto& cache = GetProgramResourceCache(*programObject);
-        if (blockIndex >= cache.storageBlocks.size()) return;
         cache.storageBlocks[blockIndex].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");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::ReadPixels called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::ReadPixels called with null GL context");
         pVulkanRenderer->ReadPixels(x, y, width, height, format, type, pixels);
     }
     void GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::GetTexImage called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::GetTexImage called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::GetTexImage called with null GL context");
         pVulkanRenderer->GetTexImage(target, level, format, type, pixels);
     }
     void GetTextureImage(const SharedPtr<MG_State::GLState::ITextureObject>& texture, TextureUploadTarget uploadTarget,
                          GLint level, GLenum format, GLenum type, GLsizei bufSize, GLvoid* pixels) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::GetTextureImage called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::GetTextureImage called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::GetTextureImage called with null GL context");
         pVulkanRenderer->GetTextureImage(texture, uploadTarget, level, format, type, bufSize, pixels);
     }
 
     void Clear(GLbitfield mask) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::Clear called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::Clear called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::Clear called with null GL context");
         pVulkanRenderer->Clear(mask);
     }
 
@@ -784,7 +853,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return false;
         }
         const Uint8* indexBytes = nullptr;
-        const auto& vao = *MGB_CTX->GetBoundVertexArray();
+        const auto& vao = *MG_State::pGLContext->GetBoundVertexArray();
         const auto& indexBufferShared = vao.GetIndexBufferBindingSlot().GetBoundObject();
         if (indexBufferShared != nullptr) {
             const SizeT offset = reinterpret_cast<SizeT>(indices);
@@ -815,7 +884,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     void DrawArrays(GLenum mode, GLint first, GLsizei count) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DrawArrays called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::DrawArrays called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DrawArrays called with null GL context");
 
         if (mode == GL_LINE_LOOP) {
             if (count < 2) {
@@ -840,7 +909,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DrawElements called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::DrawElements called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DrawElements called with null GL context");
 
         if (mode == GL_LINE_LOOP) {
             Vector<Uint32> closedIndices;
@@ -863,7 +932,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     void MultiDrawArrays(GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::MultiDrawArrays called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::MultiDrawArrays called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::MultiDrawArrays called with null GL context");
         if (drawcount <= 0) {
             return;
         }
@@ -897,29 +966,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (drawcount <= 0) {
             return;
         }
-
-        // With no element-array buffer bound, every indices[i] is a client pointer into a
-        // separate CPU allocation, not an offset into one shared buffer. The batched payload
-        // below cannot express that: it carries ONE index-buffer view for the whole batch and
-        // turns each pointer into a firstIndex relative to it. Replay the sub-draws through
-        // the single-draw entry point instead - it snapshots each client range into its own
-        // transient slice, which is exactly what the unrolled draws this must match do.
-        // (The batch used to be built this way; the shared-view rewrite that added
-        // MultiDrawIndexedCmd left the client-memory shape addressing a view whose byte
-        // offset is a hardcoded 0, so UploadAndBindIndexBuffer saw a null client pointer,
-        // declined the whole batch and painted nothing.)
-        const auto& vao = *MGB_CTX->GetBoundVertexArray();
-        if (vao.GetIndexBufferBindingSlot().GetBoundObject() == nullptr) {
-            for (GLsizei i = 0; i < drawcount; ++i) {
-                if (count[i] <= 0) {
-                    continue;
-                }
-                DrawElementsBaseVertex(mode, count[i], type, indices[i],
-                                       basevertex != nullptr ? basevertex[i] : 0);
-            }
-            return;
-        }
-
         MultiDrawIndexedCmd payload{};
         payload.mode = mode;
         payload.indexBufferView.indexType = type;
@@ -931,7 +977,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // shift - the hardware divide was the hottest instruction of this loop.
         const SizeT indexSize = MG_Util::GetGLTypeSize(type);
         if (indexSize == 0) {
-            MGLOG_E_ONCE("MultiDrawElements skipped: unsupported index type 0x%x", type);
+            MGLOG_E("MultiDrawElements skipped: unsupported index type 0x%x", type);
             return;
         }
         const Uint32 indexSizeShift = static_cast<Uint32>(std::countr_zero(indexSize));
@@ -969,13 +1015,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     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(MGB_CTX_LIVE, "DirectVulkan::MultiDrawElements called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::MultiDrawElements called with null GL context");
         MultiDrawElementsImpl(mode, count, type, indices, drawcount, nullptr);
     }
 
     void DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLint basevertex) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::DrawElementsBaseVertex called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::DrawElementsBaseVertex called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::DrawElementsBaseVertex called with null GL context");
         if (mode == GL_LINE_LOOP) {
             Vector<Uint32> closedIndices;
             if (BuildClosedLineLoopIndices(count, type, indices, closedIndices)) {
@@ -999,14 +1045,14 @@ 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(MGB_CTX_LIVE, "DirectVulkan::MultiDrawElementsBaseVertex called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::MultiDrawElementsBaseVertex called with null GL context");
         MultiDrawElementsImpl(mode, count, type, indices, drawcount, basevertex);
     }
 
     void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1,
                          GLint dstY1, GLbitfield mask, GLenum filter) {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::BlitFramebuffer called with null VulkanRenderer");
-        MOBILEGL_ASSERT(MGB_CTX_LIVE, "DirectVulkan::BlitFramebuffer called with null GL context");
+        MOBILEGL_ASSERT(MG_State::pGLContext, "DirectVulkan::BlitFramebuffer called with null GL context");
         pVulkanRenderer->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
     }
 
@@ -1107,12 +1153,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             SharedPtr<VkTimerQueryManager::TimestampRecord> end;
             // Kind::Occlusion - pool slots recorded between Begin/End; summed at result time.
             Vector<Uint32> occlusionSlots;
-            // Kind::XfbGenerated - reroute-pool slots for the span's XFB-INACTIVE
-            // draws, where the renderer's reroute is armed (the affected driver's
-            // stream query counts nothing without an open capture; see
-            // VulkanRenderer::BeginXfbQueryForDraw). Summed alongside the stream
-            // slots above, which keep the span's XFB-active draws.
-            Vector<Uint32> rerouteSlots;
             // Renderer generation the records were written under (see
             // g_rendererGeneration). A stale generation resolves as available
             // with a final zero result: the records' pool indices and frame
@@ -1122,19 +1162,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // stale queries are always safe to delete.
             Uint64 rendererGeneration = 0;
             // Kind::XfbGenerated - the frontend's paused-draw primitive counter when the
-            // query began. On the affected drivers VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT
-            // counts only what the capture saw, so a draw made while the span was paused is
-            // invisible to it - but GL_PRIMITIVES_GENERATED counts what the last vertex
-            // processing stage emitted regardless. The delta closes that gap at result time.
+            // query began. VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT counts only what the
+            // capture saw, so a draw made while the span was paused is invisible to it -
+            // but GL_PRIMITIVES_GENERATED counts what the last vertex processing stage
+            // emitted regardless. The delta closes that gap at result time.
             Uint64 pausedPrimitiveSnapshot = 0;
-            // ...unless the GPU already counted those paused draws when the span opened -
-            // through the reroute pool (VulkanRenderer::BeginXfbQueryForDraw reroutes every
-            // draw with no open capture, paused ones included) or, where the probe measured
-            // the stream query as counting capture-less draws, through the stream slot the
-            // paused draw still takes. Adding the CPU delta on top would count them twice,
-            // and the CPU counter is the weaker source anyway: only 3 of the ~15 draw entry
-            // points write it and it answers 0 for GL_PATCHES.
-            Bool pausedPrimitivesCountedByGpu = false;
         };
     } // namespace
 
@@ -1228,14 +1260,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (query->kind == VulkanTimerQuery::Kind::XfbWritten ||
             query->kind == VulkanTimerQuery::Kind::XfbGenerated) {
             Uint64 primitives = 0;
-            if (!pVulkanRenderer->ResolveXfbQueryResult(query->occlusionSlots, query->rerouteSlots,
+            if (!pVulkanRenderer->ResolveXfbQueryResult(query->occlusionSlots,
                                                         query->kind == VulkanTimerQuery::Kind::XfbGenerated,
                                                         primitives)) {
                 return false;
             }
-            if (query->kind == VulkanTimerQuery::Kind::XfbGenerated &&
-                !query->pausedPrimitivesCountedByGpu && MGB_CTX_LIVE) {
-                primitives += MGB_CTX->GetTransformFeedbackPausedPrimitiveCounter() -
+            if (query->kind == VulkanTimerQuery::Kind::XfbGenerated && MG_State::pGLContext != nullptr) {
+                primitives += MG_State::pGLContext->GetTransformFeedbackPausedPrimitiveCounter() -
                               query->pausedPrimitiveSnapshot;
             }
             *outNanoseconds = primitives;
@@ -1282,10 +1313,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         query->kind = generated ? VulkanTimerQuery::Kind::XfbGenerated : VulkanTimerQuery::Kind::XfbWritten;
         query->rendererGeneration = GetRendererGeneration();
         query->pausedPrimitiveSnapshot =
-            MGB_CTX_LIVE ? MGB_CTX->GetTransformFeedbackPausedPrimitiveCounter() : 0;
-        // Read AFTER StartXfbQueryCapture, which is where a failed reroute-pool creation
-        // disarms: the answer is then what this span will actually do for every draw.
-        query->pausedPrimitivesCountedByGpu = generated && pVulkanRenderer->ArePausedDrawsGpuCounted();
+            MG_State::pGLContext ? MG_State::pGLContext->GetTransformFeedbackPausedPrimitiveCounter() : 0;
         return query;
     }
 
@@ -1296,8 +1324,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return;
         }
         pVulkanRenderer->StopXfbQueryCapture(
-            query->kind == VulkanTimerQuery::Kind::XfbGenerated ? 1u : 0u, query->occlusionSlots,
-            query->rerouteSlots);
+            query->kind == VulkanTimerQuery::Kind::XfbGenerated ? 1u : 0u, query->occlusionSlots);
     }
 
     BackendQueryHandle BeginOcclusionQuery() {
@@ -1331,12 +1358,5 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void Present() {
         MOBILEGL_ASSERT(pVulkanRenderer, "DirectVulkan::Present called with null VulkanRenderer");
         pVulkanRenderer->Present();
-        // THE frame boundary for the MGPipe counters, at the backend entry point rather
-        // than inside VulkanRenderer::Present: that function has an early return for the
-        // no-usable-swapchain case, and a suspended frame is still a frame the counters
-        // must close.
-        if (MG_Util::PipeStats::Enabled()) {
-            MG_Util::PipeStats::OnPresent();
-        }
     }
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.h

@@ -82,9 +82,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         GLsizei height, GLint border);
     void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
                            GLsizei height);
-    void CopyImageSubData(const CopyImageEndpoint& src,
+    void CopyImageSubData(const SharedPtr<MG_State::GLState::ITextureObject>& srcTexture,
                           GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ,
-                          const CopyImageEndpoint& dst,
+                          const SharedPtr<MG_State::GLState::ITextureObject>& dstTexture,
                           GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ,
                           GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
     void GenerateMipmap(GLenum target);
@@ -95,6 +95,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void BindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access,
                           GLenum format);
     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 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);

MobileGL/MG_Backend/DirectVulkan/Renderer/BufferArena.cpp

@@ -111,11 +111,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
 
         if (buffer.IsValid()) {
-            // Outgrown, not dead: every BufferSlice handed out from this frame's arena so far
-            // still names it, and those slices stay in service until the frame slot is rewound
-            // (VkBufferResource::transientSlice, the converted-vertex-stream cache, the draw
-            // memos). The release therefore has to survive every mid-frame reclaim and land on
-            // the next ResetFrame of this slot - see VkBufferManager::CollectAllDeferredReleases.
             m_deferredReleases[frameIndex].push_back(std::move(buffer));
         }
 

MobileGL/MG_Backend/DirectVulkan/Renderer/FrameContext.cpp

@@ -205,7 +205,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // commands away. The device is gone on that path anyway - stay silent-safe
         // rather than trade a lost device for a barrier into a closed buffer.
         if (frame.hasCommandBufferRecorded) {
-            MGLOG_E_ONCE("TransitionToPresent: command buffer already closed; skipping the present barrier");
+            MGLOG_E("TransitionToPresent: command buffer already closed; skipping the present barrier");
             return false;
         }
 

MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.cpp

@@ -201,17 +201,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.renderPass, sizeof(payload.renderPass)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.colorAttachmentCount, sizeof(payload.colorAttachmentCount)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.rasterizationSamples, sizeof(payload.rasterizationSamples)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.sampleShadingEnable, sizeof(payload.sampleShadingEnable)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.minSampleShading, sizeof(payload.minSampleShading)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.sampleMask, sizeof(payload.sampleMask)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.subpass, sizeof(payload.subpass)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.topology, sizeof(payload.topology)));
         XXHASH_VERIFY(
             XXH64_update(m_hashState, &payload.primitiveRestartEnable, sizeof(payload.primitiveRestartEnable)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.patchControlPoints, sizeof(payload.patchControlPoints)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.passthroughTessControlKey,
-                                   sizeof(payload.passthroughTessControlKey)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.viewportCount, sizeof(payload.viewportCount)));
         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)));
@@ -258,23 +252,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
 
         VkPipeline pipeline = CreatePipeline(payload);
-        // A failed creation must never be memoized. Caching VK_NULL_HANDLE served the null back for
-        // the rest of the process, so one transient driver rejection turned every later draw with
-        // the same state into a vkCmdBindPipeline(VK_NULL_HANDLE) - the SIGSEGV behind 9 of the 15
-        // CTS process deaths. Retrying costs one failed vkCreateGraphicsPipelines per draw, which
-        // is the correct price for a broken pipeline and is bounded by the draw itself being
-        // skipped.
-        if (pipeline == VK_NULL_HANDLE) {
-            // Unlatched, like the CreatePipeline report it accompanies: a pipeline MobileGL
-            // assembled and the driver refused is a broken invariant, not an expected failure,
-            // so it stays loud for as long as it is reachable. Raised from MGLOG_I once the
-            // Log.h ordering fix made MGLOG_E live in INFO builds.
-            MGLOG_E("PipelineFactory::GetOrCreatePipeline: creation failed for hash=0x%llx "
-                    "programHash=0x%llx; not caching the failure",
-                    static_cast<unsigned long long>(hash),
-                    static_cast<unsigned long long>(payload.programHash));
-            return VK_NULL_HANDLE;
-        }
         m_cache.emplace(hash, PipelineCacheEntry{pipeline, payload.programHash, payload.renderPass,
                                                  m_frameCounter});
         return pipeline;
@@ -412,12 +389,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         tessellation.patchControlPoints = payload.patchControlPoints;
 
         VkPipelineViewportStateCreateInfo vpci{VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO};
-        // Both counts move together: GL has one scissor rectangle per viewport, and Vulkan
-        // requires viewportCount == scissorCount whenever both are dynamic
-        // (VUID-VkPipelineViewportStateCreateInfo-scissorCount-04136). The caller has already
-        // clamped this to the device's multiViewport capability.
-        vpci.viewportCount = std::max<Uint32>(payload.viewportCount, 1u);
-        vpci.scissorCount = vpci.viewportCount;
+        vpci.viewportCount = 1;
+        vpci.scissorCount = 1;
 
         VkPipelineRasterizationStateCreateInfo raster{VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO};
         raster.polygonMode = payload.polygonMode;
@@ -440,14 +413,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         VkPipelineMultisampleStateCreateInfo ms{VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO};
         ms.rasterizationSamples = payload.rasterizationSamples;
-        ms.sampleShadingEnable = payload.sampleShadingEnable ? VK_TRUE : VK_FALSE;
-        // Ignored by Vulkan unless sampleShadingEnable is set, but written unconditionally so the
-        // struct's bytes match the hash the payload was keyed by.
-        ms.minSampleShading = payload.minSampleShading;
-        // GL_SAMPLE_MASK / glSampleMaski. Left at nullptr - which Vulkan reads as all-ones - until
-        // now, so glSampleMaski was a silent no-op on this backend while DirectGLES forwarded it.
-        // The pointer has to outlive the vkCreateGraphicsPipelines call, which the payload does.
-        ms.pSampleMask = payload.sampleMask;
 
         VkPipelineDepthStencilStateCreateInfo depthStencil{VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO};
         depthStencil.depthTestEnable = payload.depthTestEnable ? VK_TRUE : VK_FALSE;
@@ -493,56 +458,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         blend.attachmentCount = payload.colorAttachmentCount;
         blend.pAttachments = colorAttachments.empty() ? nullptr : colorAttachments.data();
 
-        // A GL program may have a tessellation EVALUATION stage and no CONTROL stage: GL 4.6 core
-        // 11.2.2 gives it a fixed-function pass-through instead. Vulkan has no such stage, and
-        // VUID-VkGraphicsPipelineCreateInfo-pStages-00730 requires both tessellation stages or
-        // neither - so the renderer synthesizes the pass-through GL describes and hands it in
-        // here (see ProgramFactory::GetOrCreatePassthroughTessControlStage).
-        //
-        // The refusal below is what keeps the half-tessellated shape away from the driver when
-        // there is no synthesized stage to add - because Mali does not reject it, it dereferences
-        // null INSIDE vkCreateGraphicsPipelines and takes the process down (SIGSEGV, fault addr
-        // 0x34, on Mali-G715/r54p2 and Mali-G925/r49p1 alike; Adreno and lavapipe merely render
-        // wrong). Returning VK_NULL_HANDLE routes this through the same path a driver rejection
-        // takes: the draw is skipped, nothing is memoised, and the process survives.
-        const Vector<VkPipelineShaderStageCreateInfo>* effectiveStages = payload.stages;
-        Vector<VkPipelineShaderStageCreateInfo> stagesWithPassthrough;
-        if (payload.passthroughTessControlStage.module != VK_NULL_HANDLE) {
-            stagesWithPassthrough = *payload.stages;
-            stagesWithPassthrough.push_back(payload.passthroughTessControlStage);
-            effectiveStages = &stagesWithPassthrough;
-        }
-        {
-            VkShaderStageFlags stagesPresent = 0;
-            for (const auto& stageInfo : *effectiveStages) {
-                stagesPresent |= stageInfo.stage;
-            }
-            const Bool hasTessControl = (stagesPresent & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) != 0;
-            const Bool hasTessEval = (stagesPresent & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) != 0;
-            if (hasTessControl != hasTessEval) {
-                // Latched, and the latch is the point: a failed creation is deliberately never
-                // memoised (see GetOrCreatePipeline), so a program in this state re-enters here
-                // once per draw, every frame - and a refusal diagnostic that repeats per draw is
-                // noise, not a diagnostic. One line names the program; the draws it explains are
-                // all the same draw.
-                static Bool s_warnedHalfTessellatedPipeline = false;
-                if (!s_warnedHalfTessellatedPipeline) {
-                    s_warnedHalfTessellatedPipeline = true;
-                    MGLOG_E_ONCE("PipelineFactory::CreatePipeline: refusing a pipeline with %s tessellation stage and "
-                            "no %s stage (VUID-VkGraphicsPipelineCreateInfo-pStages-00730). programHash=0x%llx "
-                            "patchControlPoints=%u. Its draws are skipped; logged once.",
-                            hasTessEval ? "an evaluation" : "a control",
-                            hasTessEval ? "control" : "evaluation",
-                            static_cast<unsigned long long>(payload.programHash),
-                            payload.patchControlPoints);
-                }
-                return VK_NULL_HANDLE;
-            }
-        }
-
         VkGraphicsPipelineCreateInfo gpi{VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO};
-        gpi.stageCount = static_cast<Uint32>(effectiveStages->size());
-        gpi.pStages = effectiveStages->data();
+        gpi.stageCount = static_cast<Uint32>(payload.stages->size());
+        gpi.pStages = payload.stages->data();
         gpi.pVertexInputState = payload.vertexInputState;
         gpi.pInputAssemblyState = &ia;
         gpi.pTessellationState =
@@ -559,13 +477,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         VkPipeline pipeline = VK_NULL_HANDLE;
         const VkResult result = vkCreateGraphicsPipelines(m_device, m_pipelineCache, 1, &gpi, nullptr, &pipeline);
-        // Loud, at MGLOG_F, and deliberately NOT latched. vkCreateGraphicsPipelines refusing a
-        // pipeline MobileGL assembled is a should-never-happen state, and the driver's own
-        // answer is VK_ERROR_UNKNOWN - no information at all - so this dump is the entire
-        // diagnosis. It is not an expected failure mode, so the one-shot rule that quiets W/E
-        // does not apply: while this is reachable it should keep saying so on every draw.
-        // GetOrCreatePipeline deliberately does not cache the failure, which is what makes that
-        // repetition happen; if the repetition ever needs to stop, fix the pipeline, not the log.
         if (result != VK_SUCCESS) {
             MGLOG_F("PipelineFactory::CreatePipeline failed: result=%s (%d) programHash=0x%llx vertexInputHash=0x%llx stageCount=%u topology=%s(%d) colorAttachmentCount=%u samples=%s(%d) subpass=%u",
                     VkResultToString(result),
@@ -596,36 +507,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             MGLOG_F("PipelineFactory::CreatePipeline vertex input: bindingCount=%u attributeCount=%u",
                     payload.vertexInputState->vertexBindingDescriptionCount,
                     payload.vertexInputState->vertexAttributeDescriptionCount);
-            // The driver's own answer is VK_ERROR_UNKNOWN, i.e. no information at all, so the only
-            // way to work out WHICH shader it choked on (the open sampler-array-in-struct
-            // investigation) is to name the modules. MGLOG_I, not _D: this is part of a
-            // should-never-happen report and must survive in the INFO-level builds that CTS
-            // actually runs against, alongside the MGLOG_F lines above.
-            if (payload.stageSpirvDigests) {
-                for (SizeT i = 0; i < payload.stageSpirvDigests->size(); ++i) {
-                    const auto& digest = (*payload.stageSpirvDigests)[i];
-                    MGLOG_I("PipelineFactory::CreatePipeline spirv[%zu]: stage=0x%x words=%u bytes=%zu "
-                            "hash=0x%llx",
-                            i, digest.stage, digest.wordCount,
-                            static_cast<SizeT>(digest.wordCount) * sizeof(Uint32),
-                            static_cast<unsigned long long>(digest.hash));
-                }
-            } else {
-                MGLOG_I("PipelineFactory::CreatePipeline: no SPIR-V digests attached to the payload");
-            }
-            if (payload.stages) {
-                for (SizeT i = 0; i < payload.stages->size(); ++i) {
-                    const auto& stage = (*payload.stages)[i];
-                    // VkShaderModule is a non-dispatchable handle: a pointer on 64-bit but a
-                    // plain uint64_t on 32-bit ABIs, where a cast to const void* is ill-formed
-                    // (broke the armeabi-v7a build). Print it as the 64-bit value it is.
-                    MGLOG_I("PipelineFactory::CreatePipeline stage[%zu]: stage=0x%x module=0x%llx entry=%s "
-                            "specialization=%d",
-                            i, static_cast<Uint32>(stage.stage),
-                            static_cast<unsigned long long>(reinterpret_cast<Uint64>(stage.module)),
-                            stage.pName ? stage.pName : "(null)", stage.pSpecializationInfo ? 1 : 0);
-                }
-            }
             for (Uint32 i = 0; i < payload.colorAttachmentCount; ++i) {
                 const auto& attachment = payload.colorBlendAttachments[i];
                 MGLOG_F("PipelineFactory::CreatePipeline colorAttachment[%u]: blend=%d colorWriteMask=0x%x srcColor=%d dstColor=%d colorOp=%d srcAlpha=%d dstAlpha=%d alphaOp=%d",

MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.h

@@ -14,16 +14,6 @@
 #include <Includes.h>
 
 namespace MobileGL::MG_Backend::DirectVulkan {
-    // Enough of a fingerprint to identify the exact module the driver rejected without keeping the
-    // SPIR-V alive for every program in the cache: a driver that answers VK_ERROR_UNKNOWN tells us
-    // nothing, so the log has to carry the shader's identity itself. Diagnostic only - never part
-    // of any pipeline or program hash.
-    struct ShaderStageSpirvDigest {
-        Uint32 stage = 0; // VkShaderStageFlagBits
-        Uint32 wordCount = 0;
-        Uint64 hash = 0;
-    };
-
     class PipelineFactory {
     public:
         using HashType = Uint64;
@@ -37,47 +27,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkRenderPass renderPass = VK_NULL_HANDLE;
             Uint32 colorAttachmentCount = 1;
             VkSampleCountFlagBits rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
-            // glEnable(GL_SAMPLE_SHADING) + glMinSampleShading, which Vulkan bakes into the
-            // pipeline rather than exposing as dynamic state - so both are part of the pipeline's
-            // identity and both are hashed. The renderer leaves the enable false unless the
-            // device's sampleRateShading feature was enabled
-            // (VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784).
-            Bool sampleShadingEnable = false;
-            Float minSampleShading = 0.0f;
-            // glEnable(GL_SAMPLE_MASK) + glSampleMaski, the fixed-function coverage mask, already
-            // reduced to what GL says this draw gets (VulkanRenderer::ResolveEffectiveSampleMask:
-            // all-ones unless the target is genuinely multisampled). Pipeline state like the two
-            // above - Vulkan has no dynamic sample mask before VK_EXT_extended_dynamic_state3 -
-            // so it is hashed with them, and all-ones has to keep producing the pipeline a null
-            // pSampleMask always did.
-            //
-            // TWO words, though GL only ever fills the first. GL_MAX_SAMPLE_MASK_WORDS is clamped
-            // to 1 on both backends, so glSampleMaski writes index 0 and nothing else - but the
-            // count Vulkan READS is ceil(rasterizationSamples / 32), which is 2 on a 64-sample
-            // target, and GetAdvertisedMaxSamples does not cap the driver's sample count. A
-            // single Uint32 here let such a pipeline read one word past the member (the next
-            // struct field). The second word is all-ones: full coverage for samples 32..63, which
-            // is the only honest answer when GL has no state describing them.
-            Uint32 sampleMask[2] = {0xffffffffu, 0xffffffffu};
             Uint32 subpass = 0;
             VkPrimitiveTopology topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
             Bool primitiveRestartEnable = false;
             // GL_PATCH_VERTICES; only read for a PATCH_LIST topology.
             Uint32 patchControlPoints = 3;
-            // ProgramFactory::ComputePassthroughTessControlKey of the synthesized pass-through
-            // tessellation control stage below, or 0 when this pipeline has none. Hashed, because
-            // the levels glPatchParameterfv set are compiled INTO that module and are not a
-            // function of the program or of patchControlPoints - see the note on
-            // passthroughTessControlStage.
-            Uint64 passthroughTessControlKey = 0;
-            // How many of ARB_viewport_array's viewports this pipeline rasterizes into. 1 for
-            // every program that never assigns gl_ViewportIndex, which is all of them outside the
-            // conformance suite - the wide shape costs a longer vkCmdSetViewport/Scissor per state
-            // change and can cost hardware fast paths, so it is opt-in per program. Baked into the
-            // pipeline (viewportCount is not dynamic without VK_EXT_extended_dynamic_state) and
-            // therefore hashed; the DYNAMIC viewport/scissor arrays the draw pushes must have
-            // exactly this many elements (VUID-vkCmdDraw-viewportCount-03417/-03418).
-            Uint32 viewportCount = 1;
             VkPolygonMode polygonMode = VK_POLYGON_MODE_FILL;
             VkCullModeFlags cullMode = VK_CULL_MODE_BACK_BIT;
             VkFrontFace frontFace = VK_FRONT_FACE_CLOCKWISE;
@@ -107,21 +61,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Bool fragmentReplacesDepth = false;
             Array<VkPipelineColorBlendAttachmentState, kMaxColorAttachments> colorBlendAttachments{};
             const Vector<VkPipelineShaderStageCreateInfo>* stages = nullptr;
-            // The tessellation control stage this renderer synthesized for a program that has
-            // an evaluation stage and none of its own (GL 4.6 core 11.2.2 gives such a program a
-            // fixed-function pass-through; Vulkan has no such thing and
-            // VUID-VkGraphicsPipelineCreateInfo-pStages-00730 forbids the half-tessellated
-            // pipeline outright). Appended to `stages` at creation. A null module means the
-            // renderer could not build one, and CreatePipeline refuses the pipeline - the same
-            // refusal it applies when `stages` itself is half-tessellated.
-            //
-            // NOT hashed directly: it is a pure function of the program, of patchControlPoints and
-            // of the default tessellation levels - the first two of which ComputeHash already
-            // mixes in, and the third of which arrives through passthroughTessControlKey above.
-            VkPipelineShaderStageCreateInfo passthroughTessControlStage{};
             const VkPipelineVertexInputStateCreateInfo* vertexInputState = nullptr;
-            // Diagnostic only; may be null. Read solely from the pipeline-creation failure path.
-            const Vector<ShaderStageSpirvDigest>* stageSpirvDigests = nullptr;
         };
 
         explicit PipelineFactory(VkDevice device, const VulkanRendererConfig& config);

MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.h

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "../VkIncludes.h"
-#include "PipelineFactory.h"
 #include "MG_State/GLState/ProgramState/ProgramObject.h"
 #include "MG_State/GLState/ProgramState/ShaderObject.h"
 #include "MG_State/GLState/TextureState/TextureEnum.h"
@@ -33,13 +32,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             CombinedImageSampler,
             UniformTexelBuffer,
             StorageBuffer,
-            StorageImage,
-            // GLSL `imageBuffer` - a buffer texture reached through an IMAGE unit rather than a
-            // texture unit. Vulkan spells it VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, which is a
-            // VkBufferView like UniformTexelBuffer and not a VkImageView like StorageImage: it is
-            // the one image uniform whose descriptor is a buffer. Appended, never inserted -
-            // DescriptorKeyHash mixes the enumerator's value.
-            StorageTexelBuffer
+            StorageImage
         };
 
         enum class CompileOptionBit : Uint {
@@ -59,73 +52,19 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // recorded while GL transform feedback is active, so plain draws keep the
             // undecorated variant.
             XfbCapture = 1 << 6,
-            // Rewrites the fragment stage's gl_FragCoord reads to GL's bottom-left window
-            // origin. Vulkan's gl_FragCoord.y IS the framebuffer row being written, and the
-            // default framebuffer's image is stored in display (top-left) order, so a shader
-            // that reads gl_FragCoord there sees `height - y_GL`. Set together with
-            // PositionYFlip (the two are the same fact about the same draws) except under a
-            // quarter turn, which this renderer does not convert rectangles for either.
-            FragCoordYFlip = 1 << 7,
-            // Replaces the vertex stage's gl_BaseVertex reads with zero. GL defines the builtin
-            // as zero for every drawing command that has no baseVertex parameter - all the
-            // DrawArrays forms - while Vulkan's BaseVertex reports firstVertex there. Set only
-            // for a non-indexed draw whose program actually reads the builtin, so nothing else
-            // acquires a second program/pipeline variant. See ZeroBaseVertexPass.
-            ZeroBaseVertex = 1 << 8,
         };
         using CompileOptionFlags = Flags<CompileOptionBit>;
         using HashType = Uint64;
 
-        // The gl_PerVertex members a pass-through tessellation control stage may have to carry,
-        // in the order glslang declares them - which is the order a redeclaration must use.
-        // Which of them exist is a function of the neighbouring stage's GLSL VERSION
-        // (gl_CullDistance joins the block at #version 450), so the mask is read off that
-        // stage's SPIR-V rather than assumed. See ReflectPerVertexInputMembers.
-        enum class PerVertexMemberBit : Uint32 {
-            Position = 1u << 0,
-            PointSize = 1u << 1,
-            ClipDistance = 1u << 2,
-            CullDistance = 1u << 3,
-        };
-        // What a program parsed below #version 450 carries, and the fallback when a module's
-        // block cannot be read.
-        static constexpr Uint32 kDefaultPerVertexMembers =
-            static_cast<Uint32>(PerVertexMemberBit::Position) | static_cast<Uint32>(PerVertexMemberBit::PointSize) |
-            static_cast<Uint32>(PerVertexMemberBit::ClipDistance);
-
-        struct UpdateAfterBindLimits {
-            Bool enabled = false;
-            Uint32 maxPerStageSamplers = 0;
-            Uint32 maxPerStageUniformBuffers = 0;
-            Uint32 maxPerStageStorageBuffers = 0;
-            Uint32 maxPerStageSampledImages = 0;
-            Uint32 maxPerStageStorageImages = 0;
-            Uint32 maxPerStageResources = 0;
-            Uint32 maxSetSamplers = 0;
-            Uint32 maxSetUniformBuffers = 0;
-            Uint32 maxSetUniformBuffersDynamic = 0;
-            Uint32 maxSetStorageBuffers = 0;
-            Uint32 maxSetStorageBuffersDynamic = 0;
-            Uint32 maxSetSampledImages = 0;
-            Uint32 maxSetStorageImages = 0;
-        };
-
         struct VkProgramObject {
             static constexpr Uint32 kMaxVertexInputLocations = 32;
 
             HashType hash = 0;
             Vector<VkPipelineShaderStageCreateInfo> stages;
             Vector<VkShaderModule> modules;
-            // Parallel to stages; identifies the exact module bytes handed to the driver when a
-            // pipeline creation fails. Sixteen bytes per stage instead of keeping the SPIR-V.
-            Vector<ShaderStageSpirvDigest> stageSpirvDigests;
 
             // Layout data (previously in separate VkProgramLayout)
             VkDescriptorSetLayout descriptorSetLayout = VK_NULL_HANDLE;
-            // True only when this layout passed every descriptor-indexing feature and
-            // update-after-bind limit gate at reflection time. It controls both the
-            // layout/binding flags and the pool class used by UniformManager.
-            Bool usesUpdateAfterBind = false;
             VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
             Vector<DescriptorBindingKind> bindingKinds;
             // The bindings this program actually declares, ascending. bindingKinds is sized to the
@@ -136,9 +75,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Vector<Uint32> activeBindings;
             Vector<Uint32> dynamicBindings;
             Vector<Int> uniformBlockIndexByBinding;
-            // Descriptor count per binding (1 except for a descriptor ARRAY - a UBO or storage
-            // block instance array, an image uniform array or a sampler uniform array - each of
-            // which occupies one binding with descriptorCount = N).
+            // Descriptor count per binding (1 except for UBO instance arrays, which occupy one
+            // binding with descriptorCount = N).
             Vector<Uint16> bindingDescriptorCounts;
             // Per-element GL uniform block indices for arrayed UBO bindings (count > 1);
             // element 0 of a non-arrayed binding stays in uniformBlockIndexByBinding.
@@ -147,11 +85,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Vector<Int> samplerUniformLocationByBinding;
             Vector<TextureTarget> samplerTextureTargetByBinding;
             Vector<SamplerNumericDomain> samplerNumericDomainByBinding;
-            // Shared by StorageImage and StorageTexelBuffer bindings: a binding is one kind or
-            // the other, never both, and both need exactly the same thing - the format the
-            // shader declared, so the per-draw resolve can tell a typed declaration from a
-            // formatless one. Kept as one pair rather than two so the move operations below
-            // cannot drift out of sync with a field that only one kind populates.
             Vector<VkFormat> storageImageFormatByBinding;
             Vector<Bool> storageImageUsesBindingFormatByBinding;
             Vector<String> storageBlockNameByBinding;
@@ -159,19 +92,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // Set once during ReflectLayout so the per-draw path can skip the whole
             // storage-image preparation for the overwhelming majority of programs.
             Bool hasStorageImages = false;
-            // Something about this program's descriptors could not be resolved - an opaque
-            // uniform array whose elements have no addressable uniform locations (the
-            // multi-dimensional case), or a binding remap that failed outright. The binding
-            // STAYS DECLARED in the descriptor set layout; declining is done here, by refusing
-            // every draw, and BindProgramUniformBuffers returns false so the draw setup skips
-            // the draw exactly as it does for any other bind failure.
-            //
-            // Keeping the layout intact is the load-bearing half. Shrinking it instead - which
-            // is what the first cut of this did - leaves the shader reading a descriptor the
-            // layout never declared, and lavapipe segfaults on that inside PIPELINE CREATION,
-            // in a JIT worker thread, before any draw runs where a refusal could help. The
-            // reason was logged once at MGLOG_I when the descriptor was declined.
-            Bool declinedDescriptors = false;
             Int globalUboBinding = -1;
             Uint32 activeVertexInputLocationMask = 0;
             Array<GLenum, kMaxVertexInputLocations> vertexInputTypes{};
@@ -184,68 +104,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // gl_FragDepth); shader-computed depth is immune to the cross-pipeline
             // position-invariance quirk (see PipelineFactory::ShouldSuppressDepthWrite).
             Bool fragmentReplacesDepth = false;
-            // The vertex module declares the BaseVertex builtin. Selects the ZeroBaseVertex
-            // program variant for non-indexed draws, and is deliberately a property of the
-            // PROGRAM rather than of the variant: the zeroed variant leaves the variable
-            // declared, so both variants answer the same and the draw path can ask either.
-            Bool readsBaseVertexBuiltin = false;
-            // Some pre-rasterization stage assigns gl_ViewportIndex. Its pipeline declares
-            // viewportCount = the renderer's rasterizable viewport count instead of 1, and its
-            // draws push the whole viewport/scissor array; every other program keeps the
-            // single-viewport fast path untouched. Part of the program's identity (folded into
-            // the pipeline hash through programHash), so no memo can serve the wrong shape.
-            Bool writesViewportIndexBuiltin = false;
-            // This program has a tessellation EVALUATION stage and no tessellation CONTROL
-            // stage. GL allows that (4.6 core 11.2.2: with no control shader the input patch
-            // is passed through unmodified, the output patch size is PATCH_VERTICES, and the
-            // levels come from the PATCH_DEFAULT_*_LEVEL state); Vulkan does not - either both
-            // tessellation stages are present or neither
-            // (VUID-VkGraphicsPipelineCreateInfo-pStages-00730). So the draw path has to supply
-            // the pass-through stage GL describes; see GetOrCreatePassthroughTessControlStage.
-            // True when this program was built AS a transform-feedback capture variant but its
-            // last pre-rasterization module does NOT carry the Xfb execution mode - so the
-            // renderer must decline the capture span instead of issuing
-            // vkCmdBeginTransformFeedbackEXT against it
-            // (VUID-vkCmdBeginTransformFeedbackEXT-None-04128).
-            //
-            // Two ways to get here, and neither is visible from GL state, which is all
-            // BeginXfbCaptureForDraw otherwise consults: the clip/XFB validation backstop had to
-            // rewind past the capture decoration, or XfbCaptureDecoratePass resolved none of the
-            // requested varyings and returned without changing anything (its own MGLOG_E path)
-            // while its runner still reported success. Both used to ship a non-Xfb module under
-            // an Xfb-flagged cache entry - the flag and the layout are part of the program cache
-            // key, so it was sticky for every later captured draw of the program, not a glitch.
-            Bool xfbCaptureDeclined = false;
-            // The program has a tessellation or geometry module declaring TessellationPointSize /
-            // GeometryPointSize on a device whose shaderTessellationAndGeometryPointSize feature
-            // is off, so a pipeline built from it is invalid usage
-            // (VUID-RuntimeSpirv-PointSize-06439). Its draws are refused in SetupDraw rather than
-            // handed to the driver - the same contract PipelineFactory's half-tessellated refusal
-            // implements one level up, and the counterpart of the DirectGLES arm that reports a
-            // driver with neither point-size extension by name.
-            //
-            // Sticky by construction, which is what makes ONE log line honest: the flag lives on
-            // the cache entry, so every later draw of the same program variant reads the same
-            // answer instead of re-deciding it.
-            Bool pointSizeCapabilityUnsupported = false;
-            Bool needsPassthroughTessControl = false;
-            // ...and the pass-through this renderer can synthesize carries gl_Position and
-            // nothing else, so it is only correct when the evaluation stage's inputs are
-            // built-ins. A user-defined varying would arrive at the evaluation stage
-            // UNWRITTEN once a control stage sits between it and the vertex stage, which is
-            // silently wrong pixels rather than a crash - so those programs are declined
-            // instead (PipelineFactory::CreatePipeline refuses the pipeline and the draw is
-            // skipped). See ReflectPassthroughTessControlNeed.
-            Bool passthroughTessControlEmulatable = false;
-            // Which gl_PerVertex members the evaluation stage's `in gl_PerVertex gl_in[]` block
-            // actually carries, as a PerVertexMemberBit mask read off its SPIR-V. The synthesized
-            // control stage has to redeclare the SAME shape: glslang appends gl_CullDistance to
-            // that block from #version 450 upward, so a 450/460 program - and every ESSL program,
-            // which the source processor rewrites to "#version 460 core" - carries four members
-            // where a 430 program carries three. A fixed three-member pass-through fed the
-            // evaluation stage a differently-shaped block, which is the black-frame-no-error case
-            // this whole family is written around.
-            Uint32 passthroughPerVertexMembers = 0;
             // 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).
@@ -260,16 +118,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 hash = other.hash;
                 stages = std::move(other.stages);
                 modules = std::move(other.modules);
-                // Must travel with `modules`: these digests name the SPIR-V those exact
-                // shader modules were built from, and the pipeline-failure diagnostics
-                // print the two together. Leaving it behind used to merely lose the
-                // digests on a rehash; now that the cache is a robin-hood table, insertion
-                // SWAPS two entries, and a field that no move touches stays behind in the
-                // slot - pairing one program's modules with another program's digests, so
-                // a pipeline failure would be reported against the wrong SPIR-V.
-                stageSpirvDigests = std::move(other.stageSpirvDigests);
                 descriptorSetLayout = other.descriptorSetLayout;
-                usesUpdateAfterBind = other.usesUpdateAfterBind;
                 pipelineLayout = other.pipelineLayout;
                 bindingKinds = std::move(other.bindingKinds);
                 activeBindings = std::move(other.activeBindings);
@@ -287,7 +136,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 storageBlockNameByBinding = std::move(other.storageBlockNameByBinding);
                 storageBlockIndexByBinding = std::move(other.storageBlockIndexByBinding);
                 hasStorageImages = other.hasStorageImages;
-                declinedDescriptors = other.declinedDescriptors;
                 globalUboBinding = other.globalUboBinding;
                 activeVertexInputLocationMask = other.activeVertexInputLocationMask;
                 vertexInputTypes = other.vertexInputTypes;
@@ -297,18 +145,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 producerOutputComponentCount = other.producerOutputComponentCount;
                 fragmentInputComponentCount = other.fragmentInputComponentCount;
                 fragmentReplacesDepth = other.fragmentReplacesDepth;
-                readsBaseVertexBuiltin = other.readsBaseVertexBuiltin;
-                writesViewportIndexBuiltin = other.writesViewportIndexBuiltin;
-                needsPassthroughTessControl = other.needsPassthroughTessControl;
-                passthroughTessControlEmulatable = other.passthroughTessControlEmulatable;
-                passthroughPerVertexMembers = other.passthroughPerVertexMembers;
                 lastUsedFrame = other.lastUsedFrame;
                 other.hash = 0;
                 other.descriptorSetLayout = VK_NULL_HANDLE;
-                other.usesUpdateAfterBind = false;
                 other.pipelineLayout = VK_NULL_HANDLE;
                 other.hasStorageImages = false;
-                other.declinedDescriptors = false;
                 other.globalUboBinding = -1;
                 other.activeVertexInputLocationMask = 0;
                 other.activeFragmentOutputLocationMask = 0;
@@ -316,11 +157,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 other.producerOutputComponentCount = 0;
                 other.fragmentInputComponentCount = 0;
                 other.fragmentReplacesDepth = false;
-                other.readsBaseVertexBuiltin = false;
-                other.writesViewportIndexBuiltin = false;
-                other.needsPassthroughTessControl = false;
-                other.passthroughTessControlEmulatable = false;
-                other.passthroughPerVertexMembers = 0;
                 other.lastUsedFrame = 0;
             }
             VkProgramObject& operator=(VkProgramObject&& other) noexcept {
@@ -331,9 +167,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 hash = other.hash;
                 stages = std::move(other.stages);
                 modules = std::move(other.modules);
-                stageSpirvDigests = std::move(other.stageSpirvDigests); // travels with `modules` - see the move ctor
                 descriptorSetLayout = other.descriptorSetLayout;
-                usesUpdateAfterBind = other.usesUpdateAfterBind;
                 pipelineLayout = other.pipelineLayout;
                 bindingKinds = std::move(other.bindingKinds);
                 activeBindings = std::move(other.activeBindings);
@@ -351,7 +185,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 storageBlockNameByBinding = std::move(other.storageBlockNameByBinding);
                 storageBlockIndexByBinding = std::move(other.storageBlockIndexByBinding);
                 hasStorageImages = other.hasStorageImages;
-                declinedDescriptors = other.declinedDescriptors;
                 globalUboBinding = other.globalUboBinding;
                 activeVertexInputLocationMask = other.activeVertexInputLocationMask;
                 vertexInputTypes = other.vertexInputTypes;
@@ -361,18 +194,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 producerOutputComponentCount = other.producerOutputComponentCount;
                 fragmentInputComponentCount = other.fragmentInputComponentCount;
                 fragmentReplacesDepth = other.fragmentReplacesDepth;
-                readsBaseVertexBuiltin = other.readsBaseVertexBuiltin;
-                writesViewportIndexBuiltin = other.writesViewportIndexBuiltin;
-                needsPassthroughTessControl = other.needsPassthroughTessControl;
-                passthroughTessControlEmulatable = other.passthroughTessControlEmulatable;
-                passthroughPerVertexMembers = other.passthroughPerVertexMembers;
                 lastUsedFrame = other.lastUsedFrame;
                 other.hash = 0;
                 other.descriptorSetLayout = VK_NULL_HANDLE;
-                other.usesUpdateAfterBind = false;
                 other.pipelineLayout = VK_NULL_HANDLE;
                 other.hasStorageImages = false;
-                other.declinedDescriptors = false;
                 other.globalUboBinding = -1;
                 other.activeVertexInputLocationMask = 0;
                 other.activeFragmentOutputLocationMask = 0;
@@ -380,11 +206,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 other.producerOutputComponentCount = 0;
                 other.fragmentInputComponentCount = 0;
                 other.fragmentReplacesDepth = false;
-                other.readsBaseVertexBuiltin = false;
-                other.writesViewportIndexBuiltin = false;
-                other.needsPassthroughTessControl = false;
-                other.passthroughTessControlEmulatable = false;
-                other.passthroughPerVertexMembers = 0;
                 other.lastUsedFrame = 0;
                 return *this;
             }
@@ -412,7 +233,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 }
                 modules.clear();
                 stages.clear();
-                stageSpirvDigests.clear(); // the modules they describe are gone
             }
         };
 
@@ -428,64 +248,21 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             virtual void OnProgramEvicted(HashType programHash, VkDescriptorSetLayout descriptorSetLayout) = 0;
         };
 
-        // How this factory's compute modules implement GL_KHR_shader_subgroup. Computed
-        // once at renderer initialization (SubgroupSupportPolicy.h + the device's
-        // subgroup properties) so lowering can never disagree with the advertised
-        // capabilities. Native subgroup operations always execute natively; the two
-        // repair passes patch modules AROUND them, and the emulation only replaces them
-        // on opted-in devices with no subgroup support at all.
-        struct SubgroupLoweringPolicy {
-            Bool emulateSubgroups = false;      // MOBILEGL_MAGMA_EMULATE_SUBGROUP, no-native-support devices
-            Bool fixIterationRPSubgroupScratch = false; // patch iterationRP's under-declared scratch
-            Bool fixIterationRPBarrier = false; // repair Program 203's shared-scratch race
-            Bool deriveNumSubgroups = false;    // repair the NumSubgroups builtin
-            Bool requireFullSubgroups = false;  // computeFullSubgroups enabled on the device
-            Uint32 nativeSubgroupSize = 0;
-            // Full-subgroup launches are bounded by this device limit; a dispatch whose
-            // workgroup needs more subgroups than this cannot request the flag.
-            Uint32 maxComputeWorkgroupSubgroups = 0;
-            // VkPhysicalDeviceLimits::maxComputeSharedMemorySize; bounds the scratch the
-            // emulation pass may add (0 falls back to the Vulkan minimum, 16384).
-            Uint32 maxComputeSharedMemoryBytes = 0;
-        };
-
-        explicit ProgramFactory(VkDevice device, const VulkanRendererConfig& config, Uint32 maxBindings,
-                                Bool shaderDrawParametersEnabled,
-                                Bool unformattedFloatStorageImagesEnabled,
-                                Bool tessellationAndGeometryPointSizeEnabled,
-                                Bool enableSpirvValidation,
-                                UpdateAfterBindLimits updateAfterBindLimits,
-                                SubgroupLoweringPolicy subgroupPolicy)
+        explicit ProgramFactory(VkDevice device, const VulkanRendererConfig& config, Uint32 maxBindings = 16,
+                                Bool shaderDrawParametersEnabled = false,
+                                Bool unformattedFloatStorageImagesEnabled = false)
             : m_device(device), m_maxBindings(maxBindings), m_config(config),
               m_shaderDrawParametersEnabled(shaderDrawParametersEnabled),
-              m_unformattedFloatStorageImagesEnabled(unformattedFloatStorageImagesEnabled),
-              m_tessellationAndGeometryPointSizeEnabled(tessellationAndGeometryPointSizeEnabled),
-              m_enableSpirvValidation(enableSpirvValidation),
-              m_updateAfterBindLimits(updateAfterBindLimits),
-              m_subgroupPolicy(subgroupPolicy) {
+              m_unformattedFloatStorageImagesEnabled(unformattedFloatStorageImagesEnabled) {
             VkProgramObject::s_device = device;
         }
-        // Destroys the pass-through tessellation control modules. Runs while the device is
-        // still alive for the same reason ~VkProgramObject's does: this factory outlives
-        // nothing that owns the device.
-        ~ProgramFactory();
+        ~ProgramFactory() = default;
         ProgramFactory(const ProgramFactory&) = delete;
 
         HashType ComputeHash(const MG_State::GLState::ProgramObject& program, CompileOptionFlags flags) const;
         const VkProgramObject& GetOrCreateProgram(
             const MG_State::GLState::ProgramObject& program, CompileOptionFlags flags);
 
-        // The default framebuffer's current image height, baked as a literal into every
-        // FragCoordYFlip variant (there is no push-constant or specialization channel here, and
-        // adding one for a value that changes only on swapchain recreation would cost the draw
-        // path more than a recompile costs a resize). It is therefore part of those variants'
-        // identity: ComputeHash mixes it in when the bit is set, so a height change re-keys them
-        // and leaves every other program's hash untouched. Setting a NEW height also bumps the
-        // cache-structure epoch, because a caller holding a memoised VkProgramObject* would
-        // otherwise keep using a module compiled against the old height.
-        void SetDefaultFramebufferHeight(Uint32 height);
-        Uint32 GetDefaultFramebufferHeight() const { return m_defaultFramebufferHeight; }
-
         // 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
@@ -506,14 +283,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         static VkShaderStageFlagBits ToVkStage(ShaderStage stage);
         static VkFormat ConvertSpirvImageFormatToVkFormat(SpvImageFormat format);
         static SamplerNumericDomain UniformTypeToSamplerNumericDomain(GLenum glType);
-        // The same question for an IMAGE uniform (`image2D`, `uimageBuffer`, ...), which the
-        // sampler form above deliberately does not answer. Kept separate rather than folded in
-        // because the two are asked in different places for different reasons: a sampler's domain
-        // decides a sampled VIEW format, an image's decides what a placeholder descriptor for an
-        // UNBOUND image unit must be (see UniformManager::AcquireUnboundTexelBufferView and
-        // GetUnboundStorageImageTexture) - a formatless `writeonly` declaration reflects no
-        // format at all, and the numeric domain is then the only thing that constrains it.
-        static SamplerNumericDomain UniformTypeToImageNumericDomain(GLenum glType);
         // True when any entry point declares the DepthReplacing execution mode, i.e. the
         // shader assigns gl_FragDepth. Exposed so the blended depth-write quirk's exemption
         // can be pinned by tests. A false negative loses the exemption, so such a shader is
@@ -522,61 +291,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // True when an entry point reads the InstanceIndex builtin. Only gates a diagnostic:
         // without shaderDrawParameters such a shader cannot have gl_InstanceID rebased.
         static Bool ReflectedReadsInstanceIndexBuiltin(const SpvReflectShaderModule& reflectModule);
-        // True when an entry point declares the BaseVertex builtin, i.e. when a non-indexed
-        // draw with this program has to take the ZeroBaseVertex variant.
-        static Bool ReflectedReadsBaseVertexBuiltin(const SpvReflectShaderModule& reflectModule);
-        // Shared by the two above: does any entry point list an input variable decorated with
-        // this builtin?
-        static Bool ReflectedDeclaresInputBuiltin(const SpvReflectShaderModule& reflectModule, SpvBuiltIn builtin);
-        // True when an entry point writes the ViewportIndex builtin (gl_ViewportIndex), i.e. when
-        // the program can route primitives to a viewport other than 0 and its pipeline therefore
-        // has to declare more than one. Asks about OUTPUT variables because that is the direction
-        // a pre-rasterization stage declares it in.
-        static Bool ReflectedWritesViewportIndexBuiltin(const SpvReflectShaderModule& reflectModule);
-        static Bool ReflectedDeclaresOutputBuiltin(const SpvReflectShaderModule& reflectModule, SpvBuiltIn builtin);
-
-        // The pass-through tessellation control stage GL 4.6 core 11.2.2 describes for a
-        // program that has an evaluation stage and no control stage, for an input patch of
-        // `patchVertices` control points. Returned BY VALUE (a stage description is a POD, and
-        // the cache below is a rehashing map, so a pointer into it would not survive the next
-        // distinct patch size). `.module == VK_NULL_HANDLE` means the stage could not be built:
-        // the caller then has no control stage to inject, and CreatePipeline refuses the
-        // pipeline rather than handing the driver a half-tessellated one.
-        //
-        // Keyed on the patch size, the six default tessellation levels AND the gl_PerVertex
-        // member set, because all three decide what the generator emits. The size comes from
-        // PATCH_VERTICES and the levels from PATCH_DEFAULT_OUTER_LEVEL / PATCH_DEFAULT_INNER_LEVEL
-        // - draw state rather than link state, and the CTS case that motivated this links at the
-        // default 3 and draws at 4. The member set comes from the neighbouring evaluation stage's
-        // own SPIR-V, so two programs at different GLSL versions need different modules. The
-        // pipeline cache re-keys on the same inputs, so the module a pipeline was built with is
-        // part of that pipeline's identity. Compiling is bounded by the number of distinct
-        // (size, levels, members) combinations a program draws with - one or two in practice -
-        // and only ever happens for the rare program that has no control stage at all.
-        VkPipelineShaderStageCreateInfo GetOrCreatePassthroughTessControlStage(Uint32 patchVertices,
-                                                                              const FloatVec4& defaultOuterLevel,
-                                                                              const FloatVec2& defaultInnerLevel,
-                                                                              Uint32 perVertexMembers);
-
-        // Source of the module above. Exposed for tests: the generated GLSL is the whole
-        // contract with the evaluation stage, so it is worth pinning independently of a device.
-        static String BuildPassthroughTessControlSource(Uint32 patchVertices, const FloatVec4& defaultOuterLevel,
-                                                        const FloatVec2& defaultInnerLevel, Uint32 perVertexMembers);
-
-        // The identity of one such module: everything the generator bakes in, folded into a
-        // 64-bit key over the raw bits (so -0.0 and +0.0 key apart, which is harmless, and NaN
-        // keys to itself, which is what matters). Shared with PipelineFactory, which mixes the
-        // same value into the pipeline hash so a pipeline can never be handed a module built for
-        // different levels or a different block shape.
-        static Uint64 ComputePassthroughTessControlKey(Uint32 patchVertices, const FloatVec4& defaultOuterLevel,
-                                                       const FloatVec2& defaultInnerLevel, Uint32 perVertexMembers);
-
-        // The PerVertexMemberBit mask of the INPUT per-vertex block a module declares, read
-        // straight out of its SPIR-V (OpMemberDecorate ... BuiltIn on the struct behind the one
-        // Input variable that is an array of a Block-decorated struct). Zero when the module has
-        // no such block. Exposed for tests, which is the only way to pin the shape agreement
-        // without a device.
-        static Uint32 ReflectPerVertexInputMembers(const Vector<Uint>& spirv);
 
     private:
         struct ProgramLookupCache {
@@ -587,27 +301,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         };
 
         static TextureTarget UniformTypeToTextureTarget(GLenum glType);
-        // `stages` is ALWAYS ProgramObject::GetLinkedShaderStages() - one entry per module of
-        // `spirv`, at the same index. Taking the stages rather than the shader objects is what
-        // keeps the program's live attach list, which is a longer and differently-indexed list
-        // the moment a glAttachShader lands after the link, from being passed here by mistake.
-        void ReflectVertexInputs(const Vector<ShaderStage>& stages,
+        void ReflectVertexInputs(const Vector<SharedPtr<MG_State::GLState::ShaderObject>>& shaders,
                      const Vector<Vector<Uint>>& spirv,
                      VkProgramObject& entry) const;
-        void ReflectViewportIndexUsage(const Vector<ShaderStage>& stages,
-                                       const Vector<Vector<Uint>>& spirv,
-                                       VkProgramObject& entry) const;
-        void ReflectFragmentOutputs(const Vector<ShaderStage>& stages,
+        void ReflectFragmentOutputs(const Vector<SharedPtr<MG_State::GLState::ShaderObject>>& shaders,
                         const Vector<Vector<Uint>>& spirv,
                         VkProgramObject& entry) const;
         void ReflectLayout(const MG_State::GLState::ProgramObject& program, const Vector<Vector<Uint>>& spirv,
                            VkProgramObject& entry) const;
-        // Fills needsPassthroughTessControl / passthroughTessControlEmulatable off the linked
-        // modules. Const and reflection-only: it decides nothing about the pipeline, it only
-        // records what the evaluation stage's input interface is made of.
-        void ReflectPassthroughTessControlNeed(const Vector<ShaderStage>& stages,
-                                               const Vector<Vector<Uint>>& spirv,
-                                               VkProgramObject& entry) const;
 
         VkDevice m_device = VK_NULL_HANDLE;
         Uint32 m_maxBindings = 0;
@@ -619,42 +320,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // True only when the logical device enabled both
         // shaderStorageImageReadWithoutFormat and shaderStorageImageWriteWithoutFormat.
         Bool m_unformattedFloatStorageImagesEnabled = false;
-        // True when the logical device enabled shaderTessellationAndGeometryPointSize. When it is
-        // FALSE a program whose tessellation or geometry module declares TessellationPointSize /
-        // GeometryPointSize is refused at build time (see VkProgramObject::
-        // pointSizeCapabilityUnsupported) instead of being handed to the driver as invalid usage.
-        Bool m_tessellationAndGeometryPointSizeEnabled = false;
-        // Startup snapshot used only by internally synthesized shader modules, which do not
-        // originate from a ProgramLinkTask.
-        Bool m_enableSpirvValidation = false;
-        // Device feature and limit gate resolved before vkCreateDevice. Keeping it in
-        // the factory lets each reflected layout choose ordinary descriptors when its
-        // own counts would exceed the update-after-bind budget.
-        UpdateAfterBindLimits m_updateAfterBindLimits{};
-        SubgroupLoweringPolicy m_subgroupPolicy{};
-        // See SetDefaultFramebufferHeight. 0 means "not known yet"; the FragCoordYFlip bit is
-        // never set before the swapchain exists, so no variant can be compiled against it.
-        Uint32 m_defaultFramebufferHeight = 0;
         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;
-        // Pass-through tessellation control stages by the identity of what was compiled into
-        // them - the input patch size and the six default tessellation levels, folded into one
-        // 64-bit key by ComputePassthroughTessControlKey (the levels are float state, so the map
-        // cannot simply be keyed on the patch size any more). A failed build is cached as
-        // VK_NULL_HANDLE so a broken generator costs one compile, not one per draw.
-        //
-        // Hard-capped, because the key is application-controlled: glPatchParameterfv clamps
-        // nothing, so an application that recomputes a level per frame mints a new key per frame.
-        // Reaching the cap destroys every module and starts over (see the flush in
-        // GetOrCreatePassthroughTessControlStage); the cap is far above what any program that
-        // holds its levels still will ever need. The gl_PerVertex member set is in the key too
-        // and adds only a handful of values, so it does not move the cap in practice.
-        static constexpr SizeT kMaxPassthroughTessControlStages = 64;
-        UnorderedMap<Uint64, VkPipelineShaderStageCreateInfo> m_passthroughTessControlStages;
         static inline XXH64_state_t* m_hashState = XXH64_createState();
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/SwapchainObject.cpp

@@ -157,7 +157,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         MGLOG_I("Got %d surface formats:", swapchainCapabilities.surfaceFormats.size());
         for (const auto& sf : swapchainCapabilities.surfaceFormats) {
-            MGLOG_D("    [%s, %s]", string_VkFormat(sf.format), string_VkColorSpaceKHR(sf.colorSpace));
+            MGLOG_I("    [%s, %s]", string_VkFormat(sf.format), string_VkColorSpaceKHR(sf.colorSpace));
         }
 
         const auto pickedSurfaceFormat = ChooseSwapchainSurfaceFormat(swapchainCapabilities.surfaceFormats);
@@ -166,7 +166,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         MGLOG_I("Got %d present modes:", swapchainCapabilities.presentModes.size());
         for (const auto& pm : swapchainCapabilities.presentModes) {
-            MGLOG_D("    %s", string_VkPresentModeKHR(pm));
+            MGLOG_I("    %s", string_VkPresentModeKHR(pm));
         }
 
         const auto presentMode = ChooseSwapchainPresentMode(swapchainCapabilities.presentModes);

MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.h

@@ -26,26 +26,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     public:
         struct SamplerBindingOverride {
             Uint32 binding = 0;
-            Uint32 element = 0;
             MG_State::GLState::ITextureObject* texture = nullptr;
             const MG_State::GLState::SamplerObject* sampler = nullptr;
             VkImageView imageView = VK_NULL_HANDLE;
-            VkImageLayout imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-            Bool forceNearestFiltering = false;
         };
 
-        struct SamplerImageFeedbackBinding {
-            Uint32 samplerBinding = 0;
-            Uint32 samplerElement = 0;
-            MG_State::GLState::ITextureObject* texture = nullptr;
-            const MG_State::GLState::SamplerObject* sampler = nullptr;
-            SamplerNumericDomain numericDomain = SamplerNumericDomain::Unknown;
-        };
-
-        // `physicalDevice` is only ever asked for format properties: a placeholder descriptor for
-        // an unbound texel-buffer binding has to be built from a format the DEVICE accepts as a
-        // texel buffer, and there is no other route to that answer from here.
-        Bool Initialize(VkDevice device, VkPhysicalDevice physicalDevice, VkBufferManager* bufferManager,
+        Bool Initialize(VkDevice device, VkBufferManager* bufferManager,
                         ProgramFactory* programFactory,
                         VkDeviceSize minUniformBufferOffsetAlignment, Uint32 frameCount,
                         Uint32 maxBindings = 16, Uint32 setsPerFrame = 64,
@@ -67,13 +53,10 @@ 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 DESCRIPTOR (post fallback substitution,
-        // in binding order, and within a binding in array-element 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). An arrayed binding contributes one record per element -
-        // element granularity is required, or swapping the textures of two elements of the same
-        // array would leave the record list identical and the fast path would keep a stale set.
+        // 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;
@@ -93,12 +76,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Bool CollectStorageImageTextures(const MG_State::GLState::ProgramObject& program,
                                          const ProgramFactory::VkProgramObject& programObj,
                                          Vector<MG_State::GLState::ITextureObject*>& outTextures) const;
-        Bool CollectSamplerImageFeedback(
-            const MG_State::GLState::ProgramObject& program,
-            const ProgramFactory::VkProgramObject& programObj,
-            Vector<SamplerImageFeedbackBinding>& outBindings) const;
-        static Bool SamplerOverlapsWritableImageSubresource(Int samplerBaseLevel, Int samplerMaxLevel,
-                                                             GLint imageLevel, GLenum imageAccess);
         // 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
@@ -111,8 +88,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                        Uint32 frameIndex,
                                        VkPipelineBindPoint bindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
                                        const SamplerBindingOverride* samplerBindingOverride = nullptr,
-                                       Bool samplerDescriptorsUnchangedHint = false,
-                                       const Vector<SamplerBindingOverride>* samplerBindingOverrides = nullptr);
+                                       Bool samplerDescriptorsUnchangedHint = false);
 
         // Pure format-policy helper kept public for host regression tests. Formatted storage
         // images use their shader qualifier; transformed float images use glBindImageTexture's
@@ -135,7 +111,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkDescriptorPool handle = VK_NULL_HANDLE;
             Uint32 maxSets = 0;
             Uint32 allocatedSets = 0;
-            Bool updateAfterBind = false;
         };
 
         // A cached descriptor set together with the pool it was allocated from, so a
@@ -168,9 +143,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // 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).
-        // `element` indexes a sampler array inside the binding; see ResolveSamplerDescriptor.
         Bool ResolveSampledBinding(const MG_State::GLState::ProgramObject& program,
-                                   const ProgramFactory::VkProgramObject& programObj, Uint32 binding, Uint32 element,
+                                   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):
@@ -178,81 +152,27 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // only need the pointer skip the SharedPtr copy's atomic refcount churn.
         static MG_State::GLState::ITextureObject* ResolveSamplerTextureRaw(
             const MG_State::GLState::ProgramObject& program,
-            const ProgramFactory::VkProgramObject& programObj, Uint32 binding, Uint32 element);
-        // `numericDomain` is the sampler's class, and it matters only for the multisample arm -
-        // see GetFallbackMultisampleTexture for why the single-sampled fallback can ignore it.
-        SharedPtr<MG_State::GLState::ITextureObject> GetFallbackTexture(
-            TextureTarget target, SamplerNumericDomain numericDomain) const;
-        // The multisample arm of GetFallbackTexture. One object per (target, numeric domain) and
-        // no upload path: a multisample image cannot be written by a transfer, so its texels stay
-        // undefined - which is what GL promises for a texelFetch on an incomplete multisample
-        // texture - and it cannot carry MUTABLE_FORMAT, so its format has to match the sampler's
-        // class outright rather than being reinterpreted at view time.
-        SharedPtr<MG_State::GLState::ITextureObject> GetFallbackMultisampleTexture(
-            TextureTarget target, SamplerNumericDomain numericDomain) const;
-        // ---- placeholders for UNBOUND image-backed descriptors -------------------------
-        // GL lets a program declare `samplerBuffer`, `imageBuffer` or `image2D` and bind nothing
-        // to the unit it names: the fetch is then undefined (GL 4.6 core 8.9 for an incomplete
-        // buffer texture, 8.26 for an image unit with no texture) - undefined VALUES, not a
-        // dropped draw. Vulkan has no unwritten descriptor, so something valid has to sit in the
-        // set or the whole draw or dispatch is lost, which is what these two build. Same shape as
-        // VkBufferManager::AcquireUnboundStorageDescriptor, one level up: per FORMAT rather than
-        // one shared object, because a descriptor whose format disagrees with the shader's
-        // declaration is invalid Vulkan even when nothing ever reads it.
-        //
-        // `declaredFormat` is the format the SHADER declared (VK_FORMAT_UNDEFINED for a sampled
-        // texel buffer, which never carries one, or for a formatless `writeonly` image);
-        // `numericDomain` decides the format when there is no declaration and is the fallback
-        // class when the device cannot use the declared one as a texel buffer.
-        VkBufferView AcquireUnboundTexelBufferView(VkFormat declaredFormat, SamplerNumericDomain numericDomain,
-                                                   Bool storage);
-        // A 1x1 (x1 layer, or 6 faces for a cube) texture of `format`, shaped for `target` so the
-        // view the descriptor gets has the view type the shader's image declaration demands.
-        // Null for a target with no single-sampled placeholder shape - multisample images, whose
-        // descriptor needs a multisample view that this cannot stand in for.
-        SharedPtr<MG_State::GLState::ITextureObject> GetUnboundStorageImageTexture(TextureTarget target,
-                                                                                    VkFormat format) const;
-        // The (target, format) pair a storage-image binding's placeholder is keyed by, resolved
-        // from reflection alone. False when the binding has no placeholder shape.
-        Bool ResolveUnboundStorageImagePlaceholder(const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                                   TextureTarget& outTarget, VkFormat& outFormat) const;
-        // `element` indexes a sampler ARRAY inside one binding; each element carries its own
-        // independently assigned GL texture unit, so it selects the texture, the sampler
-        // override and the fallback separately from its neighbours.
-        //
+            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). The cache is keyed by binding alone, so it is
-        // used ONLY for single-descriptor bindings - see m_samplerResolveMemo.
+        // obligations the caller carries).
         Bool ResolveSamplerDescriptor(VkCommandBuffer commandBuffer, const MG_State::GLState::ProgramObject& program,
                                       const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                      Uint32 element, VkDescriptorImageInfo& outImageInfo,
+                                      VkDescriptorImageInfo& outImageInfo,
                                       Bool trustUnchangedHint = false) const;
         Bool ResolveSamplerDescriptorOverride(const SamplerBindingOverride& samplerBindingOverride,
                                               VkDescriptorImageInfo& outImageInfo) const;
         Bool ResolveTexelBufferDescriptor(const MG_State::GLState::ProgramObject& program,
                                           const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
                                           Uint32 frameIndex, VkBufferView& outBufferView);
-        // GLSL `imageBuffer`: the same VkBufferView descriptor as the sampled texel buffer above,
-        // but resolved from an IMAGE unit (glBindImageTexture) rather than a texture unit, and
-        // made GPU-resident-writable because the shader may store to it. No `element` parameter:
-        // an imageBuffer ARRAY is refused at program creation, so a binding is always one
-        // descriptor (see the array gate in RemapDescriptorBindingsForVulkan).
-        Bool ResolveStorageTexelBufferDescriptor(const MG_State::GLState::ProgramObject& program,
-                                                 const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                                 Uint32 frameIndex, VkBufferView& outBufferView);
-        // `element` indexes a block INSTANCE array's descriptors; it is 0 for every ordinary
-        // block. Each element resolves through its own GL storage block, and so its own GL
-        // binding point, buffer and glBindBufferRange window.
         Bool ResolveStorageBufferDescriptor(const MG_State::GLState::ProgramObject& program,
                                             const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                            Uint32 element, VkDescriptorBufferInfo& outBufferInfo) const;
-        // `element` indexes an image ARRAY inside one binding; each element carries its own
-        // independently assigned GL image unit.
+                                            VkDescriptorBufferInfo& outBufferInfo) const;
         Bool ResolveStorageImageDescriptor(VkCommandBuffer commandBuffer,
                                            const MG_State::GLState::ProgramObject& program,
                                            const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                           Uint32 element, VkDescriptorImageInfo& outImageInfo) const;
+                                           VkDescriptorImageInfo& outImageInfo) const;
         // Result of resolving a UBO binding: either a zero-copy direct bind to the app's resident
         // VkBuffer (the GLES backend's approach - no per-draw copy) or the CPU payload to upload.
         struct UboBindResult {
@@ -281,8 +201,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void BindDescriptorSetDeduped(VkCommandBuffer commandBuffer, VkPipelineBindPoint bindPoint,
                                       VkPipelineLayout pipelineLayout, VkDescriptorSet descriptorSet,
                                       const Vector<Uint32>& dynamicOffsets);
-        Bool CreateDescriptorPool(Uint32 maxSets, Bool updateAfterBind, VkDescriptorPool& outPool) const;
-        Bool GrowFrameDescriptorPool(FrameResources& frame, Uint32 frameIndex, Bool updateAfterBind);
+        Bool CreateDescriptorPool(Uint32 maxSets, VkDescriptorPool& outPool) const;
+        Bool GrowFrameDescriptorPool(FrameResources& frame, Uint32 frameIndex);
         VkResult AllocateDescriptorSetsFromActivePool(
             Uint32 frameIndex, const ProgramFactory::VkProgramObject& programObj, VkDescriptorSet& outDescriptorSet);
         VkResult AcquireDescriptorSet(Uint32 frameIndex,
@@ -290,7 +210,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                       VkDescriptorSet& outDescriptorSet);
 
         VkDevice m_device = VK_NULL_HANDLE;
-        VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
         VkBufferManager* m_bufferManager = nullptr;
         ProgramFactory* m_programFactory = nullptr;
         Vector<FrameResources> m_frames;
@@ -303,18 +222,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkTextureManager* m_textureManager = nullptr;
         VkSamplerManager* m_samplerManager = nullptr;
         mutable SharedPtr<MG_State::GLState::ITextureObject> m_fallbackTexture2D;
-        // Keyed by (arrayed, numeric domain); see GetFallbackMultisampleTexture. Lazily populated,
-        // never evicted - at most six tiny 1x1 images - and torn down with the manager.
-        mutable UnorderedMap<Uint32, SharedPtr<MG_State::GLState::ITextureObject>> m_fallbackMultisampleTextures;
-        // See AcquireUnboundTexelBufferView / GetUnboundStorageImageTexture. Both are lazily
-        // populated, never evicted (a program's declared formats are a fixed, tiny set) and torn
-        // down with the manager. The texel views are keyed by format AND by storage-vs-sampled
-        // because the two descriptor kinds demand different format FEATURES of the device, so one
-        // format can be usable for one and not the other. Deliberately NOT the per-frame
-        // texelBufferViews list: those are destroyed at every frame boundary, and these must
-        // outlive it or the placeholder would be rebuilt for every unbound binding every frame.
-        UnorderedMap<Uint64, VkBufferView> m_unboundTexelBufferViews;
-        mutable UnorderedMap<Uint64, SharedPtr<MG_State::GLState::ITextureObject>> m_unboundStorageImageTextures;
 
         // Per-draw scratch buffers for BindProgramUniformBuffers: reused (clear keeps
         // capacity) so the descriptor-write path stops allocating on every draw.
@@ -412,11 +319,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // lifetime id, so a freed-and-reallocated sampler or texture at the same heap address
         // always gets a fresh id and misses (a raw pointer would false-hit that ABA) - so a
         // stale guess can only miss and fall through to the hash, never resolve wrong. Still
-        // reset each frame alongside the descriptor-set cache. Indexed by binding, but the
-        // whole-descriptor entry is additionally keyed by program lifetime: Vulkan binding
-        // numbers are layout-local and unrelated programs routinely reuse binding 0/1.
+        // reset each frame alongside the descriptor-set cache. Indexed by binding.
         struct SamplerResolveMemo {
-            Uint64 infoProgramLifetimeId = 0;
             Uint64 samplerLifetimeId = 0;
             Uint64 textureLifetimeId = 0;
             VkSampler sampler = VK_NULL_HANDLE;
@@ -437,14 +341,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // 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).
-            //
-            // This one field is keyed by binding but describes ONE descriptor, so it is
-            // written and read only for single-descriptor bindings. A sampler ARRAY's
-            // elements share the binding and would overwrite each other here - the last
-            // element resolved would then be handed to element 0 on the next hinted draw.
-            // Every other field above is self-validating (each compares its full key
-            // before reuse, and the view-format entry is a pure function of format and
-            // numeric domain), so an arrayed binding may keep using those.
             VkDescriptorImageInfo info{};
             Bool infoValid = false;
         };

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.cpp

@@ -8,7 +8,6 @@
 
 #include "VertexInputStateFactory.h"
 #include "MG_Util/Converters/MGToStr/DataTypeConverter.h"
-#include <MG_Backend/BackendObjects.h>
 #include <utility>
 
 namespace MobileGL::MG_Backend::DirectVulkan {
@@ -108,36 +107,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 continue;
             }
 
-            VkFormat sourceVkFormat =
+            const VkFormat sourceVkFormat =
                 ToVkVertexFormat(attr.Type, attr.Size, attr.Normalized, attr.IsInteger, attr.IsBgra, attr.IsLong);
-            VertexStreamConversion conversion = VertexStreamConversion::None;
-            // Gated on the SAME flag ToVkVertexFormat gates its 64-bit path on, and that is
-            // load-bearing rather than belt-and-braces: the narrowing is only correct because the
-            // shader's `dvec` input is a `vec` by the time the pipeline is built, and what
-            // guarantees that is the flag being clear. It is clear on every backend today, and a
-            // program with a 64-bit float vertex input is demoted WHOLE for the same reason even
-            // where the device has native fp64 (ProgramSpirvTask::GenerateSpirv). With the flag
-            // set, a dvec3/dvec4 would be declined by ToVkVertexFormat AND left 64-bit in the
-            // module, so a float32 stream would be fed to a Float64 input.
-            const Bool narrowFloat64Arrays =
-                MG_Backend::pActiveBackendObject == nullptr ||
-                !MG_Backend::pActiveBackendObject->GetDynamicParameters().SupportsFloat64VertexAttributes;
-            if (sourceVkFormat == VK_FORMAT_UNDEFINED && attr.Type == DataType::Float64 && narrowFloat64Arrays) {
-                // No native 64-bit fetch here (see ToVkVertexFormat's Float64 case), but the
-                // source bytes are ordinary IEEE-754 doubles and DemoteFloat64Pass has already
-                // narrowed every dvec input to a vec, so the array is narrowed to match rather
-                // than dropped. Mirrors what DirectGLES does for the same state.
-                const VkFormat narrowedFormat = ToFloat32VertexFormat(attr.Size);
-                if (narrowedFormat != VK_FORMAT_UNDEFINED && SupportsVertexBufferFormat(narrowedFormat)) {
-                    sourceVkFormat = narrowedFormat;
-                    conversion = VertexStreamConversion::Float64ToFloat32;
-                    MGLOG_W_ONCE("Vertex attribute location=%u is a 64-bit (GL_DOUBLE) array; fetching it at "
-                            "float32 precision through format=%d (size=%d long=%s)",
-                            location, static_cast<Int>(narrowedFormat), attr.Size, attr.IsLong ? "true" : "false");
-                }
-            }
             if (sourceVkFormat == VK_FORMAT_UNDEFINED) {
-                MGLOG_E_ONCE("Unsupported vertex attribute layout (location=%u, type=%s, size=%d): the array is "
+                MGLOG_E("Unsupported vertex attribute layout (location=%u, type=%s, size=%d): the array is "
                         "enabled but cannot be mapped to a VkFormat",
                         location, MG_Util::ConvertDataTypeToString(attr.Type).c_str(), attr.Size);
                 unsupportedAttribMask |= (1u << location);
@@ -145,13 +118,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
 
             VkFormat vkFormat = sourceVkFormat;
-            if (conversion == VertexStreamConversion::None && !SupportsVertexBufferFormat(vkFormat)) {
+            VertexStreamConversion conversion = VertexStreamConversion::None;
+            if (!SupportsVertexBufferFormat(vkFormat)) {
                 if (IsScaledIntegerVertexFormat(vkFormat)) {
                     const VkFormat fallbackFormat = ToFloat32VertexFormat(attr.Size);
                     if (fallbackFormat != VK_FORMAT_UNDEFINED && SupportsVertexBufferFormat(fallbackFormat)) {
                         vkFormat = fallbackFormat;
                         conversion = VertexStreamConversion::ScaledIntegerToFloat32;
-                        MGLOG_W_ONCE("Vertex attribute location=%u format=%d lacks "
+                        MGLOG_W("Vertex attribute location=%u format=%d lacks "
                                 "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT; using float32 stream format=%d "
                                 "(type=%s size=%d normalized=%s integer=%s)",
                                 location, static_cast<Int>(sourceVkFormat), static_cast<Int>(vkFormat),
@@ -161,7 +135,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 }
 
                 if (conversion == VertexStreamConversion::None) {
-                    MGLOG_E_ONCE("Unsupported Vulkan vertex format (location=%u, format=%d, type=%s, size=%d): "
+                    MGLOG_E("Unsupported Vulkan vertex format (location=%u, format=%d, type=%s, size=%d): "
                             "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT is unavailable and no semantic fallback exists",
                             location, static_cast<Int>(sourceVkFormat),
                             MG_Util::ConvertDataTypeToString(attr.Type).c_str(), attr.Size);
@@ -172,21 +146,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
             const SizeT attribByteSize = GetAttributeByteSize(attr.Type, attr.Size, attr.IsBgra);
             if (attribByteSize == 0) {
-                MGLOG_E_ONCE("Vertex attribute with unknown component size (location=%u, type=%s): the array is "
+                MGLOG_E("Vertex attribute with unknown component size (location=%u, type=%s): the array is "
                         "enabled but cannot be sized",
                         location, MG_Util::ConvertDataTypeToString(attr.Type).c_str());
                 unsupportedAttribMask |= (1u << location);
                 continue;
             }
 
-            // Verbatim, zero included. The frontend already resolved a pointer call's
-            // "tightly packed" stride 0 into the element size (see VertexAttribute::Stride),
-            // so a zero here is the binding model's stride 0 - every vertex reads the same
-            // element - which is exactly what a zero VkVertexInputBindingDescription::stride
-            // means. Substituting the element size fetched a fresh element per vertex and ran
-            // off the end of the buffer (KHR-GL43.vertex_attrib_binding.basic-input-case7/8).
-            // Client-memory arrays cannot reach zero: they only exist on the pointer path.
-            const Uint32 sourceStride = static_cast<Uint32>(attr.Stride);
+            const Uint32 sourceStride =
+                attr.Stride > 0 ? static_cast<Uint32>(attr.Stride) : static_cast<Uint32>(attribByteSize);
             const Bool packedAttribute = attr.Type == DataType::Int2101010Rev ||
                                          attr.Type == DataType::Uint2101010Rev;
             const SizeT requiredAlignment = packedAttribute ? attribByteSize : GetComponentSize(attr.Type);
@@ -201,23 +169,16 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 // unless VK_EXT_legacy_vertex_attributes is available, so deinterleave this one
                 // attribute into a tightly packed transient stream without changing its format.
                 conversion = VertexStreamConversion::Repack;
-                MGLOG_W_ONCE("Vertex attribute location=%u uses Vulkan-incompatible alignment "
+                MGLOG_W("Vertex attribute location=%u uses Vulkan-incompatible alignment "
                         "(offset=%zu stride=%u required=%zu); using a tightly packed stream",
                         location, attr.Offset, sourceStride, requiredAlignment);
             }
 
             Uint32 stride = sourceStride;
-            // A converted stream is tightly packed, so its stride is the converted element
-            // size - unless the source stride is zero, which does not describe a packing at
-            // all but "never advance". That survives the conversion unchanged: the draw path
-            // converts exactly one element and every vertex reads it.
-            if (sourceStride != 0) {
-                if (conversion == VertexStreamConversion::Repack) {
-                    stride = static_cast<Uint32>(attribByteSize);
-                } else if (conversion == VertexStreamConversion::ScaledIntegerToFloat32 ||
-                           conversion == VertexStreamConversion::Float64ToFloat32) {
-                    stride = static_cast<Uint32>(attr.Size * static_cast<Int>(sizeof(Float)));
-                }
+            if (conversion == VertexStreamConversion::Repack) {
+                stride = static_cast<Uint32>(attribByteSize);
+            } else if (conversion == VertexStreamConversion::ScaledIntegerToFloat32) {
+                stride = static_cast<Uint32>(attr.Size * static_cast<Int>(sizeof(Float)));
             }
             const VkVertexInputRate inputRate =
                 (attr.Divisor == 0) ? VK_VERTEX_INPUT_RATE_VERTEX : VK_VERTEX_INPUT_RATE_INSTANCE;
@@ -314,10 +275,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             if (m_frameBoundaryCounter - it->second->lastUsedFrameBoundary > kRetireAgeBoundaries) {
                 it = m_cache.erase(it);
                 // Invalidate every VAO's state-pointer memo: the erased node's
-                // address may be reused by a future insert. Advance through the
-                // process-wide source so the value stays unique across factory
-                // instances (see the member comment).
-                m_evictionEpoch = ++s_evictionEpochSource;
+                // address may be reused by a future insert.
+                ++m_evictionEpoch;
             } else {
                 ++it;
             }
@@ -357,20 +316,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // 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.
-            //
-            // ... as long as the shader half still runs. It does not when the backend has declared
-            // no 64-bit vertex attribute support: DemoteFloat64Pass has already narrowed every
-            // `dvec` input to a `vec` by then, so PackDoubleVertexInputsPass finds nothing to pack
-            // and a UINT-formatted attribute would be fed to a float input - garbage with no
-            // diagnostic anywhere. Declining here hands the attribute to the caller's
-            // Float64ToFloat32 fallback instead, which narrows the source doubles to match the
-            // demoted `vec` input - the same thing DirectGLES does for the same state. The
-            // frontend RECORDS the format either way, so this gate is the only thing standing
-            // between a legal glVertexAttribLFormat and a mismatched pipeline.
-            if (MG_Backend::pActiveBackendObject == nullptr ||
-                !MG_Backend::pActiveBackendObject->GetDynamicParameters().SupportsFloat64VertexAttributes) {
-                return VK_FORMAT_UNDEFINED;
-            }
             if (!isLong || isInteger || normalized) return VK_FORMAT_UNDEFINED;
             switch (size) {
             case 1: return VK_FORMAT_R32G32_UINT;

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.h

@@ -23,9 +23,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             None = 0,
             Repack,
             ScaledIntegerToFloat32,
-            // GL_DOUBLE source data narrowed to a tightly packed float32 stream: the fetch half
-            // of the fp64 demotion the shader side already does unconditionally.
-            Float64ToFloat32,
         };
 
         struct BackendVertexInputState {
@@ -114,12 +111,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         const VulkanRendererConfig& m_config;
         VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
-        // Values are heap-allocated: UnorderedMap is open-addressing, so INSERT
-        // invalidates references to stored values - and so does ERASE, which shifts
-        // the rest of the probe cluster into the hole and therefore moves entries
-        // other than the erased one. The draw path (and the VAOs' state-pointer
-        // memos) hold entry pointers across both; only the unique_ptr cell moves,
-        // never the pointee.
+        // Values are heap-allocated: FastSTL::unordered_map is open-addressing,
+        // so INSERT invalidates references to stored values. The draw path (and
+        // the VAOs' state-pointer memos) hold entry pointers across inserts;
+        // only the unique_ptr cell moves, never the pointee.
         UnorderedMap<HashType, UniquePtr<BackendVertexInputState>> m_cache;
         // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
         Uint64 m_frameBoundaryCounter = 0;
@@ -128,17 +123,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // construction); a memo is honored only while its recorded epoch
         // matches, so an evicted entry can never be dereferenced through a
         // stale memo.
-        //
-        // Drawn from a process-wide source, never a per-instance counter: the VAO
-        // memos outlive this factory (they live on the frontend context's VAOs, the renderer
-        // is destroyed and recreated on EGL surface release/re-create), so a fresh
-        // factory restarting at a dead factory's epoch value would honor its
-        // dangling entry pointers. The constructor takes a value strictly greater
-        // than anything a predecessor ever stamped, so a dead factory's memo can
-        // never compare equal here - the same never-reused idiom as the lifetime ids.
-        // Single-threaded like the rest of the factory (renderer-thread only).
-        static inline Uint64 s_evictionEpochSource = 0;
-        Uint64 m_evictionEpoch = ++s_evictionEpochSource;
+        Uint64 m_evictionEpoch = 1;
         static inline XXH64_state_t* m_hashState = XXH64_createState();
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.cpp

@@ -10,23 +10,12 @@
 #include "../DirectVulkan.h"
 #include "VulkanRenderer.h"
 
-#include "MG_Util/Metrics/PipeStats.h"
-
 namespace MobileGL::MG_Backend::DirectVulkan {
     namespace {
         constexpr VmaAllocationCreateFlags kResidentBufferAllocationFlags =
             VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
         constexpr SizeT kLiveResourcePruneThreshold = 256;
 
-        // See VkBufferManager::AcquireUnboundStorageDescriptor. 256 bytes: comfortably past
-        // every minStorageBufferOffsetAlignment in the wild, and free.
-        constexpr VkDeviceSize kUnboundStorageDescriptorBytes = 256;
-        // See VkBufferManager::AcquireUnboundTexelBufferDescriptor. The same 256 bytes, for the
-        // same reason plus one: a texel buffer view's range must be a whole number of texels of
-        // whatever format the placeholder is asked for, and 256 divides by every texel size in
-        // the GL image-format table (1, 2, 4, 8 and 16 bytes).
-        constexpr VkDeviceSize kUnboundTexelBufferDescriptorBytes = 256;
-
         // A zero-copy persistent buffer is created once and never recreated (the app holds
         // its mapped pointer), and may be bound to any role, so it carries every usage.
         // TRANSFER_DST is added by CreateResidentStorage.
@@ -34,11 +23,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
             VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
             VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
-            // "Every usage" has to mean every usage: a buffer texture reached through an IMAGE
-            // unit takes a VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER descriptor, and the write is
-            // invalid unless the buffer was created with this bit. Nothing asked for it until
-            // imageBuffer support existed, so the omission was invisible.
-            VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+            VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
         // Appended to kPersistentBackedUsage when VK_EXT_transform_feedback is enabled
         // (see VkBufferManagerInitInfo::transformFeedbackUsageEnabled).
         constexpr VkBufferUsageFlags kTransformFeedbackUsage =
@@ -141,8 +126,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         }
         m_transientUploadArena.Shutdown();
-        m_unboundStorageBuffer.Destroy();
-        m_unboundTexelBuffer.Destroy();
         DestroyAllDeferredReleases();
         ReleaseAllLiveResources();
         m_copyProvider = nullptr;
@@ -178,23 +161,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     void VkBufferManager::CollectAllDeferredReleases() {
-        // Per-resource releases only. Every one of them was deferred behind a BumpSliceEpoch,
-        // so no memo can still name the handle, and the caller has proved the GPU is idle.
-        //
-        // The transient arena's releases are deliberately NOT collected here. A buffer lands
-        // there when the arena outgrows it mid-frame (BufferArena::EnsureCapacity), and at
-        // that moment every slice already handed out from this frame's arena still names it -
-        // VkBufferResource::transientSlice above all, which AcquireStreamedSlice keeps
-        // serving for the whole frame serial on the strength of transientFrameSerial alone.
-        // Nothing bumps the slice epoch for those other resources, so freeing the buffer
-        // here left the streamed memo handing a destroyed VkBuffer to vkCmdBindIndexBuffer
-        // (llvmpipe then faulted inside the draw; the Create/Flywheel indirect retrace died
-        // exactly this way). Mid-frame drains do not advance m_frameSerial, so they must not
-        // free arena storage either: the arena's own ResetFrame/BeginFrame is the point where
-        // the slot's slices stop being reachable, and that is where these releases land.
         for (Uint32 frameIndex = 0; frameIndex < m_deferredBufferReleases.size(); ++frameIndex) {
             CollectDeferredReleases(frameIndex);
         }
+        for (Uint32 frameIndex = 0; frameIndex < m_transientUploadArena.GetFrameCount(); ++frameIndex) {
+            m_transientUploadArena.CollectDeferredReleases(frameIndex);
+        }
     }
 
     void VkBufferManager::NotifyDeviceIdle() {
@@ -231,38 +203,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     Bool VkBufferManager::UploadTransient(BufferKind kind, Uint32 frameIndex, const void* data,
                                           VkDeviceSize size, VkDeviceSize alignment, BufferSlice& outSlice) {
-        if (!m_transientUploadArena.Upload(frameIndex, data, size, alignment, outSlice)) {
-            return false;
-        }
-        if (MG_Util::PipeStats::Enabled()) {
-            // The single chokepoint for Magma's per-draw staging. Uniform is deliberately
-            // absent: its bytes are counted by the caller, which is the only place that
-            // knows whether the payload is the default block (stage-ubo-global) or a named
-            // one repacked into the ring (stage-ubo-named), and counting here as well would
-            // double every uniform byte.
-            switch (kind) {
-            case BufferKind::Vertex:
-                MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageVertexClient,
-                                             static_cast<Uint64>(size));
-                break;
-            case BufferKind::Index:
-                MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageIndexClient,
-                                             static_cast<Uint64>(size));
-                break;
-            case BufferKind::Indirect:
-                MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageIndirectCmd,
-                                             static_cast<Uint64>(size));
-                break;
-            case BufferKind::TextureBuffer:
-            case BufferKind::ShaderStorage:
-                MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageBuffer,
-                                             static_cast<Uint64>(size));
-                break;
-            case BufferKind::Uniform:
-                break;
-            }
-        }
-        return true;
+        (void)kind;
+        return m_transientUploadArena.Upload(frameIndex, data, size, alignment, outSlice);
     }
 
     Bool VkBufferManager::InitializeTransientArenas() {
@@ -345,7 +287,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             .requiredFlags = requiredFlags,
         });
         if (!created || resource.buffer.Map() == nullptr) {
-            MGLOG_E_ONCE("VkBufferManager::CreateResidentStorage failed (size=%llu)",
+            MGLOG_E("VkBufferManager::CreateResidentStorage failed (size=%llu)",
                     static_cast<unsigned long long>(size));
             resource.buffer.Destroy();
             resource.storageSize = 0;
@@ -367,13 +309,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return false;
         }
         if (!resource.buffer.Upload(bufferObject.MappedData(), size, 0)) {
-            MGLOG_E_ONCE("VkBufferManager::SwapStorageAndUploadAll: upload failed");
+            MGLOG_E("VkBufferManager::SwapStorageAndUploadAll: upload failed");
             resource.pendingFullUpload = true;
             return false;
         }
-        if (MG_Util::PipeStats::Enabled()) {
-            MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageBuffer, static_cast<Uint64>(size));
-        }
         resource.pendingFullUpload = false;
         return true;
     }
@@ -388,11 +327,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                            static_cast<VkDeviceSize>(size), 16, staging)) {
             return false;
         }
-        if (MG_Util::PipeStats::Enabled()) {
-            // The staging fill is the host copy; the vkCmdCopyBuffer below is the device
-            // half of the same bytes and is not counted twice.
-            MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageBuffer, static_cast<Uint64>(size));
-        }
         VkCommandBuffer commandBuffer = m_copyProvider->AcquireBufferCopyCommandBuffer();
         if (commandBuffer == VK_NULL_HANDLE) {
             return false;
@@ -434,12 +368,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         BumpSliceEpoch(*resource);
         // Any cached streaming slice refers to the previous contents.
         resource->transientFrameSerial = 0;
-        // Redefining the store hands any adopted mapping back to the CPU shadow
-        // (BufferObject::RedefineStorage), so a buffer that reaches here persistent-mapped
-        // is an ordinary resident one again: it needs the busy-tracking and conditional
-        // orphan below, and the next AcquirePersistentMap has to mint storage for the new
-        // store rather than hand back a mapping of the old one.
-        resource->persistentMapped = false;
         if (!resource->buffer.IsValid()) {
             return; // streaming-only resource: shadow + serial are enough
         }
@@ -460,10 +388,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
 
         if (!resource->buffer.Upload(bufferObject.MappedData(), size, 0)) {
-            MGLOG_E_ONCE("VkBufferManager::OnRespecify: in-place upload failed");
+            MGLOG_E("VkBufferManager::OnRespecify: in-place upload failed");
             resource->pendingFullUpload = true;
-        } else if (MG_Util::PipeStats::Enabled()) {
-            MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageBuffer, static_cast<Uint64>(size));
         }
     }
 
@@ -487,11 +413,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (!IsResourceBusy(*resource)) {
             if (!resource->buffer.Upload(bufferObject.MappedData() + offset,
                                          static_cast<VkDeviceSize>(size), static_cast<VkDeviceSize>(offset))) {
-                MGLOG_E_ONCE("VkBufferManager::OnSubData: host upload failed");
+                MGLOG_E("VkBufferManager::OnSubData: host upload failed");
                 resource->pendingFullUpload = true;
-            } else if (MG_Util::PipeStats::Enabled()) {
-                MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageBuffer,
-                                             static_cast<Uint64>(size));
             }
             return;
         }
@@ -527,11 +450,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if ((appAccess & BufferMappingAccessBit::Unsynchronized) || !IsResourceBusy(*resource)) {
             if (!resource->buffer.Upload(bufferObject.MappedData() + offset,
                                          static_cast<VkDeviceSize>(size), static_cast<VkDeviceSize>(offset))) {
-                MGLOG_E_ONCE("VkBufferManager::OnFlushMappedRange: host upload failed");
+                MGLOG_E("VkBufferManager::OnFlushMappedRange: host upload failed");
                 resource->pendingFullUpload = true;
-            } else if (MG_Util::PipeStats::Enabled()) {
-                MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageBuffer,
-                                             static_cast<Uint64>(size));
             }
             return;
         }
@@ -602,13 +522,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const Uint8* seed = bufferObject.MappedData();
         if (seed != nullptr) {
             resource->buffer.Upload(seed, size, 0);
-            if (MG_Util::PipeStats::Enabled()) {
-                // The one-time seed of a persistent map. Everything the app writes AFTER
-                // this goes straight through the mapping and is persistent-map-push
-                // territory (unwired, D4/D-B4), not this class.
-                MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageBuffer,
-                                             static_cast<Uint64>(size));
-            }
         }
         resource->persistentMapped = true;
         resource->pendingFullUpload = false;
@@ -629,7 +542,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         const VkDeviceSize size = static_cast<VkDeviceSize>(bufferObject->GetSize());
         if (size == 0) {
-            MGLOG_E_ONCE("VkBufferManager::AcquireResidentSlice failed: buffer size is zero");
+            MGLOG_E("VkBufferManager::AcquireResidentSlice failed: buffer size is zero");
             return false;
         }
 
@@ -651,16 +564,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 return false;
             }
             if (!resource->buffer.Upload(bufferObject->MappedData(), size, 0)) {
-                MGLOG_E_ONCE("VkBufferManager::AcquireResidentSlice failed: initial upload failed");
+                MGLOG_E("VkBufferManager::AcquireResidentSlice failed: initial upload failed");
                 resource->buffer.Destroy();
                 resource->storageSize = 0;
                 resource->usageFlags = 0;
                 return false;
             }
-            if (MG_Util::PipeStats::Enabled()) {
-                MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageBuffer,
-                                             static_cast<Uint64>(size));
-            }
             resource->pendingFullUpload = false;
         }
 
@@ -690,7 +599,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         const VkDeviceSize size = static_cast<VkDeviceSize>(bufferObject->GetSize());
         if (size == 0) {
-            MGLOG_E_ONCE("VkBufferManager::AcquireStreamedSlice failed: buffer size is zero");
+            MGLOG_E("VkBufferManager::AcquireStreamedSlice failed: buffer size is zero");
             return false;
         }
 
@@ -740,9 +649,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                            outSlice)) {
             return false;
         }
-        if (MG_Util::PipeStats::Enabled()) {
-            MG_Util::PipeStats::AddBytes(MG_Util::PipeStats::ByteClass::StageBuffer, static_cast<Uint64>(size));
-        }
         resource->transientSlice = outSlice;
         resource->transientFrameSerial = m_frameSerial;
         resource->transientChangeSerial = changeSerial;
@@ -779,70 +685,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_deferredResourceReleases[frameIndex].clear();
     }
 
-    BufferSlice VkBufferManager::AcquireUnboundStorageDescriptor() {
-        if (!m_unboundStorageBuffer.IsValid()) {
-            if (m_initInfo.allocator == nullptr) {
-                return {};
-            }
-            // Host-visible so the zero fill needs no command buffer: this can be reached from
-            // descriptor resolution, which runs inside an already-open recording and must not
-            // start a copy of its own. The size is a whole minStorageBufferOffsetAlignment-safe
-            // block rather than 4 bytes so that a shader which does read the block gets a
-            // plausible unsized-array length instead of one that rounds to zero.
-            const Bool created = m_unboundStorageBuffer.Create({
-                .allocator = m_initInfo.allocator,
-                .size = kUnboundStorageDescriptorBytes,
-                .usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-                .memoryUsage = VMA_MEMORY_USAGE_AUTO,
-                .allocationFlags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
-                                   VMA_ALLOCATION_CREATE_MAPPED_BIT,
-                .requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
-            });
-            if (!created) {
-                MGLOG_E_ONCE("VkBufferManager::AcquireUnboundStorageDescriptor: placeholder creation failed");
-                m_unboundStorageBuffer.Destroy();
-                return {};
-            }
-            if (void* mapped = m_unboundStorageBuffer.GetMappedData()) {
-                Memset(mapped, 0, static_cast<SizeT>(kUnboundStorageDescriptorBytes));
-            }
-        }
-        return m_unboundStorageBuffer.GetSlice();
-    }
-
-    BufferSlice VkBufferManager::AcquireUnboundTexelBufferDescriptor() {
-        if (!m_unboundTexelBuffer.IsValid()) {
-            if (m_initInfo.allocator == nullptr) {
-                return {};
-            }
-            // A SECOND placeholder rather than more usage bits on the storage-block one. The two
-            // are independent failure domains: a device that refuses this allocation must not
-            // take the storage-block placeholder - and with it the fix this one is a sibling of -
-            // down with it. Host-visible and zero-filled for the same reason as that one: this is
-            // reached from descriptor resolution, inside an already-open recording, which must
-            // not start a copy of its own.
-            const Bool created = m_unboundTexelBuffer.Create({
-                .allocator = m_initInfo.allocator,
-                .size = kUnboundTexelBufferDescriptorBytes,
-                .usage = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT |
-                         VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-                .memoryUsage = VMA_MEMORY_USAGE_AUTO,
-                .allocationFlags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT |
-                                   VMA_ALLOCATION_CREATE_MAPPED_BIT,
-                .requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
-            });
-            if (!created) {
-                MGLOG_E_ONCE("VkBufferManager::AcquireUnboundTexelBufferDescriptor: placeholder creation failed");
-                m_unboundTexelBuffer.Destroy();
-                return {};
-            }
-            if (void* mapped = m_unboundTexelBuffer.GetMappedData()) {
-                Memset(mapped, 0, static_cast<SizeT>(kUnboundTexelBufferDescriptorBytes));
-            }
-        }
-        return m_unboundTexelBuffer.GetSlice();
-    }
-
     VkBufferUsageFlags VkBufferManager::GetVkBufferUsage(BufferKind kind) {
         switch (kind) {
         case BufferKind::Vertex:
@@ -855,13 +697,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         case BufferKind::Uniform:
             return VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
         case BufferKind::TextureBuffer:
-            // Both texel roles, for the same reason vertex/index carry both bits: one GL buffer
-            // texture can be read as a samplerBuffer and written as an imageBuffer, and which of
-            // the two it is only becomes known when a shader that uses it is bound - long after
-            // the resident buffer was created. A VkBufferView for a storage-texel descriptor is
-            // invalid unless the buffer was created with the storage bit, so a buffer that
-            // acquired only the uniform bit could never be given one.
-            return VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
+            return VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
         case BufferKind::ShaderStorage:
             return VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
         case BufferKind::Indirect:

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.h

@@ -102,11 +102,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // Recreate all per-frame transient arenas
         Bool RecreateTransientArenas(Uint32 frameCount);
         void BeginFrame(Uint32 frameIndex);
-        // Drains every frame slot's deferred buffer/resource releases. Only valid when
-        // the caller has proven every queue submission complete; used by the present-less
-        // frame-boundary drain. Deliberately does NOT touch the transient arena's parked
-        // superseded blocks: those are still named by this frame's slices (see the
-        // definition), and only a frame rewind retires them.
+        // Drains every frame slot's deferred buffer/resource releases (and the
+        // transient arena's parked superseded blocks). Only valid when the
+        // caller has proven every queue submission complete; used by the
+        // present-less frame-boundary drain.
         void CollectAllDeferredReleases();
         // All previously submitted GPU work has completed (vkDeviceWaitIdle).
         void NotifyDeviceIdle();
@@ -120,27 +119,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Bool UploadTransient(BufferKind kind, Uint32 frameIndex, const void* data, VkDeviceSize size,
                              VkDeviceSize alignment, BufferSlice& outSlice);
 
-        // The descriptor a shader storage block gets when the program declares it and the
-        // application bound no buffer at its GL binding point. GL 4.6 core 7.8 makes that a
-        // legal state - the block simply has no store, so reads are undefined and writes go
-        // nowhere - whereas Vulkan has no such thing as an unwritten descriptor, so something
-        // real has to sit in the set or the whole draw/dispatch is lost. One zero-filled
-        // buffer, created once and shared by every unbound binding: bindings that are only
-        // declared (the case this exists for) never touch it, and one that is actually read
-        // sees zeros, which is inside GL's "undefined". robustBufferAccess bounds anything
-        // that indexes past it.
-        BufferSlice AcquireUnboundStorageDescriptor();
-
-        // The store a texel-buffer descriptor - `samplerBuffer` or `imageBuffer` - gets when the
-        // unit the program's uniform names has no buffer texture on it, or the buffer texture on
-        // it has no GL buffer attached. Both are legal GL states that make a fetch return
-        // undefined values (GL 4.6 core 8.9: a buffer texture with no attached buffer object is
-        // incomplete, and sampling an incomplete texture is undefined - not a lost draw), and both
-        // used to take the whole draw or dispatch with them. The VIEW over this - one per format,
-        // and the descriptor is a VkBufferView, not a buffer - is built by
-        // UniformManager::AcquireUnboundTexelBufferView.
-        BufferSlice AcquireUnboundTexelBufferDescriptor();
-
         // Draw-time acquire for resident (device-storage) buffers: ensures the
         // resource exists and is fully uploaded, marks it used this frame.
         Bool AcquireResidentSlice(BufferKind kind, const SharedPtr<MG_State::GLState::BufferObject>& bufferObject,
@@ -201,11 +179,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         VkBufferManagerInitInfo m_initInfo{};
         BufferArena m_transientUploadArena;
-        // See AcquireUnboundStorageDescriptor. Lazily created, never re-created, torn down
-        // with the manager.
-        VkBufferObject m_unboundStorageBuffer;
-        // See AcquireUnboundTexelBufferDescriptor. Same lifetime rules.
-        VkBufferObject m_unboundTexelBuffer;
         IBufferCopyCommandProvider* m_copyProvider = nullptr;
         Vector<Vector<VkBufferObject>> m_deferredBufferReleases;
         Vector<Vector<SharedPtr<VkBufferResource>>> m_deferredResourceReleases;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferObject.cpp

@@ -76,7 +76,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const VkResult result =
             vmaCreateBuffer(m_allocator, &bufferInfo, &allocationInfo, &m_buffer, &m_allocation, nullptr);
         if (result != VK_SUCCESS) {
-            MGLOG_E_ONCE("VkBufferObject::Create failed: vmaCreateBuffer returned %d", result);
+            MGLOG_E("VkBufferObject::Create failed: vmaCreateBuffer returned %d", result);
             m_allocator = nullptr;
             m_buffer = VK_NULL_HANDLE;
             m_allocation = nullptr;
@@ -108,7 +108,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         const VkResult mapResult = vmaMapMemory(m_allocator, m_allocation, &m_mappedData);
         if (mapResult != VK_SUCCESS || m_mappedData == nullptr) {
-            MGLOG_E_ONCE("VkBufferObject::Map failed: vmaMapMemory returned %d", mapResult);
+            MGLOG_E("VkBufferObject::Map failed: vmaMapMemory returned %d", mapResult);
             m_mappedData = nullptr;
             return nullptr;
         }
@@ -138,14 +138,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const Bool wasMapped = IsMapped();
         void* mapped = wasMapped ? m_mappedData : Map();
         if (mapped == nullptr) {
-            MGLOG_E_ONCE("VkBufferObject::Upload failed: unable to map buffer");
+            MGLOG_E("VkBufferObject::Upload failed: unable to map buffer");
             return false;
         }
 
         Memcpy(static_cast<Uint8*>(mapped) + offset, data, static_cast<SizeT>(size));
         const VkResult flushResult = vmaFlushAllocation(m_allocator, m_allocation, offset, size);
         if (flushResult != VK_SUCCESS) {
-            MGLOG_E_ONCE("VkBufferObject::Upload failed: vmaFlushAllocation returned %d", flushResult);
+            MGLOG_E("VkBufferObject::Upload failed: vmaFlushAllocation returned %d", flushResult);
             if (!wasMapped) {
                 Unmap();
             }
@@ -170,7 +170,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         const VkResult result = vmaInvalidateAllocation(m_allocator, m_allocation, offset, resolvedSize);
         if (result != VK_SUCCESS) {
-            MGLOG_E_ONCE("VkBufferObject::Invalidate failed: vmaInvalidateAllocation returned %d", result);
+            MGLOG_E("VkBufferObject::Invalidate failed: vmaInvalidateAllocation returned %d", result);
             return false;
         }
         return true;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.cpp

@@ -8,12 +8,7 @@
 
 #include "VkClearManager.h"
 
-// For the shared ResolveAttachmentLayerCount (and the ToVulkanLevelExtent it is built on): the
-// clear key's layer span has to be the same one the render pass builds its attachment view from.
-#include "VkTextureManager.h"
-
 #include "MG_State/GLState/Core.h"
-#include <MG_Pipe/PipeInputsSwitch.h>
 #include "MG_Util/Converters/MGToStr/FramebufferEnumConverter.h"
 #include "MG_Util/Converters/MGToStr/TextureEnumConverter.h"
 
@@ -55,7 +50,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         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 (MGB_CTX->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb)) return;
+        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
@@ -105,13 +100,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return ResolveAttachmentBaseArrayLayer(uploadTarget);
     }
 
-    // ResolveAttachmentLayerCount used to be duplicated here, reading attachment.GetSize().z()
-    // raw - no ToVulkanLevelExtent remap for a 1D array, no six-faces arm for a cube map. That is
-    // not a cosmetic difference: the count below is not key-only, it is written straight into
-    // VkImageSubresourceRange::layerCount by MaterializePendingClearForTexture, which then POPS
-    // the entry - so a layered cube map's glClear reached one face and the other five were lost
-    // for good, while the very same queued clear cleared all six through the render pass's
-    // LOAD_OP_CLEAR. The helper now lives once, in VkTextureManager.h beside ToVulkanLevelExtent.
+    static Uint32 ResolveAttachmentLayerCount(
+        const MG_State::GLState::FramebufferAttachmentObject& attachment) {
+        if (attachment.IsLayered()) {
+            return static_cast<Uint32>(std::max(attachment.GetSize().z(), 1));
+        }
+        return 1u;
+    }
 
     static const MG_State::GLState::FramebufferAttachmentObject* GetClearableAttachment(
         const MG_State::GLState::FramebufferObject& drawFbo, FramebufferAttachmentType attachmentType) {
@@ -127,30 +122,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return &attachment;
     }
 
-    // The texture a pending clear is actually ABOUT. A clear issued through a GL texture view
-    // (ARB_texture_view) targets the storage it views, so it must queue against - and be found
-    // by - the storage texture; keying it on the view instead left the clear invisible to every
-    // materialisation done through the parent's name (and vice versa), so the image stayed in
-    // VK_IMAGE_LAYOUT_UNDEFINED and the readback was dropped as unreadable.
-    static MG_State::GLState::ITextureObject* ClearStorageTextureOf(MG_State::GLState::ITextureObject* texture) {
-        if (texture == nullptr) {
-            return nullptr;
-        }
-        const auto& storageOwner = texture->GetViewStorageOwner();
-        return storageOwner ? storageOwner.get() : texture;
-    }
-
-    PendingClearKey VkClearManager::MakePendingClearKey(MG_State::GLState::ITextureObject* rawTexture, Uint32 mipLevel,
+    PendingClearKey VkClearManager::MakePendingClearKey(MG_State::GLState::ITextureObject* texture, Uint32 mipLevel,
                                                         Uint32 baseArrayLayer, Uint32 layerCount) {
-        MG_State::GLState::ITextureObject* texture = ClearStorageTextureOf(rawTexture);
-        if (rawTexture != nullptr && texture != rawTexture) {
-            // The caller named a level and a layer of the VIEW; the key describes the STORAGE, so
-            // both have to be shifted into its numbering (GL 4.6 core 8.18). Without this a clear
-            // of a view's level 0 would collide with a clear of the storage's level 0 even when
-            // the view opened onto level 1.
-            mipLevel += static_cast<Uint32>(rawTexture->GetViewMinLevel());
-            baseArrayLayer += static_cast<Uint32>(rawTexture->GetViewMinLayer());
-        }
         return PendingClearKey {
             .texture = texture,
             .textureLifetimeId = texture ? texture->GetLifetimeId() : 0,
@@ -184,15 +157,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     TextureIdentity VkClearManager::MakeTextureIdentity(MG_State::GLState::ITextureObject* texture) {
-        // Same rule as VkTextureManager::MakeTextureIdentity: a GL texture view is identified by
-        // the storage it views. A clear posted against a view and one posted against its parent
-        // target the same image, so they have to coalesce rather than queue independently.
-        if (texture != nullptr) {
-            const auto& storageOwner = texture->GetViewStorageOwner();
-            if (storageOwner) {
-                texture = storageOwner.get();
-            }
-        }
         return TextureIdentity {
             .texture = texture,
             .lifetimeId = texture ? texture->GetLifetimeId() : 0,
@@ -202,15 +166,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void VkClearManager::MergeClearPayload(ClearAttachmentPayload& dst, const ClearAttachmentPayload& src) {
         dst.mask |= src.mask;
         if ((src.mask & GL_COLOR_BUFFER_BIT) != 0) {
-            // The whole colour story travels together (same rule as
-            // VkRenderPassManager::QueueRenderbufferClear): a glClearBufferiv/uiv
-            // payload carries its value in colorInt/colorUint and its branch selector
-            // in colorEncoding - dropping them here would leave the pending clear
-            // reading as an all-zero float one.
             dst.color = src.color;
-            dst.colorEncoding = src.colorEncoding;
-            dst.colorInt = src.colorInt;
-            dst.colorUint = src.colorUint;
         }
         if ((src.mask & GL_DEPTH_BUFFER_BIT) != 0) {
             dst.depth = src.depth;
@@ -322,11 +278,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return;
         }
 
-        const auto& storageOwner = texture->GetViewStorageOwner();
-        const SharedPtr<MG_State::GLState::ITextureObject>& storageTexture = storageOwner ? storageOwner : texture;
-        const PendingClearKey key = MakePendingClearKey(storageTexture.get());
+        const PendingClearKey key = MakePendingClearKey(texture.get());
         const std::lock_guard<std::mutex> lock(m_mutex);
-        m_aliveObjects[MakeTextureIdentity(storageTexture.get())] = storageTexture;
+        m_aliveObjects[MakeTextureIdentity(texture.get())] = texture;
         auto& pending = m_pendingClears[key];
         MergeClearPayload(pending, clearPayload);
         m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
@@ -343,14 +297,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
 
         const PendingClearKey key = MakePendingClearKey(attachment);
-        // The alive entry must hold the STORAGE object, because the key names it:
-        // LockTextureIdentityLocked cross-checks the two, and registering a view here under its
-        // storage's identity made every lookup of this clear fail that check and silently report
-        // "nothing pending" - which is how a clear issued through a view's framebuffer vanished.
-        const auto& storageOwner = texture->GetViewStorageOwner();
-        const SharedPtr<MG_State::GLState::ITextureObject>& storageTexture = storageOwner ? storageOwner : texture;
         const std::lock_guard<std::mutex> lock(m_mutex);
-        m_aliveObjects[MakeTextureIdentity(storageTexture.get())] = storageTexture;
+        m_aliveObjects[MakeTextureIdentity(texture.get())] = texture;
         auto& pending = m_pendingClears[key];
         MergeClearPayload(pending, clearPayload);
         m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
@@ -365,7 +313,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return false;  // per-draw hot path: nothing pending anywhere
         }
 
-        texture = ClearStorageTextureOf(texture);
         const Uint64 lifetimeId = texture->GetLifetimeId();
         const std::lock_guard<std::mutex> lock(m_mutex);
         for (auto it = m_pendingClears.begin(); it != m_pendingClears.end(); ++it) {
@@ -456,7 +403,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return false;  // per-draw hot path: nothing pending anywhere
         }
 
-        texture = ClearStorageTextureOf(texture);
         const Uint64 lifetimeId = texture->GetLifetimeId();
         const std::lock_guard<std::mutex> lock(m_mutex);
         SharedPtr<MG_State::GLState::ITextureObject> liveTexture;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.h

@@ -114,8 +114,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     class VkClearManager {
     public:
         static PendingClearKey MakePendingClearKey(const MG_State::GLState::FramebufferAttachmentObject& attachment);
-        // Resolves a GL texture view to the storage it views before keying; see the definition.
-        static PendingClearKey MakePendingClearKey(MG_State::GLState::ITextureObject* rawTexture, Uint32 mipLevel = 0,
+        static PendingClearKey MakePendingClearKey(MG_State::GLState::ITextureObject* texture, Uint32 mipLevel = 0,
                                                    Uint32 baseArrayLayer = 0, Uint32 layerCount = 1);
 
         Bool Initialize();

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.cpp

@@ -13,7 +13,6 @@
 #include "MG_Util/Converters/MGToStr/FramebufferEnumConverter.h"
 #include "MG_Util/Converters/MGToVk/TextureEnumConverter.h"
 #include "MG_Util/Metrics/TextureMetrics.h"
-#include <MG_Pipe/PipeInputsSwitch.h>
 
 namespace MobileGL::MG_Backend::DirectVulkan {
     static Bool TryResolveSampleCountFlagBits(Int requestedSamples, VkSampleCountFlagBits& outSampleCount) {
@@ -68,58 +67,28 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     static Uint32 ResolveAttachmentBaseArrayLayer(const MG_State::GLState::FramebufferAttachmentObject& attachment) {
-        // Every branch has to go through ToStorageArrayLayer, including the two that name layer 0
-        // implicitly: a layered attachment of a texture VIEW starts at the view's first layer, not
-        // at the image's, and a cube FACE index is a layer index like any other. Leaving either
-        // unshifted made the render pass write layers [0, n) while the clear key, the blit, the
-        // copy and the readback for the same attachment all addressed [minLayer, minLayer + n) -
-        // they resolve the layer through their own copies of this helper, which do shift.
-        const auto* texture = attachment.GetTexture().get();
         if (attachment.IsLayered()) {
-            return ToStorageArrayLayer(texture, 0);
+            return 0;
         }
         const TextureUploadTarget uploadTarget = attachment.GetTextureUploadTarget();
         if (!IsCubeMapFaceUploadTarget(uploadTarget)) {
-            return ToStorageArrayLayer(texture, attachment.GetTextureLayer());
+            return static_cast<Uint32>(std::max(attachment.GetTextureLayer(), 0));
         }
-        const Int face =
-            static_cast<Int>(uploadTarget) - static_cast<Int>(TextureUploadTarget::CubeMapPositiveX);
-        return ToStorageArrayLayer(texture, face);
+        return static_cast<Uint32>(uploadTarget) - static_cast<Uint32>(TextureUploadTarget::CubeMapPositiveX);
     }
 
-    // ResolveAttachmentLayerCount lives in VkTextureManager.h, beside ToVulkanLevelExtent, because
-    // VkClearManager needs the SAME answer: its pending-clear key's layerCount becomes a real
-    // VkImageSubresourceRange when a clear is materialised outside a render pass. See the header.
+    static Uint32 ResolveAttachmentLayerCount(const MG_State::GLState::FramebufferAttachmentObject& attachment) {
+        if (attachment.IsLayered()) {
+            return static_cast<Uint32>(std::max(attachment.GetSize().z(), 1));
+        }
+        return 1u;
+    }
 
-    // VUID-VkFramebufferCreateInfo-flags-04113: every view handed to vkCreateFramebuffer must have
-    // been created as VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY. The image's OWN view
-    // type is not a legal answer for several of the targets GL can attach, and returning it
-    // unchanged is what took the process down on every layered 3D / cube-map-array attachment:
-    // a 3D view is refused outright by the layer-span guard in GetOrCreateAttachmentViewAtMipLevel
-    // (3D images have arrayLayers == 1) and a CUBE_ARRAY view is built happily and then rejected -
-    // or dereferenced - by the driver inside vkCreateFramebuffer.
-    //
-    // A 2D_ARRAY view is the legal spelling of all three: over a 2D-array-compatible 3D image its
-    // "layers" are the mip's z slices (VUID-VkImageViewCreateInfo-image-04970), and over a
-    // CUBE_COMPATIBLE 2D image - which is what both cube targets are - its layers are the faces.
-    //
-    // Knowingly NOT remapped: VK_IMAGE_VIEW_TYPE_1D / _1D_ARRAY, which 04113 also forbids. There is
-    // no legal alternative for them (a VK_IMAGE_TYPE_1D image admits no 2D-family view at all), so
-    // the only honest answer would be to decline the attachment - and every driver this has run on,
-    // lavapipe included, accepts them. Declining would turn working GL_TEXTURE_1D[_ARRAY] render
-    // targets into skipped draws to satisfy a VU nothing enforces. Left as-is, deliberately.
     static VkImageViewType ResolveAttachmentViewType(
         const MG_State::GLState::FramebufferAttachmentObject& attachment,
         const VkTextureManager::TextureResource& resource) {
         if (attachment.IsLayered()) {
-            switch (resource.viewType) {
-            case VK_IMAGE_VIEW_TYPE_3D:
-            case VK_IMAGE_VIEW_TYPE_CUBE:
-            case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY:
-                return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
-            default:
-                return resource.viewType;
-            }
+            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
@@ -127,15 +96,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // 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.
-        //
-        // 3D belongs in the same list and was missing from it, which is why the "per-slice
-        // attachment view is a 2D view whose array layer is the slice" branch in
-        // GetOrCreateAttachmentViewAtMipLevel was unreachable: glFramebufferTextureLayer on a
-        // GL_TEXTURE_3D asked for a 3D view (illegal as an attachment) whose span was then checked
-        // against arrayLayers == 1, so every slice above z = 0 came back VK_NULL_HANDLE.
         if (IsCubeMapFaceUploadTarget(attachment.GetTextureUploadTarget()) ||
-            resource.viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY || resource.viewType == VK_IMAGE_VIEW_TYPE_CUBE ||
-            resource.viewType == VK_IMAGE_VIEW_TYPE_3D) {
+            resource.viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY || resource.viewType == VK_IMAGE_VIEW_TYPE_CUBE) {
             return VK_IMAGE_VIEW_TYPE_2D;
         }
         return resource.viewType;
@@ -161,7 +123,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
 
         if (!attachment.IsComplete()) {
-            MGLOG_W_ONCE("GetOrCreateRenderPass: draw buffer slot %u (%s) on FBO %u has an incomplete texture attachment; using VK_ATTACHMENT_UNUSED",
+            MGLOG_W("GetOrCreateRenderPass: draw buffer slot %u (%s) on FBO %u has an incomplete texture attachment; using VK_ATTACHMENT_UNUSED",
                     drawBufferIndex,
                     MG_Util::ConvertFramebufferAttachmentTypeToString(attachmentType).c_str(),
                     fbo.GetExternalIndex());
@@ -170,7 +132,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         auto* texture = attachment.GetTexture().get();
         if (texture == nullptr) {
-            MGLOG_W_ONCE("GetOrCreateRenderPass: draw buffer slot %u (%s) on FBO %u resolved to a null texture; using VK_ATTACHMENT_UNUSED",
+            MGLOG_W("GetOrCreateRenderPass: draw buffer slot %u (%s) on FBO %u resolved to a null texture; using VK_ATTACHMENT_UNUSED",
                     drawBufferIndex,
                     MG_Util::ConvertFramebufferAttachmentTypeToString(attachmentType).c_str(),
                     fbo.GetExternalIndex());
@@ -349,25 +311,54 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT;
         if (!TryResolveSampleCountFlagBits(renderbuffer->GetSamples(), sampleCount)) {
-            MGLOG_E_ONCE("GetOrCreateRenderbufferResource: unsupported renderbuffer sample count %d for renderbuffer %u",
+            MGLOG_E("GetOrCreateRenderbufferResource: unsupported renderbuffer sample count %d for renderbuffer %u",
                     renderbuffer->GetSamples(),
                     renderbuffer->GetExternalIndex());
             return nullptr;
         }
 
         const auto internalFormat = renderbuffer->GetInternalFormat();
-        // ONE resolver, shared with textures (VkTextureManager::ResolveTextureFormatInfo), so a
-        // renderbuffer and a texture of the same GL format cannot disagree about their VkFormat.
-        // `expandRgbToRgba` / `componentByteCount` / `alphaBytes` describe how to reshape a SHADOW
-        // UPLOAD, and a renderbuffer has none, so only `.format` is taken.
-        //
-        // This used to be a hand-maintained second copy of that table, and it was missing exactly
-        // four rows: RGBA2 and RGBA12 fell through to ConvertTextureInternalFormatToVkEnum's
-        // VK_FORMAT_UNDEFINED (no image at all - bound as a draw buffer the attachment became
-        // VK_ATTACHMENT_UNUSED and every draw into it was dropped), while RGBA4 and RGB5A1 fell
-        // through to the 16-bit packed formats and then faced 32-bit R8G8B8A8_UNORM textures across
-        // a size-incompatible vkCmdCopyImage.
-        const VkFormat format = ResolveTextureFormatInfo(internalFormat).format;
+        // Three-channel color formats widen to their RGBA twin exactly like textures do
+        // (VkTextureManager::ResolveTextureFormatInfo): blits/resolves between a
+        // renderbuffer and a texture of the same GL format then see one VkFormat.
+        const VkFormat format = [&]() -> VkFormat {
+            switch (internalFormat) {
+            case TextureInternalFormat::RGB:
+            case TextureInternalFormat::RGB8:
+            case TextureInternalFormat::R3G3B2:
+            case TextureInternalFormat::RGB4:
+            case TextureInternalFormat::RGB5:
+                return VK_FORMAT_R8G8B8A8_UNORM;
+            case TextureInternalFormat::SRGB8:
+                return VK_FORMAT_R8G8B8A8_SRGB;
+            case TextureInternalFormat::RGB8Snorm:
+                return VK_FORMAT_R8G8B8A8_SNORM;
+            case TextureInternalFormat::RGB10:
+            case TextureInternalFormat::RGB12:
+            case TextureInternalFormat::RGB16:
+                return VK_FORMAT_R16G16B16A16_UNORM;
+            case TextureInternalFormat::RGB16Snorm:
+                return VK_FORMAT_R16G16B16A16_SNORM;
+            case TextureInternalFormat::RGB16F:
+                return VK_FORMAT_R16G16B16A16_SFLOAT;
+            case TextureInternalFormat::RGB32F:
+                return VK_FORMAT_R32G32B32A32_SFLOAT;
+            case TextureInternalFormat::RGB8I:
+                return VK_FORMAT_R8G8B8A8_SINT;
+            case TextureInternalFormat::RGB8UI:
+                return VK_FORMAT_R8G8B8A8_UINT;
+            case TextureInternalFormat::RGB16I:
+                return VK_FORMAT_R16G16B16A16_SINT;
+            case TextureInternalFormat::RGB16UI:
+                return VK_FORMAT_R16G16B16A16_UINT;
+            case TextureInternalFormat::RGB32I:
+                return VK_FORMAT_R32G32B32A32_SINT;
+            case TextureInternalFormat::RGB32UI:
+                return VK_FORMAT_R32G32B32A32_UINT;
+            default:
+                return MG_Util::ConvertTextureInternalFormatToVkEnum(internalFormat);
+            }
+        }();
         const VkImageAspectFlags aspect = ResolveImageAspectMaskForFormat(format);
         // Renderbuffers are never sampled (GL has no way to bind one to a sampler), so the
         // usage set is attachment + transfer: transfer covers readback (vkCmdCopyImageToBuffer),
@@ -466,7 +457,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_physicalDevice, format, imageInfo.imageType, imageInfo.tiling, imageInfo.usage, imageInfo.flags,
             &imageFormatProperties);
         if (imageFormatResult != VK_SUCCESS || (imageFormatProperties.sampleCounts & sampleCount) == 0) {
-            MGLOG_E_ONCE("GetOrCreateRenderbufferResource: unsupported renderbuffer format=%d samples=%d for renderbuffer %u",
+            MGLOG_E("GetOrCreateRenderbufferResource: unsupported renderbuffer format=%d samples=%d for renderbuffer %u",
                     static_cast<Int>(format),
                     static_cast<Int>(sampleCount),
                     renderbuffer->GetExternalIndex());
@@ -611,7 +602,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // sRGB attachments switch between their sRGB and UNORM-twin views with this
         // capability (ResolveSrgbAttachmentWriteFormat), changing the render pass formats.
         const Bool framebufferSrgbEnabled =
-            MGB_CTX->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb);
+            MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb);
         XXHASH_VERIFY(XXH64_update(m_hashState, &framebufferSrgbEnabled, sizeof(framebufferSrgbEnabled)));
         auto& drawBuffers = fbo.GetDrawBuffers();
         XXHASH_VERIFY(XXH64_update(m_hashState, drawBuffers.data(), drawBuffers.size() * sizeof(drawBuffers[0])));
@@ -642,13 +633,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             if (att.IsTexture()) {
                 const Uint64 textureLifetimeId = att.GetTexture()->GetLifetimeId();
                 XXHASH_VERIFY(XXH64_update(m_hashState, &textureLifetimeId, sizeof(textureLifetimeId)));
-                const Int textureLevel = static_cast<Int>(ToStorageMipLevel(att.GetTexture().get(),
-                                                                             att.GetTextureLevel()));
+                const Int textureLevel = att.GetTextureLevel();
                 XXHASH_VERIFY(XXH64_update(m_hashState, &textureLevel, sizeof(textureLevel)));
                 const TextureUploadTarget textureUploadTarget = att.GetTextureUploadTarget();
                 XXHASH_VERIFY(XXH64_update(m_hashState, &textureUploadTarget, sizeof(textureUploadTarget)));
-                const Int textureLayer = static_cast<Int>(ToStorageArrayLayer(att.GetTexture().get(),
-                                                                              att.GetTextureLayer()));
+                const Int textureLayer = att.GetTextureLayer();
                 XXHASH_VERIFY(XXH64_update(m_hashState, &textureLayer, sizeof(textureLayer)));
                 const Bool textureLayered = att.IsLayered();
                 XXHASH_VERIFY(XXH64_update(m_hashState, &textureLayered, sizeof(textureLayered)));
@@ -765,7 +754,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         return XXH64_digest(m_hashState);
     }
 
-    RenderPassEntry* VkRenderPassManager::GetOrCreateRenderPass(const MG_State::GLState::FramebufferObject& fbo,
+    RenderPassEntry& VkRenderPassManager::GetOrCreateRenderPass(const MG_State::GLState::FramebufferObject& fbo,
                                                                 Uint32 swapchainImageIndex,
                                                                 Bool drawUsesDepthStencil) {
         // Resolve the default-FBO depth flavor (see the header comment): keep the
@@ -842,7 +831,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // recreated since (texture + renderbuffer image epochs), and no pending clear (which alters
         // load ops). Any of these differing forces the full recompute below. Portable to VK 1.1.
         if (activeRenderPass != nullptr && m_rpFastValid && m_rpFastFbo == &fbo &&
-            m_rpFastFboLifetimeId == fbo.GetLifetimeId() &&
             m_rpFastFboVersion == fbo.GetObjectVersion() && m_rpFastSwapchainIndex == swapchainImageIndex &&
             m_rpFastTexEpoch == m_textureManager.GetTextureImageEpoch() &&
             m_rpFastRbEpoch == m_renderbufferImageEpoch &&
@@ -851,7 +839,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             auto activeIt = m_renderPasses.find(activeRenderPass->hash);
             if (activeIt != m_renderPasses.end()) {
                 activeIt->second.lastUsedFrame = m_frameCounter;
-                return &activeIt->second;
+                return activeIt->second;
             }
         }
 
@@ -867,7 +855,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // epochs AFTER ComputeHash: its attachment SyncTexture can create an image (bump the epoch).
             m_rpFastValid = true;
             m_rpFastFbo = &fbo;
-            m_rpFastFboLifetimeId = fbo.GetLifetimeId();
             m_rpFastFboVersion = fbo.GetObjectVersion();
             m_rpFastSwapchainIndex = swapchainImageIndex;
             m_rpFastTexEpoch = m_textureManager.GetTextureImageEpoch();
@@ -875,13 +862,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_rpFastRenderPassHash = activeRenderPass->hash;
             m_rpFastHadDepthStencil = activeIt->second.hasDepthStencilAttachment;
             activeIt->second.lastUsedFrame = m_frameCounter;
-            return &activeIt->second;
+            return activeIt->second;
         }
         auto hash = ComputeHash(fbo, swapchainImageIndex, true, includeDefaultFboDepthStencil);
         auto it = m_renderPasses.find(hash);
         if (it != m_renderPasses.end()) {
             it->second.lastUsedFrame = m_frameCounter;
-            return &it->second;
+            return it->second;
         }
 
         Bool isDefaultFbo = fbo.IsDefaultFramebuffer();
@@ -942,7 +929,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     const auto& renderbuffer = rbAtt.GetRenderbuffer();
                     auto* rbResource = GetOrCreateRenderbufferResource(renderbuffer);
                     if (rbResource == nullptr || (rbResource->aspect & VK_IMAGE_ASPECT_COLOR_BIT) == 0) {
-                        MGLOG_E_ONCE("GetOrCreateRenderPass: draw buffer slot %u on FBO %u has an unsupported color "
+                        MGLOG_E("GetOrCreateRenderPass: draw buffer slot %u on FBO %u has an unsupported color "
                                 "renderbuffer %u; using VK_ATTACHMENT_UNUSED",
                                 i, fbo.GetExternalIndex(), renderbuffer->GetExternalIndex());
                         continue;
@@ -963,7 +950,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
                     const VkImageLayout trackedRbLayout = rbResource->layout;
                     const Bool rbFramebufferSrgb =
-                        MGB_CTX->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb);
+                        MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb);
                     const VkFormat rbAttachmentFormat =
                         ResolveSrgbAttachmentWriteFormat(rbResource->format, rbFramebufferSrgb);
                     rbDesc.flags = 0;
@@ -1004,12 +991,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     textureResources.emplace_back(nullptr);
                     attachmentViews.emplace_back(rbAttachmentFormat != rbResource->format ? rbResource->unormTwinView
                                                                                           : rbResource->view);
-                    if (attachmentViews.back() == VK_NULL_HANDLE) {
-                        MGLOG_E_ONCE("GetOrCreateRenderPass: renderbuffer %u has no usable view for color attachment "
-                                     "%u on FBO %u; declining the render pass",
-                                     renderbuffer->GetExternalIndex(), i, fbo.GetExternalIndex());
-                        return nullptr;
-                    }
+                    MOBILEGL_ASSERT(attachmentViews.back() != VK_NULL_HANDLE,
+                                    "GetOrCreateRenderPass: renderbuffer view missing at color attachment %d", i);
 
                     colorAttachmentRefs[i].attachment = rbAttachmentIndex;
                     continue;
@@ -1021,7 +1004,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 continue;
 
             auto& att = fbo.GetAttachment(drawbuf);
-            const Uint32 attachmentMipLevel = ToStorageMipLevel(att.GetTexture().get(), att.GetTextureLevel());
+            const Uint32 attachmentMipLevel = static_cast<Uint32>(std::max(att.GetTextureLevel(), 0));
             const auto textureTarget = texture->GetTarget();
             const Uint32 attachmentIndex = static_cast<Uint32>(attachmentDescriptions.size());
             attachmentDescriptions.emplace_back();
@@ -1064,12 +1047,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                             .key = VkClearManager::MakePendingClearKey(att)
                         });
                     }
-                    // Same remap as ResolveAttachmentLayerCount, for the same reason: a
-                    // 1D-array attachment's GL height is its layer count, and using it as the
-                    // framebuffer height asks for a framebuffer taller than the VK_IMAGE_TYPE_1D
-                    // image it is built over.
-                    const IntVec2 attachmentExtent = ResolveRenderPassFramebufferExtent(
-                        isDefaultFbo, ToVulkanLevelExtent(texture->GetTarget(), att.GetSize()), swapchainExtent);
+                    const IntVec2 attachmentExtent =
+                        ResolveRenderPassFramebufferExtent(isDefaultFbo, att.GetSize(), swapchainExtent);
                     if (width == 0)
                         width = attachmentExtent.x();
                     if (height == 0)
@@ -1097,19 +1076,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         attachmentViews.emplace_back(swapchainViews[swapchainImageIndex]);
                     } else {
                         auto* textureResource = m_textureManager.SyncTextureAndGetDescriptor(*texture);
-                        if (textureResource == nullptr) {
-                            // SyncTextureResource legitimately declines - an unsupported format,
-                            // sample count or image-flag combination, or a vkCreateImage the driver
-                            // refused. There is no image to attach, so there is no render pass.
-                            MGLOG_E_ONCE("GetOrCreateRenderPass: textureId=%d could not be backed for color "
-                                         "attachment %u on FBO %u; declining the render pass",
-                                         texture->GetExternalIndex(), i, fbo.GetExternalIndex());
-                            return nullptr;
-                        }
+                        MOBILEGL_ASSERT(textureResource,
+                                        "GetOrCreateRenderPass: SyncTextureAndGetDescriptor failed at color attachment %d", i);
                         textureResources.emplace_back(textureResource);
                         desc.format = ResolveSrgbAttachmentWriteFormat(
                             textureResource->format,
-                            MGB_CTX->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb));
+                            MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb));
                         attachmentSampleCount = textureResource->sampleCount;
                         trackedColorLayout = textureResource->layout;
                         trackedAttachmentLayouts.emplace_back(TrackedAttachmentLayoutInfo {
@@ -1126,21 +1098,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         attachmentViews.emplace_back(
                             m_textureManager.GetOrCreateAttachmentViewAtMipLevel(
                                 *texture, attachmentMipLevel, baseArrayLayer, layerCount, attachmentViewType));
-                        if (attachmentViews.back() == VK_NULL_HANDLE) {
-                            MGLOG_E_ONCE("GetOrCreateRenderPass: no attachment view for textureId=%d mip=%u layers "
-                                         "[%u, %u) viewType=%d at color attachment %u on FBO %u; declining the "
-                                         "render pass",
-                                         texture->GetExternalIndex(), attachmentMipLevel, baseArrayLayer,
-                                         baseArrayLayer + layerCount, static_cast<Int>(attachmentViewType), i,
-                                         fbo.GetExternalIndex());
-                            return nullptr;
-                        }
+                        MOBILEGL_ASSERT(attachmentViews.back() != VK_NULL_HANDLE,
+                                        "GetOrCreateRenderPass: GetOrCreateAttachmentView failed at color attachment %d", i);
                     }
                     desc.samples = attachmentSampleCount;
                     adoptRenderPassSampleCount(attachmentSampleCount, "color", texture->GetExternalIndex());
 
                     if (!hasClear && trackedColorLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
-                        MGLOG_W_ONCE("GetOrCreateRenderPass: color attachment textureId=%d starts with undefined layout and no clear; "
+                        MGLOG_W("GetOrCreateRenderPass: color attachment textureId=%d starts with undefined layout and no clear; "
                                 "using LOAD_OP_DONT_CARE",
                                 texture->GetExternalIndex());
                         desc.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
@@ -1177,8 +1142,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             if (a.IsTexture() && b.IsTexture()) {
                 return a.GetTexture().get() == b.GetTexture().get() &&
                        a.GetTextureUploadTarget() == b.GetTextureUploadTarget() &&
-                       ToStorageMipLevel(a.GetTexture().get(), a.GetTextureLevel()) ==
-                           ToStorageMipLevel(b.GetTexture().get(), b.GetTextureLevel());
+                       a.GetTextureLevel() == b.GetTextureLevel();
             }
             if (a.IsRenderbuffer() && b.IsRenderbuffer()) {
                 return a.GetRenderbuffer().get() == b.GetRenderbuffer().get();
@@ -1197,7 +1161,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             isUsableDepthStencilAttachment(depthAtt) && isUsableDepthStencilAttachment(stencilAtt) &&
             !sameDepthStencilAttachmentObject(depthAtt, stencilAtt);
         if (hasDistinctDepthAndStencilAttachments) {
-            MGLOG_E_ONCE("GetOrCreateRenderPass: separate depth/stencil attachments are not supported yet; using the depth attachment and ignoring the standalone stencil attachment for framebuffer %u",
+            MGLOG_E("GetOrCreateRenderPass: separate depth/stencil attachments are not supported yet; using the depth attachment and ignoring the standalone stencil attachment for framebuffer %u",
                     fbo.GetExternalIndex());
         }
         if (selectedDepthStencilAttachment != nullptr) {
@@ -1227,29 +1191,20 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             } else if (selectedDepthStencilAttachment->IsTexture()) {
                 auto& texture = *selectedDepthStencilAttachment->GetTexture();
                 depthTextureResource = m_textureManager.SyncTextureAndGetDescriptor(texture);
-                if (depthTextureResource == nullptr) {
-                    MGLOG_E_ONCE("GetOrCreateRenderPass: textureId=%d could not be backed for the depth/stencil "
-                                 "attachment of FBO %u; declining the render pass",
-                                 texture.GetExternalIndex(), fbo.GetExternalIndex());
-                    return nullptr;
-                }
+                MOBILEGL_ASSERT(depthTextureResource,
+                                "GetOrCreateRenderPass: SyncTextureAndGetDescriptor failed at depth attachment");
                 trackedDepthLayout = depthTextureResource->layout;
                 depthAttachmentDescription.format = depthTextureResource->format;
                 depthAttachmentSampleCount = depthTextureResource->sampleCount;
                 depthAttachmentId = static_cast<Int>(texture.GetExternalIndex());
-                attachmentExtent = ResolveRenderPassFramebufferExtent(
-                    isDefaultFbo,
-                    ToVulkanLevelExtent(texture.GetTarget(), selectedDepthStencilAttachment->GetSize()),
-                    swapchainExtent);
+                attachmentExtent =
+                    ResolveRenderPassFramebufferExtent(isDefaultFbo, selectedDepthStencilAttachment->GetSize(),
+                                                       swapchainExtent);
             } else {
                 const auto& renderbuffer = selectedDepthStencilAttachment->GetRenderbuffer();
                 depthRenderbufferResource = GetOrCreateRenderbufferResource(renderbuffer);
-                if (depthRenderbufferResource == nullptr) {
-                    MGLOG_E_ONCE("GetOrCreateRenderPass: renderbuffer %u could not be backed for the depth/stencil "
-                                 "attachment of FBO %u; declining the render pass",
-                                 renderbuffer->GetExternalIndex(), fbo.GetExternalIndex());
-                    return nullptr;
-                }
+                MOBILEGL_ASSERT(depthRenderbufferResource,
+                                "GetOrCreateRenderPass: GetOrCreateRenderbufferResource failed at depth attachment");
                 trackedDepthLayout = depthRenderbufferResource->layout;
                 depthAttachmentDescription.format = depthRenderbufferResource->format;
                 depthAttachmentSampleCount = depthRenderbufferResource->sampleCount;
@@ -1268,7 +1223,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             depthAttachmentDescription.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
             depthAttachmentDescription.initialLayout = loadInfo.initialLayout;
             if (trackedDepthLayout == VK_IMAGE_LAYOUT_UNDEFINED && (!clearDepth || !clearStencil)) {
-                MGLOG_W_ONCE("GetOrCreateRenderPass: depth/stencil attachment id=%d starts with undefined layout "
+                MGLOG_W("GetOrCreateRenderPass: depth/stencil attachment id=%d starts with undefined layout "
                         "and partial/no clear; using DONT_CARE for uncleared aspects",
                         depthAttachmentId);
             }
@@ -1297,8 +1252,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             } else if (selectedDepthStencilAttachment->IsTexture()) {
                 auto& texture = *selectedDepthStencilAttachment->GetTexture();
                 const Uint32 attachmentMipLevel =
-                    ToStorageMipLevel(selectedDepthStencilAttachment->GetTexture().get(),
-                                      selectedDepthStencilAttachment->GetTextureLevel());
+                    static_cast<Uint32>(std::max(selectedDepthStencilAttachment->GetTextureLevel(), 0));
                 MOBILEGL_ASSERT(depthTextureResource->layout != VK_IMAGE_LAYOUT_UNDEFINED ||
                                     depthAttachmentDescription.loadOp != VK_ATTACHMENT_LOAD_OP_LOAD,
                                 "GetOrCreateRenderPass: depth attachment textureId=%d has undefined tracked layout with LOAD_OP_LOAD",
@@ -1323,14 +1277,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 attachmentViews.emplace_back(
                     m_textureManager.GetOrCreateAttachmentViewAtMipLevel(
                         texture, attachmentMipLevel, baseArrayLayer, layerCount, attachmentViewType));
-                if (attachmentViews.back() == VK_NULL_HANDLE) {
-                    MGLOG_E_ONCE("GetOrCreateRenderPass: no attachment view for textureId=%d mip=%u layers [%u, %u) "
-                                 "viewType=%d at the depth/stencil attachment of FBO %u; declining the render pass",
-                                 texture.GetExternalIndex(), attachmentMipLevel, baseArrayLayer,
-                                 baseArrayLayer + layerCount, static_cast<Int>(attachmentViewType),
-                                 fbo.GetExternalIndex());
-                    return nullptr;
-                }
+                MOBILEGL_ASSERT(attachmentViews.back() != VK_NULL_HANDLE,
+                                "GetOrCreateRenderPass: GetOrCreateAttachmentView failed at depth attachment");
                 if (width == 0 || height == 0) {
                     width = attachmentExtent.x();
                     height = attachmentExtent.y();
@@ -1352,12 +1300,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 });
                 textureResources.emplace_back(nullptr);
                 attachmentViews.emplace_back(depthRenderbufferResource->view);
-                if (attachmentViews.back() == VK_NULL_HANDLE) {
-                    MGLOG_E_ONCE("GetOrCreateRenderPass: renderbuffer %u has no usable view for the depth/stencil "
-                                 "attachment of FBO %u; declining the render pass",
-                                 renderbuffer->GetExternalIndex(), fbo.GetExternalIndex());
-                    return nullptr;
-                }
                 if (width == 0 || height == 0) {
                     width = attachmentExtent.x();
                     height = attachmentExtent.y();
@@ -1455,25 +1397,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         renderPassCreateInfo.dependencyCount = 2;
         renderPassCreateInfo.pDependencies = subpassDependencies;
 
-        // NOT VK_VERIFY. VkIncludes.h states the rule this function now lives by: VK_VERIFY is the
-        // INVARIANT check - a should-never-happen state, fatal-logged unlatched and trapped in a
-        // DEBUG build - and "a soft, recoverable failure must therefore NOT be routed through
-        // VK_VERIFY. Check the VkResult directly and report it with MGLOG_E_ONCE". A decline here
-        // is recoverable by construction: the caller drops the draw. Routing it through VK_VERIFY
-        // would have made the recovery dead code in a DEBUG build (the TRAP fires inside the macro,
-        // before the handle is ever examined) and, in an INFO build, printed an UNLATCHED fatal
-        // line on every draw for the life of the process - a decline caches nothing, so every
-        // later draw to the same framebuffer re-enters this path and fails again.
         VkRenderPass renderPass = VK_NULL_HANDLE;
-        const VkResult renderPassResult =
-            vkCreateRenderPass(m_device, &renderPassCreateInfo, nullptr, &renderPass);
-        if (renderPassResult != VK_SUCCESS || renderPass == VK_NULL_HANDLE) {
-            MGLOG_E_ONCE("GetOrCreateRenderPass: vkCreateRenderPass failed (%s, %d) for FBO %u; declining the "
-                         "render pass",
-                         VkResultToString(renderPassResult), static_cast<Int>(renderPassResult),
-                         fbo.GetExternalIndex());
-            return nullptr;
-        }
+        VK_VERIFY(vkCreateRenderPass(m_device, &renderPassCreateInfo, nullptr, &renderPass));
 
         // Framebuffer
         VkFramebufferCreateInfo framebufferCreateInfo;
@@ -1486,21 +1411,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         framebufferCreateInfo.width = width;
         framebufferCreateInfo.height = height;
         framebufferCreateInfo.layers = framebufferLayers;
-        // Direct VkResult check, for the same reason as vkCreateRenderPass above.
         VkFramebuffer framebuffer = VK_NULL_HANDLE;
-        const VkResult framebufferResult =
-            vkCreateFramebuffer(m_device, &framebufferCreateInfo, nullptr, &framebuffer);
-        if (framebufferResult != VK_SUCCESS || framebuffer == VK_NULL_HANDLE) {
-            // The render pass has no entry to own it yet, so it is destroyed here rather than
-            // leaked - RenderPassEntry's destructor is the only other thing that would.
-            MGLOG_E_ONCE("GetOrCreateRenderPass: vkCreateFramebuffer failed (%s, %d) for FBO %u (%dx%d, "
-                         "%u attachments, %u layers); declining the render pass",
-                         VkResultToString(framebufferResult), static_cast<Int>(framebufferResult),
-                         fbo.GetExternalIndex(), width, height,
-                         static_cast<Uint32>(attachmentViews.size()), framebufferLayers);
-            vkDestroyRenderPass(m_device, renderPass, nullptr);
-            return nullptr;
-        }
+        VK_VERIFY(vkCreateFramebuffer(m_device, &framebufferCreateInfo, nullptr, &framebuffer));
         IntVec2 extent = {width, height};
         RenderPassEntry renderPassEntry {
             hash,
@@ -1525,7 +1437,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 extent.y());
         auto [insertedIt, _] = m_renderPasses.emplace(hash, Move(renderPassEntry));
         insertedIt->second.lastUsedFrame = m_frameCounter;
-        return &insertedIt->second;
+        return insertedIt->second;
     }
 
     void VkRenderPassManager::OnPresent() {
@@ -1595,23 +1507,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             ClearAttachmentPayload clearPayload{};
             SharedPtr<MG_State::GLState::ITextureObject> liveTexture;
             if (pending.hasInlinePayload) {
-                // The inline payload was snapshotted when the entry was CREATED, but the
-                // clear VALUE is not part of the entry's hash - a cache hit with a newer
-                // glClear would replay the creation-time value and drop the new one (the
-                // texture path below is immune because it re-reads the live payload).
-                // Same defense as ClearAttachmentsOnActiveRenderPass: prefer the live
-                // pending clear, fall back to the snapshot only when none is queued.
-                if (s_renderPassManager != nullptr &&
-                    s_renderPassManager->GetPendingRenderbufferClear(pending.renderbuffer, clearPayload)) {
-                    if ((clearPayload.mask & GL_COLOR_BUFFER_BIT) != 0 && pending.renderbuffer != nullptr &&
-                        MG_Util::GetBaseInternalFormatComponentCount(pending.renderbuffer->GetInternalFormat()) ==
-                            3) {
-                        // RGB renderbuffers are backed by an RGBA image; the missing alpha reads as 1.
-                        ForceOpaqueClearAlpha(clearPayload);
-                    }
-                } else {
-                    clearPayload = pending.inlinePayload;
-                }
+                clearPayload = pending.inlinePayload;
             } else {
                 if (pending.key.texture == nullptr ||
                     !s_clearManager->GetPendingClear(pending.key, clearPayload, liveTexture)) {

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.h

@@ -101,42 +101,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             std::swap(layers, that.layers);
             std::swap(lastUsedFrame, that.lastUsedFrame);
         }
-        // Move ASSIGNMENT, not just construction. The move constructor above and the
-        // destructor below each independently suppress the implicit one, which left the
-        // type move-constructible but not move-assignable - and therefore not swappable,
-        // which std::swap(pair&, pair&) requires. That was invisible while UnorderedMap
-        // only ever move-CONSTRUCTED an element into a fresh slot. ska::flat_hash_map
-        // probes robin-hood: inserting swaps the entry being placed against the one
-        // already sitting in the slot whenever it has travelled further from its desired
-        // position, so the mapped type has to be swappable or the table fails to
-        // instantiate at all.
-        //
-        // SWAP SEMANTICS, exactly like the move constructor: this does not release the
-        // destination's handles, it parks them in `that`, which destroys them when it
-        // dies. That is correct for the only caller - std::swap, whose temporary expires
-        // immediately - and it is what keeps the three-move sequence from destroying a
-        // live render pass. It is NOT correct for a hand-written `a = std::move(b)` where
-        // `a` held live handles and `b` outlives the statement: those handles would then
-        // survive until `b` dies. There is no such caller; add a destroy-then-steal
-        // assignment before writing one.
-        RenderPassEntry& operator=(RenderPassEntry&& that) noexcept {
-            if (this != &that) {
-                std::swap(hash, that.hash);
-                std::swap(renderPass, that.renderPass);
-                std::swap(framebuffer, that.framebuffer);
-                std::swap(compatibilityHash, that.compatibilityHash);
-                std::swap(pendingClearAttachments, that.pendingClearAttachments);
-                std::swap(trackedAttachmentLayouts, that.trackedAttachmentLayouts);
-                std::swap(attachmentCount, that.attachmentCount);
-                std::swap(colorAttachmentCount, that.colorAttachmentCount);
-                std::swap(hasDepthStencilAttachment, that.hasDepthStencilAttachment);
-                std::swap(sampleCount, that.sampleCount);
-                std::swap(extent, that.extent);
-                std::swap(layers, that.layers);
-                std::swap(lastUsedFrame, that.lastUsedFrame);
-            }
-            return *this;
-        }
         RenderPassEntry(
             Uint64 hash,
             VkRenderPass renderpass,
@@ -243,24 +207,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // draw against a depth-less active pass resolves to a new (incompatible)
         // entry, which the caller's compatibility check turns into a pass split;
         // the new pass's depth loads DONT_CARE (content was undefined all along).
-        //
-        // Returns NULLPTR when this framebuffer cannot be represented as a Vulkan render pass at
-        // all - a texture the texture manager declined to back (an unsupported format or sample
-        // count), or an attachment view it cannot construct (a layer span the image has no room
-        // for, a 3D image whose format was refused 2D-array compatibility). This used to be
-        // unrepresentable: the function returned a reference, so the only thing the two fallible
-        // calls it builds on could do was trip a MOBILEGL_ASSERT - which is compiled out of every
-        // INFO build - and then dereference the null resource, or hand VK_NULL_HANDLE to
-        // vkCreateFramebuffer. That took the whole process down (51 lost CTS records over 21
-        // bodies, one runner restart each) where a declined draw is merely a wrong picture.
-        //
-        // EVERY caller must handle nullptr by dropping the operation, exactly as the draw path
-        // already drops a draw whose sampler descriptor could not be resolved
-        // (UniformManager::BindProgramUniformBuffers). The failure paths log MGLOG_E_ONCE
-        // themselves, so a caller needs no message of its own.
-        [[nodiscard]] RenderPassEntry* GetOrCreateRenderPass(const MG_State::GLState::FramebufferObject& fbo,
-                                                             Uint32 swapchainImageIndex,
-                                                             Bool drawUsesDepthStencil = true);
+        RenderPassEntry& GetOrCreateRenderPass(const MG_State::GLState::FramebufferObject& fbo,
+                                               Uint32 swapchainImageIndex,
+                                               Bool drawUsesDepthStencil = true);
         void QueueRenderbufferClear(GLbitfield mask, const ClearFramebufferPayload& clearPayload,
                                     const MG_State::GLState::FramebufferObject& drawFbo);
         void QueueRenderbufferClear(const ClearAttachmentPayload& clearPayload,
@@ -304,11 +253,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // or a pending clear. Portable to Vulkan 1.1 (no dynamic_rendering / imageless FB needed).
         Bool m_rpFastValid = false;
         const MG_State::GLState::FramebufferObject* m_rpFastFbo = nullptr;
-        // The FBO's never-reused lifetime id joins the raw pointer + Uint16 version:
-        // a deleted FBO reallocated at the same address whose fresh setup performed
-        // the same number of version bumps would otherwise compare equal (both count
-        // from 0), serving the dead framebuffer's pass to the new object.
-        Uint64 m_rpFastFboLifetimeId = 0;
         Uint16 m_rpFastFboVersion = 0;
         Uint32 m_rpFastSwapchainIndex = 0;
         Uint64 m_rpFastTexEpoch = 0;
@@ -371,30 +315,26 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint64 deferredAtFrame = 0;
         };
 
-        // Node-based std::unordered_map, deliberately NOT the open-addressing UnorderedMap:
+        // 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. Growing
-        // an open-addressed table relocates every element, so the cached pointer went on to name
-        // freed storage still holding the pre-clear VK_IMAGE_LAYOUT_UNDEFINED; BlitFramebuffer bailed
-        // 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.
+        // 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.
-        //
-        // The case for keeping this node-based got STRONGER with ska::flat_hash_map, so do not read
-        // the paragraph above as merely historical: ska erases by shifting the rest of the probe
-        // cluster backwards into the hole, so erasing one renderbuffer relocates OTHER renderbuffers'
-        // entries - a cached pointer can now be invalidated by a key it has nothing to do with, which
-        // no call-site ordering rule can defend against. (What did change: ska's operator[] returns on
-        // a hit before it runs its grow check, so a plain lookup of a PRESENT key no longer relocates.
-        // That narrows the insert hazard; it does not touch the erase one.)
+        // 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*, PendingRenderbufferClear> m_pendingRenderbufferClears;
         Vector<DeferredRenderbufferRelease> m_deferredRenderbufferReleases;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.cpp

@@ -21,156 +21,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                    sampler.GetWrapR() == SamplerWrapMode::ClampToBorder;
         }
 
-        // The numeric domain the texture is SAMPLED in. Vulkan splits VkBorderColor into a float
-        // family and an integer family and requires the sampler's choice to match the image view's
-        // format (a float border on an integer view, or the reverse, is undefined) - so the domain
-        // comes from the TEXTURE, while the value comes from whichever GL entry point wrote it.
-        enum class BorderColorDomain {
-            Float,
-            SignedInteger,
-            UnsignedInteger
-        };
-
-        BorderColorDomain ResolveBorderColorDomain(TextureInternalFormat format) {
-            switch (format) {
-            case TextureInternalFormat::R8I:
-            case TextureInternalFormat::R16I:
-            case TextureInternalFormat::R32I:
-            case TextureInternalFormat::RG8I:
-            case TextureInternalFormat::RG16I:
-            case TextureInternalFormat::RG32I:
-            case TextureInternalFormat::RGB8I:
-            case TextureInternalFormat::RGB16I:
-            case TextureInternalFormat::RGB32I:
-            case TextureInternalFormat::RGBA8I:
-            case TextureInternalFormat::RGBA16I:
-            case TextureInternalFormat::RGBA32I:
-                return BorderColorDomain::SignedInteger;
-            case TextureInternalFormat::R8UI:
-            case TextureInternalFormat::R16UI:
-            case TextureInternalFormat::R32UI:
-            case TextureInternalFormat::RG8UI:
-            case TextureInternalFormat::RG16UI:
-            case TextureInternalFormat::RG32UI:
-            case TextureInternalFormat::RGB8UI:
-            case TextureInternalFormat::RGB16UI:
-            case TextureInternalFormat::RGB32UI:
-            case TextureInternalFormat::RGBA8UI:
-            case TextureInternalFormat::RGBA16UI:
-            case TextureInternalFormat::RGBA32UI:
-            case TextureInternalFormat::RGB10A2UI:
-                return BorderColorDomain::UnsignedInteger;
-            default:
-                return BorderColorDomain::Float;
-            }
-        }
-
-        Bool IsSignedNormalizedFormat(TextureInternalFormat format) {
-            switch (format) {
-            case TextureInternalFormat::R8Snorm:
-            case TextureInternalFormat::R16Snorm:
-            case TextureInternalFormat::RG8Snorm:
-            case TextureInternalFormat::RG16Snorm:
-            case TextureInternalFormat::RGB8Snorm:
-            case TextureInternalFormat::RGB16Snorm:
-            case TextureInternalFormat::RGBA8Snorm:
-            case TextureInternalFormat::RGBA16Snorm:
-                return true;
-            default:
-                return false;
-            }
-        }
-
-        // GL 4.6 core 8.14.2: "The border values are clamped before they are used, according to the
-        // format in which texture components are stored. For signed and unsigned normalized
-        // fixed-point formats, border values are clamped to [-1,1] and [0,1] respectively. For
-        // floating-point and integer formats, border values are clamped to the representable range of
-        // the format." Every clause of that sentence is a real case here - the clamp is not just the
-        // normalized one.
-        //
-        // Only the 32-bit float formats are genuinely unclamped: every finite float is representable
-        // in them. Half-float has a finite maximum, and the two packed "float" formats are UNSIGNED,
-        // so a negative border on them must come back as 0 rather than as a negative number the
-        // driver delivers verbatim through VK_BORDER_COLOR_FLOAT_CUSTOM_EXT.
-        struct FloatBorderRange {
-            Bool clamped = true;
-            Float minValue = 0.0f;
-            Float maxValue = 1.0f;
-        };
-
-        FloatBorderRange ResolveFloatBorderRange(TextureInternalFormat format, Bool isSignedNormalized) {
-            switch (format) {
-            case TextureInternalFormat::R32F:
-            case TextureInternalFormat::RG32F:
-            case TextureInternalFormat::RGB32F:
-            case TextureInternalFormat::RGBA32F:
-                return {false, 0.0f, 0.0f};
-            case TextureInternalFormat::R16F:
-            case TextureInternalFormat::RG16F:
-            case TextureInternalFormat::RGB16F:
-            case TextureInternalFormat::RGBA16F:
-                return {true, -65504.0f, 65504.0f};
-            // Unsigned packed floats: no sign bit at all. 65024 is the largest 11-bit float; the
-            // 10-bit blue channel tops out lower (64512) and RGB9E5 higher (65408), but the bound
-            // that matters for correctness is the lower one, and a single conservative upper bound
-            // costs nothing a real border colour will ever notice.
-            case TextureInternalFormat::R11FG11FB10F:
-                return {true, 0.0f, 64512.0f};
-            case TextureInternalFormat::RGB9E5:
-                return {true, 0.0f, 65408.0f};
-            default:
-                return {true, isSignedNormalized ? -1.0f : 0.0f, 1.0f};
-            }
-        }
-
-        // Per-component representable range of an integer texture format, as Int64 so that the whole
-        // signed and unsigned 32-bit ranges are expressible in one type and the clamp can be written
-        // once for both domains. Alpha is carried separately because RGB10_A2UI is the one format
-        // whose alpha is narrower than its colour channels.
-        struct IntegerBorderRange {
-            Int64 rgbMin = 0;
-            Int64 rgbMax = 0;
-            Int64 alphaMin = 0;
-            Int64 alphaMax = 0;
-        };
-
-        IntegerBorderRange ResolveIntegerBorderRange(TextureInternalFormat format) {
-            const auto uniform = [](Int64 low, Int64 high) { return IntegerBorderRange{low, high, low, high}; };
-            switch (format) {
-            case TextureInternalFormat::R8I:
-            case TextureInternalFormat::RG8I:
-            case TextureInternalFormat::RGB8I:
-            case TextureInternalFormat::RGBA8I:
-                return uniform(-128, 127);
-            case TextureInternalFormat::R16I:
-            case TextureInternalFormat::RG16I:
-            case TextureInternalFormat::RGB16I:
-            case TextureInternalFormat::RGBA16I:
-                return uniform(-32768, 32767);
-            case TextureInternalFormat::R8UI:
-            case TextureInternalFormat::RG8UI:
-            case TextureInternalFormat::RGB8UI:
-            case TextureInternalFormat::RGBA8UI:
-                return uniform(0, 255);
-            case TextureInternalFormat::R16UI:
-            case TextureInternalFormat::RG16UI:
-            case TextureInternalFormat::RGB16UI:
-            case TextureInternalFormat::RGBA16UI:
-                return uniform(0, 65535);
-            case TextureInternalFormat::R32UI:
-            case TextureInternalFormat::RG32UI:
-            case TextureInternalFormat::RGB32UI:
-            case TextureInternalFormat::RGBA32UI:
-                return uniform(0, 4294967295LL);
-            case TextureInternalFormat::RGB10A2UI:
-                return {0, 1023, 0, 3};
-            default:
-                // The signed 32-bit formats, and anything unexpected: the full int32 range, i.e. a
-                // clamp that cannot alter a value the GL entry points could have carried.
-                return uniform(-2147483648LL, 2147483647LL);
-            }
-        }
-
         Bool IsDepthTextureFormat(TextureInternalFormat format) {
             switch (format) {
             case TextureInternalFormat::DepthComponent:
@@ -222,9 +72,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_config = initInfo.config;
         m_samplerAnisotropySupported = initInfo.samplerAnisotropySupported;
         m_maxSamplerAnisotropy = std::max(initInfo.maxSamplerAnisotropy, 1.0f);
-        m_customBorderColorSupported = initInfo.customBorderColorSupported;
-        m_maxCustomBorderColorSamplers = initInfo.maxCustomBorderColorSamplers;
-        m_customBorderColorSamplerCount = 0;
         MOBILEGL_ASSERT(m_device != VK_NULL_HANDLE && m_config != nullptr,
                         "VkSamplerManager::Initialize failed: invalid initialization info");
         return true;
@@ -255,9 +102,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_device = VK_NULL_HANDLE;
         m_config = nullptr;
         m_frameBoundaryCounter = 0;
-        m_customBorderColorSupported = false;
-        m_maxCustomBorderColorSamplers = 0;
-        m_customBorderColorSamplerCount = 0;
     }
 
     void VkSamplerManager::OnFrameBoundary() {
@@ -279,9 +123,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 if (m_device != VK_NULL_HANDLE && entry.handle != VK_NULL_HANDLE) {
                     vkDestroySampler(m_device, entry.handle, nullptr);
                 }
-                if (entry.usesCustomBorderColor && m_customBorderColorSamplerCount > 0) {
-                    --m_customBorderColorSamplerCount;
-                }
                 it = m_samplers.erase(it);
             } else {
                 ++it;
@@ -290,8 +131,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     Uint64 VkSamplerManager::BuildSamplerKey(const MG_State::GLState::SamplerObject& sampler,
-                                             Bool forceNearestFiltering, Bool singleLevelView,
-                                             const ResolvedBorderColor& borderColor) const {
+                                             const MG_State::GLState::ITextureObject& texture,
+                                             Bool forceNearestFiltering, Bool singleLevelView) const {
         MOBILEGL_ASSERT(m_config != nullptr, "VkSamplerManager::BuildSamplerKey: m_config is null");
         XXHASH_VERIFY(XXH64_reset(m_hashState, m_config->CacheVersion));
 
@@ -325,13 +166,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         XXHASH_VERIFY(XXH64_update(m_hashState, &compareMode, sizeof(compareMode)));
         const auto compareFunc = sampler.GetSamplerCompareFunc();
         XXHASH_VERIFY(XXH64_update(m_hashState, &compareFunc, sizeof(compareFunc)));
-        // The resolved enum AND, when it is one of the *_CUSTOM_EXT values, the sixteen bytes of the
-        // colour itself: two samplers that differ only in a custom border colour carry the same enum
-        // and would otherwise collide onto whichever one was created first.
-        XXHASH_VERIFY(XXH64_update(m_hashState, &borderColor.color, sizeof(borderColor.color)));
-        if (borderColor.isCustom) {
-            XXHASH_VERIFY(XXH64_update(m_hashState, &borderColor.customValue, sizeof(borderColor.customValue)));
-        }
+        const auto borderColor = ResolveVkBorderColor(sampler, texture);
+        XXHASH_VERIFY(XXH64_update(m_hashState, &borderColor, sizeof(borderColor)));
         return XXH64_digest(m_hashState);
     }
 
@@ -347,9 +183,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // allocation for a genuinely single-level image) and faults the GPU - the same failure
         // the default-framebuffer blit shader had to work around with an explicit-LOD sample.
         const Bool singleLevelView = viewLevelCount == 1;
-        // Resolved once and used for both the key and the create-info; see ResolvedBorderColor.
-        const ResolvedBorderColor borderColor = ResolveBorderColor(sampler, texture);
-        const Uint64 key = BuildSamplerKey(sampler, forceNearestFiltering, singleLevelView, borderColor);
+        const Uint64 key = BuildSamplerKey(sampler, texture, forceNearestFiltering, singleLevelView);
         auto it = m_samplers.find(key);
         if (it != m_samplers.end()) {
             it->second.lastUsedFrameBoundary = m_frameBoundaryCounter;
@@ -377,21 +211,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // Must match BuildSamplerKey's resolution exactly.
         samplerInfo.maxLod = ResolveSingleLevelMaxLod(sampler, singleLevelView);
         samplerInfo.minLod = ResolveEffectiveMinLod(sampler, samplerInfo.maxLod);
-        samplerInfo.borderColor = borderColor.color;
+        samplerInfo.borderColor = ResolveVkBorderColor(sampler, texture);
         samplerInfo.unnormalizedCoordinates = VK_FALSE;
 
-        // VK_EXT_custom_border_color. `format` stays UNDEFINED, which is legal only because
-        // customBorderColorWithoutFormat was required alongside customBorderColors at device
-        // creation - a GL sampler object has no idea which texture it will be paired with.
-        VkSamplerCustomBorderColorCreateInfoEXT customBorderColorInfo{};
-        if (borderColor.isCustom) {
-            customBorderColorInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
-            customBorderColorInfo.customBorderColor = borderColor.customValue;
-            customBorderColorInfo.format = VK_FORMAT_UNDEFINED;
-            customBorderColorInfo.pNext = samplerInfo.pNext;
-            samplerInfo.pNext = &customBorderColorInfo;
-        }
-
         VkSampler vkSampler = VK_NULL_HANDLE;
         VK_VERIFY(vkCreateSampler(m_device, &samplerInfo, nullptr, &vkSampler), "vkCreateSampler(texture)");
 
@@ -400,10 +222,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         entry.externalIndex = sampler.GetExternalIndex();
         entry.version = sampler.GetVersion();
         entry.lastUsedFrameBoundary = m_frameBoundaryCounter;
-        entry.usesCustomBorderColor = borderColor.isCustom;
-        if (entry.usesCustomBorderColor) {
-            ++m_customBorderColorSamplerCount;
-        }
         m_samplers[key] = entry;
         return vkSampler;
     }
@@ -463,148 +281,39 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
     }
 
-    VkSamplerManager::ResolvedBorderColor VkSamplerManager::ResolveBorderColor(
-        const MG_State::GLState::SamplerObject& sampler, const MG_State::GLState::ITextureObject& texture) const {
-        ResolvedBorderColor resolved{};
+    VkBorderColor VkSamplerManager::ResolveVkBorderColor(const MG_State::GLState::SamplerObject& sampler,
+                                                         const MG_State::GLState::ITextureObject& texture) {
         if (!UsesBorderColor(sampler)) {
-            return resolved; // FLOAT_TRANSPARENT_BLACK, never sampled
+            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 format = texture.GetFormat();
-        const auto domain = ResolveBorderColorDomain(format);
-        const Bool canUseCustom = m_customBorderColorSupported && m_maxCustomBorderColorSamplers > 0 &&
-                                  m_customBorderColorSamplerCount < m_maxCustomBorderColorSamplers;
+        const auto& borderColor = sampler.GetBorderColor();
+        const Bool isDepthTexture = IsDepthTextureFormat(texture.GetFormat());
 
-        if (domain != BorderColorDomain::Float) {
-            // An integer image view REQUIRES an integer border colour, whatever the value is - even
-            // (0,0,0,1). The value itself is whichever integer form the application wrote; a float
-            // border on an integer texture is nonsense GL leaves undefined, so the derived integer
-            // representation (a plain cast) is as good an answer as any.
-            //
-            // Clamped to the format's representable range FIRST, per GL 4.6 core 8.14.2, and read
-            // through Int64 so the whole signed and unsigned 32-bit ranges are expressible at once.
-            //
-            // Which representation to start from is the TEXTURE's domain, not the entry-point form
-            // the application used. GL 4.6 core 8.10 stores an "I"-form border colour unmodified with
-            // an integer internal data type and does not define a sign conversion between the two
-            // integer forms, so the stored bits are reinterpreted in the sampled format's own
-            // signedness. Measured, not assumed: a border of -1 written with glTexParameterIiv
-            // against a GL_R8UI texture samples as 255 on the ES driver, i.e. as 0xFFFFFFFF clamped
-            // to the format's maximum - see the IntegerBorderColorScenario case that pins it. Picking
-            // the representation by the FORM instead would answer 0 here, which is a defensible
-            // reading of the same spec text but puts DirectVulkan at odds with DirectGLES - and
-            // DirectGLES cannot deviate, it forwards the value to the driver verbatim. Cross-backend
-            // agreement decides it.
-            const auto range = ResolveIntegerBorderRange(format);
-            const auto& borderColorI = sampler.GetBorderColorI();
-            const auto& borderColorUI = sampler.GetBorderColorUI();
-            const Bool startFromUnsigned = domain == BorderColorDomain::UnsignedInteger;
-            Int64 clamped[4];
-            for (SizeT channel = 0; channel < 4; ++channel) {
-                const Int64 raw = startFromUnsigned ? static_cast<Int64>(borderColorUI[channel])
-                                                    : static_cast<Int64>(borderColorI[channel]);
-                const Int64 low = channel == 3 ? range.alphaMin : range.rgbMin;
-                const Int64 high = channel == 3 ? range.alphaMax : range.rgbMax;
-                clamped[channel] = std::clamp(raw, low, high);
-            }
-
-            // Matched against the CLAMPED value, so a border the format cannot hold still lands on
-            // the palette entry it clamps to rather than missing every one of them.
-            const Bool allZeroRgb = clamped[0] == 0 && clamped[1] == 0 && clamped[2] == 0;
-            if (allZeroRgb && clamped[3] == 0) {
-                resolved.color = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
-                return resolved;
-            }
-            if (allZeroRgb && clamped[3] == 1) {
-                resolved.color = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
-                return resolved;
-            }
-            if (clamped[0] == 1 && clamped[1] == 1 && clamped[2] == 1 && clamped[3] == 1) {
-                resolved.color = VK_BORDER_COLOR_INT_OPAQUE_WHITE;
-                return resolved;
-            }
-            if (canUseCustom) {
-                resolved.color = VK_BORDER_COLOR_INT_CUSTOM_EXT;
-                resolved.isCustom = true;
-                for (SizeT channel = 0; channel < 4; ++channel) {
-                    if (domain == BorderColorDomain::UnsignedInteger) {
-                        resolved.customValue.uint32[channel] = static_cast<Uint32>(clamped[channel]);
-                    } else {
-                        resolved.customValue.int32[channel] = static_cast<Int32>(clamped[channel]);
-                    }
-                }
-                return resolved;
-            }
-            // No custom colour available: pick the nearest of the three integer palette entries
-            // rather than always answering transparent black, which is what turned an integer border
-            // of (-1,-1,-1,-1) into 0 and broke the CTS's clamped-texel detection outright.
-            const Bool opaque = clamped[3] != 0;
-            const Bool bright = clamped[0] != 0 || clamped[1] != 0 || clamped[2] != 0;
-            resolved.color = !opaque ? VK_BORDER_COLOR_INT_TRANSPARENT_BLACK
-                                     : (bright ? VK_BORDER_COLOR_INT_OPAQUE_WHITE : VK_BORDER_COLOR_INT_OPAQUE_BLACK);
-            return resolved;
-        }
-
-        // Float domain. GL 4.6 core 8.14.2/8.23: the border colour is interpreted in the texture's
-        // format, so it is clamped to that format's representable range first. Without the clamp the
-        // CTS's border of (255,255,255,255) on a GL_RGBA8 texture matched none of the palette entries
-        // and fell through to transparent black - every border texel sampled 0 where the test wanted
-        // 255. The range is per format class, not just the normalized [0,1] / [-1,1] pair: only the
-        // 32-bit float formats are unclamped.
-        FloatVec4 borderColor = sampler.GetBorderColor();
-        if (const auto range = ResolveFloatBorderRange(format, IsSignedNormalizedFormat(format)); range.clamped) {
-            borderColor = FloatVec4(std::clamp(borderColor.x(), range.minValue, range.maxValue),
-                                    std::clamp(borderColor.y(), range.minValue, range.maxValue),
-                                    std::clamp(borderColor.z(), range.minValue, range.maxValue),
-                                    std::clamp(borderColor.w(), range.minValue, range.maxValue));
-        }
-
-        // A depth texture samples one component, so only x decides - and its alpha reads as 1.
-        if (IsDepthTextureFormat(format)) {
+        if (isDepthTexture) {
             if (NearlyEqual(borderColor.x(), 1.0f)) {
-                resolved.color = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
-                return resolved;
+                return VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
             }
             if (NearlyEqual(borderColor.x(), 0.0f)) {
-                resolved.color = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
-                return resolved;
+                return VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
             }
         }
 
         const Bool rgbZero = NearlyEqual(borderColor.x(), 0.0f) && NearlyEqual(borderColor.y(), 0.0f) &&
                              NearlyEqual(borderColor.z(), 0.0f);
         if (rgbZero && NearlyEqual(borderColor.w(), 0.0f)) {
-            resolved.color = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
-            return resolved;
+            return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
         }
         if (rgbZero && NearlyEqual(borderColor.w(), 1.0f)) {
-            resolved.color = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
-            return resolved;
+            return VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
         }
         if (NearlyEqual(borderColor.x(), 1.0f) && NearlyEqual(borderColor.y(), 1.0f) &&
             NearlyEqual(borderColor.z(), 1.0f) && NearlyEqual(borderColor.w(), 1.0f)) {
-            resolved.color = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
-            return resolved;
+            return VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
         }
 
-        if (canUseCustom) {
-            resolved.color = VK_BORDER_COLOR_FLOAT_CUSTOM_EXT;
-            resolved.isCustom = true;
-            resolved.customValue.float32[0] = borderColor.x();
-            resolved.customValue.float32[1] = borderColor.y();
-            resolved.customValue.float32[2] = borderColor.z();
-            resolved.customValue.float32[3] = borderColor.w();
-            return resolved;
-        }
-
-        // Nearest of the three float palette entries. Transparent black stays the answer for a
-        // transparent border, which is what the old unconditional fallback got right by accident.
-        const Bool opaque = borderColor.w() >= 0.5f;
-        const Bool bright = (borderColor.x() + borderColor.y() + borderColor.z()) >= 1.5f;
-        resolved.color = !opaque ? VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK
-                                 : (bright ? VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE : VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK);
-        return resolved;
+        return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
     }
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.h

@@ -28,13 +28,6 @@ public:
         Bool samplerAnisotropySupported = false;
         // VkPhysicalDeviceLimits::maxSamplerAnisotropy.
         Float maxSamplerAnisotropy = 1.0f;
-        // VK_EXT_custom_border_color was enabled with BOTH customBorderColors and
-        // customBorderColorWithoutFormat; see VulkanRenderer::m_customBorderColorFeatureEnabled.
-        Bool customBorderColorSupported = false;
-        // VkPhysicalDeviceCustomBorderColorPropertiesEXT::maxCustomBorderColorSamplers. A hard device
-        // limit on how many LIVE samplers may carry a custom border colour, so the cache counts them
-        // and falls back to the snapped predefined value once it is reached.
-        Uint32 maxCustomBorderColorSamplers = 0;
     };
 
     Bool Initialize(const InitInfo& initInfo);
@@ -59,21 +52,6 @@ public:
     // boundaries.
     void OnFrameBoundary();
 
-    // What GL_TEXTURE_BORDER_COLOR resolves to for one (sampler, texture) pair. `color` is always a
-    // legal VkBorderColor; when `isCustom` it is one of the *_CUSTOM_EXT values and `customValue`
-    // carries the actual components in a VkSamplerCustomBorderColorCreateInfoEXT.
-    //
-    // Resolved ONCE per GetOrCreateSampler call and threaded into both the cache key and the
-    // create-info, so the two cannot disagree - the same discipline the resolved anisotropy needs,
-    // and here it also makes the maxCustomBorderColorSamplers fallback deterministic: whether a
-    // custom colour was affordable is decided before the key is built, not twice with a budget
-    // change in between.
-    struct ResolvedBorderColor {
-        VkBorderColor color = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
-        VkClearColorValue customValue{};
-        Bool isCustom = false;
-    };
-
 private:
     struct SamplerCacheEntry {
         VkSampler handle = VK_NULL_HANDLE;
@@ -82,18 +60,17 @@ private:
         // Frame boundary of the last cache hit; entries idle past the
         // OnFrameBoundary retirement age have their VkSampler destroyed.
         Uint64 lastUsedFrameBoundary = 0;
-        // Counted against maxCustomBorderColorSamplers for as long as this entry lives.
-        Bool usesCustomBorderColor = false;
     };
 
-    Uint64 BuildSamplerKey(const MG_State::GLState::SamplerObject& sampler, Bool forceNearestFiltering,
-                           Bool singleLevelView, const ResolvedBorderColor& borderColor) const;
+    Uint64 BuildSamplerKey(const MG_State::GLState::SamplerObject& sampler,
+                           const MG_State::GLState::ITextureObject& texture,
+                           Bool forceNearestFiltering, Bool singleLevelView) const;
     static VkFilter ToVkFilter(SamplerFilterMode mode);
     static VkSamplerMipmapMode ToVkMipmapMode(SamplerMipmapMode mode);
     static VkSamplerAddressMode ToVkAddressMode(SamplerWrapMode mode);
     static VkCompareOp ToVkCompareOp(SamplerCompareFunc func);
-    ResolvedBorderColor ResolveBorderColor(const MG_State::GLState::SamplerObject& sampler,
-                                           const MG_State::GLState::ITextureObject& texture) const;
+    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
     // the sampler filters linearly both ways, otherwise the GL request clamped to the device limit.
     // GL happily carries GL_TEXTURE_MAX_ANISOTROPY on a NEAREST sampler (Blaze3D's blocks do exactly
@@ -105,12 +82,6 @@ private:
     const VulkanRendererConfig* m_config = nullptr;
     Bool m_samplerAnisotropySupported = false;
     Float m_maxSamplerAnisotropy = 1.0f;
-    Bool m_customBorderColorSupported = false;
-    Uint32 m_maxCustomBorderColorSamplers = 0;
-    // Live cache entries carrying a custom border colour. Kept in step with the entries themselves
-    // in exactly the three places one can appear or disappear: creation, the OnFrameBoundary sweep,
-    // and Shutdown.
-    Uint32 m_customBorderColorSamplerCount = 0;
     UnorderedMap<Uint64, SamplerCacheEntry> m_samplers;
     // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
     Uint64 m_frameBoundaryCounter = 0;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.h

@@ -10,10 +10,8 @@
 
 #include "../VkIncludes.h"
 #include <Includes.h>
-#include <MG_State/GLState/FramebufferState/FramebufferObject.h>
 #include <MG_State/GLState/TextureState/TextureObject.h>
 #include <vk_mem_alloc.h>
-#include <algorithm>
 #include <unordered_map>
 #include <unordered_set>
 
@@ -24,102 +22,6 @@ class ITextureObject;
 namespace MobileGL::MG_Backend::DirectVulkan {
 enum class SamplerNumericDomain : Uint8;
 
-// What VkFormat a GL internal format is BACKED with, and how a shadow upload has to be reshaped to
-// fit it. This is not the same question as "is there an exact VkFormat for this GL format", which is
-// what ConvertTextureInternalFormatToVkEnum answers: several GL formats have no Vulkan twin at all
-// (RGBA2, RGBA12) and several three-channel ones are deliberately widened to their four-channel twin
-// because Vulkan devices rarely support the 3-channel layouts.
-//
-// SHARED, and it must stay the only answer to that question. A renderbuffer and a texture of the
-// same GL format have to resolve to the SAME VkFormat or every blit, resolve and glCopyImageSubData
-// between them crosses a size-incompatible pair, which vkCmdCopyImage leaves undefined
-// (VUID-vkCmdCopyImage-srcImage-01548). The renderbuffer path used to carry a hand-maintained second
-// copy of this table that was missing four rows - RGBA2, RGBA4, RGB5A1 and RGBA12 - so those four
-// renderbuffer formats either got no image at all or a 16-bit-packed one facing a 32-bit texture.
-struct TextureFormatInfo {
-    VkFormat format = VK_FORMAT_UNDEFINED;
-    // The GL format has three channels and is carried in a four-channel image; a shadow upload has
-    // to be expanded, inserting `alphaBytes` after every `componentByteCount * 3` source bytes.
-    Bool expandRgbToRgba = false;
-    Uint32 componentByteCount = 0;
-    Array<Uint8, 4> alphaBytes = {0, 0, 0, 0};
-};
-
-// Callers that only need the backing VkFormat (a renderbuffer has no shadow upload to reshape) take
-// `.format` and ignore the rest.
-TextureFormatInfo ResolveTextureFormatInfo(TextureInternalFormat format);
-
-// A GL 1D-ARRAY level keeps its LAYER COUNT in the state-side HEIGHT: that is what
-// glTexImage2D(GL_TEXTURE_1D_ARRAY, width, layers) means, and the frontend records the level
-// as {width, layers, 1} (see GL_Texture.cpp's AllocateStorage and the completeness walk in
-// TextureObject.cpp, which shrinks only x down the chain). Vulkan packs it the other way: a
-// 1D array is a VK_IMAGE_TYPE_1D image whose extent.height MUST be 1 and whose layers live in
-// arrayLayers - i.e. in the slot this backend reads out of z. So every place that turns a GL
-// level size into Vulkan image geometry has to move the count across first, and every GL-space
-// sub-box that rides along with it has to move its y the same way. DirectGLES performs the
-// identical remap onto the ES 2D array it maps 1D arrays to (GetBackendUploadSize).
-//
-// Applied to nothing else: a 2D array, a cube array and a 3D texture all already carry their
-// depth/layer count in z, which is where the Vulkan side expects it.
-inline IntVec3 ToVulkanLevelExtent(TextureTarget stateTarget, const IntVec3& glTexelSize) {
-    if (stateTarget == TextureTarget::Texture1DArray) {
-        return {glTexelSize.x(), 1, glTexelSize.y()};
-    }
-    return glTexelSize;
-}
-
-// How many Vulkan array layers (or, for a 3D image, z slices) a GL framebuffer attachment spans.
-//
-// THE ONE COPY, deliberately. This used to exist twice - privately in VkRenderPassManager.cpp and
-// again in VkClearManager.cpp - and the two are not independent: the render pass builds the
-// attachment view and VkFramebufferCreateInfo::layers from one, while the CLEAR key built from the
-// other is written verbatim into VkImageSubresourceRange::layerCount when a queued glClear is
-// materialised outside a render pass (MaterializePendingClearForTexture). They are two consumers
-// of the same GL clear, so any disagreement means the same glClear produces two different pictures
-// depending only on which path happens to consume it first - and the materialise path then POPS
-// the entry, so the other one never runs. Fixing one copy and leaving the other is exactly how
-// that split gets introduced; keep them the same function.
-//
-// Two shapes make this more than `size.z()`:
-//   * GL_TEXTURE_1D_ARRAY keeps its layer count in the state-side HEIGHT (see ToVulkanLevelExtent
-//     just above), so z reads 1 and every layer above the first was silently dropped.
-//   * GL_TEXTURE_CUBE_MAP is attached layered as its REPRESENTATIVE upload target, the +X face
-//     (ResolveRepresentableFramebufferTextureUploadTarget), and one face's level size has z = 1 -
-//     but a layered cube attachment names all six faces (GL 4.6 core 9.2.8), which are the image's
-//     six array layers. A cube ARRAY needs no such arm: its representative target carries 6n in z.
-inline Uint32 ResolveAttachmentLayerCount(const MG_State::GLState::FramebufferAttachmentObject& attachment) {
-    if (!attachment.IsLayered()) {
-        return 1u;
-    }
-    const auto& texture = attachment.GetTexture();
-    const TextureTarget target = texture != nullptr ? texture->GetTarget() : TextureTarget::Unknown;
-    if (target == TextureTarget::TextureCubeMap) {
-        return 6u;
-    }
-    return static_cast<Uint32>(std::max(ToVulkanLevelExtent(target, attachment.GetSize()).z(), 1));
-}
-
-// A GL framebuffer attachment's level/layer, and a GL image unit's, are relative to the texture
-// the application NAMED. When that texture was created by glTextureView (ARB_texture_view) they
-// are relative to the VIEW, and have to be shifted into the storage image's numbering before they
-// can index a Vulkan subresource - DirectVulkan gives a view no image of its own, it shares the
-// storage texture's (VkTextureManager::StorageTextureOf).
-//
-// Apply EXACTLY ONCE, at the boundary where a GL level/layer becomes a subresource index. Every
-// GetOrCreate*View entry point below expects values that have already been through here, and so
-// does everything that reads or copies an attachment directly. Both are identity on a plain
-// texture (TEXTURE_VIEW_MIN_LEVEL / MIN_LAYER are 0 there), so the conversion is unconditional
-// and there is no second, view-only code path to keep in step.
-inline Uint32 ToStorageMipLevel(const MG_State::GLState::ITextureObject* texture, Int glLevel) {
-    const Uint32 level = static_cast<Uint32>(glLevel > 0 ? glLevel : 0);
-    return texture != nullptr ? level + static_cast<Uint32>(texture->GetViewMinLevel()) : level;
-}
-
-inline Uint32 ToStorageArrayLayer(const MG_State::GLState::ITextureObject* texture, Int glLayer) {
-    const Uint32 layer = static_cast<Uint32>(glLayer > 0 ? glLayer : 0);
-    return texture != nullptr ? layer + static_cast<Uint32>(texture->GetViewMinLayer()) : layer;
-}
-
 class VkTextureManager {
 public:
     // Monotonic epoch bumped whenever a texture VkImage is (re)created. The render-pass
@@ -218,35 +120,17 @@ public:
             }
         };
 
-        // Layer range and aspect join the key because a GL texture view (ARB_texture_view) can
-        // differ from its storage on either: the Better Clouds shape samples ONE D24S8 image
-        // through two GL names in one draw, the parent with the stencil aspect and the view with
-        // the depth aspect, and a layer-sliced view of an array texture names a sub-range of the
-        // same image. Without these two fields those views would alias each other in the cache.
         struct SampledImageViewKey {
             Uint32 baseMipLevel = 0;
             Uint32 levelCount = 1;
-            Uint32 baseArrayLayer = 0;
-            Uint32 layerCount = 1;
             VkImageViewType viewType = VK_IMAGE_VIEW_TYPE_2D;
             VkFormat format = VK_FORMAT_UNDEFINED;
-            VkImageAspectFlags aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-            // GL_TEXTURE_SWIZZLE_* is per-texture state, so two views over one storage with the
-            // same window but different swizzles are different views. Baked into the key because
-            // a GL texture view's ONLY sampled view lives in this cache: unlike the storage
-            // texture's own sampledView, which SyncTextureViews rebuilds whenever the params
-            // version moves, nothing else would ever notice a swizzle change on a view.
-            Uint32 componentSwizzle = 0;
 
             Bool operator==(const SampledImageViewKey& other) const {
                 return baseMipLevel == other.baseMipLevel &&
                        levelCount == other.levelCount &&
-                       baseArrayLayer == other.baseArrayLayer &&
-                       layerCount == other.layerCount &&
                        viewType == other.viewType &&
-                       format == other.format &&
-                       aspect == other.aspect &&
-                       componentSwizzle == other.componentSwizzle;
+                       format == other.format;
             }
         };
 
@@ -254,15 +138,10 @@ public:
             SizeT operator()(const SampledImageViewKey& key) const {
                 SizeT hash = std::hash<Uint32>{}(key.baseMipLevel);
                 hash ^= std::hash<Uint32>{}(key.levelCount) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(key.baseArrayLayer) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(key.layerCount) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
                 hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.viewType)) +
                         0x9e3779b9u + (hash << 6) + (hash >> 2);
                 hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.format)) +
                         0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.aspect)) +
-                        0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(key.componentSwizzle) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
                 return hash;
             }
         };
@@ -327,12 +206,6 @@ public:
         // as defense-in-depth: any path that grows the level set (which resizes the sampled view)
         // busts the skip even if it failed to bump the content version.
         Uint32 syncedMipLevelCount = 0;
-        // Snapshot of ITextureObject::GetShapeVersion() at the last successful sync. The content
-        // version alone does NOT cover a re-specification: glTexImage2D(..., nullptr) on an
-        // already-defined level changes its size or format and dirties no texel, so it moves the
-        // shape version and nothing else. Without this in the early-out key the image, its views
-        // and therefore imageSize() all keep answering with the texture's PREVIOUS shape.
-        Uint64 syncedShapeVersion = 0;
 
         TextureResource() = default;
         TextureResource(const TextureResource&) = delete;
@@ -364,7 +237,6 @@ public:
             std::swap(this->lastRecordingGeneration, that.lastRecordingGeneration);
             std::swap(this->syncedContentVersion, that.syncedContentVersion);
             std::swap(this->syncedMipLevelCount, that.syncedMipLevelCount);
-            std::swap(this->syncedShapeVersion, that.syncedShapeVersion);
         }
 
         void Reset() {
@@ -428,7 +300,6 @@ public:
             syncedTextureParamsVersion = 0;
             syncedContentVersion = 0;
             syncedMipLevelCount = 0;
-            syncedShapeVersion = 0;
         }
 
         ~TextureResource() {
@@ -439,11 +310,6 @@ public:
         static inline VmaAllocator s_allocator = VK_NULL_HANDLE;
     };
 
-    struct SampledTextureSnapshot {
-        VkImageView imageView = VK_NULL_HANDLE;
-        VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
-    };
-
     Bool Initialize(const InitInfo& initInfo);
     void Shutdown();
     void BeginFrame(Uint32 frameIndex);
@@ -460,58 +326,6 @@ public:
     // present-less frame-boundary drain.
     void CollectAllDeferredReleases();
 
-    // ---- GL texture views (ARB_texture_view / GL 4.6 core 8.18) ----
-    // The GL texture whose STORAGE backs the given one: itself, or - for a texture created by
-    // glTextureView - the texture it views. Every image-scoped question (which VkImage, its
-    // LAYOUT, its uploads, its extent, its usage) must be asked of this object, because a view
-    // has none of its own; only the VkImageViews differ per GL texture object. Sharing one
-    // TextureResource is not an optimisation, it is the only correct arrangement: layout is a
-    // property of the image, and VulkanRenderer caches raw pointers straight to the resource's
-    // layout field, so a second resource aliasing the same image would desynchronise the moment
-    // either of them transitioned it.
-    static MG_State::GLState::ITextureObject& StorageTextureOf(MG_State::GLState::ITextureObject& texture);
-
-    // The window a GL texture object opens onto its storage image. For a plain texture this is
-    // the resource's own full extent; for a view it is the sub-range, format and aspect
-    // glTextureView gave it. Views built from a non-default window must live in the KEYED caches
-    // (attachmentViews / alternateSampledViews), never in the per-mip vectors, which belong to
-    // the storage texture's own defaults.
-    struct TextureViewWindow {
-        Uint32 baseMipLevel = 0;
-        Uint32 levelCount = 1;
-        Uint32 baseArrayLayer = 0;
-        Uint32 layerCount = 1;
-        VkFormat format = VK_FORMAT_UNDEFINED;
-        VkImageViewType viewType = VK_IMAGE_VIEW_TYPE_2D;
-        VkImageAspectFlags sampledAspect = VK_IMAGE_ASPECT_COLOR_BIT;
-        VkComponentMapping components{VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B,
-                                      VK_COMPONENT_SWIZZLE_A};
-        Bool isTextureView = false;
-    };
-
-    // The four component swizzles packed into one value, for the sampled-view cache key.
-    static Uint32 PackComponentSwizzle(const VkComponentMapping& components) {
-        return (static_cast<Uint32>(components.r) & 0xFFu) | ((static_cast<Uint32>(components.g) & 0xFFu) << 8) |
-               ((static_cast<Uint32>(components.b) & 0xFFu) << 16) |
-               ((static_cast<Uint32>(components.a) & 0xFFu) << 24);
-    }
-    TextureViewWindow ResolveTextureViewWindow(MG_State::GLState::ITextureObject& texture,
-                                               const TextureResource& resource) const;
-    // Records what a GL texture view needs of the image it views, so the next sync of the
-    // STORAGE texture creates (or recreates and copies forward) an image the view can be built
-    // over. See m_viewRequestedImageFlags for why this is lazy rather than unconditional.
-    void NoteTextureViewImageRequirements(MG_State::GLState::ITextureObject& viewTexture,
-                                          MG_State::GLState::ITextureObject& storageTexture);
-    VkImageCreateFlags GetViewRequestedImageFlags(const MG_State::GLState::ITextureObject& storageTexture) const;
-    // Appends every format a GL texture view reinterprets this storage as, for the narrowed
-    // VkImageFormatListCreateInfo the image is created with.
-    void AppendViewRequestedFormats(const MG_State::GLState::ITextureObject& storageTexture,
-                                    Vector<VkFormat>& outFormats) const;
-    // Builds (and caches, keyed by the whole window) one sampled VkImageView over a storage
-    // image. Shared back end of every GL-texture-view sampled path.
-    VkImageView GetOrCreateWindowedSampledView(MG_State::GLState::ITextureObject& texture,
-                                               TextureResource& resource, const TextureViewWindow& window);
-
     TextureResource* SyncTextureAndGetDescriptor(
         MG_State::GLState::ITextureObject& texture);
     VkImageView GetOrCreateViewAtMipLevel(MG_State::GLState::ITextureObject& texture, Uint32 mipLevel);
@@ -529,13 +343,6 @@ public:
                                                       VkImageLayout newLayout);
     Bool TransitionTextureForSampling(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
     Bool TransitionTextureForStorageImage(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
-    // Copies the complete sampler-visible mip range into a transient sampled image. The source is
-    // restored to its prior layout, so image-store descriptors continue to name the original image.
-    // The transient ownership is tied to the current frame slot and is safe through its submission.
-    Bool SnapshotTextureForSampling(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture,
-                                    SamplerNumericDomain numericDomain,
-                                    VkPipelineStageFlags consumerShaderStageMask,
-                                    SampledTextureSnapshot& outSnapshot);
 
     // Recording-generation bookkeeping for the pre-pass command stream. The
     // generation advances every time the frame command buffer (re)begins
@@ -572,33 +379,17 @@ public:
     // true - a false positive merely ends the render pass, a false negative would skip a barrier.
     Bool NeedsStorageImagePreparation(MG_State::GLState::ITextureObject& texture) const;
 
-    // `depthStencilTextureMode` is the texture's GL_DEPTH_STENCIL_TEXTURE_MODE; it only decides
-    // anything for an image that carries both aspects. Defaulted so the call sites that have no
-    // texture in hand keep the depth-aspect answer they have always given.
-    static VkImageAspectFlags ResolveSampledImageViewAspectMask(VkImageAspectFlags imageAspect,
-                                                                GLenum depthStencilTextureMode = GL_DEPTH_COMPONENT);
+    static VkImageAspectFlags ResolveSampledImageViewAspectMask(VkImageAspectFlags imageAspect);
     static VkFormat ResolveSampledImageViewFormat(VkFormat imageFormat, SamplerNumericDomain numericDomain);
     static Bool AreSampledImageViewFormatsCompatible(VkFormat imageFormat, VkFormat viewFormat);
     static Bool AreStorageImageViewFormatsCompatible(VkFormat imageFormat, VkFormat viewFormat);
 
-    // Moves `image` to `newLayout` and writes the new layout back through `trackedLayout`.
-    //
-    // The barrier covers EVERY array layer of the image, and there is deliberately no layer
-    // parameter to say otherwise: layout here is tracked per IMAGE (one `TextureResource::layout`,
-    // or one caller-owned variable), so a barrier narrower than the image would leave the layers it
-    // skipped in the old layout while the tracker claims they moved. Every transfer against a
-    // framebuffer attachment above layer 0 - glReadPixels, glBlitFramebuffer, glCopyTexSubImage,
-    // glCopyImageSubData - then ran its copy on a layer no barrier had transitioned.
-    //
-    // The mip range IS a parameter, because mip levels really are transitioned piecewise (see
-    // UpdateTrackedImageLayoutAfterAttachmentWrite and the mipmap generation loops): those callers
-    // move the complement of the level they wrote so the whole image converges on one layout again.
-    // Nothing does, or can, do that per layer.
     static Bool TransitionImageLayout(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout& trackedLayout,
                                VkImageLayout newLayout, VkPipelineStageFlags srcStageMask,
                                VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask,
                                VkAccessFlags dstAccessMask, VkImageAspectFlags aspectMask,
-                               Uint32 baseMipLevel = 0, Uint32 levelCount = 1);
+                               Uint32 baseMipLevel = 0, Uint32 levelCount = 1,
+                               Uint32 layerCount = 1);
 
     SizeT CollectGarbage();
 
@@ -726,19 +517,6 @@ private:
     std::unordered_map<TextureIdentity, TextureResource, TextureIdentityHash> m_textureResources;
     // Textures that have been bound to a GL image unit (see MarkStorageImageTexture).
     std::unordered_set<TextureIdentity, TextureIdentityHash> m_storageImageTextures;
-    // Extra VkImageCreateFlags a GL texture view needs on the storage image it views, keyed by
-    // the STORAGE texture's identity. Requested lazily, exactly like STORAGE usage above and for
-    // the same reason: VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT costs bandwidth compression on tilers
-    // (it is what VK_KHR_image_format_list exists to claw back), so setting it on every
-    // immutable-storage texture would tax every glTexStorage2D render target in a game for a
-    // feature almost none of them use. A SAME-format view - which is the common case, and the
-    // Better Clouds case - needs no flag at all and therefore costs nothing.
-    std::unordered_map<TextureIdentity, VkImageCreateFlags, TextureIdentityHash> m_viewRequestedImageFlags;
-    // Every VkFormat a GL texture view has asked to reinterpret this storage as. The narrowed
-    // VkImageFormatListCreateInfo the image is created with must name them: the list is a promise
-    // that NO other format will ever be viewed, and building a view outside it is
-    // VUID-VkImageViewCreateInfo-pNext-01585. Keyed, like the flags above, by the STORAGE texture.
-    std::unordered_map<TextureIdentity, std::unordered_set<VkFormat>, TextureIdentityHash> m_viewRequestedFormats;
     // Supported multisample counts per format, so repeat texture syncs do not
     // re-query vkGetPhysicalDeviceImageFormatProperties.
     std::unordered_map<VkFormat, VkSampleCountFlags> m_multisampleCountsByFormat;

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTimerQueryManager.cpp

@@ -15,7 +15,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         MOBILEGL_ASSERT(initInfo.device != VK_NULL_HANDLE, "VkTimerQueryManager::Initialize requires valid VkDevice");
         MOBILEGL_ASSERT(initInfo.frameCount > 0, "VkTimerQueryManager::Initialize requires non-zero frame count");
         if (initInfo.timestampValidBits == 0 || initInfo.timestampPeriodNs <= 0.0f || initInfo.slotsPerPool == 0) {
-            MGLOG_W_ONCE("VkTimerQueryManager: timestamps unsupported (validBits=%u, period=%f, slots=%u)",
+            MGLOG_W("VkTimerQueryManager: timestamps unsupported (validBits=%u, period=%f, slots=%u)",
                     initInfo.timestampValidBits, initInfo.timestampPeriodNs, initInfo.slotsPerPool);
             return false;
         }
@@ -35,7 +35,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         for (auto& poolState : m_pools) {
             const VkResult result = vkCreateQueryPool(m_device, &poolInfo, nullptr, &poolState.pool);
             if (result != VK_SUCCESS) {
-                MGLOG_E_ONCE("VkTimerQueryManager: vkCreateQueryPool failed with %s", VkResultToString(result));
+                MGLOG_E("VkTimerQueryManager: vkCreateQueryPool failed with %s", VkResultToString(result));
                 Shutdown();
                 return false;
             }
@@ -90,7 +90,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         auto& poolState = m_pools[frameIndex];
         if (poolState.cursor >= m_slotsPerPool) {
             if (!poolState.exhaustionWarned) {
-                MGLOG_W_ONCE("VkTimerQueryManager: frame %u timestamp pool exhausted (%u slots); further timer queries "
+                MGLOG_W("VkTimerQueryManager: frame %u timestamp pool exhausted (%u slots); further timer queries "
                         "this frame fall back to the frontend path",
                         frameIndex, m_slotsPerPool);
                 poolState.exhaustionWarned = true;
@@ -120,7 +120,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_device, m_pools[record.poolIndex].pool, record.slot, 1, sizeof(resultWithAvailability),
             resultWithAvailability, sizeof(Uint64), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT);
         if (result != VK_SUCCESS && result != VK_NOT_READY) {
-            MGLOG_E_ONCE("VkTimerQueryManager: vkGetQueryPoolResults failed with %s", VkResultToString(result));
+            MGLOG_E("VkTimerQueryManager: vkGetQueryPoolResults failed with %s", VkResultToString(result));
             return false;
         }
         if (resultWithAvailability[1] == 0) {

MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.h

@@ -23,8 +23,6 @@
 #include "VkTimerQueryManager.h"
 #include "MG_Util/Math/VectorTypes.h"
 #include <Includes.h>
-#include <MG_Backend/BackendObject.h>
-#include <MG_Util/SelfTest/PrimitivesGeneratedNoXfbProbe.h>
 #include <vk_mem_alloc.h>
 
 #include "../VkIncludes.h"
@@ -199,9 +197,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                   GLbitfield mask, GLenum filter);
         void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
                        GLint x, GLint y, GLsizei width, GLsizei height);
-        void CopyImageSubData(const CopyImageEndpoint& srcEndpoint,
+        void CopyImageSubData(const SharedPtr<MG_State::GLState::ITextureObject>& srcTexture,
                               GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ,
-                              const CopyImageEndpoint& dstEndpoint,
+                              const SharedPtr<MG_State::GLState::ITextureObject>& dstTexture,
                               GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ,
                               GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
         void GenerateMipmap(GLenum target);
@@ -213,20 +211,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                     GLsizei height, GLenum format, GLenum type, void* pixels);
         // Copy-and-repack core shared by depth-stencil ReadPixels and GetTexImage;
         // expects command recording to be active and any render pass already ended.
-        //
-        // `defaultFramebufferOrientation` is set only when the source is the swapchain's
-        // depth/stencil image, which this renderer stores display-side-up: the copy rect then
-        // has to be mapped out of GL's bottom-origin space and the copied rows re-oriented on
-        // the way back, exactly as the colour ReadPixels path does.
-        // `sourceLayerCount` above 1 says the `height` rows the client is owed are stored as that
-        // many ARRAY LAYERS of a one-row image rather than as rows of one layer - the shape a GL
-        // 1D array has in Vulkan. The two produce byte-identical tightly-packed readbacks, so
-        // only the copy region differs; everything after it is written against `height`.
         void ReadDepthStencilImageToClient(VkImage image, VkFormat vkFormat, VkImageLayout* trackedLayout,
                                            VkImageAspectFlags imageAspect, Uint32 mipLevel, Uint32 baseArrayLayer,
                                            GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type,
-                                           void* pixels, Bool defaultFramebufferOrientation = false,
-                                           Uint32 sourceLayerCount = 1);
+                                           void* pixels);
         // Same-extent depth blit between images of different depth formats: host
         // round-trip with a per-texel re-encode (see BlitNamedFramebuffer).
         Bool BlitDepthAcrossFormats(FrameContext::FrameData& frame, VkImage srcImage, VkFormat srcFormat,
@@ -236,18 +224,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                     GLint dstY, GLint width, GLint height, VkImageLayout srcRestoreLayout,
                                     VkImageLayout dstRestoreLayout, Bool stencilAspect);
         static SizeT GetReadbackTexelSize(VkFormat sourceFormat);
-        // Map a GL bottom-left-origin rectangle into the display-oriented swapchain image.
-        // Quarter-turn surface transforms swap the copy extent's axes.
-        static Bool MapDefaultFramebufferReadbackRect(GLint x, GLint y, GLsizei width, GLsizei height,
-                                                      VkExtent2D imageExtent,
-                                                      VkSurfaceTransformFlagBitsKHR preTransform,
-                                                      VkOffset2D* imageOffset, VkExtent2D* imageCopyExtent);
-        // Reorder a tightly packed block copied with MapDefaultFramebufferReadbackRect back into
-        // GL row order. The input block has swapped dimensions for 90/270 degree transforms.
-        static Bool RemapDefaultFramebufferReadback(const Uint8* rawPixels, Uint32 logicalWidth,
-                                                    Uint32 logicalHeight,
-                                                    VkSurfaceTransformFlagBitsKHR preTransform,
-                                                    SizeT texelSize, Uint8* outPixels);
         static Bool ConvertReadbackPixels(const Uint8* sourcePixels, VkFormat sourceFormat,
                                           GLsizei width, GLsizei height, GLenum destinationFormat,
                                           GLenum destinationType, SizeT destinationRowStride,
@@ -317,12 +293,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // The samplerAnisotropy device feature was granted, so GL_TEXTURE_MAX_ANISOTROPY_EXT is
         // honored rather than accepted-and-ignored.
         Bool IsSamplerAnisotropySupported() const { return m_samplerAnisotropyFeatureEnabled; }
-        // ARB_base_instance extends indirect command records with a non-zero firstInstance and
-        // requires gl_InstanceID to remain zero-based. Vulkan needs both features to honor that
-        // complete contract: one legalizes the command word, the other enables the shader rebase.
-        Bool IsNonZeroIndirectBaseInstanceSupported() const {
-            return m_drawIndirectFirstInstanceFeatureEnabled && m_shaderDrawParametersFeatureEnabled;
-        }
         // Ensures the frame command buffer is recording (same lazy pattern as
         // SetupDraw) and writes a bottom-of-pipe timestamp into the current
         // frame's pool. Null when unsupported or the pool is exhausted.
@@ -393,31 +363,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint32 samplerBinding = 0;
         };
 
-        // A single-sample staging image for multisample-resolve blits that also have to change
-        // orientation. vkCmdResolveImage cannot flip (it takes one offset per side, not the
-        // invertible pair vkCmdBlitImage takes), so a resolve into or out of the default
-        // framebuffer used to land the mirrored band. Resolving here first and then blitting from
-        // here separates the two operations, and each one then does only what it can express.
-        //
-        // Pooled rather than created per blit: the CTS runs hundreds of these back to back, and
-        // create-destroy per call would both cost allocations and, worse, need per-call deferred
-        // destruction to outlive the recording. It grows to the largest extent asked for and is
-        // reused; format changes recreate it.
-        struct MultisampleResolveScratchImage {
-            VkImage image = VK_NULL_HANDLE;
-            VmaAllocation allocation = VK_NULL_HANDLE;
-            VkFormat format = VK_FORMAT_UNDEFINED;
-            VkExtent2D extent = {0, 0};
-            VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
-        };
-        MultisampleResolveScratchImage m_msResolveScratch;
-        // Returns a scratch image at least `extent` in size with exactly `format`, transitioned to
-        // TRANSFER_DST and ready to be resolved into. Null image on failure (the caller then falls
-        // back to the direct resolve).
-        Bool AcquireMultisampleResolveScratchImage(VkCommandBuffer commandBuffer, VkFormat format,
-                                                   VkExtent2D extent);
-        void DestroyMultisampleResolveScratchImage();
-
         struct DeferredDepthMipmapCleanup {
             Vector<VkImageView> imageViews;
             Vector<VkFramebuffer> framebuffers;
@@ -500,13 +445,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void* m_platformDisplay = nullptr;
         void* m_platformLibrary = nullptr;
         void* m_platformCloseDisplay = nullptr;
-        // Whether the loader exposes VK_EXT_headless_surface, detected once in
-        // CreateInstance() from the enumerated instance extensions. On desktop an
-        // offscreen surface REQUIRES it: false is a clean, loud bring-up failure, never
-        // a substituted window. (Android is the one exception and has its own path -
-        // no Mali/Adreno driver seen so far exposes the extension, so a windowless
-        // context is given an AImageReader ANativeWindow that is never displayed.)
+        // Some real ICDs (e.g. NVIDIA's proprietary Linux driver) don't implement
+        // VK_EXT_headless_surface at all. Detected once in CreateInstance() from the
+        // enumerated instance extensions; when false, CreateSurface() falls back to a
+        // hidden Xlib window instead of vkCreateHeadlessSurfaceEXT.
         Bool m_headlessSurfaceSupported = true;
+        // Set when CreateSurface() had to create its own Xlib window for the fallback
+        // above (rather than being handed one by the caller), so Shutdown() knows it
+        // owns that window and must destroy it.
+        Bool m_ownsFallbackXlibWindow = false;
         // 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
@@ -561,20 +508,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Bool m_samplerAnisotropyFeatureEnabled = false;
         Bool m_shaderDrawParametersExtensionEnabled = false;
         Bool m_shaderDrawParametersFeatureEnabled = false;
-        // Native subgroup topology, queried at device creation for the compute-module
-        // subgroup repairs (SubgroupSupportPolicy.h) and the REQUIRE_FULL_SUBGROUPS
-        // stage flag; 0 / false when the device has no usable compute subgroups or
-        // MOBILEGL_MAGMA_DISABLE_SUBGROUP forced them off.
-        Uint32 m_nativeSubgroupSize = 0;
-        Bool m_nativeSubgroupSupported = false;
-        Bool m_computeFullSubgroupsFeatureEnabled = false;
-        // VkPhysicalDeviceSubgroupSizeControlProperties::maxComputeWorkgroupSubgroups;
-        // 0 when the extension (and therefore the full-subgroups flag) is unavailable.
-        Uint32 m_maxComputeWorkgroupSubgroups = 0;
         Bool m_unformattedFloatStorageImagesEnabled = false;
-        // Set only after descriptor-indexing feature AND property queries prove that
-        // update-after-bind is legal for every descriptor category this renderer emits.
-        ProgramFactory::UpdateAfterBindLimits m_updateAfterBindLimits{};
         // fillModeNonSolid gates VK_POLYGON_MODE_LINE/_POINT (glPolygonMode); independentBlend gates
         // per-draw-buffer color write masks (glColorMaski). Both are cached at device creation and
         // drive a runtime fallback when the device lacks them.
@@ -585,36 +519,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;
-        // shaderTessellationAndGeometryPointSize gates the PointSize built-in in a tessellation
-        // or geometry stage, which desktop GL treats as an ordinary per-vertex output (writable,
-        // and capturable by name through transform feedback). Cached at device creation and
-        // handed to ProgramFactory, which refuses a program whose tessellation or geometry module
-        // declares the matching SPIR-V capability while this is false - SetupDraw then skips its
-        // draws (VkProgramObject::pointSizeCapabilityUnsupported) rather than building a pipeline
-        // that is invalid usage.
-        Bool m_tessellationAndGeometryPointSizeFeatureEnabled = false;
-        // VK_EXT_custom_border_color. Vulkan's four predefined VkBorderColor values cover only
-        // transparent/opaque black and opaque white; GL_TEXTURE_BORDER_COLOR is an arbitrary vec4 (or
-        // an arbitrary ivec4/uvec4 through the "I" entry points). Without this extension a border
-        // colour outside the palette has to be snapped to the nearest predefined one. Both features
-        // are required together: customBorderColorWithoutFormat is what lets a sampler carry a custom
-        // colour without naming the image format it will be paired with, which GL's sampler objects
-        // cannot know. maxCustomBorderColorSamplers is a real device limit, so the sampler cache has
-        // to be able to fall back to the snapped value once it is reached.
-        Bool m_customBorderColorFeatureEnabled = false;
-        Uint32 m_maxCustomBorderColorSamplers = 0;
-        // sampleRateShading gates VkPipelineMultisampleStateCreateInfo::sampleShadingEnable, i.e.
-        // glEnable(GL_SAMPLE_SHADING) + glMinSampleShading. Unlike dualSrcBlend this does NOT
-        // hard-fail the draw when absent: sample shading is a rate hint, and every sample-rate
-        // pipeline is still correct (just not per-sample) at the default rate - so the enable is
-        // dropped and the draw proceeds, which is what a GL implementation with SAMPLES=1 does too.
-        Bool m_sampleRateShadingFeatureEnabled = false;
-        // multiViewport gates rasterizing into more than one of ARB_viewport_array's 16 viewports
-        // (gl_ViewportIndex). m_maxRasterizableViewports is min(MAX_VIEWPORTS, device limit), or 1
-        // when the feature is off, and is the viewportCount a gl_ViewportIndex-writing pipeline
-        // declares - it is NOT what GL_MAX_VIEWPORTS reports, which is the frontend state width.
-        Bool m_multiViewportFeatureEnabled = false;
-        Uint32 m_maxRasterizableViewports = 1;
         // 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
@@ -675,18 +579,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // per object: one group of four slots each, handed out on first use.
         static constexpr SizeT kXfbCounterObjectSlots = 16;
         VkBufferObject m_xfbCounterBuffer;
-        // Which transform feedback object owns each slot group, by the frontend's never-reused
-        // lifetime id (0 = the slot is free). This used to be an UnorderedMap keyed on the GL
-        // NAME, which is recycled by glGenTransformFeedbacks: a deleted-and-recreated object
-        // inherited the dead one's slot, and since nothing ever removed an entry the map also
-        // grew for the life of the context. A fixed table cannot do either: a group is taken over
-        // only from an owner with no OPEN span (see CurrentXfbCounterSlot), so an object whose
-        // counters can still be resumed never loses them, and a dead object's group comes back.
-        Array<Uint64, kXfbCounterObjectSlots> m_xfbCounterSlotOwner{};
-        // Tie-break among reclaimable groups only; never on its own, because the paused span the
-        // groups exist for is by construction the least recently used one.
-        Array<Uint64, kXfbCounterObjectSlots> m_xfbCounterSlotLastUse{};
-        Uint64 m_xfbCounterSlotUseSerial = 0;
+        UnorderedMap<Uint, Uint32> m_xfbCounterSlotByObject;
+        Uint32 m_xfbNextCounterSlot = 0;
         // Set for a slot once a captured draw has been recorded into its span; selects
         // counter-buffer resume on the next captured draw of the same span.
         Array<Bool, kXfbCounterObjectSlots> m_xfbCountersValid{};
@@ -728,74 +622,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Vector<Uint32> m_xfbQueryActiveSlots[2];
         Bool m_xfbQuerySlotOpen = false;
         Uint32 m_xfbQueryOpenSlot = 0;
-        // GL_PRIMITIVES_GENERATED reroute for draws made while transform feedback is
-        // INACTIVE. The stream pool's primitivesNeeded is defined to count those draws
-        // too, but a Mali driver (and Mesa lavapipe) answers 0 unless a capture span
-        // is open (the CTS's tessellator-measuring shape). Where the bring-up probe
-        // finds that defect with a working control - or
-        // MOBILEGL_MAGMA_PRIMGEN_QUERY_REROUTE forces it - such draws accumulate the
-        // GENERATED count through this pool instead, whose type the arming picks:
-        // VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT where the device hosts the dedicated
-        // query with its rasterizer-discard feature (exact semantics by definition -
-        // the extension exists because GL needs this count without a capture), else a
-        // VK_QUERY_TYPE_PIPELINE_STATISTICS pool over clipping-stage invocations (one
-        // per primitive reaching primitive clipping - after every vertex processing
-        // stage, before rasterizer discard - which is the same set).
-        // XFB-ACTIVE draws keep the stream slot (exact today, and WRITTEN needs it);
-        // every draw with no open capture - a PAUSED span's draws included - takes a
-        // reroute slot, and the span then ignores the frontend's CPU paused-primitive
-        // counter rather than adding it on top (see IsPrimGenRerouteArmed): that
-        // counter is written by only 3 of the ~15 draw entry points and answers 0 for
-        // GL_PATCHES, so it cannot price the draws this reroute exists to repair. One
-        // GL query span may therefore hold slots of both pools.
-        Bool m_pipelineStatisticsQueryFeatureEnabled = false;
-        // VK_EXT_primitives_generated_query: base feature, and the
-        // ...WithRasterizerDiscard feature without which a discarding draw inside the
-        // query is invalid usage (so the reroute never picks the dedicated pool on a
-        // base-only device - GL applications toggle discard freely).
-        Bool m_primitivesGeneratedQueryFeatureEnabled = false;
-        Bool m_primitivesGeneratedQueryDiscardFeatureEnabled = false;
-        // tessellationShader was enabled at device creation (it is taken whenever the
-        // device advertises it); gates the probe's PATCHES shape.
-        Bool m_tessellationShaderFeatureEnabled = false;
-        MG_Util::SelfTest::PrimGenRerouteKind m_primGenRerouteKind =
-            MG_Util::SelfTest::PrimGenRerouteKind::None;
-        // The bring-up probe measured this device's stream query as counting draws made
-        // with no capture span open (the StreamCounts verdict) - so it counts the
-        // PAUSED-span ones too, through the stream slot they take when nothing is
-        // rerouted. Only the probe can know this, so it stays false wherever the probe
-        // is not consulted (the forced arms), which keeps those lanes' accounting as it
-        // was.
-        Bool m_primGenStreamCountsXfbInactiveDraws = false;
-        VkQueryPool m_primGenReroutePool = VK_NULL_HANDLE;
-        Uint32 m_primGenRerouteSlotCursor = 0;
-        Vector<Uint32> m_primGenRerouteActiveSlots;
-        Bool m_primGenRerouteSlotOpen = false;
-        Uint32 m_primGenRerouteOpenSlot = 0;
-        // Runs the bring-up probe (memoized per process) and decides
-        // m_primGenRerouteKind. Called at the end of device creation: it records on
-        // m_graphicsQueue, which nothing else is using yet.
-        void ArmPrimGenReroute();
 
     public:
-        // Whether a GENERATED span opened now will have the draws made while the GL
-        // span is PAUSED counted on the GPU - through the reroute pool, which takes
-        // every draw with no open capture, or (where the reroute is not armed because
-        // the stream query was measured to count capture-less draws) through the stream
-        // slot such a draw still takes. The frontend's CPU paused-primitive counter
-        // must not be added on top of either: it would double count, and it cannot
-        // price the draws that matter anyway - only 3 of the ~15 draw entry points
-        // write it and it answers 0 for GL_PATCHES. Read once per span, after
-        // StartXfbQueryCapture (whose pool creation may disarm the reroute).
-        Bool ArePausedDrawsGpuCounted() const;
         // kind: 0 = PRIMITIVES_WRITTEN, 1 = PRIMITIVES_GENERATED.
         Bool StartXfbQueryCapture(Uint32 kind);
-        void StopXfbQueryCapture(Uint32 kind, Vector<Uint32>& outSlots, Vector<Uint32>& outRerouteSlots);
-        Bool ResolveXfbQueryResult(const Vector<Uint32>& slots, const Vector<Uint32>& rerouteSlots,
-                                   Bool wantGenerated, Uint64& outPrimitives);
+        void StopXfbQueryCapture(Uint32 kind, Vector<Uint32>& outSlots);
+        Bool ResolveXfbQueryResult(const Vector<Uint32>& slots, Bool wantGenerated, Uint64& outPrimitives);
 
     private:
-        void BeginXfbQueryForDraw(VkCommandBuffer commandBuffer, Bool xfbActive);
+        void BeginXfbQueryForDraw(VkCommandBuffer commandBuffer);
         void EndXfbQueryForDraw(VkCommandBuffer commandBuffer);
 
         VkCommandPool m_commandPool = VK_NULL_HANDLE;
@@ -827,12 +662,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // values the memo already holds.
             Uint64 pipelineStateHash = 0;
             ProgramFactory::CompileOptionFlags transformFlags = {};
-            // Baked into the pipeline (PipelineFactory::ComputeHash mixes it), and NOT derivable
-            // from anything else in this key: it depends on whether the draw is indexed and on the
-            // index type, neither of which the mode/program/state hashes carry. Without it an
-            // indexed and a non-indexed draw over the same program and state collide on one entry
-            // and the second one gets the first one's restart setting.
-            Bool primitiveRestartEnable = false;
             VkPipeline pipeline = VK_NULL_HANDLE;
         };
         static constexpr Uint32 kPipelineMemoSize = 8;
@@ -846,18 +675,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // 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,
-                                        VkSampleCountFlagBits rasterizationSamples) const;
-        // The effective GL_SAMPLE_MASK word for a draw at this rasterization sample count; see
-        // the definition for the GL-vs-Vulkan rule it reconciles. Shared by the pipeline payload
-        // and the pipeline-state memo word so the two cannot disagree.
-        Uint32 ResolveEffectiveSampleMask(VkSampleCountFlagBits rasterizationSamples) const;
+        Uint64 ComputePipelineStateHash(Uint32 colorAttachmentCount) const;
         Uint m_pipelineStateHashVersion = 0;
         Uint32 m_pipelineStateHashColorCount = 0;
-        // The sample count the cached hash was computed at. A pipeline-state input now depends on
-        // it (the effective sample mask), so a draw that changes only the target's sample count
-        // has to recompute rather than reuse.
-        VkSampleCountFlagBits m_pipelineStateHashSampleCount = VK_SAMPLE_COUNT_1_BIT;
         Uint64 m_pipelineStateHash = 0;
         Bool m_pipelineStateHashValid = false;
         // GetShaderTransformFlags memo. NOT pure in the pre-transform alone: the
@@ -899,9 +719,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // Skip the per-draw CollectSampledTextures walk (~5% of the render thread) when the sampled
         // texture SET is provably unchanged from the previous draw: same program (lifetime id +
         // backend-state version, which covers sampler-uniform reassignment / relink) and transform
-        // flags, no texture bind/unbind/delete since (GetTextureBindGeneration), and nothing that
-        // moves a texture's shape or a sampler's parameters since (GetSamplingResolutionGeneration
-        // - membership depends on mipmap-completeness, which both of those decide). On a hit,
+        // flags, and no texture bind/unbind/delete since (GetTextureBindGeneration). On a hit,
         // m_sampledTexturesScratch still holds the previous draw's list and steps 2-4 (feedback /
         // layout probe / transition) re-run on it, so layout correctness is unaffected - only the GL
         // walk is skipped. The program lifetime id (never reused, unlike the GL name) and the
@@ -912,11 +730,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint32 m_lastSampledSetProgramVersion = 0;
         ProgramFactory::CompileOptionFlags m_lastSampledSetTransformFlags = {};
         Uint64 m_lastSampledSetBindGeneration = 0;
-        Uint64 m_lastSampledSetSamplingGeneration = 0;
-        // Set from the draw's resolved VkProgramObject on both the full and the fast setup paths;
-        // read by BeginXfbCaptureForDraw, which has only GL state otherwise. See
-        // VkProgramObject::xfbCaptureDeclined.
-        Bool m_currentDrawXfbCaptureDeclined = false;
 
         // Memo for the per-draw explicit-LOD-0 eligibility probe
         // (ProgramSamplesOnlySingleLevelTextures): same key family as the
@@ -929,26 +742,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint32 m_lastLodProgramVersion = 0;
         Uint64 m_lastLodBindGeneration = 0;
         Uint64 m_lastLodParamsSum = 0;
-        // Sampling-resolution generation at probe time. The probe reads the effective
-        // sampler's filters/aniso/LOD range, whose setters bump only this counter -
-        // the params-version sum above never moves for them.
-        Uint64 m_lastLodSamplingGeneration = 0;
         ProgramFactory::CompileOptionFlags m_lastLodBaseFlags = {};
         ProgramFactory::CompileOptionFlags m_lastLodResultFlags = {};
 
-        // Does the current program's vertex stage declare the BaseVertex builtin? A property
-        // of the program's SPIR-V, so (lifetime id, backend-state version) is the whole key.
-        //
-        // Memoized rather than re-asked because asking means resolving the UN-zeroed program
-        // variant, and a program that only ever draws non-indexed would then compile a variant
-        // no draw uses AND re-stamp its use every draw, so the idle sweep could never retire
-        // it. With the memo the answer is known before the first lookup and only the variant
-        // the draw actually needs is resolved.
-        Bool m_lastBaseVertexQueryValid = false;
-        Uint64 m_lastBaseVertexProgramLifetimeId = 0;
-        Uint32 m_lastBaseVertexProgramVersion = 0;
-        Bool m_lastBaseVertexReads = false;
-
         // Snapshot behind TrySetupDrawFastPath. Values only: the program and
         // render-pass caches are open-addressing maps whose entries move on
         // insert, so no pointers into them are cached; the pipeline handle is
@@ -970,23 +766,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint64 vaoLifetimeId = 0;
             Uint32 vaoConfigVersion = 0;
             const void* drawFbo = nullptr;
-            // Never-reused lifetime id beside the raw pointer + Uint16 version: a
-            // deleted FBO recycled at the same address with the same fresh version
-            // count would otherwise compare equal (same ABA as the render-pass
-            // manager's fast-path memo).
-            Uint64 drawFboLifetimeId = 0;
             Uint16 fboVersion = 0;
             Bool drawFboIsDefault = false;
             Uint renderStateVersion = 0;
             Uint64 bindGeneration = 0;
             Uint32 baseTransformFlags = 0;
             Uint32 resolvedTransformFlags = 0;
-            // What ResolvePrimitiveRestartEnable answered for the draw this snapshot was taken
-            // from, i.e. what its pipeline's primitiveRestartEnable was built with. `aspects`
-            // already separates indexed from non-indexed draws, but not one index TYPE from
-            // another, and a restart index that fits GL_UNSIGNED_INT but not GL_UNSIGNED_SHORT
-            // makes those two draws want different pipelines.
-            Bool primitiveRestartEnable = false;
             Uint64 renderPassHash = 0;
             Uint32 imageIndex = 0;
             Uint64 textureEraseEpoch = 0;
@@ -1004,20 +789,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // 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;
-            // The snapshotting draw's pipeline viewportCount. A pure function of the PROGRAM
-            // (writesViewportIndexBuiltin) and of a device feature fixed at renderer init, both
-            // of which the programLifetimeId/programVersion guards above already pin - carried
-            // here so the fast path does not re-fetch the program object to re-derive it.
-            Uint32 viewportCount = 1;
             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;
-            // Pinned with the colour count and for the same reason: the fast path recomputes the
-            // pipeline-state value hash from the snapshot, and that hash reads the sample count.
-            VkSampleCountFlagBits renderPassSampleCount = VK_SAMPLE_COUNT_1_BIT;
             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
@@ -1079,8 +856,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // already sampleable.
         Vector<VkTextureManager::TextureResource*> m_sampledResourcesScratch;
         Vector<MG_State::GLState::ITextureObject*> m_storageImageTexturesScratch;
-        Vector<UniformManager::SamplerImageFeedbackBinding> m_samplerImageFeedbackScratch;
-        Vector<UniformManager::SamplerBindingOverride> m_samplerImageBindingOverridesScratch;
         Vector<VkBuffer> m_vertexBuffersScratch;
         Vector<VkDeviceSize> m_vertexOffsetsScratch;
         Vector<VkVertexInputAttributeDescription> m_patchedAttributesScratch;
@@ -1207,14 +982,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkBuffer indexVkBuffer = VK_NULL_HANDLE;
             VkDeviceSize indexSliceOffset = 0;
             Uint64 indexFrameSerial = 0;
-            // The EBO carried a host map when the slice was recorded - the mirror of
-            // anyBufferMapped on the vertex half. A shadow-backed (non-adopted)
-            // persistent map mutates its shadow with no API call and no epoch bump, so
-            // the one-compare rescue must decline and re-run the acquire, whose
-            // SyncPersistentMappedRange is the push-down. A map taken AFTER the record
-            // is already covered: AcquirePersistentMap bumps the slice epoch for the
-            // request itself, adopted or declined.
-            Bool indexBufferMapped = false;
 
             // Bound per draw (first bindingCount elements).
             VkBuffer vkBuffers[kMaxBindings] = {};
@@ -1293,23 +1060,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void CreateSwapchain();
         void CreateCommandPool();
 
-        // Whether THIS draw's primitive stream restarts, and therefore what
-        // VkPipelineInputAssemblyStateCreateInfo::primitiveRestartEnable must be. Resolved by the
-        // caller because it needs two facts a pipeline cannot see: whether the draw is indexed at
-        // all (GL primitive restart acts on the index stream, so it is a no-op for glDrawArrays),
-        // and the index TYPE (an application restart index that does not fit the type matches no
-        // index, so that draw restarts nowhere - see UploadAndBindIndexBuffer).
-        Bool ResolvePrimitiveRestartEnable(Flags<DrawSetupAspect> aspects,
-                                           const IndexBufferView* pIndexBufferView) const;
-
         VkPipeline GetOrCreatePipeline(
             GLenum mode,
             const MG_State::GLState::ProgramObject& program,
             const ProgramFactory::VkProgramObject& programObj,
             ProgramFactory::CompileOptionFlags transformFlags,
             const MG_State::GLState::VertexArrayObject& vao,
-            const RenderPassEntry& renderPassEntry,
-            Bool primitiveRestartEnable);
+            const RenderPassEntry& renderPassEntry);
         VkPipeline GetOrCreateComputePipeline(const ProgramFactory::VkProgramObject& programObj);
         void DestroyComputePipelines();
         // Takes the frame rather than a command buffer: a first-time storage-usage upgrade has to
@@ -1318,34 +1075,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             FrameContext::FrameData& frame,
             const MG_State::GLState::ProgramObject& program,
             const ProgramFactory::VkProgramObject& programObj);
-        // Vulkan forbids a sampled descriptor and writable storage descriptor from naming the
-        // same image subresource in one shader operation. Snapshot only the sampler side; the
-        // storage descriptor continues to name the application texture.
-        Bool PrepareSamplerImageFeedbackSnapshots(
-            FrameContext::FrameData& frame,
-            const MG_State::GLState::ProgramObject& program,
-            const ProgramFactory::VkProgramObject& programObj,
-            VkPipelineStageFlags consumerShaderStageMask);
 
         // 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.
-        // viewportCount is the bound pipeline's declared viewport count: 1 for every program that
-        // does not write gl_ViewportIndex (the memoized fast path), otherwise the renderer's
-        // rasterizable viewport count, which takes the unmemoized array path.
-        void ApplyDynamicDrawStateTail(FrameContext::FrameData& frame, const IntVec2& extent, Bool isDefaultFbo,
-                                       Uint32 viewportCount = 1);
-        void ApplyMultiViewportDynamicState(VkCommandBuffer commandBuffer, Uint32 viewportCount, const IntVec2& extent,
-                                            VkSurfaceTransformFlagBitsKHR preTransform, Bool isDefaultFbo);
-        VkRect2D ComputeGLScissorRect(Uint32 index, const IntVec2& extent,
-                                      VkSurfaceTransformFlagBitsKHR preTransform, Bool isDefaultFbo) const;
-        // How many viewports a draw with this program rasterizes into: 1 unless the program
-        // assigns gl_ViewportIndex AND the device enabled multiViewport. Both the pipeline's
-        // baked viewportCount and the dynamic arrays come from this one answer, so they cannot
-        // disagree.
-        Uint32 ResolveDrawViewportCount(Bool programWritesViewportIndex) const {
-            return programWritesViewportIndex && m_multiViewportFeatureEnabled ? m_maxRasterizableViewports : 1u;
-        }
+        void ApplyDynamicDrawStateTail(FrameContext::FrameData& frame, const IntVec2& extent, Bool isDefaultFbo);
 
         Bool UploadAndBindVertexBuffers(VkCommandBuffer commandBuffer, const MG_State::GLState::VertexArrayObject& vao,
                                         const ProgramFactory::VkProgramObject& programObj,
@@ -1376,40 +1110,16 @@ 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 layer of a colour image through a throwaway render pass whose entire content
-        // is its LOAD_OP_CLEAR. Two callers, both of which a transfer clear cannot serve: a z
-        // slice of a VK_IMAGE_TYPE_3D image (vkCmdClearColorImage cannot name one), and a
-        // MULTISAMPLE image (which carries no TRANSFER_DST usage at all). `finalLayout` is the
-        // layout the caller already tracks for the whole image, so this never has to touch
-        // resource->layout.
+        // 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,
-                                           VkImageLayout finalLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+                                           Uint32 depthSlice, const VkClearValue& clearValue);
         Bool MaterializePendingClearForTexture(VkCommandBuffer commandBuffer,
                                                MG_State::GLState::ITextureObject& texture);
-        // The multisample arm of the above. Split out rather than branched inline because it
-        // shares none of the transfer path: a multisample image carries no TRANSFER_DST usage, so
-        // neither the TRANSFER_DST transition nor vkCmdClearColorImage is legal on one.
-        Bool MaterializeMultisamplePendingClear(VkCommandBuffer commandBuffer,
-                                                MG_State::GLState::ITextureObject& texture,
-                                                VkTextureManager::TextureResource& resource,
-                                                const Vector<PendingClearEntry>& pendingClears);
         Bool MaterializePendingClearForRenderbuffer(
             VkCommandBuffer commandBuffer,
             const SharedPtr<MG_State::GLState::RenderbufferObject>& renderbuffer);
-        // The default framebuffer's twin of the two above. It cannot go through
-        // MaterializePendingClearForTexture: the default FBO's colour attachment is a
-        // placeholder texture object, and syncing THAT would clear a texture image nobody
-        // presents instead of the acquired swapchain image.
-        Bool MaterializePendingClearForDefaultFramebuffer(VkCommandBuffer commandBuffer,
-                                                          MG_State::GLState::FramebufferObject& fbo,
-                                                          FramebufferAttachmentType attachmentType);
-        // Its depth/stencil half: a different image (the swapchain's depth/stencil twin), a
-        // different clear command and per-aspect masking.
-        Bool MaterializePendingDepthStencilClearForDefaultFramebuffer(
-            VkCommandBuffer commandBuffer, const MG_State::GLState::FramebufferAttachmentObject& attachment,
-            const ClearAttachmentPayload& payload);
         VkPipeline GetOrCreateBlitPipeline(const RenderPassEntry& renderPassEntry);
         Bool GenerateDepthMipmapWithShader(FrameContext::FrameData& frame,
                                            MG_State::GLState::ITextureObject& texture,

MobileGL/MG_Backend/DirectVulkan/SubgroupSupportPolicy.h

@@ -1,63 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/SubgroupSupportPolicy.h
-// Copyright (c) 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 <Config.h>
-#include <Includes.h>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    // The single decision point for how DirectVulkan implements GL_KHR_shader_subgroup,
-    // shared by capability advertisement (BackendObject) and module lowering
-    // (VulkanRenderer / ProgramFactory) so the two can never disagree.
-    //
-    // Native subgroups are the implementation whenever the device has them, whatever
-    // their width - subgroup operations execute on the hardware paths they were made
-    // for. Module-level repairs keep the GL contract intact around them:
-    //   - FixIterationRPSubgroupScratchPass patches the one known pack bug: iterationRP's
-    //     prefixSumCache[32], under-declared for sub-16-lane devices (8-lane lavapipe);
-    //   - FixIterationRPBarrierPass repairs Program 203's race between two reductions
-    //     reusing that scratch, when explicitly enabled;
-    //   - DeriveNumSubgroupsPass replaces the one builtin drivers get wrong
-    //     (gl_NumSubgroups) with the value the rest of the topology implies.
-    // The 32-lane shared-memory emulation (EmulateSubgroupsPass) is a LAST RESORT for
-    // devices with no subgroup support at all, and only when the user opts in with
-    // MOBILEGL_MAGMA_EMULATE_SUBGROUP=1; it never replaces available native operations.
-
-    inline constexpr Uint32 kEmulatedSubgroupSize = 32u;
-    inline constexpr Uint32 kEmulatedSubgroupStages = GL_COMPUTE_SHADER_BIT;
-    inline constexpr Uint32 kEmulatedSubgroupFeatures =
-        GL_SUBGROUP_FEATURE_BASIC_BIT_KHR | GL_SUBGROUP_FEATURE_VOTE_BIT_KHR |
-        GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR | GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR |
-        GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR | GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR |
-        GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR | GL_SUBGROUP_FEATURE_QUAD_BIT_KHR;
-
-    inline Bool ShouldEmulateSubgroups(const Bool nativeSubgroupSupported) {
-        return MG_Config::Features.MagmaEmulateSubgroup && !nativeSubgroupSupported &&
-               !MG_Config::Features.MagmaDisableSubgroup;
-    }
-
-    inline Bool ShouldFixIterationRPSubgroupScratch() {
-        // Auto is ON: the patch is fingerprint-gated to iterationRP's reduction and
-        // grows one under-declared array; every other module passes through untouched.
-        return MG_Config::Features.MagmaFixIterationRPSubgroupScratch !=
-               MG_Config::QuirkOverride::ForceOff;
-    }
-
-    inline Bool ShouldFixIterationRPBarrier() {
-        return MG_Config::Features.MagmaIterationRPFixBarrier;
-    }
-
-    inline Bool ShouldDeriveNumSubgroups() {
-        // Auto is ON: gl_NumSubgroups must agree with the gl_SubgroupID range for the GL
-        // contract to hold, and the derived ceil() value is the one the renderer can pin
-        // with REQUIRE_FULL_SUBGROUPS - the driver builtin is the value with no
-        // cross-driver guarantee (Adreno returns 1 for an 8-subgroup dispatch).
-        return MG_Config::Features.MagmaDeriveNumSubgroups != MG_Config::QuirkOverride::ForceOff;
-    }
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/VkIncludes.h

@@ -74,18 +74,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 // The context line (__VA_ARGS__ = its own format string + args) must be a SEPARATE log
 // call: appending its format to the base format while its arguments precede the base
 // arguments makes every conversion read the wrong slot (a %s pulling an int crashes).
-//
-// MGLOG_F and deliberately NOT latched. VK_VERIFY is the invariant-check macro: a Vulkan call
-// MobileGL believes it has already made legal came back non-success, which is a
-// should-never-happen state, not an expected failure mode a user hits. Those fast-fail loudly
-// and keep saying so - the log-quietness rules that latch W/E cover expected failures (driver
-// capability gaps, app misuse), not broken internal invariants. MOBILEGL_ASSERT below traps in
-// a DEBUG build; MGLOG_F is what makes the same condition visible in an INFO test run, where
-// the assert is compiled out by contract.
-//
-// A soft, recoverable failure must therefore NOT be routed through VK_VERIFY. Check the
-// VkResult directly and report it with MGLOG_E_ONCE - see VkTextureManager::SyncTextureResource,
-// where a driver legitimately refuses an image the format pre-check accepted.
 #define VK_VERIFY(expr, ...)                                                                                           \
     do {                                                                                                               \
         VkResult _vk_verify_result = (expr);                                                                           \

MobileGL/MG_Backend/MGPipe/PipeInputs.cpp

@@ -1,179 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/MGPipe/PipeInputs.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
-
-// The backend-side half of the PipeInputs block: the poison Fatal with its verb name, the
-// name lookups the runtime knobs need, and - in a verify build - the per-field equality,
-// the entry comparator and the corruption injector. Compiled only under MOBILEGL_PIPE_PUSH
-// (CMakeLists.txt appends it to SOURCE_FILES there), so the pull build never sees it. Spells
-// no MG_State global: everything that reads the live context lives in MG_Impl/Pipe/PipeFill.cpp.
-#include <MG_Backend/MGPipe/PipeInputs.h>
-
-#include <cstdint>
-#include <cstring>
-
-namespace MobileGL::MG_Pipe {
-    const char* MGPipeVerbName(MGPipeVerb verb) {
-        const auto index = static_cast<SizeT>(verb);
-        return index < kMGPipeVerbCount ? kMGPipeVerbNames[index] : "<none>";
-    }
-
-    [[noreturn]] void MGPipeInputPoisonFatalForVerb(MGPipeInputField field, MGPipeVerb verb) {
-        MGPipeInputPoisonFatal(field, MGPipeVerbName(verb));
-    }
-
-    Optional<MGPipeInputField> MGPipeFindInputField(const char* name) {
-        if (name == nullptr) return std::nullopt;
-        for (SizeT i = 0; i < kMGPipeInputFieldCount; ++i) {
-            if (std::strcmp(kMGPipeInputFieldNames[i], name) == 0) return static_cast<MGPipeInputField>(i);
-        }
-        return std::nullopt;
-    }
-
-    Optional<MGPipeVerb> MGPipeFindVerb(const char* name) {
-        if (name == nullptr) return std::nullopt;
-        for (SizeT i = 0; i < kMGPipeVerbCount; ++i) {
-            if (std::strcmp(kMGPipeVerbNames[i], name) == 0) return static_cast<MGPipeVerb>(i);
-        }
-        return std::nullopt;
-    }
-
-#if MOBILEGL_PIPE_VERIFY
-    namespace {
-        using CurrentVertexAttributeValue = PipeInputs::CurrentVertexAttributeValue;
-
-        // Every overload is declared up front: the array overloads recurse into their element
-        // type, and a call inside a template only sees what was declared before the template.
-        template <class T>
-        Bool StorageEqual(const T& a, const T& b);
-        template <class T>
-        Bool StorageEqual(T* const& a, T* const& b);
-        template <class T>
-        Bool StorageEqual(const SharedPtr<T>& a, const SharedPtr<T>& b);
-        template <class T, SizeT N>
-        Bool StorageEqual(const T (&a)[N], const T (&b)[N]);
-        Bool StorageEqual(const PipeInputs::IndexedCapabilities& a, const PipeInputs::IndexedCapabilities& b);
-        Bool StorageEqual(const CurrentVertexAttributeValue& a, const CurrentVertexAttributeValue& b);
-        template <class T>
-        void CorruptStorage(T& v);
-        template <class T>
-        void CorruptStorage(T*& p);
-        template <class T>
-        void CorruptStorage(SharedPtr<T>& p);
-        template <class T, SizeT N>
-        void CorruptStorage(T (&a)[N]);
-        void CorruptStorage(PipeInputs::IndexedCapabilities& c);
-        void CorruptStorage(CurrentVertexAttributeValue& v);
-
-        // ---- equality over one field's storage ----
-        // O-class storage compares by identity: a raw pointer into the context, or the object a
-        // SharedPtr owns. Everything else goes through G4's MGPipeFieldEqual, recursing through
-        // C arrays element-wise.
-        template <class T>
-        Bool StorageEqual(T* const& a, T* const& b) {
-            return a == b;
-        }
-        template <class T>
-        Bool StorageEqual(const SharedPtr<T>& a, const SharedPtr<T>& b) {
-            return a.get() == b.get();
-        }
-        template <class T, SizeT N>
-        Bool StorageEqual(const T (&a)[N], const T (&b)[N]) {
-            for (SizeT i = 0; i < N; ++i) {
-                if (!StorageEqual(a[i], b[i])) return false;
-            }
-            return true;
-        }
-        Bool StorageEqual(const PipeInputs::IndexedCapabilities& a, const PipeInputs::IndexedCapabilities& b) {
-            return StorageEqual(a.Blend, b.Blend) && StorageEqual(a.ScissorTest, b.ScissorTest);
-        }
-        // Three scalar arrays and nothing else (Core.h), so a bitwise compare has no padding to
-        // false-differ on and keeps a NaN float attribute equal to itself. The size assertion is
-        // what turns a fourth member into a build break rather than a blind spot.
-        Bool StorageEqual(const CurrentVertexAttributeValue& a, const CurrentVertexAttributeValue& b) {
-            static_assert(sizeof(CurrentVertexAttributeValue) == 3 * 4 * 4,
-                          "CurrentVertexAttributeValue grew a member; update the comparator");
-            return std::memcmp(&a, &b, sizeof(CurrentVertexAttributeValue)) == 0;
-        }
-        template <class T>
-        Bool StorageEqual(const T& a, const T& b) {
-            return MGPipeFieldEqual(a, b);
-        }
-
-        // ---- corruption of one field's storage ----
-        // Every shape is perturbed in a way the comparator above must see: a Bool flips, a
-        // scalar or enum moves by one, a pointer's low bits are flipped (never dereferenced:
-        // the snapshot is only ever compared), a SharedPtr becomes an aliasing pointer to a
-        // flipped address with no control block, an array corrupts its first element, and any
-        // other struct has its first byte XOR'ed with 0x5A.
-        template <class T>
-        T* FlipPointer(T* p) {
-            return reinterpret_cast<T*>(reinterpret_cast<std::uintptr_t>(p) ^ 0x5A);
-        }
-        template <class T>
-        void CorruptStorage(T*& p) {
-            p = FlipPointer(p);
-        }
-        template <class T>
-        void CorruptStorage(SharedPtr<T>& p) {
-            p = SharedPtr<T>(SharedPtr<T>(), FlipPointer(p.get()));
-        }
-        template <class T, SizeT N>
-        void CorruptStorage(T (&a)[N]) {
-            CorruptStorage(a[0]);
-        }
-        void CorruptStorage(PipeInputs::IndexedCapabilities& c) {
-            CorruptStorage(c.Blend);
-        }
-        void CorruptStorage(CurrentVertexAttributeValue& v) {
-            v.floatValue[0] += 1.f;
-        }
-        template <class T>
-        void CorruptStorage(T& v) {
-            if constexpr (std::is_same_v<T, Bool>) {
-                v = !v;
-            } else if constexpr (std::is_enum_v<T>) {
-                v = static_cast<T>(static_cast<std::underlying_type_t<T>>(v) + 1);
-            } else if constexpr (std::is_arithmetic_v<T>) {
-                v = static_cast<T>(v + 1);
-            } else {
-                static_assert(std::is_trivially_copyable_v<T>, "PipeInputs storage must be trivially copyable");
-                unsigned char first = 0;
-                std::memcpy(&first, &v, 1);
-                first ^= 0x5A;
-                std::memcpy(&v, &first, 1);
-            }
-        }
-    } // namespace
-
-    Bool MGPipeInputsFieldEqual(MGPipeInputField field, const PipeInputs& a, const PipeInputs& b) {
-        // A forwarded field has no storage and is equal by definition; VisitStorage answers
-        // false for it, hence the explicit sticky test first.
-        if (kMGPipeInputFieldSticky[static_cast<SizeT>(field)]) return true;
-        return PipeInputs::VisitStorage(field, a, b, [](const auto& x, const auto& y) { return StorageEqual(x, y); });
-    }
-
-    Bool MGPipeVerifyInputs(const PipeInputs& pushed, const PipeInputs& snapshot, const MGPipeFieldMask& mask,
-                            MGPipeInputField* outField) {
-        for (SizeT i = 0; i < kMGPipeInputFieldCount; ++i) {
-            const auto field = static_cast<MGPipeInputField>(i);
-            if (!MGPipeFieldMaskHas(mask, field)) continue;
-            if (MGPipeInputsFieldEqual(field, pushed, snapshot)) continue;
-            if (outField != nullptr) *outField = field;
-            return false;
-        }
-        return true;
-    }
-
-    Bool MGPipeApplyVerifyCorruption(PipeInputs& snapshot, MGPipeInputField field) {
-        return PipeInputs::VisitStorage(field, snapshot, snapshot, [](auto& x, auto&) {
-            CorruptStorage(x);
-            return true;
-        });
-    }
-#endif // MOBILEGL_PIPE_VERIFY
-} // namespace MobileGL::MG_Pipe

MobileGL/MG_Backend/MGPipe/PipeInputs.h

@@ -1,714 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/MGPipe/PipeInputs.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 <MG_Pipe/MGPipe.h>
-// The frontend types the accessors return. Allowed here: P13 keeps this include for the
-// verify arm (ARCHITECTURE.md 9.5). This header spells no MG_State global - every read of
-// the live context happens on the client side, in MG_Impl/Pipe/PipeFill.cpp.
-#include <MG_State/GLState/Core.h>
-
-// MOBILEGL_PIPE_POISON: the per-verb generation stamps and the read-side
-// Fatal{UnmigratedPipeInput} check. Derived here, once. The repository's debug gate is
-// MOBILEGL_LOG_ACTIVE_LEVEL <= MOBILEGL_LOG_LEVEL_DEBUG (Defines.h); the verify CI build is
-// Release/INFO with MOBILEGL_BUILD_DISAGGREGATED=OFF, so the third arm is what arms the poison
-// there without dragging MG_Remote in.
-#if MOBILEGL_PIPE_PUSH && (MOBILEGL_LOG_ACTIVE_LEVEL <= MOBILEGL_LOG_LEVEL_DEBUG || MOBILEGL_BUILD_DISAGGREGATED || \
-                           MOBILEGL_PIPE_VERIFY)
-#define MOBILEGL_PIPE_POISON 1
-#else
-#define MOBILEGL_PIPE_POISON 0
-#endif
-
-namespace MobileGL::MG_Pipe {
-    // PipeInputs.cpp. The poison Fatal with the verb's name ("<none>" before the first
-    // verb): MGLOG_F + std::abort(), live at every log level on purpose - this is not
-    // MOBILEGL_ASSERT, which is inert in INFO builds.
-    [[noreturn]] void MGPipeInputPoisonFatalForVerb(MGPipeInputField field, MGPipeVerb verb);
-    // kMGPipeVerbNames[verb], or "<none>" for kVerbCount (no verb has been filled yet).
-    const char* MGPipeVerbName(MGPipeVerb verb);
-    // Name lookups for the runtime knobs (MOBILEGL_PIPE_VERIFY_CORRUPT names a field,
-    // MOBILEGL_PIPE_POISON_OMIT a Verb:Field pair). Empty on an unknown name.
-    Optional<MGPipeInputField> MGPipeFindInputField(const char* name);
-    Optional<MGPipeVerb> MGPipeFindVerb(const char* name);
-
-    // The read-side poison check, on every non-forwarded accessor. Under MOBILEGL_PIPE_POISON
-    // a read of a field whose stamp is older than the current verb serial is
-    // Fatal{UnmigratedPipeInput, "Field@Verb"}; otherwise the accessor is a plain load.
-#if MOBILEGL_PIPE_POISON
-#define MGP_INPUT_CHECK(Field)                                                                                         \
-    do {                                                                                                               \
-        if (!::MobileGL::MG_Pipe::MGPipeInputFieldIsFresh(m_filled, (Field))) {                                        \
-            ::MobileGL::MG_Pipe::MGPipeInputPoisonFatalForVerb((Field), m_currentVerb);                                \
-        }                                                                                                              \
-    } while (0)
-#else
-#define MGP_INPUT_CHECK(Field) ((void)0)
-#endif
-    // The compare-at-read hook of the MOBILEGL_PIPE_VERIFY comparator (P1 brief D8), defined
-    // in MG_Impl/Pipe/PipeFill.cpp: re-reads the field from the live context and compares it
-    // against the stored value, and reports the FIRST divergence as
-    // Fatal{PipeVerifyDiffer, "Field@Verb", verb=<serial>, where=read} (the indices go in a
-    // preceding MGLOG_E). Only the live block (gPipeInputs) is verified; a snapshot's own
-    // accessors are plain loads. Off in every other build.
-    struct PipeInputs;
-#if MOBILEGL_PIPE_VERIFY
-    void MGPipeVerifyReadHook(const PipeInputs& self, MGPipeInputField field, Uint index0, Uint index1);
-#define MGP_INPUT_VERIFY_READ(Field, Index0, Index1)                                                                   \
-    ::MobileGL::MG_Pipe::MGPipeVerifyReadHook(*this, (Field), static_cast<Uint>(Index0), static_cast<Uint>(Index1))
-#else
-#define MGP_INPUT_VERIFY_READ(Field, Index0, Index1) ((void)0)
-#endif
-
-    // The V/O storage of every field that has storage, by field id. The seven F-class
-    // (forwarded) fields have none. PipeInputs::VisitStorage dispatches on this list, which
-    // is what keeps the comparator and the corruption injector one function each instead of
-    // two sixty-way switches.
-    // clang-format off
-#define MGP_INPUT_STORAGE_LIST(X)                                                    \
-    X(GetActiveTextureUnit,                        m_activeTextureUnit)              \
-    X(GetBlendColor,                               m_blendColor)                     \
-    X(GetBlendEquationIndexed,                     m_blendEquation)                  \
-    X(GetBlendFuncIndexed,                         m_blendFunc)                      \
-    X(GetBoundTransformFeedbackName,               m_boundTransformFeedbackName)     \
-    X(GetBoundVertexArray,                         m_boundVertexArray)               \
-    X(GetBufferBindingSlot,                        m_bufferBindingSlot)              \
-    X(GetBufferBindingPoint,                       m_bufferBindingPointBase)         \
-    X(GetTouchedBufferBindingPointCount,           m_touchedBindingPointCount)       \
-    X(GetClampReadColor,                           m_clampReadColor)                 \
-    X(GetClearColor,                               m_clearColor)                     \
-    X(GetClearDepth,                               m_clearDepth)                     \
-    X(GetClearStencil,                             m_clearStencil)                   \
-    X(GetColorMaskIndexed,                         m_colorMask)                      \
-    X(GetCullFaceMode,                             m_cullFaceMode)                   \
-    X(GetCurrentVertexAttribute,                   m_currentVertexAttribute)         \
-    X(GetDepthFunc,                                m_depthFunc)                      \
-    X(GetDepthMask,                                m_depthMask)                      \
-    X(GetDepthRangeIndexed,                        m_depthRange)                     \
-    X(GetFramebufferBindingSlot,                   m_framebufferBindingSlot)         \
-    X(GetImageTextureBinding,                      m_imageTextureBindingBase)        \
-    X(GetLineWidth,                                m_lineWidth)                      \
-    X(GetLogicOp,                                  m_logicOp)                        \
-    X(GetMaxTouchedTextureUnit,                    m_maxTouchedTextureUnit)          \
-    X(GetMinSampleShadingValue,                    m_minSampleShadingValue)          \
-    X(GetPatchDefaultInnerLevel,                   m_patchDefaultInnerLevel)         \
-    X(GetPatchDefaultOuterLevel,                   m_patchDefaultOuterLevel)         \
-    X(GetPatchVertices,                            m_patchVertices)                  \
-    X(GetPipelineStateVersion,                     m_pipelineStateVersion)           \
-    X(GetPixelStoreParameters,                     m_pixelStore)                     \
-    X(GetPolygonModeFront,                         m_polygonModeFront)               \
-    X(GetPolygonOffsetFactor,                      m_polygonOffsetFactor)            \
-    X(GetPolygonOffsetUnits,                       m_polygonOffsetUnits)             \
-    X(GetPrimitiveRestartIndex,                    m_primitiveRestartIndex)          \
-    X(GetProgramForDispatch,                       m_programForDispatch)             \
-    X(GetProgramForDraw,                           m_programForDraw)                 \
-    X(GetProvokingVertexMode,                      m_provokingVertexMode)            \
-    X(GetRenderStateParameters,                    m_renderState)                    \
-    X(GetRenderStateParametersVersion,             m_renderStateParametersVersion)   \
-    X(GetSamplingResolutionGeneration,             m_samplingResolutionGeneration)   \
-    X(GetScissorBox,                               m_scissorBox)                     \
-    X(GetStencilState,                             m_stencil)                        \
-    X(GetTextureBindGeneration,                    m_textureBindGeneration)          \
-    X(GetTextureContextId,                         m_textureContextId)               \
-    X(GetTextureUnitObject,                        m_textureUnitBase)                \
-    X(GetTransformFeedbackCapturedVertices,        m_transformFeedbackCapturedVertices) \
-    X(GetTransformFeedbackGeneration,              m_transformFeedbackGeneration)    \
-    X(GetTransformFeedbackPausedPrimitiveCounter,  m_transformFeedbackPausedPrimitiveCounter) \
-    X(GetTransformFeedbackProgram,                 m_transformFeedbackProgram)       \
-    X(GetViewport,                                 m_viewport)                       \
-    X(GetViewportIndexed,                          m_viewportIndexed)                \
-    X(IsCapabilityEnabled,                         m_capability)                     \
-    X(IsCapabilityEnabledIndexed,                  m_capabilityIndexed)              \
-    X(IsTransformFeedbackActive,                   m_transformFeedbackActive)        \
-    X(IsTransformFeedbackPaused,                   m_transformFeedbackPaused)        \
-    X(GetBoundTransformFeedbackLifetimeId,         m_boundTransformFeedbackLifetimeId)
-    // clang-format on
-
-    // The seven F-class fields, for the arithmetic below and for the sticky table's proof.
-    // The forwarded set IS the sticky set (PipeFields.def marks the same seven rows F and
-    // sticky), so an eighth sticky row without a forwarder is refused here, not by a test.
-    inline constexpr SizeT kMGPipeForwardedFieldCount = 7;
-    static_assert(kMGPipeForwardedFieldCount == kMGPipeInputStickyFieldCount,
-                  "the forwarded (F-class) fields and the sticky fields of PipeFields.def are the same seven rows");
-
-    // The block the backends read instead of GLContext (ARCHITECTURE.md 9.2 phase A, P1 brief
-    // D4). One struct, three storage classes, and every accessor keeps the NAME, PARAMETERS
-    // and RETURN TYPE of its GLContext counterpart (MG_State/GLState/Core.h) so the strangler
-    // sed is type-neutral:
-    //
-    //   V (value)            copied out of GLContext at fill time by calling the same accessor;
-    //                        no derivation logic is re-implemented here, which is what keeps the
-    //                        copy semantically identical by construction.
-    //   O (object reference) a SharedPtr copy, or a raw pointer to the live GLContext-owned
-    //                        slot/array for the accessors that return a non-const reference into
-    //                        the context. Identity is what phase C turns into a handle.
-    //   F (forwarded)        argument-keyed lookups and reverse-channel calls, defined out of
-    //                        line in MG_Impl/Pipe/PipeFill.cpp (the client side, where the live
-    //                        context may be spelled). Sticky: stamped once by the first fill that
-    //                        sees a live context.
-    //
-    // Every non-forwarded accessor is MGP_INPUT_CHECK (poison) -> MGP_INPUT_VERIFY_READ
-    // (compare-at-read) -> the storage. Both macros expand to nothing when their switch is
-    // off, so a plain MOBILEGL_PIPE_PUSH build's accessor is a load.
-    struct PipeInputs {
-        using GLContext = MG_State::GLState::GLContext;
-        using BufferObject = MG_State::GLState::BufferObject;
-        using BufferTarget = ::MobileGL::BufferTarget;
-        using FramebufferObject = MG_State::GLState::FramebufferObject;
-        using FramebufferTarget = ::MobileGL::FramebufferTarget;
-        using VertexArrayObject = MG_State::GLState::VertexArrayObject;
-        using ProgramObject = MG_State::GLState::ProgramObject;
-        using ITextureObject = MG_State::GLState::ITextureObject;
-        using TextureUnit = MG_State::GLState::TextureUnit;
-        using ImageTextureBinding = MG_State::GLState::ImageTextureBinding;
-        using CurrentVertexAttributeValue = MG_State::GLState::CurrentVertexAttributeValue;
-
-        static constexpr SizeT kBufferTargetCount = static_cast<SizeT>(BufferTarget::BufferTargetCount);
-        static constexpr SizeT kFramebufferTargetCount = static_cast<SizeT>(FramebufferTarget::FramebufferTargetCount);
-        static constexpr SizeT kCapabilityCount = static_cast<SizeT>(CapabilityInput::CapabilityInputCount);
-        static constexpr SizeT kMaxViewports = RenderStateParameters::MAX_VIEWPORTS;
-        static constexpr SizeT kMaxVertexAttribs = VertexArrayObject::MAX_VERTEX_ATTRIBS;
-        static constexpr SizeT kStencilFaceCount = static_cast<SizeT>(StencilFace::StencilFaceCount);
-
-        // IsCapabilityEnabledIndexed's two indexed capabilities, the only ones GLContext keeps
-        // indexed state for (RenderState::IsCapabilityEnabledIndexed).
-        struct IndexedCapabilities {
-            Bool Blend[kMGMaxDrawBuffers];
-            Bool ScissorTest[kMaxViewports];
-        };
-
-        // ---- identity / liveness (not fields) ----
-        // Whether a live GLContext exists. Forwarded (PipeFill.cpp): under push MGB_CTX_LIVE
-        // must be true as soon as a context exists, fill or no fill, which is what today's
-        // null-context guards test.
-        Bool IsLive() const;
-        // The live GLContext's address at the last fill; serves MGB_CTX_IDENTITY.
-        const void* ContextIdentity() const { return m_contextIdentity; }
-        // The verb of the last fill, kVerbCount before the first one.
-        MGPipeVerb CurrentVerb() const { return m_currentVerb; }
-#if MOBILEGL_PIPE_POISON
-        const MGPipeFilledState& FilledState() const { return m_filled; }
-#endif
-
-        // ---- V: values ----
-        Int GetActiveTextureUnit() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetActiveTextureUnit);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetActiveTextureUnit, 0, 0);
-            return m_activeTextureUnit;
-        }
-        const FloatVec4& GetBlendColor() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetBlendColor);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetBlendColor, 0, 0);
-            return m_blendColor;
-        }
-        void GetBlendEquationIndexed(Uint index, BlendEquation& color, BlendEquation& alpha) const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetBlendEquationIndexed);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetBlendEquationIndexed, index, 0);
-            if (index >= kMGMaxDrawBuffers) {
-                MOBILEGL_ASSERT(false, "Blend equation index out of range: %u", index);
-                return;
-            }
-            color = m_blendEquation[index][0];
-            alpha = m_blendEquation[index][1];
-        }
-        void GetBlendFuncIndexed(Uint index, BlendFactor& srcRGB, BlendFactor& dstRGB, BlendFactor& srcAlpha,
-                                 BlendFactor& dstAlpha) const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetBlendFuncIndexed);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetBlendFuncIndexed, index, 0);
-            if (index >= kMGMaxDrawBuffers) {
-                MOBILEGL_ASSERT(false, "Blend func index out of range: %u", index);
-                return;
-            }
-            srcRGB = m_blendFunc[index][0];
-            dstRGB = m_blendFunc[index][1];
-            srcAlpha = m_blendFunc[index][2];
-            dstAlpha = m_blendFunc[index][3];
-        }
-        // Dead field: filled, read by no backend since the D21 XFB counter-slot rekey; kept so
-        // the vendored inventory row keeps its mapping (Coverage.def).
-        Uint GetBoundTransformFeedbackName() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetBoundTransformFeedbackName);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetBoundTransformFeedbackName, 0, 0);
-            return m_boundTransformFeedbackName;
-        }
-        SizeT GetTouchedBufferBindingPointCount(BufferTarget target) const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetTouchedBufferBindingPointCount);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetTouchedBufferBindingPointCount, static_cast<Uint>(target), 0);
-            return m_touchedBindingPointCount[static_cast<SizeT>(target)];
-        }
-        GLenum GetClampReadColor() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetClampReadColor);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetClampReadColor, 0, 0);
-            return m_clampReadColor;
-        }
-        const FloatVec4& GetClearColor() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetClearColor);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetClearColor, 0, 0);
-            return m_clearColor;
-        }
-        Float GetClearDepth() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetClearDepth);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetClearDepth, 0, 0);
-            return m_clearDepth;
-        }
-        Uint32 GetClearStencil() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetClearStencil);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetClearStencil, 0, 0);
-            return m_clearStencil;
-        }
-        BoolVec4 GetColorMaskIndexed(Uint index) const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetColorMaskIndexed);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetColorMaskIndexed, index, 0);
-            return m_colorMask[index];
-        }
-        CullFaceMode GetCullFaceMode() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetCullFaceMode);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetCullFaceMode, 0, 0);
-            return m_cullFaceMode;
-        }
-        const CurrentVertexAttributeValue& GetCurrentVertexAttribute(Uint index) const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetCurrentVertexAttribute);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetCurrentVertexAttribute, index, 0);
-            if (index >= kMaxVertexAttribs) {
-                static const CurrentVertexAttributeValue defaultValue{};
-                MGLOG_E_ONCE("PipeInputs::GetCurrentVertexAttribute: index %u is out of range", index);
-                return defaultValue;
-            }
-            return m_currentVertexAttribute[index];
-        }
-        DepthTestFunc GetDepthFunc() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetDepthFunc);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetDepthFunc, 0, 0);
-            return m_depthFunc;
-        }
-        Bool GetDepthMask() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetDepthMask);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetDepthMask, 0, 0);
-            return m_depthMask;
-        }
-        const FloatVec2& GetDepthRangeIndexed(Uint index) const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetDepthRangeIndexed);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetDepthRangeIndexed, index, 0);
-            if (index >= kMaxViewports) {
-                MOBILEGL_ASSERT(false, "Depth range index out of range: %u", index);
-                return m_depthRange[0];
-            }
-            return m_depthRange[index];
-        }
-        Float GetLineWidth() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetLineWidth);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetLineWidth, 0, 0);
-            return m_lineWidth;
-        }
-        LogicOperation GetLogicOp() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetLogicOp);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetLogicOp, 0, 0);
-            return m_logicOp;
-        }
-        Int GetMaxTouchedTextureUnit() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetMaxTouchedTextureUnit);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetMaxTouchedTextureUnit, 0, 0);
-            return m_maxTouchedTextureUnit;
-        }
-        Float GetMinSampleShadingValue() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetMinSampleShadingValue);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetMinSampleShadingValue, 0, 0);
-            return m_minSampleShadingValue;
-        }
-        const FloatVec2& GetPatchDefaultInnerLevel() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetPatchDefaultInnerLevel);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetPatchDefaultInnerLevel, 0, 0);
-            return m_patchDefaultInnerLevel;
-        }
-        const FloatVec4& GetPatchDefaultOuterLevel() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetPatchDefaultOuterLevel);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetPatchDefaultOuterLevel, 0, 0);
-            return m_patchDefaultOuterLevel;
-        }
-        Uint GetPatchVertices() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetPatchVertices);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetPatchVertices, 0, 0);
-            return m_patchVertices;
-        }
-        Uint GetPipelineStateVersion() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetPipelineStateVersion);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetPipelineStateVersion, 0, 0);
-            return m_pipelineStateVersion;
-        }
-        Uint GetRenderStateParametersVersion() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetRenderStateParametersVersion);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetRenderStateParametersVersion, 0, 0);
-            return m_renderStateParametersVersion;
-        }
-        PixelStoreParameters GetPixelStoreParameters(Bool isUnpack) const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetPixelStoreParameters);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetPixelStoreParameters, isUnpack ? 1u : 0u, 0);
-            return m_pixelStore[isUnpack ? 1 : 0];
-        }
-        GLenum GetPolygonModeFront() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetPolygonModeFront);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetPolygonModeFront, 0, 0);
-            return m_polygonModeFront;
-        }
-        Float GetPolygonOffsetFactor() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetPolygonOffsetFactor);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetPolygonOffsetFactor, 0, 0);
-            return m_polygonOffsetFactor;
-        }
-        Float GetPolygonOffsetUnits() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetPolygonOffsetUnits);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetPolygonOffsetUnits, 0, 0);
-            return m_polygonOffsetUnits;
-        }
-        Uint32 GetPrimitiveRestartIndex() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetPrimitiveRestartIndex);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetPrimitiveRestartIndex, 0, 0);
-            return m_primitiveRestartIndex;
-        }
-        ProvokingVertexMode GetProvokingVertexMode() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetProvokingVertexMode);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetProvokingVertexMode, 0, 0);
-            return m_provokingVertexMode;
-        }
-        const RenderStateParameters& GetRenderStateParameters() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetRenderStateParameters);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetRenderStateParameters, 0, 0);
-            return m_renderState;
-        }
-        Uint64 GetSamplingResolutionGeneration() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetSamplingResolutionGeneration);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetSamplingResolutionGeneration, 0, 0);
-            return m_samplingResolutionGeneration;
-        }
-        const IntVec4& GetScissorBox() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetScissorBox);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetScissorBox, 0, 0);
-            return m_scissorBox;
-        }
-        const StencilFaceState& GetStencilState(StencilFace face) const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetStencilState);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetStencilState, static_cast<Uint>(face), 0);
-            return m_stencil[face == StencilFace::Back ? 1 : 0];
-        }
-        Uint64 GetTextureBindGeneration() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetTextureBindGeneration);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetTextureBindGeneration, 0, 0);
-            return m_textureBindGeneration;
-        }
-        Uint64 GetTextureContextId() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetTextureContextId);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetTextureContextId, 0, 0);
-            return m_textureContextId;
-        }
-        Uint64 GetTransformFeedbackCapturedVertices() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetTransformFeedbackCapturedVertices);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetTransformFeedbackCapturedVertices, 0, 0);
-            return m_transformFeedbackCapturedVertices;
-        }
-        Uint64 GetTransformFeedbackGeneration() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetTransformFeedbackGeneration);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetTransformFeedbackGeneration, 0, 0);
-            return m_transformFeedbackGeneration;
-        }
-        Uint64 GetTransformFeedbackPausedPrimitiveCounter() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetTransformFeedbackPausedPrimitiveCounter);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetTransformFeedbackPausedPrimitiveCounter, 0, 0);
-            return m_transformFeedbackPausedPrimitiveCounter;
-        }
-        Uint64 GetBoundTransformFeedbackLifetimeId() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetBoundTransformFeedbackLifetimeId);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetBoundTransformFeedbackLifetimeId, 0, 0);
-            return m_boundTransformFeedbackLifetimeId;
-        }
-        IntVec4 GetViewport() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetViewport);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetViewport, 0, 0);
-            return m_viewport;
-        }
-        const FloatVec4& GetViewportIndexed(Uint index) const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetViewportIndexed);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetViewportIndexed, index, 0);
-            if (index >= kMaxViewports) {
-                MOBILEGL_ASSERT(false, "Viewport index out of range: %u", index);
-                return m_viewportIndexed[0];
-            }
-            return m_viewportIndexed[index];
-        }
-        Bool IsCapabilityEnabled(CapabilityInput cap) const {
-            MGP_INPUT_CHECK(MGPipeInputField::IsCapabilityEnabled);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::IsCapabilityEnabled, static_cast<Uint>(cap), 0);
-            const auto index = static_cast<SizeT>(cap);
-            return index < kCapabilityCount ? m_capability[index] : false;
-        }
-        // Blend and ScissorTest are the only indexed capabilities GLContext keeps; no backend
-        // asks for another (VulkanRenderer asks Blend). Any other cap is a read the fill cannot
-        // have served: Fatal{UnmigratedPipeInput} naming the field and the verb, the cap in a
-        // preceding MGLOG_E.
-        Bool IsCapabilityEnabledIndexed(CapabilityInput cap, Uint index) const {
-            MGP_INPUT_CHECK(MGPipeInputField::IsCapabilityEnabledIndexed);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::IsCapabilityEnabledIndexed, static_cast<Uint>(cap), index);
-            if (cap == CapabilityInput::Blend) {
-                return index < kMGMaxDrawBuffers ? m_capabilityIndexed.Blend[index] : false;
-            }
-            if (cap == CapabilityInput::ScissorTest) {
-                return index < kMaxViewports ? m_capabilityIndexed.ScissorTest[index] : false;
-            }
-            MGLOG_E("PipeInputs::IsCapabilityEnabledIndexed: no indexed storage for cap=%d (index=%u)",
-                    static_cast<int>(cap), index);
-            MGPipeInputPoisonFatalForVerb(MGPipeInputField::IsCapabilityEnabledIndexed, m_currentVerb);
-        }
-        Bool IsTransformFeedbackActive() const {
-            MGP_INPUT_CHECK(MGPipeInputField::IsTransformFeedbackActive);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::IsTransformFeedbackActive, 0, 0);
-            return m_transformFeedbackActive;
-        }
-        Bool IsTransformFeedbackPaused() const {
-            MGP_INPUT_CHECK(MGPipeInputField::IsTransformFeedbackPaused);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::IsTransformFeedbackPaused, 0, 0);
-            return m_transformFeedbackPaused;
-        }
-
-        // ---- O: object references ----
-        const SharedPtr<VertexArrayObject>& GetBoundVertexArray() {
-            MGP_INPUT_CHECK(MGPipeInputField::GetBoundVertexArray);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetBoundVertexArray, 0, 0);
-            return m_boundVertexArray;
-        }
-        // A target the fill left null (one outside GlobalBufferTargets / BufferBindPointTargets,
-        // or a read before any fill) is a read the fill cannot have served: the poison Fatal,
-        // the target in a preceding MGLOG_E.
-        BindingSlot<BufferObject>& GetBufferBindingSlot(BufferTarget target) {
-            MGP_INPUT_CHECK(MGPipeInputField::GetBufferBindingSlot);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetBufferBindingSlot, static_cast<Uint>(target), 0);
-            const auto index = static_cast<SizeT>(target);
-            if (index >= kBufferTargetCount || m_bufferBindingSlot[index] == nullptr) {
-                MGLOG_E("PipeInputs::GetBufferBindingSlot: no slot for target=%d", static_cast<int>(target));
-                MGPipeInputPoisonFatalForVerb(MGPipeInputField::GetBufferBindingSlot, m_currentVerb);
-            }
-            return *m_bufferBindingSlot[index];
-        }
-        BindingSlotRange1D<BufferObject>& GetBufferBindingPoint(BufferTarget target, Uint index) {
-            MGP_INPUT_CHECK(MGPipeInputField::GetBufferBindingPoint);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetBufferBindingPoint, static_cast<Uint>(target), index);
-            const auto targetIndex = static_cast<SizeT>(target);
-            if (targetIndex >= kBufferTargetCount || m_bufferBindingPointBase[targetIndex] == nullptr) {
-                MGLOG_E("PipeInputs::GetBufferBindingPoint: no binding points for target=%d (index=%u)",
-                        static_cast<int>(target), index);
-                MGPipeInputPoisonFatalForVerb(MGPipeInputField::GetBufferBindingPoint, m_currentVerb);
-            }
-            // The live storage is Array<Array<BindingSlotRange1D, BufferBindingPointCount>, N>
-            // (BufferState.h), so base[index] is the live slot GLContext would hand out.
-            return m_bufferBindingPointBase[targetIndex][index];
-        }
-        BindingSlot<FramebufferObject>& GetFramebufferBindingSlot(FramebufferTarget target) {
-            MGP_INPUT_CHECK(MGPipeInputField::GetFramebufferBindingSlot);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetFramebufferBindingSlot, static_cast<Uint>(target), 0);
-            const auto index = static_cast<SizeT>(target);
-            if (index >= kFramebufferTargetCount || m_framebufferBindingSlot[index] == nullptr) {
-                MGLOG_E("PipeInputs::GetFramebufferBindingSlot: no slot for target=%d", static_cast<int>(target));
-                MGPipeInputPoisonFatalForVerb(MGPipeInputField::GetFramebufferBindingSlot, m_currentVerb);
-            }
-            return *m_framebufferBindingSlot[index];
-        }
-        ImageTextureBinding& GetImageTextureBinding(Int unit) {
-            MGP_INPUT_CHECK(MGPipeInputField::GetImageTextureBinding);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetImageTextureBinding, static_cast<Uint>(unit), 0);
-            if (m_imageTextureBindingBase == nullptr) {
-                MGPipeInputPoisonFatalForVerb(MGPipeInputField::GetImageTextureBinding, m_currentVerb);
-            }
-            return m_imageTextureBindingBase[unit];
-        }
-        const ImageTextureBinding& GetImageTextureBinding(Int unit) const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetImageTextureBinding);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetImageTextureBinding, static_cast<Uint>(unit), 0);
-            if (m_imageTextureBindingBase == nullptr) {
-                MGPipeInputPoisonFatalForVerb(MGPipeInputField::GetImageTextureBinding, m_currentVerb);
-            }
-            return m_imageTextureBindingBase[unit];
-        }
-        const SharedPtr<ProgramObject>& GetProgramForDispatch() {
-            MGP_INPUT_CHECK(MGPipeInputField::GetProgramForDispatch);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetProgramForDispatch, 0, 0);
-            return m_programForDispatch;
-        }
-        const SharedPtr<ProgramObject>& GetProgramForDraw() {
-            MGP_INPUT_CHECK(MGPipeInputField::GetProgramForDraw);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetProgramForDraw, 0, 0);
-            return m_programForDraw;
-        }
-        const SharedPtr<ProgramObject>& GetTransformFeedbackProgram() const {
-            MGP_INPUT_CHECK(MGPipeInputField::GetTransformFeedbackProgram);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetTransformFeedbackProgram, 0, 0);
-            return m_transformFeedbackProgram;
-        }
-        TextureUnit& GetTextureUnitObject(Int unit) {
-            MGP_INPUT_CHECK(MGPipeInputField::GetTextureUnitObject);
-            MGP_INPUT_VERIFY_READ(MGPipeInputField::GetTextureUnitObject, static_cast<Uint>(unit), 0);
-            if (m_textureUnitBase == nullptr) {
-                MGPipeInputPoisonFatalForVerb(MGPipeInputField::GetTextureUnitObject, m_currentVerb);
-            }
-            return m_textureUnitBase[unit];
-        }
-
-        // ---- F: forwarded to the live context (MG_Impl/Pipe/PipeFill.cpp); sticky ----
-        // Each takes an argument that is not verb state - a GL name, a lifetime id, a target -
-        // i.e. it is a lookup or a reverse-channel write, not a state read; there is no value
-        // the filler could copy and no verb whose fill could make it stale. Phase C replaces
-        // them with handle tables and callbacks.
-        // They carry no MGP_INPUT_CHECK / MGP_INPUT_VERIFY_READ (the declared exception to
-        // P1 brief D4's "every accessor body"): a forward is a live call, not a stored value,
-        // and InvalidateCompileEnv is reached from backend initialisation before any verb has
-        // filled, where a check would be Fatal{...@<none>} on every start. Their sticky stamp
-        // is therefore consulted by no accessor; the tests pin it through
-        // MGPipeInputFieldIsFresh directly.
-        SizeT GetBufferBindingPointCount(BufferTarget target) const;
-        const SharedPtr<ProgramObject>& GetProgramObject(Uint index);
-        const SharedPtr<ITextureObject>& GetTextureObject(Uint index);
-        Bool HasOpenTransformFeedbackSpan(Uint64 lifetimeId) const;
-        void InvalidateCompileEnv();
-        Bool ValidateProgramName(Uint index) const;
-        // Dropped with an MGLOG_E_ONCE when no context is live; today's guarded sites never
-        // reach it without one.
-        void RecordError(ErrorCode code, UniquePtr<ErrorInfo> info);
-
-        // ---- the storage visitor ----
-        // Calls fn(a.<member>, b.<member>) for the field's storage and returns its result; returns
-        // false without calling fn for a forwarded field, which has none. The comparator's
-        // per-field equality and the verify corruption injector are both one call of this.
-        template <class Fn>
-        static Bool VisitStorage(MGPipeInputField field, PipeInputs& a, PipeInputs& b, Fn&& fn) {
-            switch (field) {
-#define MGP_INPUT_VISIT(Field, Member)                                                                                 \
-    case MGPipeInputField::Field:                                                                                      \
-        return fn(a.Member, b.Member);
-                MGP_INPUT_STORAGE_LIST(MGP_INPUT_VISIT)
-#undef MGP_INPUT_VISIT
-            default:
-                return false;
-            }
-        }
-        template <class Fn>
-        static Bool VisitStorage(MGPipeInputField field, const PipeInputs& a, const PipeInputs& b, Fn&& fn) {
-            switch (field) {
-#define MGP_INPUT_VISIT(Field, Member)                                                                                 \
-    case MGPipeInputField::Field:                                                                                      \
-        return fn(a.Member, b.Member);
-                MGP_INPUT_STORAGE_LIST(MGP_INPUT_VISIT)
-#undef MGP_INPUT_VISIT
-            default:
-                return false;
-            }
-        }
-
-    private:
-        // The one door into the storage from the client side (MG_Impl/Pipe/PipeFill.cpp):
-        // the filler's per-field copies and stamps, and the verify snapshot.
-        friend struct MGPipeFillAccess;
-
-        // ---- identity ----
-        const void* m_contextIdentity = nullptr;
-        Bool m_live = false;
-        MGPipeVerb m_currentVerb = MGPipeVerb::kVerbCount;
-#if MOBILEGL_PIPE_POISON
-        MGPipeFilledState m_filled{};
-#endif
-
-        // ---- V ----
-        Int m_activeTextureUnit = 0;
-        FloatVec4 m_blendColor{};
-        BlendEquation m_blendEquation[kMGMaxDrawBuffers][2]{};
-        BlendFactor m_blendFunc[kMGMaxDrawBuffers][4]{};
-        Uint m_boundTransformFeedbackName = 0;
-        SizeT m_touchedBindingPointCount[kBufferTargetCount]{};
-        GLenum m_clampReadColor = 0;
-        FloatVec4 m_clearColor{};
-        Float m_clearDepth = 0.f;
-        Uint32 m_clearStencil = 0;
-        BoolVec4 m_colorMask[kMGMaxDrawBuffers]{};
-        CullFaceMode m_cullFaceMode{};
-        CurrentVertexAttributeValue m_currentVertexAttribute[kMaxVertexAttribs]{};
-        DepthTestFunc m_depthFunc{};
-        Bool m_depthMask = false;
-        FloatVec2 m_depthRange[kMaxViewports]{};
-        Float m_lineWidth = 0.f;
-        LogicOperation m_logicOp{};
-        Int m_maxTouchedTextureUnit = -1;
-        Float m_minSampleShadingValue = 0.f;
-        FloatVec2 m_patchDefaultInnerLevel{};
-        FloatVec4 m_patchDefaultOuterLevel{};
-        Uint m_patchVertices = 0;
-        Uint m_pipelineStateVersion = 0;
-        Uint m_renderStateParametersVersion = 0;
-        PixelStoreParameters m_pixelStore[2]{}; // [0] = pack, [1] = unpack
-        GLenum m_polygonModeFront = 0;
-        Float m_polygonOffsetFactor = 0.f;
-        Float m_polygonOffsetUnits = 0.f;
-        Uint32 m_primitiveRestartIndex = 0;
-        ProvokingVertexMode m_provokingVertexMode{};
-        RenderStateParameters m_renderState{};
-        Uint64 m_samplingResolutionGeneration = 0;
-        Uint64 m_textureBindGeneration = 0;
-        Uint64 m_textureContextId = 0;
-        IntVec4 m_scissorBox{};
-        StencilFaceState m_stencil[kStencilFaceCount]{};
-        Uint64 m_transformFeedbackCapturedVertices = 0;
-        Uint64 m_transformFeedbackGeneration = 0;
-        Uint64 m_transformFeedbackPausedPrimitiveCounter = 0;
-        Uint64 m_boundTransformFeedbackLifetimeId = 0;
-        IntVec4 m_viewport{};
-        FloatVec4 m_viewportIndexed[kMaxViewports]{};
-        Bool m_capability[kCapabilityCount]{};
-        IndexedCapabilities m_capabilityIndexed{};
-        Bool m_transformFeedbackActive = false;
-        Bool m_transformFeedbackPaused = false;
-
-        // ---- O ----
-        SharedPtr<VertexArrayObject> m_boundVertexArray;
-        BindingSlot<BufferObject>* m_bufferBindingSlot[kBufferTargetCount]{};
-        BindingSlotRange1D<BufferObject>* m_bufferBindingPointBase[kBufferTargetCount]{};
-        BindingSlot<FramebufferObject>* m_framebufferBindingSlot[kFramebufferTargetCount]{};
-        ImageTextureBinding* m_imageTextureBindingBase = nullptr;
-        SharedPtr<ProgramObject> m_programForDispatch;
-        SharedPtr<ProgramObject> m_programForDraw;
-        SharedPtr<ProgramObject> m_transformFeedbackProgram;
-        TextureUnit* m_textureUnitBase = nullptr;
-    };
-
-    // The single global the backends read through MGB_CTX (ARCHITECTURE.md 9.2). An inline
-    // variable: no .cpp is needed for the definition.
-    inline PipeInputs gPipeInputs{};
-
-    // Every field has storage or is forwarded, and nothing else.
-#define MGP_INPUT_COUNT_ONE(Field, Member) +1
-    static_assert(0 MGP_INPUT_STORAGE_LIST(MGP_INPUT_COUNT_ONE) + kMGPipeForwardedFieldCount == kMGPipeInputFieldCount,
-                  "MGP_INPUT_STORAGE_LIST plus the seven forwarded fields is not the PipeInputs field set");
-#undef MGP_INPUT_COUNT_ONE
-    // The docs budget ~20 KB; the block is a few KB.
-    static_assert(sizeof(PipeInputs) < 20 * 1024, "PipeInputs outgrew its budget");
-
-#if MOBILEGL_PIPE_VERIFY
-    // PipeInputs.cpp. Per-field equality for the entry compare (P1 brief D8): V by value
-    // through G4's MGPipeFieldEqual (bitwise floats, field-wise structs), O by identity, F
-    // always equal (no storage).
-    Bool MGPipeInputsFieldEqual(MGPipeInputField field, const PipeInputs& a, const PipeInputs& b);
-    // PipeInputs.cpp. The entry compare: every field in `mask` of the pushed block against the
-    // snapshot, first differing field out. Exported from the shared library on purpose - the
-    // retrace-verify CI job proves it swapped in a verify build by finding this symbol with
-    // nm -D, so a "green" run against a library without the comparator cannot happen.
-#if defined(__GNUC__) || defined(__clang__)
-    __attribute__((visibility("default")))
-#endif
-    Bool MGPipeVerifyInputs(const PipeInputs& pushed, const PipeInputs& snapshot, const MGPipeFieldMask& mask,
-                            MGPipeInputField* outField);
-    // PipeInputs.cpp. Negative control A: perturbs one field's storage (flip a Bool, +1 a
-    // scalar, ^0x5A the first byte of a struct, flip a pointer's low bits - never
-    // dereferenced, the snapshot is only ever compared). Returns false for a forwarded field,
-    // which has nothing to corrupt.
-    Bool MGPipeApplyVerifyCorruption(PipeInputs& snapshot, MGPipeInputField field);
-#endif
-} // namespace MobileGL::MG_Pipe

MobileGL/MG_Benchmark/CMakeLists.txt

@@ -42,7 +42,4 @@ set_tests_properties(SanityBench PROPERTIES LABELS benchmark)
 
 add_subdirectory(Program)
 add_subdirectory(Buffer)
-add_subdirectory(Driver)
-add_subdirectory(Container)
-add_subdirectory(ShaderCache)
-add_subdirectory(Transpile)
+add_subdirectory(Driver)

MobileGL/MG_Benchmark/Container/CMakeLists.txt

@@ -1,20 +0,0 @@
-cmake_minimum_required(VERSION 3.24)
-
-add_executable(
-        UnorderedMapBench
-        UnorderedMapBench.cpp
-)
-
-target_include_directories(UnorderedMapBench PRIVATE
-        ${MGL_ROOT}/include
-        ${MGL_ROOT}/MobileGL
-)
-
-target_link_libraries(
-        UnorderedMapBench PRIVATE
-        benchmark::benchmark
-        ${LINK_LIBRARIES}
-)
-
-add_test(NAME UnorderedMapBench COMMAND UnorderedMapBench --benchmark_counters_tabular=true)
-set_tests_properties(UnorderedMapBench PROPERTIES LABELS benchmark)

MobileGL/MG_Benchmark/Container/UnorderedMapBench.cpp

@@ -1,248 +0,0 @@
-// MobileGL - MobileGL/MG_Benchmark/Container/UnorderedMapBench.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
-//
-// The standing performance observatory for MobileGL::UnorderedMap.
-//
-// This benchmarks the ALIAS, never a concrete table, so whatever UnorderedMap
-// names today is what gets measured - swap the container in MG_Util/Types.h and
-// re-run this same binary to get a directly comparable set of numbers. That is
-// the point of it: the container sits on per-draw paths, so a change to it needs
-// evidence, and the evidence should be produced the same way every time.
-//
-// The workloads are the shapes the tree actually exercises, not generic hash-map
-// microbenchmarks. Four key shapes, because they stress a hash function very
-// differently:
-//   * SEQUENTIAL   dense small integers - GL object names from the index generator
-//                  (buffer/texture/framebuffer/sampler registries).
-//   * POINTER      real heap addresses - StateBackendObjectRegistry keys on
-//                  StateObject*. These are aligned, so their low bits are the
-//                  least random part of the key; a table that indexes on raw low
-//                  bits clusters badly here and one that mixes first does not.
-//                  Taken from the real allocator rather than a synthetic stride,
-//                  which would flatter whichever table mixes its bits.
-//   * DIGEST       already well-mixed 64-bit values - the XXH64 pipeline,
-//                  vertex-input-state and program memos.
-//   * NAME         short strings - uniform/attribute name to location maps.
-//
-// Sizes sweep from 8 upward because the per-draw memos are usually SMALL; a table
-// that only wins at 4096 entries has not won anything that matters here.
-//
-// Run:  build-linux/MobileGL/MG_Benchmark/Container/UnorderedMapBench
-//   or: ctest -R UnorderedMapBench     (label: benchmark)
-
-#include <cstdint>
-#include <memory>
-#include <random>
-#include <string>
-#include <vector>
-#include <benchmark/benchmark.h>
-
-#include "MG_Util/Types.h"
-
-using namespace MobileGL;
-
-namespace {
-
-    constexpr Int64 kMinSize = 8;
-    constexpr Int64 kMaxSize = 4096;
-
-    // Keep the real allocations alive for the whole process: the POINTER shape is
-    // only honest if the keys are addresses the allocator actually handed out, and
-    // they have to stay unique (a freed address can be handed out twice).
-    std::vector<std::unique_ptr<char[]>>& PointerKeyStorage() {
-        static std::vector<std::unique_ptr<char[]>> storage;
-        return storage;
-    }
-
-    Vector<Uint64> SequentialKeys(SizeT n) {
-        Vector<Uint64> keys;
-        keys.reserve(n);
-        for (SizeT i = 0; i < n; ++i) keys.push_back(static_cast<Uint64>(i) + 1);
-        return keys;
-    }
-
-    Vector<Uint64> PointerKeys(SizeT n) {
-        auto& storage = PointerKeyStorage();
-        Vector<Uint64> keys;
-        keys.reserve(n);
-        std::mt19937_64 rng(0xBEEF);
-        std::vector<std::unique_ptr<char[]>> churn;
-        for (SizeT i = 0; i < n; ++i) {
-            // State objects are not all one size, and the allocator sees other
-            // traffic between them - a single uniform stride is not what this
-            // registry ever sees.
-            const SizeT sz = 96 + (rng() % 192);
-            auto p = std::make_unique<char[]>(sz);
-            keys.push_back(reinterpret_cast<Uint64>(p.get()));
-            storage.push_back(std::move(p));
-            if ((rng() & 3) == 0) churn.push_back(std::make_unique<char[]>(32 + (rng() % 128)));
-        }
-        return keys;
-    }
-
-    Vector<Uint64> DigestKeys(SizeT n) {
-        Vector<Uint64> keys;
-        keys.reserve(n);
-        std::mt19937_64 rng(0xC0FFEE);
-        for (SizeT i = 0; i < n; ++i) keys.push_back(rng());
-        return keys;
-    }
-
-    Vector<String> NameKeys(SizeT n) {
-        static const char* kPrefixes[] = {"u_", "a_", "mc_", "iris_", "gl_", "v_"};
-        Vector<String> keys;
-        keys.reserve(n);
-        for (SizeT i = 0; i < n; ++i) {
-            keys.push_back(String(kPrefixes[i % 6]) + "Uniform" + std::to_string(i) + "_xyz");
-        }
-        return keys;
-    }
-
-    // Key sets are built once per size and shared: generating them inside the timed
-    // loop would measure the generator (and, for POINTER, the allocator) instead of
-    // the table.
-    template <typename KeyVec, KeyVec (*Make)(SizeT)>
-    const KeyVec& CachedKeys(SizeT n) {
-        static UnorderedMap<SizeT, KeyVec> cache;
-        auto it = cache.find(n);
-        if (it != cache.end()) return it->second;
-        return cache.emplace(n, Make(n)).first->second;
-    }
-
-    template <typename Key>
-    UnorderedMap<Key, Uint64> Populated(const Vector<Key>& keys) {
-        UnorderedMap<Key, Uint64> map;
-        for (SizeT i = 0; i < keys.size(); ++i) map[keys[i]] = i;
-        return map;
-    }
-
-    // ---- the workloads ----------------------------------------------------
-
-    // The dominant per-draw operation by a wide margin: a populated cache that is
-    // read far more often than it is written.
-    template <typename KeyVec, KeyVec (*Make)(SizeT)>
-    void LookupHit(benchmark::State& state) {
-        const auto& keys = CachedKeys<KeyVec, Make>(static_cast<SizeT>(state.range(0)));
-        auto map = Populated(keys);
-        for (auto _ : state) {
-            for (const auto& k : keys) {
-                auto it = map.find(k);
-                benchmark::DoNotOptimize(it->second);
-            }
-        }
-        state.SetItemsProcessed(state.iterations() * static_cast<Int64>(keys.size()));
-    }
-
-    // "Is this resource cached yet?" answered NO - the probe length on a miss is a
-    // different cost from a hit, and resource caches ask this constantly.
-    template <typename KeyVec, KeyVec (*Make)(SizeT)>
-    void LookupMiss(benchmark::State& state) {
-        const SizeT n = static_cast<SizeT>(state.range(0));
-        const auto& keys = CachedKeys<KeyVec, Make>(n);
-        auto map = Populated(keys);
-        const KeyVec absent = Make(n); // same shape, never inserted
-        for (auto _ : state) {
-            for (const auto& k : absent) {
-                benchmark::DoNotOptimize(map.find(k) != map.end());
-            }
-        }
-        state.SetItemsProcessed(state.iterations() * static_cast<Int64>(absent.size()));
-    }
-
-    // Building a cache from empty, rehashes included.
-    template <typename KeyVec, KeyVec (*Make)(SizeT)>
-    void InsertGrow(benchmark::State& state) {
-        const auto& keys = CachedKeys<KeyVec, Make>(static_cast<SizeT>(state.range(0)));
-        for (auto _ : state) {
-            UnorderedMap<typename KeyVec::value_type, Uint64> map;
-            for (SizeT i = 0; i < keys.size(); ++i) map[keys[i]] = i;
-            benchmark::DoNotOptimize(map.size());
-        }
-        state.SetItemsProcessed(state.iterations() * static_cast<Int64>(keys.size()));
-    }
-
-    // Cache eviction and refill: erase half by key, put them back. This is the
-    // aged-out-entry sweep the pipeline and vertex-input caches do.
-    template <typename KeyVec, KeyVec (*Make)(SizeT)>
-    void EraseChurn(benchmark::State& state) {
-        const auto& keys = CachedKeys<KeyVec, Make>(static_cast<SizeT>(state.range(0)));
-        for (auto _ : state) {
-            state.PauseTiming();
-            auto map = Populated(keys);
-            state.ResumeTiming();
-            for (SizeT i = 0; i < keys.size(); i += 2) benchmark::DoNotOptimize(map.erase(keys[i]));
-            for (SizeT i = 0; i < keys.size(); i += 2) map[keys[i]] = i;
-            benchmark::DoNotOptimize(map.size());
-        }
-        state.SetItemsProcessed(state.iterations() * static_cast<Int64>(keys.size()));
-    }
-
-    // Mass eviction: erase-while-iterating across the whole table. This is the loop
-    // shape that a container's erase()-return contract can get wrong, and the one
-    // that fed garbage handles to vkDestroyPipeline when it was wrong before.
-    template <typename KeyVec, KeyVec (*Make)(SizeT)>
-    void EraseSweep(benchmark::State& state) {
-        const auto& keys = CachedKeys<KeyVec, Make>(static_cast<SizeT>(state.range(0)));
-        for (auto _ : state) {
-            state.PauseTiming();
-            auto map = Populated(keys);
-            state.ResumeTiming();
-            for (auto it = map.begin(); it != map.end();) it = map.erase(it);
-            benchmark::DoNotOptimize(map.size());
-        }
-        state.SetItemsProcessed(state.iterations() * static_cast<Int64>(keys.size()));
-    }
-
-    // Whole-table walks: the per-frame sweeps that age entries out, and the
-    // teardown loops that destroy every Vulkan object a cache owns.
-    template <typename KeyVec, KeyVec (*Make)(SizeT)>
-    void Iterate(benchmark::State& state) {
-        const auto& keys = CachedKeys<KeyVec, Make>(static_cast<SizeT>(state.range(0)));
-        auto map = Populated(keys);
-        for (auto _ : state) {
-            Uint64 acc = 0;
-            for (const auto& entry : map) acc += entry.second;
-            benchmark::DoNotOptimize(acc);
-        }
-        state.SetItemsProcessed(state.iterations() * static_cast<Int64>(keys.size()));
-    }
-
-} // namespace
-
-#define MGL_MAP_BENCH(WORKLOAD, SHAPE, VEC, MAKER)                                                 \
-    BENCHMARK_TEMPLATE(WORKLOAD, VEC, MAKER)                                                       \
-        ->Name(#WORKLOAD "/" #SHAPE)                                                               \
-        ->RangeMultiplier(8)                                                                       \
-        ->Range(kMinSize, kMaxSize)
-
-MGL_MAP_BENCH(LookupHit, sequential, Vector<Uint64>, SequentialKeys);
-MGL_MAP_BENCH(LookupHit, pointer, Vector<Uint64>, PointerKeys);
-MGL_MAP_BENCH(LookupHit, digest, Vector<Uint64>, DigestKeys);
-MGL_MAP_BENCH(LookupHit, name, Vector<String>, NameKeys);
-
-MGL_MAP_BENCH(LookupMiss, sequential, Vector<Uint64>, SequentialKeys);
-MGL_MAP_BENCH(LookupMiss, pointer, Vector<Uint64>, PointerKeys);
-MGL_MAP_BENCH(LookupMiss, digest, Vector<Uint64>, DigestKeys);
-MGL_MAP_BENCH(LookupMiss, name, Vector<String>, NameKeys);
-
-MGL_MAP_BENCH(InsertGrow, sequential, Vector<Uint64>, SequentialKeys);
-MGL_MAP_BENCH(InsertGrow, pointer, Vector<Uint64>, PointerKeys);
-MGL_MAP_BENCH(InsertGrow, digest, Vector<Uint64>, DigestKeys);
-MGL_MAP_BENCH(InsertGrow, name, Vector<String>, NameKeys);
-
-MGL_MAP_BENCH(EraseChurn, sequential, Vector<Uint64>, SequentialKeys);
-MGL_MAP_BENCH(EraseChurn, digest, Vector<Uint64>, DigestKeys);
-MGL_MAP_BENCH(EraseChurn, name, Vector<String>, NameKeys);
-
-MGL_MAP_BENCH(EraseSweep, sequential, Vector<Uint64>, SequentialKeys);
-MGL_MAP_BENCH(EraseSweep, digest, Vector<Uint64>, DigestKeys);
-
-MGL_MAP_BENCH(Iterate, sequential, Vector<Uint64>, SequentialKeys);
-MGL_MAP_BENCH(Iterate, digest, Vector<Uint64>, DigestKeys);
-
-BENCHMARK_MAIN();

MobileGL/MG_Benchmark/ShaderCache/CMakeLists.txt

@@ -1,21 +0,0 @@
-cmake_minimum_required(VERSION 3.24)
-
-add_executable(
-        TranslationCacheBench
-        TranslationCacheBench.cpp
-)
-
-target_include_directories(TranslationCacheBench PRIVATE
-        ${MGL_ROOT}/include
-        ${MGL_ROOT}/MobileGL
-        ${MGL_ROOT}/3rdparty/SPIRV-Reflect
-)
-
-target_link_libraries(
-        TranslationCacheBench PRIVATE
-        benchmark::benchmark
-        ${LINK_LIBRARIES}
-)
-
-add_test(NAME TranslationCacheBench COMMAND TranslationCacheBench --benchmark_counters_tabular=true)
-set_tests_properties(TranslationCacheBench PROPERTIES LABELS benchmark)

MobileGL/MG_Benchmark/ShaderCache/TranslationCacheBench.cpp

@@ -1,457 +0,0 @@
-// MobileGL - MobileGL/MG_Benchmark/ShaderCache/TranslationCacheBench.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
-
-// What the two-level shader translation memo is worth, measured on the workload that
-// motivated it: the KHR-GL33.texture_swizzle.smoke_* shape, where one case builds 2592
-// programs out of a handful of distinct sources.
-//
-// Four pairs of cases, each Off/On:
-//
-//   ProgramLink      - the whole glCompileShader + glLinkProgram path for one program, with
-//                      FRESH SHADER OBJECTS every iteration. This is the CTS shape exactly,
-//                      and it is the headline case now. It used to be the PESSIMISTIC one:
-//                      a hit still paid for both glslang parses, because the parse happens
-//                      at glCompileShader - a different entry point from the one L1
-//                      memoizes - and fresh shader objects meant ShaderCompileAdoptionMap
-//                      could not hand the earlier parse over either. L1c is what closed
-//                      that: the compile half of the memo recognises each stage's source
-//                      and publishes its verdict without parsing, so on a hit this case now
-//                      constructs no glslang object at all.
-//
-//   SharedShaderLink - the same program population with the shader objects KEPT ALIVE, so
-//                      the parses happen once outside the measured loop whatever the cache
-//                      does. That makes it the CONTROL for L1c rather than a target: its
-//                      numbers should not move, and if they do, L1c has added cost to a
-//                      path it was supposed to leave alone.
-//
-//   DeferredParseLink - the shape where L1c could LOSE: a constant vertex source (which
-//                      hits L1c and therefore skips its parse) against a fresh fragment
-//                      source every iteration (which makes the PROGRAM key miss, so the
-//                      skipped parse has to happen inside the link after all). Same parse
-//                      count either way, so the pair should land within noise; see its own
-//                      header below.
-//
-//   EsslTranspile    - the DirectGLES backend segment: the SPIR-V pass chain plus
-//                      SPIRV-Cross. Runs the driver-INDEPENDENT half of the real chain (the
-//                      passes SyncToBackend runs unconditionally, plus the two stage-gated
-//                      ones a fragment module reaches) so the miss path costs what
-//                      production costs; the capability-gated passes need a live ES driver
-//                      and are not reachable from a benchmark process.
-//
-// Every On case runs with a warm cache: the first iteration misses and every one after it
-// hits, which is exactly the steady state of a 2592-program smoke case.
-
-#include <benchmark/benchmark.h>
-
-#include <string>
-
-#include "Config.h"
-#include "Includes.h"
-#include "Init.h"
-#include "MG_Impl/GLImpl/Program/GL_Program.h"
-#include "MG_State/GLState/Core.h"
-#include "MG_State/GLState/ProgramState/ProgramTranslationCache.h"
-#include "MG_Util/ShaderTranspiler/ShaderCompiler.h"
-#include "MG_Util/ShaderTranspiler/SpvcSession.h"
-#include "MG_Util/ShaderTranspiler/TranslationCache.h"
-#include "MG_Util/ShaderTranspiler/Types.h"
-
-using namespace MobileGL;
-using namespace MobileGL::MG_Util::ShaderTranspiler;
-
-namespace {
-    const char* kVertexSource = R"(#version 460
-layout(location = 0) in vec3 aPos;
-out vec3 vPos;
-out vec2 vUv;
-void main() {
-    vPos = aPos;
-    vUv = aPos.xy * 0.5 + 0.5;
-    gl_Position = vec4(aPos, 1.0);
-}
-)";
-
-    // Shaped after gl3cTextureSwizzleTests.cpp's template: a sampler of one type, one
-    // TEXTURE_ACCESS, one CHANNEL, and an output whose BASIC_TYPE is the only thing that
-    // varies within a case. Padded with enough real arithmetic that the translation chain
-    // is doing work rather than measuring fixed overheads.
-    // `padLines` = 0 is the honest CTS size: gl3cTextureSwizzleTests' smoke template is a
-    // handful of lines, and that is the workload the memo exists for. The padded variant is
-    // kept alongside it because a shaderpack stage is orders of magnitude bigger, and the
-    // two bracket the ratio the cache is worth in practice.
-    String SwizzleLikeFragment(const String& prefix, const int padLines) {
-        String source = "#version 460\n";
-        source += "in vec3 vPos;\n";
-        source += "in vec2 vUv;\n";
-        source += "layout(location = 0) out " + prefix + "vec4 fragColor;\n";
-        source += "uniform sampler2D uTex;\n";
-        source += "uniform vec4 uTint;\n";
-        source += "uniform mat4 uModel;\n";
-        source += "uniform float uArr[8];\n";
-        source += "void main() {\n";
-        source += "    vec4 s = texture(uTex, vUv);\n";
-        source += "    float acc = s.r;\n";
-        for (int i = 0; i < padLines; ++i) {
-            source += "    acc = acc * 1.0001 + sin(acc + " + std::to_string(i) + ".0) * cos(acc);\n";
-        }
-        source += "    for (int i = 0; i < 8; ++i) acc += uArr[i];\n";
-        source += "    vec4 p = uModel * vec4(vPos, 1.0);\n";
-        source += "    fragColor = " + prefix + "vec4((s + uTint) * acc + p);\n";
-        source += "}\n";
-        return source;
-    }
-
-    class CacheModeScope {
-    public:
-        explicit CacheModeScope(const Bool enabled)
-            : m_saved(MG_Config::Features.ShaderTranslationCache) {
-            MG_Config::Features.ShaderTranslationCache =
-                enabled ? MG_Config::QuirkOverride::ForceOn : MG_Config::QuirkOverride::ForceOff;
-        }
-        ~CacheModeScope() { MG_Config::Features.ShaderTranslationCache = m_saved; }
-
-    private:
-        const MG_Config::QuirkOverride m_saved;
-    };
-
-    class SyncCompileScope {
-    public:
-        SyncCompileScope() : m_saved(MG_Config::Features.AsyncShaderCompile) {
-            MG_Config::Features.AsyncShaderCompile = MG_Config::QuirkOverride::ForceOff;
-        }
-        ~SyncCompileScope() { MG_Config::Features.AsyncShaderCompile = m_saved; }
-
-    private:
-        const MG_Config::QuirkOverride m_saved;
-    };
-
-    // One program, built the way the CTS builds one: fresh shader objects every time.
-    void LinkOneProgram(const String& vertexSource, const String& fragmentSource) {
-        using namespace MG_Impl::GLImpl;
-        const GLuint vs = CreateShader(GL_VERTEX_SHADER);
-        const char* vsText = vertexSource.c_str();
-        ShaderSource(vs, 1, &vsText, nullptr);
-        CompileShader(vs);
-
-        const GLuint fs = CreateShader(GL_FRAGMENT_SHADER);
-        const char* fsText = fragmentSource.c_str();
-        ShaderSource(fs, 1, &fsText, nullptr);
-        CompileShader(fs);
-
-        const GLuint program = CreateProgram();
-        AttachShader(program, vs);
-        AttachShader(program, fs);
-        LinkProgram(program);
-        benchmark::DoNotOptimize(program);
-
-        DeleteProgram(program);
-        DeleteShader(vs);
-        DeleteShader(fs);
-    }
-
-    Vector<Uint32> BuildSanitizedFragmentSpirv(const String& fragmentSource) {
-        ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = fragmentSource};
-        auto shader = ShaderCompiler::CompileShader(attrib);
-        if (!shader) return {};
-        ProgramAttrib programAttrib{.shaders = {shader.value()}};
-        auto program = ShaderCompiler::LinkProgram(programAttrib);
-        if (!program) return {};
-        ProgramBinaryAttrib binaryAttrib{.shaderTypes = {GL_FRAGMENT_SHADER}, .program = *program.value()};
-        auto binary = ShaderCompiler::GetSpirvBinaryFromProgram(binaryAttrib);
-        if (!binary || binary->empty()) return {};
-        Vector<Uint32> sanitized;
-        if (!ShaderCompiler::SanitizeAndOptimizeBinary(binary->front(), sanitized)) return {};
-        return sanitized;
-    }
-
-    // The driver-independent part of BackendProgramObjectImpl::TranspileSpirvToEssl, in the
-    // same order. What is missing is only the capability-gated passes (viewport lowering,
-    // multisample clamping, noperspective emulation, the image-format bake), which cannot
-    // fire without a live ES driver to arm them.
-    Bool TranspileLikeDirectGles(const Vector<Uint32>& spirv, const Uint esslVersion, String& outEssl) {
-        Vector<Uint32> a;
-        const Vector<Uint32>* effective = &spirv;
-        if (ShaderCompiler::StripUboMemberRelaxedPrecisionForEssl(*effective, a, false) && !a.empty()) {
-            effective = &a;
-        }
-        Vector<Uint32> b;
-        if (ShaderCompiler::LowerRectImages(*effective, b, false) && !b.empty()) effective = &b;
-        Vector<Uint32> c;
-        if (ShaderCompiler::Lower1DArrayImagesForEssl(*effective, c, false) && !c.empty()) effective = &c;
-        Vector<Uint32> d;
-        if (ShaderCompiler::LegalizeFragmentOutputIndexingForEssl(*effective, d, false) && !d.empty()) {
-            effective = &d;
-        }
-
-        SpvcSession session(*effective, SessionUsageBit::Transpile);
-        spvc_compiler_options options;
-        if (session.CreateOptions(&options) != SPVC_SUCCESS) return false;
-        spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_GLSL_VERSION, esslVersion);
-        spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_ES, SPVC_TRUE);
-        spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_VULKAN_SEMANTICS, SPVC_FALSE);
-        session.SetOptions(options);
-        const char* result = nullptr;
-        session.Compile(&result);
-        if (!result) return false;
-        outEssl = result;
-        return true;
-    }
-
-    EsslTranslationKeyInputs EsslInputsFor(const Vector<Uint32>& spirv) {
-        EsslTranslationKeyInputs inputs;
-        inputs.spirv = &spirv;
-        inputs.shaderType = GL_FRAGMENT_SHADER;
-        inputs.maxColorTextureSamples = 4;
-        inputs.maxIntegerSamples = 1;
-        inputs.maxDepthTextureSamples = 4;
-        inputs.advertisedMaxSamples = 4;
-        inputs.esslVersion = 320;
-        return inputs;
-    }
-} // namespace
-
-// ---------------------------------------------------------------------------------------
-// L1, in situ: the full glCompileShader + glLinkProgram path for a repeated program.
-// ---------------------------------------------------------------------------------------
-// Arg(0) = the CTS smoke size; Arg(120) = a heavy stage, bracketing the ratio.
-static void BM_ProgramLink_CacheOff(benchmark::State& state) {
-    MobileGL::Initialize();
-    const SyncCompileScope sync;
-    const CacheModeScope cache(false);
-    const String vs = kVertexSource;
-    const String fs = SwizzleLikeFragment("", static_cast<int>(state.range(0)));
-    for (auto _ : state) {
-        LinkOneProgram(vs, fs);
-    }
-    state.SetLabel("MOBILEGL_SHADER_CACHE=0");
-}
-BENCHMARK(BM_ProgramLink_CacheOff)->Arg(0)->Arg(120)->Unit(benchmark::kMicrosecond);
-
-static void BM_ProgramLink_CacheOn(benchmark::State& state) {
-    MobileGL::Initialize();
-    const SyncCompileScope sync;
-    const CacheModeScope cache(true);
-    const String vs = kVertexSource;
-    const String fs = SwizzleLikeFragment("", static_cast<int>(state.range(0)));
-    LinkOneProgram(vs, fs); // prime, so the measured loop is the steady state
-    const TranslationCacheStats before = MG_State::GLState::GetProgramTranslationCache().Stats();
-    const TranslationCacheStats parseBefore = GetShaderParseVerdictCache().Stats();
-    for (auto _ : state) {
-        LinkOneProgram(vs, fs);
-    }
-    const TranslationCacheStats stats = MG_State::GLState::GetProgramTranslationCache().Stats();
-    const TranslationCacheStats parseStats = GetShaderParseVerdictCache().Stats();
-    state.counters["L1_hits"] = static_cast<double>(stats.hits - before.hits);
-    state.counters["L1_misses"] = static_cast<double>(stats.misses - before.misses);
-    // Two stages per iteration, so a clean run shows L1c_hits == 2 * iterations and zero
-    // misses: every glCompileShader in the loop skipped its parse.
-    state.counters["L1c_hits"] = static_cast<double>(parseStats.hits - parseBefore.hits);
-    state.counters["L1c_misses"] = static_cast<double>(parseStats.misses - parseBefore.misses);
-}
-BENCHMARK(BM_ProgramLink_CacheOn)->Arg(0)->Arg(120)->Unit(benchmark::kMicrosecond);
-
-// ---------------------------------------------------------------------------------------
-// L1, the shape the memo actually exists for: MANY PROGRAMS OUT OF THE SAME SHADERS.
-//
-// The pair above deletes its shader objects every iteration, which forces a fresh glslang
-// parse per iteration no matter what the link does - glCompileShader parses, and that is a
-// DIFFERENT entry point from the one L1 memoizes. It is a real workload (what an application
-// that never reuses a shader object pays) but it is the pessimistic one, and the residual it
-// leaves is the parse, not the link.
-//
-// This pair keeps the shader objects alive, so the parses happen once before the measured
-// loop and the L1 hit then skips the link, mapIO, the SPIR-V, the reflection and the routing
-// outright.
-//
-// SINCE L1c THIS IS THE CONTROL, NOT THE TARGET. Nothing inside the measured loop calls
-// glCompileShader, so L1c cannot fire here at all - which is exactly what makes the pair
-// useful: it is the shape that says whether the compile-side memo has slowed the LINK path
-// down. Its numbers should be indistinguishable from the pre-L1c ones.
-// ---------------------------------------------------------------------------------------
-namespace {
-    struct SharedShaders {
-        GLuint vs = 0;
-        GLuint fs = 0;
-    };
-
-    SharedShaders MakeSharedShaders(const String& vertexSource, const String& fragmentSource) {
-        using namespace MG_Impl::GLImpl;
-        SharedShaders shaders;
-        shaders.vs = CreateShader(GL_VERTEX_SHADER);
-        const char* vsText = vertexSource.c_str();
-        ShaderSource(shaders.vs, 1, &vsText, nullptr);
-        CompileShader(shaders.vs);
-        shaders.fs = CreateShader(GL_FRAGMENT_SHADER);
-        const char* fsText = fragmentSource.c_str();
-        ShaderSource(shaders.fs, 1, &fsText, nullptr);
-        CompileShader(shaders.fs);
-        return shaders;
-    }
-
-    void LinkFromSharedShaders(const SharedShaders& shaders) {
-        using namespace MG_Impl::GLImpl;
-        const GLuint program = CreateProgram();
-        AttachShader(program, shaders.vs);
-        AttachShader(program, shaders.fs);
-        LinkProgram(program);
-        benchmark::DoNotOptimize(program);
-        DeleteProgram(program);
-    }
-} // namespace
-
-static void BM_SharedShaderLink_CacheOff(benchmark::State& state) {
-    MobileGL::Initialize();
-    const SyncCompileScope sync;
-    const CacheModeScope cache(false);
-    const SharedShaders shaders =
-        MakeSharedShaders(kVertexSource, SwizzleLikeFragment("", static_cast<int>(state.range(0))));
-    for (auto _ : state) {
-        LinkFromSharedShaders(shaders);
-    }
-    state.SetLabel("MOBILEGL_SHADER_CACHE=0");
-}
-BENCHMARK(BM_SharedShaderLink_CacheOff)->Arg(0)->Arg(120)->Unit(benchmark::kMicrosecond);
-
-static void BM_SharedShaderLink_CacheOn(benchmark::State& state) {
-    MobileGL::Initialize();
-    const SyncCompileScope sync;
-    const CacheModeScope cache(true);
-    const SharedShaders shaders =
-        MakeSharedShaders(kVertexSource, SwizzleLikeFragment("", static_cast<int>(state.range(0))));
-    LinkFromSharedShaders(shaders); // prime, so the measured loop is the steady state
-    const TranslationCacheStats before = MG_State::GLState::GetProgramTranslationCache().Stats();
-    for (auto _ : state) {
-        LinkFromSharedShaders(shaders);
-    }
-    const TranslationCacheStats stats = MG_State::GLState::GetProgramTranslationCache().Stats();
-    state.counters["L1_hits"] = static_cast<double>(stats.hits - before.hits);
-    state.counters["L1_misses"] = static_cast<double>(stats.misses - before.misses);
-}
-BENCHMARK(BM_SharedShaderLink_CacheOn)->Arg(0)->Arg(120)->Unit(benchmark::kMicrosecond);
-
-// ---------------------------------------------------------------------------------------
-// L2, component: the DirectGLES SPIR-V pass chain plus SPIRV-Cross for one stage.
-// ---------------------------------------------------------------------------------------
-static void BM_EsslTranspile_CacheOff(benchmark::State& state) {
-    MobileGL::Initialize();
-    const Vector<Uint32> spirv =
-        BuildSanitizedFragmentSpirv(SwizzleLikeFragment("", static_cast<int>(state.range(0))));
-    if (spirv.empty()) {
-        state.SkipWithError("could not build the fragment module");
-        return;
-    }
-    String essl;
-    for (auto _ : state) {
-        if (!TranspileLikeDirectGles(spirv, 320, essl)) {
-            state.SkipWithError("transpile failed");
-            break;
-        }
-        benchmark::DoNotOptimize(essl.data());
-    }
-    state.SetLabel("MOBILEGL_SHADER_CACHE=0");
-}
-BENCHMARK(BM_EsslTranspile_CacheOff)->Arg(0)->Arg(120)->Unit(benchmark::kMicrosecond);
-
-static void BM_EsslTranspile_CacheOn(benchmark::State& state) {
-    MobileGL::Initialize();
-    const Vector<Uint32> spirv =
-        BuildSanitizedFragmentSpirv(SwizzleLikeFragment("", static_cast<int>(state.range(0))));
-    if (spirv.empty()) {
-        state.SkipWithError("could not build the fragment module");
-        return;
-    }
-    BoundedTranslationCache<EsslTranslationResult> cache("bench L2", 64, 8u << 20);
-    const EsslTranslationKeyInputs inputs = EsslInputsFor(spirv);
-    for (auto _ : state) {
-        const TranslationCacheKey key = BuildEsslTranslationKey(inputs);
-        EsslTranslationResultPtr hit = cache.Find(key);
-        if (!hit) {
-            auto payload = MakeShared<EsslTranslationResult>();
-            if (!TranspileLikeDirectGles(spirv, inputs.esslVersion, payload->essl)) {
-                state.SkipWithError("transpile failed");
-                break;
-            }
-            cache.Insert(key, EsslTranslationResultPtr(payload), EsslTranslationResultBytes(*payload));
-            hit = payload;
-        }
-        benchmark::DoNotOptimize(hit->essl.data());
-    }
-    const TranslationCacheStats stats = cache.Stats();
-    state.counters["L2_hits"] = static_cast<double>(stats.hits);
-    state.counters["L2_misses"] = static_cast<double>(stats.misses);
-}
-BENCHMARK(BM_EsslTranspile_CacheOn)->Arg(0)->Arg(120)->Unit(benchmark::kMicrosecond);
-
-// ---------------------------------------------------------------------------------------
-// L1c, the shape where it could LOSE rather than win: the DEFERRED PARSE.
-// ---------------------------------------------------------------------------------------
-// A stage whose compile hits L1c holds no AST, so if the program-level key then MISSES, the
-// parse it skipped has to happen anyway - inside the link, via ClaimParsedShader. The parse
-// is moved, not removed, and this pair is what says whether moving it costs anything.
-//
-// The shape forces exactly that, every iteration: one CONSTANT vertex source (hits L1c after
-// the first iteration) linked against a FRESH fragment source each time (misses L1c, and
-// makes the program key miss too). So:
-//
-//   cache off - two parses at glCompileShader, then the link.
-//   cache on  - one parse at glCompileShader (the fragment), one deferred parse inside the
-//               link (the vertex), then the link.
-//
-// The parse count is identical, so these two should land within noise of each other. If the
-// On arm is materially SLOWER, L1c is charging for something - the per-compile key build and
-// hash over the full preprocessed source, or the loss of the claim-CAS reuse - and that cost
-// shows up here and nowhere else.
-//
-// The distinct fragment sources also churn both front-end levels through their FIFO caps,
-// which is the eviction behaviour a real shaderpack load produces; over a long run the
-// constant vertex entry is occasionally evicted by that churn and re-inserted, so the L1c
-// hit rate reported below is high but not exactly 1.0 per iteration.
-namespace {
-    String UniqueFragmentSource(const Uint64 serial, const int padLines) {
-        return SwizzleLikeFragment("", padLines) +
-               "\n// unique-" + std::to_string(serial) + "\n";
-    }
-} // namespace
-
-static void BM_DeferredParseLink_CacheOff(benchmark::State& state) {
-    MobileGL::Initialize();
-    const SyncCompileScope sync;
-    const CacheModeScope cache(false);
-    const String vs = kVertexSource;
-    Uint64 serial = 0;
-    for (auto _ : state) {
-        LinkOneProgram(vs, UniqueFragmentSource(serial++, static_cast<int>(state.range(0))));
-    }
-    state.SetLabel("MOBILEGL_SHADER_CACHE=0");
-}
-BENCHMARK(BM_DeferredParseLink_CacheOff)->Arg(0)->Arg(120)->Unit(benchmark::kMicrosecond);
-
-static void BM_DeferredParseLink_CacheOn(benchmark::State& state) {
-    MobileGL::Initialize();
-    const SyncCompileScope sync;
-    const CacheModeScope cache(true);
-    const String vs = kVertexSource;
-    Uint64 serial = 0;
-    LinkOneProgram(vs, UniqueFragmentSource(~0ull, static_cast<int>(state.range(0)))); // prime the vertex entry
-    const TranslationCacheStats before = MG_State::GLState::GetProgramTranslationCache().Stats();
-    const TranslationCacheStats parseBefore = GetShaderParseVerdictCache().Stats();
-    for (auto _ : state) {
-        LinkOneProgram(vs, UniqueFragmentSource(serial++, static_cast<int>(state.range(0))));
-    }
-    const TranslationCacheStats stats = MG_State::GLState::GetProgramTranslationCache().Stats();
-    const TranslationCacheStats parseStats = GetShaderParseVerdictCache().Stats();
-    // Expected shape: L1 all misses (every program is new), L1c one hit (vertex) and one miss
-    // (fragment) per iteration.
-    state.counters["L1_hits"] = static_cast<double>(stats.hits - before.hits);
-    state.counters["L1_misses"] = static_cast<double>(stats.misses - before.misses);
-    state.counters["L1c_hits"] = static_cast<double>(parseStats.hits - parseBefore.hits);
-    state.counters["L1c_misses"] = static_cast<double>(parseStats.misses - parseBefore.misses);
-}
-BENCHMARK(BM_DeferredParseLink_CacheOn)->Arg(0)->Arg(120)->Unit(benchmark::kMicrosecond);
-
-BENCHMARK_MAIN();

MobileGL/MG_Benchmark/Transpile/CMakeLists.txt

@@ -1,20 +0,0 @@
-cmake_minimum_required(VERSION 3.24)
-
-# Deliberately NOT a google-benchmark target: the interesting quantity is a per-stage
-# breakdown of one program build, which needs its own clock around sub-steps that share
-# set-up, and a plain main() keeps the output a table this can be read straight out of.
-add_executable(
-        TranspileProfile
-        TranspileProfile.cpp
-)
-
-target_include_directories(TranspileProfile PRIVATE
-        ${MGL_ROOT}/include
-        ${MGL_ROOT}/MobileGL
-        ${MGL_ROOT}/3rdparty/SPIRV-Reflect
-)
-
-target_link_libraries(
-        TranspileProfile PRIVATE
-        ${LINK_LIBRARIES}
-)

MobileGL/MG_Impl/EGLImpl/EGLImpl.cpp

@@ -21,7 +21,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
 
         EGLStateContext* GetState() {
             if (!MG_State::pEGLContext) {
-                MGLOG_E_ONCE("pEGLContext is null. MG_State may not be initialized.");
+                MGLOG_E("pEGLContext is null. MG_State may not be initialized.");
             }
             return MG_State::pEGLContext.get();
         }
@@ -146,7 +146,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
 
         auto* backendObject = GetBackendObject(state);
         if (!backendObject) {
-            MGLOG_E_ONCE("activeBackendObject not initialized!");
+            MGLOG_E("activeBackendObject not initialized!");
             state->DestroySurface(dpy, surface);
             return EGL_NO_SURFACE;
         }
@@ -172,11 +172,11 @@ namespace MobileGL::MG_Impl::EGLImpl {
 
         auto* backendObject = GetBackendObject(state);
         if (!backendObject) {
-            MGLOG_E_ONCE("activeBackendObject not initialized!");
+            MGLOG_E("activeBackendObject not initialized!");
             return EGL_FALSE;
         }
         if (!backendObject->SwapEGLBuffers(dpy, draw)) {
-            MGLOG_E_ONCE("eglSwapBuffers failed on thread=%s dpy=%p draw=%p", CurrentThreadIdString().c_str(), dpy, draw);
+            MGLOG_E("eglSwapBuffers failed on thread=%s dpy=%p draw=%p", CurrentThreadIdString().c_str(), dpy, draw);
             state->SetError(EGL_BAD_SURFACE);
             return EGL_FALSE;
         }
@@ -211,7 +211,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
 
         auto* backendObject = GetBackendObject(state);
         if (!backendObject) {
-            MGLOG_E_ONCE("activeBackendObject not initialized!");
+            MGLOG_E("activeBackendObject not initialized!");
             return EGL_FALSE;
         }
         if (!backendObject->InitializeEGLDisplay(dpy, major, minor)) {
@@ -265,7 +265,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
         if (releaseCurrentRequest) {
             if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) {
                 if (!backendObject->MakeEGLCurrent(dpy, draw, read, ctx)) {
-                    MGLOG_E_ONCE("eglMakeCurrent release failed in backend thread=%s", threadId.c_str());
+                    MGLOG_E("eglMakeCurrent release failed in backend thread=%s", threadId.c_str());
                     state->MakeCurrent(oldDisplay, oldDraw, oldRead, oldContext);
                     state->SetError(EGL_BAD_ACCESS);
                     return EGL_FALSE;
@@ -277,12 +277,12 @@ namespace MobileGL::MG_Impl::EGLImpl {
 
         auto* backendObject = GetBackendObject(state);
         if (!backendObject) {
-            MGLOG_E_ONCE("activeBackendObject not initialized!");
+            MGLOG_E("activeBackendObject not initialized!");
             state->MakeCurrent(oldDisplay, oldDraw, oldRead, oldContext);
             return EGL_FALSE;
         }
         if (!backendObject->MakeEGLCurrent(dpy, draw, read, ctx)) {
-            MGLOG_E_ONCE("eglMakeCurrent backend attach failed thread=%s dpy=%p draw=%p read=%p ctx=%p", threadId.c_str(),
+            MGLOG_E("eglMakeCurrent backend attach failed thread=%s dpy=%p draw=%p read=%p ctx=%p", threadId.c_str(),
                     dpy, draw, read, ctx);
             state->SetError(EGL_BAD_ACCESS);
             state->MakeCurrent(oldDisplay, oldDraw, oldRead, oldContext);
@@ -703,7 +703,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
 
         auto* backendObject = GetBackendObject(state);
         if (!backendObject) {
-            MGLOG_E_ONCE("activeBackendObject not initialized!");
+            MGLOG_E("activeBackendObject not initialized!");
             state->DestroySurface(dpy, surface);
             return EGL_NO_SURFACE;
         }
@@ -726,7 +726,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
         }
         auto* backendObject = GetBackendObject(state);
         if (!backendObject) {
-            MGLOG_E_ONCE("activeBackendObject not initialized!");
+            MGLOG_E("activeBackendObject not initialized!");
             return EGL_FALSE;
         }
         width = std::max<EGLint>(width, 1);
@@ -764,7 +764,7 @@ namespace MobileGL::MG_Impl::EGLImpl {
         MGLOG_D("eglGetProcAddress(%s)", name);
         void* proc = MG_Impl::GetProcAddress(name);
         if (!proc) {
-            MGLOG_D("Failed to get function: %s", name);
+            MGLOG_W("Failed to get function: %s", name);
             return nullptr;
         }
         return (__eglMustCastToProperFunctionPointerType)proc;

MobileGL/MG_Impl/GLImpl/Buffer/GL_Buffer.cpp

@@ -18,7 +18,6 @@
 #include <MG_Util/Converters/GLToStr/GLEnumConverter.h>
 #include <MG_Util/Converters/GLToMG/BufferEnumConverter.h>
 #include <MG_Util/Converters/MGToGL/BufferEnumConverter.h>
-#include <MG_Util/Texture/PixelStoreProcessor.h>
 
 namespace MobileGL::MG_Impl::GLImpl {
     namespace {
@@ -32,8 +31,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             NamedBufferData,
             NamedBufferSubData,
             CopyNamedBufferSubData,
-            ClearBufferData,
-            ClearBufferSubData,
             ClearNamedBufferData,
             ClearNamedBufferSubData,
             MapBufferRange,
@@ -68,10 +65,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                 return "NamedBufferSubData";
             case BufferOp::CopyNamedBufferSubData:
                 return "CopyNamedBufferSubData";
-            case BufferOp::ClearBufferData:
-                return "ClearBufferData";
-            case BufferOp::ClearBufferSubData:
-                return "ClearBufferSubData";
             case BufferOp::ClearNamedBufferData:
                 return "ClearNamedBufferData";
             case BufferOp::ClearNamedBufferSubData:
@@ -150,6 +143,16 @@ namespace MobileGL::MG_Impl::GLImpl {
                 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;
         }
 
@@ -191,59 +194,27 @@ namespace MobileGL::MG_Impl::GLImpl {
             return true;
         }
 
-        Bool BuildClearPattern(GLenum internalformat, GLenum format, GLenum type, const void* data,
-                               SizeT patternSize, BufferOp op, Vector<Uint8>& pattern) {
-            const TextureInternalFormat internal = MG_Util::ConvertGLEnumToTextureInternalFormat(internalformat);
-            const TextureInputFormat inputFormat = MG_Util::ConvertGLEnumToTextureInputFormat(format);
-            const TexturePixelDataType inputType = MG_Util::ConvertGLEnumToTexturePixelDataType(type);
-
-            Vector<Uint8> zeroInput;
-            const void* inputPixel = data;
-            if (inputPixel == nullptr) {
-                const SizeT inputSize = MG_Util::GetInputBytesPerPixel(inputFormat, inputType);
-                if (inputSize == 0) {
-                    MG_State::pGLContext->RecordError(
-                        ErrorCode::InvalidValue,
-                        MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", GetBufferOpName(op),
-                                                     "format and type do not describe a source pixel."));
-                    return false;
-                }
-                zeroInput.resize(inputSize);
-                inputPixel = zeroInput.data();
-            }
-
-            if (!MG_Util::PixelStoreProcessor::ConvertOnePixelToInternal(
-                    internal, inputFormat, inputType, inputPixel, pattern)) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", GetBufferOpName(op),
-                        std::format("Cannot convert one ({}, {}) pixel into internalformat 0x{:X}.",
-                                    MG_Util::ConvertGLEnumToString(format), MG_Util::ConvertGLEnumToString(type),
-                                    internalformat)));
-                return false;
-            }
-
-            if (data == nullptr) {
-                // GL defines a null clear value as all zero bits in the destination store, while
-                // retaining the format/type validation above.
-                pattern.assign(patternSize, 0);
-            }
-            return true;
-        }
-
-        void ClearBufferRange_State(const SharedPtr<MG_State::GLState::BufferObject>& bufferObject,
-                                    GLenum internalformat, GLintptr offset, GLsizeiptr size,
-                                    GLenum format, GLenum type, const void* data, BufferOp op) {
+        void ClearNamedBufferRange_State(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size,
+                                         GLenum format, GLenum type, const void* data, BufferOp op) {
             const SizeT patternSize = GetClearPatternSize(internalformat, format, type, op);
             if (patternSize == 0) return;
+
+            auto bufferObject = GetNamedBufferObject(buffer, op);
+            if (!bufferObject) return;
             if (!ValidateBufferClearRange(bufferObject, offset, size, patternSize, op)) return;
             if (size == 0) return;
 
-            Vector<Uint8> pattern;
-            if (!BuildClearPattern(internalformat, format, type, data, patternSize, op, pattern)) return;
-            bufferObject->FillSubData({pattern.data(), pattern.size()}, static_cast<SizeT>(offset),
-                                      static_cast<SizeT>(size));
+            Vector<Uint8> clearData(static_cast<SizeT>(size));
+            if (data) {
+                const auto* pattern = static_cast<const Uint8*>(data);
+                for (SizeT at = 0; at < clearData.size(); at += patternSize) {
+                    Memcpy(clearData.data() + at, pattern, patternSize);
+                }
+            } else {
+                Memset(clearData.data(), 0, clearData.size());
+            }
+
+            bufferObject->UploadSubData({clearData.data(), clearData.size()}, static_cast<SizeT>(offset));
         }
 
         auto& GetBufferBindingSlot(BufferTarget target) {
@@ -1226,34 +1197,17 @@ namespace MobileGL::MG_Impl::GLImpl {
                                         static_cast<SizeT>(writeOffset), static_cast<SizeT>(size));
     }
 
-    void ClearBufferData_State(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void* data) {
-        auto bufferObject = GetBoundBufferObject(target, BufferOp::ClearBufferData);
-        if (!bufferObject) return;
-        ClearBufferRange_State(bufferObject, internalformat, 0, static_cast<GLsizeiptr>(bufferObject->GetSize()), format,
-                               type, data, BufferOp::ClearBufferData);
-    }
-
-    void ClearBufferSubData_State(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size,
-                                  GLenum format, GLenum type, const void* data) {
-        auto bufferObject = GetBoundBufferObject(target, BufferOp::ClearBufferSubData);
-        if (!bufferObject) return;
-        ClearBufferRange_State(bufferObject, internalformat, offset, size, format, type, data,
-                               BufferOp::ClearBufferSubData);
-    }
-
     void ClearNamedBufferData_State(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void* data) {
         auto bufferObject = GetNamedBufferObject(buffer, BufferOp::ClearNamedBufferData);
         if (!bufferObject) return;
-        ClearBufferRange_State(bufferObject, internalformat, 0, static_cast<GLsizeiptr>(bufferObject->GetSize()), format,
-                               type, data, BufferOp::ClearNamedBufferData);
+        ClearNamedBufferRange_State(buffer, internalformat, 0, static_cast<GLsizeiptr>(bufferObject->GetSize()), format,
+                                    type, data, BufferOp::ClearNamedBufferData);
     }
 
     void ClearNamedBufferSubData_State(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size,
                                        GLenum format, GLenum type, const void* data) {
-        auto bufferObject = GetNamedBufferObject(buffer, BufferOp::ClearNamedBufferSubData);
-        if (!bufferObject) return;
-        ClearBufferRange_State(bufferObject, internalformat, offset, size, format, type, data,
-                               BufferOp::ClearNamedBufferSubData);
+        ClearNamedBufferRange_State(buffer, internalformat, offset, size, format, type, data,
+                                    BufferOp::ClearNamedBufferSubData);
     }
 
     void* MapNamedBuffer_State(GLuint buffer, GLenum access) {
@@ -1537,8 +1491,8 @@ namespace MobileGL::MG_Impl::GLImpl {
     // 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, Bool hasBuffer = true) {
-        if (hasBuffer && size <= 0) {
+                                                 const char* funcName) {
+        if (size <= 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
                 MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", funcName,
@@ -1573,27 +1527,16 @@ namespace MobileGL::MG_Impl::GLImpl {
                 return false;
             }
         }
-        // GL 4.6 core 6.1.1 constrains the OFFSET to a multiple of four for both
-        // TRANSFORM_FEEDBACK_BUFFER and ATOMIC_COUNTER_BUFFER (the atomic-counter one has no
-        // queryable alignment pname, which is why it was missing here), and the SIZE only for
-        // transform feedback, whose capture is written in whole 32-bit components. Extending the
-        // size rule to atomic counters as well breaks a legal bind: the conformance suite splits
-        // MAX_ATOMIC_COUNTER_BUFFER_SIZE evenly across the binding points and that quotient is
-        // not required to land on four.
-        if ((target == GL_TRANSFORM_FEEDBACK_BUFFER || target == GL_ATOMIC_COUNTER_BUFFER) && (offset % 4) != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", funcName,
-                                             std::format("offset ({}) must be a multiple of 4 for {}.", offset,
-                                                         MG_Util::ConvertGLEnumToString(target))));
-            return false;
-        }
-        if (target == GL_TRANSFORM_FEEDBACK_BUFFER && hasBuffer && (size % 4) != 0) {
+        // 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("size ({}) must be a multiple of 4 for GL_TRANSFORM_FEEDBACK_BUFFER.", size)));
+                    std::format("offset ({}) and size ({}) must both be multiples of 4 for "
+                                "GL_TRANSFORM_FEEDBACK_BUFFER.",
+                                offset, size)));
             return false;
         }
         return true;
@@ -1605,12 +1548,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
         if (!BufferImpl::ValidateBufferBindingPointTarget(bufferTarget)) return;
         if (!BufferImpl::ValidateBufferBindingPointIndex(bufferTarget, index)) return;
-        // The target's alignment rules are a property of the BINDING POINT, not of the buffer,
-        // so they apply even when buffer is zero - which is exactly how
-        // KHR-GL43.shader_storage_buffer_object.negative-api-bind probes the SSBO alignment
-        // (glBindBufferRange(SHADER_STORAGE_BUFFER, 0, 0, alignment - 1, 0)). Only the size
-        // rules need a buffer, since buffer 0 detaches the binding point and ignores size.
-        if (!ValidateBufferRangeOffsetAndSize(target, offset, size, __func__, /*hasBuffer: */ buffer != 0)) return;
+        if (buffer != 0 && !ValidateBufferRangeOffsetAndSize(target, offset, size, __func__)) return;
         if (bufferTarget == BufferTarget::TransformFeedback && MG_State::pGLContext->IsTransformFeedbackActive()) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
@@ -1708,15 +1646,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         CopyNamedBufferSubData_State(readBuffer, writeBuffer, readOffset, writeOffset, size);
     }
 
-    void ClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void* data) {
-        ClearBufferData_State(target, internalformat, format, type, data);
-    }
-
-    void ClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format,
-                            GLenum type, const void* data) {
-        ClearBufferSubData_State(target, internalformat, offset, size, format, type, data);
-    }
-
     void ClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void* data) {
         ClearNamedBufferData_State(buffer, internalformat, format, type, data);
     }
@@ -1803,30 +1732,10 @@ namespace MobileGL::MG_Impl::GLImpl {
         return BufferImpl::ValidateBufferBindingPointRange(bufferTarget, first, count, funcName);
     }
 
-    // ARB_multi_bind states the equivalence to a loop of single binds "except that ... buffers
-    // will not be created if they do not exist": glBindBuffer instantiates a name glGenBuffers
-    // merely reserved, glBindBuffers* must refuse it and raise INVALID_OPERATION instead
-    // (KHR-GL44.multi_bind.errors_bind_buffers).
-    //
-    // Deliberately PER ELEMENT, not all-or-nothing: the equivalence the extension defines is a
-    // loop, so a bad entry costs its own binding point and nothing else. Rejecting the whole
-    // call instead cost multi_bind.functional_bind_buffers_base its bindings.
-    static Bool IsExistingBufferForMultiBind(GLuint buffer, GLsizei index, const char* funcName) {
-        if (buffer == 0 || MG_State::pGLContext->ValidateBufferObject(buffer)) return true;
-        MG_State::pGLContext->RecordError(
-            ErrorCode::InvalidOperation,
-            MakeUnique<GenericErrorInfo>(
-                "MG_Impl/GLImpl", funcName,
-                std::format("buffers[{}] ({}) is not the name of an existing buffer object.", index, buffer)));
-        return false;
-    }
-
     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) {
-            const GLuint buffer = buffers ? buffers[i] : 0;
-            if (!IsExistingBufferForMultiBind(buffer, i, __func__)) continue;
-            BindBufferBase_State(target, first + i, buffer);
+            BindBufferBase_State(target, first + i, buffers ? buffers[i] : 0);
         }
     }
 
@@ -1840,7 +1749,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                           const GLsizeiptr* sizes) {
         if (!ValidateMultiBindBufferRange(target, first, count, __func__)) return;
         for (GLsizei i = 0; i < count; ++i) {
-            if (buffers && !IsExistingBufferForMultiBind(buffers[i], i, __func__)) continue;
             if (!buffers || buffers[i] == 0) {
                 BindBufferBase_State(target, first + i, 0);
             } else {

MobileGL/MG_Impl/GLImpl/Buffer/GL_Buffer.h

@@ -27,9 +27,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     void NamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data);
     void CopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset,
                                 GLsizeiptr size);
-    void ClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void* data);
-    void ClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format,
-                            GLenum type, const void* data);
     void ClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void* data);
     void ClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format,
                                  GLenum type, const void* data);

MobileGL/MG_Impl/GLImpl/Buffer/Validators.cpp

@@ -13,7 +13,6 @@
 #include <MG_Util/Converters/GLToStr/GLEnumConverter.h>
 #include <MG_Util/Converters/MGToGL/BufferEnumConverter.h>
 #include <MG_Util/Converters/MGToStr/BufferEnumConverter.h>
-#include <MG_Util/ShaderTranspiler/Types.h>
 
 namespace MobileGL::MG_Impl::GLImpl::BufferImpl {
     Bool ValidateBufferTarget(BufferTarget target) {
@@ -68,13 +67,6 @@ namespace MobileGL::MG_Impl::GLImpl::BufferImpl {
                 // binding points in GL 3.3 (no ARB_transform_feedback3).
                 pointCount = std::min<SizeT>(pointCount, 4);
             }
-            if (target == BufferTarget::AtomicCounter) {
-                // GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, which is NOT the state layer's array
-                // size: a counter buffer reaches a shader only as a lowered storage block, so the
-                // reserved range is the ceiling, and glGetIntegerv advertises the same number.
-                pointCount = std::min<SizeT>(
-                    pointCount, static_cast<SizeT>(MG_Util::ShaderTranspiler::MAX_ATOMIC_COUNTER_BUFFER_BINDINGS));
-            }
             return pointCount;
         }
     } // namespace

MobileGL/MG_Impl/GLImpl/Debug/GL_Debug.cpp

@@ -1,271 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/GLImpl/Debug/GL_Debug.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_Debug.h"
-
-#include <cstring>
-
-#include <MG_State/GLState/Core.h>
-#include <MG_State/GLState/ErrorState/Error.h>
-#include <MG_Impl/GLImpl/Query/GL_Query.h>
-#include <MG_Util/Converters/GLToStr/GLEnumConverter.h>
-
-namespace MobileGL::MG_Impl::GLImpl {
-    namespace {
-        // Must agree with what GL_Getter answers for GL_MAX_DEBUG_GROUP_STACK_DEPTH and
-        // GL_MAX_DEBUG_MESSAGE_LENGTH / GL_MAX_LABEL_LENGTH; an application that sizes a buffer
-        // off the query and then trips a different limit here would have no way to explain it.
-        constexpr SizeT kMaxDebugGroupStackDepth = 64;
-        constexpr GLsizei kMaxDebugMessageLength = 1024;
-        constexpr GLsizei kMaxLabelLength = 256;
-
-        // The debug state KHR_debug makes per-context. Held here rather than on GLContext because
-        // nothing else in MobileGL reads it, and it is keyed on the context id so a
-        // destroyed-and-recreated context starts with an empty stack and no labels - which the
-        // unit tests, which recreate the context between cases, depend on.
-        struct DebugState {
-            Uint64 contextId = 0;
-            // The messages pushed with glPushDebugGroup, innermost last. The base group GL creates
-            // the context with is implicit and is what makes the reported depth start at 1.
-            Vector<String> groupStack;
-            // Keyed by (identifier, name); see MakeObjectLabelKey.
-            UnorderedMap<Uint64, String> objectLabels;
-        };
-
-        DebugState& State() {
-            static DebugState state;
-            const Uint64 contextId = MG_State::pGLContext ? MG_State::pGLContext->GetTextureContextId() : 0;
-            if (state.contextId != contextId) {
-                state.contextId = contextId;
-                state.groupStack.clear();
-                state.objectLabels.clear();
-            }
-            return state;
-        }
-
-        Uint64 MakeObjectLabelKey(GLenum identifier, GLuint name) {
-            return (static_cast<Uint64>(identifier) << 32) | static_cast<Uint64>(name);
-        }
-
-        void RecordDebugError(ErrorCode code, const char* caller, const String& message) {
-            MG_State::pGLContext->RecordError(code, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", caller, message));
-        }
-
-        // GL 4.6 core 20.2: only an APPLICATION or THIRD_PARTY source may be injected; the rest
-        // are reserved for the implementation itself.
-        Bool ValidateInjectedSource(GLenum source, const char* caller) {
-            if (source == GL_DEBUG_SOURCE_APPLICATION || source == GL_DEBUG_SOURCE_THIRD_PARTY) {
-                return true;
-            }
-            RecordDebugError(ErrorCode::InvalidEnum, caller,
-                             std::format("source {} is not GL_DEBUG_SOURCE_APPLICATION or "
-                                         "GL_DEBUG_SOURCE_THIRD_PARTY.",
-                                         MG_Util::ConvertGLEnumToString(source)));
-            return false;
-        }
-
-        // A negative length means the string is NUL-terminated (GL 4.6 core 20.2), which is how
-        // every one of these entry points spells "just use the whole thing".
-        Bool ValidateDebugStringLength(GLsizei length, const GLchar* text, GLsizei limit, const char* caller,
-                                       const char* what) {
-            const GLsizei effective =
-                length < 0 ? static_cast<GLsizei>(text != nullptr ? std::strlen(text) : 0) : length;
-            if (effective < limit) {
-                return true;
-            }
-            RecordDebugError(ErrorCode::InvalidValue, caller,
-                             std::format("{} length {} is not less than the {} limit of {}.", what, effective, what,
-                                         limit));
-            return false;
-        }
-
-        String MakeDebugString(GLsizei length, const GLchar* text) {
-            if (text == nullptr) return {};
-            return length < 0 ? String(text) : String(text, static_cast<SizeT>(length));
-        }
-
-        // Whether `name` currently names an object of `identifier`'s type. GL 4.6 core 20.5 makes
-        // labelling something that does not exist INVALID_VALUE, and every type KHR_debug lists
-        // has a frontend name check - so this is answered exactly rather than waved through.
-        // GL_DISPLAY_LIST is deliberately absent: it exists only in the compatibility profile,
-        // which MobileGL does not expose, so it falls to the INVALID_ENUM path below.
-        Bool ValidateLabelledObject(GLenum identifier, GLuint name, Bool& outIdentifierKnown) {
-            outIdentifierKnown = true;
-            auto* context = MG_State::pGLContext.get();
-            switch (identifier) {
-            case GL_BUFFER:
-                return context->ValidateBufferName(name);
-            case GL_SHADER:
-                return context->ValidateShaderName(name);
-            case GL_PROGRAM:
-                return context->ValidateProgramName(name);
-            case GL_VERTEX_ARRAY:
-                return context->ValidateVertexArrayName(name);
-            case GL_QUERY:
-                return IsQuery(name) == GL_TRUE;
-            case GL_PROGRAM_PIPELINE:
-                return context->ValidateProgramPipelineName(name);
-            case GL_TRANSFORM_FEEDBACK:
-                return context->ValidateTransformFeedbackName(name);
-            case GL_SAMPLER:
-                return context->ValidateSamplerName(name);
-            case GL_TEXTURE:
-                return context->ValidateTextureName(name);
-            case GL_RENDERBUFFER:
-                return context->ValidateRenderbufferName(name);
-            case GL_FRAMEBUFFER:
-                // Name 0 is the default framebuffer, which is a real, labellable object.
-                return name == 0 || context->ValidateFramebufferName(name);
-            default:
-                outIdentifierKnown = false;
-                return false;
-            }
-        }
-    } // namespace
-
-    GLint GetDebugGroupStackDepth() {
-        // GL 4.6 core 20.6: the context is created with one group already on the stack, so the
-        // reported depth is one more than the number of pushes the application has made.
-        return static_cast<GLint>(State().groupStack.size()) + 1;
-    }
-
-    void PushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar* message) {
-        static_cast<void>(id);
-        if (!ValidateInjectedSource(source, __func__)) return;
-        if (!ValidateDebugStringLength(length, message, kMaxDebugMessageLength, __func__, "message")) return;
-
-        auto& state = State();
-        if (state.groupStack.size() + 1 >= kMaxDebugGroupStackDepth) {
-            // Not INVALID_*: KHR_debug gives the group stack its own error code.
-            RecordDebugError(ErrorCode::StackOverflow, __func__,
-                             std::format("the debug group stack is already {} deep, which is its maximum.",
-                                         kMaxDebugGroupStackDepth));
-            return;
-        }
-        state.groupStack.push_back(MakeDebugString(length, message));
-        MGLOG_D("glPushDebugGroup(%s) -> depth %d", state.groupStack.back().c_str(), GetDebugGroupStackDepth());
-    }
-
-    void PopDebugGroup() {
-        auto& state = State();
-        if (state.groupStack.empty()) {
-            // The base group the context was created with may not be popped (GL 4.6 core 20.6).
-            RecordDebugError(ErrorCode::StackUnderflow, __func__,
-                             "the debug group stack holds only the group the context was created with.");
-            return;
-        }
-        MGLOG_D("glPopDebugGroup(%s)", state.groupStack.back().c_str());
-        state.groupStack.pop_back();
-    }
-
-    void DebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length,
-                            const GLchar* buf) {
-        static_cast<void>(id);
-        if (!ValidateInjectedSource(source, __func__)) return;
-        switch (type) {
-        case GL_DEBUG_TYPE_ERROR:
-        case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
-        case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
-        case GL_DEBUG_TYPE_PORTABILITY:
-        case GL_DEBUG_TYPE_PERFORMANCE:
-        case GL_DEBUG_TYPE_MARKER:
-        case GL_DEBUG_TYPE_PUSH_GROUP:
-        case GL_DEBUG_TYPE_POP_GROUP:
-        case GL_DEBUG_TYPE_OTHER:
-            break;
-        default:
-            RecordDebugError(ErrorCode::InvalidEnum, __func__,
-                             std::format("type {} is not a debug message type.",
-                                         MG_Util::ConvertGLEnumToString(type)));
-            return;
-        }
-        switch (severity) {
-        case GL_DEBUG_SEVERITY_HIGH:
-        case GL_DEBUG_SEVERITY_MEDIUM:
-        case GL_DEBUG_SEVERITY_LOW:
-        case GL_DEBUG_SEVERITY_NOTIFICATION:
-            break;
-        default:
-            RecordDebugError(ErrorCode::InvalidEnum, __func__,
-                             std::format("severity {} is not a debug message severity.",
-                                         MG_Util::ConvertGLEnumToString(severity)));
-            return;
-        }
-        if (!ValidateDebugStringLength(length, buf, kMaxDebugMessageLength, __func__, "message")) return;
-
-        // No callback is ever invoked and the message log is empty by construction
-        // (GL_MAX_DEBUG_LOGGED_MESSAGES is 1 and glGetDebugMessageLog returns nothing), so the
-        // application-visible effect is exactly the error checking above. The text still reaches
-        // MobileGL's own log, where it is worth having next to the calls it annotates - at debug
-        // level, so an application that inserts a message per draw costs nothing in a release build.
-        MGLOG_D("glDebugMessageInsert: %s", MakeDebugString(length, buf).c_str());
-    }
-
-    void ObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar* label) {
-        Bool identifierKnown = false;
-        const Bool objectExists = ValidateLabelledObject(identifier, name, identifierKnown);
-        if (!identifierKnown) {
-            RecordDebugError(ErrorCode::InvalidEnum, __func__,
-                             std::format("identifier {} is not a labellable object type.",
-                                         MG_Util::ConvertGLEnumToString(identifier)));
-            return;
-        }
-        if (!objectExists) {
-            RecordDebugError(ErrorCode::InvalidValue, __func__,
-                             std::format("{} {} is not the name of an existing object.",
-                                         MG_Util::ConvertGLEnumToString(identifier), name));
-            return;
-        }
-        if (!ValidateDebugStringLength(length, label, kMaxLabelLength, __func__, "label")) return;
-
-        auto& labels = State().objectLabels;
-        const Uint64 key = MakeObjectLabelKey(identifier, name);
-        if (label == nullptr) {
-            // GL 4.6 core 20.5: a NULL label removes any label the object had.
-            labels.erase(key);
-            return;
-        }
-        labels[key] = MakeDebugString(length, label);
-    }
-
-    void GetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label) {
-        if (bufSize < 0) {
-            RecordDebugError(ErrorCode::InvalidValue, __func__, "bufSize must not be negative.");
-            return;
-        }
-        Bool identifierKnown = false;
-        const Bool objectExists = ValidateLabelledObject(identifier, name, identifierKnown);
-        if (!identifierKnown) {
-            RecordDebugError(ErrorCode::InvalidEnum, __func__,
-                             std::format("identifier {} is not a labellable object type.",
-                                         MG_Util::ConvertGLEnumToString(identifier)));
-            return;
-        }
-        if (!objectExists) {
-            RecordDebugError(ErrorCode::InvalidValue, __func__,
-                             std::format("{} {} is not the name of an existing object.",
-                                         MG_Util::ConvertGLEnumToString(identifier), name));
-            return;
-        }
-
-        const auto& labels = State().objectLabels;
-        const auto it = labels.find(MakeObjectLabelKey(identifier, name));
-        const String& text = it != labels.end() ? it->second : String{};
-        // GL 4.6 core 20.5: the returned length excludes the NUL, and an unlabelled object hands
-        // back an empty string with length 0 rather than an error.
-        SizeT copied = 0;
-        if (label != nullptr && bufSize > 0) {
-            copied = std::min(text.size(), static_cast<SizeT>(bufSize) - 1);
-            std::memcpy(label, text.data(), copied);
-            label[copied] = '\0';
-        }
-        if (length != nullptr) {
-            *length = static_cast<GLsizei>(copied);
-        }
-    }
-} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Debug/GL_Debug.h

@@ -1,42 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/GLImpl/Debug/GL_Debug.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 {
-    // KHR_debug, core since GL 4.3 (GL 4.6 core 20). Applications use these to annotate a capture
-    // and to name their objects; Better Clouds calls all four for exactly that.
-    //
-    // MobileGL implements the STATE and the ERRORS, and deliberately does not forward the calls to
-    // the host driver. Two independent reasons:
-    //
-    //  * glObjectLabel names a FRONTEND object. MobileGL's texture 5 is not the ES driver's
-    //    texture 5 (and under DirectVulkan it is not a driver object at all), so forwarding the
-    //    pair verbatim would label an unrelated object or a nonexistent one - worse than not
-    //    labelling.
-    //  * A debug GROUP is only meaningful if it brackets the commands the application issued
-    //    inside it. Neither backend emits its work at the moment the GL call arrives: DirectGLES
-    //    defers and reorders state sync and uploads around draws, and DirectVulkan is usually not
-    //    even recording a command buffer here. A forwarded push/pop would therefore enclose the
-    //    wrong commands, which is a misleading capture rather than a helpful one.
-    //
-    // What the application can rely on is the observable contract: the group stack depth is real
-    // (GL_DEBUG_GROUP_STACK_DEPTH tracks it, and over/underflow raise the errors KHR_debug
-    // specifies), and a label written with glObjectLabel comes back from glGetObjectLabel.
-    void PushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar* message);
-    void PopDebugGroup();
-    void DebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length,
-                            const GLchar* buf);
-    void ObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar* label);
-    void GetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label);
-
-    // Current depth of the debug group stack, for GL_DEBUG_GROUP_STACK_DEPTH. The base group the
-    // context is created with counts, so this is never below 1 (GL 4.6 core 20.6).
-    GLint GetDebugGroupStackDepth();
-} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.h

@@ -32,10 +32,8 @@ namespace MobileGL::MG_Impl::GLImpl {
     void DispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ);
     void DispatchComputeIndirect(GLintptr indirect);
     void PatchParameteri(GLenum pname, GLint value);
-    void PatchParameterfv(GLenum pname, const GLfloat* values);
     void MemoryBarrier(GLbitfield barriers);
     void MemoryBarrierByRegion(GLbitfield barriers);
-    void TextureBarrier();
     void MultiDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride);
     void MultiDrawArraysIndirect(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride);
     void MultiDrawElementsIndirectCount(GLenum mode, GLenum type, const void* indirect, GLintptr drawcount,

MobileGL/MG_Impl/GLImpl/Exporting/Definitions.cpp

@@ -20,18 +20,17 @@
 #include "../Framebuffer/GL_Framebuffer.h"
 #include "../VertexArray/GL_VertexArray.h"
 #include "../Sync/GL_Sync.h"
-#include "../Debug/GL_Debug.h"
 #include <MG_State/GLState/Core.h>
 
 #define DECLARE_GL_FUNCTION_STUB_HEAD(type, name, ...) MOBILEGL_GL_API type gl##name(__VA_ARGS__) {
 
 #define DECLARE_GL_FUNCTION_STUB_END(type, name, ...)                                                                  \
-    MGLOG_W_ONCE("Stub function: %s(...)", __FUNCTION__);                                                                   \
+    MGLOG_W("Stub function: %s(...)", __FUNCTION__);                                                                   \
     return (type)1;                                                                                                    \
     }
 
 #define DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(type, name, ...)                                                        \
-    MGLOG_W_ONCE("Stub function: %s(...)", __FUNCTION__);                                                                   \
+    MGLOG_W("Stub function: %s(...)", __FUNCTION__);                                                                   \
     }
 
 #define DECLARE_GL_FUNCTION_HEAD(type, name, ...) MOBILEGL_GL_API type gl##name(__VA_ARGS__) {
@@ -160,7 +159,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ReleaseShaderCompiler) DECLARE_GL_FUNCTION_S
 DECLARE_GL_FUNCTION_HEAD(void, RenderbufferStorage, GLenum target, GLenum internalformat, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, RenderbufferStorage, target, internalformat, width, height)
 DECLARE_GL_FUNCTION_HEAD(void, SampleCoverage, GLfloat value, GLboolean invert) DECLARE_GL_FUNCTION_END_NO_RETURN(void, SampleCoverage, value, invert)
 DECLARE_GL_FUNCTION_HEAD(void, Scissor, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, Scissor, x, y, width, height)
-DECLARE_GL_FUNCTION_HEAD(void, ShaderBinary, GLsizei count, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ShaderBinary, count, shaders, binaryformat, binary, length)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ShaderBinary, GLsizei count, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ShaderBinary, count, shaders, binaryformat, binary, length)
 DECLARE_GL_FUNCTION_HEAD(void, ShaderSource, GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ShaderSource, shader, count, string, length)
 DECLARE_GL_FUNCTION_HEAD(void, StencilFunc, GLenum func, GLint ref, GLuint mask) DECLARE_GL_FUNCTION_END_NO_RETURN(void, StencilFunc, func, ref, mask)
 DECLARE_GL_FUNCTION_HEAD(void, StencilFuncSeparate, GLenum face, GLenum func, GLint ref, GLuint mask) DECLARE_GL_FUNCTION_END_NO_RETURN(void, StencilFuncSeparate, face, func, ref, mask)
@@ -379,13 +378,27 @@ DECLARE_GL_FUNCTION_HEAD(void, VertexBindingDivisor, GLuint bindingindex, GLuint
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendBarrier) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendBarrier)
 DECLARE_GL_FUNCTION_HEAD(void, CopyImageSubData, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CopyImageSubData, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DebugMessageControl, GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DebugMessageControl, source, type, severity, count, ids, enabled)
-DECLARE_GL_FUNCTION_HEAD(void, DebugMessageInsert, GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DebugMessageInsert, source, type, id, severity, length, buf)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, DebugMessageInsert, GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DebugMessageInsert, source, type, id, severity, length, buf)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DebugMessageCallback, GLDEBUGPROC callback, const void* userParam) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DebugMessageCallback, callback, userParam)
 DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GetDebugMessageLog, GLuint count, GLsizei bufSize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog) DECLARE_GL_FUNCTION_STUB_END(GLuint, GetDebugMessageLog, count, bufSize, sources, types, ids, severities, lengths, messageLog)
-DECLARE_GL_FUNCTION_HEAD(void, PushDebugGroup, GLenum source, GLuint id, GLsizei length, const GLchar* message) DECLARE_GL_FUNCTION_END_NO_RETURN(void, PushDebugGroup, source, id, length, message)
-DECLARE_GL_FUNCTION_HEAD(void, PopDebugGroup) DECLARE_GL_FUNCTION_END_NO_RETURN(void, PopDebugGroup)
-DECLARE_GL_FUNCTION_HEAD(void, ObjectLabel, GLenum identifier, GLuint name, GLsizei length, const GLchar* label) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ObjectLabel, identifier, name, length, label)
-DECLARE_GL_FUNCTION_HEAD(void, GetObjectLabel, GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetObjectLabel, identifier, name, bufSize, length, label)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, PushDebugGroup, GLenum source, GLuint id, GLsizei length, const GLchar* message) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PushDebugGroup, source, id, length, message)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, PopDebugGroup) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PopDebugGroup)
+MOBILEGL_GL_API void glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar* label) {
+    (void)identifier;
+    (void)name;
+    (void)length;
+    (void)label;
+}
+MOBILEGL_GL_API void glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label) {
+    (void)identifier;
+    (void)name;
+    if (length) {
+        *length = 0;
+    }
+    if (label && bufSize > 0) {
+        label[0] = '\0';
+    }
+}
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ObjectPtrLabel, const void* ptr, GLsizei length, const GLchar* label) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ObjectPtrLabel, ptr, length, label)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetObjectPtrLabel, const void* ptr, GLsizei bufSize, GLsizei* length, GLchar* label) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetObjectPtrLabel, ptr, bufSize, length, label)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetPointerv, GLenum pname, void** params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetPointerv, pname, params)
@@ -411,7 +424,7 @@ DECLARE_GL_FUNCTION_HEAD(void, ReadnPixels, GLint x, GLint y, GLsizei width, GLs
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformfv, GLuint program, GLint location, GLsizei bufSize, GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformfv, program, location, bufSize, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformiv, GLuint program, GLint location, GLsizei bufSize, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformiv, program, location, bufSize, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformuiv, GLuint program, GLint location, GLsizei bufSize, GLuint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformuiv, program, location, bufSize, params)
-DECLARE_GL_FUNCTION_HEAD(void, MinSampleShading, GLfloat value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MinSampleShading, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, MinSampleShading, GLfloat value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MinSampleShading, value)
 DECLARE_GL_FUNCTION_HEAD(void, PatchParameteri, GLenum pname, GLint value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, PatchParameteri, pname, value)
 DECLARE_GL_FUNCTION_HEAD(void, TexParameterIiv, GLenum target, GLenum pname, const GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TexParameterIiv, target, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, TexParameterIuiv, GLenum target, GLenum pname, const GLuint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TexParameterIuiv, target, pname, params)
@@ -712,8 +725,8 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, LoadName, GLuint name) DECLARE_GL_FUNCTION_S
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PushName, GLuint name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PushName, name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PopName) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PopName)
 DECLARE_GL_FUNCTION_HEAD(void, ClampColor, GLenum target, GLenum clamp) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClampColor, target, clamp)
-DECLARE_GL_FUNCTION_HEAD(void, BeginConditionalRender, GLuint id, GLenum mode) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BeginConditionalRender, id, mode)
-DECLARE_GL_FUNCTION_HEAD(void, EndConditionalRender) DECLARE_GL_FUNCTION_END_NO_RETURN(void, EndConditionalRender)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, BeginConditionalRender, GLuint id, GLenum mode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BeginConditionalRender, id, mode)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, EndConditionalRender, void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EndConditionalRender)
 DECLARE_GL_FUNCTION_HEAD(void, VertexAttribI1i, GLuint index, GLint x) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexAttribI1i, index, x)
 DECLARE_GL_FUNCTION_HEAD(void, VertexAttribI2i, GLuint index, GLint x, GLint y) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexAttribI2i, index, x, y)
 DECLARE_GL_FUNCTION_HEAD(void, VertexAttribI3i, GLuint index, GLint x, GLint y, GLint z) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexAttribI3i, index, x, y, z)
@@ -923,7 +936,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetActiveSubroutineName, GLuint program, GLe
 DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformSubroutinesuiv, GLenum shadertype, GLsizei count, const GLuint* indices) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformSubroutinesuiv, shadertype, count, indices)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetUniformSubroutineuiv, GLenum shadertype, GLint location, GLuint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetUniformSubroutineuiv, shadertype, location, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetProgramStageiv, GLuint program, GLenum shadertype, GLenum pname, GLint* values) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetProgramStageiv, program, shadertype, pname, values)
-DECLARE_GL_FUNCTION_HEAD(void, PatchParameterfv, GLenum pname, const GLfloat* values) DECLARE_GL_FUNCTION_END_NO_RETURN(void, PatchParameterfv, pname, values)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, PatchParameterfv, GLenum pname, const GLfloat* values) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PatchParameterfv, pname, values)
 DECLARE_GL_FUNCTION_HEAD(void, DrawTransformFeedback, GLenum mode, GLuint id) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawTransformFeedback, mode, id)
 DECLARE_GL_FUNCTION_HEAD(void, DrawTransformFeedbackStream, GLenum mode, GLuint id, GLuint stream) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawTransformFeedbackStream, mode, id, stream)
 DECLARE_GL_FUNCTION_HEAD(void, BeginQueryIndexed, GLenum target, GLuint index, GLuint id) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BeginQueryIndexed, target, index, id)
@@ -956,24 +969,24 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribL3dv, GLuint index, const GLdoub
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribL4dv, GLuint index, const GLdouble* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttribL4dv, index, v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribLPointer, GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttribLPointer, index, size, type, stride, pointer)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVertexAttribLdv, GLuint index, GLenum pname, GLdouble* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVertexAttribLdv, index, pname, params)
-DECLARE_GL_FUNCTION_HEAD(void, ViewportArrayv, GLuint first, GLsizei count, const GLfloat* v) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ViewportArrayv, first, count, v)
-DECLARE_GL_FUNCTION_HEAD(void, ViewportIndexedf, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ViewportIndexedf, index, x, y, w, h)
-DECLARE_GL_FUNCTION_HEAD(void, ViewportIndexedfv, GLuint index, const GLfloat* v) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ViewportIndexedfv, index, v)
-DECLARE_GL_FUNCTION_HEAD(void, ScissorArrayv, GLuint first, GLsizei count, const GLint* v) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ScissorArrayv, first, count, v)
-DECLARE_GL_FUNCTION_HEAD(void, ScissorIndexed, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ScissorIndexed, index, left, bottom, width, height)
-DECLARE_GL_FUNCTION_HEAD(void, ScissorIndexedv, GLuint index, const GLint* v) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ScissorIndexedv, index, v)
-DECLARE_GL_FUNCTION_HEAD(void, DepthRangeArrayv, GLuint first, GLsizei count, const GLdouble* v) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DepthRangeArrayv, first, count, v)
-DECLARE_GL_FUNCTION_HEAD(void, DepthRangeIndexed, GLuint index, GLdouble n, GLdouble f) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DepthRangeIndexed, index, n, f)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ViewportArrayv, GLuint first, GLsizei count, const GLfloat* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ViewportArrayv, first, count, v)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ViewportIndexedf, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ViewportIndexedf, index, x, y, w, h)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ViewportIndexedfv, GLuint index, const GLfloat* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ViewportIndexedfv, index, v)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ScissorArrayv, GLuint first, GLsizei count, const GLint* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ScissorArrayv, first, count, v)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ScissorIndexed, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ScissorIndexed, index, left, bottom, width, height)
+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_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)
-DECLARE_GL_FUNCTION_HEAD(void, GetActiveAtomicCounterBufferiv, GLuint program, GLuint bufferIndex, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetActiveAtomicCounterBufferiv, program, bufferIndex, pname, params)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetActiveAtomicCounterBufferiv, GLuint program, GLuint bufferIndex, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetActiveAtomicCounterBufferiv, program, bufferIndex, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, DrawTransformFeedbackInstanced, GLenum mode, GLuint id, GLsizei instancecount) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawTransformFeedbackInstanced, mode, id, instancecount)
 DECLARE_GL_FUNCTION_HEAD(void, DrawTransformFeedbackStreamInstanced, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawTransformFeedbackStreamInstanced, mode, id, stream, instancecount)
-DECLARE_GL_FUNCTION_HEAD(void, ClearBufferData, GLenum target, GLenum internalformat, GLenum format, GLenum type, const void* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearBufferData, target, internalformat, format, type, data)
-DECLARE_GL_FUNCTION_HEAD(void, ClearBufferSubData, GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearBufferSubData, target, internalformat, offset, size, format, type, data)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearBufferData, GLenum target, GLenum internalformat, GLenum format, GLenum type, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearBufferData, target, internalformat, format, type, data)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearBufferSubData, GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearBufferSubData, target, internalformat, offset, size, format, type, data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetInternalformati64v, GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint64* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetInternalformati64v, target, internalformat, pname, count, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateTexSubImage, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InvalidateTexSubImage, texture, level, xoffset, yoffset, zoffset, width, height, depth)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateTexImage, GLuint texture, GLint level) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InvalidateTexImage, texture, level)
@@ -983,18 +996,18 @@ DECLARE_GL_FUNCTION_HEAD(void, MultiDrawArraysIndirect, GLenum mode, const void*
 DECLARE_GL_FUNCTION_HEAD(void, MultiDrawElementsIndirect, GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MultiDrawElementsIndirect, mode, type, indirect, drawcount, stride)
 DECLARE_GL_FUNCTION_HEAD(GLint, GetProgramResourceLocationIndex, GLuint program, GLenum programInterface, const GLchar* name) DECLARE_GL_FUNCTION_END(GLint, GetProgramResourceLocationIndex, program, programInterface, name)
 DECLARE_GL_FUNCTION_HEAD(void, ShaderStorageBlockBinding, GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ShaderStorageBlockBinding, program, storageBlockIndex, storageBlockBinding)
-DECLARE_GL_FUNCTION_HEAD(void, TextureView, GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureView, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, TextureView, GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TextureView, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers)
 DECLARE_GL_FUNCTION_HEAD(void, VertexAttribLFormat, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexAttribLFormat, attribindex, size, type, relativeoffset)
 DECLARE_GL_FUNCTION_HEAD(void, BufferStorage, GLenum target, GLsizeiptr size, const void* data, GLbitfield flags) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BufferStorage, target, size, data, flags)
 DECLARE_GL_FUNCTION_HEAD(void, ClearTexImage, GLuint texture, GLint level, GLenum format, GLenum type, const void* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearTexImage, texture, level, format, type, data)
 DECLARE_GL_FUNCTION_HEAD(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) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearTexSubImage, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data)
 DECLARE_GL_FUNCTION_HEAD(void, BindBuffersBase, GLenum target, GLuint first, GLsizei count, const GLuint* buffers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindBuffersBase, target, first, count, buffers)
 DECLARE_GL_FUNCTION_HEAD(void, BindBuffersRange, GLenum target, GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets, const GLsizeiptr* sizes) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindBuffersRange, target, first, count, buffers, offsets, sizes)
-DECLARE_GL_FUNCTION_HEAD(void, BindTextures, GLuint first, GLsizei count, const GLuint* textures) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindTextures, first, count, textures)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, BindTextures, GLuint first, GLsizei count, const GLuint* textures) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindTextures, first, count, textures)
 DECLARE_GL_FUNCTION_HEAD(void, BindSamplers, GLuint first, GLsizei count, const GLuint* samplers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindSamplers, first, count, samplers)
-DECLARE_GL_FUNCTION_HEAD(void, BindImageTextures, GLuint first, GLsizei count, const GLuint* textures) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindImageTextures, first, count, textures)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, BindImageTextures, GLuint first, GLsizei count, const GLuint* textures) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindImageTextures, first, count, textures)
 DECLARE_GL_FUNCTION_HEAD(void, BindVertexBuffers, GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets, const GLsizei* strides) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindVertexBuffers, first, count, buffers, offsets, strides)
-DECLARE_GL_FUNCTION_HEAD(void, ClipControl, GLenum origin, GLenum depth) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClipControl, origin, depth)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ClipControl, GLenum origin, GLenum depth) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClipControl, origin, depth)
 DECLARE_GL_FUNCTION_HEAD(void, CreateTransformFeedbacks, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateTransformFeedbacks, n, ids)
 DECLARE_GL_FUNCTION_HEAD(void, TransformFeedbackBufferBase, GLuint xfb, GLuint index, GLuint buffer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TransformFeedbackBufferBase, xfb, index, buffer)
 DECLARE_GL_FUNCTION_HEAD(void, TransformFeedbackBufferRange, GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TransformFeedbackBufferRange, xfb, index, buffer, offset, size)
@@ -1047,9 +1060,9 @@ DECLARE_GL_FUNCTION_HEAD(void, TextureStorage3DMultisample, GLuint texture, GLsi
 DECLARE_GL_FUNCTION_HEAD(void, TextureSubImage1D, GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureSubImage1D, texture, level, xoffset, width, format, type, pixels)
 DECLARE_GL_FUNCTION_HEAD(void, TextureSubImage2D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureSubImage2D, texture, level, xoffset, yoffset, width, height, format, type, pixels)
 DECLARE_GL_FUNCTION_HEAD(void, TextureSubImage3D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureSubImage3D, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)
-DECLARE_GL_FUNCTION_HEAD(void, CompressedTextureSubImage1D, GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CompressedTextureSubImage1D, texture, level, xoffset, width, format, imageSize, data)
-DECLARE_GL_FUNCTION_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_END_NO_RETURN(void, CompressedTextureSubImage2D, texture, level, xoffset, yoffset, width, height, format, imageSize, data)
-DECLARE_GL_FUNCTION_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_END_NO_RETURN(void, CompressedTextureSubImage3D, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)
+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_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)
@@ -1107,11 +1120,11 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnConvolutionFilter, GLenum target, GLenum
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnSeparableFilter, GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void* row, GLsizei columnBufSize, void* column, void* span) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnSeparableFilter, target, format, type, rowBufSize, row, columnBufSize, column, span)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnHistogram, GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnHistogram, target, reset, format, type, bufSize, values)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnMinmax, GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnMinmax, target, reset, format, type, bufSize, values)
-DECLARE_GL_FUNCTION_HEAD(void, TextureBarrier, void) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureBarrier, )
-DECLARE_GL_FUNCTION_HEAD(void, SpecializeShader, GLuint shader, const GLchar* pEntryPoint, GLuint numSpecializationConstants, const GLuint* pConstantIndex, const GLuint* pConstantValue) DECLARE_GL_FUNCTION_END_NO_RETURN(void, SpecializeShader, shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, TextureBarrier, void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TextureBarrier, )
+DECLARE_GL_FUNCTION_STUB_HEAD(void, SpecializeShader, GLuint shader, const GLchar* pEntryPoint, GLuint numSpecializationConstants, const GLuint* pConstantIndex, const GLuint* pConstantValue) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SpecializeShader, shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue)
 DECLARE_GL_FUNCTION_HEAD(void, MultiDrawArraysIndirectCount, GLenum mode, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MultiDrawArraysIndirectCount, mode, indirect, drawcount, maxdrawcount, stride)
 DECLARE_GL_FUNCTION_HEAD(void, MultiDrawElementsIndirectCount, GLenum mode, GLenum type, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MultiDrawElementsIndirectCount, mode, type, indirect, drawcount, maxdrawcount, stride)
-DECLARE_GL_FUNCTION_HEAD(void, PolygonOffsetClamp, GLfloat factor, GLfloat units, GLfloat clamp) DECLARE_GL_FUNCTION_END_NO_RETURN(void, PolygonOffsetClamp, factor, units, clamp)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, PolygonOffsetClamp, GLfloat factor, GLfloat units, GLfloat clamp) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PolygonOffsetClamp, factor, units, clamp)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PrimitiveBoundingBoxARB, GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) DECLARE_GL_FUNCTION_STUB_END(void, PrimitiveBoundingBoxARB, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW)
 DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetTextureHandleARB, GLuint texture) DECLARE_GL_FUNCTION_STUB_END(GLuint64, GetTextureHandleARB, texture)
 DECLARE_GL_FUNCTION_STUB_HEAD(GLuint64, GetTextureSamplerHandleARB, GLuint texture, GLuint sampler) DECLARE_GL_FUNCTION_STUB_END(GLuint64, GetTextureSamplerHandleARB, texture, sampler)
@@ -1150,7 +1163,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetProgramLocalParameterdvARB, GLenum target
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetProgramLocalParameterfvARB, GLenum target, GLuint index, GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetProgramLocalParameterfvARB, target, index, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetProgramStringARB, GLenum target, GLenum pname, void* string) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetProgramStringARB, target, pname, string)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, FramebufferTextureFaceARB, GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FramebufferTextureFaceARB, target, attachment, texture, level, face)
-DECLARE_GL_FUNCTION_HEAD(void, SpecializeShaderARB, GLuint shader, const GLchar* pEntryPoint, GLuint numSpecializationConstants, const GLuint* pConstantIndex, const GLuint* pConstantValue) DECLARE_GL_FUNCTION_END_NO_RETURN(void, SpecializeShader, shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, SpecializeShaderARB, GLuint shader, const GLchar* pEntryPoint, GLuint numSpecializationConstants, const GLuint* pConstantIndex, const GLuint* pConstantValue) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SpecializeShaderARB, shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, Uniform1i64ARB, GLint location, GLint64 x) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Uniform1i64ARB, location, x)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, Uniform2i64ARB, GLint location, GLint64 x, GLint64 y) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Uniform2i64ARB, location, x, y)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, Uniform3i64ARB, GLint location, GLint64 x, GLint64 y, GLint64 z) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Uniform3i64ARB, location, x, y, z)
@@ -1835,9 +1848,9 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetBooleanIndexedvEXT, GLenum target, GLuint
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureImage3DEXT, GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureImage3DEXT, texture, target, level, internalformat, width, height, depth, border, imageSize, bits)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureImage2DEXT, GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureImage2DEXT, texture, target, level, internalformat, width, height, border, imageSize, bits)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureImage1DEXT, GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureImage1DEXT, texture, target, level, internalformat, width, border, imageSize, bits)
-DECLARE_GL_FUNCTION_HEAD(void, CompressedTextureSubImage3DEXT, GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CompressedTextureSubImage3D, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits)
-DECLARE_GL_FUNCTION_HEAD(void, CompressedTextureSubImage2DEXT, GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CompressedTextureSubImage2D, texture, level, xoffset, yoffset, width, height, format, imageSize, bits)
-DECLARE_GL_FUNCTION_HEAD(void, CompressedTextureSubImage1DEXT, GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CompressedTextureSubImage1D, texture, level, xoffset, width, format, imageSize, bits)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureSubImage3DEXT, GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureSubImage3DEXT, texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureSubImage2DEXT, GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureSubImage2DEXT, texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureSubImage1DEXT, GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureSubImage1DEXT, texture, target, level, xoffset, width, format, imageSize, bits)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetCompressedTextureImageEXT, GLuint texture, GLenum target, GLint lod, void* img) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetCompressedTextureImageEXT, texture, target, lod, img)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedMultiTexImage3DEXT, GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedMultiTexImage3DEXT, texunit, target, level, internalformat, width, height, depth, border, imageSize, bits)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedMultiTexImage2DEXT, GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* bits) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedMultiTexImage2DEXT, texunit, target, level, internalformat, width, height, border, imageSize, bits)
@@ -2049,7 +2062,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetPixelTransformParameterivEXT, GLenum targ
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetPixelTransformParameterfvEXT, GLenum target, GLenum pname, GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetPixelTransformParameterfvEXT, target, pname, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PointParameterfEXT, GLenum pname, GLfloat param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PointParameterfEXT, pname, param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PointParameterfvEXT, GLenum pname, const GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PointParameterfvEXT, pname, params)
-DECLARE_GL_FUNCTION_HEAD(void, PolygonOffsetClampEXT, GLfloat factor, GLfloat units, GLfloat clamp) DECLARE_GL_FUNCTION_END_NO_RETURN(void, PolygonOffsetClamp, factor, units, clamp)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, PolygonOffsetClampEXT, GLfloat factor, GLfloat units, GLfloat clamp) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PolygonOffsetClampEXT, factor, units, clamp)
 DECLARE_GL_FUNCTION_HEAD(void, ProvokingVertexEXT, GLenum mode) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProvokingVertex, mode)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, RasterSamplesEXT, GLuint samples, GLboolean fixedsamplelocations) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, RasterSamplesEXT, samples, fixedsamplelocations)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SecondaryColor3bEXT, GLbyte red, GLbyte green, GLbyte blue) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SecondaryColor3bEXT, red, green, blue)
@@ -2546,7 +2559,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ShadingRateImageBarrierNV, GLboolean synchro
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ShadingRateImagePaletteNV, GLuint viewport, GLuint first, GLsizei count, const GLenum* rates) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ShadingRateImagePaletteNV, viewport, first, count, rates)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ShadingRateSampleOrderNV, GLenum order) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ShadingRateSampleOrderNV, order)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ShadingRateSampleOrderCustomNV, GLenum rate, GLuint samples, const GLint* locations) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ShadingRateSampleOrderCustomNV, rate, samples, locations)
-DECLARE_GL_FUNCTION_HEAD(void, TextureBarrierNV, void) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureBarrier, )
+DECLARE_GL_FUNCTION_STUB_HEAD(void, TextureBarrierNV, void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TextureBarrierNV, )
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexImage2DMultisampleCoverageNV, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexImage2DMultisampleCoverageNV, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TexImage3DMultisampleCoverageNV, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexImage3DMultisampleCoverageNV, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, TextureImage2DMultisampleNV, GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TextureImage2DMultisampleNV, texture, target, samples, internalFormat, width, height, fixedSampleLocations)
@@ -2572,7 +2585,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, BindTransformFeedbackNV, GLenum target, GLui
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteTransformFeedbacksNV, GLsizei n, const GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteTransformFeedbacksNV, n, ids)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenTransformFeedbacksNV, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenTransformFeedbacksNV, n, ids)
 MOBILEGL_GL_API GLboolean glIsTransformFeedbackNV(GLuint id) {
-    MGLOG_W_ONCE("Stub function: %s(...)", __FUNCTION__);
+    MGLOG_W("Stub function: %s(...)", __FUNCTION__);
     return GL_FALSE;
 }
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PauseTransformFeedbackNV, void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PauseTransformFeedbackNV, )
@@ -3168,5 +3181,5 @@ MOBILEGL_GL_API void glVertexAttribDivisorARB(GLuint index, GLuint divisor) {
 }
 
 MOBILEGL_GL_API void glWindowRectanglesEXT(GLenum mode, GLsizei count, const GLint* box) {
-    MGLOG_W_ONCE("Stub function: %s(...)", __FUNCTION__);
+    MGLOG_W("Stub function: %s(...)", __FUNCTION__);
 }

MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp

@@ -13,9 +13,7 @@
 #include <MG_Backend/BackendObjects.h>
 #include <MG_Util/Metrics/TextureMetrics.h>
 #include <MG_Impl/GLImpl/Texture/Validators.h>
-#include <MG_Impl/GLImpl/Getter/GL_Getter.h>
 #include <MG_State/GLState/ErrorState/Error.h>
-#include <MG_Impl/Pipe/PipeFill.h>
 #include <MG_Util/Converters/GLToStr/GLEnumConverter.h>
 #include <MG_Util/Converters/GLToMG/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToMG/TextureEnumConverter.h>
@@ -475,75 +473,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
         }
 
-        // GL 4.6 core 9.2.8 conditions that depend only on the framebuffer and the attachment
-        // point. Shared, because glFramebufferTexture / 1D / 2D / 3D / TextureLayer are aliases of
-        // one another in that section and a CTS case that walks the family must not get five
-        // different answers - which is exactly what happened when these lived in one helper that
-        // only two of the five went through.
-        Bool ValidateFramebufferTextureAttachmentPoint(const char* functionName,
-                                                       const SharedPtr<MG_State::GLState::FramebufferObject>&
-                                                           framebufferObject,
-                                                       FramebufferAttachmentType attachmentType) {
-            // "An INVALID_OPERATION error is generated if COLOR_ATTACHMENTm is used with m greater
-            // than or equal to MAX_COLOR_ATTACHMENTS."
-            if (!FramebufferImpl::ValidateColorAttachmentInRange(attachmentType, functionName)) return false;
-            // "An INVALID_OPERATION error is generated if zero is bound to target." MobileGL keeps
-            // a real FramebufferObject for framebuffer 0, so a null test can never see this - the
-            // object is always there, and framebuffer 0 has to be recognised by identity instead,
-            // the same comparison DrawBuffers_State makes. Without this an attach onto the default
-            // framebuffer silently REPLACED its colour attachment, permanently desynchronising it
-            // from what the swapchain keeps publishing.
-            const auto& defaultFramebufferInfo = FramebufferImpl::pDefaultFramebufferInfo;
-            if (!framebufferObject ||
-                (defaultFramebufferInfo && framebufferObject == defaultFramebufferInfo->defaultFBO)) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", functionName,
-                        "No framebuffer object is bound to the target; the default framebuffer's attachments "
-                        "cannot be named."));
-                return false;
-            }
-            return true;
-        }
-
-        // The other half of 9.2.8: "level must be greater than or equal to zero", and for a
-        // texture with immutable storage it "must be smaller than the number of levels the texture
-        // has". Split from the attachment-point half because the caller only has a texture object
-        // once the detach (texture == 0) case is behind it.
-        Bool ValidateFramebufferTextureLevel(const char* functionName,
-                                             const SharedPtr<MG_State::GLState::ITextureObject>& textureObject,
-                                             GLint level) {
-            if (level < 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                                 "Texture level must be non-negative."));
-                return false;
-            }
-            if (!textureObject || !textureObject->IsImmutable()) {
-                // A mutable texture has no level bound here: a level it has not specified yet is
-                // not an error, it just leaves the framebuffer incomplete.
-                return true;
-            }
-            // GetAddressableLevelCount(), NOT GetImmutableLevels(): for a VIEW the latter is
-            // deliberately the ORIGINAL texture's count (GL 4.6 core 8.18 defines
-            // TEXTURE_IMMUTABLE_LEVELS on a view that way), which is far too large a bound - a
-            // two-level view onto a ten-level texture would accept level 5 and attach an image
-            // nothing can draw into.
-            const Uint levelBound = textureObject->GetAddressableLevelCount();
-            if (static_cast<Uint>(level) >= levelBound) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", functionName,
-                        std::format("Texture level {} is beyond the {} level(s) this texture has.", level,
-                                    levelBound)));
-                return false;
-            }
-            return true;
-        }
-
         void AttachFramebufferTextureWithUploadTarget(const char* functionName, GLenum target, GLenum attachment,
                                                       GLuint texture, GLint level,
                                                       TextureUploadTarget textureUploadTarget, Bool layered = false) {
@@ -552,24 +481,10 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
 
             if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
-                // `layered` has to travel with the split. GL_DEPTH_STENCIL_ATTACHMENT is only a
-                // shorthand for attaching the same image to both halves (GL 4.6 core 9.2.6), so
-                // whether glFramebufferTexture made it LAYERED is a property of the call, not of
-                // which half is being recorded - and dropping it here (the parameter defaults to
-                // false) recorded a non-layered depth/stencil attachment beside a layered colour
-                // one for every layered target. That is an inconsistent framebuffer by 9.4.1's
-                // own rule, and downstream it means the depth/stencil attachment covers layer 0
-                // alone: DirectVulkan built its view with layerCount 1 under a framebuffer
-                // declaring N layers (VUID-VkFramebufferCreateInfo-flags-04535), and DirectGLES
-                // attached one layer of it beside a layered colour target, which the driver
-                // answers with GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS - every draw silently
-                // produced nothing. This is the shape
-                // texture_cube_map_array.stencil_attachments_*_layered and
-                // geometry_shader.layered_framebuffer.stencil_support are built on.
                 AttachFramebufferTextureWithUploadTarget(functionName, target, GL_DEPTH_ATTACHMENT, texture, level,
-                                                        textureUploadTarget, layered);
+                                                        textureUploadTarget);
                 AttachFramebufferTextureWithUploadTarget(functionName, target, GL_STENCIL_ATTACHMENT, texture, level,
-                                                        textureUploadTarget, layered);
+                                                        textureUploadTarget);
                 return;
             }
 
@@ -581,7 +496,13 @@ namespace MobileGL::MG_Impl::GLImpl {
 
             auto& bindingSlot = MG_State::pGLContext->GetFramebufferBindingSlot(framebufferTarget);
             auto& framebufferObject = bindingSlot.GetBoundObject();
-            if (!ValidateFramebufferTextureAttachmentPoint(functionName, framebufferObject, attachmentType)) return;
+            if (!framebufferObject) {
+                MG_State::pGLContext->RecordError(
+                    ErrorCode::InvalidOperation,
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
+                                                 "Framebuffer target is bound to no framebuffer object."));
+                return;
+            }
 
             if (texture == 0) {
                 framebufferObject->Detach(attachmentType);
@@ -596,7 +517,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                                                  std::format("Texture object {} is not valid.", texture)));
                 return;
             }
-            if (!ValidateFramebufferTextureLevel(functionName, textureObject, level)) return;
 
             const auto expectedTextureTarget = MG_Util::ConvertTextureUploadTargetToTextureTarget(textureUploadTarget);
             if (expectedTextureTarget == TextureTarget::Unknown ||
@@ -617,7 +537,6 @@ namespace MobileGL::MG_Impl::GLImpl {
 
     void BlitFramebuffer_Backend(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0,
                                  GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
-        MGP_FILL(BlitFramebuffer);
         MG_Backend::gBackendFunctionsTable.GL.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
                                                               mask, filter);
     }
@@ -628,10 +547,9 @@ namespace MobileGL::MG_Impl::GLImpl {
                                       GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
         auto blitNamedFramebuffer = MG_Backend::gBackendFunctionsTable.GL.BlitNamedFramebuffer;
         if (!blitNamedFramebuffer) {
-            MGLOG_E_ONCE("glBlitNamedFramebuffer skipped: backend does not implement explicit framebuffer blit.");
+            MGLOG_E("glBlitNamedFramebuffer skipped: backend does not implement explicit framebuffer blit.");
             return;
         }
-        MGP_FILL(BlitNamedFramebuffer);
         blitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
                              dstY1, mask, filter);
     }
@@ -640,10 +558,9 @@ namespace MobileGL::MG_Impl::GLImpl {
                                          GLenum buffer, GLint drawbuffer, const GLfloat* value) {
         auto clearNamedFramebufferfv = MG_Backend::gBackendFunctionsTable.GL.ClearNamedFramebufferfv;
         if (!clearNamedFramebufferfv) {
-            MGLOG_E_ONCE("glClearNamedFramebufferfv skipped: backend does not implement explicit framebuffer clear.");
+            MGLOG_E("glClearNamedFramebufferfv skipped: backend does not implement explicit framebuffer clear.");
             return;
         }
-        MGP_FILL(ClearNamedFramebufferfv);
         clearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
     }
 
@@ -651,10 +568,9 @@ namespace MobileGL::MG_Impl::GLImpl {
                                          GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
         auto clearNamedFramebufferfi = MG_Backend::gBackendFunctionsTable.GL.ClearNamedFramebufferfi;
         if (!clearNamedFramebufferfi) {
-            MGLOG_E_ONCE("glClearNamedFramebufferfi skipped: backend does not implement explicit framebuffer clear.");
+            MGLOG_E("glClearNamedFramebufferfi skipped: backend does not implement explicit framebuffer clear.");
             return;
         }
-        MGP_FILL(ClearNamedFramebufferfi);
         clearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);
     }
 
@@ -662,10 +578,9 @@ namespace MobileGL::MG_Impl::GLImpl {
                                          GLenum buffer, GLint drawbuffer, const GLint* value) {
         auto clearNamedFramebufferiv = MG_Backend::gBackendFunctionsTable.GL.ClearNamedFramebufferiv;
         if (!clearNamedFramebufferiv) {
-            MGLOG_E_ONCE("glClearNamedFramebufferiv skipped: backend does not implement explicit framebuffer clear.");
+            MGLOG_E("glClearNamedFramebufferiv skipped: backend does not implement explicit framebuffer clear.");
             return;
         }
-        MGP_FILL(ClearNamedFramebufferiv);
         clearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
     }
 
@@ -673,10 +588,9 @@ namespace MobileGL::MG_Impl::GLImpl {
                                           GLenum buffer, GLint drawbuffer, const GLuint* value) {
         auto clearNamedFramebufferuiv = MG_Backend::gBackendFunctionsTable.GL.ClearNamedFramebufferuiv;
         if (!clearNamedFramebufferuiv) {
-            MGLOG_E_ONCE("glClearNamedFramebufferuiv skipped: backend does not implement explicit framebuffer clear.");
+            MGLOG_E("glClearNamedFramebufferuiv skipped: backend does not implement explicit framebuffer clear.");
             return;
         }
-        MGP_FILL(ClearNamedFramebufferuiv);
         clearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
     }
 
@@ -703,67 +617,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (MG_Backend::pActiveBackendObject == nullptr) {
             return std::numeric_limits<Int>::max();
         }
-        return GetAdvertisedMaxSamples();
-    }
-
-    // GL_MAX_SAMPLES is the ceiling over all formats; an integer format has its own
-    // (GL_MAX_INTEGER_SAMPLES) and GL 4.6 core 9.2.4 makes exceeding it INVALID_OPERATION.
-    // The multisample TEXTURE path resolves the limit per format the same way
-    // (GL_Texture.cpp, GetMaxSupportedTextureSamples), and both now enforce exactly what their
-    // pname advertises. The integer ceiling used to be floored at GL_MAX_SAMPLES so that the
-    // frontend would accept a count it had advertised globally - but on Adreno and Mali the
-    // integer path is genuinely one sample, and accepting four only moved the failure from an
-    // honest INVALID_OPERATION here to a silently under-allocated renderbuffer.
-    // The head of the per-format renderbuffer sample list the backend probed, or 0 when nothing
-    // was probed for it. Same shape as GetProbedMaxTextureSamples in GL_Texture.cpp, and reads
-    // the same cache glGetInternalformativ(GL_RENDERBUFFER, ..., GL_SAMPLES) answers from.
-    static Int GetProbedMaxRenderbufferSamples(TextureInternalFormat format) {
-        if (MG_Backend::pActiveBackendObject == nullptr) {
-            return 0;
-        }
-        const SizeT targetIndex = MG_Backend::GetRenderbufferFormatCapabilityTargetIndex();
-        const SizeT formatIndex = static_cast<SizeT>(format);
-        if (targetIndex >= MG_Backend::kFormatCapabilityTargetCount ||
-            formatIndex >= MG_Backend::kFormatCapabilityFormatCount) {
-            return 0;
-        }
-        const auto& sampleCounts =
-            MG_Backend::pActiveBackendObject->GetFormatCapabilities().SampleCounts[targetIndex][formatIndex];
-        return sampleCounts.empty() ? 0 : sampleCounts.front();
-    }
-
-    Int GetMaxRenderbufferSamplesForFormat_State(TextureInternalFormat format) {
-        if (MG_Backend::pActiveBackendObject == nullptr) {
-            return std::numeric_limits<Int>::max();
-        }
-
-        GLenum normalizedInternalFormat = MG_Util::ConvertTextureInternalFormatToGLEnum(format);
-        GLenum normalizedFormat = GL_RGBA;
-        GLenum normalizedType = GL_UNSIGNED_BYTE;
-        MG_Util::TextureFormatProcessor::NormalizePixelFormat(normalizedInternalFormat,
-                                                              PixelFormatNormalizeOptionBit::None,
-                                                              &normalizedInternalFormat, &normalizedFormat,
-                                                              &normalizedType);
-        const Bool isIntegerFormat = normalizedFormat == GL_RED_INTEGER || normalizedFormat == GL_RG_INTEGER ||
-                                     normalizedFormat == GL_RGB_INTEGER || normalizedFormat == GL_RGBA_INTEGER;
-        // The per-format probe first, for the same reason the texture path takes it first: GL 4.6
-        // core 9.2.4 words the error as "samples is greater than the maximum number of samples
-        // supported for internalformat (see GetInternalformativ)", and
-        // glGetInternalformativ(GL_RENDERBUFFER, ..., GL_SAMPLES) is answered from exactly this
-        // list. It was never consulted here - the TODO that deferred it was written before the
-        // query was backed and had gone stale - so a format whose multisample probes fail inside
-        // a category that allows four was accepted at four, quietly allocated at one by
-        // ClampSamplesToBackendSupport, and then reported as four by
-        // glGetRenderbufferParameteriv(GL_RENDERBUFFER_SAMPLES).
-        const Int probedMaxSamples = GetProbedMaxRenderbufferSamples(format);
-        if (probedMaxSamples > 0) {
-            return probedMaxSamples;
-        }
-        if (!isIntegerFormat) {
-            return GetMaxRenderbufferSamples_State();
-        }
-        // Exactly what glGetIntegerv(GL_MAX_INTEGER_SAMPLES) reports.
-        return GetAdvertisedIntegerMaxSamples();
+        return std::max(MG_Backend::pActiveBackendObject->GetDynamicParameters().MaxSamples, 1);
     }
 
     Bool ValidateRenderbufferStorageSize_State(GLsizei width, GLsizei height, const char* caller) {
@@ -787,7 +641,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         return true;
     }
 
-    Bool ValidateRenderbufferStorageSamples_State(GLsizei samples, TextureInternalFormat format, const char* caller) {
+    Bool ValidateRenderbufferStorageSamples_State(GLsizei samples, const char* caller) {
         if (samples < 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
@@ -795,12 +649,9 @@ namespace MobileGL::MG_Impl::GLImpl {
             return false;
         }
 
-        // Per-internalformat, from the probe list glGetInternalformativ answers with, falling back
-        // to the format's category pname where nothing was probed. (This carried a TODO deferring
-        // the per-format resolution "once glGetInternalformativ is backed"; it has been backed for
-        // both renderbuffers and multisample textures since, so the deferral was collected.)
-        const Int maxSamples = GetMaxRenderbufferSamplesForFormat_State(format);
+        const Int maxSamples = GetMaxRenderbufferSamples_State();
         if (samples > maxSamples) {
+            // TODO: Use per-internalformat renderbuffer sample limits once glGetInternalformativ is backed.
             // GL 4.6 core 9.2.4 makes asking for more samples than the format supports
             // INVALID_OPERATION, not INVALID_VALUE - the count is well formed, this format just
             // cannot deliver it. Only a negative count is INVALID_VALUE.
@@ -808,7 +659,7 @@ namespace MobileGL::MG_Impl::GLImpl {
                 ErrorCode::InvalidOperation,
                 MakeUnique<GenericErrorInfo>(
                     "MG_Impl/GLImpl", caller,
-                    std::format("Sample count {} exceeds this format's sample limit ({}).", samples, maxSamples)));
+                    std::format("Sample count {} exceeds GL_MAX_SAMPLES ({}).", samples, maxSamples)));
             return false;
         }
         return true;
@@ -833,7 +684,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         TextureInternalFormat format = MG_Util::ConvertGLEnumToTextureInternalFormat(internalformat);
         if (!TextureImpl::ValidateTextureInternalFormat(format)) return;
 
-        if (!ValidateRenderbufferStorageSamples_State(samples, format, kCaller)) return;
+        if (!ValidateRenderbufferStorageSamples_State(samples, kCaller)) return;
         if (!ValidateRenderbufferStorageSize_State(width, height, kCaller)) return;
 
         renderbufferObject->AllocateStorage({width, height});
@@ -1080,8 +931,7 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         TextureInternalFormat format = MG_Util::ConvertGLEnumToTextureInternalFormat(internalformat);
         if (!TextureImpl::ValidateTextureInternalFormat(format)) return;
-        if (!ValidateRenderbufferStorageSamples_State(samples, format, "NamedRenderbufferStorageMultisample_State"))
-            return;
+        if (!ValidateRenderbufferStorageSamples_State(samples, "NamedRenderbufferStorageMultisample_State")) return;
         if (!ValidateRenderbufferStorageSize_State(width, height, "NamedRenderbufferStorageMultisample_State")) return;
 
         renderbufferObject->AllocateStorage({width, height});
@@ -1163,7 +1013,13 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         auto& bindingSlot = MG_State::pGLContext->GetFramebufferBindingSlot(framebufferTarget);
         auto& framebufferObject = bindingSlot.GetBoundObject();
-        if (!ValidateFramebufferTextureAttachmentPoint(functionName, framebufferObject, attachmentType)) return;
+        if (!framebufferObject) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
+                                             "Framebuffer target is bound to no framebuffer object."));
+            return;
+        }
 
         if (texture == 0) {
             framebufferObject->Detach(attachmentType);
@@ -1178,7 +1034,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                                              std::format("Texture object {} is not valid.", texture)));
             return;
         }
-        if (!ValidateFramebufferTextureLevel(functionName, textureObject, level)) return;
         if (layer < 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
@@ -1301,13 +1156,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                                              "Framebuffer target is bound to no framebuffer object."));
             return;
         }
-        // glFramebufferTexture2D is by far the most-used member of the family and the only one
-        // that inlines its own logic instead of going through the shared helper, so the 9.2.8
-        // conditions have to be asked here explicitly.
-        if (!ValidateFramebufferTextureAttachmentPoint("FramebufferTexture2D_State", framebufferObject,
-                                                       attachmentType)) {
-            return;
-        }
 
         if (texture == 0) {
             framebufferObject->Detach(attachmentType);
@@ -1322,7 +1170,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                                              std::format("Texture object {} is not valid.", texture)));
             return;
         }
-        if (!ValidateFramebufferTextureLevel("FramebufferTexture2D_State", textureObject, level)) return;
 
         const auto expectedTextureTarget = MG_Util::ConvertTextureUploadTargetToTextureTarget(textureUploadTarget);
         if (expectedTextureTarget == TextureTarget::Unknown ||
@@ -1359,12 +1206,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
-        // The name's validity is an INVALID_VALUE condition (GL 4.6 core 9.2.8), and it has to be
-        // asked BEFORE the object is resolved: reporting the miss as the INVALID_OPERATION below
-        // pre-empted the shared helper's ValidateTextureName and answered the wrong error code for
-        // every texture name that was never generated.
-        if (!TextureImpl::ValidateTextureName(texture, true)) return;
-
         auto& textureObject = MG_State::pGLContext->GetTextureObject(texture);
         if (!textureObject) {
             MG_State::pGLContext->RecordError(
@@ -1415,10 +1256,13 @@ namespace MobileGL::MG_Impl::GLImpl {
                                              std::format("Texture object {} is not valid.", texture)));
             return;
         }
-        // The whole level condition, not just its negative half: glNamedFramebufferTexture and
-        // glFramebufferTexture are equivalent in 9.2.8, so an out-of-range immutable level has to
-        // be rejected on both or a CTS case gets two answers for one rule.
-        if (!ValidateFramebufferTextureLevel("NamedFramebufferTexture_State", textureObject, level)) return;
+        if (level < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "NamedFramebufferTexture_State",
+                                             "Texture level must be non-negative."));
+            return;
+        }
 
         TextureUploadTarget textureUploadTarget = TextureUploadTarget::Unknown;
         Bool layered = false;
@@ -2734,30 +2578,18 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void ClearBufferfi_Backend(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
-        // GL 4.6 core 10.9 makes ClearBuffer* conditional alongside the drawing commands.
-        if (MG_State::pGLContext->ConditionalRenderDiscardsCommands()) return;
-        MGP_FILL(ClearBufferfi);
         MG_Backend::gBackendFunctionsTable.GL.ClearBufferfi(buffer, drawbuffer, depth, stencil);
     }
 
     void ClearBufferfv_Backend(GLenum buffer, GLint drawbuffer, const GLfloat* value) {
-        // GL 4.6 core 10.9 makes ClearBuffer* conditional alongside the drawing commands.
-        if (MG_State::pGLContext->ConditionalRenderDiscardsCommands()) return;
-        MGP_FILL(ClearBufferfv);
         MG_Backend::gBackendFunctionsTable.GL.ClearBufferfv(buffer, drawbuffer, value);
     }
 
     void ClearBufferuiv_Backend(GLenum buffer, GLint drawbuffer, const GLuint* value) {
-        // GL 4.6 core 10.9 makes ClearBuffer* conditional alongside the drawing commands.
-        if (MG_State::pGLContext->ConditionalRenderDiscardsCommands()) return;
-        MGP_FILL(ClearBufferuiv);
         MG_Backend::gBackendFunctionsTable.GL.ClearBufferuiv(buffer, drawbuffer, value);
     }
 
     void ClearBufferiv_Backend(GLenum buffer, GLint drawbuffer, const GLint* value) {
-        // GL 4.6 core 10.9 makes ClearBuffer* conditional alongside the drawing commands.
-        if (MG_State::pGLContext->ConditionalRenderDiscardsCommands()) return;
-        MGP_FILL(ClearBufferiv);
         MG_Backend::gBackendFunctionsTable.GL.ClearBufferiv(buffer, drawbuffer, value);
     }
 
@@ -3005,7 +2837,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void ReadPixels_Backend(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) {
-        MGP_FILL(ReadPixels);
         MG_Backend::gBackendFunctionsTable.GL.ReadPixels(x, y, width, height, format, type, pixels);
     }
 
@@ -3287,55 +3118,15 @@ namespace MobileGL::MG_Impl::GLImpl {
         GetNamedFramebufferAttachmentParameteriv_State(framebuffer, attachment, pname, params);
     }
 
-    // The three argument errors GL 4.6 core 18.3.1 asks a blit for. They have to be raised here,
-    // in the backend-independent frontend: DirectGLES drains the driver's error queue around the
-    // blit on purpose (that is how the resolve fallback probes the driver), so an ES-side
-    // rejection never reaches the application and glGetError() answered GL_NO_ERROR for a call
-    // the spec requires to fail (KHR-GL30.api.coverage's glBlitFramebuffer sub-check). DirectVulkan
-    // already dropped the bad-filter and LINEAR-with-depth/stencil calls on the floor with a log
-    // line (VulkanRenderer::BlitFramebuffer), so the only thing that changes for it is that the
-    // error is now visible where the spec says it should be.
-    static Bool ValidateBlitMaskAndFilter(const char* functionName, GLbitfield mask, GLenum filter) {
-        constexpr GLbitfield kBlitMaskBits = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
-        if ((mask & ~kBlitMaskBits) != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             "mask contains bits other than GL_COLOR_BUFFER_BIT, "
-                                             "GL_DEPTH_BUFFER_BIT and GL_STENCIL_BUFFER_BIT."));
-            return false;
-        }
-        if (filter != GL_NEAREST && filter != GL_LINEAR) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             "filter must be GL_NEAREST or GL_LINEAR."));
-            return false;
-        }
-        // Depth and stencil have no meaningful interpolation, so GL_LINEAR is rejected outright
-        // rather than downgraded - even when the mask also carries the colour bit.
-        if (filter == GL_LINEAR && (mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             "GL_LINEAR filtering is not allowed when mask includes "
-                                             "GL_DEPTH_BUFFER_BIT or GL_STENCIL_BUFFER_BIT."));
-            return false;
-        }
-        return true;
-    }
-
     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) {
-        if (!ValidateBlitMaskAndFilter(__func__, mask, filter)) return;
         BlitNamedFramebuffer_State(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
                                    dstY1, mask, filter);
     }
 
     void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1,
                          GLint dstY1, GLbitfield mask, GLenum filter) {
-        if (!ValidateBlitMaskAndFilter(__func__, mask, filter)) return;
         BlitFramebuffer_Backend(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
     }
 

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.h

@@ -24,25 +24,4 @@ namespace MobileGL::MG_Impl::GLImpl {
     void GetInteger64i_v(GLenum target, GLuint index, GLint64* data);
     GLenum GetError();
     GLenum GetGraphicsResetStatus();
-    // The GL_MAX_SAMPLES value MobileGL advertises, i.e. the driver's value floored to the GL
-    // core minimum of 4. This is the RENDERBUFFER ceiling; the three per-category texture
-    // ceilings below have a minimum of one and are reported as probed.
-    GLint GetAdvertisedMaxSamples();
-    // Exactly what GL_MAX_COLOR_TEXTURE_SAMPLES / GL_MAX_DEPTH_TEXTURE_SAMPLES /
-    // GL_MAX_INTEGER_SAMPLES report: the probed backend limit floored at the GL 4.6 core minimum
-    // of ONE (table 23.53). Exported so the frontend's storage validation enforces exactly what
-    // the query promised - it used to floor both at 4 and then let the backend quietly
-    // under-allocate whatever the driver could not actually provide.
-    GLint GetAdvertisedColorTextureMaxSamples();
-    GLint GetAdvertisedDepthTextureMaxSamples();
-    GLint GetAdvertisedIntegerMaxSamples();
-    // What glGetIntegerv(GL_SAMPLES) answers for the CURRENT draw framebuffer: the largest sample
-    // count over its attachments, and 0 for a single-sample or default framebuffer (GL 4.6 core
-    // 9.2.3 / 22.2 - GL_SAMPLE_BUFFERS is 1 exactly when this is non-zero).
-    //
-    // Shared rather than duplicated because two callers need the identical number and disagreeing
-    // would be a silent bug: the query itself, and the draw path's write of the reserved
-    // gl_NumSamples stand-in - a shader comparing gl_NumSamples against glGetIntegerv(GL_SAMPLES)
-    // is exactly what the sample_variables CTS does.
-    GLint ResolveDrawFramebufferSampleCount();
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Program/GL_Program.h

@@ -13,12 +13,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     void AttachShader(GLuint program, GLuint shader);
     void BindAttribLocation(GLuint program, GLuint index, const GLchar* name);
     void CompileShader(GLuint shader);
-    // GL_ARB_gl_spirv, core since 4.6. The pair is a two-step operation: glShaderBinary attaches
-    // the module to one or more shader objects, glSpecializeShader names its entry point and
-    // supplies its specialization constants and is what actually compiles them.
-    void ShaderBinary(GLsizei count, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length);
-    void SpecializeShader(GLuint shader, const GLchar* pEntryPoint, GLuint numSpecializationConstants,
-                          const GLuint* pConstantIndex, const GLuint* pConstantValue);
     GLuint CreateProgram(void);
     GLuint CreateShader(GLenum type);
     void DeleteProgram(GLuint program);
@@ -146,7 +140,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                               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 GetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint* params);
     void ShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
     void Uniform1d(GLint location, GLdouble v0);
     void Uniform1dv(GLint location, GLsizei count, const GLdouble* value);

MobileGL/MG_Impl/GLImpl/Program/GL_ProgramPipeline.cpp

@@ -19,26 +19,16 @@ namespace MobileGL::MG_Impl::GLImpl {
                 code, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", function, Move(message)));
         }
 
-        // GL 4.6 core 7.4 asks only that the name came from GenProgramPipelines and has not been
-        // deleted - so a name that was reserved and never bound is legal here, and the command
-        // MATERIALIZES it rather than rejecting it.
-        //
-        // Requiring a bound object instead is what broke every separable-program conformance case
-        // across three families: the CTS reserves a name, calls glUseProgramStages three times and
-        // only then binds, which is the order the spec's own example uses. Each of those calls
-        // failed with INVALID_OPERATION, so the stage programs were never recorded - the pipeline
-        // stayed empty, GetProgramForDraw flattened nothing and the draw painted nothing, and the
-        // rejected calls' error was left in the queue for the harness to find. One cause, both
-        // symptoms.
+        // 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) {
-            const auto& object = MG_State::pGLContext->MaterializeProgramPipelineObject(pipeline);
-            if (!object) {
+            if (!MG_State::pGLContext->IsProgramPipelineObject(pipeline)) {
                 RecordPipelineError(ErrorCode::InvalidOperation, function,
                                     std::format("Program pipeline {} does not exist.", pipeline));
                 return nullptr;
             }
-            return &object;
+            return &MG_State::pGLContext->GetProgramPipelineObject(pipeline);
         }
 
         Bool ValidatePipelineCount(GLsizei n, const char* function) {
@@ -192,15 +182,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                                     std::format("Program {} has not been linked successfully.", program));
                 return;
             }
-            // GL 4.6 core 7.4: "INVALID_OPERATION is generated if program was not linked with its
-            // PROGRAM_SEPARABLE status set". The LATCHED flag is the one that decides - a program
-            // whose live flag was cleared after a separable link is still a legal stage, and a
-            // program whose live flag was set after a non-separable link is not.
-            if (!programObject->GetLinkedSeparable()) {
-                RecordPipelineError(ErrorCode::InvalidOperation, __func__,
-                                    std::format("Program {} was not linked as a separable program.", program));
-                return;
-            }
         }
 
         const GLbitfield selected = stages == GL_ALL_SHADER_BITS ? kAllStageBits : stages;

MobileGL/MG_Impl/GLImpl/Program/ProgramInterface.cpp

@@ -19,7 +19,7 @@ namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
         // "<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 = MG_Util::ShaderTranspiler::ATOMIC_COUNTER_BLOCK_PREFIX;
+        constexpr const char* kAtomicCounterBlockPrefix = "gl_AtomicCounterBlock";
 
         enum class BlockKind {
             Uniform,       // a real GL uniform block
@@ -81,18 +81,19 @@ namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
         // 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 ProgramObject::TypeFacts& type) {
-            if (!type.isArray || EndsWithZeroSubscript(name)) return name;
+        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.
-        // `record.arraySize` is already the sized-array/reflected-size resolution; the only
-        // extra rule here is GL's 0 for a runtime-sized array.
-        GLint ArraySizeOf(const ProgramObject::ResourceReflection& record) {
-            if (record.type.isArray && !record.type.isSizedArray) return 0;
-            return record.arraySize;
+        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
@@ -173,21 +174,22 @@ namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
             return static_cast<GLint>(element);
         }
 
-        BlockKind ClassifyBlock(const ProgramObject::BlockReflection& block) {
+        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;
-            if (block.type.isBuffer) return BlockKind::Storage;
+            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 ProgramObject::TypeFacts& type) {
-            if (!type.isMatrix) return 0;
-            const bool rowMajor = type.layoutMatrix == static_cast<Int>(glslang::ElmRowMajor);
-            const int strideVectorComponents = rowMajor ? type.matrixCols : type.matrixRows;
+        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
@@ -195,9 +197,9 @@ namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
             return (vectorAlignment + 15) & ~15;
         }
 
-        GLint IsRowMajorOf(const ProgramObject::TypeFacts& type) {
-            if (!type.isMatrix) return 0;
-            return type.layoutMatrix == static_cast<Int>(glslang::ElmRowMajor) ? 1 : 0;
+        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) {
@@ -208,69 +210,14 @@ namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
 
         // ---- model construction --------------------------------------------------------
 
-        // GL_REFERENCED_BY_*_SHADER for an ARRAYED block instance, refined per element.
-        //
-        // glslang records a block reference by walking up to the base symbol and calling
-        // addBlockName with the whole ARRAY type, which ORs the referencing stage into every
-        // element at once - it has not resolved the subscript yet at that point. So reading
-        // "e[0].b" marks both TrickyBlock[0] and TrickyBlock[1] as referenced by the fragment
-        // stage (KHR-GL43.program_interface_query.uniform-block-types).
-        //
-        // The MEMBER masks are exact: EShReflectionAllBlockVariables enumerates every member of
-        // every element with the stage mask suppressed, and only the dereference chain actually
-        // walked turns a bit on - and that chain carries the subscript. So the union of a block
-        // instance's members is the reference set of that instance.
-        //
-        // Applied ONLY to arrayed instances, because for a scalar block glslang is already exact.
-        // Note the union is used even when it is empty: an array element nobody dereferenced has
-        // no member bits and is genuinely referenced by nobody, which is the whole point - falling
-        // back to the block's own mask there would restore the over-approximation.
-        Vector<Uint32> BuildBlockStagesFromMembers(const ProgramObject::LinkArtifacts& reflection,
-                                                    Int blockCount) {
-            Vector<Uint32> stagesByBlock(static_cast<SizeT>(blockCount < 0 ? 0 : blockCount), 0u);
-            const Int uniformCount = static_cast<Int>(reflection.uniformReflection.size());
-            for (Int index = 0; index < uniformCount; ++index) {
-                const auto& uniform = reflection.uniformReflection[index];
-                const Int owner = uniform.index;
-                if (owner < 0 || owner >= blockCount) continue;
-                stagesByBlock[static_cast<SizeT>(owner)] |= static_cast<Uint32>(uniform.stages);
-            }
-            return stagesByBlock;
-        }
-
-        // UNIFORM blocks only, and that scope is load-bearing rather than cautious. The member
-        // names glslang produces for a uniform block array carry the subscript
-        // ("TrickyBlock[0].b", via EShReflectionStrictArraySuffix), so each element's members are
-        // distinct entries and the bits land on the right one. A SHADER STORAGE block array does
-        // NOT get that treatment - its buffer variables reflect under one subscript-free spelling
-        // shared by every element - so a union over them credits element 0 and starves the rest.
-        // KHR-GL43.program_interface_query.ssb-types is the case that says so: it reads ss[0] and
-        // ss[1] and requires both to report the fragment stage, which only glslang's own
-        // (deliberately over-approximating) block mask gets right. Storage and atomic-counter
-        // blocks therefore keep that mask untouched.
-        Uint32 UniformBlockStages(const ProgramObject::BlockReflection& block, const Vector<Uint32>& stagesFromMembers,
-                                  Int tIndex) {
-            String arrayBase;
-            Uint element = 0;
-            Bool malformed = false;
-            if (!SplitTrailingSubscript(block.name, arrayBase, element, malformed) || malformed) {
-                return static_cast<Uint32>(block.stages);
-            }
-            if (tIndex < 0 || tIndex >= static_cast<Int>(stagesFromMembers.size())) {
-                return static_cast<Uint32>(block.stages);
-            }
-            return stagesFromMembers[static_cast<SizeT>(tIndex)];
-        }
-
-        void BuildBlocks(ProgramObject& program, const ProgramObject::LinkArtifacts& reflection, Model& model,
+        void BuildBlocks(ProgramObject& program, const glslang::TProgram& reflection, Model& model,
                          Vector<BlockKind>& blockKind, Vector<Int>& blockInterfaceIndex) {
-            const Int blockCount = static_cast<Int>(reflection.blockReflection.size());
+            const Int blockCount = const_cast<glslang::TProgram&>(reflection).getNumUniformBlocks();
             blockKind.assign(blockCount, BlockKind::Uniform);
             blockInterfaceIndex.assign(blockCount, -1);
-            const Vector<Uint32> stagesFromMembers = BuildBlockStagesFromMembers(reflection, blockCount);
 
             for (Int tIndex = 0; tIndex < blockCount; ++tIndex) {
-                const auto& block = reflection.blockReflection[tIndex];
+                const auto& block = const_cast<glslang::TProgram&>(reflection).getUniformBlock(tIndex);
                 const BlockKind kind = ClassifyBlock(block);
                 blockKind[tIndex] = kind;
                 if (kind == BlockKind::AtomicCounter) {
@@ -291,7 +238,7 @@ namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
                     // 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.binding;
+                    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);
@@ -305,53 +252,38 @@ namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
             // 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.GetGlUniformBlockCount();
+            const Int glBlockCount = program.GetActiveUniformBlocksCount();
             for (Int glIndex = 0; glIndex < glBlockCount; ++glIndex) {
-                // The block-space index the block-keyed accessors want; the two spaces differ
-                // whenever the program also has a storage or atomic counter block, which
-                // glslang files under the same reflection list (no EShReflectionSeparateBuffers).
-                const Int blockIndex = program.BlockIndexFromGlUniformBlock(static_cast<Uint>(glIndex));
                 Resource resource;
-                resource.name = program.GetUniformBlockName(static_cast<Uint>(blockIndex));
-                resource.bufferBinding = static_cast<GLint>(program.GetUniformBlockBinding(static_cast<Uint>(blockIndex)));
-                resource.bufferDataSize = static_cast<GLint>(program.GetUBOSizeAt(static_cast<Uint>(blockIndex)));
-                const Int tIndex = program.TProgramBlockIndex(static_cast<Uint>(blockIndex));
+                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 = UniformBlockStages(reflection.blockReflection[tIndex],
-                                                      stagesFromMembers, tIndex);
+                    resource.stages =
+                        static_cast<Uint32>(const_cast<glslang::TProgram&>(reflection).getUniformBlock(tIndex).stages);
                 }
                 model.uniformBlocks.push_back(Move(resource));
             }
         }
 
-        void BuildUniformsAndBufferVariables(ProgramObject& program,
-                                             const ProgramObject::LinkArtifacts& reflection, Model& model,
+        void BuildUniformsAndBufferVariables(ProgramObject& program, const glslang::TProgram& reflection, Model& model,
                                              const Vector<BlockKind>& blockKind,
                                              const Vector<Int>& blockInterfaceIndex) {
-            // Walks the TPROGRAM uniform space, not the GL one. A buffer variable is not a GL
-            // uniform (GL 4.6 core 7.3.1) and DoReflection therefore keeps it out of the GL
-            // active-uniform index space - but GL_BUFFER_VARIABLE still has to enumerate it, and
-            // this is the only place that does. GL uniforms keep their GL index as their
-            // GL_UNIFORM resource index: the GL space is a subsequence of this one, so pushing
-            // the GL-visible entries in this order preserves the correspondence.
-            const Int tUniformCount = static_cast<Int>(reflection.uniformReflection.size());
-            for (Int tIndex = 0; tIndex < tUniformCount; ++tIndex) {
-                const auto& refl = ProgramObject::UniformAtIn(reflection, tIndex);
-                const auto& type = refl.type;
+            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;
-                const Int glIndex = program.GlUniformIndexFromTProgram(tIndex);
-                // Everything except a buffer variable is enumerated through the GL space, so a
-                // uniform the relaxed parse swept out of it (a declared-but-dead default-block
-                // one) stays out of GL_UNIFORM too.
-                if (kind != BlockKind::Storage && glIndex < 0) continue;
 
                 Resource resource;
                 resource.name = refl.name;
                 resource.type = static_cast<GLenum>(refl.glDefineType);
-                resource.arraySize = ArraySizeOf(refl);
+                resource.arraySize = ArraySizeOf(type, refl.size);
                 resource.stages = static_cast<Uint32>(refl.stages);
 
                 if (kind == BlockKind::Storage) {
@@ -379,12 +311,11 @@ namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
                     resource.atomicCounterBufferIndex = blockInterfaceIndex[owner];
                     resource.location = -1;
                 } else {
-                    const Uint glUniformIndex = static_cast<Uint>(glIndex);
-                    resource.blockIndex = program.GetActiveUniformBlockIndex(glUniformIndex);
-                    resource.offset = program.GetActiveUniformOffset(glUniformIndex);
-                    resource.arrayStride = program.GetActiveUniformArrayStride(glUniformIndex);
-                    resource.matrixStride = program.GetActiveUniformMatrixStride(glUniformIndex);
-                    resource.isRowMajor = program.GetActiveUniformIsRowMajor(glUniformIndex);
+                    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).
@@ -403,16 +334,12 @@ namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
                         static_cast<GLuint>(i));
                 }
             }
-            for (SizeT glBlockIndex = 0; glBlockIndex < model.uniformBlocks.size(); ++glBlockIndex) {
+            for (SizeT blockIndex = 0; blockIndex < model.uniformBlocks.size(); ++blockIndex) {
                 // Members of an arrayed block are reflected once, against instance [0].
-                // GetUniformBlockMemberOwnerIndex takes and answers BLOCK indices, while
-                // Resource::blockIndex is a GL_UNIFORM_BLOCK index, so translate both ways.
-                const Int blockIndex = program.BlockIndexFromGlUniformBlock(static_cast<Uint>(glBlockIndex));
-                const Int owner = program.GlUniformBlockIndexFromBlock(
-                    static_cast<Int>(program.GetUniformBlockMemberOwnerIndex(static_cast<Uint>(blockIndex))));
+                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[glBlockIndex].activeVariables.push_back(static_cast<GLuint>(i));
+                        model.uniformBlocks[blockIndex].activeVariables.push_back(static_cast<GLuint>(i));
                     }
                 }
             }
@@ -425,67 +352,49 @@ namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
             }
         }
 
-        // A built-in interface block that a shader redeclares with fewer members keeps the
-        // omitted ones in its type when the redeclaration is ANONYMOUS - glslang hides them
-        // (basic type void) instead of erasing them, because the original shared declaration
-        // has to stay usable. Only the instance-named form erases. So a separable vertex
-        // program that redeclares `out gl_PerVertex { vec4 gl_Position; }` still carries
-        // gl_PointSize and gl_ClipDistance through the block-unwrapping reflection, and they
-        // are not part of its output interface.
-        Bool IsHiddenBlockMember(const ProgramObject::TypeFacts& type) { return type.isVoid; }
+        void BuildStageIO(ProgramObject& program, const glslang::TProgram& reflection, Model& model) {
+            auto& mutableReflection = const_cast<glslang::TProgram&>(reflection);
 
-        void BuildStageIO(ProgramObject& program, const ProgramObject::LinkArtifacts& reflection, Model& model) {
-            const Int inputCount = static_cast<Int>(reflection.pipeInputReflection.size());
+            const Int inputCount = mutableReflection.getNumPipeInputs();
             for (Int index = 0; index < inputCount; ++index) {
-                const auto& refl = reflection.pipeInputReflection[index];
-                const auto& type = refl.type;
-                if (IsHiddenBlockMember(type)) continue;
+                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(refl);
+                resource.arraySize = ArraySizeOf(type, refl.size);
                 resource.location = program.GetAttributeLocation(refl.name);
-                if (resource.location < 0) resource.location = MappedLocation(refl.location);
-                resource.isPerPatch = type.isPatch ? 1 : 0;
+                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));
             }
 
-            // A color number, and therefore a color INDEX, exists only for a fragment stage's
-            // outputs. The output interface belongs to the program's last stage, so for a
-            // separable tessellation/geometry/vertex program these are varyings: asking the
-            // frag-data maps about them can still answer a location (a tess-control output
-            // carries its own layout(location=N)), and a location then manufactures a color
-            // index of 0 where GL requires -1
-            // (KHR-GL43.program_interface_query.separate-programs-tess-control).
-            const Bool lastStageIsFragment = reflection.lastStageIsFragment;
-            const Int outputCount = static_cast<Int>(reflection.pipeOutputReflection.size());
+            const Int outputCount = mutableReflection.getNumPipeOutputs();
             for (Int index = 0; index < outputCount; ++index) {
-                const auto& refl = reflection.pipeOutputReflection[index];
-                const auto& type = refl.type;
-                if (IsHiddenBlockMember(type)) continue;
+                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(refl);
+                resource.arraySize = ArraySizeOf(type, refl.size);
                 resource.location = MappedLocation(program.GetFragmentDataLocation(refl.name.c_str()));
-                if (resource.location < 0 || !lastStageIsFragment) {
-                    // A built-in output (gl_FragDepth, gl_SampleMask) has no location, and a
-                    // non-fragment stage's outputs have no color number at all - either way there
-                    // is no color index.
+                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.hasIndex) {
-                        resource.locationIndex = static_cast<GLint>(type.layoutIndex);
+                    if (resource.locationIndex == 0 && type != nullptr && type->getQualifier().hasIndex()) {
+                        resource.locationIndex = static_cast<GLint>(type->getQualifier().layoutIndex);
                     }
                 }
-                resource.isPerPatch = type.isPatch ? 1 : 0;
+                resource.isPerPatch = (type != nullptr && type->getQualifier().patch) ? 1 : 0;
                 resource.stages = static_cast<Uint32>(refl.stages);
                 model.programOutputs.push_back(Move(resource));
             }
@@ -525,14 +434,15 @@ namespace MobileGL::MG_Impl::GLImpl::ProgramInterface {
         Model BuildModel(ProgramObject& program) {
             Model model;
             if (!program.GetLinkStatus()) return model;
-            const ProgramObject::LinkArtifacts& reflection = program.GetLinkReflection();
+            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);
+            BuildBlocks(program, *reflection, model, blockKind, blockInterfaceIndex);
+            BuildUniformsAndBufferVariables(program, *reflection, model, blockKind, blockInterfaceIndex);
+            BuildStageIO(program, *reflection, model);
             BuildXfb(program, model);
             return model;
         }

MobileGL/MG_Impl/GLImpl/Query/GL_Query.cpp

@@ -12,7 +12,6 @@
 #include <MG_Backend/BackendObjects.h>
 #include <MG_State/GLState/Core.h>
 #include <MG_State/GLState/ErrorState/ErrorInfo.h>
-#include <MG_Impl/Pipe/PipeFill.h>
 
 namespace MobileGL::MG_Impl::GLImpl {
     namespace {
@@ -32,15 +31,8 @@ namespace MobileGL::MG_Impl::GLImpl {
             Bool ended = false;
             Bool resultCached = false;
             Uint64 cachedResult = 0;
-            // The transform feedback primitive counter matching this query's target, at
-            // BeginQuery time.
+            // Transform feedback primitive counter at BeginQuery time.
             Uint64 counterSnapshot = 0;
-            // Capture-draw counters at BeginQuery time: how many capture draws the CPU
-            // accounting had reproduced exactly, and how many of those it could not (a
-            // geometry stage amplifies). Their deltas decide whether the CPU result may
-            // stand in for the backend's.
-            Uint64 accountedCaptureDrawSnapshot = 0;
-            Uint64 geometryCaptureDrawSnapshot = 0;
         };
 
         // Query calls may arrive from any thread (launchers migrate the context
@@ -60,62 +52,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         GLuint g_activePrimitivesGeneratedQueryId = 0;
         // Id of the query active on GL_SAMPLES_PASSED (0 = none).
         GLuint g_activeSamplesPassedQueryId = 0;
-        // Ids of the queries active on the GL_ARB_pipeline_statistics_query targets, one slot per
-        // target (0 = none). A map rather than a field per target: the eleven behave identically
-        // and none of them has any state beyond "which object is counting".
-        UnorderedMap<GLenum, GLuint> g_activePipelineStatisticsQueryIds;
-
-        // Whether MobileGL puts GL_ARB_tessellation_shader in its extension string. Read from the
-        // ADVERTISED list rather than from a capability bit for the same reason
-        // BackendSupportsTextureViews does (GL_Texture.cpp): it makes "MobileGL claims tessellation
-        // support" and "the tessellation-conditional API surface is open" the same fact by
-        // construction, so the day a backend starts advertising the string the surface below opens
-        // with it and no second edit is owed.
-        Bool AdvertisesTessellationShaderExtension() {
-            const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
-            if (!activeBackendObject) return false;
-            const auto& extensions = activeBackendObject->GetRendererInfo().RendererGLInfo.Extensions;
-            return std::find(extensions.begin(), extensions.end(), E_GL_ARB_tessellation_shader) != extensions.end();
-        }
-
-        // The eleven pipeline-statistics counters (GL 4.6 core table 4.3 / ARB_pipeline_statistics_query).
-        // A 4.6 core context ACCEPTS the nine unconditional ones at glBeginQuery - there is no query
-        // by which an application could learn otherwise before calling. MobileGL instruments none of
-        // them, and says so the way GL 4.6 core 4.2.1 provides for: GL_QUERY_COUNTER_BITS answers
-        // zero for these targets, which is the spec's own signal that the counter is unsupported and
-        // its results indeterminate. That is an honest zero, not an advertised capability - the
-        // alternative, GL_INVALID_ENUM on a core entry point, is both non-conformant AND less
-        // informative.
-        //
-        // The two TESSELLATION targets are the exception, because ARB_pipeline_statistics_query
-        // makes them conditional on tessellation support rather than unconditional, and the only
-        // thing an application (or the conformance suite) can read to decide whether an
-        // implementation has it is the GL_ARB_tessellation_shader string. MobileGL does not emit it
-        // today, so these two answer GL_INVALID_ENUM: an API surface that accepts a
-        // tessellation-conditional token while withholding the string that announces the condition
-        // is self-contradictory, and it is the contradiction the suite catches
-        // (KHR-GL46.pipeline_statistics_query_tests_ARB.api_coverage_unsupported_calls, whose
-        // support probe is gl4cPipelineStatisticsQueryTests.cpp:1166-1176). The gate is the
-        // advertisement itself, not a hardcoded "no", so this is one switch and not two.
-        Bool IsPipelineStatisticsQueryTarget(GLenum target) {
-            switch (target) {
-            case GL_VERTICES_SUBMITTED:
-            case GL_PRIMITIVES_SUBMITTED:
-            case GL_VERTEX_SHADER_INVOCATIONS:
-            case GL_GEOMETRY_SHADER_INVOCATIONS:
-            case GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED:
-            case GL_FRAGMENT_SHADER_INVOCATIONS:
-            case GL_COMPUTE_SHADER_INVOCATIONS:
-            case GL_CLIPPING_INPUT_PRIMITIVES:
-            case GL_CLIPPING_OUTPUT_PRIMITIVES:
-                return true;
-            case GL_TESS_CONTROL_SHADER_PATCHES:
-            case GL_TESS_EVALUATION_SHADER_INVOCATIONS:
-                return AdvertisesTessellationShaderExtension();
-            default:
-                return false;
-            }
-        }
 
         Bool TimerQueryDisabled() {
             return MG_Config::Features.DisableTimerQuery;
@@ -165,7 +101,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         void ResetQueryObjectLocked(QueryObject* queryObject) {
             if (queryObject->backendHandle) {
                 if (const auto deleteBackendQuery = MG_Backend::gBackendFunctionsTable.GL.DeleteBackendQuery) {
-                    MGP_FILL(DeleteBackendQuery);
                     deleteBackendQuery(queryObject->backendHandle);
                 }
                 queryObject->backendHandle = nullptr;
@@ -180,7 +115,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         void EndTimeElapsedQueryLocked(QueryObject* queryObject) {
             const auto endTimeElapsedQuery = MG_Backend::gBackendFunctionsTable.GL.EndTimeElapsedQuery;
             if (endTimeElapsedQuery && queryObject->backendHandle) {
-                MGP_FILL(EndTimeElapsedQuery);
                 endTimeElapsedQuery(queryObject->backendHandle);
             }
             queryObject->active = false;
@@ -188,46 +122,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             g_activeTimeElapsedQueryId = 0;
         }
 
-        // The CPU accounting counter a transform feedback query target reads: what the capture
-        // buffers took for GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, and everything the capture
-        // stage assembled - a paused span included - for GL_PRIMITIVES_GENERATED. One counter
-        // for both targets would report the clamped written count as the generated one.
-        Uint64 TransformFeedbackCounterForTarget(GLenum target) {
-            return target == GL_PRIMITIVES_GENERATED
-                       ? MG_State::pGLContext->GetTransformFeedbackGeneratedCounter()
-                       : MG_State::pGLContext->GetTransformFeedbackPrimitiveCounter();
-        }
-
-        // The span's CPU accounting delta. Saturating: a snapshot left above its counter (a
-        // context switch between Begin and End, a counter that never moved) would otherwise
-        // wrap to 2^64-1, which GetQueryObjectuiv hands the app as 4294967295.
-        Uint64 TransformFeedbackCpuResult(const QueryObject* queryObject) {
-            const Uint64 counter = TransformFeedbackCounterForTarget(queryObject->target);
-            return counter > queryObject->counterSnapshot ? counter - queryObject->counterSnapshot : 0;
-        }
-
-        // Whether this ended span's result should come from the CPU accounting rather than from
-        // the backend query it also ran. Three conditions, all necessary:
-        //   * the backend asked for it (DirectGLES, whose ES driver counter is the unreliable
-        //     one; DirectVulkan never sets the bit and so is untouched by any of this);
-        //   * the target is PRIMITIVES_WRITTEN. GL_PRIMITIVES_GENERATED counts primitives
-        //     whether or not a capture is active, and the accounting only ever sees capture
-        //     draws, so the backend's counter is the more complete answer there;
-        //   * the span was fully accounted: at least one capture draw reached the accounting
-        //     (the instanced, indirect and multi-draw entry points do not call it at all, so a
-        //     span made of those is invisible to it) and none of them amplified through a
-        //     geometry stage, which the CPU cannot model.
-        Bool PrefersCpuTransformFeedbackResult(const QueryObject* queryObject) {
-            if (!MG_Backend::gBackendFunctionsTable.GL.PrefersCpuXfbPrimitiveAccounting) return false;
-            if (queryObject->target != GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN) return false;
-            if (MG_State::pGLContext->GetTransformFeedbackGeometryCaptureDraws() !=
-                queryObject->geometryCaptureDrawSnapshot) {
-                return false;
-            }
-            return MG_State::pGLContext->GetTransformFeedbackAccountedCaptureDraws() !=
-                   queryObject->accountedCaptureDrawSnapshot;
-        }
-
         // 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
@@ -260,7 +154,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                 }
                 Uint64 result = 0;
                 const auto getQueryResult64 = MG_Backend::gBackendFunctionsTable.GL.GetQueryResult64;
-                MGP_FILL(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
@@ -275,7 +168,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                 }
                 if (queryObject->backendHandle) {
                     if (const auto deleteBackendQuery = MG_Backend::gBackendFunctionsTable.GL.DeleteBackendQuery) {
-                        MGP_FILL(DeleteBackendQuery);
                         deleteBackendQuery(queryObject->backendHandle);
                     }
                     queryObject->backendHandle = nullptr;
@@ -291,7 +183,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                     return true;
                 }
                 const auto isQueryResultAvailable = MG_Backend::gBackendFunctionsTable.GL.IsQueryResultAvailable;
-                MGP_FILL(IsQueryResultAvailable);
                 outValue = (!isQueryResultAvailable || isQueryResultAvailable(queryObject->backendHandle)) ? 1 : 0;
                 return true;
             }
@@ -303,7 +194,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                 Uint64 result = 0;
                 if (queryObject->backendHandle) {
                     const auto getQueryResult64 = MG_Backend::gBackendFunctionsTable.GL.GetQueryResult64;
-                    MGP_FILL(GetQueryResult64);
                     if (getQueryResult64 &&
                         !getQueryResult64(queryObject->backendHandle, /*wait=*/true, &result)) {
                         // The backend could not produce the result YET (e.g. a
@@ -324,7 +214,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                     // query degrades to a zero result); the backend handle is
                     // consumed and the value cached for later reads.
                     if (const auto deleteBackendQuery = MG_Backend::gBackendFunctionsTable.GL.DeleteBackendQuery) {
-                        MGP_FILL(DeleteBackendQuery);
                         deleteBackendQuery(queryObject->backendHandle);
                     }
                     queryObject->backendHandle = nullptr;
@@ -430,14 +319,10 @@ namespace MobileGL::MG_Impl::GLImpl {
                     queryObject->target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
                     if (const auto endOcclusionQuery = MG_Backend::gBackendFunctionsTable.GL.EndOcclusionQuery;
                         endOcclusionQuery && queryObject->backendHandle) {
-                        MGP_FILL(EndOcclusionQuery);
                         endOcclusionQuery(queryObject->backendHandle);
                     }
                     queryObject->active = false;
                     g_activeSamplesPassedQueryId = 0;
-                } else if (IsPipelineStatisticsQueryTarget(queryObject->target)) {
-                    queryObject->active = false;
-                    g_activePipelineStatisticsQueryIds[queryObject->target] = 0;
                 } else if (queryObject->target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ||
                            queryObject->target == GL_PRIMITIVES_GENERATED) {
                     queryObject->active = false;
@@ -450,7 +335,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
             if (queryObject->backendHandle) {
                 if (const auto deleteBackendQuery = MG_Backend::gBackendFunctionsTable.GL.DeleteBackendQuery) {
-                    MGP_FILL(DeleteBackendQuery);
                     deleteBackendQuery(queryObject->backendHandle);
                 }
                 queryObject->backendHandle = nullptr;
@@ -479,9 +363,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             (target == GL_SAMPLES_PASSED || target == GL_ANY_SAMPLES_PASSED ||
              target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) &&
             MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery != nullptr;
-        const Bool isPipelineStatisticsQuery = IsPipelineStatisticsQueryTarget(target);
-        if (target != GL_TIME_ELAPSED && !isTransformFeedbackQuery && !isOcclusionQuery &&
-            !isPipelineStatisticsQuery) {
+        if (target != GL_TIME_ELAPSED && !isTransformFeedbackQuery && !isOcclusionQuery) {
             // GL_TIMESTAMP is not a valid BeginQuery target; the occlusion targets
             // need backend support.
             RecordQueryError(ErrorCode::InvalidEnum, __FUNCTION__, "Query target is not supported.");
@@ -497,12 +379,10 @@ namespace MobileGL::MG_Impl::GLImpl {
             RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__, "Query object does not exist.");
             return;
         }
-        GLuint& activeQueryId = isPipelineStatisticsQuery
-            ? g_activePipelineStatisticsQueryIds[target]
-            : (isTransformFeedbackQuery
-                   ? (target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ? g_activePrimitivesWrittenQueryId
-                                                                         : g_activePrimitivesGeneratedQueryId)
-                   : (isOcclusionQuery ? g_activeSamplesPassedQueryId : g_activeTimeElapsedQueryId));
+        GLuint& activeQueryId = isTransformFeedbackQuery
+            ? (target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ? g_activePrimitivesWrittenQueryId
+                                                                  : g_activePrimitivesGeneratedQueryId)
+            : (isOcclusionQuery ? g_activeSamplesPassedQueryId : g_activeTimeElapsedQueryId);
         if (activeQueryId != 0) {
             RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__,
                              "A query is already active on this target.");
@@ -521,28 +401,17 @@ namespace MobileGL::MG_Impl::GLImpl {
         ResetQueryObjectLocked(queryObject); // discard any previous result
         queryObject->target = target;
         queryObject->active = true;
-        if (isPipelineStatisticsQuery) {
-            // Nothing to start: the counter is uninstrumented and GL_QUERY_COUNTER_BITS says so.
-            // The object still becomes a real, target-latched query so every other rule about it
-            // (re-use with another target, double-begin, EndQuery pairing) keeps holding.
-        } else if (isTransformFeedbackQuery) {
+        if (isTransformFeedbackQuery) {
             // Prefer real GPU transform-feedback queries (exact with geometry shaders);
             // the CPU accounting delta stays as the fallback when the backend lacks them.
             const auto beginXfbPrimitivesQuery = MG_Backend::gBackendFunctionsTable.GL.BeginXfbPrimitivesQuery;
-            MGP_FILL(BeginXfbPrimitivesQuery);
             queryObject->backendHandle =
                 beginXfbPrimitivesQuery ? beginXfbPrimitivesQuery(target == GL_PRIMITIVES_GENERATED) : nullptr;
-            queryObject->counterSnapshot = TransformFeedbackCounterForTarget(target);
-            queryObject->accountedCaptureDrawSnapshot =
-                MG_State::pGLContext->GetTransformFeedbackAccountedCaptureDraws();
-            queryObject->geometryCaptureDrawSnapshot =
-                MG_State::pGLContext->GetTransformFeedbackGeometryCaptureDraws();
+            queryObject->counterSnapshot = MG_State::pGLContext->GetTransformFeedbackPrimitiveCounter();
         } else if (isOcclusionQuery) {
-            MGP_FILL(BeginOcclusionQuery);
             queryObject->backendHandle = MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery();
         } else {
             const auto beginTimeElapsedQuery = MG_Backend::gBackendFunctionsTable.GL.BeginTimeElapsedQuery;
-            MGP_FILL(BeginTimeElapsedQuery);
             queryObject->backendHandle =
                 (!TimerQueryDisabled() && beginTimeElapsedQuery) ? beginTimeElapsedQuery() : nullptr;
         }
@@ -556,19 +425,15 @@ namespace MobileGL::MG_Impl::GLImpl {
             (target == GL_SAMPLES_PASSED || target == GL_ANY_SAMPLES_PASSED ||
              target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) &&
             MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery != nullptr;
-        const Bool isPipelineStatisticsQuery = IsPipelineStatisticsQueryTarget(target);
-        if (target != GL_TIME_ELAPSED && !isTransformFeedbackQuery && !isOcclusionQuery &&
-            !isPipelineStatisticsQuery) {
+        if (target != GL_TIME_ELAPSED && !isTransformFeedbackQuery && !isOcclusionQuery) {
             RecordQueryError(ErrorCode::InvalidEnum, __FUNCTION__, "Query target is not supported.");
             return;
         }
         const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
-        GLuint& activeQueryId = isPipelineStatisticsQuery
-            ? g_activePipelineStatisticsQueryIds[target]
-            : (isTransformFeedbackQuery
-                   ? (target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ? g_activePrimitivesWrittenQueryId
-                                                                         : g_activePrimitivesGeneratedQueryId)
-                   : (isOcclusionQuery ? g_activeSamplesPassedQueryId : g_activeTimeElapsedQueryId));
+        GLuint& activeQueryId = isTransformFeedbackQuery
+            ? (target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ? g_activePrimitivesWrittenQueryId
+                                                                  : g_activePrimitivesGeneratedQueryId)
+            : (isOcclusionQuery ? g_activeSamplesPassedQueryId : g_activeTimeElapsedQueryId);
         if (activeQueryId == 0) {
             RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__, "No query is active on this target.");
             return;
@@ -578,39 +443,17 @@ namespace MobileGL::MG_Impl::GLImpl {
             activeQueryId = 0; // should not happen; keep state consistent
             return;
         }
-        if (isPipelineStatisticsQuery) {
-            // The result is a definite zero rather than an unread backend handle, so a later
-            // GetQueryObject* answers immediately and never waits on something that was never
-            // started. GL_QUERY_COUNTER_BITS = 0 is what marks that zero indeterminate.
-            queryObject->cachedResult = 0;
-            queryObject->resultCached = true;
-            queryObject->active = false;
-            queryObject->ended = true;
-            activeQueryId = 0;
-            return;
-        }
         if (isTransformFeedbackQuery) {
             if (queryObject->backendHandle) {
                 if (const auto endXfbPrimitivesQuery = MG_Backend::gBackendFunctionsTable.GL.EndXfbPrimitivesQuery) {
-                    MGP_FILL(EndXfbPrimitivesQuery);
                     endXfbPrimitivesQuery(queryObject->backendHandle);
                 }
-            }
-            // A backend query that is not going to be read is released here, not left to be
-            // collected later: the span is over, the driver object has nothing left to say.
-            // Ending it first is what makes that legal.
-            if (!queryObject->backendHandle || PrefersCpuTransformFeedbackResult(queryObject)) {
-                if (queryObject->backendHandle) {
-                    if (const auto deleteBackendQuery = MG_Backend::gBackendFunctionsTable.GL.DeleteBackendQuery) {
-                        MGP_FILL(DeleteBackendQuery);
-                        deleteBackendQuery(queryObject->backendHandle);
-                    }
-                    queryObject->backendHandle = nullptr;
-                }
-                queryObject->cachedResult = TransformFeedbackCpuResult(queryObject);
+                // Result comes from the GPU query at read time.
+            } else {
+                queryObject->cachedResult =
+                    MG_State::pGLContext->GetTransformFeedbackPrimitiveCounter() - queryObject->counterSnapshot;
                 queryObject->resultCached = true;
             }
-            // Otherwise the result comes from the GPU query at read time.
             queryObject->active = false;
             queryObject->ended = true;
             activeQueryId = 0;
@@ -619,7 +462,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (isOcclusionQuery) {
             if (const auto endOcclusionQuery = MG_Backend::gBackendFunctionsTable.GL.EndOcclusionQuery;
                 endOcclusionQuery && queryObject->backendHandle) {
-                MGP_FILL(EndOcclusionQuery);
                 endOcclusionQuery(queryObject->backendHandle);
             }
             queryObject->active = false;
@@ -658,81 +500,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         ResetQueryObjectLocked(queryObject); // discard any previous result
         queryObject->target = target;
         const auto queryCounterTimestamp = MG_Backend::gBackendFunctionsTable.GL.QueryCounterTimestamp;
-        MGP_FILL(QueryCounterTimestamp);
         queryObject->backendHandle =
             (!TimerQueryDisabled() && queryCounterTimestamp) ? queryCounterTimestamp() : nullptr;
         queryObject->ended = true;
     }
 
-    void BeginConditionalRender(GLuint id, GLenum mode) {
-        // GL 4.6 core 10.9's eight modes. The _INVERTED half flips the sense of the predicate;
-        // the BY_REGION half only narrows WHERE an implementation is permitted to discard, so
-        // treating it as its whole-framebuffer sibling is what an implementation without region
-        // granularity does. The _NO_WAIT half is a permission to render rather than stall, not an
-        // obligation - see the resolve below.
-        Bool inverted = false;
-        switch (mode) {
-        case GL_QUERY_WAIT:
-        case GL_QUERY_NO_WAIT:
-        case GL_QUERY_BY_REGION_WAIT:
-        case GL_QUERY_BY_REGION_NO_WAIT:
-            inverted = false;
-            break;
-        case GL_QUERY_WAIT_INVERTED:
-        case GL_QUERY_NO_WAIT_INVERTED:
-        case GL_QUERY_BY_REGION_WAIT_INVERTED:
-        case GL_QUERY_BY_REGION_NO_WAIT_INVERTED:
-            inverted = true;
-            break;
-        default:
-            RecordQueryError(ErrorCode::InvalidEnum, __FUNCTION__, "mode is not a conditional render mode.");
-            return;
-        }
-
-        if (MG_State::pGLContext->IsConditionalRenderActive()) {
-            RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__, "Conditional rendering is already active.");
-            return;
-        }
-
-        {
-            const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
-            const auto* queryObject = FindQueryObjectLocked(id);
-            // A generated NAME is not yet a query object; it becomes one at its first use with a
-            // target (the same rule glIsQuery answers by).
-            if (!queryObject || (!queryObject->created && queryObject->target == 0)) {
-                RecordQueryError(ErrorCode::InvalidValue, __FUNCTION__, "id is not the name of a query object.");
-                return;
-            }
-            if (queryObject->active) {
-                RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__, "The query object is still active.");
-                return;
-            }
-            if (queryObject->target != GL_SAMPLES_PASSED && queryObject->target != GL_ANY_SAMPLES_PASSED &&
-                queryObject->target != GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
-                RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__,
-                                 "Conditional rendering requires an occlusion query object.");
-                return;
-            }
-        }
-
-        // Resolved ONCE, here, and by WAITING even for the _NO_WAIT modes: the spec lets those
-        // render instead of stalling, so always waiting is conforming and is the only choice that
-        // gives the whole block one deterministic verdict. Reading it per command instead would
-        // let a result that lands mid-block change the answer half way through.
-        Uint64 samplesPassed = 0;
-        if (!GetQueryObjectValue(id, GL_QUERY_RESULT, __FUNCTION__, samplesPassed)) return;
-        const Bool passed = samplesPassed != 0;
-        MG_State::pGLContext->BeginConditionalRender(id, mode, inverted ? passed : !passed);
-    }
-
-    void EndConditionalRender() {
-        if (!MG_State::pGLContext->IsConditionalRenderActive()) {
-            RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__, "Conditional rendering is not active.");
-            return;
-        }
-        MG_State::pGLContext->EndConditionalRender();
-    }
-
     void GetQueryiv(GLenum target, GLenum pname, GLint* params) {
         if (!params) {
             return;
@@ -756,12 +528,7 @@ namespace MobileGL::MG_Impl::GLImpl {
                 *params = static_cast<GLint>(g_activePrimitivesGeneratedQueryId);
                 break;
             default:
-                if (IsPipelineStatisticsQueryTarget(target)) {
-                    const auto it = g_activePipelineStatisticsQueryIds.find(target);
-                    *params = it != g_activePipelineStatisticsQueryIds.end() ? static_cast<GLint>(it->second) : 0;
-                } else {
-                    *params = 0;
-                }
+                *params = 0;
                 break;
             }
             return;
@@ -772,14 +539,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             // entry points / timestamp valid bits at call time, not at table
             // init), and the MOBILEGL_DISABLE_TIMERQUERY kill switch always
             // wins.
-            if (IsPipelineStatisticsQueryTarget(target)) {
-                // Zero: GL 4.6 core 4.2.1's way of saying the counter is not implemented and its
-                // results are indeterminate. The conformance suite reads exactly this and skips
-                // the functional half of each such target, which is the outcome an uninstrumented
-                // counter should produce.
-                *params = 0;
-                return;
-            }
             if (target == GL_SAMPLES_PASSED || target == GL_ANY_SAMPLES_PASSED ||
                 target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
                 const Bool occlusionSupported = MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery != nullptr;
@@ -788,7 +547,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
             const Bool timerTarget = target == GL_TIME_ELAPSED || target == GL_TIMESTAMP;
             const auto isTimerQuerySupported = MG_Backend::gBackendFunctionsTable.GL.IsTimerQuerySupported;
-            MGP_FILL(IsTimerQuerySupported);
             const Bool supported =
                 timerTarget && !TimerQueryDisabled() && isTimerQuerySupported && isTimerQuerySupported();
             *params = supported ? 64 : 0;
@@ -854,24 +612,14 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     namespace {
-        Bool IsPerVertexStreamQueryTarget(GLenum target) {
-            return target == GL_PRIMITIVES_GENERATED || target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN;
-        }
-
         // The indexed query entry points differ from the plain ones only in the vertex
         // stream they address (GL 4.6 core 4.2.1): index must be below GL_MAX_VERTEX_STREAMS
-        // for the two transform feedback targets and zero for every other target. MobileGL
-        // implements ONE vertex stream, so both bounds are 1 and a valid call is always index 0 -
-        // which is what makes the three forwards below equivalent to the unindexed entry points.
-        //
-        // THAT EQUIVALENCE IS THE WHOLE JUSTIFICATION, and it is read out of the getter rather
-        // than assumed: the moment GL_MAX_VERTEX_STREAMS answers more than one, index 1..3 starts
-        // reaching EndQueryIndexed and GetQueryIndexediv, which resolve the active query from
-        // per-TARGET globals and would end - or report - a query begun on a different stream.
-        // Raising that limit therefore means giving each active query a stream index and
-        // comparing it here, not just changing the number.
+        // for the two transform feedback targets and zero for every other target. With a
+        // single vertex stream both bounds are 1, so a valid call is always index 0 and
+        // forwards to the unindexed implementation.
         Bool ValidateQueryStreamIndex(const char* function, GLenum target, GLuint index) {
-            const Bool perStreamTarget = IsPerVertexStreamQueryTarget(target);
+            const Bool perStreamTarget =
+                target == GL_PRIMITIVES_GENERATED || target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN;
             GLint maxVertexStreams = 1;
             if (perStreamTarget) {
                 GetIntegerv(GL_MAX_VERTEX_STREAMS, &maxVertexStreams);
@@ -884,7 +632,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                                              : "index must be zero for this query target.");
             return false;
         }
-
     } // namespace
 
     void BeginQueryIndexed(GLenum target, GLuint index, GLuint id) {
@@ -901,40 +648,4 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!ValidateQueryStreamIndex(__FUNCTION__, target, index)) return;
         GetQueryiv(target, pname, params);
     }
-
-    void DestroyAllQueryObjects() {
-        // Detach the registry under the lock, release outside it - same discipline
-        // (and the same accepted teardown race) as DestroyAllSyncObjects. Without
-        // this drain, every query the app left undeleted survived full library
-        // teardown in the process-global registry: the objects and their backend
-        // wrappers leaked across Destroy/Initialize cycles, stale ids kept
-        // answering IsQuery == GL_TRUE in the re-initialized library, and a later
-        // glDeleteQueries could hand the OLD backend's handle to a DIFFERENT
-        // backend's DeleteBackendQuery, which casts it to the wrong wrapper type.
-        UnorderedMap<GLuint, QueryObject*> orphans;
-        {
-            const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
-            orphans.swap(g_liveQueryObjects);
-            g_activeTimeElapsedQueryId = 0;
-            g_activePrimitivesWrittenQueryId = 0;
-            g_activePrimitivesGeneratedQueryId = 0;
-            g_activeSamplesPassedQueryId = 0;
-        }
-        if (orphans.empty()) {
-            return;
-        }
-        // Backend handles must be released by the backend that created them, so
-        // this runs while the function table is still populated. Both backends'
-        // DeleteBackendQuery are generation-guarded, so a handle whose renderer
-        // or ES context is already gone frees only the wrapper.
-        const auto deleteBackendQuery = MG_Backend::gBackendFunctionsTable.GL.DeleteBackendQuery;
-        for (const auto& [_, queryObject] : orphans) {
-            if (deleteBackendQuery && queryObject->backendHandle) {
-                MGP_FILL(DeleteBackendQuery);
-                deleteBackendQuery(queryObject->backendHandle);
-            }
-            delete queryObject;
-        }
-        MGLOG_D("DestroyAllQueryObjects: reclaimed %zu query object(s) the app left undeleted", orphans.size());
-    }
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Query/GL_Query.h

@@ -29,18 +29,4 @@ namespace MobileGL::MG_Impl::GLImpl {
     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);
-    // Conditional rendering (GL 4.6 core 10.9). Implemented here rather than beside the drawing
-    // entry points because the predicate is a QUERY OBJECT's result, and the object registry -
-    // with the lock that guards it - lives in this file.
-    void BeginConditionalRender(GLuint id, GLenum mode);
-    void EndConditionalRender();
-    // Destroys every still-registered query object exactly as DeleteQueries would.
-    // GL requires queries to die with their context; called only from full library
-    // teardown (DestroyImpl), where no context survives on any thread, so the
-    // process-global registry can be drained wholesale. Must run while the backend
-    // function table is still populated: each backend handle has to be released by
-    // the backend that created it, never by a later re-initialized one (whose
-    // DeleteBackendQuery would cast the wrapper to the wrong backend's type).
-    // Same contract as DestroyAllSyncObjects.
-    void DestroyAllQueryObjects();
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/RenderState/GL_RenderState.cpp

@@ -8,7 +8,6 @@
 
 #include "GL_RenderState.h"
 #include <cmath>
-#include <MG_Impl/GLImpl/Getter/GL_Getter.h>
 #include <MG_State/GLState/Core.h>
 #include <MG_Util/Converters/GLToStr/GLEnumConverter.h>
 #include <MG_Util/Converters/GLToMG/RenderStateEnumConverter.h>
@@ -20,118 +19,28 @@ namespace MobileGL::MG_Impl::GLImpl {
         return std::clamp(static_cast<Float>(value), 0.0f, 1.0f);
     }
 
-    // GL 4.6 core 17.3.2 and 22.1 give exactly two indexed capabilities: GL_BLEND, indexed by
-    // draw buffer, and GL_SCISSOR_TEST, indexed by viewport. They have DIFFERENT bounds
-    // (MAX_DRAW_BUFFERS vs MAX_VIEWPORTS), so the limit is picked per target rather than shared.
-    static Bool ValidateIndexedCapability(GLenum target, GLuint index, const char* functionName) {
-        GLuint limit = 0;
-        const char* indexName = nullptr;
-        switch (target) {
-        case GL_BLEND:
-            limit = MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS;
-            indexName = "Buffer";
-            break;
-        case GL_SCISSOR_TEST:
-            limit = RenderStateParameters::MAX_VIEWPORTS;
-            indexName = "Viewport";
-            break;
-        default:
+    static Bool ValidateIndexedBlendCapability(GLenum target, GLuint index, const char* functionName) {
+        if (target != GL_BLEND) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidEnum,
                 MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             "Only GL_BLEND and GL_SCISSOR_TEST are supported for indexed "
-                                             "capability state."));
+                                             "Only GL_BLEND is supported for indexed capability state."));
             return false;
         }
 
-        if (index >= limit) {
+        if (index >= MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             String(indexName) + " index " + std::to_string(index) +
-                                                 " is out of range. Max supported is " + std::to_string(limit - 1) +
-                                                 "."));
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl", functionName,
+                    "Buffer index " + std::to_string(index) + " is out of range. Max supported is " +
+                        std::to_string(MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS - 1) + "."));
             return false;
         }
 
         return true;
     }
 
-    // ------------------ ARB_viewport_array parameter validation ------------------
-    // All three families share the same two shapes, so they share the two checkers. GL 4.6 core
-    // 13.6.1/17.3.2: an out-of-range index is GL_INVALID_VALUE, and so is a negative width or
-    // height. `first + count == MAX_VIEWPORTS` is LEGAL - only strictly greater is an error,
-    // which KHR-GL43.viewport_array.api_errors checks explicitly in both directions.
-    static Bool ValidateViewportIndex(GLuint index, const char* functionName) {
-        if (index < RenderStateParameters::MAX_VIEWPORTS) return true;
-
-        MG_State::pGLContext->RecordError(
-            ErrorCode::InvalidValue,
-            MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                         "Viewport index " + std::to_string(index) +
-                                             " is out of range. Max supported is " +
-                                             std::to_string(RenderStateParameters::MAX_VIEWPORTS - 1) + "."));
-        return false;
-    }
-
-    static Bool ValidateViewportRange(GLuint first, GLsizei count, const char* functionName) {
-        if (count < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName, "count must not be negative."));
-            return false;
-        }
-        // Widened before adding: first is a GLuint and count a GLsizei, so `first + count` in
-        // 32 bits can wrap past MAX_VIEWPORTS and let an out-of-range range through.
-        const Uint64 last = static_cast<Uint64>(first) + static_cast<Uint64>(count);
-        if (last > RenderStateParameters::MAX_VIEWPORTS) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             "first (" + std::to_string(first) + ") + count (" +
-                                                 std::to_string(count) + ") exceeds GL_MAX_VIEWPORTS (" +
-                                                 std::to_string(RenderStateParameters::MAX_VIEWPORTS) + ")."));
-            return false;
-        }
-        return true;
-    }
-
-    template <typename T>
-    static Bool ValidateNonNegativeExtent(T width, T height, const char* functionName) {
-        if (width >= T(0) && height >= T(0)) return true;
-
-        MG_State::pGLContext->RecordError(
-            ErrorCode::InvalidValue,
-            MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName, "Width and height must be non-negative."));
-        return false;
-    }
-
-    // The array forms are all-or-nothing: one bad element rejects the whole call with a SINGLE
-    // GL_INVALID_VALUE and leaves every rectangle untouched. api_errors relies on both halves -
-    // it passes a full 16-element array with exactly one negative extent and then asserts the
-    // error queue holds exactly one entry.
-    template <typename T>
-    static Bool ValidateArrayExtents(GLsizei count, const T* v, const char* functionName) {
-        for (GLsizei i = 0; i < count; ++i) {
-            if (v[i * 4 + 2] >= T(0) && v[i * 4 + 3] >= T(0)) continue;
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             "Width and height must be non-negative (element " + std::to_string(i) +
-                                                 ")."));
-            return false;
-        }
-        return true;
-    }
-
-    static Bool ValidateNonNullArray(const void* v, const char* functionName) {
-        if (v != nullptr) return true;
-        MG_State::pGLContext->RecordError(
-            ErrorCode::InvalidValue,
-            MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName, "value pointer cannot be null."));
-        return false;
-    }
-
     static Bool TryConvertBlendEquation(GLenum mode, const char* functionName,
                                         ::MobileGL::BlendEquation& outEquation) {
         outEquation = MG_Util::ConvertGLEnumToBlendEquation(mode);
@@ -183,70 +92,16 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void Viewport_State(GLint x, GLint y, GLsizei width, GLsizei height) {
-        if (!ValidateNonNegativeExtent(width, height, "Viewport_State")) return;
+        if (width < 0 || height < 0) {
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "Viewport_State",
+                                                                           "Width abd height must be non-negative."));
+            return;
+        }
 
         MG_State::pGLContext->SetViewport(IntVec4(x, y, width, height));
     }
 
-    // ------------------ ARB_viewport_array setters ------------------
-    void ViewportArrayv_State(GLuint first, GLsizei count, const GLfloat* v) {
-        if (!ValidateViewportRange(first, count, "ViewportArrayv_State")) return;
-        if (count == 0) return;
-        if (!ValidateNonNullArray(v, "ViewportArrayv_State")) return;
-        if (!ValidateArrayExtents(count, v, "ViewportArrayv_State")) return;
-
-        for (GLsizei i = 0; i < count; ++i) {
-            MG_State::pGLContext->SetViewportIndexed(first + static_cast<GLuint>(i),
-                                                     FloatVec4(v[i * 4 + 0], v[i * 4 + 1], v[i * 4 + 2], v[i * 4 + 3]));
-        }
-    }
-
-    void ViewportIndexedf_State(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
-        if (!ValidateViewportIndex(index, "ViewportIndexedf_State")) return;
-        if (!ValidateNonNegativeExtent(w, h, "ViewportIndexedf_State")) return;
-
-        MG_State::pGLContext->SetViewportIndexed(index, FloatVec4(x, y, w, h));
-    }
-
-    void ScissorArrayv_State(GLuint first, GLsizei count, const GLint* v) {
-        if (!ValidateViewportRange(first, count, "ScissorArrayv_State")) return;
-        if (count == 0) return;
-        if (!ValidateNonNullArray(v, "ScissorArrayv_State")) return;
-        if (!ValidateArrayExtents(count, v, "ScissorArrayv_State")) return;
-
-        for (GLsizei i = 0; i < count; ++i) {
-            MG_State::pGLContext->SetScissorBoxIndexed(first + static_cast<GLuint>(i),
-                                                       IntVec4(v[i * 4 + 0], v[i * 4 + 1], v[i * 4 + 2], v[i * 4 + 3]));
-        }
-    }
-
-    void ScissorIndexed_State(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) {
-        if (!ValidateViewportIndex(index, "ScissorIndexed_State")) return;
-        if (!ValidateNonNegativeExtent(width, height, "ScissorIndexed_State")) return;
-
-        MG_State::pGLContext->SetScissorBoxIndexed(index, IntVec4(left, bottom, width, height));
-    }
-
-    void DepthRangeArrayv_State(GLuint first, GLsizei count, const GLdouble* v) {
-        if (!ValidateViewportRange(first, count, "DepthRangeArrayv_State")) return;
-        if (count == 0) return;
-        if (!ValidateNonNullArray(v, "DepthRangeArrayv_State")) return;
-
-        for (GLsizei i = 0; i < count; ++i) {
-            MG_State::pGLContext->SetDepthRangeIndexed(
-                first + static_cast<GLuint>(i),
-                FloatVec2(ClampUnitFloat(static_cast<GLfloat>(v[i * 2 + 0])),
-                          ClampUnitFloat(static_cast<GLfloat>(v[i * 2 + 1]))));
-        }
-    }
-
-    void DepthRangeIndexed_State(GLuint index, GLdouble n, GLdouble f) {
-        if (!ValidateViewportIndex(index, "DepthRangeIndexed_State")) return;
-
-        MG_State::pGLContext->SetDepthRangeIndexed(
-            index, FloatVec2(ClampUnitFloat(static_cast<GLfloat>(n)), ClampUnitFloat(static_cast<GLfloat>(f))));
-    }
-
     void StencilOpSeparate_State(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
         Bool applyFront = false;
         Bool applyBack = false;
@@ -319,7 +174,12 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void Scissor_State(GLint x, GLint y, GLsizei width, GLsizei height) {
-        if (!ValidateNonNegativeExtent(width, height, "Scissor_State")) return;
+        if (width < 0 || height < 0) {
+            MG_State::pGLContext->RecordError(ErrorCode::InvalidValue,
+                                              MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "Scissor_State",
+                                                                           "Width abd height must be non-negative."));
+            return;
+        }
 
         MG_State::pGLContext->SetScissorBox(IntVec4(x, y, width, height));
     }
@@ -328,50 +188,10 @@ namespace MobileGL::MG_Impl::GLImpl {
         MG_State::pGLContext->SetSampleCoverage(std::clamp(static_cast<Float>(value), 0.0f, 1.0f), invert == GL_TRUE);
     }
 
-    // ARB_sample_shading / GL 4.6 core 14.3.1: "value is clamped to [0, 1] when specified", so
-    // there is no error to raise - a caller that asks for 2.0 gets 1.0 and GL_MIN_SAMPLE_SHADING_-
-    // VALUE reads back 1.0. Was a logging no-op while ARB_sample_shading was advertised, which
-    // let an application enable GL_SAMPLE_SHADING and then quietly get the driver's default rate.
-    void MinSampleShading_State(GLfloat value) {
-        MG_State::pGLContext->SetMinSampleShadingValue(std::clamp(static_cast<Float>(value), 0.0f, 1.0f));
-    }
-
     void PolygonOffset_State(GLfloat factor, GLfloat units) {
         MG_State::pGLContext->SetPolygonOffset(static_cast<Float>(factor), static_cast<Float>(units));
     }
 
-    void PolygonOffsetClamp_State(GLfloat factor, GLfloat units, GLfloat clamp) {
-        // GL 4.6 core 14.6.5 / GL_EXT_polygon_offset_clamp. No error cases: any three floats are
-        // legal, and clamp = 0 is exactly glPolygonOffset. Whether the backend can APPLY the clamp
-        // is a separate question (see the DirectGLES/DirectVulkan forwarding); the state is
-        // recorded either way, because GL_POLYGON_OFFSET_CLAMP has to read back what was written.
-        MG_State::pGLContext->SetPolygonOffsetClamped(static_cast<Float>(factor), static_cast<Float>(units),
-                                                      static_cast<Float>(clamp));
-    }
-
-    void ClipControl_State(GLenum origin, GLenum depth) {
-        // GL 4.5 core 13.5: both arguments are strict enums, and either being wrong is
-        // GL_INVALID_ENUM with the state left untouched.
-        if (origin != GL_LOWER_LEFT && origin != GL_UPPER_LEFT) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "glClipControl origin must be GL_LOWER_LEFT or GL_UPPER_LEFT; got " +
-                                                 MG_Util::ConvertGLEnumToString(origin) + "."));
-            return;
-        }
-        if (depth != GL_NEGATIVE_ONE_TO_ONE && depth != GL_ZERO_TO_ONE) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl", __func__,
-                    "glClipControl depth must be GL_NEGATIVE_ONE_TO_ONE or GL_ZERO_TO_ONE; got " +
-                        MG_Util::ConvertGLEnumToString(depth) + "."));
-            return;
-        }
-        MG_State::pGLContext->SetClipControl(origin, depth);
-    }
-
     void PolygonMode_State(GLenum face, GLenum mode) {
         // GL 3.3 core: separate front/back polygon modes were removed in 3.1, so the only legal
         // face is GL_FRONT_AND_BACK. GL_FRONT / GL_BACK must be rejected (some desktop drivers
@@ -515,7 +335,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     GLboolean IsEnabledi_State(GLenum target, GLuint index) {
-        if (!ValidateIndexedCapability(target, index, "IsEnabledi_State")) {
+        if (!ValidateIndexedBlendCapability(target, index, "IsEnabledi_State")) {
             return GL_FALSE;
         }
 
@@ -560,25 +380,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
-        // GL 4.6 core 22.1: glGetBooleani_v answers EVERY indexed state, not just the indexed
-        // capabilities - a non-boolean value simply reads back as "is it non-zero". Routing the
-        // non-capability enums to the pname table glGetIntegeri_v already owns is what makes
-        // that true; without it a query like glGetBooleani_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 0)
-        // came back GL_INVALID_ENUM (KHR-GL43.compute_shader.max).
-        if (MG_Util::ConvertGLEnumToCapabilityInput(target) != CapabilityInput::Unknown) {
-            *data = IsEnabledi_State(target, index);
-            return;
-        }
-        GLint values[4] = {};
-        GetIntegeri_v(target, index, values);
-        // The ARB_viewport_array rectangles are the only multi-component indexed state that
-        // reaches here; writing element 0 alone would leave the caller's other three untouched.
-        const GLsizei components = target == GL_VIEWPORT || target == GL_SCISSOR_BOX
-            ? 4
-            : (target == GL_DEPTH_RANGE ? 2 : 1);
-        for (GLsizei i = 0; i < components; ++i) {
-            data[i] = values[i] != 0 ? GL_TRUE : GL_FALSE;
-        }
+        *data = IsEnabledi_State(target, index);
     }
 
     GLboolean IsEnabled_State(GLenum cap) {
@@ -911,7 +713,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void Disablei_State(GLenum target, GLuint index) {
-        if (!ValidateIndexedCapability(target, index, "Disablei_State")) {
+        if (!ValidateIndexedBlendCapability(target, index, "Disablei_State")) {
             return;
         }
 
@@ -929,7 +731,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void Enablei_State(GLenum target, GLuint index) {
-        if (!ValidateIndexedCapability(target, index, "Enablei_State")) {
+        if (!ValidateIndexedBlendCapability(target, index, "Enablei_State")) {
             return;
         }
 
@@ -983,44 +785,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         Viewport_State(x, y, width, height);
     }
 
-    void ViewportArrayv(GLuint first, GLsizei count, const GLfloat* v) {
-        ViewportArrayv_State(first, count, v);
-    }
-
-    void ViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
-        ViewportIndexedf_State(index, x, y, w, h);
-    }
-
-    void ViewportIndexedfv(GLuint index, const GLfloat* v) {
-        // The index is validated before the pointer is touched: glViewportIndexedfv(MAX, nullptr)
-        // must be one GL_INVALID_VALUE, not a null dereference.
-        if (!ValidateViewportIndex(index, "ViewportIndexedfv")) return;
-        if (!ValidateNonNullArray(v, "ViewportIndexedfv")) return;
-        ViewportIndexedf_State(index, v[0], v[1], v[2], v[3]);
-    }
-
-    void ScissorArrayv(GLuint first, GLsizei count, const GLint* v) {
-        ScissorArrayv_State(first, count, v);
-    }
-
-    void ScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) {
-        ScissorIndexed_State(index, left, bottom, width, height);
-    }
-
-    void ScissorIndexedv(GLuint index, const GLint* v) {
-        if (!ValidateViewportIndex(index, "ScissorIndexedv")) return;
-        if (!ValidateNonNullArray(v, "ScissorIndexedv")) return;
-        ScissorIndexed_State(index, v[0], v[1], v[2], v[3]);
-    }
-
-    void DepthRangeArrayv(GLuint first, GLsizei count, const GLdouble* v) {
-        DepthRangeArrayv_State(first, count, v);
-    }
-
-    void DepthRangeIndexed(GLuint index, GLdouble n, GLdouble f) {
-        DepthRangeIndexed_State(index, n, f);
-    }
-
     void StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
         StencilOpSeparate_State(face, sfail, dpfail, dppass);
     }
@@ -1053,22 +817,10 @@ namespace MobileGL::MG_Impl::GLImpl {
         SampleCoverage_State(value, invert);
     }
 
-    void MinSampleShading(GLfloat value) {
-        MinSampleShading_State(value);
-    }
-
     void PolygonOffset(GLfloat factor, GLfloat units) {
         PolygonOffset_State(factor, units);
     }
 
-    void PolygonOffsetClamp(GLfloat factor, GLfloat units, GLfloat clamp) {
-        PolygonOffsetClamp_State(factor, units, clamp);
-    }
-
-    void ClipControl(GLenum origin, GLenum depth) {
-        ClipControl_State(origin, depth);
-    }
-
     void PolygonMode(GLenum face, GLenum mode) {
         PolygonMode_State(face, mode);
     }

MobileGL/MG_Impl/GLImpl/RenderState/GL_RenderState.h

@@ -20,16 +20,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     void Enablei(GLenum target, GLuint index);
     void BlendFunc(GLenum sfactor, GLenum dfactor);
     void Viewport(GLint x, GLint y, GLsizei width, GLsizei height);
-    // ARB_viewport_array (core since GL 4.1). Every one of these addresses the same 16-element
-    // indexed state the classic glViewport/glScissor/glDepthRange trio broadcasts to.
-    void ViewportArrayv(GLuint first, GLsizei count, const GLfloat* v);
-    void ViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void ViewportIndexedfv(GLuint index, const GLfloat* v);
-    void ScissorArrayv(GLuint first, GLsizei count, const GLint* v);
-    void ScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void ScissorIndexedv(GLuint index, const GLint* v);
-    void DepthRangeArrayv(GLuint first, GLsizei count, const GLdouble* v);
-    void DepthRangeIndexed(GLuint index, GLdouble n, GLdouble f);
     void StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
     void StencilOp(GLenum fail, GLenum zfail, GLenum zpass);
     void StencilMaskSeparate(GLenum face, GLuint mask);
@@ -38,10 +28,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     void StencilFunc(GLenum func, GLint ref, GLuint mask);
     void Scissor(GLint x, GLint y, GLsizei width, GLsizei height);
     void SampleCoverage(GLfloat value, GLboolean invert);
-    void MinSampleShading(GLfloat value);
     void PolygonOffset(GLfloat factor, GLfloat units);
-    void PolygonOffsetClamp(GLfloat factor, GLfloat units, GLfloat clamp);
-    void ClipControl(GLenum origin, GLenum depth);
     void PolygonMode(GLenum face, GLenum mode);
     void PointSize(GLfloat size);
     void PointParameterf(GLenum pname, GLfloat param);

MobileGL/MG_Impl/GLImpl/Sampler/GL_Sampler.cpp

@@ -9,11 +9,9 @@
 #include "GL_Sampler.h"
 #include "Validators.h"
 #include "../Getter/GL_Getter.h"
-#include "../Texture/GL_Texture.h"
 #include <MG_State/GLState/Core.h>
 #include <MG_Util/Converters/GLToMG/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToGL/TextureEnumConverter.h>
-#include <MG_Util/Math/FixedPointConversion.h>
 
 namespace MobileGL::MG_Impl::GLImpl {
     namespace {
@@ -23,50 +21,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return static_cast<Float>(*(const GLint*)param);
         }
 
-        // GL_TEXTURE_BORDER_COLOR is the only sampler parameter with more than one component, and it
-        // is also the only one whose meaning depends on WHICH entry point wrote it. Everything else
-        // reads exactly one component and does not care.
-        Bool IsVectorOnlySamplerPname(GLenum pname) {
-            return pname == GL_TEXTURE_BORDER_COLOR;
-        }
-
-        // A state query returns the value CONVERTED to the type the caller asked for (GL 4.6 core
-        // 2.2.2 / 6.1), never the other type's bits. These two are the sampler side of the numeric
-        // casts GetTexParameterfv_State/GetTexParameteriv_State already do on the texture side; the
-        // sampler path funnels all three spellings through one void* function, which is precisely how
-        // it came to write a fixed type regardless of the caller.
-        //
-        // Truncation rather than rounding for the float -> integer direction, matching the texture
-        // twin (GetTexParameteriv_State's static_cast<GLint> on MIN_LOD/MAX_LOD/LOD_BIAS): the two
-        // spellings of the same state disagreeing is the bug being fixed here, and a texture and a
-        // sampler queried the same way must answer the same number.
-        void StoreSamplerScalar(void* params, Bool isFloat, Bool isUnsignedInteger, Float value) {
-            if (isFloat) {
-                *(GLfloat*)params = value;
-                return;
-            }
-            // Via GLint in both integer spellings: a direct float -> GLuint cast of a negative value
-            // (GL_TEXTURE_MIN_LOD defaults to -1000) is undefined behaviour, while the two-step
-            // conversion is the well-defined modular one, and it is what the texture-side
-            // GetTexParameterIuiv fallback does.
-            const GLint asInt = static_cast<GLint>(value);
-            if (isUnsignedInteger) {
-                *(GLuint*)params = static_cast<GLuint>(asInt);
-            } else {
-                *(GLint*)params = asInt;
-            }
-        }
-
-        void StoreSamplerEnum(void* params, Bool isFloat, Bool isUnsignedInteger, GLenum value) {
-            if (isFloat) {
-                *(GLfloat*)params = static_cast<GLfloat>(value);
-            } else if (isUnsignedInteger) {
-                *(GLuint*)params = value;
-            } else {
-                *(GLint*)params = static_cast<GLint>(value);
-            }
-        }
-
         Bool ValidateSamplerParameterValue(GLenum pname, const void* param, Bool isFloat, Bool isUnsignedInteger) {
             if (param == nullptr) return false;
 
@@ -101,15 +55,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
     } // namespace
 
-    // `isIntegerCommand` distinguishes the "I" spellings (glSamplerParameterIiv / Iuiv) from the
-    // plain ones. It only matters for GL_TEXTURE_BORDER_COLOR, and there it decides everything:
-    // GL 4.6 core 8.10 says the I forms store the components unmodified with an integer internal
-    // type, while glSamplerParameteriv converts them to floating point with equation 2.2. Routing
-    // both to the same setter - which is what this file used to do - meant glSamplerParameteriv
-    // stored raw integers (so a border of 255 became float 255.0 instead of the spec's ~1.19e-7)
-    // and glSamplerParameterIiv lost the fact that it was ever an integer at all.
     void SetSamplerParam_State(GLuint sampler, GLenum pname, const void* param, bool isFloat,
-                               bool isUnsignedInteger, bool isIntegerCommand) {
+                               bool isUnsignedInteger) {
         if (param == nullptr) return;
         if (!SamplerImpl::ValidateSamplerName(sampler)) return;
 
@@ -164,13 +111,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             if (isFloat) {
                 const auto* values = (const GLfloat*)param;
                 samplerObj->SetBorderColor(FloatVec4(values[0], values[1], values[2], values[3]));
-            } else if (!isIntegerCommand) {
-                // glSamplerParameteriv: GL 4.6 core equation 2.2 into the FLOAT border colour.
-                const auto* values = (const GLint*)param;
-                samplerObj->SetBorderColor(FloatVec4(MG_Util::SignedNormalizedInt32ToFloat(values[0]),
-                                                     MG_Util::SignedNormalizedInt32ToFloat(values[1]),
-                                                     MG_Util::SignedNormalizedInt32ToFloat(values[2]),
-                                                     MG_Util::SignedNormalizedInt32ToFloat(values[3])));
             } else if (isUnsignedInteger) {
                 const auto* values = (const GLuint*)param;
                 samplerObj->SetBorderColorUI(UintVec4(values[0], values[1], values[2], values[3]));
@@ -187,7 +127,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void GetSamplerParam_State(GLuint sampler, GLenum pname, void* params, bool isFloat,
-                               bool isUnsignedInteger, bool isIntegerCommand) {
+                               bool isUnsignedInteger) {
         if (params == nullptr) return;
         if (!SamplerImpl::ValidateSamplerName(sampler)) return;
 
@@ -200,56 +140,47 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (!SamplerImpl::ValidateSamplerObject(sampler)) return;
 
         using namespace MG_Util;
-        // Every scalar pname goes through StoreSamplerScalar/StoreSamplerEnum so the CALLER'S form
-        // decides the destination type. Writing a fixed type regardless - which is what these case
-        // labels used to do - hands back the other type's bit pattern rather than a converted value:
-        // glGetSamplerParameterfv(GL_TEXTURE_WRAP_S) deposited the integer 10497 into a GLfloat and
-        // the caller read 1.47e-41, and glGetSamplerParameteriv(GL_TEXTURE_MIN_LOD) deposited the
-        // IEEE bits of -1000.0f and the caller read -998637568. Sixteen (pname, entry-point) pairs
-        // were broken this way; only MAX_ANISOTROPY_EXT and BORDER_COLOR branched correctly, which is
-        // how the same bug class was already found and fixed once for a single pname.
         switch (pname) {
         case GL_TEXTURE_WRAP_S:
-            StoreSamplerEnum(params, isFloat, isUnsignedInteger,
-                             MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapS()));
+            *(GLuint*)params = MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapS());
             break;
         case GL_TEXTURE_WRAP_T:
-            StoreSamplerEnum(params, isFloat, isUnsignedInteger,
-                             MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapT()));
+            *(GLuint*)params = MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapT());
             break;
         case GL_TEXTURE_WRAP_R:
-            StoreSamplerEnum(params, isFloat, isUnsignedInteger,
-                             MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapR()));
+            *(GLuint*)params = MG_Util::ConvertSamplerWrapModeToGLEnum(samplerObj->GetWrapR());
             break;
         case GL_TEXTURE_MIN_FILTER:
-            StoreSamplerEnum(params, isFloat, isUnsignedInteger,
-                             MG_Util::ConvertSamplerFilterModeToGLEnum(samplerObj->GetMinFilter(),
-                                                                       samplerObj->GetMipmapMode()));
+            *(GLuint*)params =
+                MG_Util::ConvertSamplerFilterModeToGLEnum(samplerObj->GetMinFilter(), samplerObj->GetMipmapMode());
             break;
         case GL_TEXTURE_MAG_FILTER:
-            StoreSamplerEnum(params, isFloat, isUnsignedInteger,
-                             MG_Util::ConvertSamplerFilterModeToGLEnum(samplerObj->GetMagFilter(),
-                                                                       SamplerMipmapMode::None));
+            *(GLuint*)params =
+                MG_Util::ConvertSamplerFilterModeToGLEnum(samplerObj->GetMagFilter(), SamplerMipmapMode::None);
             break;
         case GL_TEXTURE_MIN_LOD:
-            StoreSamplerScalar(params, isFloat, isUnsignedInteger, samplerObj->GetMinLod());
+            *(GLfloat*)params = samplerObj->GetMinLod();
             break;
         case GL_TEXTURE_MAX_LOD:
-            StoreSamplerScalar(params, isFloat, isUnsignedInteger, samplerObj->GetMaxLod());
+            *(GLfloat*)params = samplerObj->GetMaxLod();
             break;
         case GL_TEXTURE_LOD_BIAS:
-            StoreSamplerScalar(params, isFloat, isUnsignedInteger, samplerObj->GetLodBias());
+            *(GLfloat*)params = samplerObj->GetLodBias();
             break;
         case GL_TEXTURE_MAX_ANISOTROPY_EXT:
-            StoreSamplerScalar(params, isFloat, isUnsignedInteger, samplerObj->GetMaxAnisotropy());
+            if (isFloat) {
+                *(GLfloat*)params = samplerObj->GetMaxAnisotropy();
+            } else if (isUnsignedInteger) {
+                *(GLuint*)params = static_cast<GLuint>(samplerObj->GetMaxAnisotropy());
+            } else {
+                *(GLint*)params = static_cast<GLint>(samplerObj->GetMaxAnisotropy());
+            }
             break;
         case GL_TEXTURE_COMPARE_MODE:
-            StoreSamplerEnum(params, isFloat, isUnsignedInteger,
-                             MG_Util::ConvertSamplerCompareModeToGLEnum(samplerObj->GetCompareMode()));
+            *(GLuint*)params = MG_Util::ConvertSamplerCompareModeToGLEnum(samplerObj->GetCompareMode());
             break;
         case GL_TEXTURE_COMPARE_FUNC:
-            StoreSamplerEnum(params, isFloat, isUnsignedInteger,
-                             MG_Util::ConvertSamplerCompareFuncToGLEnum(samplerObj->GetSamplerCompareFunc()));
+            *(GLuint*)params = MG_Util::ConvertSamplerCompareFuncToGLEnum(samplerObj->GetSamplerCompareFunc());
             break;
         case GL_TEXTURE_BORDER_COLOR: {
             if (isFloat) {
@@ -259,16 +190,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                 out[1] = color.y();
                 out[2] = color.z();
                 out[3] = color.w();
-            } else if (!isIntegerCommand) {
-                // glGetSamplerParameteriv: the inverse of the write side, GL 4.6 core equation 2.3.
-                // Exactly inverse, so a {0,1,2,4} written with glSamplerParameteriv reads back as
-                // {0,1,2,4}; a bare truncating cast answered {0,0,0,0}.
-                const auto& color = samplerObj->GetBorderColor();
-                auto* out = (GLint*)params;
-                out[0] = MG_Util::FloatToSignedNormalizedInt32(color.x());
-                out[1] = MG_Util::FloatToSignedNormalizedInt32(color.y());
-                out[2] = MG_Util::FloatToSignedNormalizedInt32(color.z());
-                out[3] = MG_Util::FloatToSignedNormalizedInt32(color.w());
             } else if (isUnsignedInteger) {
                 const auto& color = samplerObj->GetBorderColorUI();
                 auto* out = (GLuint*)params;
@@ -348,13 +269,15 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
     }
 
-    // The number of texture units a sampler may be bound to is the same count a TEXTURE may be
-    // bound to - GL 3.3 core 3.8.2 names GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS for both - so it is
-    // computed once, in GetCombinedTextureImageUnitCount, and named here for the sampler-side
-    // readers below. Two copies of that arithmetic is how glBindSamplers and glBindTextures would
-    // come to disagree about which units exist.
+    // 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() {
-        return GetCombinedTextureImageUnitCount();
+        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) {
@@ -371,10 +294,16 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (sampler == 0) {
             textureUnit.SetSamplerObject(nullptr);
         } else {
-            // GL 4.6 core 8.2: BindSampler on a name GenSamplers never returned - or one already
-            // deleted - is INVALID_OPERATION, and so is every other sampler entry point on such a
-            // name, so the shared validator answers for all of them.
-            if (!SamplerImpl::ValidateSamplerName(sampler)) return;
+            // GL 3.3 core 3.8.2: BindSampler on a name GenSamplers never returned - or one already
+            // deleted - is INVALID_OPERATION. SamplerParameter* raises INVALID_VALUE for the same
+            // name, which is why this cannot go through the shared SamplerImpl validator.
+            if (!MG_State::pGLContext->ValidateSamplerName(sampler)) {
+                MG_State::pGLContext->RecordError(
+                    ErrorCode::InvalidOperation,
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BindSampler_State",
+                                                 std::format("Invalid sampler name {}", sampler)));
+                return;
+            }
             Bool doesSamplerObjectCreated = MG_State::pGLContext->ValidateSamplerObject(sampler);
             if (!doesSamplerObjectCreated) {
                 MG_State::pGLContext->CreateSamplerObject(sampler);
@@ -407,71 +336,37 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
-        // ARB_multi_bind adds one rule the single-bind path does not have: "samplers will not be
-        // created if they do not exist", so a name that is not an existing sampler OBJECT is
-        // INVALID_OPERATION here (KHR-GL44.multi_bind.errors_bind_samplers). Per element, not
-        // all-or-nothing - the extension defines glBindSamplers as a loop, so a bad entry costs
-        // its own texture unit and leaves the rest of the range bound.
         for (GLsizei i = 0; i < count; ++i) {
-            const GLuint sampler = samplers ? samplers[i] : 0;
-            if (sampler != 0 && !MG_State::pGLContext->ValidateSamplerObject(sampler)) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", "BindSamplers",
-                        std::format("samplers[{}] ({}) is not the name of an existing sampler object.", i, sampler)));
-                continue;
-            }
-            BindSampler_State(first + i, sampler);
+            BindSampler_State(first + i, samplers ? samplers[i] : 0);
         }
     }
 
     /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
     void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) {
-        GetSamplerParam_State(sampler, pname, params, false, false, false);
+        GetSamplerParam_State(sampler, pname, params, false, false);
     }
 
     void SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint* param) {
-        SetSamplerParam_State(sampler, pname, param, false, true, true);
+        SetSamplerParam_State(sampler, pname, param, false, true);
     }
 
     void SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint* param) {
-        SetSamplerParam_State(sampler, pname, param, false, false, true);
+        SetSamplerParam_State(sampler, pname, param, false, false);
     }
 
     void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) {
-        SetSamplerParam_State(sampler, pname, param, false, false, false);
+        SetSamplerParam_State(sampler, pname, param, false, false);
     }
 
     void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) {
-        SetSamplerParam_State(sampler, pname, param, true, false, false);
+        SetSamplerParam_State(sampler, pname, param, true, false);
     }
 
-    // GL 4.6 core 8.10: the scalar spellings take "the value of pname", so a pname with more than one
-    // component is INVALID_ENUM here rather than something to read four components of. Guarding at
-    // the entry point rather than downstream is also what stops the vector path reading twelve bytes
-    // past the caller's single stack scalar - taking the address of a by-value argument and handing
-    // it to a four-component reader is what these used to do. The texture-side twins already answer
-    // INVALID_ENUM for GL_TEXTURE_BORDER_COLOR (TexParameteri/f name it as unsupported outright).
     void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) {
-        if (IsVectorOnlySamplerPname(pname)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "SamplerParameteri",
-                                             "pname has more than one component and needs a vector form."));
-            return;
-        }
         SamplerParameteriv(sampler, pname, &param);
     }
 
     void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) {
-        if (IsVectorOnlySamplerPname(pname)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "SamplerParameterf",
-                                             "pname has more than one component and needs a vector form."));
-            return;
-        }
         SamplerParameterfv(sampler, pname, &param);
     }
 
@@ -480,15 +375,15 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint* params) {
-        GetSamplerParam_State(sampler, pname, params, false, true, true);
+        GetSamplerParam_State(sampler, pname, params, false, true);
     }
 
     void GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint* params) {
-        GetSamplerParam_State(sampler, pname, params, false, false, true);
+        GetSamplerParam_State(sampler, pname, params, false, false);
     }
 
     void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) {
-        GetSamplerParam_State(sampler, pname, params, true, false, false);
+        GetSamplerParam_State(sampler, pname, params, true, false);
     }
 
     void GenSamplers(GLsizei count, GLuint* samplers) {

MobileGL/MG_Impl/GLImpl/Sampler/Validators.cpp

@@ -12,17 +12,11 @@
 #include <MG_Util/Converters/GLToMG/TextureEnumConverter.h>
 
 namespace MobileGL::MG_Impl::GLImpl::SamplerImpl {
-    // GL 4.6 core 8.2: "An INVALID_OPERATION error is generated if sampler is not the name of a
-    // sampler object previously returned from a call to GenSamplers." That class is shared by every
-    // sampler entry point - BindSampler, SamplerParameter*, GetSamplerParameter* - so this one gate
-    // answers for all of them. It used to report INVALID_VALUE (the GL 3.3 wording), which forced
-    // BindSampler to carry a bespoke duplicate of the same check just to get the class right.
     Bool ValidateSamplerName(GLuint sampler) {
         if (!MG_State::pGLContext->ValidateSamplerName(sampler)) {
             MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerName",
-                                             std::format("Invalid sampler name {}", sampler)));
+                ErrorCode::InvalidValue, MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateSamplerName",
+                                                                      std::format("Invalid sampler name {}", sampler)));
             return false;
         }
         return true;

MobileGL/MG_Impl/GLImpl/Sync/GL_Sync.cpp

@@ -8,8 +8,6 @@
 
 #include "GL_Sync.h"
 #include <MG_Backend/BackendObjects.h>
-#include <MG_State/GLState/Core.h>
-#include <MG_Impl/Pipe/PipeFill.h>
 
 namespace MobileGL::MG_Impl::GLImpl {
     namespace {
@@ -37,27 +35,10 @@ namespace MobileGL::MG_Impl::GLImpl {
     } // namespace
 
     GLsync FenceSync(GLenum condition, GLbitfield flags) {
-        // GL 4.6 core 4.1.2: GL_SYNC_GPU_COMMANDS_COMPLETE is the only condition and the only
-        // legal flags value is zero; both violations return 0 rather than a handle. A caller that
-        // then hands the 0 back to glDeleteSync hits the glDeleteSync(0) no-op below.
-        if (condition != GL_SYNC_GPU_COMMANDS_COMPLETE) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "condition must be GL_SYNC_GPU_COMMANDS_COMPLETE."));
-            return nullptr;
-        }
-        if (flags != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "flags must be zero."));
-            return nullptr;
-        }
         auto* syncObject = new SyncObject;
         syncObject->condition = condition;
         syncObject->flags = flags;
         if (const auto backendFenceSync = MG_Backend::gBackendFunctionsTable.GL.FenceSync) {
-            MGP_FILL(FenceSync);
             syncObject->backendHandle = backendFenceSync();
         }
         const GLsync handle = reinterpret_cast<GLsync>(syncObject);
@@ -71,58 +52,24 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
-        // GL 4.6 core 4.1.1: GL_SYNC_FLUSH_COMMANDS_BIT is the only bit this call accepts, and
-        // any other bit is INVALID_VALUE. Silently ignoring the stray bits used to make a caller
-        // that passed, say, GL_SYNC_GPU_COMMANDS_COMPLETE by mistake think it had asked for a
-        // flush it never got.
-        if ((flags & ~static_cast<GLbitfield>(GL_SYNC_FLUSH_COMMANDS_BIT)) != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "flags must be zero or GL_SYNC_FLUSH_COMMANDS_BIT."));
-            return GL_WAIT_FAILED;
-        }
         const auto* syncObject = FindSyncObject(sync);
         if (!syncObject) {
-            // The spec pairs the GL_WAIT_FAILED return with a recorded INVALID_VALUE; returning
-            // the enum alone left glGetError() clean and the failure indistinguishable from a
-            // genuine wait failure on a live sync.
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "sync is not the name of a sync object."));
             return GL_WAIT_FAILED;
         }
         const auto backendClientWaitSync = MG_Backend::gBackendFunctionsTable.GL.ClientWaitSync;
         if (!backendClientWaitSync || !syncObject->backendHandle) {
             return GL_ALREADY_SIGNALED; // legacy always-signaled fallback
         }
-        MGP_FILL(ClientWaitSync);
         return backendClientWaitSync(syncObject->backendHandle, flags, timeout);
     }
 
     void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
-        // GL 4.6 core 4.1.2: the server-side wait takes no flags and no finite timeout - both
-        // arguments exist only to be forward-compatible, and anything else is INVALID_VALUE.
-        // Neither backend ever honored a nonzero timeout (DirectGLES hard-codes
-        // 0/GL_TIMEOUT_IGNORED, DirectVulkan's queue ordering makes the wait implicit), so
-        // rejecting the call loses no wait that used to happen.
-        if (flags != 0 || timeout != GL_TIMEOUT_IGNORED) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "flags must be zero and timeout must be GL_TIMEOUT_IGNORED."));
-            return;
-        }
         const auto* syncObject = FindSyncObject(sync);
         if (!syncObject) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "sync is not the name of a sync object."));
             return;
         }
         const auto backendWaitSync = MG_Backend::gBackendFunctionsTable.GL.WaitSync;
         if (backendWaitSync && syncObject->backendHandle) {
-            MGP_FILL(WaitSync);
             backendWaitSync(syncObject->backendHandle, flags, timeout);
         }
     }
@@ -143,29 +90,14 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
         const auto backendDeleteSync = MG_Backend::gBackendFunctionsTable.GL.DeleteSync;
         if (backendDeleteSync && syncObject->backendHandle) {
-            MGP_FILL(DeleteSync);
             backendDeleteSync(syncObject->backendHandle);
         }
         delete syncObject;
     }
 
     void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) {
-        // GL 4.6 core 4.1: a negative bufSize is INVALID_VALUE, an unnamed sync is INVALID_VALUE
-        // and an unrecognised pname is INVALID_ENUM. All three used to leave glGetError() clean
-        // and write a plausible-looking zero, which is the one failure mode a caller cannot tell
-        // apart from a real answer - GL_SYNC_STATUS legitimately answers GL_UNSIGNALED (0x9118),
-        // but a mistyped pname answered a bare 0 that no query ever returns.
-        if (bufSize < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "bufSize must not be negative."));
-            return;
-        }
         const auto* syncObject = FindSyncObject(sync);
         if (!syncObject) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "sync is not the name of a sync object."));
             if (length) {
                 *length = 0;
             }
@@ -179,7 +111,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             break;
         case GL_SYNC_STATUS: {
             const auto backendGetSyncStatus = MG_Backend::gBackendFunctionsTable.GL.GetSyncStatus;
-            MGP_FILL(GetSyncStatus);
             const Bool signaled = !backendGetSyncStatus || !syncObject->backendHandle ||
                                   backendGetSyncStatus(syncObject->backendHandle);
             value = signaled ? GL_SIGNALED : GL_UNSIGNALED;
@@ -192,15 +123,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             value = static_cast<GLint>(syncObject->flags);
             break;
         default:
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "pname must be GL_OBJECT_TYPE, GL_SYNC_STATUS, GL_SYNC_CONDITION or "
-                                             "GL_SYNC_FLAGS."));
-            if (length) {
-                *length = 0;
-            }
-            return;
+            break;
         }
 
         if (length) {
@@ -233,7 +156,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         const auto backendDeleteSync = MG_Backend::gBackendFunctionsTable.GL.DeleteSync;
         for (const auto& [_, syncObject] : orphans) {
             if (backendDeleteSync && syncObject->backendHandle) {
-                MGP_FILL(DeleteSync);
                 backendDeleteSync(syncObject->backendHandle);
             }
             delete syncObject;

MobileGL/MG_Impl/GLImpl/Texture/GL_Texture.h

@@ -8,24 +8,9 @@
 
 #pragma once
 #include <Includes.h>
-#include <MG_State/GLState/TextureState/TextureObject.h>
 
 namespace MobileGL::MG_Impl::GLImpl {
     /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
-    // Answers a texture-image query straight out of the CPU shadow, into client memory or a bound
-    // PIXEL_PACK_BUFFER. This is the whole of glGetTexImage on a build with no backend readback, and
-    // it is also the sound fallback for a backend that has no GPU image to read: with no image,
-    // nothing GPU-side can ever have written the texture, so the shadow IS its content.
-    //
-    // It answers a NARROWER contract than glGetTexImage's, and refuses what it cannot do rather than
-    // answering wrongly. The copy is verbatim: it performs no format or type conversion, and it packs
-    // rows tightly, honouring only GL_PACK_SWAP_BYTES and the bitmap GL_PACK_LSB_FIRST path. A
-    // request whose (format, type) texel size differs from the texture's own, or a pixel-store state
-    // that adds row padding / a row-length override / a skip offset, is rejected with
-    // GL_INVALID_OPERATION (see ValidateShadowReadbackLayout, which spells out why each is unsafe).
-    void CopyTextureImageToClientOrPBO_State(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject,
-                                             TextureUploadTarget textureUploadTarget, GLint level, GLenum format,
-                                             GLenum type, GLsizei bufSize, void* pixels, const char* caller);
     // 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);
@@ -52,13 +37,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                            GLenum format, GLenum type, const void* pixels);
     void TextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width,
                            GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels);
-    void CompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format,
-                                     GLsizei imageSize, const void* data);
-    void CompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
-                                     GLsizei height, GLenum format, GLsizei imageSize, const void* data);
-    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);
     void TextureParameterf(GLuint texture, GLenum pname, GLfloat param);
     void TextureParameterfv(GLuint texture, GLenum pname, const GLfloat* params);
     void TextureParameteri(GLuint texture, GLenum pname, GLint param);
@@ -80,8 +58,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     void GetTextureParameteriv(GLuint texture, GLenum pname, GLint* params);
     void GetTextureLevelParameterfv(GLuint texture, GLint level, GLenum pname, GLfloat* params);
     void GetTextureLevelParameteriv(GLuint texture, GLint level, GLenum pname, GLint* params);
-    void TextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel,
-                     GLuint numlevels, GLuint minlayer, GLuint numlayers);
     void TexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
     void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
     void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height,
@@ -156,11 +132,5 @@ namespace MobileGL::MG_Impl::GLImpl {
     void CompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border,
                               GLsizei imageSize, const void* data);
     void BindTexture(GLenum target, GLuint texture);
-    void BindTextures(GLuint first, GLsizei count, const GLuint* textures);
-    void BindImageTextures(GLuint first, GLsizei count, const GLuint* textures);
     void ActiveTexture(GLenum texture);
-    // The number of texture image units a texture or a sampler may be bound to: what the backend
-    // advertises as GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, clamped by the frontend's fixed unit-array
-    // capacity. Shared so the texture and sampler multi-bind range checks cannot drift apart.
-    GLint GetCombinedTextureImageUnitCount();
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Texture/Validators.cpp

@@ -15,7 +15,6 @@
 #include <MG_Util/Converters/MGToGL/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToMG/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToStr/TextureEnumConverter.h>
-#include <MG_Util/Metrics/TextureMetrics.h>
 
 namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
     Bool ValidateTextureTarget(TextureTarget target) {
@@ -103,28 +102,6 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
         return true;
     }
 
-    Bool ValidateCubeMapArrayShape(TextureUploadTarget target, GLsizei width, GLsizei height, GLsizei depth,
-                                   const char* caller) {
-        if (target != TextureUploadTarget::CubeMapArray && target != TextureUploadTarget::ProxyCubeMapArray) {
-            return true;
-        }
-        if (width != height) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", caller,
-                                             "Cube map array levels must be square (width == height)"));
-            return false;
-        }
-        if (depth % 6 != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", caller,
-                                             "Cube map array depth must be a multiple of six"));
-            return false;
-        }
-        return true;
-    }
-
     Bool ValidateTextureSizeWithTextureUploadTarget(TextureUploadTarget target, GLsizei width, GLsizei height) {
         if (target == TextureUploadTarget::CubeMapPositiveX || target == TextureUploadTarget::CubeMapNegativeX ||
             target == TextureUploadTarget::CubeMapPositiveY || target == TextureUploadTarget::CubeMapNegativeY ||
@@ -335,13 +312,9 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
             return false;
         }
 
-        // The stencil-only transfer path arrived with GL 4.4 / ARB_texture_stencil8, and only ever
-        // pairs with stencil-only storage: against a depth, depth-stencil or colour internal format
-        // STENCIL_INDEX keeps the pre-4.4 answer (GL CTS packed_pixels feeds exactly that pairing
-        // and expects INVALID_OPERATION).
-        if (format == TextureInputFormat::StencilIndex &&
-            internalFormat != TextureInternalFormat::StencilIndex8) {
-            return recordInvalidOperation("STENCIL_INDEX requires a stencil-only internal format");
+        // TexImage in core 3.3 has no stencil-only upload path (that arrived with GL 4.4).
+        if (format == TextureInputFormat::StencilIndex) {
+            return recordInvalidOperation("STENCIL_INDEX is not a valid texture upload format");
         }
 
         if (IsDepthLikeInputFormat(format) != IsDepthLikeInternalFormat(internalFormat)) {
@@ -380,63 +353,6 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
         return true;
     }
 
-    Bool ValidateTextureLevelExists(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject, Int level,
-                                    const char* caller) {
-        // A null object is somebody else's error to report - ValidateTextureObject runs
-        // first at every call site and has already recorded it.
-        if (!textureObject) return false;
-
-        const auto* mipmapTexture = MG_State::GLState::AsMipmapTexture(textureObject.get());
-        if (mipmapTexture == nullptr) {
-            // The only non-mipmap storage class is a buffer texture, and GL_TEXTURE_BUFFER is
-            // not a target glCopyImageSubData accepts at all (it is in the CTS's invalid-target
-            // set). Declining here is not the error code the spec asks for - that would be
-            // INVALID_ENUM from a target check this validator is not - but it does keep a
-            // texture with no image levels whatsoever from reaching a backend that would
-            // dereference a backend texture it never created.
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", caller,
-                                             "Texture has no mipmap levels to address."));
-            return false;
-        }
-
-        // What this number is, exactly, because two other things are almost it and neither is
-        // safe to assume: it is the number of level SLOTS the shadow has allocated - holes
-        // included, since MipmapStorage::AllocateLevel grows to level+1 and never fills the gap.
-        // For a cube map MipmapUploadTargetArray reports face +X's chain rather than the union.
-        //
-        // The guarantee that matters is one-sided: this count is always >= the level count the
-        // backends derive (VkTextureManager::GetUploadMipLevelCount stops at the first level
-        // with a non-positive extent, so it can only be shorter). That is the safe direction -
-        // no copy to a level the texture genuinely has is ever rejected here. It is NOT an
-        // exact match, so the backends keep their own range guard for the band in between: a
-        // chain with a hole (level 0 and 2 defined, 1 not) is accepted by this predicate and
-        // declined by the backend, which is a silent no-op rather than a copy. That band is a
-        // backend storage limitation, not a validation one - rejecting it here with
-        // INVALID_VALUE would be refusing a copy the spec permits.
-        const Uint levelCount = mipmapTexture->GetMipmapLevelCount();
-
-        if (levelCount == 0) {
-            // No image has ever been defined on this texture, so the fault is the texture,
-            // not the number: GL 4.6 core 18.3.2 asks for INVALID_OPERATION when an object a
-            // copy names is an incomplete texture.
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", caller,
-                                             "Texture has no image defined at any level."));
-            return false;
-        }
-        if (level < 0 || static_cast<Uint>(level) >= levelCount) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", caller,
-                                             "Texture level does not exist in this texture."));
-            return false;
-        }
-        return true;
-    }
-
     Bool ValidateTextureObject(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject) {
         if (!textureObject) {
             MG_State::pGLContext->RecordError(
@@ -508,281 +424,19 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
         return true;
     }
 
-    namespace {
-        // Component set of an UNSIZED base internal format, as the bitmask GL 4.6 SS 8.6
-        // reasons about. Colour components are independent bits so "subset" is a plain
-        // mask test; depth and stencil are their own components and never satisfy a
-        // colour request (or each other).
-        enum : Uint32 {
-            kComponentR = 1u << 0,
-            kComponentG = 1u << 1,
-            kComponentB = 1u << 2,
-            kComponentA = 1u << 3,
-            kComponentDepth = 1u << 4,
-            kComponentStencil = 1u << 5,
-        };
-
-        Uint32 BaseFormatComponents(TextureInternalFormat unsizedFormat) {
-            switch (unsizedFormat) {
-            case TextureInternalFormat::Red:
-                return kComponentR;
-            case TextureInternalFormat::RG:
-                return kComponentR | kComponentG;
-            case TextureInternalFormat::RGB:
-                return kComponentR | kComponentG | kComponentB;
-            case TextureInternalFormat::RGBA:
-                return kComponentR | kComponentG | kComponentB | kComponentA;
-            case TextureInternalFormat::DepthComponent:
-                return kComponentDepth;
-            case TextureInternalFormat::DepthStencil:
-                return kComponentDepth | kComponentStencil;
-            default:
-                return 0;
-            }
-        }
-    } // namespace
-
-    CopyImageTexelBlock ResolveCopyImageTexelBlock(TextureInternalFormat format, GLenum compressedFormat) {
-        CopyImageTexelBlock block{};
-        if (compressedFormat != GL_NONE) {
-            const auto info = MG_Util::GetCompressedFormatInfo(compressedFormat);
-            if (info.blockByteSize != 0) {
-                block.byteSize = info.blockByteSize;
-                block.blockWidth = info.blockWidth;
-                block.blockHeight = info.blockHeight;
-                block.compressed = true;
-                return block;
-            }
-        }
-        // The size MobileGL actually stores a texel of this format in, which for every format GL
-        // gives a required size is that required size. The handful of legacy formats GL leaves
-        // implementation-defined (R3_G3_B2, RGB4/5/10/12, RGBA2/12) have no view class in table
-        // 8.22 to be compared against anyway, and this is the size that decides whether a raw
-        // copy between them would in fact preserve the bytes.
-        block.byteSize = MG_Util::GetSizedInternalFormatSizeInBytes(format);
-        return block;
-    }
-
-    Bool ValidateCopyImageFormatCompatibility(const CopyImageTexelBlock& srcBlock,
-                                              const CopyImageTexelBlock& dstBlock) {
-        if (srcBlock.byteSize == 0 || dstBlock.byteSize == 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ValidateCopyImageFormatCompatibility",
-                                             "A copied image has no storage whose texel size is known."));
-            return false;
-        }
-        if (srcBlock.byteSize != dstBlock.byteSize) {
+    Bool ValidateBaseInternalFormatMatch(TextureInternalFormat format1, TextureInternalFormat format2) {
+        auto unsizedFormat1 = MG_Util::ConvertInternalFormatToUnsized(format1);
+        auto unsizedFormat2 = MG_Util::ConvertInternalFormatToUnsized(format2);
+        if (unsizedFormat1 != unsizedFormat2) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
                 MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl", "ValidateCopyImageFormatCompatibility",
-                    std::format("The two images' texel blocks are different sizes ({} vs. {} bytes), so the "
-                                "formats are not copy-compatible.",
-                                srcBlock.byteSize, dstBlock.byteSize)));
-            return false;
-        }
-        // Two compressed images additionally have to agree on the SHAPE of the block, not only
-        // its size: an 8-byte 4x4 block and a hypothetical 8-byte 8x8 one hold different texel
-        // counts, and GL 4.6 core 18.3.2 requires both dimensions to match.
-        if (srcBlock.compressed && dstBlock.compressed &&
-            (srcBlock.blockWidth != dstBlock.blockWidth || srcBlock.blockHeight != dstBlock.blockHeight)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl", "ValidateCopyImageFormatCompatibility",
-                    std::format("The two compressed images have different block dimensions ({}x{} vs. {}x{}).",
-                                srcBlock.blockWidth, srcBlock.blockHeight, dstBlock.blockWidth,
-                                dstBlock.blockHeight)));
+                    std::format("MG_Impl/GLImpl", "ValidateBaseInternalFormatMatch",
+                                "The base internal format of the two formats do not match ({} vs. {})",
+                                MG_Util::ConvertTextureInternalFormatToString(unsizedFormat1).c_str(),
+                                MG_Util::ConvertTextureInternalFormatToString(unsizedFormat2).c_str())));
             return false;
         }
         return true;
-    }
-
-    Bool ValidateCopyImageBlockAlignment(const CopyImageTexelBlock& block, Int x, Int y, Int width, Int height,
-                                         Int imageWidth, Int imageHeight, const char* endpointName) {
-        if (!block.compressed) return true;
-        const Int blockWidth = static_cast<Int>(block.blockWidth);
-        const Int blockHeight = static_cast<Int>(block.blockHeight);
-        if (blockWidth <= 1 && blockHeight <= 1) return true;
-        // The origin is unconditional; the extent gets the "or it reaches the edge of the image"
-        // exemption GL 4.6 core 18.3.2 grants, which is what lets a 16x16 BPTC image be copied
-        // whole even when the last block is partial.
-        const Bool originAligned = (x % blockWidth == 0) && (y % blockHeight == 0);
-        const Bool widthOk = (width % blockWidth == 0) || (x + width == imageWidth);
-        const Bool heightOk = (height % blockHeight == 0) || (y + height == imageHeight);
-        if (originAligned && widthOk && heightOk) return true;
-        MG_State::pGLContext->RecordError(
-            ErrorCode::InvalidValue,
-            MakeUnique<GenericErrorInfo>(
-                "MG_Impl/GLImpl", "ValidateCopyImageBlockAlignment",
-                std::format("The {} region [{}, {}] + [{} x {}] is not aligned to the {}x{} compressed block "
-                            "grid of a {} x {} image.",
-                            endpointName, x, y, width, height, blockWidth, blockHeight, imageWidth, imageHeight)));
-        return false;
-    }
-
-    Bool ValidateCopyTexImageBaseFormatSubset(TextureInternalFormat destFormat, TextureInternalFormat srcFormat) {
-        const auto unsizedDest = MG_Util::ConvertInternalFormatToUnsized(destFormat);
-        const auto unsizedSrc = MG_Util::ConvertInternalFormatToUnsized(srcFormat);
-        // GL 4.6 SS 8.6: glCopyTexImage* may request a SUBSET of the read buffer's components,
-        // not an exact match - GL_RGB from an RGBA8 framebuffer is textbook legal and is what
-        // Minecraft and its mods do. glCopyTexImage2D used to run the exact-match predicate
-        // above and turn its rejection into an uncaught exception through the C GL ABI, so the
-        // app died rather than seeing a GL error.
-        const Uint32 destComponents = BaseFormatComponents(unsizedDest);
-        const Uint32 srcComponents = BaseFormatComponents(unsizedSrc);
-        if (destComponents == 0 || srcComponents == 0 || (destComponents & ~srcComponents) != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl", "ValidateCopyTexImageBaseFormatSubset",
-                    std::format("the read buffer's base internal format {} does not provide every component of "
-                                "the requested internal format {}",
-                                MG_Util::ConvertTextureInternalFormatToString(unsizedSrc),
-                                MG_Util::ConvertTextureInternalFormatToString(unsizedDest))));
-            return false;
-        }
-        return true;
-    }
-
-    // GL 4.6 core table 8.21 ("Compatible internal formats for TextureView"), transcribed whole.
-    // Written against the raw GLenum rather than TextureInternalFormat on purpose: MobileGL's own
-    // enum collapses every compressed format onto uncompressed storage and drops formats it
-    // cannot carry, so classifying the converted value would silently widen the compatibility
-    // rule - GL_COMPRESSED_RG_RGTC2 and GL_RGBA8 would end up in the same class.
-    TextureViewClass GetTextureViewClass(GLenum internalformat) {
-        switch (internalformat) {
-        case GL_RGBA32F:
-        case GL_RGBA32UI:
-        case GL_RGBA32I:
-            return TextureViewClass::Bits128;
-        case GL_RGB32F:
-        case GL_RGB32UI:
-        case GL_RGB32I:
-            return TextureViewClass::Bits96;
-        case GL_RGBA16F:
-        case GL_RG32F:
-        case GL_RGBA16UI:
-        case GL_RG32UI:
-        case GL_RGBA16I:
-        case GL_RG32I:
-        case GL_RGBA16:
-        case GL_RGBA16_SNORM:
-            return TextureViewClass::Bits64;
-        case GL_RGB16:
-        case GL_RGB16_SNORM:
-        case GL_RGB16F:
-        case GL_RGB16UI:
-        case GL_RGB16I:
-            return TextureViewClass::Bits48;
-        case GL_RG16F:
-        case GL_R11F_G11F_B10F:
-        case GL_R32F:
-        case GL_RGB10_A2UI:
-        case GL_RGBA8UI:
-        case GL_RG16UI:
-        case GL_R32UI:
-        case GL_RGBA8I:
-        case GL_RG16I:
-        case GL_R32I:
-        case GL_RGB10_A2:
-        case GL_RGBA8:
-        case GL_RG16:
-        case GL_RGBA8_SNORM:
-        case GL_RG16_SNORM:
-        case GL_SRGB8_ALPHA8:
-        case GL_RGB9_E5:
-            return TextureViewClass::Bits32;
-        case GL_RGB8:
-        case GL_RGB8_SNORM:
-        case GL_SRGB8:
-        case GL_RGB8UI:
-        case GL_RGB8I:
-            return TextureViewClass::Bits24;
-        case GL_R16F:
-        case GL_RG8UI:
-        case GL_R16UI:
-        case GL_RG8I:
-        case GL_R16I:
-        case GL_RG8:
-        case GL_R16:
-        case GL_RG8_SNORM:
-        case GL_R16_SNORM:
-            return TextureViewClass::Bits16;
-        case GL_R8UI:
-        case GL_R8I:
-        case GL_R8:
-        case GL_R8_SNORM:
-            return TextureViewClass::Bits8;
-        case GL_COMPRESSED_RED_RGTC1:
-        case GL_COMPRESSED_SIGNED_RED_RGTC1:
-            return TextureViewClass::Rgtc1Red;
-        case GL_COMPRESSED_RG_RGTC2:
-        case GL_COMPRESSED_SIGNED_RG_RGTC2:
-            return TextureViewClass::Rgtc2Rg;
-        case GL_COMPRESSED_RGBA_BPTC_UNORM:
-        case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM:
-            return TextureViewClass::BptcUnorm;
-        case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT:
-        case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT:
-            return TextureViewClass::BptcFloat;
-        default:
-            // Every depth/stencil format, every S3TC/ETC/ASTC format and every unsized format
-            // reaches here. The caller must then demand an EXACT format match.
-            return TextureViewClass::None;
-        }
-    }
-
-    // GL 4.6 core table 8.20 ("Legal texture targets for TextureView").
-    Bool IsLegalTextureViewTargetPair(TextureTarget origTarget, TextureTarget viewTarget) {
-        switch (origTarget) {
-        case TextureTarget::Texture1D:
-            return viewTarget == TextureTarget::Texture1D || viewTarget == TextureTarget::Texture1DArray;
-        case TextureTarget::Texture2D:
-            return viewTarget == TextureTarget::Texture2D || viewTarget == TextureTarget::Texture2DArray;
-        case TextureTarget::Texture3D:
-            return viewTarget == TextureTarget::Texture3D;
-        case TextureTarget::TextureCubeMap:
-            return viewTarget == TextureTarget::TextureCubeMap || viewTarget == TextureTarget::Texture2D ||
-                   viewTarget == TextureTarget::Texture2DArray || viewTarget == TextureTarget::TextureCubeMapArray;
-        case TextureTarget::TextureRectangle:
-            return viewTarget == TextureTarget::TextureRectangle;
-        case TextureTarget::Texture1DArray:
-            return viewTarget == TextureTarget::Texture1DArray || viewTarget == TextureTarget::Texture1D;
-        case TextureTarget::Texture2DArray:
-            return viewTarget == TextureTarget::Texture2DArray || viewTarget == TextureTarget::Texture2D ||
-                   viewTarget == TextureTarget::TextureCubeMap || viewTarget == TextureTarget::TextureCubeMapArray;
-        case TextureTarget::TextureCubeMapArray:
-            return viewTarget == TextureTarget::TextureCubeMapArray || viewTarget == TextureTarget::Texture2DArray ||
-                   viewTarget == TextureTarget::Texture2D || viewTarget == TextureTarget::TextureCubeMap;
-        case TextureTarget::Texture2DMultisample:
-        case TextureTarget::Texture2DMultisampleArray:
-            return viewTarget == TextureTarget::Texture2DMultisample ||
-                   viewTarget == TextureTarget::Texture2DMultisampleArray;
-        case TextureTarget::TextureBuffer:
-            // The table lists no legal target for a buffer texture: its storage is a buffer
-            // object, and there is nothing to make a view of.
-            return false;
-        default:
-            return false;
-        }
-    }
-
-    Uint RequiredTextureViewLayerCount(TextureTarget viewTarget) {
-        switch (viewTarget) {
-        case TextureTarget::TextureCubeMap:
-            return 6;
-        case TextureTarget::Texture1D:
-        case TextureTarget::Texture2D:
-        case TextureTarget::Texture3D:
-        case TextureTarget::TextureRectangle:
-        case TextureTarget::Texture2DMultisample:
-            return 1;
-        default:
-            // 1D/2D array, cube-map array, 2D multisample array: any count (the cube-map array's
-            // "multiple of 6" is checked by the caller).
-            return 0;
-        }
-    }
+    } // namespace TextureImpl
 } // namespace MobileGL::MG_Impl::GLImpl::TextureImpl

MobileGL/MG_Impl/GLImpl/Texture/Validators.h

@@ -20,13 +20,6 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
     Bool ValidateTexturePixelDataType(TexturePixelDataType texturePixelDataType);
     Bool ValidateTextureLevelNumber(Int level);
     Bool ValidateTextureSizeWithTextureUploadTarget(TextureUploadTarget target, GLsizei width, GLsizei height);
-    // The two shape rules a cube-map-array level owes (GL 4.6 core 8.5): its faces are square, and
-    // its depth counts whole cubes. Both are GL_INVALID_VALUE. This used to be spelled inline in
-    // glTexStorage3D only, which is why glTexImage3D let both violations through - every entry
-    // point that DEFINES a cube-array level calls this now, so the two cannot drift again. A
-    // non-cube-array upload target answers true untouched.
-    Bool ValidateCubeMapArrayShape(TextureUploadTarget target, GLsizei width, GLsizei height, GLsizei depth,
-                                   const char* caller);
     Bool ValidateTextureSizeRange(Int width, Int height, Int depth);
     Bool ValidateTextureInternalFormat(TextureInternalFormat format);
     Bool ValidateTextureBorderNumber(Int border);
@@ -37,16 +30,6 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
                                                           TextureInternalFormat internalFormat,
                                                           TexturePixelDataType type);
     Bool ValidateTextureLevelWithUploadTarget(TextureUploadTarget target, Int level);
-    // "Is <level> a level this texture actually has?", which ValidateTextureLevelNumber above
-    // does NOT answer - that one only bounds the index by GL_MAX_TEXTURE_SIZE and knows nothing
-    // about the object. Entry points that resolve a level straight into a backend image
-    // subresource need this one: a level the texture never had is GL_INVALID_VALUE (GL 4.6 core
-    // 18.3.2), and passing it through instead reaches the driver as an out-of-range subresource.
-    // Note the error split is per-entry-point, so this is not universally reusable:
-    // glClearTexImage owes INVALID_OPERATION for the same out-of-range level and spells its own
-    // copy of this predicate in GL_Texture.cpp (GetClearTextureObject).
-    Bool ValidateTextureLevelExists(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject, Int level,
-                                    const char* caller);
     Bool ValidateTextureObject(const 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
@@ -57,62 +40,5 @@ namespace MobileGL::MG_Impl::GLImpl::TextureImpl {
                                          TextureTarget target);
     Bool ValidateTextureSubImageOffsets(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject, Int xoffset,
                                         Int width, Int yoffset = 0, Int height = 0, Int zoffset = 0, Int depth = 0);
-    // The texel block of one glCopyImageSubData endpoint, resolved to the two things the
-    // compatibility rule actually asks about. `compressed` is not redundant with a block bigger
-    // than 1x1: it is what distinguishes "compressed, and so the region is measured in texels of
-    // a blocked image" from "uncompressed, and so it is measured in texels".
-    struct CopyImageTexelBlock {
-        SizeT byteSize = 0;
-        Uint blockWidth = 1;
-        Uint blockHeight = 1;
-        Bool compressed = false;
-    };
-    // `compressedFormat` is the GLenum a glCompressedTexImage* upload recorded for the level, or
-    // GL_NONE. It has to be asked for separately because MobileGL stores every compressed format
-    // in uncompressed storage (ConvertGLEnumToTextureInternalFormat), so the TextureInternalFormat
-    // alone can no longer tell a BPTC image from the RGBA8 backing it.
-    CopyImageTexelBlock ResolveCopyImageTexelBlock(TextureInternalFormat format, GLenum compressedFormat);
-    // GL 4.6 core 18.3.2: the two images must be COMPATIBLE, and compatible means their texel
-    // blocks are the same SIZE - not that they share a base internal format. RGBA32UI into
-    // RGBA32F is legal (both 128-bit) while RGBA8 into RGBA32F is not, and a compressed image
-    // pairs with an uncompressed one whose texel is as big as the compressed block.
-    Bool ValidateCopyImageFormatCompatibility(const CopyImageTexelBlock& srcBlock,
-                                              const CopyImageTexelBlock& dstBlock);
-    // GL 4.6 core 18.3.2: for a compressed image the region's origin must sit on a block
-    // boundary and its size must be a whole number of blocks - unless the edge it runs to is
-    // the edge of the image.
-    Bool ValidateCopyImageBlockAlignment(const CopyImageTexelBlock& block, Int x, Int y, Int width, Int height,
-                                         Int imageWidth, Int imageHeight, const char* endpointName);
-    // GL 4.6 SS 8.6 subset rule for glCopyTexImage*: the read buffer must supply every component
-    // the requested internalformat asks for, but may supply more.
-    Bool ValidateCopyTexImageBaseFormatSubset(TextureInternalFormat destFormat, TextureInternalFormat srcFormat);
-
-    // ---- glTextureView (ARB_texture_view / GL 4.6 core 8.18) ----
-    // Table 8.21's view classes. `None` is not a class - it means the format has NO entry in the
-    // table, which the spec turns into a much stricter rule than "same class": such a format can
-    // only ever be viewed as ITSELF. Every depth, stencil and depth/stencil format lands here,
-    // which is why the Better Clouds D24S8 view must name GL_DEPTH24_STENCIL8 exactly.
-    enum class TextureViewClass {
-        None = 0,
-        Bits128,
-        Bits96,
-        Bits64,
-        Bits48,
-        Bits32,
-        Bits24,
-        Bits16,
-        Bits8,
-        Rgtc1Red,
-        Rgtc2Rg,
-        BptcUnorm,
-        BptcFloat,
-    };
-    TextureViewClass GetTextureViewClass(GLenum internalformat);
-    // Table 8.20: which <target> values glTextureView accepts for a given origtexture target.
-    Bool IsLegalTextureViewTargetPair(TextureTarget origTarget, TextureTarget viewTarget);
-    // Table 8.20 again, read the other way: how many layers <target> requires. Returns 0 for the
-    // targets whose layer count is unconstrained (the array targets), 6 for GL_TEXTURE_CUBE_MAP,
-    // and 1 for every single-layer target. GL_TEXTURE_CUBE_MAP_ARRAY is special-cased by the
-    // caller because its constraint is "a multiple of 6", not an exact count.
-    Uint RequiredTextureViewLayerCount(TextureTarget viewTarget);
+    Bool ValidateBaseInternalFormatMatch(TextureInternalFormat format1, TextureInternalFormat format2);
 } // namespace MobileGL::MG_Impl::GLImpl::TextureImpl

MobileGL/MG_Impl/GLImpl/VertexArray/GL_VertexArray.cpp

@@ -179,28 +179,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return vao;
         }
 
-        // The ARB_vertex_attrib_binding entry points that take no vertex array name modify the
-        // *bound* vertex array, and in a core profile the default vertex array (name 0) is not
-        // one: every one of them is INVALID_OPERATION there (GL 4.6 core 10.3.1, and the tail of
-        // each KHR-GL4x.vertex_attrib_binding.negative-* case checks exactly this). MobileGL
-        // keeps a real object at name 0 for the compatibility paths, so GetBoundVertexArray
-        // never returns null and the rule has to be spelled out - behind the same gate the VAO-0
-        // draw rule already uses (MOBILEGL_RELAXED_SEMANTICS, plus "the context never asked for
-        // a core profile"), so applications that legitimately run relaxed keep working.
-        static SharedPtr<MG_State::GLState::VertexArrayObject> GetBoundVertexArrayForBindingApi(const char* funcName) {
-            auto vao = GetBoundVertexArrayOrError(funcName);
-            if (!vao) return nullptr;
-            if (vao->GetExternalIndex() == 0 && !MG_State::IsRelaxedSemanticsActive()) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", funcName,
-                        "The default vertex array object cannot be modified in a core profile."));
-                return nullptr;
-            }
-            return vao;
-        }
-
         static bool ValidateVertexAttribPname(GLenum pname) {
             switch (pname) {
             case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
@@ -315,10 +293,9 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         auto offset = reinterpret_cast<SizeT>(pointer);
 
-        const int effectiveStride = EffectiveVertexStride(stride, size, type);
-        vao->SetAttributeFormat(index, size, dataType, false, stride, offset, true, false, effectiveStride);
+        vao->SetAttributeFormat(index, size, dataType, false, stride, offset, true, false);
         vao->BindAttributeBuffer(index, vbo);
-        vao->MirrorPointerIntoBinding(index, vbo, offset, effectiveStride);
+        vao->MirrorPointerIntoBinding(index, vbo, offset, EffectiveVertexStride(stride, size, type));
     }
 
     void VertexAttribPointer_State(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
@@ -346,11 +323,9 @@ namespace MobileGL::MG_Impl::GLImpl {
         // backend can pick the reversed VkFormat / pass GL_BGRA through to a GLES driver.
         const bool isBgra = (size == static_cast<GLint>(GL_BGRA));
         const int effectiveSize = isBgra ? 4 : size;
-        const int effectiveStride = EffectiveVertexStride(stride, effectiveSize, type);
-        vao->SetAttributeFormat(index, effectiveSize, dataType, normalized, stride, offset, false, isBgra,
-                                effectiveStride);
+        vao->SetAttributeFormat(index, effectiveSize, dataType, normalized, stride, offset, false, isBgra);
         vao->BindAttributeBuffer(index, vbo);
-        vao->MirrorPointerIntoBinding(index, vbo, offset, effectiveStride);
+        vao->MirrorPointerIntoBinding(index, vbo, offset, EffectiveVertexStride(stride, effectiveSize, type));
     }
 
     void BindVertexArray_State(GLuint array) {
@@ -514,17 +489,10 @@ namespace MobileGL::MG_Impl::GLImpl {
     // 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 at full precision is detected, not assumed: DirectVulkan
-    // needs shaderFloat64, and DirectGLES can never have it at all. What that costs is PRECISION,
-    // not the call and no longer the array: GL 4.6 core 10.3.2 defines no error for a well-formed
-    // glVertexAttribLFormat, and a GL 4.3 context has 64-bit attributes in core, so declining the
-    // call would be non-conformant and would make the four pure state queries
-    // (VERTEX_ATTRIB_ARRAY_SIZE / _TYPE / _LONG / _RELATIVE_OFFSET) unanswerable
-    // (KHR-GL43.vertex_attrib_binding.basic-state1/3). The format is therefore RECORDED here and
-    // the array is NARROWED to float32 at draw, matching the fp64 demotion every shader already
-    // gets (DemoteFloat64Pass) - loudly, once, naming the cost. The matching startup POST row is in
-    // MG_Util/SelfTest/DriverPost.cpp; the draw-side narrowing is DirectGLES/Managers.cpp and, on
-    // DirectVulkan, VertexInputStateFactory's Float64 case.
+    // 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,
                                                   GLuint relativeoffset) {
@@ -534,12 +502,15 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         if (!MG_Backend::pActiveBackendObject ||
             !MG_Backend::pActiveBackendObject->GetDynamicParameters().SupportsFloat64VertexAttributes) {
-            MGLOG_W_ONCE("VertexAttribLFormat: attribute %u asked for a 64-bit (GL_DOUBLE) format, but this "
-                    "backend has no double-precision vertex attribute support - the format is recorded "
-                    "and queryable, and the array is FETCHED AT FLOAT32 PRECISION at draw (the same "
-                    "narrowing the shader's dvec inputs already get); see the \"64-bit vertex "
-                    "attributes\" / \"shaderFloat64\" POST row for what that costs",
+            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),
@@ -973,7 +944,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             params[0] = static_cast<GLfloat>(attr->Size);
             return;
         case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
-            params[0] = static_cast<GLfloat>(attr->LegacyStride);
+            params[0] = static_cast<GLfloat>(attr->Stride);
             return;
         case GL_VERTEX_ATTRIB_ARRAY_TYPE:
             params[0] = static_cast<GLfloat>(MG_Util::ConvertDataTypeToGLEnum(attr->Type));
@@ -1043,7 +1014,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             params[0] = static_cast<GLdouble>(attr->Size);
             return;
         case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
-            params[0] = static_cast<GLdouble>(attr->LegacyStride);
+            params[0] = static_cast<GLdouble>(attr->Stride);
             return;
         case GL_VERTEX_ATTRIB_ARRAY_TYPE:
             params[0] = static_cast<GLdouble>(MG_Util::ConvertDataTypeToGLEnum(attr->Type));
@@ -1108,11 +1079,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_VERTEX_ATTRIB_ARRAY_SIZE:
             params[0] = attr->Size;
             return;
-        // The legacy shadow, not the resolved draw stride: GL 4.6 core table 23.3 defines this
-        // as the last glVertexAttrib*Pointer argument, which glBindVertexBuffer must not
-        // overwrite even though it does overwrite what the backend actually reads.
         case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
-            params[0] = attr->LegacyStride;
+            params[0] = attr->Stride;
             return;
         case GL_VERTEX_ATTRIB_ARRAY_TYPE:
             params[0] = static_cast<GLint>(MG_Util::ConvertDataTypeToGLEnum(attr->Type));
@@ -1170,7 +1138,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
 
         const auto& attr = vao->GetAttribute(index);
-        *pointer = reinterpret_cast<void*>(attr.LegacyPointer);
+        *pointer = reinterpret_cast<void*>(attr.Offset);
     }
 
     void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) {
@@ -1254,7 +1222,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             *param = static_cast<GLint>(attr.Size);
             return;
         case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
-            *param = static_cast<GLint>(attr.LegacyStride);
+            *param = static_cast<GLint>(attr.Stride);
             return;
         case GL_VERTEX_ATTRIB_ARRAY_TYPE:
             *param = static_cast<GLint>(MG_Util::ConvertDataTypeToGLEnum(attr.Type));
@@ -1326,14 +1294,14 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void BindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) {
-        auto vao = GetBoundVertexArrayForBindingApi("BindVertexBuffer");
+        auto vao = GetBoundVertexArrayOrError("BindVertexBuffer");
         if (!vao) return;
         VertexBufferBinding_State(vao, bindingindex, buffer, offset, stride, "BindVertexBuffer");
     }
 
     void BindVertexBuffers(GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets,
                            const GLsizei* strides) {
-        auto vao = GetBoundVertexArrayForBindingApi("BindVertexBuffers");
+        auto vao = GetBoundVertexArrayOrError("BindVertexBuffers");
         if (!vao) return;
         if (!ValidateVertexBindingRange(first, count, "BindVertexBuffers")) return;
         for (GLsizei i = 0; i < count; ++i) {
@@ -1347,21 +1315,21 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void VertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) {
-        auto vao = GetBoundVertexArrayForBindingApi("VertexAttribFormat");
+        auto vao = GetBoundVertexArrayOrError("VertexAttribFormat");
         if (!vao) return;
         VertexAttribFormatSeparate_State(vao, attribindex, size, type, normalized, relativeoffset, false,
                                          "VertexAttribFormat");
     }
 
     void VertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) {
-        auto vao = GetBoundVertexArrayForBindingApi("VertexAttribIFormat");
+        auto vao = GetBoundVertexArrayOrError("VertexAttribIFormat");
         if (!vao) return;
         VertexAttribFormatSeparate_State(vao, attribindex, size, type, GL_FALSE, relativeoffset, true,
                                          "VertexAttribIFormat");
     }
 
     void VertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) {
-        auto vao = GetBoundVertexArrayForBindingApi("VertexAttribLFormat");
+        auto vao = GetBoundVertexArrayOrError("VertexAttribLFormat");
         if (!vao) return;
         VertexAttribLFormatSeparate_State(vao, attribindex, size, type, relativeoffset);
     }
@@ -1373,7 +1341,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void VertexAttribBinding(GLuint attribindex, GLuint bindingindex) {
-        auto vao = GetBoundVertexArrayForBindingApi("VertexAttribBinding");
+        auto vao = GetBoundVertexArrayOrError("VertexAttribBinding");
         if (!vao) return;
         if (!VertexArrayImpl::ValidateVertexAttributeIndex(attribindex)) return;
         if (!ValidateVertexBindingIndex(bindingindex, "VertexAttribBinding")) return;
@@ -1381,7 +1349,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void VertexBindingDivisor(GLuint bindingindex, GLuint divisor) {
-        auto vao = GetBoundVertexArrayForBindingApi("VertexBindingDivisor");
+        auto vao = GetBoundVertexArrayOrError("VertexBindingDivisor");
         if (!vao) return;
         if (!ValidateVertexBindingIndex(bindingindex, "VertexBindingDivisor")) return;
         vao->SetBindingDivisor(bindingindex, divisor);

MobileGL/MG_Impl/GLImpl/VertexArray/Validators.cpp

@@ -12,15 +12,15 @@
 #include <MG_State/GLState/ErrorState/Error.h>
 #include <MG_Util/Converters/MGToGL/DataTypeConverter.h>
 #include <MG_Util/Converters/MGToStr/DataTypeConverter.h>
-#include <MG_Util/ShaderTranspiler/CompileEnv.h>
 
 namespace MobileGL::MG_Impl::GLImpl::VertexArrayImpl {
     Uint GetMaxVertexAttribs() {
-        // Shared with reflection's limit and with gl_MaxVertexAttribs; see ResolveMaxVertexAttribs.
-        const Bool hasBackend = MG_Backend::pActiveBackendObject != nullptr;
-        const Int backendLimit =
-            hasBackend ? MG_Backend::pActiveBackendObject->GetDynamicParameters().MaxVertexAttribs : 0;
-        return static_cast<Uint>(MG_Util::ShaderTranspiler::ResolveMaxVertexAttribs(hasBackend, backendLimit));
+        constexpr Uint capacity = static_cast<Uint>(MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS);
+        if (!MG_Backend::pActiveBackendObject) return capacity;
+
+        const Int backendLimit = MG_Backend::pActiveBackendObject->GetDynamicParameters().MaxVertexAttribs;
+        if (backendLimit <= 0) return capacity;
+        return std::min(static_cast<Uint>(backendLimit), capacity);
     }
 
     Uint GetMaxVertexAttribBindings() {

MobileGL/MG_Impl/GLXImpl/Exporting/Definitions.cpp

@@ -166,32 +166,32 @@ MOBILEGL_GLX_API int glXSwapIntervalSGI(int interval) {
 
 // Legacy entry points some loaders probe for; harmless no-op stubs.
 MOBILEGL_GLX_API void glXCopyContext(Display*, void*, void*, unsigned long) {
-    MGLOG_W_ONCE("glx: glXCopyContext is not supported");
+    MGLOG_W("glx: glXCopyContext is not supported");
 }
 
 MOBILEGL_GLX_API unsigned long glXCreateGLXPixmap(Display*, void*, unsigned long) {
-    MGLOG_W_ONCE("glx: glXCreateGLXPixmap is not supported");
+    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_ONCE("glx: glXCreatePixmap is not supported");
+    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_ONCE("glx: glXCreatePbuffer is not supported");
+    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_ONCE("glx: glXUseXFont is not supported");
+    MGLOG_W("glx: glXUseXFont is not supported");
 }
 
 MOBILEGL_GLX_API void glXSelectEvent(Display*, unsigned long, unsigned long) {}

MobileGL/MG_Impl/GLXImpl/GLXImpl.cpp

@@ -149,7 +149,7 @@ namespace MobileGL::MG_Impl::GLXImpl {
                     fns->Sync = reinterpret_cast<decltype(fns->Sync)>(dlsym(fns->Library, "XSync"));
                 }
                 if (!fns->Valid()) {
-                    MGLOG_E_ONCE("glx: failed to load libX11 entry points");
+                    MGLOG_E("glx: failed to load libX11 entry points");
                 }
                 return fns;
             }();
@@ -314,7 +314,7 @@ namespace MobileGL::MG_Impl::GLXImpl {
             Uint32 width = 0;
             Uint32 height = 0;
             if (!QueryDrawableSize(dpy, drawable, width, height)) {
-                MGLOG_E_ONCE("glx: XGetGeometry failed for drawable 0x%lx", drawable);
+                MGLOG_E("glx: XGetGeometry failed for drawable 0x%lx", drawable);
                 return nullptr;
             }
 
@@ -326,7 +326,7 @@ namespace MobileGL::MG_Impl::GLXImpl {
             EGLSurface surface = EGLImpl::CreatePlatformWindowSurface(
                 context.Display, context.Config, reinterpret_cast<void*>(drawable), attribs);
             if (surface == EGL_NO_SURFACE) {
-                MGLOG_E_ONCE("glx: failed to create window surface for drawable 0x%lx (%ux%u)", drawable,
+                MGLOG_E("glx: failed to create window surface for drawable 0x%lx (%ux%u)", drawable,
                         width, height);
                 return nullptr;
             }
@@ -347,7 +347,7 @@ namespace MobileGL::MG_Impl::GLXImpl {
             const std::lock_guard<std::recursive_mutex> lock(RegistryMutex());
             EGLDisplay display = EnsureDisplay();
             if (display == EGL_NO_DISPLAY) {
-                MGLOG_E_ONCE("glx: no EGL display");
+                MGLOG_E("glx: no EGL display");
                 return nullptr;
             }
             EGLImpl::BindAPI(EGL_OPENGL_API);
@@ -376,13 +376,13 @@ namespace MobileGL::MG_Impl::GLXImpl {
             EGLint configCount = 0;
             if (!EGLImpl::ChooseConfig(display, configAttribs, &config, 1, &configCount) ||
                 configCount <= 0) {
-                MGLOG_E_ONCE("glx: eglChooseConfig failed");
+                MGLOG_E("glx: eglChooseConfig failed");
                 return nullptr;
             }
 
             EGLContext eglContext = EGLImpl::CreateContext(display, config, shareContext, contextAttribs);
             if (eglContext == EGL_NO_CONTEXT) {
-                MGLOG_E_ONCE("glx: eglCreateContext failed");
+                MGLOG_E("glx: eglCreateContext failed");
                 return nullptr;
             }
 
@@ -931,7 +931,7 @@ namespace MobileGL::MG_Impl::GLXImpl {
 
         if (!EGLImpl::MakeCurrent(object->Display, surface->Surface, surface->Surface,
                                   object->Context)) {
-            MGLOG_E_ONCE("glx: eglMakeCurrent failed (drawable=0x%lx, ctx=%p)", drawable, context);
+            MGLOG_E("glx: eglMakeCurrent failed (drawable=0x%lx, ctx=%p)", drawable, context);
             return 0;
         }
         t_current = {dpy, drawable, drawable, context};
@@ -943,7 +943,7 @@ namespace MobileGL::MG_Impl::GLXImpl {
         if (context && draw != read) {
             // MobileGL's backends reject split draw/read surfaces; bind the draw
             // drawable for both, which is what every real caller here needs.
-            MGLOG_W_ONCE("glx: glXMakeContextCurrent draw 0x%lx != read 0x%lx, using draw for both", draw,
+            MGLOG_W("glx: glXMakeContextCurrent draw 0x%lx != read 0x%lx, using draw for both", draw,
                     read);
         }
         const int result = MakeCurrent(dpy, draw, context);
@@ -958,7 +958,7 @@ namespace MobileGL::MG_Impl::GLXImpl {
         auto& surfaces = DrawableSurfaces();
         auto it = surfaces.find(drawable);
         if (it == surfaces.end()) {
-            MGLOG_W_ONCE("glx: glXSwapBuffers with no surface for drawable 0x%lx", drawable);
+            MGLOG_W("glx: glXSwapBuffers with no surface for drawable 0x%lx", drawable);
             return;
         }
         SyncSurfaceSize(dpy, drawable, it->second);

MobileGL/MG_Impl/GLXImpl/LookUp/LookUp.cpp

@@ -31,7 +31,7 @@ namespace MG_Impl::GLXImpl {
 #endif
         void* proc = MobileGL::MG_Impl::GetProcAddress(name);
         if (!proc) {
-            MGLOG_D("Failed to get function: %s", (const char*)name);
+            MGLOG_W("Failed to get function: %s", (const char*)name);
             return nullptr;
         }