[Fix] (MG_Backend/DirectVulkan, ShaderTranspiler, MG_Test, TraceReplay): make iterationRP retrace pass on 64-lane Vulkan devices with subgroup-width emulation and format-aware readback

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

.github/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/workflows/apk.yml

@@ -11,9 +11,6 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
-    permissions:
-      actions: write
-      contents: read
     env:
       CCACHE_BASEDIR: ${{ github.workspace }}
       CCACHE_COMPRESS: "true"
@@ -44,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
@@ -127,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)"
@@ -225,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')"
@@ -435,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
@@ -470,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}" \
@@ -527,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()
@@ -615,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})"

.github/workflows/test.yml

@@ -1,4 +1,4 @@
-name: Test
+name: Test
 
 on:
   push:
@@ -11,9 +11,6 @@ on:
 jobs:
   build-linux:
     runs-on: ubuntu-latest
-    permissions:
-      actions: write
-      contents: read
     env:
       BUILD_DIR: build-linux
       CCACHE_BASEDIR: ${{ github.workspace }}
@@ -37,11 +34,12 @@ jobs:
         uses: lukka/get-cmake@v4.3.3
 
       - name: Restore ccache
-        uses: actions/cache/restore@v5
+        uses: actions/cache@v5
         with:
           path: .ccache
-          key: ${{ runner.os }}-test-${{ github.job }}-ccache-v1
+          key: ${{ runner.os }}-test-${{ github.job }}-ccache-${{ github.ref_name }}-${{ github.run_id }}
           restore-keys: |
+            ${{ runner.os }}-test-${{ github.job }}-ccache-${{ github.ref_name }}-
             ${{ runner.os }}-test-${{ github.job }}-ccache-
 
       - name: Prepare Vulkan SDK
@@ -85,8 +83,6 @@ jobs:
             -DMOBILEGL_LOG_ACTIVE_LEVEL=MOBILEGL_LOG_LEVEL_INFO \
             -DMOBILEGL_BUILD_TEST=ON \
             -DMOBILEGL_BUILD_BENCHMARK=ON \
-            -DMOBILEGL_BUILD_INTEGRATION_TEST=ON \
-            -DMOBILEGL_ITEST_VK_ICD=/usr/share/vulkan/icd.d/lvp_icd.json \
             -DMOBILEGL_BUILD_TRACE_REPLAY=OFF \
             -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON \
             -DBENCHMARK_ENABLE_TESTING=OFF \
@@ -99,28 +95,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 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 }}-test-${{ 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 }}-test-${{ github.job }}-ccache-v1
-
       - name: Package Linux runtime
         run: |
           mkdir -p ci-artifacts
@@ -136,7 +110,6 @@ jobs:
             "${BUILD_DIR}/CTestTestfile.cmake" \
             "${BUILD_DIR}/MobileGL/MG_Test" \
             "${BUILD_DIR}/MobileGL/MG_Benchmark" \
-            "${BUILD_DIR}/MobileGL/MG_IntegrationTest" \
             "${SHARED_LIBS[@]}"
 
       - name: Upload Linux runtime
@@ -186,102 +159,12 @@ jobs:
       - name: Test
         working-directory: build-linux
         run: |
-          ulimit -c unlimited
-          sudo sysctl -w kernel.core_pattern='/tmp/core.%e.%p'
           if [ "${{ secrets.ACTIONS_STEP_DEBUG }}" = "true" ]; then
             ctest -V -L unit --no-tests=error
           else
             ctest --output-on-failure -L unit --no-tests=error
           fi
 
-      - name: Upload core dumps
-        if: failure()
-        uses: actions/upload-artifact@v7
-        with:
-          name: unit-core-dumps
-          path: /tmp/core.*
-          if-no-files-found: ignore
-
-  integration:
-    runs-on: ubuntu-latest
-    needs: build-linux
-
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v6
-
-      - name: Get CMake
-        uses: lukka/get-cmake@v4.3.3
-
-      - name: Install runtime dependencies
-        # Same set as the benchmark job, for the same reason: the scenarios bring
-        # up real headless EGL (llvmpipe) and Vulkan (lavapipe) contexts, and
-        # libegl-mesa0 - the EGL vendor library behind glvnd's libegl1 dispatch -
-        # only arrives as a Recommends.
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libvulkan1 libegl1 libegl-mesa0 libgles2 libgl1-mesa-dri mesa-vulkan-drivers
-
-      - name: Download Linux runtime
-        uses: actions/download-artifact@v8
-        with:
-          name: mobilegl-linux-runtime
-          path: .
-
-      - name: Unpack Linux runtime
-        run: tar -xzf mobilegl-linux-runtime.tgz
-
-      - name: Normalize CTest command paths
-        run: |
-          python - <<'PY'
-          from pathlib import Path
-          import re
-
-          for path in Path('build-linux').rglob('CTestTestfile.cmake'):
-              text = path.read_text()
-              text = re.sub(r'"[^"]*/cmake-[^"]*/bin/cmake"', '"cmake"', text)
-              path.write_text(text)
-          PY
-
-      - name: Integration scenarios
-        working-directory: build-linux
-        # REQUIRE_GPU makes a driverless runner FAIL instead of skipping every
-        # scenario - an all-skip run is otherwise indistinguishable from a pass,
-        # which is how a five-month-old draw-dropping bug survived unseen until
-        # this lane existed.
-        #
-        # The lavapipe ICD pin lives in the build-linux configure
-        # (-DMOBILEGL_ITEST_VK_ICD), NOT here: the configure bakes it into each
-        # test's ctest ENVIRONMENT property, and a property entry OVERRIDES the
-        # job environment - a VK_ICD_FILENAMES exported here would be silently
-        # ignored while looking like it works. This lane runs on lavapipe
-        # deterministically, not on whichever of the eight Mesa ICDs a GPU-less
-        # runner enumerates first.
-        #
-        # Cores are armed so that any crash - the harness pre-flight child's
-        # included - leaves /tmp/core.*, which the failure-only step below ships
-        # as an artifact. Analyzing a downloaded core against the runtime
-        # artifact's binary in an ubuntu-24.04 userspace reproduces the exact
-        # crash stack without burning a CI round on an in-workflow debugger.
-        env:
-          MOBILEGL_ITEST_REQUIRE_GPU: "1"
-        run: |
-          ulimit -c unlimited
-          sudo sysctl -w kernel.core_pattern='/tmp/core.%e.%p'
-          if [ "${{ secrets.ACTIONS_STEP_DEBUG }}" = "true" ]; then
-            ctest -V -L integration-gpu --no-tests=error
-          else
-            ctest --output-on-failure -L integration-gpu --no-tests=error
-          fi
-
-      - name: Upload core dumps
-        if: failure()
-        uses: actions/upload-artifact@v7
-        with:
-          name: integration-core-dumps
-          path: /tmp/core.*
-          if-no-files-found: ignore
-
   benchmark:
     runs-on: ubuntu-latest
     needs: build-linux
@@ -294,13 +177,9 @@ jobs:
         uses: lukka/get-cmake@v4.3.3
 
       - name: Install runtime dependencies
-        # libegl-mesa0 is the EGL vendor library itself: DriverBench brings up a
-        # real GL context, and libegl1 is only glvnd's dispatch. It normally
-        # arrives as a Recommends of libegl1, which is too quiet a dependency for
-        # the one job that needs a working driver.
         run: |
           sudo apt-get update
-          sudo apt-get install -y libvulkan1 libegl1 libegl-mesa0 libgles2 libgl1-mesa-dri mesa-vulkan-drivers
+          sudo apt-get install -y libvulkan1 libegl1 libgles2 libgl1-mesa-dri mesa-vulkan-drivers
 
       - name: Download Linux runtime
         uses: actions/download-artifact@v8
@@ -325,18 +204,7 @@ jobs:
 
       - name: Benchmark
         working-directory: build-linux
-        run: |
-          ulimit -c unlimited
-          sudo sysctl -w kernel.core_pattern='/tmp/core.%e.%p'
-          ctest -V -C Release -L benchmark --no-tests=error
-
-      - name: Upload core dumps
-        if: failure()
-        uses: actions/upload-artifact@v7
-        with:
-          name: benchmark-core-dumps
-          path: /tmp/core.*
-          if-no-files-found: ignore
+        run: ctest -V -C Release -L benchmark --no-tests=error
 
   build-retrace:
     runs-on: ubuntu-latest
@@ -344,10 +212,6 @@ jobs:
       - build-linux
       - test
       - benchmark
-      - integration
-    permissions:
-      actions: write
-      contents: read
     env:
       BUILD_DIR: build-retrace
       CCACHE_BASEDIR: ${{ github.workspace }}
@@ -372,11 +236,12 @@ jobs:
         uses: lukka/get-cmake@v4.3.3
 
       - name: Restore ccache
-        uses: actions/cache/restore@v5
+        uses: actions/cache@v5
         with:
           path: .ccache
-          key: ${{ runner.os }}-test-${{ github.job }}-ccache-v1
+          key: ${{ runner.os }}-test-${{ github.job }}-ccache-${{ github.ref_name }}-${{ github.run_id }}
           restore-keys: |
+            ${{ runner.os }}-test-${{ github.job }}-ccache-${{ github.ref_name }}-
             ${{ runner.os }}-test-${{ github.job }}-ccache-
 
       - name: Prepare Vulkan SDK
@@ -442,21 +307,6 @@ jobs:
         if: always()
         run: ccache --show-stats
 
-      - name: Release superseded ccache entry
-        if: github.ref_name == github.event.repository.default_branch
-        env:
-          GH_TOKEN: ${{ github.token }}
-          CACHE_KEY: ${{ runner.os }}-test-${{ 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 }}-test-${{ github.job }}-ccache-v1
-
       - name: Normalize CTest command paths
         run: |
           python - <<'PY'
@@ -489,7 +339,6 @@ jobs:
     needs:
       - test
       - benchmark
-      - integration
     outputs:
       names: ${{ steps.trace-cases.outputs.names }}
     steps:
@@ -513,41 +362,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')"
@@ -635,30 +452,11 @@ jobs:
       - name: Retrace and validate
         working-directory: build-retrace/tools/trace_replay
         run: |
-          ulimit -c unlimited
-          sudo sysctl -w kernel.core_pattern='/tmp/core.%e.%p'
           if [ '${{ matrix.backend }}' = 'DirectVulkan' ]; then
             export MOBILEGL_MAGMA_R11G11B10F_FALLBACK=1
           fi
-          # The blended depth-write quirk auto-enables only on Qualcomm, which no CI
-          # runner has, so force it on for the OIT case it exists to fix. ForceOn
-          # bypasses only the vendor gate, so this exercises the real strip on
-          # lavapipe. The Android AVD lane deliberately leaves it off, keeping the
-          # unstripped path covered for the same trace.
-          if [ '${{ matrix.backend }}' = 'DirectVulkan' ] \
-             && [ '${{ matrix.case }}' = 'improved-transparency-minecraft-26.3' ]; then
-            export MOBILEGL_MAGMA_DISABLE_BLENDED_DEPTH_WRITE=1
-          fi
           ctest -V --no-tests=error -R '^MobileGLTraceReplay\.${{ matrix.case }}\.${{ matrix.backend }}$'
 
-      - name: Upload core dumps
-        if: failure()
-        uses: actions/upload-artifact@v7
-        with:
-          name: retrace-core-dumps-${{ matrix.backend }}-${{ matrix.case }}
-          path: /tmp/core.*
-          if-no-files-found: ignore
-
       - name: Upload actual image
         if: always()
         uses: actions/upload-artifact@v7

.gitignore

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

.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
@@ -28,9 +31,3 @@
 [submodule "3rdparty/apitrace"]
 	path = 3rdparty/apitrace
 	url = https://github.com/MobileGL-Dev/apitrace.git
-[submodule "3rdparty/asio"]
-	path = 3rdparty/asio
-	url = https://github.com/chriskohlhoff/asio.git
-[submodule "include/ska"]
-	path = include/ska
-	url = https://github.com/MobileGL-Dev/flat_hash_map.git

CMakeLists.txt

@@ -4,11 +4,6 @@ project("MobileGL")
 
 option(MOBILEGL_BUILD_TEST        "Build MobileGL tests"                             ON )
 option(MOBILEGL_BUILD_BENCHMARK   "Build MobileGL benchmarks"                        ON )
-# Headless end-to-end GPU scenarios (MobileGL/MG_IntegrationTest). They need a
-# real GPU/ICD to do anything, so they are off by default for CI; every scenario
-# skips cleanly where there is none. Registered under the `integration-gpu`
-# ctest label so a run can select or exclude them.
-option(MOBILEGL_BUILD_INTEGRATION_TEST "Build MobileGL headless GPU integration tests" OFF)
 option(MOBILEGL_FORCE_RELEASE_OPT "Enable Release optimization flags in Debug build" ON )
 option(MOBILEGL_ENABLE_TRACY      "Enable tracy for profiling"                       OFF)
 option(MOBILEGL_BUILD_TRACE_REPLAY "Build desktop apitrace replay runner"            OFF)
@@ -20,86 +15,9 @@ set(MOBILEGL_VULKAN_LIBRARY "" CACHE FILEPATH "Vulkan loader/MoltenVK library to
 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)
-
-if ((NOT CMAKE_BUILD_TYPE STREQUAL "Debug" OR MOBILEGL_FORCE_RELEASE_OPT) AND MOBILEGL_ENABLE_LTO)
+if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug" OR MOBILEGL_FORCE_RELEASE_OPT)
     # Check if ThinLTO or LTO is suppported
     include(CheckIPOSupported)
     include(CheckCCompilerFlag)
@@ -229,9 +147,6 @@ set(SOURCE_FILES
 
     MobileGL/MG_Util/Debug/Log.cpp
 
-    MobileGL/MG_Util/Async/JobNode.cpp
-    MobileGL/MG_Util/Async/ShaderCompilePool.cpp
-
     MobileGL/MG_Util/Math/VectorTypes.cpp
     MobileGL/MG_Util/Metrics/TextureMetrics.cpp
 
@@ -265,7 +180,6 @@ set(SOURCE_FILES
 
     MobileGL/MG_Util/Classifiers/TextureEnumClassifier.cpp
 
-    MobileGL/MG_Util/ShaderTranspiler/CompileEnv.cpp
     MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpvcSession.cpp
     MobileGL/MG_Util/ShaderTranspiler/ShaderSourceProcessor.cpp
@@ -273,25 +187,10 @@ set(SOURCE_FILES
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FlattenInterfaceStructPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EliminateFloatEqualsZeroPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RenameSamplerFunctionParameterPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RenameBuiltinShadowingFunctionsPass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecomposeWorkgroupVec3Pass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecoratePositionInvariantPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.cpp
     MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerDrawParametersPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/PackDoubleVertexInputsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FlattenXfbInterfaceBlocksPass.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/NormalizeRectCoordinatesPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/Lower1DArrayImagesPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/BakeImageFormatsPass.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/BackendLoaders/OpenGL/Loader.cpp
     MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.cpp
@@ -302,7 +201,6 @@ set(SOURCE_FILES
     MobileGL/MG_Util/Texture/TextureFormatProcessor.cpp
 
     MobileGL/MG_Impl/GLXImpl/Exporting/Definitions.cpp
-    MobileGL/MG_Impl/GLXImpl/GLXImpl.cpp
     MobileGL/MG_Impl/GLXImpl/LookUp/LookUp.cpp
 
     MobileGL/MG_Impl/EGLImpl/Exporting/Definitions.cpp
@@ -316,8 +214,6 @@ set(SOURCE_FILES
     MobileGL/MG_Impl/GLImpl/Framebuffer/Validators.cpp
     MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp
     MobileGL/MG_Impl/GLImpl/Program/GL_Program.cpp
-    MobileGL/MG_Impl/GLImpl/Program/ProgramInterface.cpp
-    MobileGL/MG_Impl/GLImpl/Program/GL_ProgramPipeline.cpp
     MobileGL/MG_Impl/GLImpl/Texture/GL_Texture.cpp
     MobileGL/MG_Impl/GLImpl/Texture/Validators.cpp
     MobileGL/MG_Impl/GLImpl/Texture/ProxyTexture.cpp
@@ -340,7 +236,6 @@ set(SOURCE_FILES
     MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp
     MobileGL/MG_Backend/DirectGLES/Utils.cpp
     MobileGL/MG_Backend/DirectGLES/Managers.cpp
-    MobileGL/MG_Backend/DirectGLES/MultiDraw.cpp
 
     MobileGL/MG_Backend/DirectVulkan/DirectVulkan.cpp
     MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.cpp
@@ -379,12 +274,7 @@ set(SOURCE_FILES
     MobileGL/MG_State/GLState/TextureState/TextureUnit.cpp
     MobileGL/MG_State/GLState/TextureState/TextureState.cpp
     MobileGL/MG_State/GLState/ProgramState/ProgramObject.cpp
-    MobileGL/MG_State/GLState/ProgramState/ProgramLinkTask.cpp
-    MobileGL/MG_State/GLState/ProgramState/ProgramSpirvTask.cpp
-    MobileGL/MG_State/GLState/ProgramState/ShaderCompileTask.cpp
     MobileGL/MG_State/GLState/ProgramState/ShaderObject.cpp
-    MobileGL/MG_State/GLState/ProgramState/ShaderPreprocessCache.cpp
-    MobileGL/MG_State/GLState/ProgramState/ShaderCompileAdoptionMap.cpp
     MobileGL/MG_State/GLState/ProgramState/ProgramState.cpp
     MobileGL/MG_State/GLState/RenderState/RenderState.cpp
     MobileGL/MG_State/GLState/FramebufferState/FramebufferObject.cpp
@@ -407,22 +297,9 @@ endif()
 if (ANDROID)
     list(APPEND SOURCE_FILES
         MobileGL/MG_Util/SelfTest/DriverPostJni.cpp
-        MobileGL/MG_Util/SelfTest/DriverBenchJni.cpp
     )
 endif()
 
-if (WIN32)
-    list(APPEND SOURCE_FILES
-        MobileGL/MG_Impl/WGLImpl/WGLImpl.cpp
-        MobileGL/MG_Impl/WGLImpl/Exporting/Definitions.cpp
-    )
-endif()
-
-# The shader-compile pool runs standalone Asio on real threads. This host's glibc (>= 2.34)
-# merged pthread into libc, so it links without asking, but the NDK and musl are not
-# guaranteed to be as forgiving - ask for it explicitly rather than rely on the accident.
-find_package(Threads REQUIRED)
-
 set(MOBILEGL_LINK_LIBRARIES
         glslang::glslang
         spirv-cross-c
@@ -432,17 +309,12 @@ set(MOBILEGL_LINK_LIBRARIES
         GPUOpen::VulkanMemoryAllocator
         Vulkan::UtilityHeaders
         spirv-reflect-static
-        Threads::Threads
 )
 
 set(MOBILEGL_COMPILE_DEF
         -DVMA_STATIC_VULKAN_FUNCTIONS=0
         -DVMA_DYNAMIC_VULKAN_FUNCTIONS=1
         -DVMA_VULKAN_VERSION=1001000
-        # Header-only Asio, no Boost, no deprecated interfaces. Set on the definition list
-        # rather than per-target so the shared library and the _s static target agree.
-        -DASIO_STANDALONE
-        -DASIO_NO_DEPRECATED
 )
 
 message(STATUS "MOBILEGL_COMPILE_DEF=${MOBILEGL_COMPILE_DEF}")
@@ -454,24 +326,12 @@ set(MOBILEGL_INCLUDE_DIR
         ${spirv-tools_SOURCE_DIR}/include
         ${spirv-tools_BINARY_DIR}
         ${SPIRV-Headers_SOURCE_DIR}/include
-        # Header-only submodule: no add_subdirectory, no link target. Only
-        # MG_Util/Async/ShaderCompilePool.cpp includes it, and it stays behind that file's
-        # pimpl so no consumer target needs this path.
-        ${CMAKE_SOURCE_DIR}/3rdparty/asio/asio/include
 )
 
-add_library(${CMAKE_PROJECT_NAME} SHARED
+add_library(${CMAKE_PROJECT_NAME} SHARED 
     ${SOURCE_FILES}
 )
 
-if (WIN32)
-    # The wgl* entry points are exported via .def (see the comment in wgl.def);
-    # only the shared library links it.
-    target_sources(${CMAKE_PROJECT_NAME} PRIVATE
-        MobileGL/MG_Impl/WGLImpl/Exporting/wgl.def
-    )
-endif()
-
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
     set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES
         C_VISIBILITY_PRESET default
@@ -514,18 +374,6 @@ if(UNIX AND NOT APPLE AND NOT ANDROID)
     endforeach()
 endif()
 
-if(WIN32)
-    # Drop-in for the classic GL loader path: a copy named opengl32.dll placed
-    # next to a host executable is what LoadLibrary("opengl32.dll") and gdi32's
-    # pixel-format forwarding will resolve.
-    add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                "$<TARGET_FILE:${CMAKE_PROJECT_NAME}>"
-                "$<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>/opengl32.dll"
-        COMMENT "Creating opengl32.dll drop-in copy"
-    )
-endif()
-
 if(NOT ANDROID)
     add_library(${CMAKE_PROJECT_NAME}_s STATIC 
         ${SOURCE_FILES}
@@ -577,21 +425,8 @@ if (ANDROID)
 endif()
 
 if (APPLE AND NOT MOBILEGL_IOS)
-    # MobileGL statically embeds glslang, SPIRV-Tools, and SPIRV-Cross. When
-    # this dylib is injected with DYLD_INSERT_LIBRARIES, exporting those C++
-    # symbols interposes incompatible copies embedded by host libraries such
-    # as shaderc. Keep only the public GL/EGL/CGL loader surface globally
-    # visible; GetProcAddress can still return pointers to hidden internals.
-    set(MOBILEGL_MACOS_EXPORTED_SYMBOLS
-        "${CMAKE_CURRENT_SOURCE_DIR}/MobileGL/MG_Impl/DyldInterpose/ExportedSymbols.txt")
-    target_link_options(${CMAKE_PROJECT_NAME} PRIVATE
-        "LINKER:-exported_symbols_list,${MOBILEGL_MACOS_EXPORTED_SYMBOLS}")
-    set_property(TARGET ${CMAKE_PROJECT_NAME} APPEND PROPERTY
-        LINK_DEPENDS "${MOBILEGL_MACOS_EXPORTED_SYMBOLS}")
-
     target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC
         "-framework Cocoa"
-        "-framework CoreVideo"
         "-framework QuartzCore"
         "-framework Foundation"
         "-framework OpenGL"
@@ -599,7 +434,6 @@ if (APPLE AND NOT MOBILEGL_IOS)
     if(TARGET ${CMAKE_PROJECT_NAME}_s)
         target_link_libraries(${CMAKE_PROJECT_NAME}_s PUBLIC
             "-framework Cocoa"
-            "-framework CoreVideo"
             "-framework QuartzCore"
             "-framework Foundation"
             "-framework OpenGL"
@@ -655,12 +489,6 @@ if (NOT ANDROID)
         add_subdirectory(MobileGL/MG_Test)
     endif()
 
-    # After MG_Test so googletest is already available when the unit tests are
-    # built; the module fetches its own copy when they are not.
-    if (MOBILEGL_BUILD_INTEGRATION_TEST)
-        add_subdirectory(MobileGL/MG_IntegrationTest)
-    endif()
-
     if (MOBILEGL_BUILD_BENCHMARK)
         add_subdirectory(MobileGL/MG_Benchmark)
     endif()

MobileGL/Config.h

@@ -14,48 +14,12 @@ namespace MobileGL::MG_Config {
     inline const String ProjectName = "MobileGL";
     inline const String CoreName = "MobileGL Core";
     inline const String CoreVendor = "MobileGL-Dev (BZLZHH, Swung0x48, Tungsten)";
-    inline const Version CoreVersion = {26, 8, 0, "-dev", VersionType::Development};
+    inline const Version CoreVersion = {26, 7, 0, "-dev", VersionType::Development};
     inline const VersionStringFormatAttrib DefaultVersionStringFormatAttrib = {2, 2, 0, true, true};
     inline const Uint64 CacheVersion = 0;
 
     extern BackendType ActiveBackendType;
 
-    // Tri-state override for device-specific quirks: Auto lets the detected device decide,
-    // ForceOn/ForceOff bypass the detection in either direction. ForceOn only bypasses the
-    // device gate - each quirk keeps its structural safety checks.
-    enum class QuirkOverride : Uint8 {
-        Auto = 0,
-        ForceOn,
-        ForceOff,
-    };
-
-    // Preferred DirectVulkan dispatch tier for the glMultiDraw* families. A preference,
-    // never a demand: the renderer clamps it to what the device supports at device
-    // creation, falling down the chain ext -> indirect -> unroll with one log line.
-    enum class MultiDrawMode : Uint8 {
-        Auto = 0, // unset: best supported tier
-        Ext,      // VK_EXT_multi_draw: one vkCmdDrawMultiEXT / vkCmdDrawMultiIndexedEXT
-        Indirect, // multiDrawIndirect feature: one vkCmdDraw*Indirect over a transient command array
-        Unroll,   // one vkCmdDraw* per sub-draw
-    };
-
-    // Preferred DirectGLES emulation tier for glMultiDrawElements(BaseVertex). GLES has no
-    // such entry point in core, so every tier below is an emulation; they differ only in
-    // which driver capability they lean on and how many driver calls a batch costs. Like
-    // the Magma knob this is a preference, clamped at resolution time to what the ES
-    // driver actually supports, with one log line when it falls back.
-    enum class GLESMultiDrawMode : Uint8 {
-        Auto = 0,      // unset: best supported tier
-        Ext,           // one glMultiDrawElementsBaseVertexEXT
-        MultiIndirect, // one glMultiDrawElementsIndirectEXT over a scratch command buffer
-        Indirect,      // one glDrawElementsIndirect per sub-draw over that same buffer
-        BaseVertex,    // one glDrawElementsBaseVertex per sub-draw
-        DrawElements,  // baseVertex folded into a scratch index buffer on the CPU, then plain
-                       // glDrawElements per sub-draw (for drivers with no base-vertex draw at all)
-        Compute,       // a compute shader flattens every sub-draw into one rebased index buffer,
-                       // drawn by a single glDrawElements
-    };
-
     // Feature toggles parsed once from environment variables in MG_ConfigLoader::Init()
     // (ConfigLoader.cpp), before the accepted-env map is destroyed. All Bool fields share
     // one truthy rule: the variable is set, non-empty, not "0", and not "false"
@@ -66,11 +30,6 @@ namespace MobileGL::MG_Config {
     //   - DISPLAY: X11 session variable, not MobileGL configuration.
     //   - MOBILEGL_LOG_FILE_PATH: log-file init runs before MG_ConfigLoader::Init
     //     (see MG_Util/Debug/Log.cpp).
-    //   - MOBILEGL_VALIDATE_SPIRV: test suites like SpirvPassTest exercise
-    //     ShaderCompiler without ever running MobileGL::Initialize(), and every
-    //     Initialize() re-runs MG_ConfigLoader::Init, which would clobber a
-    //     programmatic override stored here (see ShaderCompiler.cpp,
-    //     SpirvValidationEnabled).
     struct FeaturesTable {
         // MOBILEGL_DISABLE_TIMERQUERY: do not advertise or use GPU timer queries.
         Bool DisableTimerQuery = false;
@@ -82,14 +41,6 @@ namespace MobileGL::MG_Config {
 #endif
         // MOBILEGL_DISABLE_SUBGROUP: force-disable Vulkan shader subgroup support.
         Bool DisableSubgroup = false;
-        // 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_MAGMA_R11G11B10F_FALLBACK: use fallback format for R11G11B10F on Vulkan.
         Bool MagmaR11G11B10FFallback = false;
         // MOBILEGL_MAGMA_FRAMESINFLIGHT: requested Magma frames in flight, defaulting to 3.
@@ -97,13 +48,6 @@ namespace MobileGL::MG_Config {
         // MOBILEGL_AVOID_SAMPLER_MIPMAP_MIN_FILTER: avoid mipmap min filters in samplers,
         // resolves certain rendering bugs on ANGLE + llvmpipe.
         Bool AvoidSamplerMipmapMinFilter = false;
-        // MOBILEGL_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 AvoidExplicitLodBias = 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
@@ -117,65 +61,12 @@ namespace MobileGL::MG_Config {
         // per-draw glBufferSubData path instead of the persistent-mapped ring allocator
         // (negative control / driver-bug escape hatch).
         Bool DisableUboRing = 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;
         // 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
-        // cross-pipeline vertex position invariance. Sorted-transparency "over" blends,
-        // gl_FragDepth writers, and fully color-masked attachments are exempt (see
-        // PipelineFactory::ShouldSuppressDepthWrite). Auto detects Qualcomm.
-        QuirkOverride MagmaDisableBlendedDepthWriteQuirk = QuirkOverride::Auto;
-        // MOBILEGL_DISABLE_ROBUST_BUFFER_ACCESS: leave the Vulkan robustBufferAccess device
-        // feature off. It is enabled by default to match GL's defined out-of-range fetch
-        // behavior; this escape hatch exists to measure or dodge its GPU cost on a device.
-        Bool DisableRobustBufferAccess = false;
-        // MOBILEGL_MAGMA_MULTIDRAW_MODE: preferred DirectVulkan multi-draw dispatch tier
-        // ("ext" | "indirect" | "unroll", see MultiDrawMode). Clamped to device support;
-        // unset picks the best supported tier.
-        MultiDrawMode MagmaMultiDrawMode = MultiDrawMode::Auto;
-        // MOBILEGL_ESPRYT_MULTIDRAW_MODE: preferred DirectGLES glMultiDrawElements emulation
-        // tier ("ext" | "multiindirect" | "indirect" | "basevertex" | "drawelements" |
-        // "compute", see GLESMultiDrawMode). Clamped to driver support; unset picks the best
-        // supported tier, which never includes "compute" - see the note on its resolution.
-        GLESMultiDrawMode EsprytMultiDrawMode = GLESMultiDrawMode::Auto;
-        // MOBILEGL_ASYNC_SHADER_COMPILE: overrides asynchronous shader compilation. Unset
-        // keeps the built-in default (MG_Util::Async::kAsyncShaderCompileDefault); falsy
-        // forces every glCompileShader/glLinkProgram to run synchronously on the calling
-        // thread AND withdraws GL_KHR_parallel_shader_compile, so the single switch reverts
-        // both the threading and the application-visible behaviour change.
-        QuirkOverride AsyncShaderCompile = QuirkOverride::Auto;
-        // MOBILEGL_ASYNC_SHADER_COMPILE_THREADS: shader-compile worker count. 0 (unset) means
-        // auto, which is min(4, big cores); an explicit value is honoured as given.
-        Uint32 AsyncShaderCompileThreads = 0;
-        // 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;
     };
     extern FeaturesTable Features;
 } // namespace MobileGL::MG_Config

MobileGL/ConfigLoader.cpp

@@ -86,58 +86,6 @@ namespace MobileGL::MG_ConfigLoader {
         return it != acceptedEnvVariablesMap->end() && IsTruthyValue(it->second);
     }
 
-    // Quirk overrides are tri-state: an unset variable keeps device auto-detection, a truthy
-    // value forces the quirk on, anything else set ("0", "false", "") forces it off.
-    inline MG_Config::QuirkOverride QueryEnvQuirkOverride(const String& key) {
-        auto it = acceptedEnvVariablesMap->find(key);
-        if (it == acceptedEnvVariablesMap->end()) {
-            return MG_Config::QuirkOverride::Auto;
-        }
-        return IsTruthyValue(it->second) ? MG_Config::QuirkOverride::ForceOn
-                                         : MG_Config::QuirkOverride::ForceOff;
-    }
-
-    // Multi-draw mode is a named-value preference: unset keeps Auto (best supported tier),
-    // a recognized name selects that tier as the ceiling, anything else warns and keeps Auto.
-    inline MG_Config::MultiDrawMode QueryEnvMultiDrawMode(const String& key) {
-        auto it = acceptedEnvVariablesMap->find(key);
-        if (it == acceptedEnvVariablesMap->end()) {
-            return MG_Config::MultiDrawMode::Auto;
-        }
-        String lowered = it->second;
-        std::transform(lowered.begin(), lowered.end(), lowered.begin(),
-                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-        if (lowered == "ext") return MG_Config::MultiDrawMode::Ext;
-        if (lowered == "indirect") return MG_Config::MultiDrawMode::Indirect;
-        if (lowered == "unroll") return MG_Config::MultiDrawMode::Unroll;
-        if (lowered.empty() || lowered == "auto") return MG_Config::MultiDrawMode::Auto;
-        MGLOG_W("Config: Ignoring invalid env variable %s='%s'; expected ext|indirect|unroll|auto, using auto",
-                key.c_str(), it->second.c_str());
-        return MG_Config::MultiDrawMode::Auto;
-    }
-
-    // Same contract as QueryEnvMultiDrawMode, over the DirectGLES tier names.
-    inline MG_Config::GLESMultiDrawMode QueryEnvGLESMultiDrawMode(const String& key) {
-        auto it = acceptedEnvVariablesMap->find(key);
-        if (it == acceptedEnvVariablesMap->end()) {
-            return MG_Config::GLESMultiDrawMode::Auto;
-        }
-        String lowered = it->second;
-        std::transform(lowered.begin(), lowered.end(), lowered.begin(),
-                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-        if (lowered == "ext") return MG_Config::GLESMultiDrawMode::Ext;
-        if (lowered == "multiindirect") return MG_Config::GLESMultiDrawMode::MultiIndirect;
-        if (lowered == "indirect") return MG_Config::GLESMultiDrawMode::Indirect;
-        if (lowered == "basevertex") return MG_Config::GLESMultiDrawMode::BaseVertex;
-        if (lowered == "drawelements") return MG_Config::GLESMultiDrawMode::DrawElements;
-        if (lowered == "compute") return MG_Config::GLESMultiDrawMode::Compute;
-        if (lowered.empty() || lowered == "auto") return MG_Config::GLESMultiDrawMode::Auto;
-        MGLOG_W("Config: Ignoring invalid env variable %s='%s'; expected "
-                "ext|multiindirect|indirect|basevertex|drawelements|compute|auto, using auto",
-                key.c_str(), it->second.c_str());
-        return MG_Config::GLESMultiDrawMode::Auto;
-    }
-
     inline Uint32 QueryEnvUint32(const String& key, Uint32 defaultValue, Uint32 minValue, Uint32 maxValue) {
         auto it = acceptedEnvVariablesMap->find(key);
         if (it == acceptedEnvVariablesMap->end()) {
@@ -167,28 +115,14 @@ namespace MobileGL::MG_ConfigLoader {
         QueryEnvVariable("MOBILEGL_TRACE_ANGLE_VARIANT", features.TraceAngleVariant, "");
 #endif
         features.DisableSubgroup = QueryEnvFlag("MOBILEGL_DISABLE_SUBGROUP");
-        features.AdvertiseFp64 = QueryEnvFlag("MOBILEGL_ADVERTISE_FP64");
         features.MagmaR11G11B10FFallback = QueryEnvFlag("MOBILEGL_MAGMA_R11G11B10F_FALLBACK");
         features.MagmaFramesInFlight = QueryEnvUint32("MOBILEGL_MAGMA_FRAMESINFLIGHT", 3, 1, 64);
         features.AvoidSamplerMipmapMinFilter =
             QueryEnvFlag("MOBILEGL_AVOID_SAMPLER_MIPMAP_MIN_FILTER");
-        features.AvoidExplicitLodBias = QueryEnvFlag("MOBILEGL_AVOID_EXPLICIT_LOD_BIAS");
         features.CoherentAsFlush = QueryEnvFlag("MOBILEGL_COHERENT_AS_FLUSH");
         features.TraceSkipAutodestroy = QueryEnvFlag("MOBILEGL_TRACE_SKIP_AUTODESTROY");
         features.DisableUboRing = QueryEnvFlag("MOBILEGL_DISABLE_UBO_RING");
-        features.EsprytForceDepthStencilReadbackEmulation =
-            QueryEnvFlag("MOBILEGL_ESPRYT_FORCE_DS_READBACK_EMULATION");
         features.RelaxedSemantics = QueryEnvFlag("MOBILEGL_RELAXED_SEMANTICS");
-        features.SubgroupPrefixScanQuirk = QueryEnvQuirkOverride("MOBILEGL_QUIRK_SUBGROUP_PREFIX_SCAN");
-        features.MagmaDisableBlendedDepthWriteQuirk =
-            QueryEnvQuirkOverride("MOBILEGL_MAGMA_DISABLE_BLENDED_DEPTH_WRITE");
-        features.DisableRobustBufferAccess = QueryEnvFlag("MOBILEGL_DISABLE_ROBUST_BUFFER_ACCESS");
-        features.MagmaMultiDrawMode = QueryEnvMultiDrawMode("MOBILEGL_MAGMA_MULTIDRAW_MODE");
-        features.EsprytMultiDrawMode = QueryEnvGLESMultiDrawMode("MOBILEGL_ESPRYT_MULTIDRAW_MODE");
-        features.AsyncShaderCompile = QueryEnvQuirkOverride("MOBILEGL_ASYNC_SHADER_COMPILE");
-        features.AsyncShaderCompileThreads = QueryEnvUint32("MOBILEGL_ASYNC_SHADER_COMPILE_THREADS", 0, 0, 64);
-        features.AsyncOptimisticShaderStatus =
-            QueryEnvQuirkOverride("MOBILEGL_ASYNC_OPTIMISTIC_SHADER_STATUS");
     }
 
     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
@@ -44,26 +34,8 @@
 #define MOBILEGL_EGL_API MOBILEGL_API
 #define MOBILEGL_CGL_API MOBILEGL_API
 #define MOBILEGL_NSOPENGL_API MOBILEGL_API
-#define MOBILEGL_WGL_API MOBILEGL_API
 
 // ====================== MobileGL configurations ======================= //
-// 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 +67,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/GlobalObjects.cpp

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

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

@@ -9,27 +9,14 @@
 #include "Init.h"
 #include "Config.h"
 #include <MG_Backend/BackendObjects.h>
-#include <MG_Backend/DirectVulkan/DirectVulkan.h>
 #include <MG_State/GLState/Core.h>
 #include <MG_State/EGLState/Core.h>
 #include <MG_Impl/GLImpl/Texture/ProxyTexture.h>
 #include <MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h>
-#include <MG_Impl/GLImpl/Sync/GL_Sync.h>
-#include <MG_Util/Async/ShaderCompilePool.h>
-#include <MG_Util/ShaderTranspiler/ShaderCompiler.h>
-
-#include <atomic>
-#include <mutex>
 
 namespace MobileGL {
     namespace {
-        std::atomic<Bool> g_isInitialized = false;
-        thread_local Bool tl_initializing = false;
-
-        std::mutex& InitMutex() {
-            static std::mutex mutex;
-            return mutex;
-        }
+        Bool g_isInitialized = false;
 
         void DestroyImpl(Bool logLifecycle) {
             if (!g_isInitialized) {
@@ -39,33 +26,12 @@ namespace MobileGL {
             if (logLifecycle) {
                 MGLOG_I("MobileGL closing...");
             }
-            // First, before anything else is torn down. In-flight compile/link jobs own
-            // their own inputs and are safe against everything below EXCEPT glslang's
-            // process globals and the TShader/TProgram objects hanging off pGLContext,
-            // both of which this function is about to destroy. This is the one
-            // cancellation path in the whole design that waits.
-            MG_Util::Async::ShaderCompilePool::Get().StopAndDrain();
-            // GL syncs die with their contexts, and every context is gone by the
-            // time full teardown runs: drain the live-sync registry while the
-            // backend function table can still release the backend handles (and
-            // before a re-initialized library could pair them with the wrong
-            // backend's DeleteSync).
-            MG_Impl::GLImpl::DestroyAllSyncObjects();
+            glslang::FinalizeProcess();
             MG_Backend::pActiveBackendObject.reset();
             MG_State::pGLContext.reset();
             MG_State::pEGLContext.reset();
             MG_Impl::GLImpl::TextureImpl::pProxyTextureManager.reset();
             MG_Impl::GLImpl::FramebufferImpl::pDefaultFramebufferInfo.reset();
-            // Must run AFTER pGLContext.reset(). FinalizeProcess -> ShFinalize deletes
-            // glslang's process-wide pool allocator and every cached built-in symbol table,
-            // while the TShader/TProgram objects owned by the shader and program objects
-            // still reference levels adopted from those tables. Finalizing first left live
-            // glslang objects pointing at freed memory for the rest of the teardown.
-            glslang::FinalizeProcess();
-            // Immediately after, and never apart from it: FinalizeProcess just deleted the
-            // built-in symbol tables the prewarm latch stands for, so leaving it set would
-            // make the next Initialize() skip a prewarm it genuinely needs.
-            MG_Util::ShaderTranspiler::ShaderCompiler::ResetPrewarmLatch();
             MG_Backend::gBackendFunctionsTable = {};
             g_isInitialized = false;
             if (logLifecycle) {
@@ -93,55 +59,45 @@ namespace MobileGL {
         MG_Impl::Init();
         MGLOG_D("MG_Impl initialized");
         glslang::InitializeProcess();
-        // On the GL thread, before any worker can exist. glslang builds its built-in symbol
-        // tables lazily under a process-wide lock held for the whole build, so without this
-        // the first concurrent compiles of a shaderpack all serialize behind the very first
-        // parse and asynchronous compilation looks like it is doing nothing.
-        //
-        // Gated on the flag, because the problem it solves only exists when there are
-        // workers: with compilation synchronous, nothing ever contends for that lock and the
-        // three throwaway parses buy nothing - they just add to every eglInitialize. Read the
-        // flag here rather than inside PrewarmBuiltins so ShaderCompiler keeps no dependency
-        // on the async subsystem (ProgramUtilTest compiles that file without it).
-        if (MG_Util::Async::AsyncShaderCompileEnabled()) {
-            MG_Util::ShaderTranspiler::ShaderCompiler::PrewarmBuiltins();
-        }
         MGLOG_D("glslang initialized");
         g_isInitialized = true;
         MGLOG_I("MobileGL initialized");
     }
 
-    void EnsureInitialized() {
-        if (g_isInitialized.load(std::memory_order_acquire)) {
-            return;
-        }
-        // Re-entrant call while this thread is already inside Initialize()
-        // (e.g. an init step routing back through a public entry point).
-        if (tl_initializing) {
-            return;
-        }
-        const std::lock_guard<std::mutex> lock(InitMutex());
-        if (g_isInitialized.load(std::memory_order_acquire)) {
-            return;
-        }
-        tl_initializing = true;
-        Initialize();
-        tl_initializing = false;
-    }
-
     void Destroy() {
         DestroyImpl(true);
     }
 
-    // MobileGL's lifecycle is owned entirely by the host-API layers
-    // (EGL/WGL/CGL): initialization happens lazily on the first entry point
-    // via EnsureInitialized(), and full teardown happens deterministically
-    // when the last EGL display is terminated with nothing current (EGLImpl
-    // calls Destroy()). There is intentionally no backend-initializing static
-    // constructor, no static destructor, and no DllMain: the global singletons
-    // use leak-at-exit storage (see GlobalObjects.cpp), so a process that exits
-    // without eglTerminate simply leaks them to the OS instead of running
-    // backend destructors during static teardown. macOS has a lightweight
-    // dyld constructor that installs NSOpenGL dispatch hooks only; full backend
-    // initialization still enters here from the first hooked CGL context.
+#if defined(__linux__) || defined(__APPLE__)
+    __attribute__((constructor)) static void AutoInit() {
+        Initialize();
+    }
+
+    __attribute__((destructor)) static void AutoDestroy() {
+        if (MG_Config::Features.TraceSkipAutodestroy) {
+            return;
+        }
+#if defined(__APPLE__)
+        // macOS injected dylibs can run destructors after logging/backend static state is already torn down.
+        return;
+#else
+        DestroyImpl(false);
+#endif
+    }
+#endif
+
+#ifdef _WIN32
+    BOOL WINAPI DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
+        switch (ul_reason_for_call) {
+        case DLL_PROCESS_ATTACH:
+            Initialize();
+            break;
+
+        case DLL_PROCESS_DETACH:
+            Destroy();
+            break;
+        }
+        return TRUE;
+    }
+#endif
 } // namespace MobileGL

MobileGL/Init.h

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

MobileGL/MG_Backend/BackendObject.h

@@ -145,10 +145,6 @@ namespace MobileGL {
                                             GLenum buffer, GLint drawbuffer, const GLfloat* value);
             void (*ClearNamedFramebufferfi)(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
                                             GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-            void (*ClearNamedFramebufferiv)(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                            GLenum buffer, GLint drawbuffer, const GLint* value);
-            void (*ClearNamedFramebufferuiv)(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                             GLenum buffer, GLint drawbuffer, const GLuint* value);
             void (*BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0,
                                     GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
             void (*BlitNamedFramebuffer)(const SharedPtr<MG_State::GLState::FramebufferObject>& readFramebuffer,
@@ -181,18 +177,15 @@ namespace MobileGL {
             void (*GetIntegeri_v)(GLenum target, GLuint index, GLint* data);
             void (*GetInteger64i_v)(GLenum target, GLuint index, GLint64* data);
             void (*GetProgramiv)(GLuint program, GLenum pname, GLint* params);
-            // The GL program interface (glGetProgramInterfaceiv / glGetProgramResource*) is NOT
-            // a backend query: it describes the program the application wrote, in the
-            // application's namespace, which neither backend program is in. It is answered
-            // entirely by MG_Impl/GLImpl/Program/ProgramInterface from the frontend reflection.
-            // Takes the block's GL NAME, not glShaderStorageBlockBinding's index. The index
-            // the application passes is the frontend interface-query enumeration's, and no
-            // backend shares that index space: DirectVulkan enumerates SPIR-V descriptor
-            // bindings and DirectGLES asks a real driver about SPIRV-Cross-generated ESSL.
-            // The name is the one coordinate all three agree on, so the frontend resolves the
-            // index against its own enumeration and each backend maps the name to its own.
-            void (*ShaderStorageBlockBinding)(GLuint program, const GLchar* storageBlockName,
-                                              GLuint storageBlockBinding);
+            void (*GetProgramInterfaceiv)(GLuint program, GLenum programInterface, GLenum pname, GLint* params);
+            GLuint (*GetProgramResourceIndex)(GLuint program, GLenum programInterface, const GLchar* name);
+            void (*GetProgramResourceName)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize,
+                                           GLsizei* length, GLchar* name);
+            void (*GetProgramResourceiv)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount,
+                                         const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params);
+            GLint (*GetProgramResourceLocation)(GLuint program, GLenum programInterface, const GLchar* name);
+            GLint (*GetProgramResourceLocationIndex)(GLuint program, GLenum programInterface, const GLchar* name);
+            void (*ShaderStorageBlockBinding)(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
             // GL fence sync objects. All entries are optional (may be null); the
             // frontend then falls back to always-signaled sync semantics.
             // FenceSync may itself return null when the backend cannot create a
@@ -227,31 +220,6 @@ namespace MobileGL {
             // and leave the query readable later.
             Bool (*GetQueryResult64)(BackendQueryHandle query, Bool wait, Uint64* outNanoseconds);
             void (*DeleteBackendQuery)(BackendQueryHandle query);
-            // GL_SAMPLES_PASSED occlusion queries (optional; null = unsupported,
-            // the frontend then rejects the target). Results/deletion flow through
-            // GetQueryResult64 / DeleteBackendQuery like timer queries.
-            BackendQueryHandle (*BeginOcclusionQuery)();
-            void (*EndOcclusionQuery)(BackendQueryHandle query);
-            // Transform feedback primitive queries backed by real GPU query pools
-            // (optional; null = frontend falls back to CPU accounting).
-            BackendQueryHandle (*BeginXfbPrimitivesQuery)(Bool generated);
-            void (*EndXfbPrimitivesQuery)(BackendQueryHandle query);
-            // 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
-            // called while the frontend capture state is still active, so the backend
-            // can still see the capture program and buffer bindings.
-            // GL_PATCH_VERTICES; ES 3.2 spells it the same way.
-            void (*PatchParameteri)(GLenum pname, GLint value);
-            void (*BeginTransformFeedback)(GLenum primitiveMode);
-            void (*EndTransformFeedback)();
-            // ARB_transform_feedback2. A backend that leaves these null keeps the single
-            // implicit capture span the frontend has always modelled; the frontend state
-            // (paused flag, per-object bindings) is tracked either way.
-            void (*PauseTransformFeedback)();
-            void (*ResumeTransformFeedback)();
-            void (*BindTransformFeedback)(GLuint name);
-            void (*DeleteTransformFeedback)(GLuint name);
             Int64 (*GetGpuTimestampNs)(); // glGetInteger64v(GL_TIMESTAMP); 0 if unsupported
         };
         struct GlobalBackendFunctionsTable {
@@ -262,21 +230,6 @@ namespace MobileGL {
             void (*SetSwapInterval)(Int interval);
         };
 
-        // Coarse GPU vendor identity for gating device-specific quirks. Detected from the
-        // Vulkan physical-device vendorID or the GLES GL_VENDOR/GL_RENDERER strings; stays
-        // Unknown when detection is inconclusive, in which case auto-gated quirks stay off.
-        enum class GpuVendorKind : Uint8 {
-            Unknown = 0,
-            Qualcomm,
-            Arm,
-            Nvidia,
-            Amd,
-            Intel,
-            ImgTec,
-            // Software rasterizers (llvmpipe/lavapipe, SwiftShader).
-            Software,
-        };
-
         struct DynamicBackendParameters {
             SizeT UniformBufferOffsetAlignment = 256;
             // GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT. 1.0 means the backend cannot filter anisotropically,
@@ -304,13 +257,6 @@ namespace MobileGL {
             Int MaxIntegerSamples = 1;
             Int MaxSamples = 1;
             Int MaxSampleMaskWords = 1;
-            // Tessellation limits; defaults are the GL 4.0 core minimums.
-            Int MaxPatchVertices = 32;
-            Int MaxTessGenLevel = 64;
-            // GL_MIN/MAX_PROGRAM_TEXTURE_GATHER_OFFSET. Defaults are the GL 4.0 core
-            // minimums, which every ES 3.1 driver also guarantees.
-            Int MinProgramTextureGatherOffset = -8;
-            Int MaxProgramTextureGatherOffset = 7;
             Int MaxTextureImageUnits = 32;
             Int MaxVertexTextureImageUnits = 32;
             Int MaxComputeTextureImageUnits = 32;
@@ -322,8 +268,6 @@ namespace MobileGL {
             Int MaxComputeWorkGroupInvocations = 128;
             Int MaxShaderStorageBufferBindings = 8;
             Int MaxTextureBufferSize = 65536;
-            // GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT; 1 means the offset is unconstrained.
-            Int TextureBufferOffsetAlignment = 1;
             Int MaxUniformBufferBindings = 24;
             Int MaxUniformBlockSize = 16384;
             Int MaxImageUnits = 8;
@@ -341,69 +285,19 @@ namespace MobileGL {
             Float ViewportBoundsRangeMin = 0.0f;
             Float ViewportBoundsRangeMax = 0.0f;
             Int ViewportSubpixelBits = 0;
-            // GL 4.x fragment-interpolation offset limits. These defaults are the
-            // core minimums and are replaced by live GLES/Vulkan device limits.
-            Float MinFragmentInterpolationOffset = -0.5f;
-            // For four fractional bits the greatest required legal offset is
-            // 0.5 - 2^-4 = 0.4375 (GL 4.6 table 23.70).
-            Float MaxFragmentInterpolationOffset = 0.4375f;
-            Int FragmentInterpolationOffsetBits = 4;
             Bool SupportsWideLines = false;
-            // Whether a framebuffer whose depth and stencil attachments are distinct
-            // images can be rendered to. GL only requires support when both refer to the
-            // same image and lets an implementation answer GL_FRAMEBUFFER_UNSUPPORTED
-            // otherwise, which is what DirectVulkan (one combined attachment) and the
-            // real ES drivers behind DirectGLES both do. Defaults to true so a backend
-            // that never sets it keeps the permissive behaviour.
-            Bool SupportsDistinctDepthStencilAttachments = true;
-            // Whether attaching a single layer of a 3D or array texture to a framebuffer actually
-            // renders to that layer. DirectGLES hands the layer straight to
-            // glFramebufferTextureLayer, so it does; DirectVulkan maps a GL layer onto a Vulkan
-            // array layer with no notion of a 3D depth slice, so it does not yet. Defaults to false
-            // so a backend that never sets it gets the conservative answer.
-            // Which layered texture targets this backend can attach ONE layer of to a framebuffer
-            // and then really clear, render and read back that layer. Bit (1u << TextureTarget) is
-            // set for each supported target. Deliberately per target rather than one flag: the three
-            // ways a GL layer maps onto Vulkan are independent capabilities. A 2D or 2D multisample
-            // array layer IS a VkImage array layer and needs nothing extra; a 3D texture's layer is
-            // a z slice, which needs a 2D-array-compatible image and a per-slice clear that
-            // vkCmdClearColorImage cannot express; a cube map array needs an image shape and the
-            // imageCubeArray feature before it can be attached at any layer at all. Defaults to 0 so
-            // a backend that never sets it gets the conservative answer.
-            Uint32 PerLayerFramebufferAttachmentTargets = 0;
-
-            static constexpr Uint32 PerLayerFramebufferAttachmentBit(TextureTarget target) {
-                return (static_cast<Int>(target) >= 0 &&
-                        static_cast<Int>(target) < static_cast<Int>(TextureTarget::TextureTargetCount))
-                           ? (1u << static_cast<Uint32>(target))
-                           : 0u;
-            }
-
-            Bool SupportsPerLayerFramebufferAttachment(TextureTarget target) const {
-                const Uint32 bit = PerLayerFramebufferAttachmentBit(target);
-                return bit != 0 && (PerLayerFramebufferAttachmentTargets & bit) != 0;
-            }
-            // Whether glVertexAttribLFormat / glVertexArrayAttribLFormat can be honoured, i.e.
-            // whether a 64-bit vertex attribute can actually reach a shader unconverted. Detected,
-            // never assumed: DirectVulkan needs VkPhysicalDeviceFeatures::shaderFloat64 (the
-            // attribute travels as its 32-bit word pair, so no VK_FORMAT_R64* is required, but the
-            // bitcast result is Float64); DirectGLES can never have it, ESSL having no fp64 type at
-            // all. Defaults to false so a backend that never sets it gets the conservative answer.
-            Bool SupportsFloat64VertexAttributes = false;
             SizeT MaxShaderStorageBlockSize = 128 * 1024 * 1024;
             Uint32 SubgroupSize = 0;
             Uint32 SubgroupSupportedStages = 0;
             Uint32 SubgroupSupportedFeatures = 0;
             Bool SubgroupQuadOperationsInAllStages = false;
-            GpuVendorKind GpuVendor = GpuVendorKind::Unknown;
         };
 
         enum class WindowBackend {
             Android,
             X11,
             MetalLayer,
-            Win32, // Handle is an HWND
-            // TODO: Wayland, etc.
+            // TODO: Wayland, Windows, etc.
             WindowBackendCount,
             Unknown = -1
         };

MobileGL/MG_Backend/BackendObjects.h

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

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp

@@ -18,10 +18,8 @@
 #include <MG_Util/Converters/MGToGL/TextureEnumConverter.h>
 #include <MG_Util/Converters/MGToStr/TextureEnumConverter.h>
 #include <MG_Util/Texture/TextureFormatProcessor.h>
-#include <MG_Util/Async/ShaderCompilePool.h>
 #include <Config.h>
 #include <algorithm>
-#include <cmath>
 #include <format>
 
 namespace MobileGL::MG_Backend::DirectGLES {
@@ -33,7 +31,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
         void ClearGLErrors(const MG_External::GLESFunctionsTable& gl) {
             if (!gl.glGetError) return;
-            while (gl.glGetError() != GL_NO_ERROR) {}
+            while (gl.glGetError() != GL_NO_ERROR) {
+            }
         }
 
         Bool CheckNoGLError(const MG_External::GLESFunctionsTable& gl) {
@@ -77,7 +76,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
         }
 
         Bool IsGLESProbeMultisampleTarget(TextureTarget target) {
-            return target == TextureTarget::Texture2DMultisample || target == TextureTarget::Texture2DMultisampleArray;
+            return target == TextureTarget::Texture2DMultisample ||
+                   target == TextureTarget::Texture2DMultisampleArray;
         }
 
         GLenum GetFramebufferAttachment(TextureInternalFormat format) {
@@ -114,8 +114,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
             GLenum normalizedInternalFormat = glFormat;
             GLenum imageFormat = GL_RGBA;
             GLenum imageType = GL_UNSIGNED_BYTE;
-            MG_Util::TextureFormatProcessor::NormalizePixelFormat(glFormat, PixelFormatNormalizeOptionBit::None,
-                                                                  &normalizedInternalFormat, &imageFormat, &imageType);
+            MG_Util::TextureFormatProcessor::NormalizePixelFormat(
+                glFormat, PixelFormatNormalizeOptionBit::None, &normalizedInternalFormat, &imageFormat, &imageType);
             return imageFormat != GL_RED_INTEGER && imageFormat != GL_RG_INTEGER && imageFormat != GL_RGB_INTEGER &&
                    imageFormat != GL_RGBA_INTEGER && !MG_Util::IsDepthFormatInternalFormat(format) &&
                    !MG_Util::IsStencilFormatInternalFormat(format);
@@ -153,9 +153,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
         GLESProbeFormatInfo BuildNativeProbeFormatInfo(GLenum requestedInternalFormat) {
             GLESProbeFormatInfo info;
             info.InternalFormat = requestedInternalFormat;
-            MG_Util::TextureFormatProcessor::NormalizePixelFormat(requestedInternalFormat,
-                                                                  PixelFormatNormalizeOptionBit::None, nullptr,
-                                                                  &info.ImageFormat, &info.ImageType);
+            MG_Util::TextureFormatProcessor::NormalizePixelFormat(
+                requestedInternalFormat, PixelFormatNormalizeOptionBit::None, nullptr, &info.ImageFormat,
+                &info.ImageType);
             return info;
         }
 
@@ -209,12 +209,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             if (options & PixelFormatNormalizeOptionBit::NoDepthComponent32) {
                 reasons.push_back("GL_DEPTH_COMPONENT32 native probe failed on OpenGL ES");
             }
-            if (options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget) {
-                reasons.push_back("no colour-renderable three-channel format on OpenGL ES");
-            }
-            if (options & PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget) {
-                reasons.push_back("EXT_render_snorm not supported");
-            }
 
             String reason;
             for (SizeT i = 0; i < reasons.size(); ++i) {
@@ -232,16 +226,20 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return MG_Util::ConvertGLEnumToString(internalFormat);
         }
 
-        void LogGLESFormatCaveat(TextureInternalFormat logicalFormat, SizeT targetIndex,
+        void LogGLESFormatCaveat(TextureInternalFormat logicalFormat,
+                                 SizeT targetIndex,
                                  const GLESProbeFormatInfo& fallbackInfo) {
             MGLOG_D("Caveat: %s %s not fully supported. Reason: %s. Fallback: %s",
                     GetFormatCapabilityTargetName(targetIndex).c_str(),
-                    MG_Util::ConvertTextureInternalFormatToString(logicalFormat).c_str(), fallbackInfo.Reason.c_str(),
+                    MG_Util::ConvertTextureInternalFormatToString(logicalFormat).c_str(),
+                    fallbackInfo.Reason.c_str(),
                     ConvertFallbackInternalFormatToString(fallbackInfo.InternalFormat).c_str());
         }
 
-        Bool BuildFallbackProbeFormatInfo(GLenum requestedInternalFormat, Flags<PixelFormatNormalizeOptionBit> options,
-                                          Bool forced, GLESProbeFormatInfo& outInfo) {
+        Bool BuildFallbackProbeFormatInfo(GLenum requestedInternalFormat,
+                                          Flags<PixelFormatNormalizeOptionBit> options,
+                                          Bool forced,
+                                          GLESProbeFormatInfo& outInfo) {
             const Flags<PixelFormatNormalizeOptionBit> applicableOptions =
                 MG_Util::TextureFormatProcessor::GetApplicablePixelFormatNormalizeOptions(requestedInternalFormat,
                                                                                           options);
@@ -256,7 +254,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return outInfo.InternalFormat != GL_UNKNOWN_MGL;
         }
 
-        FormatCapabilityFlags BuildTextureCapsFromProbe(TextureInternalFormat logicalFormat, TextureTarget target,
+        FormatCapabilityFlags BuildTextureCapsFromProbe(TextureInternalFormat logicalFormat,
+                                                        TextureTarget target,
                                                         Bool renderable) {
             FormatCapabilityFlags caps = GetTextureFeatureCaps(logicalFormat, target);
             if (renderable) {
@@ -270,12 +269,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return caps;
         }
 
-        void AddFullFormatCaps(FormatCapabilityCache& cache, SizeT targetIndex, SizeT formatIndex,
+        void AddFullFormatCaps(FormatCapabilityCache& cache,
+                               SizeT targetIndex,
+                               SizeT formatIndex,
                                FormatCapabilityFlags caps) {
             cache.FullCaps[targetIndex][formatIndex] |= caps;
         }
 
-        Bool AddCaveatFormatCaps(FormatCapabilityCache& cache, SizeT targetIndex, SizeT formatIndex,
+        Bool AddCaveatFormatCaps(FormatCapabilityCache& cache,
+                                 SizeT targetIndex,
+                                 SizeT formatIndex,
                                  FormatCapabilityFlags caps) {
             Bool added = false;
             for (FormatCapability capability : kReportedFormatCapabilities) {
@@ -289,7 +292,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
         }
 
         Int GetGLESFormatMaxSamples(const MG_External::GLESCapabilities& capabilities,
-                                    TextureInternalFormat logicalFormat, GLenum imageFormat) {
+                                    TextureInternalFormat logicalFormat,
+                                    GLenum imageFormat) {
             const Bool isDepth = MG_Util::IsDepthFormatInternalFormat(logicalFormat);
             const Bool isStencil = MG_Util::IsStencilFormatInternalFormat(logicalFormat);
             const Bool isInteger = imageFormat == GL_RED_INTEGER || imageFormat == GL_RG_INTEGER ||
@@ -303,8 +307,10 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return capabilities.MaxColorTextureSamples;
         }
 
-        Bool ProbeFramebufferCompletenessForTexture(const MG_External::GLESFunctionsTable& gl, TextureTarget target,
-                                                    GLuint texture, TextureInternalFormat format) {
+        Bool ProbeFramebufferCompletenessForTexture(const MG_External::GLESFunctionsTable& gl,
+                                                   TextureTarget target,
+                                                   GLuint texture,
+                                                   TextureInternalFormat format) {
             GLuint framebuffer = 0;
             GLint prevFramebuffer = 0;
             if (!gl.glGenFramebuffers || !gl.glBindFramebuffer || !gl.glCheckFramebufferStatus ||
@@ -350,44 +356,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return complete;
         }
 
-        // Whether the driver renders to a framebuffer whose depth and stencil come from
-        // two different renderbuffers. GL only requires support when both attachments are
-        // the same image, and ES drivers commonly answer GL_FRAMEBUFFER_UNSUPPORTED here;
-        // reporting COMPLETE from the frontend and then rendering into a framebuffer the
-        // driver refuses leaves the results silently empty.
-        Bool ProbeDistinctDepthStencilAttachments(const MG_External::GLESFunctionsTable& gl) {
-            if (!gl.glGenFramebuffers || !gl.glBindFramebuffer || !gl.glFramebufferRenderbuffer ||
-                !gl.glCheckFramebufferStatus || !gl.glDeleteFramebuffers || !gl.glGenRenderbuffers ||
-                !gl.glBindRenderbuffer || !gl.glRenderbufferStorage || !gl.glDeleteRenderbuffers) {
-                return true;
-            }
-
-            GLint prevFramebuffer = 0, prevRenderbuffer = 0;
-            gl.glGetIntegerv(GL_FRAMEBUFFER_BINDING, &prevFramebuffer);
-            gl.glGetIntegerv(GL_RENDERBUFFER_BINDING, &prevRenderbuffer);
-
-            GLuint framebuffer = 0;
-            GLuint renderbuffers[2] = {0, 0};
-            gl.glGenFramebuffers(1, &framebuffer);
-            gl.glGenRenderbuffers(2, renderbuffers);
-            gl.glBindRenderbuffer(GL_RENDERBUFFER, renderbuffers[0]);
-            gl.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, 4, 4);
-            gl.glBindRenderbuffer(GL_RENDERBUFFER, renderbuffers[1]);
-            gl.glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, 4, 4);
-            gl.glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
-            gl.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, renderbuffers[0]);
-            gl.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, renderbuffers[1]);
-            const Bool supported = gl.glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE;
-
-            gl.glBindFramebuffer(GL_FRAMEBUFFER, static_cast<GLuint>(prevFramebuffer));
-            gl.glBindRenderbuffer(GL_RENDERBUFFER, static_cast<GLuint>(prevRenderbuffer));
-            gl.glDeleteFramebuffers(1, &framebuffer);
-            gl.glDeleteRenderbuffers(2, renderbuffers);
-            return supported;
-        }
-
-        Bool ProbeFramebufferCompletenessForRenderbuffer(const MG_External::GLESFunctionsTable& gl, GLuint renderbuffer,
-                                                         TextureInternalFormat format) {
+        Bool ProbeFramebufferCompletenessForRenderbuffer(const MG_External::GLESFunctionsTable& gl,
+                                                        GLuint renderbuffer,
+                                                        TextureInternalFormat format) {
             GLuint framebuffer = 0;
             GLint prevFramebuffer = 0;
             if (!gl.glGenFramebuffers || !gl.glBindFramebuffer || !gl.glFramebufferRenderbuffer ||
@@ -454,16 +425,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     }
                     break;
                 case TextureTarget::Texture3D:
-                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 2, 0, imageFormat, imageType,
-                                    nullptr);
+                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 2, 0, imageFormat,
+                                    imageType, nullptr);
                     break;
                 case TextureTarget::Texture2DArray:
-                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 1, 0, imageFormat, imageType,
-                                    nullptr);
+                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 1, 0, imageFormat,
+                                    imageType, nullptr);
                     break;
                 case TextureTarget::TextureCubeMapArray:
-                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 6, 0, imageFormat, imageType,
-                                    nullptr);
+                    gl.glTexImage3D(glTarget, 0, static_cast<GLint>(internalFormat), 2, 2, 6, 0, imageFormat,
+                                    imageType, nullptr);
                     break;
                 default:
                     break;
@@ -484,8 +455,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return created;
         }
 
-        Bool ProbeRenderbuffer(const MG_External::GLESFunctionsTable& gl, GLenum internalFormat,
-                               TextureInternalFormat logicalFormat, Bool multisample, Int samples) {
+        Bool ProbeRenderbuffer(const MG_External::GLESFunctionsTable& gl,
+                               GLenum internalFormat,
+                               TextureInternalFormat logicalFormat,
+                               Bool multisample,
+                               Int samples) {
             if (!gl.glGenRenderbuffers || !gl.glBindRenderbuffer || !gl.glDeleteRenderbuffers) {
                 return false;
             }
@@ -507,16 +481,17 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 gl.glRenderbufferStorage(GL_RENDERBUFFER, internalFormat, 1, 1);
             }
             const Bool created = CheckNoGLError(gl);
-            const Bool complete =
-                created && ProbeFramebufferCompletenessForRenderbuffer(gl, renderbuffer, logicalFormat);
+            const Bool complete = created && ProbeFramebufferCompletenessForRenderbuffer(gl, renderbuffer, logicalFormat);
             gl.glBindRenderbuffer(GL_RENDERBUFFER, static_cast<GLuint>(prevRenderbuffer));
             gl.glDeleteRenderbuffers(1, &renderbuffer);
             ClearGLErrors(gl);
             return complete;
         }
 
-        Vector<Int> ProbeRenderbufferSampleCounts(const MG_External::GLESFunctionsTable& gl, GLenum internalFormat,
-                                                  TextureInternalFormat logicalFormat, Int maxSamples) {
+        Vector<Int> ProbeRenderbufferSampleCounts(const MG_External::GLESFunctionsTable& gl,
+                                                  GLenum internalFormat,
+                                                  TextureInternalFormat logicalFormat,
+                                                  Int maxSamples) {
             Vector<Int> sampleCounts;
             for (Int samples = std::max(maxSamples, 1); samples > 1; samples >>= 1) {
                 if (ProbeRenderbuffer(gl, internalFormat, logicalFormat, true, samples)) {
@@ -544,84 +519,20 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
 
                 const GLESProbeFormatInfo nativeInfo = BuildNativeProbeFormatInfo(requestedInternalFormat);
-                GLESProbeFormatInfo outerFallbackInfo;
-                const Bool outerHasForcedFallback =
-                    BuildFallbackProbeFormatInfo(requestedInternalFormat, forcedOptions, true, outerFallbackInfo);
-                if (!outerHasForcedFallback) {
-                    BuildFallbackProbeFormatInfo(requestedInternalFormat, driverOptions, false, outerFallbackInfo);
+                GLESProbeFormatInfo fallbackInfo;
+                const Bool hasForcedFallback =
+                    BuildFallbackProbeFormatInfo(requestedInternalFormat, forcedOptions, true, fallbackInfo);
+                if (!hasForcedFallback) {
+                    BuildFallbackProbeFormatInfo(requestedInternalFormat, driverOptions, false, fallbackInfo);
                 }
 
                 for (SizeT targetIndex = 0; targetIndex < kFormatCapabilityTextureTargetCount; ++targetIndex) {
                     const auto target = static_cast<TextureTarget>(targetIndex);
-                    // Colour-attachable targets need a colour-renderable fallback; the ordinary
-                    // fallback for a three-channel format is another three-channel one, which ES
-                    // accepts as a texture but never as an attachment. Recompute the fallback per
-                    // target so those formats get widened where the target demands it.
-                    const Flags<PixelFormatNormalizeOptionBit> renderTargetOptions =
-                        TextureImpl::GetRenderTargetNormalizeOptions(capabilities, targetIndex);
-                    // Multisample storage has no three-channel form on ES at all, so its widening
-                    // is unconditional and skips the native probe (which cannot succeed). Every
-                    // other target keeps the widening on the DRIVER branch, behind the native
-                    // probe: `shouldProbeFallback = !nativeCreated || !nativeRenderable` below is
-                    // what makes the substitution conditional on the driver actually refusing, so
-                    // a driver that does render to a three-channel image keeps allocating it byte
-                    // for byte. That is a per-format runtime answer, NOT a desktop-vs-device
-                    // split: llvmpipe renders to GL_RGB16F but refuses GL_RGB8_SNORM, GL_SRGB8,
-                    // GL_RGB32F and the RGB integer formats, so the CI driver widens those eight
-                    // too. Re-run the retrace fixtures and the glcts suites on any change here.
-                    const Bool widenUnconditionally = IsGLESProbeMultisampleTarget(target);
-                    GLESProbeFormatInfo fallbackInfo = outerFallbackInfo;
-                    Bool hasForcedFallback = outerHasForcedFallback;
-                    if (renderTargetOptions) {
-                        // Folded into the forced options only when a forced fallback already
-                        // applies, so the render-target bits never *create* one: ANGLE's forced
-                        // GL_RGB8_SNORM -> GL_RGB16F is still three-channel and still needs
-                        // widening, but a non-ANGLE driver must not lose its native probe.
-                        const Flags<PixelFormatNormalizeOptionBit> forcedProbeOptions =
-                            (outerHasForcedFallback || widenUnconditionally) ? forcedOptions | renderTargetOptions
-                                                                             : forcedOptions;
-                        hasForcedFallback =
-                            BuildFallbackProbeFormatInfo(requestedInternalFormat, forcedProbeOptions, true,
-                                                         fallbackInfo);
-                        if (!hasForcedFallback) {
-                            BuildFallbackProbeFormatInfo(requestedInternalFormat,
-                                                         driverOptions | renderTargetOptions, false, fallbackInfo);
-                        }
-                        // HONEST STATUS OF THE FORCED PATH. A forced fallback is only ever built
-                        // for ANGLE (GetForcedPixelFormatNormalizeOptions returns nothing for any
-                        // other renderer), and it SKIPS the native probe entirely - the widened
-                        // format is asserted rather than measured on this device. That assertion
-                        // is validated on exactly one configuration, the android-angle retrace
-                        // golden; it is NOT covered by the headless llvmpipe suites, which take
-                        // the driver branch below and prove nothing about ANGLE's answers. So log
-                        // the choice at INFO rather than the usual MGLOG_D caveat: on any other
-                        // ANGLE device the device report is the only evidence there is of which
-                        // storage format the image really got. Once per format on the ordinary 2D
-                        // target - repeating it for all ten targets would bury the report.
-                        if (hasForcedFallback && target == TextureTarget::Texture2D &&
-                            (MG_Util::TextureFormatProcessor::GetApplicablePixelFormatNormalizeOptions(
-                                 requestedInternalFormat, renderTargetOptions) &
-                             PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget)) {
-                            MGLOG_I("Three-channel widening (FORCED path, no native probe): %s stored as %s. "
-                                    "Reason: %s. Device-validated on the android-angle golden only.",
-                                    MG_Util::ConvertTextureInternalFormatToString(logicalFormat).c_str(),
-                                    ConvertFallbackInternalFormatToString(fallbackInfo.InternalFormat).c_str(),
-                                    fallbackInfo.Reason.c_str());
-                        }
-                    }
-
-                    // 1D, 1D-array and rectangle textures live on an ES target (see
-                    // TextureImpl::MapToBackendTextureTarget), so they have to be probed there too -
-                    // probing the desktop-only target itself always failed, which left those slots
-                    // of the cache empty and stopped any fallback format from being selected for
-                    // them (a GL_DEPTH_COMPONENT32 1D texture then got no storage at all).
-                    const TextureTarget probeTarget = TextureImpl::MapToBackendTextureTarget(target);
-
                     Bool shouldProbeFallback = hasForcedFallback;
                     if (!hasForcedFallback) {
                         Bool nativeRenderable = false;
                         const Bool nativeCreated =
-                            ProbeTexture(gl, probeTarget, nativeInfo.InternalFormat, nativeInfo.ImageFormat,
+                            ProbeTexture(gl, target, nativeInfo.InternalFormat, nativeInfo.ImageFormat,
                                          nativeInfo.ImageType, logicalFormat, &nativeRenderable);
                         if (nativeCreated) {
                             AddFullFormatCaps(cache, targetIndex, formatIndex,
@@ -636,12 +547,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     if (shouldProbeFallback && fallbackInfo.InternalFormat != GL_UNKNOWN_MGL) {
                         Bool fallbackRenderable = false;
                         const Bool fallbackCreated =
-                            ProbeTexture(gl, probeTarget, fallbackInfo.InternalFormat, fallbackInfo.ImageFormat,
+                            ProbeTexture(gl, target, fallbackInfo.InternalFormat, fallbackInfo.ImageFormat,
                                          fallbackInfo.ImageType, logicalFormat, &fallbackRenderable);
                         if (fallbackCreated) {
-                            if (AddCaveatFormatCaps(
-                                    cache, targetIndex, formatIndex,
-                                    BuildTextureCapsFromProbe(logicalFormat, target, fallbackRenderable))) {
+                            if (AddCaveatFormatCaps(cache, targetIndex, formatIndex,
+                                                    BuildTextureCapsFromProbe(logicalFormat, target,
+                                                                              fallbackRenderable))) {
                                 LogGLESFormatCaveat(logicalFormat, targetIndex, fallbackInfo);
                             }
                             if (IsGLESProbeMultisampleTarget(target)) {
@@ -652,26 +563,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 }
 
                 const SizeT renderbufferTargetIndex = GetRenderbufferFormatCapabilityTargetIndex();
-                // A renderbuffer exists only to be attached, so it needs the same three-channel
-                // widening the colour-attachable texture targets get - and on the same terms: the
-                // native storage is probed first, so a driver that renders to it keeps it.
-                const Flags<PixelFormatNormalizeOptionBit> renderbufferOptions =
-                    TextureImpl::GetRenderTargetNormalizeOptions(capabilities, renderbufferTargetIndex);
-                GLESProbeFormatInfo renderbufferFallbackInfo = outerFallbackInfo;
-                Bool renderbufferHasForcedFallback = outerHasForcedFallback;
-                if (renderbufferOptions) {
-                    const Flags<PixelFormatNormalizeOptionBit> forcedProbeOptions =
-                        outerHasForcedFallback ? forcedOptions | renderbufferOptions : forcedOptions;
-                    renderbufferHasForcedFallback = BuildFallbackProbeFormatInfo(
-                        requestedInternalFormat, forcedProbeOptions, true, renderbufferFallbackInfo);
-                    if (!renderbufferHasForcedFallback) {
-                        BuildFallbackProbeFormatInfo(requestedInternalFormat, driverOptions | renderbufferOptions,
-                                                     false, renderbufferFallbackInfo);
-                    }
-                }
-
-                Bool shouldProbeFallbackRenderbuffer = renderbufferHasForcedFallback;
-                if (!renderbufferHasForcedFallback) {
+                Bool shouldProbeFallbackRenderbuffer = hasForcedFallback;
+                if (!hasForcedFallback) {
                     const Bool nativeRenderbufferComplete =
                         ProbeRenderbuffer(gl, nativeInfo.InternalFormat, logicalFormat, false, 1);
                     if (nativeRenderbufferComplete) {
@@ -685,16 +578,16 @@ namespace MobileGL::MG_Backend::DirectGLES {
                         shouldProbeFallbackRenderbuffer = true;
                     }
                 }
-                if (shouldProbeFallbackRenderbuffer && renderbufferFallbackInfo.InternalFormat != GL_UNKNOWN_MGL &&
-                    ProbeRenderbuffer(gl, renderbufferFallbackInfo.InternalFormat, logicalFormat, false, 1)) {
+                if (shouldProbeFallbackRenderbuffer && fallbackInfo.InternalFormat != GL_UNKNOWN_MGL &&
+                    ProbeRenderbuffer(gl, fallbackInfo.InternalFormat, logicalFormat, false, 1)) {
                     if (AddCaveatFormatCaps(cache, renderbufferTargetIndex, formatIndex,
                                             GetRenderbufferFeatureCaps(logicalFormat))) {
-                        LogGLESFormatCaveat(logicalFormat, renderbufferTargetIndex, renderbufferFallbackInfo);
+                        LogGLESFormatCaveat(logicalFormat, renderbufferTargetIndex, fallbackInfo);
                     }
                     const Int maxSamples =
-                        GetGLESFormatMaxSamples(capabilities, logicalFormat, renderbufferFallbackInfo.ImageFormat);
-                    cache.SampleCounts[renderbufferTargetIndex][formatIndex] = ProbeRenderbufferSampleCounts(
-                        gl, renderbufferFallbackInfo.InternalFormat, logicalFormat, maxSamples);
+                        GetGLESFormatMaxSamples(capabilities, logicalFormat, fallbackInfo.ImageFormat);
+                    cache.SampleCounts[renderbufferTargetIndex][formatIndex] =
+                        ProbeRenderbufferSampleCounts(gl, fallbackInfo.InternalFormat, logicalFormat, maxSamples);
                 }
             }
         }
@@ -710,7 +603,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 .ExtraVendor = Nullopt,              // Extra vendor
                 .RendererGLInfo =
                     {
-                        .TargetGLVersion = {4, 0, 0},   // GL target version
+                        .TargetGLVersion = {3, 3, 0},   // Target OpenGL Version
                         .TargetGLSLVersion = {4, 6, 0}, // Target Shading Language Version
                         // Baseline advertisement (no timer queries / anisotropy yet); reconciled
                         // once the ES capabilities exist, see UpdateAdvertisedCapabilityExtensions.
@@ -741,7 +634,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
     } // namespace
 
     void PopulateFormatCapabilities(const MG_External::GLESFunctionsTable& gl,
-                                    const MG_External::GLESCapabilities& capabilities, FormatCapabilityCache& cache) {
+                                    const MG_External::GLESCapabilities& capabilities,
+                                    FormatCapabilityCache& cache) {
         PopulateFormatCapabilitiesImpl(gl, capabilities, cache);
     }
 
@@ -805,10 +699,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return false;
         }
 
-        if ((handle.Backend != WindowBackend::Android && handle.Backend != WindowBackend::X11 &&
-             handle.Backend != WindowBackend::MetalLayer && handle.Backend != WindowBackend::Win32) ||
+        if ((handle.Backend != WindowBackend::Android &&
+             handle.Backend != WindowBackend::X11 &&
+             handle.Backend != WindowBackend::MetalLayer) ||
             !handle.Handle) {
-            MGLOG_E("DirectGLES backend only supports Android, X11, CAMetalLayer, and Win32 native windows");
+            MGLOG_E("DirectGLES backend only supports Android, X11, and CAMetalLayer native windows");
             return false;
         }
 
@@ -925,61 +820,17 @@ namespace MobileGL::MG_Backend::DirectGLES {
     }
 
     Vector<GLExtension> BuildAdvertisedExtensions(Bool timerQueriesSupported, Bool anisotropicFilteringSupported) {
-        Vector<GLExtension> extensions = {
-            V_OpenGL30, V_OpenGL31, V_OpenGL32, V_OpenGL33, V_OpenGL40, E_GL_ARB_draw_buffers_blend,
-            E_GL_ARB_compute_shader, E_GL_ARB_shader_storage_buffer_object, E_GL_ARB_shader_image_load_store,
-            E_GL_ARB_program_interface_query, E_GL_ARB_framebuffer_object, E_GL_EXT_framebuffer_object,
-            E_GL_ARB_depth_texture, E_GL_ARB_buffer_storage, E_GL_ARB_texture_storage,
-            E_GL_ARB_texture_storage_multisample, E_GL_ARB_clear_texture, E_GL_ARB_direct_state_access,
-            E_GL_ARB_multi_draw_indirect, E_GL_ARB_indirect_parameters, E_GL_ARB_shader_draw_parameters,
-            E_GL_ARB_gpu_shader5, E_GL_ARB_multi_bind, E_GL_ARB_shading_language_420pack,
-            E_GL_ARB_vertex_attrib_binding,
-            // Both are core from GL 3.2/3.3 on and implemented here for
-            // every advertised version, but an app targeting 3.0/3.1
-            // only reaches them through the extension string - the CTS
-            // picks a whole different shader for draw_buffers without
-            // explicit_attrib_location. DirectVulkan advertises both.
-            E_GL_ARB_explicit_attrib_location, E_GL_ARB_texture_multisample, E_GL_ARB_shader_image_size,
-            // 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,
-            // Advertised with GL_NUM_PROGRAM_BINARY_FORMATS = 0, which the
-            // extension explicitly permits. It is also the only thing that
-            // exposes glProgramParameteri before GL 4.1.
-            E_GL_ARB_get_program_binary};
-        // GL_KHR_parallel_shader_compile is MobileGL's own capability, not the host ES
-        // driver's: the compiler threads are MobileGL's, and glCompileShader/glLinkProgram
-        // are serviced entirely inside the frontend. Whether the device driver advertises
-        // the string is irrelevant here (the POST reports it separately, for the day the
-        // driver-side link is what gets parallelised).
-        //
-        // Gated on the async flag deliberately, and this is the whole reason the gate
-        // exists. Advertising the string is the one part of asynchronous compilation that a
-        // recorded trace can never cover: Iris and Sodium change their SUBMISSION SCHEDULE
-        // the moment they see it - they enqueue whole pipeline batches and poll
-        // GL_COMPLETION_STATUS_KHR instead of compiling one program at a time - so
-        // MOBILEGL_ASYNC_SHADER_COMPILE=0 has to withdraw the application-visible behaviour
-        // change as well as the threading, or the kill switch would only be half a switch.
-        if (MG_Util::Async::AsyncShaderCompileEnabled()) {
-            extensions.push_back(E_GL_KHR_parallel_shader_compile);
-        }
-        // 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);
-        }
+        Vector<GLExtension> extensions = {V_OpenGL30, V_OpenGL31, V_OpenGL32,
+                                          V_OpenGL33, E_GL_ARB_draw_buffers_blend, E_GL_ARB_compute_shader,
+                                          E_GL_ARB_shader_storage_buffer_object, E_GL_ARB_shader_image_load_store,
+                                          E_GL_ARB_program_interface_query, E_GL_ARB_framebuffer_object,
+                                          E_GL_EXT_framebuffer_object, E_GL_ARB_depth_texture, E_GL_ARB_buffer_storage,
+                                          E_GL_ARB_texture_storage, E_GL_ARB_texture_storage_multisample,
+                                          E_GL_ARB_direct_state_access,
+                                          E_GL_ARB_multi_draw_indirect, E_GL_ARB_indirect_parameters,
+                                          E_GL_ARB_shader_draw_parameters, E_GL_ARB_gpu_shader5, E_GL_ARB_multi_bind,
+                                          E_GL_ARB_shading_language_420pack, E_GL_ARB_vertex_attrib_binding,
+                                          E_GL_ARB_shader_image_size};
         // 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.
@@ -1022,7 +873,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;
@@ -1041,6 +891,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
             funcsTable.GL.GetIntegeri_v = GetIntegeri_v;
             funcsTable.GL.GetInteger64i_v = GetInteger64i_v;
             funcsTable.GL.GetProgramiv = GetProgramiv;
+            funcsTable.GL.GetProgramInterfaceiv = GetProgramInterfaceiv;
+            funcsTable.GL.GetProgramResourceIndex = GetProgramResourceIndex;
+            funcsTable.GL.GetProgramResourceName = GetProgramResourceName;
+            funcsTable.GL.GetProgramResourceiv = GetProgramResourceiv;
+            funcsTable.GL.GetProgramResourceLocation = GetProgramResourceLocation;
+            funcsTable.GL.GetProgramResourceLocationIndex = GetProgramResourceLocationIndex;
             funcsTable.GL.ShaderStorageBlockBinding = ShaderStorageBlockBinding;
             funcsTable.GL.Clear = Clear;
             funcsTable.GL.ClearBufferfi = ClearBufferfi;
@@ -1048,8 +904,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
             funcsTable.GL.ClearBufferuiv = ClearBufferuiv;
             funcsTable.GL.ClearBufferiv = ClearBufferiv;
             funcsTable.GL.ClearNamedFramebufferfv = ClearNamedFramebufferfv;
-            funcsTable.GL.ClearNamedFramebufferiv = ClearNamedFramebufferiv;
-            funcsTable.GL.ClearNamedFramebufferuiv = ClearNamedFramebufferuiv;
             funcsTable.GL.ClearNamedFramebufferfi = ClearNamedFramebufferfi;
             funcsTable.GL.BlitFramebuffer = BlitFramebuffer;
             funcsTable.GL.BlitNamedFramebuffer = BlitNamedFramebuffer;
@@ -1079,30 +933,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
                 funcsTable.GL.BeginTimeElapsedQuery = BeginTimeElapsedQuery;
                 funcsTable.GL.EndTimeElapsedQuery = EndTimeElapsedQuery;
                 funcsTable.GL.QueryCounterTimestamp = QueryCounterTimestamp;
+                funcsTable.GL.IsQueryResultAvailable = IsQueryResultAvailable;
+                funcsTable.GL.GetQueryResult64 = GetQueryResult64;
+                funcsTable.GL.DeleteBackendQuery = DeleteBackendQuery;
                 funcsTable.GL.GetGpuTimestampNs = GetGpuTimestampNs;
             }
-            // Occlusion queries are core ES3 (independent of MOBILEGL_DISABLE_TIMERQUERY)
-            // and share the handle-based result/delete entries, which must exist even
-            // when the timer-query group above is disabled.
-            funcsTable.GL.BeginOcclusionQuery = BeginOcclusionQuery;
-            funcsTable.GL.EndOcclusionQuery = EndOcclusionQuery;
-            // Real driver primitive counters: the frontend's CPU accounting cannot see a
-            // geometry shader's amplification.
-            funcsTable.GL.BeginXfbPrimitivesQuery = BeginXfbPrimitivesQuery;
-            funcsTable.GL.EndXfbPrimitivesQuery = EndXfbPrimitivesQuery;
-            funcsTable.GL.IsQueryResultAvailable = IsQueryResultAvailable;
-            funcsTable.GL.GetQueryResult64 = GetQueryResult64;
-            funcsTable.GL.DeleteBackendQuery = DeleteBackendQuery;
-            // Transform feedback is captured by the real ES driver rather than
-            // reconstructed from the draw recording, so the frontend has to hand the
-            // span boundaries over.
-            funcsTable.GL.PatchParameteri = DirectGLES::PatchParameteri;
-            funcsTable.GL.BeginTransformFeedback = XfbImpl::BeginTransformFeedback;
-            funcsTable.GL.EndTransformFeedback = XfbImpl::EndTransformFeedback;
-            funcsTable.GL.PauseTransformFeedback = XfbImpl::PauseTransformFeedback;
-            funcsTable.GL.ResumeTransformFeedback = XfbImpl::ResumeTransformFeedback;
-            funcsTable.GL.BindTransformFeedback = XfbImpl::BindTransformFeedback;
-            funcsTable.GL.DeleteTransformFeedback = XfbImpl::DeleteTransformFeedback;
             funcsTableInitialized = true;
         }
         return funcsTable;
@@ -1112,7 +947,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
         return m_dynamicParameters;
     }
 
-    void BackendObject_DirectGLES::ApplyGLESCapabilitiesForTesting(const MG_External::GLESCapabilities& capabilities) {
+    void BackendObject_DirectGLES::ApplyGLESCapabilitiesForTesting(
+        const MG_External::GLESCapabilities& capabilities) {
         m_GLESCapabilities = capabilities;
         UpdateDynamicBackendParameters();
     }
@@ -1142,10 +978,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         m_dynamicParameters.MaxIntegerSamples = m_GLESCapabilities.MaxIntegerSamples;
         m_dynamicParameters.MaxSamples = m_GLESCapabilities.MaxSamples;
         m_dynamicParameters.MaxSampleMaskWords = m_GLESCapabilities.MaxSampleMaskWords;
-        m_dynamicParameters.MaxPatchVertices = m_GLESCapabilities.MaxPatchVertices;
-        m_dynamicParameters.MaxTessGenLevel = m_GLESCapabilities.MaxTessGenLevel;
-        m_dynamicParameters.MinProgramTextureGatherOffset = m_GLESCapabilities.MinProgramTextureGatherOffset;
-        m_dynamicParameters.MaxProgramTextureGatherOffset = m_GLESCapabilities.MaxProgramTextureGatherOffset;
         // Clamp the advertised sampler limits the same way the DirectVulkan backend does: per-stage
         // GL_MAX_TEXTURE_IMAGE_UNITS must never exceed host-side fixed arrays sized off it (e.g.
         // Minecraft's 128-entry Blaze3D GlStateManager.TEXTURES[], iterated by Iris), and the combined
@@ -1172,21 +1004,11 @@ namespace MobileGL::MG_Backend::DirectGLES {
         m_dynamicParameters.MaxComputeUniformBlocks = m_GLESCapabilities.MaxComputeUniformBlocks;
         m_dynamicParameters.MaxComputeWorkGroupInvocations = m_GLESCapabilities.MaxComputeWorkGroupInvocations;
         m_dynamicParameters.MaxShaderStorageBufferBindings = m_GLESCapabilities.MaxShaderStorageBufferBindings;
-        // 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.MaxTextureBufferSize = m_GLESCapabilities.MaxTextureBufferSize;
-        m_dynamicParameters.TextureBufferOffsetAlignment = m_GLESCapabilities.TextureBufferOffsetAlignment;
         m_dynamicParameters.MaxUniformBufferBindings = m_GLESCapabilities.MaxUniformBufferBindings;
         m_dynamicParameters.MaxUniformBlockSize = m_GLESCapabilities.MaxUniformBlockSize;
-        const Int maxSupportedTextureUnits = static_cast<Int>(MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS);
+        const Int maxSupportedTextureUnits =
+            static_cast<Int>(MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS);
         m_dynamicParameters.MaxImageUnits =
             std::max(std::min(m_GLESCapabilities.MaxImageUnits, maxSupportedTextureUnits), 0);
         m_dynamicParameters.MaxCombinedImageUniforms = std::max(m_GLESCapabilities.MaxCombinedImageUniforms, 0);
@@ -1194,40 +1016,14 @@ namespace MobileGL::MG_Backend::DirectGLES {
             return std::min({std::max(stageLimit, 0), m_dynamicParameters.MaxImageUnits,
                              m_dynamicParameters.MaxCombinedImageUniforms});
         };
-        m_dynamicParameters.MaxVertexImageUniforms = clampStageImageUniforms(m_GLESCapabilities.MaxVertexImageUniforms);
+        m_dynamicParameters.MaxVertexImageUniforms =
+            clampStageImageUniforms(m_GLESCapabilities.MaxVertexImageUniforms);
         m_dynamicParameters.MaxGeometryImageUniforms =
             clampStageImageUniforms(m_GLESCapabilities.MaxGeometryImageUniforms);
         m_dynamicParameters.MaxFragmentImageUniforms =
             clampStageImageUniforms(m_GLESCapabilities.MaxFragmentImageUniforms);
         m_dynamicParameters.MaxComputeImageUniforms =
             clampStageImageUniforms(m_GLESCapabilities.MaxComputeImageUniforms);
-        m_dynamicParameters.SupportsDistinctDepthStencilAttachments =
-            ProbeDistinctDepthStencilAttachments(DirectGLES::g_GLESFuncs);
-        // SyncAttachmentObject routes a layered upload target to glFramebufferTextureLayer with the
-        // attachment's layer passed through, so this backend really does render to the layer it was
-        // given - provided the driver resolved the entry point at all.
-        // SyncAttachmentObject (Managers.cpp, the glFramebufferTextureLayer branch) routes exactly
-        // five upload targets to glFramebufferTextureLayer with the attachment's layer passed
-        // through, so this backend really does render to the layer it was given - provided the driver
-        // resolved the entry point at all. The cube map array is the one target that also needs
-        // ES-level support before it has any storage to attach.
-        m_dynamicParameters.PerLayerFramebufferAttachmentTargets = 0;
-        if (DirectGLES::g_GLESFuncs.glFramebufferTextureLayer != nullptr) {
-            using DynParams = MG_Backend::DynamicBackendParameters;
-            m_dynamicParameters.PerLayerFramebufferAttachmentTargets |=
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture3D) |
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture1DArray) |
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture2DArray) |
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture2DMultisampleArray);
-            if (m_GLESCapabilities.SupportsTextureCubeMapArray) {
-                m_dynamicParameters.PerLayerFramebufferAttachmentTargets |=
-                    DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::TextureCubeMapArray);
-            }
-        }
-        // Not a driver question and never will be: OpenGL ES has no double-precision vertex format
-        // and ESSL has no fp64 type to consume one with, so a 64-bit vertex attribute has nowhere to
-        // land on this backend regardless of what the driver underneath happens to support.
-        m_dynamicParameters.SupportsFloat64VertexAttributes = false;
         m_dynamicParameters.MaxDrawBuffers = m_GLESCapabilities.MaxDrawBuffers;
         m_dynamicParameters.MaxColorAttachments = m_GLESCapabilities.MaxColorAttachments;
         m_dynamicParameters.MaxClipDistances = m_GLESCapabilities.MaxClipDistances;
@@ -1237,50 +1033,8 @@ namespace MobileGL::MG_Backend::DirectGLES {
         m_dynamicParameters.ViewportBoundsRangeMin = m_GLESCapabilities.ViewportBoundsRangeMin;
         m_dynamicParameters.ViewportBoundsRangeMax = m_GLESCapabilities.ViewportBoundsRangeMax;
         m_dynamicParameters.ViewportSubpixelBits = m_GLESCapabilities.ViewportSubpixelBits;
-        m_dynamicParameters.MinFragmentInterpolationOffset =
-            std::isfinite(m_GLESCapabilities.MinFragmentInterpolationOffset) &&
-                    m_GLESCapabilities.MinFragmentInterpolationOffset <= -0.5f
-                ? m_GLESCapabilities.MinFragmentInterpolationOffset
-                : -0.5f;
-        m_dynamicParameters.MaxFragmentInterpolationOffset = 0.4375f;
-        m_dynamicParameters.FragmentInterpolationOffsetBits = 4;
-        if (m_GLESCapabilities.FragmentInterpolationOffsetBits >= 4 &&
-            std::isfinite(m_GLESCapabilities.MaxFragmentInterpolationOffset)) {
-            const Float requiredMaxOffset =
-                0.5f - std::ldexp(1.0f, -m_GLESCapabilities.FragmentInterpolationOffsetBits);
-            if (m_GLESCapabilities.MaxFragmentInterpolationOffset >= requiredMaxOffset) {
-                m_dynamicParameters.MaxFragmentInterpolationOffset = m_GLESCapabilities.MaxFragmentInterpolationOffset;
-                m_dynamicParameters.FragmentInterpolationOffsetBits =
-                    m_GLESCapabilities.FragmentInterpolationOffsetBits;
-            }
-        }
         m_dynamicParameters.SupportsWideLines =
             m_GLESCapabilities.AliasedLineWidthRangeMax > 1.0f || m_GLESCapabilities.SmoothLineWidthRangeMax > 1.0f;
-
-        const auto containsAny = [](const String& haystack, std::initializer_list<const char*> needles) {
-            return std::any_of(needles.begin(), needles.end(),
-                               [&](const char* needle) { return haystack.find(needle) != String::npos; });
-        };
-        const String vendorAndRenderer =
-            m_GLESCapabilities.GLESVendorString + " " + m_GLESCapabilities.GLESRendererString;
-        if (containsAny(vendorAndRenderer, {"llvmpipe", "SwiftShader", "softpipe"})) {
-            // Check software rasterizers first: ANGLE-on-llvmpipe reports both.
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Software;
-        } else if (containsAny(vendorAndRenderer, {"Qualcomm", "Adreno"})) {
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Qualcomm;
-        } else if (containsAny(vendorAndRenderer, {"Mali", "ARM"})) {
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Arm;
-        } else if (containsAny(vendorAndRenderer, {"NVIDIA"})) {
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Nvidia;
-        } else if (containsAny(vendorAndRenderer, {"AMD", "Radeon"})) {
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Amd;
-        } else if (containsAny(vendorAndRenderer, {"Intel"})) {
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Intel;
-        } else if (containsAny(vendorAndRenderer, {"Imagination", "PowerVR"})) {
-            m_dynamicParameters.GpuVendor = GpuVendorKind::ImgTec;
-        } else {
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Unknown;
-        }
     }
 
     const MG_External::GLESFunctionsTable& BackendObject_DirectGLES::GetGLESFunctions() const {

MobileGL/MG_Backend/DirectGLES/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);
@@ -61,10 +59,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                  GLenum buffer, GLint drawbuffer, const GLfloat* value);
     void ClearNamedFramebufferfi(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
                                  GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void ClearNamedFramebufferiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                 GLenum buffer, GLint drawbuffer, const GLint* value);
-    void ClearNamedFramebufferuiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                  GLenum buffer, GLint drawbuffer, const GLuint* value);
     void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1,
                          GLint dstY1, GLbitfield mask, GLenum filter);
     void BlitNamedFramebuffer(const SharedPtr<MG_State::GLState::FramebufferObject>& readFramebuffer,
@@ -94,7 +88,15 @@ namespace MobileGL::MG_Backend::DirectGLES {
     void GetIntegeri_v(GLenum target, GLuint index, GLint* data);
     void GetInteger64i_v(GLenum target, GLuint index, GLint64* data);
     void GetProgramiv(GLuint program, GLenum pname, GLint* params);
-    void ShaderStorageBlockBinding(GLuint program, const GLchar* storageBlockName, GLuint storageBlockBinding);
+    void GetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint* params);
+    GLuint GetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar* name);
+    void GetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length,
+                                GLchar* name);
+    void GetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount,
+                              const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params);
+    GLint GetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar* name);
+    GLint GetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar* name);
+    void ShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
     Bool InitWindowSurface(NativeWindowType window);
     Bool InitPbufferSurface(EGLint width, EGLint height);
     Bool MakeCurrent();
@@ -119,24 +121,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
@@ -146,16 +130,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
     BackendQueryHandle BeginTimeElapsedQuery();
     void EndTimeElapsedQuery(BackendQueryHandle query);
     BackendQueryHandle QueryCounterTimestamp();
-    // GL_ANY_SAMPLES_PASSED(_CONSERVATIVE) occlusion queries: core ES3, independent of
-    // GL_EXT_disjoint_timer_query and of MOBILEGL_DISABLE_TIMERQUERY. Results/deletion
-    // flow through GetQueryResult64/DeleteBackendQuery like the timer queries above.
-    BackendQueryHandle BeginOcclusionQuery();
-    void EndOcclusionQuery(BackendQueryHandle query);
-    // GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN / GL_PRIMITIVES_GENERATED, also core ES
-    // (GL_PRIMITIVES_GENERATED from ES 3.2 on). Null when the target is unavailable, in
-    // which case the frontend falls back to counting primitives from the draw calls.
-    BackendQueryHandle BeginXfbPrimitivesQuery(Bool generated);
-    void EndXfbPrimitivesQuery(BackendQueryHandle query);
     Bool IsQueryResultAvailable(BackendQueryHandle query);
     // Returns true when a final value landed in *outNanoseconds (a zero for
     // null or stale-generation handles IS final: the frontend may cache it
@@ -172,11 +146,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
     // A buffer retired during frame N is safe to recycle once CompletedFrameSerial() >= N.
     Uint64 CurrentFrameSerial();
     Uint64 CompletedFrameSerial();
-    // Block (up to timeoutNs) until the given frame serial provably retired on the
-    // GPU, using the per-frame fence ring. False when no usable fence covers the
-    // serial (fence-less context, foreign thread, or the slot was recycled);
-    // completion state is untouched in that case.
-    Bool WaitForFrameSerialCompleted(Uint64 serial, Uint64 timeoutNs);
     // Applies (or defers until the window surface exists) the app-requested
     // eglSwapInterval on the native EGL surface.
     void SetSwapInterval(Int interval);
@@ -185,49 +154,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
     void SetGLESCapabilities(const MG_External::GLESCapabilities& capabilities);
     void DestroyEGLContext();
 
-    // Transform feedback capture spans, performed by the real ES driver. The
-    // capture set is declared on the backend program at link time; the driver-side
-    // begin is deferred to the first draw of the span (ES needs the capturing
-    // program current and the capture buffers bound), and the end also mirrors the
-    // captured bytes back into the frontend buffer shadows.
-    void PatchParameteri(GLenum pname, GLint value);
-
-    namespace XfbImpl {
-        Bool AreTransformFeedbacksSupported();
-        // True while a capture span is open on the current transform feedback object
-        // (frontend Begin seen and not paused), whether or not the deferred driver-side
-        // Begin has been issued yet. Draw paths that would restructure the primitive
-        // stream, or that need to dispatch compute mid-draw, decline while it is set.
-        Bool IsCaptureSpanOpen();
-        void BeginTransformFeedback(GLenum primitiveMode);
-        void EndTransformFeedback();
-        void PauseTransformFeedback();
-        void ResumeTransformFeedback();
-        void BindTransformFeedback(GLuint name);
-        void DeleteTransformFeedback(GLuint name);
-        void OnBackendContextDestroyed();
-    } // namespace XfbImpl
-
-    namespace RenderStateImpl {
-        // Pushes the frontend's render-state block to the ES driver, diffed against what was
-        // last pushed.
-        //
-        // `forColorClear` names the CALLER, and the only thing it changes is the colour write
-        // mask handed to the driver. A draw into a colour attachment the backend widened from
-        // three channels to four gets that buffer's alpha channel masked OFF, so nothing can
-        // move the stored alpha away from the 1.0 the application's three-channel format
-        // implies (see FramebufferImpl::g_alphaWidenedDrawBufferMask). A CLEAR is how that 1.0
-        // gets there in the first place, so it must be allowed to write alpha - hence the flag
-        // rather than an unconditional doctoring. It is part of the sync memo, so a clear
-        // followed by a draw re-pushes the mask instead of early-outing on an unchanged
-        // frontend version.
-        //
-        // The application's own colour mask is never modified: glGet(GL_COLOR_WRITEMASK)
-        // answers from the frontend state, which this function only reads.
-        void SyncRenderState(Bool forColorClear = false);
-        void InvalidateSyncedRenderState();
-    } // namespace RenderStateImpl
-
     extern MG_External::EGLFunctionsTable g_EGLFuncs;
     extern MG_External::GLESFunctionsTable g_GLESFuncs;
     extern MG_External::GLESCapabilities g_GLESCapabilities;

MobileGL/MG_Backend/DirectGLES/MultiDraw.cpp

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

MobileGL/MG_Backend/DirectGLES/MultiDraw.h

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

MobileGL/MG_Backend/DirectGLES/Utils.h

@@ -9,8 +9,6 @@
 #pragma once
 #include <Includes.h>
 #include <MG_State/GLState/Core.h>
-#include <MG_Util/BackendLoaders/OpenGL/Loader.h>
-#include <MG_Util/Texture/TextureFormatProcessor.h>
 
 namespace MobileGL::MG_Backend::DirectGLES {
     namespace DebugImpl {
@@ -36,29 +34,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
     } // namespace VertexArrayImpl
 
     namespace TextureImpl {
-        // Whether images on this format-capability target can back a colour attachment, and so
-        // need a colour-renderable storage format even when the frontend asked for a
-        // three-channel one ES never renders to. Shared by the capability probe (which passes the
-        // capabilities it has just queried, before the globals are published) and by the
-        // allocation path (which reads the active backend's), so the format the cache was probed
-        // with is always the format the image is created with.
-        Bool TargetRequiresRenderableFormat(SizeT targetIndex);
-        Flags<PixelFormatNormalizeOptionBit> GetRenderTargetNormalizeOptions(
-            const MG_External::GLESCapabilities& capabilities, SizeT targetIndex);
-
         void GenerateTextureFormatInfo(TextureInternalFormat internalFormat, GLenum* outInternalFormat,
                                        GLenum* outFormat, GLenum* outType,
                                        TextureTarget target = TextureTarget::Unknown);
         void GenerateRenderbufferFormatInfo(TextureInternalFormat internalFormat, GLenum* outInternalFormat,
                                             GLenum* outFormat, GLenum* outType);
         Bool ShouldUseCaveatTextureFormat(TextureInternalFormat internalFormat, TextureTarget target);
-
-        // True when the format the image is actually created with has an alpha channel the
-        // frontend format does not (the three-channel colour-renderable widening). GL reads such
-        // a channel back as 1.0, so any swizzle source of ALPHA has to be answered with ONE and
-        // any readback of the image has to overwrite the alpha the draw happened to leave there.
-        Bool BackendTextureFormatAddsAlpha(TextureInternalFormat internalFormat, TextureTarget target);
-        Bool BackendRenderbufferFormatAddsAlpha(TextureInternalFormat internalFormat);
         Bool ShouldUseCaveatRenderbufferFormat(TextureInternalFormat internalFormat);
     } // namespace TextureImpl
 
@@ -107,24 +88,6 @@ namespace MobileGL::MG_Backend::DirectGLES {
         // bytes, dst receives width * GetReadbackDstPixelSize(mapping, type) bytes.
         void ConvertWideReadbackRow(const Uint8* src, Uint8* dst, SizeT width, GLenum wideType,
                                     const ReadbackChannelMapping& mapping, GLenum type);
-
-        // Stores wide RGBA(_INTEGER) rows into the client pointer or the bound PACK pixel buffer,
-        // honoring the client-side PACK pixel-store parameters (row length, alignment, skips,
-        // swap-bytes, and - when applyPackImageParams - image height/skip images). Shared by the
-        // DirectGLES and DirectVulkan readback conversion paths.
-        Bool StoreWideRowsToClient(const Uint8* wide, GLenum wideType, GLsizei width, GLsizei sliceHeight,
-                                   GLsizei sliceCount, const ReadbackChannelMapping& mapping, GLenum type,
-                                   void* pixels, Bool applyPackImageParams);
-
-        // 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 {
@@ -133,92 +96,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
         String ClampNormFallbackOutputs(String glslCode, GLenum shaderType, Uint32 snormOutputMask,
                                         Uint32 unormOutputMask);
         String ForceFlatIntegerVaryings(const String& glslCode, GLenum shaderType);
-        // Legacy GLSL's gl_FragColor is broadcast to every enabled draw buffer (GL 4.6
-        // 15.2.3), but ShaderSourceProcessor lowers it to the single output mg_FragColor,
-        // which only ever reaches draw buffer 0. Replicates it across `drawBufferCount`
-        // outputs and copies the value into them at the end of main. A no-op for
-        // 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);
-        // 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 writeonly half a read+write image uniform is split into (see
-        // SplitReadWriteImageUniforms); the suffix is the image's own name.
-        constexpr const char* IMAGE_WRITE_ALIAS_PREFIX = "mg_imageWrite_";
-        // 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:
-        //  * loaded only            -> add `readonly`
-        //  * stored only            -> add `writeonly`
-        //  * both                   -> emit TWO declarations on the same binding and of the
-        //                              same type, `readonly <name>` and `writeonly
-        //                              <IMAGE_WRITE_ALIAS_PREFIX><name>`, and point every
-        //                              imageStore at the second one. 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.
-        //
-        // 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.
-        String SplitReadWriteImageUniforms(const String& glslCode);
-        // 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_";
-        // ES has no per-texture/sampler LOD bias at all (GL_TEXTURE_LOD_BIAS is desktop
-        // only; Vulkan spells it VkSamplerCreateInfo::mipLodBias), so it has to reach the
-        // shader as a uniform and be folded into every lookup's level of detail. Declares
-        // one `uniform highp float mg_lodBias_<sampler>;` per mip-capable sampler and adds
-        // it to the bias / explicit-LOD argument of every lookup that takes one. Draws push
-        // 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_AVOID_EXPLICIT_LOD_BIAS).
-        String EmulateTextureLodBias(const String& glslCode, Bool avoidExplicitLodBias = false);
     } // namespace PrgramImpl
 
     namespace Utils {

MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.cpp

@@ -16,10 +16,8 @@
 #include "MG_Util/Converters/MGToStr/TextureEnumConverter.h"
 #include "MG_Util/Converters/MGToVk/TextureEnumConverter.h"
 #include "MG_Util/Texture/TextureFormatProcessor.h"
-#include "MG_Util/Async/ShaderCompilePool.h"
 
 #include <Config.h>
-#include <cmath>
 #include <cstdlib>
 #include <cstring>
 
@@ -42,11 +40,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Bool IsLayeredTarget(TextureTarget target) {
             return target == TextureTarget::Texture3D || target == TextureTarget::Texture1DArray ||
                    target == TextureTarget::Texture2DArray || target == TextureTarget::TextureCubeMap ||
-                   target == TextureTarget::TextureCubeMapArray || target == TextureTarget::Texture2DMultisampleArray;
+                   target == TextureTarget::TextureCubeMapArray ||
+                   target == TextureTarget::Texture2DMultisampleArray;
         }
 
         Bool IsMultisampleTarget(TextureTarget target) {
-            return target == TextureTarget::Texture2DMultisample || target == TextureTarget::Texture2DMultisampleArray;
+            return target == TextureTarget::Texture2DMultisample ||
+                   target == TextureTarget::Texture2DMultisampleArray;
         }
 
         Bool IsTextureBufferTarget(TextureTarget target) {
@@ -58,8 +58,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             GLenum normalizedInternalFormat = glFormat;
             GLenum imageFormat = GL_RGBA;
             GLenum imageType = GL_UNSIGNED_BYTE;
-            MG_Util::TextureFormatProcessor::NormalizePixelFormat(glFormat, PixelFormatNormalizeOptionBit::None,
-                                                                  &normalizedInternalFormat, &imageFormat, &imageType);
+            MG_Util::TextureFormatProcessor::NormalizePixelFormat(
+                glFormat, PixelFormatNormalizeOptionBit::None, &normalizedInternalFormat, &imageFormat, &imageType);
             return imageFormat == GL_RED_INTEGER || imageFormat == GL_RG_INTEGER || imageFormat == GL_RGB_INTEGER ||
                    imageFormat == GL_RGBA_INTEGER;
         }
@@ -80,7 +80,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return caps;
         }
 
-        FormatCapabilityFlags BuildVulkanCaps(TextureInternalFormat logicalFormat, TextureTarget target,
+        FormatCapabilityFlags BuildVulkanCaps(TextureInternalFormat logicalFormat,
+                                              TextureTarget target,
                                               VkFormatFeatureFlags features) {
             FormatCapabilityFlags caps;
             const Bool isDepth = MG_Util::IsDepthFormatInternalFormat(logicalFormat);
@@ -99,7 +100,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             const Bool sampled = (features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0;
             const Bool linearFilter = (features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT) != 0;
             const Bool colorRenderable = (features & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) != 0;
-            const Bool depthStencilRenderable = (features & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0;
+            const Bool depthStencilRenderable =
+                (features & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0;
             const Bool renderable = (isDepth || isStencil) ? depthStencilRenderable : colorRenderable;
 
             if (sampled || renderable) {
@@ -138,20 +140,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             case TextureInternalFormat::RGB:
             case TextureInternalFormat::RGB8:
                 return TextureInternalFormat::RGBA8;
-            // Legacy low-bit-depth formats with no (or rarely supported) native Vulkan
-            // encoding; a wider normalized fallback keeps at least the required precision.
-            case TextureInternalFormat::R3G3B2:
-            case TextureInternalFormat::RGB4:
-            case TextureInternalFormat::RGB5:
-            case TextureInternalFormat::RGBA2:
-            case TextureInternalFormat::RGBA4:
-            case TextureInternalFormat::RGB5A1:
-                return TextureInternalFormat::RGBA8;
-            case TextureInternalFormat::RGB10:
-                return TextureInternalFormat::RGB10A2;
-            case TextureInternalFormat::RGB12:
-            case TextureInternalFormat::RGBA12:
-                return TextureInternalFormat::RGBA16;
             case TextureInternalFormat::SRGB8:
                 return TextureInternalFormat::SRGB8Alpha8;
             case TextureInternalFormat::RGB8Snorm:
@@ -196,20 +184,21 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         Bool HasNewCaveatFormatCaps(FormatCapabilityFlags nativeCaps, FormatCapabilityFlags fallbackCaps) {
             for (FormatCapability capability : kReportedFormatCapabilities) {
-                if (HasFormatCapability(fallbackCaps, capability) && !HasFormatCapability(nativeCaps, capability)) {
+                if (HasFormatCapability(fallbackCaps, capability) &&
+                    !HasFormatCapability(nativeCaps, capability)) {
                     return true;
                 }
             }
             return false;
         }
 
-        void LogVulkanFormatCaveat(TextureInternalFormat logicalFormat, SizeT targetIndex,
+        void LogVulkanFormatCaveat(TextureInternalFormat logicalFormat,
+                                   SizeT targetIndex,
                                    TextureInternalFormat fallbackFormat) {
-            MGLOG_D(
-                "Caveat: %s %s not fully supported. Reason: native Vulkan format is not fully supported. Fallback: %s",
-                GetFormatCapabilityTargetName(targetIndex).c_str(),
-                MG_Util::ConvertTextureInternalFormatToString(logicalFormat).c_str(),
-                MG_Util::ConvertTextureInternalFormatToString(fallbackFormat).c_str());
+            MGLOG_D("Caveat: %s %s not fully supported. Reason: native Vulkan format is not fully supported. Fallback: %s",
+                    GetFormatCapabilityTargetName(targetIndex).c_str(),
+                    MG_Util::ConvertTextureInternalFormatToString(logicalFormat).c_str(),
+                    MG_Util::ConvertTextureInternalFormatToString(fallbackFormat).c_str());
         }
 
         Vector<Int> BuildSampleCounts(Int maxSamples) {
@@ -253,15 +242,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
                 for (SizeT targetIndex = 0; targetIndex < kFormatCapabilityTextureTargetCount; ++targetIndex) {
                     const auto target = static_cast<TextureTarget>(targetIndex);
-                    const VkFormatFeatureFlags nativeFeatures = IsTextureBufferTarget(target)
-                                                                    ? nativeProperties.bufferFeatures
-                                                                    : nativeProperties.optimalTilingFeatures;
+                    const VkFormatFeatureFlags nativeFeatures =
+                        IsTextureBufferTarget(target) ? nativeProperties.bufferFeatures
+                                                      : nativeProperties.optimalTilingFeatures;
                     FormatCapabilityFlags nativeCaps = BuildVulkanCaps(logicalFormat, target, nativeFeatures);
                     cache.FullCaps[targetIndex][formatIndex] |= nativeCaps;
 
-                    const VkFormatFeatureFlags fallbackFeatures = IsTextureBufferTarget(target)
-                                                                      ? fallbackProperties.bufferFeatures
-                                                                      : fallbackProperties.optimalTilingFeatures;
+                    const VkFormatFeatureFlags fallbackFeatures =
+                        IsTextureBufferTarget(target) ? fallbackProperties.bufferFeatures
+                                                      : fallbackProperties.optimalTilingFeatures;
                     FormatCapabilityFlags fallbackCaps = BuildVulkanCaps(logicalFormat, target, fallbackFeatures);
                     if (fallbackFormat != VK_FORMAT_UNDEFINED && fallbackFormat != nativeFormat) {
                         cache.CaveatCaps[targetIndex][formatIndex] |= fallbackCaps;
@@ -296,8 +285,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 cache.FullCaps[renderbufferTargetIndex][formatIndex] |= renderbufferCaps;
 
                 if (fallbackFormat != VK_FORMAT_UNDEFINED && fallbackFormat != nativeFormat) {
-                    FormatCapabilityFlags fallbackRenderbufferCaps = BuildVulkanCaps(
-                        logicalFormat, TextureTarget::Texture2D, fallbackProperties.optimalTilingFeatures);
+                    FormatCapabilityFlags fallbackRenderbufferCaps =
+                        BuildVulkanCaps(logicalFormat, TextureTarget::Texture2D,
+                                        fallbackProperties.optimalTilingFeatures);
                     fallbackRenderbufferCaps &= FormatCapability::Creatable;
                     if ((fallbackProperties.optimalTilingFeatures &
                          (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) !=
@@ -306,7 +296,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         fallbackRenderbufferCaps |= FormatCapability::MultisampleRenderbuffer;
                     }
                     cache.CaveatCaps[renderbufferTargetIndex][formatIndex] |= fallbackRenderbufferCaps;
-                    if (fallbackLogicalFormat && HasNewCaveatFormatCaps(renderbufferCaps, fallbackRenderbufferCaps)) {
+                    if (fallbackLogicalFormat &&
+                        HasNewCaveatFormatCaps(renderbufferCaps, fallbackRenderbufferCaps)) {
                         LogVulkanFormatCaveat(logicalFormat, renderbufferTargetIndex, *fallbackLogicalFormat);
                     }
                 }
@@ -323,13 +314,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     void PopulateFormatCapabilities(VkPhysicalDevice physicalDevice,
                                     PFN_vkGetPhysicalDeviceFormatProperties getFormatProperties,
-                                    const MG_External::VulkanCapabilities& capabilities, FormatCapabilityCache& cache) {
+                                    const MG_External::VulkanCapabilities& capabilities,
+                                    FormatCapabilityCache& cache) {
         PopulateFormatCapabilitiesImpl(physicalDevice, getFormatProperties, capabilities, cache);
     }
 
     BackendObject_DirectVulkan::~BackendObject_DirectVulkan() = default;
 
-    BackendObject_DirectVulkan::BackendObject_DirectVulkan() : m_rendererInfo{GetRendererIdentity()} {}
+    BackendObject_DirectVulkan::BackendObject_DirectVulkan(): m_rendererInfo{GetRendererIdentity()} {}
 
     Bool BackendObject_DirectVulkan::InitWindowSurface() {
         if (!m_windowHandle.Handle) {
@@ -403,9 +395,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             MGLOG_E("DirectVulkan backend not initialized");
             return false;
         }
-        if (!handle.Handle || (handle.Backend != WindowBackend::Android && handle.Backend != WindowBackend::X11 &&
-                               handle.Backend != WindowBackend::MetalLayer && handle.Backend != WindowBackend::Win32)) {
-            MGLOG_E("DirectVulkan backend only supports Android, X11, CAMetalLayer, and Win32 native windows");
+        if (!handle.Handle || (handle.Backend != WindowBackend::Android &&
+                               handle.Backend != WindowBackend::X11 &&
+                               handle.Backend != WindowBackend::MetalLayer)) {
+            MGLOG_E("DirectVulkan backend only supports Android, X11, and CAMetalLayer native windows");
             return false;
         }
 
@@ -461,9 +454,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // treat them as signaled/available with zero results from here on.
         BumpRendererGeneration();
         pVulkanRenderer.reset();
-        // The reflection cache is file-scope, not renderer-owned; without this the
-        // deleted programs' reflection strings survive full context teardown.
-        ClearProgramResourceCaches();
         BackendObject::ReleaseEGLResources();
     }
 
@@ -473,9 +463,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // treat them as signaled/available with zero results from here on.
         BumpRendererGeneration();
         pVulkanRenderer.reset();
-        // The reflection cache is file-scope, not renderer-owned; without this the
-        // deleted programs' reflection strings survive full context teardown.
-        ClearProgramResourceCaches();
     }
 
     const RendererInfo& BackendObject_DirectVulkan::GetRendererInfo() const {
@@ -495,68 +482,35 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             .RendererName = "Magma",
             .BackendName = "Direct (Vulkan)",
             .ExtraVendor = Nullopt,
-            .RendererGLInfo = {.TargetGLVersion = {4, 0, 0},
-                               .TargetGLSLVersion = {4, 6, 0},
-                               // Baseline advertisement (no shader subgroup, no timer queries); a
-                               // live backend reconciles its copy in UpdateAdvertisedExtensions.
-                               .Extensions = BuildAdvertisedExtensions(false, false, false),
-                               .IsCompatibilityProfile = false},
+            .RendererGLInfo =
+                {
+                    .TargetGLVersion = {3, 3, 0},
+                    .TargetGLSLVersion = {4, 6, 0},
+                    // Baseline advertisement (no shader subgroup, no timer queries); a
+                    // live backend reconciles its copy in UpdateAdvertisedExtensions.
+                    .Extensions = BuildAdvertisedExtensions(false, false, false),
+                    .IsCompatibilityProfile = false
+                },
             .StaticBackendCapability = {.AllowVSOnlyPrograms = false}};
         return rendererInfo;
     }
 
     Vector<GLExtension> BuildAdvertisedExtensions(Bool shaderSubgroupSupported, Bool timerQueriesSupported,
                                                   Bool anisotropicFilteringSupported) {
-        Vector<GLExtension> extensions = {
-            V_OpenGL30, V_OpenGL31, V_OpenGL32, V_OpenGL33, V_OpenGL40, E_GL_ARB_draw_buffers_blend,
-            E_GL_ARB_compute_shader, E_GL_ARB_shader_storage_buffer_object, E_GL_ARB_shader_image_load_store,
-            E_GL_ARB_program_interface_query, E_GL_ARB_framebuffer_object, E_GL_ARB_multi_draw_indirect,
-            E_GL_ARB_indirect_parameters, E_GL_EXT_framebuffer_object, E_GL_ARB_depth_texture, E_GL_ARB_buffer_storage,
-            E_GL_ARB_texture_storage, E_GL_ARB_texture_storage_multisample, E_GL_ARB_texture_multisample,
-            E_GL_ARB_clear_texture, E_GL_ARB_direct_state_access, E_GL_ARB_shader_draw_parameters,
-            E_GL_ARB_gpu_shader_int64, E_GL_KHR_debug, E_GL_ARB_gpu_shader5, E_GL_ARB_multi_bind,
-            E_GL_ARB_shading_language_420pack, E_GL_ARB_vertex_attrib_binding, E_GL_ARB_shader_image_size,
-            E_GL_ARB_explicit_attrib_location,
-            // 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,
-            // Advertised with GL_NUM_PROGRAM_BINARY_FORMATS = 0, which the
-            // extension explicitly permits. It is also the only thing that
-            // exposes glProgramParameteri before GL 4.1.
-            E_GL_ARB_get_program_binary};
+        Vector<GLExtension> extensions = {V_OpenGL30, V_OpenGL31, V_OpenGL32,
+                                          V_OpenGL33, E_GL_ARB_draw_buffers_blend, E_GL_ARB_compute_shader,
+                                          E_GL_ARB_shader_storage_buffer_object, E_GL_ARB_shader_image_load_store,
+                                          E_GL_ARB_program_interface_query, E_GL_ARB_framebuffer_object,
+                                          E_GL_ARB_multi_draw_indirect, E_GL_ARB_indirect_parameters,
+                                          E_GL_EXT_framebuffer_object, E_GL_ARB_depth_texture, E_GL_ARB_buffer_storage,
+                                          E_GL_ARB_texture_storage, E_GL_ARB_texture_storage_multisample,
+                                          E_GL_ARB_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};
         if (shaderSubgroupSupported && !MG_Config::Features.DisableSubgroup) {
             extensions.push_back(E_GL_KHR_shader_subgroup);
         }
-        // GL_KHR_parallel_shader_compile is MobileGL's own capability, not the Vulkan
-        // device's: the compiler threads belong to MobileGL's shader pool and
-        // glCompileShader/glLinkProgram are serviced entirely inside the frontend, so there
-        // is no device feature to condition this on.
-        //
-        // Gated on the async flag deliberately, and this is the whole reason the gate
-        // exists. Advertising the string is the one part of asynchronous compilation that a
-        // recorded trace can never cover: Iris and Sodium change their SUBMISSION SCHEDULE
-        // the moment they see it - they enqueue whole pipeline batches and poll
-        // GL_COMPLETION_STATUS_KHR instead of compiling one program at a time - so
-        // MOBILEGL_ASYNC_SHADER_COMPILE=0 has to withdraw the application-visible behaviour
-        // change as well as the threading, or the kill switch would only be half a switch.
-        if (MG_Util::Async::AsyncShaderCompileEnabled()) {
-            extensions.push_back(E_GL_KHR_parallel_shader_compile);
-        }
-        // GL_ARB_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);
-        }
         // 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.
@@ -616,8 +570,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             funcsTable.GL.ClearBufferiv = ClearBufferiv;
             funcsTable.GL.ClearNamedFramebufferfv = ClearNamedFramebufferfv;
             funcsTable.GL.ClearNamedFramebufferfi = ClearNamedFramebufferfi;
-            funcsTable.GL.ClearNamedFramebufferiv = ClearNamedFramebufferiv;
-            funcsTable.GL.ClearNamedFramebufferuiv = ClearNamedFramebufferuiv;
             funcsTable.GL.BlitFramebuffer = BlitFramebuffer;
             funcsTable.GL.BlitNamedFramebuffer = BlitNamedFramebuffer;
             funcsTable.GL.CopyTexImage2D = CopyTexImage2D;
@@ -635,6 +587,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             funcsTable.GL.GetIntegeri_v = GetIntegeri_v;
             funcsTable.GL.GetInteger64i_v = GetInteger64i_v;
             funcsTable.GL.GetProgramiv = GetProgramiv;
+            funcsTable.GL.GetProgramInterfaceiv = GetProgramInterfaceiv;
+            funcsTable.GL.GetProgramResourceIndex = GetProgramResourceIndex;
+            funcsTable.GL.GetProgramResourceName = GetProgramResourceName;
+            funcsTable.GL.GetProgramResourceiv = GetProgramResourceiv;
+            funcsTable.GL.GetProgramResourceLocation = GetProgramResourceLocation;
+            funcsTable.GL.GetProgramResourceLocationIndex = GetProgramResourceLocationIndex;
             funcsTable.GL.ShaderStorageBlockBinding = ShaderStorageBlockBinding;
             funcsTable.GL.FenceSync = FenceSync;
             funcsTable.GL.ClientWaitSync = ClientWaitSync;
@@ -655,15 +613,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 funcsTable.GL.DeleteBackendQuery = DeleteBackendQuery;
                 funcsTable.GL.GetGpuTimestampNs = GetGpuTimestampNs;
             }
-            // Occlusion queries share the handle-based result/delete entries, which must
-            // exist even when timer queries are disabled.
-            funcsTable.GL.BeginOcclusionQuery = BeginOcclusionQuery;
-            funcsTable.GL.EndOcclusionQuery = EndOcclusionQuery;
-            funcsTable.GL.BeginXfbPrimitivesQuery = BeginXfbPrimitivesQuery;
-            funcsTable.GL.EndXfbPrimitivesQuery = EndXfbPrimitivesQuery;
-            funcsTable.GL.IsQueryResultAvailable = IsQueryResultAvailable;
-            funcsTable.GL.GetQueryResult64 = GetQueryResult64;
-            funcsTable.GL.DeleteBackendQuery = DeleteBackendQuery;
             funcsTableInitialized = true;
         }
         return funcsTable;
@@ -744,7 +693,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // rather than a maximum the sampler manager will never apply.
         m_dynamicParameters.MaxTextureMaxAnisotropy =
             (pVulkanRenderer && pVulkanRenderer->IsSamplerAnisotropySupported()) ? m_vulkanCaps.MaxSamplerAnisotropy
-                                                                                 : 1.0f;
+                                                                                : 1.0f;
         m_dynamicParameters.SmoothLineWidthRangeMin = m_vulkanCaps.SmoothLineWidthRangeMin;
         m_dynamicParameters.SmoothLineWidthRangeMax = m_vulkanCaps.SmoothLineWidthRangeMax;
         m_dynamicParameters.SmoothLineWidthGranularity = m_vulkanCaps.SmoothLineWidthGranularity;
@@ -765,7 +714,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_dynamicParameters.MaxIntegerSamples = m_vulkanCaps.MaxIntegerSamples;
         m_dynamicParameters.MaxSamples = m_vulkanCaps.MaxSamples;
         m_dynamicParameters.MaxSampleMaskWords = m_vulkanCaps.MaxSampleMaskWords;
-        const Int maxSupportedTextureUnits = static_cast<Int>(MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS);
+        const Int maxSupportedTextureUnits =
+            static_cast<Int>(MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS);
         // GL_MAX_TEXTURE_IMAGE_UNITS is a *per-stage* sampler limit. Adreno/Qualcomm report a huge
         // maxPerStageDescriptorSampledImages (descriptor-indexing scale), so clamping it only to our
         // combined array capacity (192) still advertises 192 per stage. Host code treats this value as
@@ -775,7 +725,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // limits while keeping the combined limit at our texture-unit array capacity.
         constexpr Int maxPerStageTextureUnits =
             static_cast<Int>(MG_State::GLState::TextureState::MAX_PER_STAGE_TEXTURE_IMAGE_UNITS);
-        m_dynamicParameters.MaxTextureImageUnits = std::min(m_vulkanCaps.MaxTextureImageUnits, maxPerStageTextureUnits);
+        m_dynamicParameters.MaxTextureImageUnits =
+            std::min(m_vulkanCaps.MaxTextureImageUnits, maxPerStageTextureUnits);
         m_dynamicParameters.MaxVertexTextureImageUnits =
             std::min(m_vulkanCaps.MaxVertexTextureImageUnits, maxPerStageTextureUnits);
         m_dynamicParameters.MaxComputeTextureImageUnits =
@@ -784,52 +735,19 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             std::min(m_vulkanCaps.MaxCombinedTextureImageUnits, maxSupportedTextureUnits);
         // Never advertise more attributes than the state layer can store: the current-value array and
         // the Uint32 attribute masks the draw path passes around are both bounded by MAX_VERTEX_ATTRIBS.
-        m_dynamicParameters.MaxVertexAttribs = std::min(
-            m_vulkanCaps.MaxVertexAttribs, static_cast<Int>(MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS));
-        // 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.MaxVertexAttribs =
+            std::min(m_vulkanCaps.MaxVertexAttribs,
+                     static_cast<Int>(MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS));
+        m_dynamicParameters.MaxComputeShaderStorageBlocks = m_vulkanCaps.MaxComputeShaderStorageBlocks;
+        m_dynamicParameters.MaxCombinedShaderStorageBlocks = m_vulkanCaps.MaxCombinedShaderStorageBlocks;
+        m_dynamicParameters.MaxComputeUniformBlocks = m_vulkanCaps.MaxComputeUniformBlocks;
         m_dynamicParameters.MaxComputeWorkGroupInvocations = m_vulkanCaps.MaxComputeWorkGroupInvocations;
-        m_dynamicParameters.MaxShaderStorageBufferBindings =
-            clampLimit("GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS", m_vulkanCaps.MaxShaderStorageBufferBindings,
-                       kMaxAdvertisedBufferBlocks);
-        m_dynamicParameters.MaxTextureBufferSize = clampLimit(
-            "GL_MAX_TEXTURE_BUFFER_SIZE", m_vulkanCaps.MaxTextureBufferSize, kMaxAdvertisedTextureBufferSize);
-        m_dynamicParameters.TextureBufferOffsetAlignment = m_vulkanCaps.TextureBufferOffsetAlignment;
-        m_dynamicParameters.MaxUniformBufferBindings = clampLimit(
-            "GL_MAX_UNIFORM_BUFFER_BINDINGS", m_vulkanCaps.MaxUniformBufferBindings, kMaxAdvertisedBufferBlocks);
+        m_dynamicParameters.MaxShaderStorageBufferBindings = m_vulkanCaps.MaxShaderStorageBufferBindings;
+        m_dynamicParameters.MaxTextureBufferSize = m_vulkanCaps.MaxTextureBufferSize;
+        m_dynamicParameters.MaxUniformBufferBindings = m_vulkanCaps.MaxUniformBufferBindings;
         m_dynamicParameters.MaxUniformBlockSize = m_vulkanCaps.MaxUniformBlockSize;
-        m_dynamicParameters.MaxImageUnits = std::max(std::min(m_vulkanCaps.MaxImageUnits, maxSupportedTextureUnits), 0);
+        m_dynamicParameters.MaxImageUnits =
+            std::max(std::min(m_vulkanCaps.MaxImageUnits, maxSupportedTextureUnits), 0);
         m_dynamicParameters.MaxCombinedImageUniforms = std::max(m_vulkanCaps.MaxCombinedImageUniforms, 0);
         const Int maxPerStageImageUniforms =
             std::min(m_dynamicParameters.MaxImageUnits, m_dynamicParameters.MaxCombinedImageUniforms);
@@ -846,7 +764,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_vulkanCaps.SupportsFragmentStoresAndAtomics ? maxPerStageImageUniforms : 0;
         m_dynamicParameters.MaxComputeImageUniforms =
             std::min(std::max(m_vulkanCaps.MaxComputeImageUniforms, 0), maxPerStageImageUniforms);
-        const Int maxSupportedDrawBuffers = static_cast<Int>(MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS);
+        const Int maxSupportedDrawBuffers =
+            static_cast<Int>(MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS);
         m_dynamicParameters.MaxDrawBuffers = std::min(m_vulkanCaps.MaxDrawBuffers, maxSupportedDrawBuffers);
         m_dynamicParameters.MaxColorAttachments = std::min(m_vulkanCaps.MaxColorAttachments, maxSupportedDrawBuffers);
         m_dynamicParameters.MaxClipDistances = m_vulkanCaps.MaxClipDistances;
@@ -856,73 +775,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_dynamicParameters.ViewportBoundsRangeMin = m_vulkanCaps.ViewportBoundsRangeMin;
         m_dynamicParameters.ViewportBoundsRangeMax = m_vulkanCaps.ViewportBoundsRangeMax;
         m_dynamicParameters.ViewportSubpixelBits = m_vulkanCaps.ViewportSubpixelBits;
-        m_dynamicParameters.MinFragmentInterpolationOffset =
-            std::isfinite(m_vulkanCaps.MinFragmentInterpolationOffset) &&
-                    m_vulkanCaps.MinFragmentInterpolationOffset <= -0.5f
-                ? m_vulkanCaps.MinFragmentInterpolationOffset
-                : -0.5f;
-        m_dynamicParameters.MaxFragmentInterpolationOffset = 0.4375f;
-        m_dynamicParameters.FragmentInterpolationOffsetBits = 4;
-        if (m_vulkanCaps.FragmentInterpolationOffsetBits >= 4 &&
-            std::isfinite(m_vulkanCaps.MaxFragmentInterpolationOffset)) {
-            const Float requiredMaxOffset = 0.5f - std::ldexp(1.0f, -m_vulkanCaps.FragmentInterpolationOffsetBits);
-            if (m_vulkanCaps.MaxFragmentInterpolationOffset >= requiredMaxOffset) {
-                m_dynamicParameters.MaxFragmentInterpolationOffset = m_vulkanCaps.MaxFragmentInterpolationOffset;
-                m_dynamicParameters.FragmentInterpolationOffsetBits = m_vulkanCaps.FragmentInterpolationOffsetBits;
-            }
-        }
         m_dynamicParameters.SupportsWideLines = m_vulkanCaps.SupportsWideLines;
-        // A 2D or 2D multisample array texture is a VK_IMAGE_TYPE_2D image whose GL depth IS its
-        // arrayLayers, so a GL layer is a Vulkan array layer with nothing to translate.
-        // ResolveAttachmentBaseArrayLayer already passes the attachment's layer through. The other
-        // layered targets are declared separately as their own machinery lands.
-        {
-            using DynParams = MG_Backend::DynamicBackendParameters;
-            m_dynamicParameters.PerLayerFramebufferAttachmentTargets |=
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture2DArray) |
-                DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture2DMultisampleArray);
-            // A cube map array is one 2D image with arrayLayers = 6 * cubeCount, so a GL layer is a
-            // Vulkan array layer here too - but the image cannot be created without imageCubeArray.
-            // A 3D texture's GL layer is a z slice, which only a 2D view over a 2D-array-compatible
-            // image can name. Optimistic: a format that refuses the flag is caught at image creation
-            // and declines the slice view there, which the clear path handles as a soft miss.
-            if (m_vulkanCaps.Supports2DArrayCompatible3DImages) {
-                m_dynamicParameters.PerLayerFramebufferAttachmentTargets |=
-                    DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::Texture3D);
-            }
-            if (m_vulkanCaps.SupportsImageCubeArray) {
-                m_dynamicParameters.PerLayerFramebufferAttachmentTargets |=
-                    DynParams::PerLayerFramebufferAttachmentBit(TextureTarget::TextureCubeMapArray);
-            }
-        }
-        // Never, on any device, and no longer for the reason it used to be. It used to track
-        // shaderFloat64 because a `dvec3` input needed the Float64 capability 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.
-        //
-        // The shader half of that is gone: every 64-bit float is narrowed before any module
-        // reaches a backend (ShaderTranspiler::DemoteFloat64Pass), so there is no `double` input
-        // left to bitcast INTO, and feeding a UINT-formatted attribute to what is now a `float`
-        // input would be silent garbage. Reconstructing the value would mean decoding the
-        // IEEE-754 double bit pattern in the shader - software fp64, which is precisely what the
-        // demotion exists to avoid - and on Espryt it would additionally need the ES driver to
-        // fetch 2N uint components where the application declared N doubles, which a dvec3 or
-        // dvec4 cannot even express within one attribute location.
-        //
-        // So glVertexAttribLFormat / glVertexAttribLPointer are declined here exactly as they
-        // already were on Espryt and on every real mobile device (Adreno and Mali both report
-        // shaderFloat64 == VK_FALSE), and for the same visible reason. A `dvec3` INPUT still
-        // compiles and draws - it is a `vec3` after demotion - as long as the application feeds
-        // it with glVertexAttribPointer(GL_FLOAT) rather than 64-bit data.
-        m_dynamicParameters.SupportsFloat64VertexAttributes = false;
         m_dynamicParameters.MaxShaderStorageBlockSize =
             std::min(m_vulkanCaps.MaxShaderStorageBlockSize, kMaxAdvertisedShaderStorageBlockSize);
         if (m_vulkanCaps.SupportsShaderSubgroup) {
             m_dynamicParameters.SubgroupSize = m_vulkanCaps.SubgroupSize;
             m_dynamicParameters.SubgroupSupportedStages = mapShaderStages(m_vulkanCaps.SubgroupSupportedStages);
-            m_dynamicParameters.SubgroupSupportedFeatures =
-                mapSubgroupFeatures(m_vulkanCaps.SubgroupSupportedOperations);
+            m_dynamicParameters.SubgroupSupportedFeatures = mapSubgroupFeatures(m_vulkanCaps.SubgroupSupportedOperations);
             m_dynamicParameters.SubgroupQuadOperationsInAllStages = m_vulkanCaps.SubgroupQuadOperationsInAllStages;
         } else {
             m_dynamicParameters.SubgroupSize = 0;
@@ -932,34 +791,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
         if (m_dynamicParameters.MaxShaderStorageBlockSize != m_vulkanCaps.MaxShaderStorageBlockSize) {
             MGLOG_I("DirectVulkan: clamped GL_MAX_SHADER_STORAGE_BLOCK_SIZE from %zu to %zu",
-                    m_vulkanCaps.MaxShaderStorageBlockSize, m_dynamicParameters.MaxShaderStorageBlockSize);
-        }
-        switch (m_vulkanCaps.VendorId) {
-        case 0x5143u: // VK_VENDOR_ID: Qualcomm
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Qualcomm;
-            break;
-        case 0x13B5u: // ARM
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Arm;
-            break;
-        case 0x10DEu: // NVIDIA
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Nvidia;
-            break;
-        case 0x1002u: // AMD
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Amd;
-            break;
-        case 0x8086u: // Intel
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Intel;
-            break;
-        case 0x1010u: // Imagination
-            m_dynamicParameters.GpuVendor = GpuVendorKind::ImgTec;
-            break;
-        case 0x10005u: // Mesa software (lavapipe)
-        case 0x1AE0u:  // Google (SwiftShader)
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Software;
-            break;
-        default:
-            m_dynamicParameters.GpuVendor = GpuVendorKind::Unknown;
-            break;
+                    m_vulkanCaps.MaxShaderStorageBlockSize,
+                    m_dynamicParameters.MaxShaderStorageBlockSize);
         }
     }
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.h

@@ -12,7 +12,7 @@
 #include "Renderer/VulkanRenderer.h"
 
 namespace MobileGL::MG_Backend::DirectVulkan {
-    extern UniquePtr<VulkanRenderer>& pVulkanRenderer;
+    extern UniquePtr<VulkanRenderer> pVulkanRenderer;
 
     // Generation of the live VulkanRenderer instance, mirroring DirectGLES's
     // g_syncContextGeneration. BackendObject_DirectVulkan bumps it wherever
@@ -23,22 +23,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     Uint64 GetRendererGeneration();
     void BumpRendererGeneration();
 
-    // Drops every cached program-resource reflection entry (CPU-side strings/vectors
-    // only, no Vulkan handles). Called at EGL teardown next to the renderer reset;
-    // safe because GL calls are serialized in this codebase, and any still-live
-    // program rebuilds its entry from the retained generated SPIR-V on demand.
-    void ClearProgramResourceCaches();
-
     void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
     void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value);
     void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value);
     void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value);
     void ClearNamedFramebufferfv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
                                  GLint drawbuffer, const GLfloat* value);
-    void ClearNamedFramebufferiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
-                                 GLint drawbuffer, const GLint* value);
-    void ClearNamedFramebufferuiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
-                                  GLint drawbuffer, const GLuint* value);
     void ClearNamedFramebufferfi(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer, GLenum buffer,
                                  GLint drawbuffer, GLfloat depth, GLint stencil);
     void Clear(GLbitfield mask);
@@ -97,7 +87,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void GetIntegeri_v(GLenum target, GLuint index, GLint* data);
     void GetInteger64i_v(GLenum target, GLuint index, GLint64* data);
     void GetProgramiv(GLuint program, GLenum pname, GLint* params);
-    void ShaderStorageBlockBinding(GLuint program, const GLchar* storageBlockName, GLuint storageBlockBinding);
+    void GetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint* params);
+    GLuint GetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar* name);
+    void GetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize,
+                                GLsizei* length, GLchar* name);
+    void GetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount,
+                              const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params);
+    GLint GetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar* name);
+    GLint GetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar* name);
+    void ShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
     void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
     void GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels);
     void GetTextureImage(const SharedPtr<MG_State::GLState::ITextureObject>& texture, TextureUploadTarget uploadTarget,
@@ -119,10 +117,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     // only while a live renderer exists whose device can actually time.
     Bool IsTimerQuerySupported();
     BackendQueryHandle BeginTimeElapsedQuery();
-    BackendQueryHandle BeginXfbPrimitivesQuery(Bool generated);
-    void EndXfbPrimitivesQuery(BackendQueryHandle query);
-    BackendQueryHandle BeginOcclusionQuery();
-    void EndOcclusionQuery(BackendQueryHandle query);
     void EndTimeElapsedQuery(BackendQueryHandle query);
     BackendQueryHandle QueryCounterTimestamp();
     Bool IsQueryResultAvailable(BackendQueryHandle query);

MobileGL/MG_Backend/DirectVulkan/Renderer/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

@@ -16,19 +16,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_device = device;
         m_commandPool = commandPool;
 
-        Vector<VkCommandBuffer> commandBuffers(frameCount * 2, VK_NULL_HANDLE);
+        Vector<VkCommandBuffer> commandBuffers(frameCount, VK_NULL_HANDLE);
         VkCommandBufferAllocateInfo allocInfo{};
         allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
         allocInfo.commandPool = commandPool;
         allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-        allocInfo.commandBufferCount = frameCount * 2;
+        allocInfo.commandBufferCount = frameCount;
         VkResult result = vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data());
         if (result != VK_SUCCESS) {
             return result;
         }
         for (Uint32 i = 0; i < frameCount; ++i) {
             m_frames[i].commandBuffer = commandBuffers[i];
-            m_frames[i].preCommandBuffer = commandBuffers[frameCount + i];
         }
 
         VkSemaphoreCreateInfo semaphoreInfo{VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO};
@@ -48,10 +47,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     void FrameContext::Destroy(VkDevice device, VkCommandPool commandPool) {
         const Uint32 frameCount = static_cast<Uint32>(m_frames.size());
-        Vector<VkCommandBuffer> commandBuffers(frameCount * 2, VK_NULL_HANDLE);
+        Vector<VkCommandBuffer> commandBuffers(frameCount, VK_NULL_HANDLE);
         for (Uint32 i = 0; i < frameCount; ++i) {
             commandBuffers[i] = m_frames[i].commandBuffer;
-            commandBuffers[frameCount + i] = m_frames[i].preCommandBuffer;
         }
 
         for (Uint32 i = 0; i < frameCount; ++i) {
@@ -62,7 +60,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             for (auto& frame : m_frames) {
                 FreeRetiredCommandBuffers(frame);
             }
-            vkFreeCommandBuffers(device, commandPool, frameCount * 2, commandBuffers.data());
+            vkFreeCommandBuffers(device, commandPool, frameCount, commandBuffers.data());
         }
         m_frames.clear();
         currentFrameIndex = 0;
@@ -89,8 +87,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         currentFrameIndex = (currentFrameIndex + 1) % static_cast<Uint32>(m_frames.size());
         GetCurrent().isCommandRecording = false;
         GetCurrent().hasCommandBufferRecorded = false;
-        GetCurrent().isPreCommandRecording = false;
-        GetCurrent().hasPreCommandBufferRecorded = false;
     }
 
     VkCommandBuffer& FrameContext::BeginCommandRecording(VkCommandBufferUsageFlags flags,
@@ -122,41 +118,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         frame.hasCommandBufferRecorded = true;
     }
 
-    VkCommandBuffer FrameContext::BeginPreCommandRecording() {
-        auto& frame = GetCurrent();
-        if (frame.isPreCommandRecording) {
-            return frame.preCommandBuffer;
-        }
-        MOBILEGL_ASSERT(!frame.hasPreCommandBufferRecorded,
-                        "BeginPreCommandRecording: a recorded pre stream is still awaiting submission");
-        VK_VERIFY(vkResetCommandBuffer(frame.preCommandBuffer, 0), "BeginPreCommandRecording, vkResetCommandBuffer");
-        VkCommandBufferBeginInfo beginInfo{};
-        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-        VK_VERIFY(vkBeginCommandBuffer(frame.preCommandBuffer, &beginInfo),
-                  "BeginPreCommandRecording, vkBeginCommandBuffer");
-        frame.isPreCommandRecording = true;
-        return frame.preCommandBuffer;
-    }
-
-    void FrameContext::EndPreCommandRecordingIfOpen() {
-        auto& frame = GetCurrent();
-        if (!frame.isPreCommandRecording) {
-            return;
-        }
-        VK_VERIFY(vkEndCommandBuffer(frame.preCommandBuffer), "EndPreCommandRecordingIfOpen, vkEndCommandBuffer");
-        frame.isPreCommandRecording = false;
-        frame.hasPreCommandBufferRecorded = true;
-    }
-
-    void FrameContext::AbandonPreCommandRecording() {
-        auto& frame = GetCurrent();
-        if (frame.isPreCommandRecording) {
-            VK_VERIFY(vkEndCommandBuffer(frame.preCommandBuffer), "AbandonPreCommandRecording, vkEndCommandBuffer");
-        }
-        frame.isPreCommandRecording = false;
-        frame.hasPreCommandBufferRecorded = false;
-    }
-
     VkResult FrameContext::InitializeSwapchainSemaphores(VkDevice device, Uint32 swapchainImageCount) {
         DestroySwapchainSemaphores(device);
         if (swapchainImageCount == 0) {
@@ -189,30 +150,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     Bool FrameContext::TransitionToPresent(VkImage image, VkImageLayout oldLayout, VkImageLayout presentLayout) {
         auto& frame = GetCurrent();
-        if (oldLayout == presentLayout || oldLayout == VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR) {
+        if (frame.hasCommandBufferRecorded || frame.isCommandRecording || oldLayout == presentLayout ||
+            oldLayout == VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR) {
             return false;
         }
 
-        // The barrier belongs in the frame's own recording. Bailing out because
-        // something was already recorded (the previous behaviour) dropped the
-        // transition entirely for every frame that never ran a default-framebuffer
-        // render pass - the only other thing that carries the image to
-        // PRESENT_SRC_KHR, via that pass's finalLayout - so the swapchain image was
-        // handed to the WSI still in the layout it was acquired in.
-        // A closed-but-unsubmitted buffer can only come from a submit that already
-        // failed (SubmitPendingCommandBuffer leaves the flag set on error), and
-        // appending to it is illegal while reopening would reset the frame's own
-        // commands away. The device is gone on that path anyway - stay silent-safe
-        // rather than trade a lost device for a barrier into a closed buffer.
-        if (frame.hasCommandBufferRecorded) {
-            MGLOG_E_ONCE("TransitionToPresent: command buffer already closed; skipping the present barrier");
-            return false;
-        }
-
-        // Reopening a recording here would vkResetCommandBuffer this frame's own
-        // commands away, so append to the open one and let the caller close it.
-        const Bool openedRecording = !frame.isCommandRecording;
-        VkCommandBuffer commandBuffer = openedRecording ? BeginCommandRecording() : frame.commandBuffer;
+        auto& commandBuffer = BeginCommandRecording();
 
         VkImageMemoryBarrier presentBarrier{};
         presentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -231,9 +174,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0,
                              nullptr, 0, nullptr, 1, &presentBarrier);
 
-        if (openedRecording) {
-            EndCommandRecording();
-        }
+        EndCommandRecording();
         return true;
     }
 
@@ -241,27 +182,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                                Uint32 swapchainImageIndex) const {
         const auto& frame = GetCurrent();
         MOBILEGL_ASSERT(!frame.isCommandRecording, "GetSubmitInfo called while command buffer recording is still active");
-        MOBILEGL_ASSERT(!frame.isPreCommandRecording,
-                        "GetSubmitInfo called while the pre-pass stream is still recording");
         AssertValidSwapchainImageIndex(swapchainImageIndex);
         SubmitInfoPacket packet{};
         packet.waitSemaphore = frame.imageAvailableSemaphore;
         packet.signalSemaphore = m_swapchainImageRenderFinishedSemaphores[swapchainImageIndex];
-
-        Uint32 commandBufferCount = 0;
-        // The pre-pass stream executes strictly before the frame's commands.
-        if (frame.hasPreCommandBufferRecorded) {
-            packet.commandBuffers[commandBufferCount++] = frame.preCommandBuffer;
-        }
-        if (shouldSubmitCommandBuffer) {
-            packet.commandBuffers[commandBufferCount++] = frame.commandBuffer;
-        }
+        packet.commandBuffer = frame.commandBuffer;
 
         packet.submitInfo.waitSemaphoreCount = frame.imageAvailableSemaphoreConsumed ? 0U : 1U;
         packet.submitInfo.pWaitSemaphores = frame.imageAvailableSemaphoreConsumed ? nullptr : &packet.waitSemaphore;
         packet.submitInfo.pWaitDstStageMask = frame.imageAvailableSemaphoreConsumed ? nullptr : &packet.waitDstStageMask;
-        packet.submitInfo.commandBufferCount = commandBufferCount;
-        packet.submitInfo.pCommandBuffers = commandBufferCount > 0 ? packet.commandBuffers : nullptr;
+        packet.submitInfo.commandBufferCount = shouldSubmitCommandBuffer ? 1U : 0U;
+        packet.submitInfo.pCommandBuffers = shouldSubmitCommandBuffer ? &packet.commandBuffer : nullptr;
         packet.submitInfo.signalSemaphoreCount = 1;
         packet.submitInfo.pSignalSemaphores = &packet.signalSemaphore;
         return packet;
@@ -296,21 +227,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         result = vkAcquireNextImageKHR(device, swapchain, timeout, frame.imageAvailableSemaphore, acquireFence,
                                        &outImageIndex);
-        // VK_SUBOPTIMAL_KHR is a success code: an image *was* acquired and
-        // imageAvailableSemaphore *will* be signaled. Bailing out on it skipped both
-        // the consumed-flag reset (leaving a stale "already consumed", so the next
-        // submit never waited on the pending signal) and the fence reset (leaving
-        // the slot's fence signaled for the next submit to reuse). Only a genuine
-        // failure - VK_ERROR_OUT_OF_DATE_KHR and friends, where nothing is acquired
-        // and nothing is signaled - skips the bookkeeping.
-        if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
+        if (result != VK_SUCCESS) {
             return result;
         }
 
         frame.imageAvailableSemaphoreConsumed = false;
-        const VkResult resetResult = vkResetFences(device, 1, &frame.imageInFlightFence);
-        // Hand the acquire's own code back so the caller can schedule a rebuild.
-        return resetResult == VK_SUCCESS ? result : resetResult;
+        return vkResetFences(device, 1, &frame.imageInFlightFence);
     }
 
     Uint32 FrameContext::GetCurrentFrameIndex() const {
@@ -325,14 +247,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_recordingObserver = observer;
     }
 
-    VkResult FrameContext::RetireCurrentCommandBuffer(Bool retirePreCommandBuffer) {
+    VkResult FrameContext::RetireCurrentCommandBuffer() {
         MOBILEGL_ASSERT(m_device != VK_NULL_HANDLE && m_commandPool != VK_NULL_HANDLE,
                         "RetireCurrentCommandBuffer requires an initialized FrameContext");
         auto& frame = GetCurrent();
         MOBILEGL_ASSERT(!frame.isCommandRecording,
                         "RetireCurrentCommandBuffer called while the command buffer is still recording");
-        MOBILEGL_ASSERT(!frame.isPreCommandRecording,
-                        "RetireCurrentCommandBuffer called while the pre-pass stream is still recording");
 
         VkCommandBufferAllocateInfo allocInfo{};
         allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
@@ -340,23 +260,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
         allocInfo.commandBufferCount = 1;
         VkCommandBuffer replacement = VK_NULL_HANDLE;
-        VkResult result = vkAllocateCommandBuffers(m_device, &allocInfo, &replacement);
+        const VkResult result = vkAllocateCommandBuffers(m_device, &allocInfo, &replacement);
         if (result != VK_SUCCESS) {
             return result;
         }
-        if (retirePreCommandBuffer) {
-            VkCommandBuffer preReplacement = VK_NULL_HANDLE;
-            result = vkAllocateCommandBuffers(m_device, &allocInfo, &preReplacement);
-            if (result != VK_SUCCESS) {
-                vkFreeCommandBuffers(m_device, m_commandPool, 1, &replacement);
-                return result;
-            }
-            frame.retiredCommandBuffers.push_back({frame.preCommandBuffer, frame.lastSubmitIndex});
-            frame.preCommandBuffer = preReplacement;
-        }
-        // lastSubmitIndex was just written by the renderer for the submission
-        // that carried this command buffer.
-        frame.retiredCommandBuffers.push_back({frame.commandBuffer, frame.lastSubmitIndex});
+        frame.retiredCommandBuffers.push_back(frame.commandBuffer);
         frame.commandBuffer = replacement;
         return VK_SUCCESS;
     }
@@ -366,40 +274,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return;
         }
         if (m_device != VK_NULL_HANDLE && m_commandPool != VK_NULL_HANDLE) {
-            for (const auto& retired : frame.retiredCommandBuffers) {
-                vkFreeCommandBuffers(m_device, m_commandPool, 1, &retired.commandBuffer);
-            }
+            vkFreeCommandBuffers(m_device, m_commandPool, static_cast<Uint32>(frame.retiredCommandBuffers.size()),
+                                 frame.retiredCommandBuffers.data());
         }
         frame.retiredCommandBuffers.clear();
     }
 
-    void FrameContext::FreeRetiredCommandBuffersCompletedUpTo(Uint64 completedSubmitIndex) {
-        if (m_device == VK_NULL_HANDLE || m_commandPool == VK_NULL_HANDLE) {
-            return;
-        }
-        for (auto& frame : m_frames) {
-            // Retired buffers are appended in submit order, so the completed
-            // ones form a prefix.
-            SizeT completedCount = 0;
-            while (completedCount < frame.retiredCommandBuffers.size() &&
-                   frame.retiredCommandBuffers[completedCount].submitIndex <= completedSubmitIndex) {
-                vkFreeCommandBuffers(m_device, m_commandPool, 1,
-                                     &frame.retiredCommandBuffers[completedCount].commandBuffer);
-                ++completedCount;
-            }
-            if (completedCount > 0) {
-                frame.retiredCommandBuffers.erase(frame.retiredCommandBuffers.begin(),
-                                                  frame.retiredCommandBuffers.begin() + completedCount);
-            }
-        }
-    }
-
-    void FrameContext::FreeAllRetiredCommandBuffers() {
-        for (auto& frame : m_frames) {
-            FreeRetiredCommandBuffers(frame);
-        }
-    }
-
     void FrameContext::AssertValidFrameIndex(Uint32 frameIndex) const {
         MOBILEGL_ASSERT(frameIndex < m_frames.size(), "FrameContext index out of range");
     }

MobileGL/MG_Backend/DirectVulkan/Renderer/FrameContext.h

@@ -29,9 +29,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkPipelineStageFlags waitDstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
             VkSemaphore waitSemaphore = VK_NULL_HANDLE;
             VkSemaphore signalSemaphore = VK_NULL_HANDLE;
-            // [0] = pre-pass command buffer (when recorded), then the frame
-            // command buffer; submitInfo.pCommandBuffers points here.
-            VkCommandBuffer commandBuffers[2] = {VK_NULL_HANDLE, VK_NULL_HANDLE};
+            VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
             VkSubmitInfo submitInfo{VK_STRUCTURE_TYPE_SUBMIT_INFO};
         };
 
@@ -42,35 +40,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkPresentInfoKHR presentInfo{VK_STRUCTURE_TYPE_PRESENT_INFO_KHR};
         };
 
-        // A command buffer submitted mid-frame (FlushPendingCommands), tagged
-        // with the submit-tracker index it was submitted under so it can be
-        // freed as soon as that submission is observed complete - without
-        // waiting for the slot's fence to be waited again (present-less flush
-        // loops never wait it).
-        struct RetiredCommandBuffer {
-            VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
-            Uint64 submitIndex = 0;
-        };
-
         struct FrameData {
             VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
-            // Pre-pass work stream: out-of-pass commands (deferred clear
-            // materialization, sampled-layout transitions) for resources the
-            // frame's recording has not touched yet. Submitted immediately
-            // BEFORE commandBuffer in the same vkQueueSubmit, so recording
-            // into it never has to split the frame's active render pass.
-            VkCommandBuffer preCommandBuffer = VK_NULL_HANDLE;
             VkSemaphore imageAvailableSemaphore = VK_NULL_HANDLE;
             VkFence imageInFlightFence = VK_NULL_HANDLE;
             Bool isCommandRecording = false;
             Bool hasCommandBufferRecorded = false;
-            Bool isPreCommandRecording = false;
-            Bool hasPreCommandBufferRecorded = false;
             Bool imageAvailableSemaphoreConsumed = false;
-            // Command buffers submitted mid-frame (FlushPendingCommands),
-            // appended in submit order; freed once their submission is known
-            // complete (fence wait or completion poll).
-            Vector<RetiredCommandBuffer> retiredCommandBuffers;
+            // Command buffers submitted mid-frame (FlushPendingCommands) whose
+            // execution is only known complete once this slot's fence has been
+            // waited again; freed at that point.
+            Vector<VkCommandBuffer> retiredCommandBuffers;
             // Submit-tracker index of this slot's most recent queue submission
             // (written by the renderer at submit time).
             Uint64 lastSubmitIndex = 0;
@@ -87,14 +67,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkCommandBuffer& BeginCommandRecording(VkCommandBufferUsageFlags flags = 0,
                                                const VkCommandBufferInheritanceInfo* pInheritanceInfo = nullptr);
         void EndCommandRecording();
-        // Lazily opens the pre-pass work stream (see FrameData::preCommandBuffer).
-        VkCommandBuffer BeginPreCommandRecording();
-        // Closes the pre stream if open, marking it for submission ahead of the
-        // frame command buffer. Safe to call when it never opened.
-        void EndPreCommandRecordingIfOpen();
-        // Drops an in-progress or recorded-but-unsubmitted pre stream (dropped
-        // frame recordings, swapchain recreation).
-        void AbandonPreCommandRecording();
         VkResult InitializeSwapchainSemaphores(VkDevice device, Uint32 swapchainImageCount);
         void DestroySwapchainSemaphores(VkDevice device);
         Bool TransitionToPresent(VkImage image, VkImageLayout oldLayout,
@@ -107,18 +79,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // Parks the current (already ended and submitted) command buffer on the
         // slot's retired list and installs a freshly allocated one, so recording
         // can restart while the submitted buffer is still executing. Retired
-        // buffers are freed after the slot's fence is next waited, or as soon
-        // as their submission is observed complete.
-        VkResult RetireCurrentCommandBuffer(Bool retirePreCommandBuffer = false);
-
-        // Frees every retired command buffer whose tagged submission index is
-        // known complete. Driven by the renderer's submit tracker on completion
-        // events (fence waits and non-blocking polls), so present-less flush
-        // loops reclaim their buffers without any extra wait.
-        void FreeRetiredCommandBuffersCompletedUpTo(Uint64 completedSubmitIndex);
-        // Frees every slot's retired command buffers. Only valid when the
-        // caller has proven every queue submission complete.
-        void FreeAllRetiredCommandBuffers();
+        // buffers are freed after the slot's fence is next waited.
+        VkResult RetireCurrentCommandBuffer();
 
         Uint32 GetCurrentFrameIndex() const;
         Uint32 GetFrameCount() const;

MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.cpp

@@ -8,8 +8,6 @@
 
 #include "PipelineFactory.h"
 
-#include <algorithm>
-
 namespace MobileGL::MG_Backend::DirectVulkan {
     static const char* PrimitiveTopologyToString(VkPrimitiveTopology topology) {
         switch (topology) {
@@ -110,81 +108,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                   "vkCreatePipelineCache");
     }
 
-    // Must be called once, before any pipeline is created: the flag is not part of the
-    // pipeline hash, so flipping it mid-life would serve cached pipelines built under the
-    // old value.
-    void PipelineFactory::SetSuppressBlendedDepthWrite(Bool enabled) {
-        s_suppressBlendedDepthWrite = enabled;
-    }
-
-    Bool PipelineFactory::ShouldSuppressBlendedDepthWriteForDevice(MG_Config::QuirkOverride quirkOverride,
-                                                                   Uint32 vendorId) {
-        static constexpr Uint32 kVendorIdQualcomm = 0x5143;
-        switch (quirkOverride) {
-        case MG_Config::QuirkOverride::ForceOn:
-            return true;
-        case MG_Config::QuirkOverride::ForceOff:
-            return false;
-        case MG_Config::QuirkOverride::Auto:
-        default:
-            return vendorId == kVendorIdQualcomm;
-        }
-    }
-
-    namespace {
-        // MIN/MAX extremum blending: the signature of a depth-bounds accumulation pass
-        // (MC 26.3 OIT writes vec4(-linD, linD, deviceZ, 0) under GL_MAX while writing
-        // depth for its equality chain). MIN/MAX ignore blend factors per the Vulkan spec.
-        //
-        // Deliberately the ONLY shape stripped. A quirk should touch as little unrelated
-        // content as possible, and a trace sweep of every fixture showed the wider
-        // alternatives all cost more than they fix:
-        //   - additive ONE+ONE with a depth write matched zero draws of the 26.3 chain
-        //     (its transmittance/accumulate passes disable depth writes themselves) - the
-        //     only real content it caught was harmless additive glow effects (Create);
-        //   - sorted-transparency "over" blends (SRC_ALPHA-style) are order-dependent,
-        //     drawn once per surface, and rely on their depth writes for occlusion;
-        //   - separate-alpha accumulation over an over-blending color channel has no
-        //     known pairing with a depth-equality chain (color channel only, see tests).
-        // If a future workload pairs another blend shape with an equality chain, widen
-        // this with that evidence in hand rather than pre-emptively.
-        Bool IsAccumulationBlend(const VkPipelineColorBlendAttachmentState& attachment) {
-            return attachment.colorBlendOp == VK_BLEND_OP_MIN ||
-                   attachment.colorBlendOp == VK_BLEND_OP_MAX;
-        }
-    } // namespace
-
-    Bool PipelineFactory::ShouldSuppressDepthWrite(const PipelineCreatePayload& payload) {
-        if (!payload.depthWriteEnable) {
-            return false;
-        }
-        // A shader that assigns gl_FragDepth supplies depth itself rather than taking the
-        // pipeline's interpolated Z, so a driver that varies the vertex position math
-        // between pipelines cannot desynchronize it. (A gl_FragDepth = gl_FragCoord.z
-        // passthrough is the exception that stays exposed; no known content pairs one with
-        // an equality chain, and 26.3's composite is a genuine computed-depth writer.)
-        if (payload.fragmentReplacesDepth) {
-            return false;
-        }
-        for (Uint32 i = 0; i < payload.colorAttachmentCount; ++i) {
-            const VkPipelineColorBlendAttachmentState& attachment = payload.colorBlendAttachments[i];
-            if (attachment.blendEnable != VK_TRUE) {
-                continue;
-            }
-            // All color writes masked: blending is moot (depth-prepass pattern that left
-            // GL_BLEND enabled); stripping the depth write would delete the whole prepass.
-            if (attachment.colorWriteMask == 0) {
-                continue;
-            }
-            // Any attachment qualifies, not just attachment 0: the 26.3 transmittance pass
-            // accumulates into a 2-target MRT and must stay stripped.
-            if (IsAccumulationBlend(attachment)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     PipelineFactory::~PipelineFactory() {
         DestroyAll();
         if (m_pipelineCache != VK_NULL_HANDLE) {
@@ -205,12 +128,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         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.polygonMode, sizeof(payload.polygonMode)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.cullMode, sizeof(payload.cullMode)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.frontFace, sizeof(payload.frontFace)));
-        XXHASH_VERIFY(
-            XXH64_update(m_hashState, &payload.provokingVertexMode, sizeof(payload.provokingVertexMode)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.depthTestEnable, sizeof(payload.depthTestEnable)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.depthWriteEnable, sizeof(payload.depthWriteEnable)));
         XXHASH_VERIFY(XXH64_update(m_hashState, &payload.depthBiasEnable, sizeof(payload.depthBiasEnable)));
@@ -232,8 +152,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             XXH64_update(m_hashState, &payload.backStencilDepthFailOp, sizeof(payload.backStencilDepthFailOp)));
         XXHASH_VERIFY(
             XXH64_update(m_hashState, &payload.backStencilCompareOp, sizeof(payload.backStencilCompareOp)));
-        XXHASH_VERIFY(
-            XXH64_update(m_hashState, &payload.fragmentReplacesDepth, sizeof(payload.fragmentReplacesDepth)));
         if (payload.colorAttachmentCount > 0) {
             XXHASH_VERIFY(XXH64_update(
                 m_hashState,
@@ -247,125 +165,23 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const HashType hash = ComputeHash(payload);
         auto it = m_cache.find(hash);
         if (it != m_cache.end()) {
-            it->second.lastUsedFrame = m_frameCounter;
-            return it->second.pipeline;
+            return it->second;
         }
 
         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});
+        m_cache.emplace(hash, pipeline);
         return pipeline;
     }
 
     void PipelineFactory::DestroyAll() {
         for (auto& pair : m_cache) {
-            if (pair.second.pipeline != VK_NULL_HANDLE) {
-                vkDestroyPipeline(m_device, pair.second.pipeline, nullptr);
+            if (pair.second != VK_NULL_HANDLE) {
+                vkDestroyPipeline(m_device, pair.second, nullptr);
             }
         }
         m_cache.clear();
     }
 
-    Uint32 PipelineFactory::OnFrameBoundary() {
-        ++m_frameCounter;
-
-        // Sweep cadence and retire age mirror VkRenderPassManager::OnPresent: an entry
-        // idle for more than kRetireAgeFrames frame boundaries cannot be referenced by
-        // any in-flight command buffer (frames-in-flight <= MOBILEGL_MAGMA_FRAMESINFLIGHT),
-        // so immediate vkDestroyPipeline is safe. The caller must drop its "last
-        // pipeline" memo when this returns non-zero: the memo can return a cached
-        // handle without touching this cache, so an evicted pipeline may still be
-        // memoized (present-less flush loops never reset the memo per frame).
-        constexpr Uint64 kSweepInterval = 256;
-        constexpr Uint64 kRetireAgeFrames = 1024;
-        if ((m_frameCounter % kSweepInterval) != 0) {
-            return 0;
-        }
-
-        Uint32 evicted = 0;
-        for (auto it = m_cache.begin(); it != m_cache.end();) {
-            if (m_frameCounter - it->second.lastUsedFrame > kRetireAgeFrames) {
-                if (it->second.pipeline != VK_NULL_HANDLE) {
-                    vkDestroyPipeline(m_device, it->second.pipeline, nullptr);
-                }
-                it = m_cache.erase(it);
-                ++evicted;
-            } else {
-                ++it;
-            }
-        }
-        if (evicted > 0) {
-            MGLOG_D("PipelineFactory::OnFrameBoundary: evicted %u idle pipelines (%zu remain)", evicted,
-                    m_cache.size());
-        }
-        return evicted;
-    }
-
-    Uint32 PipelineFactory::EvictByRenderPasses(const Vector<VkRenderPass>& renderPasses) {
-        if (renderPasses.empty() || m_cache.empty()) {
-            return 0;
-        }
-        // Sorted-batch membership test keeps a mass eviction (shader-pack switch,
-        // dimension exit) at one O(cache * log batch) scan instead of one full scan
-        // per dying pass.
-        Vector<VkRenderPass> sortedPasses = renderPasses;
-        std::sort(sortedPasses.begin(), sortedPasses.end());
-        Uint32 evicted = 0;
-        for (auto it = m_cache.begin(); it != m_cache.end();) {
-            if (std::binary_search(sortedPasses.begin(), sortedPasses.end(), it->second.renderPass)) {
-                if (it->second.pipeline != VK_NULL_HANDLE) {
-                    vkDestroyPipeline(m_device, it->second.pipeline, nullptr);
-                }
-                it = m_cache.erase(it);
-                ++evicted;
-            } else {
-                ++it;
-            }
-        }
-        if (evicted > 0) {
-            MGLOG_D("PipelineFactory::EvictByRenderPasses: evicted %u pipelines for %zu destroyed render passes",
-                    evicted, sortedPasses.size());
-        }
-        return evicted;
-    }
-
-    Uint32 PipelineFactory::EvictByProgramHash(HashType programHash) {
-        Uint32 evicted = 0;
-        for (auto it = m_cache.begin(); it != m_cache.end();) {
-            if (it->second.programHash == programHash) {
-                if (it->second.pipeline != VK_NULL_HANDLE) {
-                    vkDestroyPipeline(m_device, it->second.pipeline, nullptr);
-                }
-                it = m_cache.erase(it);
-                ++evicted;
-            } else {
-                ++it;
-            }
-        }
-        if (evicted > 0) {
-            MGLOG_D("PipelineFactory::EvictByProgramHash: evicted %u pipelines for program hash 0x%llx",
-                    evicted, static_cast<unsigned long long>(programHash));
-        }
-        return evicted;
-    }
-
     VkPipeline PipelineFactory::CreatePipeline(const PipelineCreatePayload& payload) const {
         MOBILEGL_ASSERT(payload.stages != nullptr && !payload.stages->empty(), "PipelineFactory: stages are empty");
         MOBILEGL_ASSERT(payload.vertexInputState != nullptr, "PipelineFactory: vertexInputState is null");
@@ -400,11 +216,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         ia.topology = payload.topology;
         ia.primitiveRestartEnable = payload.primitiveRestartEnable ? VK_TRUE : VK_FALSE;
 
-        // Only a patch topology has a tessellation stage to configure; leaving the pointer null
-        // otherwise is what the spec expects.
-        VkPipelineTessellationStateCreateInfo tessellation{VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO};
-        tessellation.patchControlPoints = payload.patchControlPoints;
-
         VkPipelineViewportStateCreateInfo vpci{VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO};
         vpci.viewportCount = 1;
         vpci.scissorCount = 1;
@@ -416,17 +227,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         raster.depthBiasEnable = payload.depthBiasEnable ? VK_TRUE : VK_FALSE;
         raster.rasterizerDiscardEnable = payload.rasterizerDiscardEnable ? VK_TRUE : VK_FALSE;
         raster.lineWidth = 1.0f;
-        // Only chain the struct when the mode is not Vulkan's implicit default: a device without
-        // VK_EXT_provoking_vertex enabled must never see this pNext entry, and the renderer's
-        // selector already collapses to FIRST in exactly that case - so a device without the
-        // extension produces a byte-identical VkGraphicsPipelineCreateInfo to before.
-        VkPipelineRasterizationProvokingVertexStateCreateInfoEXT provokingVertexState{
-            VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT};
-        if (payload.provokingVertexMode != VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT) {
-            provokingVertexState.provokingVertexMode = payload.provokingVertexMode;
-            provokingVertexState.pNext = raster.pNext;
-            raster.pNext = &provokingVertexState;
-        }
 
         VkPipelineMultisampleStateCreateInfo ms{VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO};
         ms.rasterizationSamples = payload.rasterizationSamples;
@@ -458,77 +258,17 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         for (Uint32 i = 0; i < payload.colorAttachmentCount; ++i) {
             colorAttachments[i] = payload.colorBlendAttachments[i];
         }
-        // Suppress depth writes on accumulation-blended pipelines when the active driver
-        // cannot keep vertex positions invariant across the pipelines of a multi-pass
-        // depth-equality chain (see SetSuppressBlendedDepthWrite). The decision is narrowed
-        // in ShouldSuppressDepthWrite: sorted-transparency "over" blends (vanilla MC water),
-        // gl_FragDepth writers, and masked-out attachments keep their depth writes.
-        // This bakes the decision into the pipeline, which only works because depth write is
-        // static state here - adding VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE to kDynamicStates
-        // would let the record-time value override it and silently disable the quirk.
-        if (s_suppressBlendedDepthWrite && ShouldSuppressDepthWrite(payload)) {
-            depthStencil.depthWriteEnable = VK_FALSE;
-        }
         VkPipelineColorBlendStateCreateInfo blend{VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO};
         blend.logicOpEnable = payload.logicOpEnable ? VK_TRUE : VK_FALSE;
         blend.logicOp = payload.logicOp;
         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 =
-            payload.topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST ? &tessellation : nullptr;
         gpi.pViewportState = &vpci;
         gpi.pRasterizationState = &raster;
         gpi.pMultisampleState = &ms;
@@ -541,13 +281,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),
@@ -578,36 +311,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;
@@ -40,16 +30,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             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;
             VkPolygonMode polygonMode = VK_POLYGON_MODE_FILL;
             VkCullModeFlags cullMode = VK_CULL_MODE_BACK_BIT;
             VkFrontFace frontFace = VK_FRONT_FACE_CLOCKWISE;
-            // GL's provoking vertex, baked into the pipeline (VK_EXT_provoking_vertex). It selects
-            // which vertex a flat varying takes AND the vertex order transform feedback records for
-            // strips/fans, so it is part of the pipeline's identity, not dynamic state. Defaults to
-            // Vulkan's own convention, which is what a device without the extension gets.
-            VkProvokingVertexModeEXT provokingVertexMode = VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT;
             Bool depthTestEnable = false;
             Bool depthWriteEnable = false;
             Bool depthBiasEnable = false;
@@ -66,25 +49,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkStencilOp backStencilPassOp = VK_STENCIL_OP_KEEP;
             VkStencilOp backStencilDepthFailOp = VK_STENCIL_OP_KEEP;
             VkCompareOp backStencilCompareOp = VK_COMPARE_OP_ALWAYS;
-            // The fragment module writes gl_FragDepth (SPIR-V DepthReplacing); exempts the
-            // pipeline from the blended depth-write quirk (see ShouldSuppressDepthWrite).
-            Bool fragmentReplacesDepth = false;
             Array<VkPipelineColorBlendAttachmentState, kMaxColorAttachments> colorBlendAttachments{};
             const Vector<VkPipelineShaderStageCreateInfo>* stages = nullptr;
-            // 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: it is a pure function of the program and of patchControlPoints, both
-            // of which ComputeHash already mixes in.
-            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);
@@ -95,69 +62,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkPipeline GetOrCreatePipeline(const PipelineCreatePayload& payload);
         void DestroyAll();
 
-        // Frame boundary hook: ages the pipeline cache and destroys long-unused entries
-        // (their command buffers retired many frames ago), mirroring
-        // VkRenderPassManager::OnPresent's sweep. Returns the number of pipelines
-        // destroyed so the caller can drop any memoized VkPipeline handle.
-        Uint32 OnFrameBoundary();
-        // Destroys every cached pipeline hashed on one of `renderPasses`. Only safe
-        // when the caller guarantees GPU idleness for them - the render-pass manager
-        // calls this (via the renderer) for passes its own >1024-boundary-idle sweep
-        // just evicted, and a pipeline hashed on those handles is only ever bound by
-        // draws that also hit the render-pass entries. Also closes the handle-recycling
-        // hazard: a recycled VkRenderPass value must never serve a stale pipeline.
-        // Batched: one cache scan regardless of how many passes died in the sweep.
-        // Returns the number destroyed (callers invalidate memos when non-zero).
-        Uint32 EvictByRenderPasses(const Vector<VkRenderPass>& renderPasses);
-        // Destroys every cached pipeline built from the program with content hash
-        // `programHash`. Called from the ProgramFactory eviction path, which proves the
-        // same >1024-boundary idleness (the program's pipelines are only bound by draws
-        // that stamp its factory entry). Returns the number destroyed.
-        Uint32 EvictByProgramHash(HashType programHash);
-
-        // Driver quirk: suppress depth writes on accumulation-blended pipelines. Multi-pass
-        // depth-equality rendering (a blended prepass writes depth that later passes re-test
-        // with an equality-inclusive compare on the re-rasterized geometry) requires
-        // cross-pipeline position invariance that some mobile compilers do not provide, even
-        // with the SPIR-V Invariant decoration; whole primitives then drop out of the later
-        // passes. Only MIN/MAX extremum blends are stripped - the signature of such a
-        // chain's depth-bounds pass (MC 26.3 OIT), and per a fixture-wide trace sweep the
-        // only depth-writing shape the chain actually uses - so every other blend
-        // (sorted-transparency "over" like vanilla MC water, additive glows, ...) keeps
-        // its depth writes. Set at renderer initialization based on the active driver.
-        static void SetSuppressBlendedDepthWrite(Bool enabled);
-        static Bool IsSuppressBlendedDepthWriteEnabled() { return s_suppressBlendedDepthWrite; }
-        // Device gate for the quirk: ForceOn/ForceOff bypass detection, Auto enables it on
-        // the known-affected vendor (Qualcomm).
-        static Bool ShouldSuppressBlendedDepthWriteForDevice(MG_Config::QuirkOverride quirkOverride,
-                                                             Uint32 vendorId);
-        // Pure per-pipeline strip decision (exempts gl_FragDepth writers, masked-out and
-        // non-accumulation blends); combined with the device flag in CreatePipeline. Static
-        // and payload-only so tests can pin the contract without a VkDevice.
-        static Bool ShouldSuppressDepthWrite(const PipelineCreatePayload& payload);
-
     private:
-        struct PipelineCacheEntry {
-            VkPipeline pipeline = VK_NULL_HANDLE;
-            // The hashed inputs the eviction paths key on: programHash ties the entry to
-            // its ProgramFactory entry, renderPass records the exact handle the hash
-            // folded in (the hash is one-way, so targeted eviction needs them verbatim).
-            HashType programHash = 0;
-            VkRenderPass renderPass = VK_NULL_HANDLE;
-            // Frame-boundary counter value of the last GetOrCreatePipeline hit; drives
-            // cache eviction (see OnFrameBoundary).
-            Uint64 lastUsedFrame = 0;
-        };
-
         VkPipeline CreatePipeline(const PipelineCreatePayload& payload) const;
 
         VkDevice m_device = VK_NULL_HANDLE;
         const VulkanRendererConfig& m_config;
         VkPipelineCache m_pipelineCache = VK_NULL_HANDLE;
-        UnorderedMap<HashType, PipelineCacheEntry> m_cache;
-        // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
-        Uint64 m_frameCounter = 0;
+        UnorderedMap<HashType, VkPipeline> m_cache;
         static inline XXH64_state_t* m_hashState = XXH64_createState();
-        static inline Bool s_suppressBlendedDepthWrite = false;
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.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 {
@@ -49,29 +42,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             SurfaceRotate90 = 1 << 2,
             SurfaceRotate180 = 1 << 3,
             SurfaceRotate270 = 1 << 4,
-            // Rewrites the fragment stage's implicit-LOD image samples to explicit LOD 0.
-            // Only ever set for a draw whose every sampler binding is clamped to a single mip
-            // level, which makes the two forms produce identical texels (the implicit lambda is
-            // clamped into [minLod, maxLod] = [0, 0] regardless of derivatives or bias).
-            ExplicitLod0Sampling = 1 << 5,
-            // Decorates the last vertex-processing stage's captured varyings with
-            // XfbBuffer/XfbStride/Offset (VK_EXT_transform_feedback). Set only for draws
-            // recorded while GL transform feedback is active, so plain draws keep the
-            // undecorated variant.
-            XfbCapture = 1 << 6,
-            // 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;
@@ -82,58 +52,21 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             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;
             VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
             Vector<DescriptorBindingKind> bindingKinds;
-            // The bindings this program actually declares, ascending. bindingKinds is sized to the
-            // 256-binding cap while a real GL program uses 1-8, so the per-draw descriptor walk was
-            // scanning 256 slots to find a handful. MUST stay ascending: Vulkan consumes
-            // pDynamicOffsets in binding order and the writer pushes them in iteration order, so an
-            // unordered list would silently mis-pair dynamic offsets with their uniform blocks.
-            Vector<Uint32> activeBindings;
             Vector<Uint32> dynamicBindings;
             Vector<Int> uniformBlockIndexByBinding;
-            // Descriptor count per binding (1 except for 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).
-            Vector<Uint16> bindingDescriptorCounts;
-            // Per-element GL uniform block indices for arrayed UBO bindings (count > 1);
-            // element 0 of a non-arrayed binding stays in uniformBlockIndexByBinding.
-            UnorderedMap<Uint32, Vector<Int>> arrayedUniformBlockIndicesByBinding;
             Vector<String> samplerNameByBinding;
             Vector<Int> samplerUniformLocationByBinding;
             Vector<TextureTarget> samplerTextureTargetByBinding;
             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;
             Vector<Int> storageBlockIndexByBinding;
-            // Set once during ReflectLayout so the per-draw path can skip the whole
-            // storage-image preparation for the overwhelming majority of programs.
-            Bool hasStorageImages = false;
-            // 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{};
@@ -142,35 +75,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             ShaderStage rasterizationProducerStage = ShaderStage::Unknown;
             Uint32 producerOutputComponentCount = 0;
             Uint32 fragmentInputComponentCount = 0;
-            // The fragment module declares the DepthReplacing execution mode (writes
-            // gl_FragDepth); shader-computed depth is immune to the cross-pipeline
-            // position-invariance quirk (see PipelineFactory::ShouldSuppressDepthWrite).
-            Bool fragmentReplacesDepth = false;
-            // 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;
-            // 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.
-            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;
-            // Frame-boundary counter value of the last GetOrCreateProgram hit; drives
-            // cache eviction (see OnFrameBoundary). Mutable: the draw snapshot's memoised
-            // entry pointer re-stamps use through a const reference (StampProgramUse).
-            mutable Uint64 lastUsedFrame = 0;
 
             static inline VkDevice s_device = VK_NULL_HANDLE;
 
@@ -181,22 +85,11 @@ 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;
                 pipelineLayout = other.pipelineLayout;
                 bindingKinds = std::move(other.bindingKinds);
-                activeBindings = std::move(other.activeBindings);
                 dynamicBindings = std::move(other.dynamicBindings);
                 uniformBlockIndexByBinding = std::move(other.uniformBlockIndexByBinding);
-                bindingDescriptorCounts = std::move(other.bindingDescriptorCounts);
-                arrayedUniformBlockIndicesByBinding = std::move(other.arrayedUniformBlockIndicesByBinding);
                 samplerNameByBinding = std::move(other.samplerNameByBinding);
                 samplerUniformLocationByBinding = std::move(other.samplerUniformLocationByBinding);
                 samplerTextureTargetByBinding = std::move(other.samplerTextureTargetByBinding);
@@ -206,8 +99,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     std::move(other.storageImageUsesBindingFormatByBinding);
                 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;
@@ -216,27 +107,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 rasterizationProducerStage = other.rasterizationProducerStage;
                 producerOutputComponentCount = other.producerOutputComponentCount;
                 fragmentInputComponentCount = other.fragmentInputComponentCount;
-                fragmentReplacesDepth = other.fragmentReplacesDepth;
-                readsBaseVertexBuiltin = other.readsBaseVertexBuiltin;
-                needsPassthroughTessControl = other.needsPassthroughTessControl;
-                passthroughTessControlEmulatable = other.passthroughTessControlEmulatable;
-                lastUsedFrame = other.lastUsedFrame;
                 other.hash = 0;
                 other.descriptorSetLayout = VK_NULL_HANDLE;
                 other.pipelineLayout = VK_NULL_HANDLE;
-                other.hasStorageImages = false;
-                other.declinedDescriptors = false;
                 other.globalUboBinding = -1;
                 other.activeVertexInputLocationMask = 0;
                 other.activeFragmentOutputLocationMask = 0;
                 other.rasterizationProducerStage = ShaderStage::Unknown;
                 other.producerOutputComponentCount = 0;
                 other.fragmentInputComponentCount = 0;
-                other.fragmentReplacesDepth = false;
-                other.readsBaseVertexBuiltin = false;
-                other.needsPassthroughTessControl = false;
-                other.passthroughTessControlEmulatable = false;
-                other.lastUsedFrame = 0;
             }
             VkProgramObject& operator=(VkProgramObject&& other) noexcept {
                 if (this == &other) {
@@ -246,15 +125,11 @@ 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;
                 pipelineLayout = other.pipelineLayout;
                 bindingKinds = std::move(other.bindingKinds);
-                activeBindings = std::move(other.activeBindings);
                 dynamicBindings = std::move(other.dynamicBindings);
                 uniformBlockIndexByBinding = std::move(other.uniformBlockIndexByBinding);
-                bindingDescriptorCounts = std::move(other.bindingDescriptorCounts);
-                arrayedUniformBlockIndicesByBinding = std::move(other.arrayedUniformBlockIndicesByBinding);
                 samplerNameByBinding = std::move(other.samplerNameByBinding);
                 samplerUniformLocationByBinding = std::move(other.samplerUniformLocationByBinding);
                 samplerTextureTargetByBinding = std::move(other.samplerTextureTargetByBinding);
@@ -264,8 +139,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     std::move(other.storageImageUsesBindingFormatByBinding);
                 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;
@@ -274,27 +147,15 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 rasterizationProducerStage = other.rasterizationProducerStage;
                 producerOutputComponentCount = other.producerOutputComponentCount;
                 fragmentInputComponentCount = other.fragmentInputComponentCount;
-                fragmentReplacesDepth = other.fragmentReplacesDepth;
-                readsBaseVertexBuiltin = other.readsBaseVertexBuiltin;
-                needsPassthroughTessControl = other.needsPassthroughTessControl;
-                passthroughTessControlEmulatable = other.passthroughTessControlEmulatable;
-                lastUsedFrame = other.lastUsedFrame;
                 other.hash = 0;
                 other.descriptorSetLayout = VK_NULL_HANDLE;
                 other.pipelineLayout = VK_NULL_HANDLE;
-                other.hasStorageImages = false;
-                other.declinedDescriptors = false;
                 other.globalUboBinding = -1;
                 other.activeVertexInputLocationMask = 0;
                 other.activeFragmentOutputLocationMask = 0;
                 other.rasterizationProducerStage = ShaderStage::Unknown;
                 other.producerOutputComponentCount = 0;
                 other.fragmentInputComponentCount = 0;
-                other.fragmentReplacesDepth = false;
-                other.readsBaseVertexBuiltin = false;
-                other.needsPassthroughTessControl = false;
-                other.passthroughTessControlEmulatable = false;
-                other.lastUsedFrame = 0;
                 return *this;
             }
 
@@ -321,22 +182,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 }
                 modules.clear();
                 stages.clear();
-                stageSpirvDigests.clear(); // the modules they describe are gone
             }
         };
 
-        // Notified when the OnFrameBoundary sweep destroys an aged-out cache entry,
-        // carrying the entry's content hash and the VkDescriptorSetLayout it owned.
-        // Dependent caches (compute pipelines, PipelineFactory entries, UniformManager's
-        // per-layout descriptor sets) must purge in the same step: after vkDestroy the
-        // layout handle value may be recycled for an unrelated layout, and the program
-        // hash may be re-inserted by a later rebuild of the same content.
-        class IEvictionObserver {
-        public:
-            virtual ~IEvictionObserver() = default;
-            virtual void OnProgramEvicted(HashType programHash, VkDescriptorSetLayout descriptorSetLayout) = 0;
-        };
-
         explicit ProgramFactory(VkDevice device, const VulkanRendererConfig& config, Uint32 maxBindings = 16,
                                 Bool shaderDrawParametersEnabled = false,
                                 Bool unformattedFloatStorageImagesEnabled = false)
@@ -345,82 +193,16 @@ namespace MobileGL::MG_Backend::DirectVulkan {
               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
-        // this is unchanged; on a bump it must re-run GetOrCreateProgram.
-        Uint64 GetCacheStructureEpoch() const { return m_cacheStructureEpoch; }
-        // A memoised entry pointer bypasses GetOrCreateProgram, whose per-lookup stamp is
-        // what keeps an in-use entry out of OnFrameBoundary's idle sweep - so such a
-        // caller must re-stamp the entry itself, at least once per frame boundary.
-        void StampProgramUse(const VkProgramObject& entry) const { entry.lastUsedFrame = m_frameCounter; }
-
-        // Observer may be null (no notifications). Not owned.
-        void SetEvictionObserver(IEvictionObserver* observer) { m_evictionObserver = observer; }
-        // Frame boundary hook: ages the program cache and evicts long-unused entries
-        // (their command buffers retired many frames ago), mirroring
-        // VkRenderPassManager::OnPresent's sweep.
-        void OnFrameBoundary();
-
         static VkShaderStageFlagBits ToVkStage(ShaderStage stage);
         static VkFormat ConvertSpirvImageFormatToVkFormat(SpvImageFormat format);
         static SamplerNumericDomain UniformTypeToSamplerNumericDomain(GLenum glType);
-        // True when any entry point declares the DepthReplacing execution mode, i.e. the
-        // shader assigns gl_FragDepth. Exposed so the blended depth-write quirk's exemption
-        // can be pinned by tests. A false negative loses the exemption, so such a shader is
-        // stripped conservatively and forfeits its depth write.
-        static Bool ReflectedFragmentReplacesDepth(const SpvReflectShaderModule& reflectModule);
-        // True when an entry point reads the InstanceIndex builtin. Only gates a diagnostic:
-        // without shaderDrawParameters such a shader cannot have gl_InstanceID rebased.
-        static Bool ReflectedReadsInstanceIndexBuiltin(const SpvReflectShaderModule& reflectModule);
-        // 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);
-
-        // 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 because GL takes the output patch size from PATCH_VERTICES,
-        // which is draw state, not link state - the CTS case that motivated this links at the
-        // default 3 and draws at 4. The pipeline cache already re-keys on patchControlPoints,
-        // so the module a pipeline was built with is part of that pipeline's identity.
-        // Compiling is bounded by the number of distinct patch sizes a program draws with
-        // (MAX_PATCH_VERTICES = 32 in the worst case, one or two in practice) and only ever
-        // happens for the rare program that has no control stage at all.
-        VkPipelineShaderStageCreateInfo GetOrCreatePassthroughTessControlStage(Uint32 patchVertices);
-
-        // 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);
 
     private:
         struct ProgramLookupCache {
@@ -439,12 +221,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         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<SharedPtr<MG_State::GLState::ShaderObject>>& shaders,
-                                               const Vector<Vector<Uint>>& spirv,
-                                               VkProgramObject& entry) const;
 
         VkDevice m_device = VK_NULL_HANDLE;
         Uint32 m_maxBindings = 0;
@@ -456,20 +232,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // True only when the logical device enabled both
         // shaderStorageImageReadWithoutFormat and shaderStorageImageWriteWithoutFormat.
         Bool m_unformattedFloatStorageImagesEnabled = false;
-        // 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 input patch size. Never evicted: at most
-        // MAX_PATCH_VERTICES entries exist for the lifetime of the device, and every pipeline
-        // ever built from one keeps referencing its module. A failed build is cached as
-        // VK_NULL_HANDLE so a broken generator costs one compile, not one per draw.
-        UnorderedMap<Uint32, 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);
@@ -247,11 +247,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         m_surfaceFormat = {createInfo.imageFormat, createInfo.imageColorSpace};
         m_extent = createInfo.imageExtent;
-        // The surface-space extent this swapchain was built from, i.e. before the
-        // quarter-turn swap above. Out-of-date checks must compare in THIS space: comparing a
-        // freshly queried currentExtent against the swapped m_extent flips axes every rotation
-        // and makes the comparison alternate forever.
-        m_surfaceExtent = defaultFramebufferExtent;
         m_preTransform = createInfo.preTransform;
 
         VK_VERIFY(vkCreateSwapchainKHR(device, &createInfo, nullptr, &m_swapchain));
@@ -262,9 +257,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_images.resize(imageCount, VK_NULL_HANDLE);
         VK_VERIFY(vkGetSwapchainImagesKHR(device, m_swapchain, &imageCount, m_images.data()));
         m_imageLayouts.assign(imageCount, VK_IMAGE_LAYOUT_UNDEFINED);
-        // Fresh swapchain images hold garbage until a render pass stores into them.
-        m_imageContentDefined.assign(imageCount, false);
-        m_depthStencilContentDefined.assign(imageCount, false);
 
         CreateImageViews(device);
         CreateDepthStencilResources(device, physicalDevice);
@@ -436,39 +428,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         m_images.clear();
         m_imageLayouts.clear();
-        m_imageContentDefined.clear();
-        m_depthStencilContentDefined.clear();
         m_preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
     }
 
-    Bool SwapchainObject::IsImageContentDefined(Uint32 index) const {
-        MOBILEGL_ASSERT(index < m_imageContentDefined.size(), "Swapchain image content index out of range");
-        return m_imageContentDefined[index];
-    }
-
-    void SwapchainObject::SetImageContentDefined(Uint32 index, Bool defined) {
-        MOBILEGL_ASSERT(index < m_imageContentDefined.size(), "Swapchain image content index out of range");
-        m_imageContentDefined[index] = defined;
-    }
-
-    Bool SwapchainObject::IsDepthStencilContentDefined(Uint32 index) const {
-        MOBILEGL_ASSERT(index < m_depthStencilContentDefined.size(),
-                        "Swapchain depth/stencil content index out of range");
-        return m_depthStencilContentDefined[index];
-    }
-
-    void SwapchainObject::SetDepthStencilContentDefined(Uint32 index, Bool defined) {
-        MOBILEGL_ASSERT(index < m_depthStencilContentDefined.size(),
-                        "Swapchain depth/stencil content index out of range");
-        m_depthStencilContentDefined[index] = defined;
-    }
-
-    void SwapchainObject::SetAllDepthStencilContentUndefined() {
-        for (SizeT i = 0; i < m_depthStencilContentDefined.size(); ++i) {
-            m_depthStencilContentDefined[i] = false;
-        }
-    }
-
     VkImage SwapchainObject::GetImage(Uint32 index) const {
         MOBILEGL_ASSERT(index < m_images.size(), "Swapchain image index out of range");
         return m_images[index];

MobileGL/MG_Backend/DirectVulkan/Renderer/SwapchainObject.h

@@ -35,9 +35,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkSwapchainKHR GetHandle() const { return m_swapchain; }
         const VkSurfaceFormatKHR& GetSurfaceFormat() const { return m_surfaceFormat; }
         VkExtent2D GetExtent() const { return m_extent; }
-        // Surface-space extent (before the pre-rotation quarter-turn swap) this swapchain was
-        // created from - the value to compare a freshly queried currentExtent against.
-        VkExtent2D GetSurfaceExtent() const { return m_surfaceExtent; }
         VkSurfaceTransformFlagBitsKHR GetPreTransform() const { return m_preTransform; }
         const Vector<VkImage>& GetImages() const { return m_images; }
         const Vector<VkImageView>& GetImageViews() const { return m_imageViews; }
@@ -52,21 +49,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void SetImageLayout(Uint32 index, VkImageLayout layout);
         SizeT GetImageCount() const { return m_images.size(); }
 
-        // EGL content-validity tracking for the default framebuffer. A color
-        // buffer's content is undefined once its image has been presented
-        // (EGL_BUFFER_DESTROYED swap behaviour, the implementation default),
-        // and every ancillary (depth/stencil) buffer's content is undefined
-        // after ANY swap regardless of swap behaviour (EGL 1.5 §3.10.1). The
-        // render-pass manager turns an undefined attachment's tile load into
-        // LOAD_OP_DONT_CARE. Flags start false (a fresh swapchain image holds
-        // garbage) and a render pass storing into an attachment sets it back
-        // to defined.
-        Bool IsImageContentDefined(Uint32 index) const;
-        void SetImageContentDefined(Uint32 index, Bool defined);
-        Bool IsDepthStencilContentDefined(Uint32 index) const;
-        void SetDepthStencilContentDefined(Uint32 index, Bool defined);
-        void SetAllDepthStencilContentUndefined();
-
     private:
         void CreateImageViews(VkDevice device);
         void CreateDepthStencilResources(VkDevice device, VkPhysicalDevice physicalDevice);
@@ -81,7 +63,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkSwapchainKHR m_swapchain = VK_NULL_HANDLE;
         VkSurfaceFormatKHR m_surfaceFormat{};
         VkExtent2D m_extent{};
-        VkExtent2D m_surfaceExtent{};
         VkSurfaceTransformFlagBitsKHR m_preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
         Vector<VkImage> m_images;
         Vector<VkImageView> m_imageViews;
@@ -92,7 +73,5 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Vector<VkDeviceMemory> m_depthStencilImageMemories;
         Vector<VkImageView> m_depthStencilImageViews;
         Vector<VkImageLayout> m_depthStencilImageLayouts;
-        Vector<Bool> m_imageContentDefined;
-        Vector<Bool> m_depthStencilContentDefined;
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.h

@@ -39,59 +39,18 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void Shutdown();
 
         void BeginFrame(Uint32 frameIndex);
-        // A command buffer (re)began recording: descriptor bindings recorded into
-        // the previous buffer do not carry over, so drop the bind-dedup shadow.
-        void OnCommandBufferBoundary() { m_lastBindValid = false; }
-        // A ProgramFactory eviction just destroyed this layout: purge every frame
-        // slot's cached descriptor sets for it, so a recycled handle value can never
-        // stale-hit sets written for the dead layout's bindings. The sets are
-        // vkFreeDescriptorSets'd back to their pools (created with
-        // FREE_DESCRIPTOR_SET_BIT) and the pool accounting is credited, so program
-        // churn recycles pool capacity instead of abandoning it. GPU-safe: the layout
-        // only dies after >1024 idle frame boundaries, so no in-flight command buffer
-        // references its sets. This is the only eviction path for the per-layout
-        // caches - a live layout's entry must never be purged (its sets would be
-        // unreachable pool slots), so there is deliberately no age-based sweep here.
-        void OnDescriptorSetLayoutDestroyed(VkDescriptorSetLayout descriptorSetLayout);
-        // 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.
-        struct SampledBindingRecord {
-            Uint64 textureLifetimeId = 0;
-            Uint64 samplerLifetimeId = 0;
-        };
         Bool CollectSampledTextures(const MG_State::GLState::ProgramObject& program,
                                     const ProgramFactory::VkProgramObject& programObj,
-                                    Vector<MG_State::GLState::ITextureObject*>& outTextures,
-                                    Vector<SampledBindingRecord>* outBindingRecords = nullptr);
-        // Shadow-compare for the SetupDraw fast path: re-runs the CollectSampledTextures
-        // walk and reports whether every visited binding still resolves to the recorded
-        // (texture, effective sampler) pair. A texture bind generation bump alone (e.g. a
-        // redundant glBindSampler, which always bumps it) does not prove the sampled set
-        // moved; this walk does, without rebuilding the set or falling off the fast path.
-        Bool SampledBindingsUnchanged(const MG_State::GLState::ProgramObject& program,
-                                      const ProgramFactory::VkProgramObject& programObj,
-                                      const Vector<SampledBindingRecord>& previousRecords) const;
+                                    Vector<MG_State::GLState::ITextureObject*>& outTextures);
         Bool CollectStorageImageTextures(const MG_State::GLState::ProgramObject& program,
                                          const ProgramFactory::VkProgramObject& programObj,
                                          Vector<MG_State::GLState::ITextureObject*>& outTextures) const;
-        // samplerDescriptorsUnchangedHint: the caller (SetupDraw fast path) proved that
-        // every input of every combined-image-sampler resolution is unchanged since the
-        // previous draw's resolve - same (texture, sampler) per binding, texture params
-        // sum, sampling-resolution generation (sampler params + texture shape), image
-        // epochs AND per-resource layout values - so the per-binding cached
-        // VkDescriptorImageInfo may be reused without re-running the resolve chain.
         Bool BindProgramUniformBuffers(VkCommandBuffer commandBuffer,
                                        const MG_State::GLState::ProgramObject& program,
                                        const ProgramFactory::VkProgramObject& programObj,
                                        Uint32 frameIndex,
                                        VkPipelineBindPoint bindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                       const SamplerBindingOverride* samplerBindingOverride = nullptr,
-                                       Bool samplerDescriptorsUnchangedHint = false);
+                                       const SamplerBindingOverride* samplerBindingOverride = nullptr);
 
         // Pure format-policy helper kept public for host regression tests. Formatted storage
         // images use their shader qualifier; transformed float images use glBindImageTexture's
@@ -99,16 +58,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         static VkFormat ResolveStorageImageViewFormat(VkFormat reflectedFormat, GLenum bindingFormat,
                                                       VkFormat resourceFormat, Bool useBindingFormat);
 
-        // True when the program reads at least one sampler and every one of them is bound to a
-        // texture whose GL level range is a single level. Such a sampler resolves to
-        // minLod = maxLod = 0 (see VkSamplerManager::GetOrCreateSampler), so an implicit-LOD sample
-        // and an explicit LOD 0 sample must read the same texel - which is what makes the
-        // ExplicitLod0Sampling SPIR-V rewrite safe to request. Deliberately conservative: it reads
-        // only GL state, so a texture that ends up single-level for another reason (one uploaded
-        // level under a wide level range) merely misses the rewrite.
-        static Bool ProgramSamplesOnlySingleLevelTextures(const MG_State::GLState::ProgramObject& program,
-                                                          const ProgramFactory::VkProgramObject& programObj);
-
     private:
         struct DescriptorPoolBucket {
             VkDescriptorPool handle = VK_NULL_HANDLE;
@@ -116,16 +65,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint32 allocatedSets = 0;
         };
 
-        // A cached descriptor set together with the pool it was allocated from, so a
-        // layout-destroyed purge can vkFreeDescriptorSets it back and credit the
-        // owning bucket's accounting.
-        struct CachedDescriptorSet {
-            VkDescriptorSet set = VK_NULL_HANDLE;
-            VkDescriptorPool pool = VK_NULL_HANDLE;
-        };
-
         struct DescriptorSetCacheEntry {
-            Vector<CachedDescriptorSet> sets;
+            Vector<VkDescriptorSet> sets;
             Uint32 cursor = 0;
         };
 
@@ -141,60 +82,28 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         static Bool ResolveSamplerTexture(const MG_State::GLState::ProgramObject& program,
                                    const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
                                    SharedPtr<MG_State::GLState::ITextureObject>& outTexture);
-        // Shared per-binding resolution for CollectSampledTextures and
-        // SampledBindingsUnchanged, so membership and comparison can never diverge:
-        // texture after the fallback substitution (may still be null when no fallback
-        // exists), effective sampler = unit override else the texture's own sampler.
-        // False = the binding is skipped (unbound with a non-2D fallback target).
-        // `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,
-                                   MG_State::GLState::ITextureObject*& outTexture,
-                                   const MG_State::GLState::SamplerObject*& outSampler) const;
         // Raw-pointer variant for the per-draw sampled-texture walk (CollectSampledTextures):
         // the bound texture stays alive through the draw via GL binding state, so callers that
         // only need the pointer skip the SharedPtr copy's atomic refcount churn.
         static MG_State::GLState::ITextureObject* ResolveSamplerTextureRaw(
             const MG_State::GLState::ProgramObject& program,
-            const ProgramFactory::VkProgramObject& programObj, Uint32 binding, Uint32 element);
+            const ProgramFactory::VkProgramObject& programObj, Uint32 binding);
         SharedPtr<MG_State::GLState::ITextureObject> GetFallbackTexture(TextureTarget target) 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.
-        //
-        // 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.
         Bool ResolveSamplerDescriptor(VkCommandBuffer commandBuffer, const MG_State::GLState::ProgramObject& program,
                                       const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                      Uint32 element, VkDescriptorImageInfo& outImageInfo,
-                                      Bool trustUnchangedHint = false) const;
+                                      VkDescriptorImageInfo& outImageInfo) const;
         Bool ResolveSamplerDescriptorOverride(const SamplerBindingOverride& samplerBindingOverride,
                                               VkDescriptorImageInfo& outImageInfo) const;
         Bool ResolveTexelBufferDescriptor(const MG_State::GLState::ProgramObject& program,
                                           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 {
@@ -207,22 +116,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         };
         Bool ResolveUniformBufferPayload(const MG_State::GLState::ProgramObject& program,
                                          const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                         Uint32 arrayElement, UboBindResult& out) const;
-        // Shared resolution of one dynamic-UBO binding element into the
-        // (buffer, range, dynamicOffset) triple the descriptor consumes: direct
-        // bind, global-slice reuse, or transient upload. Used by the full walk
-        // and by the dynamic-offset-only rebind (see FastRebindMemo).
-        Bool ResolveDynamicUboDescriptor(const MG_State::GLState::ProgramObject& program,
-                                         const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                         Uint32 arrayElement, Uint32 frameIndex, VkBuffer& outBuffer,
-                                         VkDeviceSize& outRange, Uint32& outDynamicOffset);
-        // The vkCmdBindDescriptorSets tail shared by the full walk and the
-        // dynamic-offset-only rebind: skips the driver call when this exact
-        // binding is already live on the command buffer (see the bind-dedup
-        // shadow below), otherwise binds and refreshes the shadow.
-        void BindDescriptorSetDeduped(VkCommandBuffer commandBuffer, VkPipelineBindPoint bindPoint,
-                                      VkPipelineLayout pipelineLayout, VkDescriptorSet descriptorSet,
-                                      const Vector<Uint32>& dynamicOffsets);
+                                         UboBindResult& out) const;
         Bool CreateDescriptorPool(Uint32 maxSets, VkDescriptorPool& outPool) const;
         Bool GrowFrameDescriptorPool(FrameResources& frame, Uint32 frameIndex);
         VkResult AllocateDescriptorSetsFromActivePool(
@@ -253,82 +147,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Vector<VkBufferView> m_texelBufferViewsScratch;
         Vector<Uint32> m_dynamicOffsetsScratch;
 
-        // Descriptor-set reuse across recent draws (see BindProgramUniformBuffers).
-        // When a draw's resolved descriptor content is byte-identical to one memoized
-        // earlier, reuse that VkDescriptorSet and skip AcquireDescriptorSet +
-        // vkUpdateDescriptorSets - only the bind-time dynamic offsets differ. Four
-        // entries with round-robin replacement rather than one: draws alternating
-        // between two programs (MC's chunk<->entity ping-pong) would thrash a single
-        // slot into a full re-allocate+write every draw. Reset each frame in BeginFrame
-        // because the frame's descriptor sets are recycled there.
-        struct DescriptorReuseEntry {
-            Uint64 signature = 0;
-            VkDescriptorSet set = VK_NULL_HANDLE;
-            Bool valid = false;
-        };
-        static constexpr Uint32 kDescriptorReuseMemoSize = 4;
-        DescriptorReuseEntry m_descriptorReuseMemo[kDescriptorReuseMemoSize];
-        Uint32 m_descriptorReuseMemoNext = 0;
-
-        // Dynamic-offset-only rebind (see BindProgramUniformBuffers): records the
-        // descriptor set selected by the last cacheable full walk of a program
-        // whose active bindings are exactly one dynamic UBO (single descriptor)
-        // plus combined-image samplers. When the next call proves every sampler
-        // descriptor input unchanged (samplerDescriptorsUnchangedHint) and the
-        // UBO re-resolves to the SAME VkBuffer+range - only the dynamic offset
-        // moved, the per-draw glUniform case - the walk collapses to: resolve one
-        // offset, rebind the recorded set with new pDynamicOffsets (Vulkan allows
-        // rebinding the same set with different dynamic offsets).
-        // Invalidation inventory: BeginFrame clears it (the frame's sets are
-        // recycled) and the frameIndex field guards cross-frame confusion on top;
-        // OnDescriptorSetLayoutDestroyed clears it (the set may be freed); a
-        // sampler-override walk clears it (mirrors m_descriptorReuseMemo); a
-        // program relink bumps the backend state version and thus programObj.hash
-        // so the key misses; the program lifetime id is never reused, so a
-        // deleted-and-recreated program misses; a texture/sampler/binding change
-        // drops the hint upstream; an arena wrap or growth resolves a different
-        // VkBuffer and misses. AcquireDescriptorSet's per-frame cursor only
-        // advances, so the recorded set is never re-written within its frame.
-        struct FastRebindMemo {
-            Bool valid = false;
-            Uint32 frameIndex = 0;
-            Uint64 programLifetimeId = 0;
-            ProgramFactory::HashType programHash = 0;
-            Uint32 uboBinding = 0;
-            VkBuffer uboBuffer = VK_NULL_HANDLE;
-            VkDeviceSize uboRange = 0;
-            VkDescriptorSet set = VK_NULL_HANDLE;
-        };
-        FastRebindMemo m_fastRebindMemo;
-
-        // vkCmdBindDescriptorSets dedup: consecutive draws with a static uniform
-        // block resolve to the same set AND the same dynamic offsets, so the
-        // driver call can be skipped outright. Command-buffer-scope state; reset
-        // via OnCommandBufferBoundary whenever a recording (re)begins. Keyed on
-        // layout+bind point, so a pipeline-layout switch always rebinds.
-        static constexpr Uint32 kMaxShadowedDynamicOffsets = 8;
-        Bool m_lastBindValid = false;
-        VkDescriptorSet m_lastBindSet = VK_NULL_HANDLE;
-        VkPipelineLayout m_lastBindLayout = VK_NULL_HANDLE;
-        VkPipelineBindPoint m_lastBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
-        Uint32 m_lastBindOffsetCount = 0;
-        Uint32 m_lastBindOffsets[kMaxShadowedDynamicOffsets] = {};
-
-        // Global-UBO transient-slice reuse: MC leaves the default uniform block
-        // untouched across long GUI/terrain runs, so the per-draw re-upload of
-        // the same bytes can reuse the slice uploaded earlier THIS frame (frame
-        // serial guards arena recycling; the content version guards writes).
-        struct GlobalUboSliceMemo {
-            Uint64 programLifetimeId = 0;
-            Uint64 frameSerial = 0;
-            Uint32 uboContentVersion = 0;
-            VkBuffer buffer = VK_NULL_HANDLE;
-            VkDeviceSize offset = 0;
-            VkDeviceSize range = 0;
-        };
-        static constexpr Uint32 kGlobalUboMemoSize = 4;
-        GlobalUboSliceMemo m_globalUboMemo[kGlobalUboMemoSize];
-        Uint32 m_globalUboMemoNext = 0;
+        // Descriptor-set reuse across consecutive draws (see BindProgramUniformBuffers).
+        // When a draw's resolved descriptor content is byte-identical to the previous
+        // draw's, reuse the same VkDescriptorSet and skip AcquireDescriptorSet +
+        // vkUpdateDescriptorSets - only the bind-time dynamic offsets differ. Reset each
+        // frame in BeginFrame because the frame's descriptor sets are recycled there.
+        VkDescriptorSet m_lastBoundDescriptorSet = VK_NULL_HANDLE;
+        Uint64 m_lastDescriptorSignature = 0;
+        Bool m_hasLastDescriptor = false;
 
         // Per-binding fast path over VkSamplerManager's content-hashed sampler cache, which
         // stays the source of truth: its key hashes all sampler+texture state, so two distinct
@@ -346,48 +172,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             Uint64 samplerLifetimeId = 0;
             Uint64 textureLifetimeId = 0;
             VkSampler sampler = VK_NULL_HANDLE;
-            Uint32 viewLevelCount = 0;
             Uint16 samplerVersion = 0;
             Uint16 textureParamsVersion = 0;
             Bool forceNearestFiltering = false;
             Bool valid = false;
-            // ResolveSampledImageViewFormat is pure in (image format, numeric domain), but a
-            // domain mismatch walks a ~184-entry format table. Memo the resolution per binding
-            // so a reinterpreted sampler pays that scan once, not once per draw.
-            VkFormat viewFormatSource = VK_FORMAT_UNDEFINED;
-            SamplerNumericDomain viewFormatDomain = SamplerNumericDomain::Unknown;
-            VkFormat viewFormat = VK_FORMAT_UNDEFINED;
-            Bool viewFormatValid = false;
-            // Whole resolved descriptor from this binding's last full resolve. Reused
-            // ONLY under ResolveSamplerDescriptor's trustUnchangedHint, whose caller
-            // proves every resolve input unchanged; cleared with the per-frame reset
-            // (the cached VkSampler outlives a frame only via a fresh resolve, which
-            // also re-stamps it against VkSamplerManager's frame-boundary sweep).
-            //
-            // 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;
         };
         mutable Vector<SamplerResolveMemo> m_samplerResolveMemo;
-        // Exclusive upper bound on the entries of m_samplerResolveMemo that any resolve
-        // has ever written. The vector is sized to the DEVICE binding cap (256 on desktop
-        // NVIDIA), but a program declares 1-8 bindings, so the per-frame reset below was
-        // memsetting ~22 KB of never-touched entries every frame - a measurable slice of
-        // the per-frame fixed cost on draw-light frames. Every site that can turn any of
-        // an entry's *Valid flags on raises this mark first, so entries at or above it are
-        // provably still in their constructed (all-invalid) state and clearing them is a
-        // no-op. Never lowered except by Initialize/Shutdown, which rebuild the vector.
-        mutable Uint32 m_samplerResolveMemoHighWater = 0;
-        void NoteSamplerResolveMemoTouched(Uint32 binding) const {
-            if (binding >= m_samplerResolveMemoHighWater) {
-                m_samplerResolveMemoHighWater = binding + 1;
-            }
-        }
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.cpp

@@ -29,22 +29,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.Stride, sizeof(attr.Stride)));
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.Offset, sizeof(attr.Offset)));
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.IsInteger, sizeof(attr.IsInteger)));
-            XXHASH_VERIFY(XXH64_update(m_hashState, &attr.IsLong, sizeof(attr.IsLong)));
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.IsBgra, sizeof(attr.IsBgra)));
             XXHASH_VERIFY(XXH64_update(m_hashState, &attr.Divisor, sizeof(attr.Divisor)));
 
-            // The bound buffer's IDENTITY is a component of the key, and it has to be the
-            // buffer's never-reused lifetime id - NOT its heap address, which this used to
-            // hash. An address is recycled by the allocator, so a deleted-and-recreated
-            // buffer reproduces it; combined with a byte-identical attribute layout that
-            // reproduces the WHOLE content hash, and the hash is what
-            // TryBindResolvedVertexBindings accepts as proof that a memoised binding still
-            // reads the buffer it was resolved from. It did not: a destroyed buffer's GPU
-            // slice was bound for its successor's draw, which is how a transform-feedback
-            // capture came back holding a dead VAO's vertex data (0,0,0,1 - the previous
-            // test's positions) instead of its own.
-            // Zero for client memory (no buffer), which is a distinct identity of its own.
-            const Uint64 bufferKey = attr.Buffer ? attr.Buffer->GetLifetimeId() : 0;
+            const SizeT bufferKey = reinterpret_cast<SizeT>(attr.Buffer.get());
             XXHASH_VERIFY(XXH64_update(m_hashState, &bufferKey, sizeof(bufferKey)));
         }
 
@@ -63,33 +51,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     const VertexInputStateFactory::BackendVertexInputState& VertexInputStateFactory::GetOrCreateVertexInputState(
         const MG_State::GLState::VertexArrayObject& vao) {
-        // Per-draw fast path: the VAO carries a pointer to its resolved entry,
-        // valid while its config version and the cache's eviction epoch both
-        // match - no re-hash, no map lookup.
-        const void* memoState = nullptr;
-        Uint64 memoEpoch = 0;
-        if (vao.GetBackendStateMemo(memoState, memoEpoch) && memoEpoch == m_evictionEpoch) {
-            const auto* entry = static_cast<const BackendVertexInputState*>(memoState);
-            entry->lastUsedFrameBoundary = m_frameBoundaryCounter;
-            return *entry;
-        }
-        const BackendVertexInputState& entry = GetOrCreateVertexInputState(vao, GetOrComputeHash(vao));
-        vao.SetBackendStateMemo(&entry, m_evictionEpoch);
-        // Also mirror the layout identity and the two per-draw masks into the VAO's aux
-        // memo (pure VALUES derived from the VAO configuration, so config-version
-        // guarding alone is sound). The draw fast path reads them from the VAO object it
-        // already touched instead of chasing into this entry - see PackVertexInputAuxMemo.
-        vao.SetBackendAuxMemo(entry.layoutHash,
-                              PackVertexInputAuxMasks(entry.unsupportedAttribMask, entry.attributeLocationMask));
-        return entry;
+        return GetOrCreateVertexInputState(vao, GetOrComputeHash(vao));
     }
 
     const VertexInputStateFactory::BackendVertexInputState& VertexInputStateFactory::GetOrCreateVertexInputState(
         const MG_State::GLState::VertexArrayObject& vao, HashType hash) {
         auto it = m_cache.find(hash);
         if (it != m_cache.end()) {
-            it->second->lastUsedFrameBoundary = m_frameBoundaryCounter;
-            return *it->second;
+            return it->second;
         }
 
         VertexInputStateBuilder builder;
@@ -98,7 +67,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Vector<Uint32> bindingAttributeLocations;
         Vector<Bool> bindingUsesClientMemory;
         Vector<VertexStreamConversion> bindingConversions;
-        Vector<VkVertexInputBindingDivisorDescriptionEXT> bindingDivisors;
         Uint32 unsupportedAttribMask = 0;
 
         for (Uint32 location = 0; location < MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS; ++location) {
@@ -108,9 +76,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
 
             const VkFormat sourceVkFormat =
-                ToVkVertexFormat(attr.Type, attr.Size, attr.Normalized, attr.IsInteger, attr.IsBgra, attr.IsLong);
+                ToVkVertexFormat(attr.Type, attr.Size, attr.Normalized, attr.IsInteger, attr.IsBgra);
             if (sourceVkFormat == VK_FORMAT_UNDEFINED) {
-                MGLOG_E_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);
@@ -125,7 +93,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     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),
@@ -135,7 +103,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);
@@ -146,51 +114,34 @@ 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);
-            // For a client-memory array attr.Offset holds the raw client pointer, and the
-            // draw path re-uploads the data to a 16-aligned transient slice with attribute
-            // offset 0, so only the stride can violate Vulkan's fetch alignment there.
-            const Bool clientMemoryAttribute = attr.Buffer == nullptr;
             if (conversion == VertexStreamConversion::None && requiredAlignment > 1 &&
-                ((sourceStride % requiredAlignment) != 0 ||
-                 (!clientMemoryAttribute && (attr.Offset % requiredAlignment) != 0))) {
+                ((sourceStride % requiredAlignment) != 0 || (attr.Offset % requiredAlignment) != 0)) {
                 // GL accepts arbitrary byte strides and offsets. Core Vulkan vertex fetches do not
                 // unless VK_EXT_legacy_vertex_attributes is available, so deinterleave this one
                 // attribute into a tightly packed transient stream without changing its format.
                 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) {
-                    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;
@@ -204,51 +155,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             bindingConversions.push_back(conversion);
             builder.AddBinding(binding, stride, inputRate);
             builder.AddAttribute(location, binding, vkFormat, 0);
-            // Divisor 1 is what VK_VERTEX_INPUT_RATE_INSTANCE already means; only anything
-            // else needs the extension to say it.
-            if (inputRate == VK_VERTEX_INPUT_RATE_INSTANCE && attr.Divisor != 1) {
-                bindingDivisors.push_back({binding, static_cast<Uint32>(attr.Divisor)});
-            }
         }
 
         const auto& state = builder.Build();
 
-        auto& slot = m_cache[hash];
-        if (!slot) {
-            slot = MakeUnique<BackendVertexInputState>();
-        }
-        BackendVertexInputState& entry = *slot;
+        auto& entry = m_cache[hash];
         entry.hash = hash;
-        entry.lastUsedFrameBoundary = m_frameBoundaryCounter;
-        entry.bindingDivisors = Move(bindingDivisors);
         entry.bindings = builder.GetBindings();
         entry.attributes = builder.GetAttributes();
-        // See the layoutHash declaration: hash only the resolved layout, never
-        // buffer identities, so identical layouts across VAOs/buffers agree.
-        XXHASH_VERIFY(XXH64_reset(m_hashState, 0));
-        for (const auto& binding : entry.bindings) {
-            XXHASH_VERIFY(XXH64_update(m_hashState, &binding.binding, sizeof(binding.binding)));
-            XXHASH_VERIFY(XXH64_update(m_hashState, &binding.stride, sizeof(binding.stride)));
-            XXHASH_VERIFY(XXH64_update(m_hashState, &binding.inputRate, sizeof(binding.inputRate)));
-        }
-        for (const auto& attribute : entry.attributes) {
-            XXHASH_VERIFY(XXH64_update(m_hashState, &attribute.location, sizeof(attribute.location)));
-            XXHASH_VERIFY(XXH64_update(m_hashState, &attribute.binding, sizeof(attribute.binding)));
-            XXHASH_VERIFY(XXH64_update(m_hashState, &attribute.format, sizeof(attribute.format)));
-            XXHASH_VERIFY(XXH64_update(m_hashState, &attribute.offset, sizeof(attribute.offset)));
-        }
-        for (const auto& divisor : entry.bindingDivisors) {
-            XXHASH_VERIFY(XXH64_update(m_hashState, &divisor.binding, sizeof(divisor.binding)));
-            XXHASH_VERIFY(XXH64_update(m_hashState, &divisor.divisor, sizeof(divisor.divisor)));
-        }
-        XXHASH_VERIFY(XXH64_update(m_hashState, &unsupportedAttribMask, sizeof(unsupportedAttribMask)));
-        entry.layoutHash = XXH64_digest(m_hashState);
-        entry.attributeLocationMask = 0;
-        for (const auto& attribute : entry.attributes) {
-            if (attribute.location < 32u) {
-                entry.attributeLocationMask |= (1u << attribute.location);
-            }
-        }
         entry.bindingBufferKeys = std::move(bindingBufferKeys);
         entry.bindingBaseOffsets = std::move(bindingBaseOffsets);
         entry.bindingAttributeLocations = std::move(bindingAttributeLocations);
@@ -258,45 +172,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         entry.state = state;
         entry.state.pVertexBindingDescriptions = entry.bindings.empty() ? nullptr : entry.bindings.data();
         entry.state.pVertexAttributeDescriptions = entry.attributes.empty() ? nullptr : entry.attributes.data();
-        if (!entry.bindingDivisors.empty()) {
-            entry.divisorState.vertexBindingDivisorCount = static_cast<Uint32>(entry.bindingDivisors.size());
-            entry.divisorState.pVertexBindingDivisors = entry.bindingDivisors.data();
-            entry.state.pNext = &entry.divisorState;
-        } else {
-            entry.state.pNext = nullptr;
-        }
         return entry;
     }
 
-    void VertexInputStateFactory::OnFrameBoundary() {
-        ++m_frameBoundaryCounter;
-
-        // Sweep occasionally; evict entries whose last hit is far in the past.
-        // Erasure happens only here, never mid-frame: the draw path holds a
-        // reference into the current entry across its setup, and unordered_map
-        // erase would invalidate it. Entries are CPU-side only, so no GPU-idle
-        // proof is needed; an evicted entry that is used again is simply rebuilt
-        // from the VAO state (same hash, same content).
-        constexpr Uint64 kSweepInterval = 256;
-        constexpr Uint64 kRetireAgeBoundaries = 1024;
-        if ((m_frameBoundaryCounter % kSweepInterval) != 0) {
-            return;
-        }
-
-        for (auto it = m_cache.begin(); it != m_cache.end();) {
-            if (m_frameBoundaryCounter - it->second->lastUsedFrameBoundary > kRetireAgeBoundaries) {
-                it = m_cache.erase(it);
-                // Invalidate every VAO's state-pointer memo: the erased node's
-                // address may be reused by a future insert.
-                ++m_evictionEpoch;
-            } else {
-                ++it;
-            }
-        }
-    }
-
     VkFormat VertexInputStateFactory::ToVkVertexFormat(DataType type, Int size, Bool normalized, Bool isInteger,
-                                                       Bool isBgra, Bool isLong) {
+                                                       Bool isBgra) {
         if (isBgra) {
             // GL_BGRA: four reversed-order components, always normalized (enforced at validation), only
             // legal with GL_UNSIGNED_BYTE or a 2_10_10_10 type. The reversed VkFormats put the
@@ -321,22 +201,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         case DataType::Int2101010Rev:
             if (isInteger || size != 4) return VK_FORMAT_UNDEFINED;
             return normalized ? VK_FORMAT_A2B10G10R10_SNORM_PACK32 : VK_FORMAT_A2B10G10R10_SSCALED_PACK32;
-        case DataType::Float64:
-            // A 64-bit attribute is fetched as its 32-bit word pair and bitcast back to double in the
-            // shader (PackDoubleVertexInputsPass does the shader half). That is bit-exact and, unlike
-            // VK_FORMAT_R64*_SFLOAT, needs no format capability: lavapipe reports bufferFeatures = 0
-            // for every R64 float format, so a native 64-bit vertex fetch is simply unavailable there
-            // while shaderFloat64 is not. Both halves key off nothing but the attribute being long,
-            // so they always agree without extra plumbing.
-            if (!isLong || isInteger || normalized) return VK_FORMAT_UNDEFINED;
-            switch (size) {
-            case 1: return VK_FORMAT_R32G32_UINT;
-            case 2: return VK_FORMAT_R32G32B32A32_UINT;
-            // A dvec3/dvec4 input is 6/8 uint32 components: no single VkFormat, and GL spreads it
-            // over two attribute locations, which the location-per-VAO-index model here does not
-            // express. Declined rather than fetched wrong.
-            default: return VK_FORMAT_UNDEFINED;
-            }
         case DataType::Float32:
             switch (size) {
             case 1: return VK_FORMAT_R32_SFLOAT;

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.h

@@ -27,19 +27,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
         struct BackendVertexInputState {
             HashType hash = 0;
-            // Hash of the resolved Vulkan vertex layout only (bindings, attributes,
-            // unsupported mask) - NO buffer identities. `hash` mixes each bound
-            // buffer's never-reused LIFETIME ID, so per-chunk VBOs mint a fresh
-            // identity per buffer; keying pipelines on that minted one VkPipeline per
-            // chunk section for an identical layout, defeating pipeline reuse and the
-            // per-draw memo. Pipelines depend only on the layout, so they key on this
-            // instead.
-            HashType layoutHash = 0;
-            // Frame boundary of the last cache hit; entries idle past the
-            // OnFrameBoundary retirement age are evicted (CPU heap only).
-            // Mutable: the VAO's state-pointer memo fast path stamps it through
-            // a const entry reference.
-            mutable Uint64 lastUsedFrameBoundary = 0;
             Vector<VkVertexInputBindingDescription> bindings;
             Vector<VkVertexInputAttributeDescription> attributes;
             Vector<SizeT> bindingBufferKeys;
@@ -51,17 +38,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             // absent from `attributes`, so without this mask the draw path cannot tell them apart from
             // a genuinely disabled array and would silently feed the shader the current attribute value.
             Uint32 unsupportedAttribMask = 0;
-            // Bitmask of `attributes[i].location` - the draw path needs it up to
-            // three times per draw, so it is baked once at build time.
-            Uint32 attributeLocationMask = 0;
-            // Per-binding glVertexAttribDivisor values other than 1. Vulkan's instance input
-            // rate advances once per instance and nothing else, so anything else has to be
-            // stated through VK_EXT_vertex_attribute_divisor. Empty when every instanced
-            // binding uses divisor 1, which is what the plain input rate already means.
-            Vector<VkVertexInputBindingDivisorDescriptionEXT> bindingDivisors;
-            VkPipelineVertexInputDivisorStateCreateInfoEXT divisorState{
-                VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT
-            };
             VkPipelineVertexInputStateCreateInfo state{
                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
             };
@@ -72,13 +48,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         ~VertexInputStateFactory() = default;
         VertexInputStateFactory(const VertexInputStateFactory&) = delete;
 
-        // The VAO aux-memo payload GetOrCreateVertexInputState(vao) stamps: aux0 is the
-        // entry's layoutHash, aux1 packs (unsupportedAttribMask << 32) | attributeLocationMask.
-        // Readers that find the aux memo valid can use these without resolving the entry.
-        static Uint64 PackVertexInputAuxMasks(Uint32 unsupportedAttribMask, Uint32 attributeLocationMask) {
-            return (static_cast<Uint64>(unsupportedAttribMask) << 32) | attributeLocationMask;
-        }
-
         HashType ComputeHash(const MG_State::GLState::VertexArrayObject& vao) const;
         // Memoized ComputeHash: reuses the VAO's cached hash while its config version
         // is unchanged. Use this on per-draw paths.
@@ -86,16 +55,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const BackendVertexInputState& GetOrCreateVertexInputState(
             const MG_State::GLState::VertexArrayObject& vao, HashType hash);
         const BackendVertexInputState& GetOrCreateVertexInputState(const MG_State::GLState::VertexArrayObject& vao);
-        // Frame boundary hook: ages the cache and evicts entries not hit for many
-        // frames. The key mixes each bound buffer's never-reused lifetime id, so
-        // buffer/VAO churn keeps minting fresh keys - and does so by construction,
-        // not by luck: a recreated buffer can no longer land back on its dead
-        // predecessor's key. Without eviction the map grows for the whole session.
-        // Entries hold no Vulkan handles (pipeline creation copies the descriptions)
-        // and the draw path's entry reference never spans a frame boundary, so
-        // eviction here needs no GPU-idle proof. Self-gated: one counter bump and
-        // compare except on sweep boundaries.
-        void OnFrameBoundary();
         static SizeT GetComponentSize(DataType type);
         // Tightly-packed byte size of one vertex element for this attribute: componentSize * size for
         // normal types, and 4 (one packed word) for the 2_10_10_10 types and GL_BGRA. Returns 0 for
@@ -103,29 +62,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         static SizeT GetAttributeByteSize(DataType type, Int size, Bool isBgra);
 
     private:
-        static VkFormat ToVkVertexFormat(DataType type, Int size, Bool normalized, Bool isInteger, Bool isBgra = false,
-                                         Bool isLong = false);
+        static VkFormat ToVkVertexFormat(DataType type, Int size, Bool normalized, Bool isInteger, Bool isBgra = false);
         static Bool IsScaledIntegerVertexFormat(VkFormat format);
         static VkFormat ToFloat32VertexFormat(Int componentCount);
         Bool SupportsVertexBufferFormat(VkFormat format) const;
 
         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.
-        UnorderedMap<HashType, UniquePtr<BackendVertexInputState>> m_cache;
-        // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
-        Uint64 m_frameBoundaryCounter = 0;
-        // Bumped whenever any cache entry is erased. VAOs memo a raw pointer to
-        // their heap-allocated entry (stable across map insert/rehash by
-        // construction); a memo is honored only while its recorded epoch
-        // matches, so an evicted entry can never be dereferenced through a
-        // stale memo.
-        Uint64 m_evictionEpoch = 1;
+        UnorderedMap<HashType, BackendVertexInputState> m_cache;
         static inline XXH64_state_t* m_hashState = XXH64_createState();
     };
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.cpp

@@ -7,8 +7,6 @@
 // End of Source File Header
 
 #include "VkBufferManager.h"
-#include "../DirectVulkan.h"
-#include "VulkanRenderer.h"
 
 namespace MobileGL::MG_Backend::DirectVulkan {
     namespace {
@@ -23,15 +21,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;
-        // Appended to kPersistentBackedUsage when VK_EXT_transform_feedback is enabled
-        // (see VkBufferManagerInitInfo::transformFeedbackUsageEnabled).
-        constexpr VkBufferUsageFlags kTransformFeedbackUsage =
-            VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
+            VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
         // The app writes into the persistent map with no explicit flush, so its memory must
         // be host-coherent (Adreno host-visible memory is; requiring it keeps us portable).
         constexpr VkMemoryPropertyFlags kPersistentBackedRequiredFlags =
@@ -63,18 +53,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         }
 
-        // The CPU is about to read a buffer a shader wrote. Its bytes live in coherent
-        // host-visible GPU storage (EnsureGpuResidentStorage adopts it when the buffer is
-        // bound as a shader storage buffer), so nothing needs copying - but coherence only
-        // says the writes are visible once they have happened, so the work has to retire
-        // first.
-        void Ops_ReadbackFromGpu(BufferObject& bufferObject) {
-            (void)bufferObject;
-            if (pVulkanRenderer) {
-                pVulkanRenderer->FinishPendingGpuWork();
-            }
-        }
-
         void* Ops_AcquirePersistentMap(BufferObject& bufferObject) {
             if (g_activeBufferManager) {
                 return g_activeBufferManager->AcquirePersistentMap(bufferObject);
@@ -98,7 +76,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             .FlushMappedRange = Ops_FlushMappedRange,
             .OnDestroy = Ops_OnDestroy,
             .AcquirePersistentMap = Ops_AcquirePersistentMap,
-            .ReadbackFromGpu = Ops_ReadbackFromGpu,
         };
     } // namespace
 
@@ -164,26 +141,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_transientUploadArena.BeginFrame(frameIndex);
     }
 
-    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);
-        }
-    }
-
     void VkBufferManager::NotifyDeviceIdle() {
         // Everything submitted so far has completed. Work recorded for the
         // current frame has not been submitted yet, so the current serial
@@ -257,15 +214,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     void VkBufferManager::TrackLiveResource(const SharedPtr<VkBufferResource>& resource) {
-        // Sweep on a doubling watermark rather than on every insert past the threshold. The old
-        // form walked the whole vector for each new buffer once the list passed 256, and when the
-        // buffers are all live the walk removes nothing and the list grows by one - so creating N
-        // live buffers cost ~N^2/2 expired() checks. Reclamation semantics are unchanged: the sweep
-        // still removes exactly the expired entries, just less often and with the same bound on how
-        // much dead weight can accumulate (at most as many entries as were live at the last sweep).
-        if (m_liveResources.size() >= std::max<SizeT>(kLiveResourcePruneThreshold, 2 * m_liveResourcesLastPruned)) {
+        if (m_liveResources.size() >= kLiveResourcePruneThreshold) {
             std::erase_if(m_liveResources, [](const WeakPtr<VkBufferResource>& weak) { return weak.expired(); });
-            m_liveResourcesLastPruned = m_liveResources.size();
         }
         m_liveResources.push_back(resource);
     }
@@ -273,7 +223,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void VkBufferManager::ReleaseAllLiveResources() {
         for (auto& weak : m_liveResources) {
             if (auto resource = weak.lock()) {
-                BumpSliceEpoch(*resource);
                 resource->buffer.Destroy();
                 resource->storageSize = 0;
                 resource->usageFlags = 0;
@@ -288,9 +237,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
 
     Bool VkBufferManager::CreateResidentStorage(VkBufferResource& resource, VkDeviceSize size,
                                                 VkBufferUsageFlags usage, VkMemoryPropertyFlags requiredFlags) {
-        // The only place a resident VkBuffer handle is minted, so every resident slice
-        // change funnels through here (callers release the old handle first).
-        BumpSliceEpoch(resource);
         // Staged range copies write resident storage with vkCmdCopyBuffer.
         usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
         const Bool created = resource.buffer.Create({
@@ -302,7 +248,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;
@@ -324,7 +270,7 @@ 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;
         }
@@ -377,18 +323,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (!resource) {
             return; // lazy: AcquireResidentSlice performs a full upload on creation
         }
-        // A respecify can change the size, the usage hint (so the resident/streamed
-        // route), and the contents at once; retire every memo before deciding what to
-        // do about the storage.
-        BumpSliceEpoch(*resource);
         // Any cached streaming slice refers to the previous contents.
         resource->transientFrameSerial = 0;
-        // 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
         }
@@ -409,7 +345,7 @@ 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;
         }
     }
@@ -419,9 +355,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (!resource) {
             return;
         }
-        // Drops the streaming memo below and may end in a storage swap or a deferred
-        // full re-upload, so no memoised slice survives this.
-        BumpSliceEpoch(*resource);
         resource->transientFrameSerial = 0;
         if (!resource->buffer.IsValid() || resource->pendingFullUpload) {
             return;
@@ -434,7 +367,7 @@ 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;
             }
             return;
@@ -454,7 +387,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (!resource) {
             return;
         }
-        BumpSliceEpoch(*resource);
         resource->transientFrameSerial = 0;
         if (!resource->buffer.IsValid() || resource->pendingFullUpload) {
             return;
@@ -471,7 +403,7 @@ 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;
             }
             return;
@@ -514,13 +446,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             TrackLiveResource(resource);
         }
 
-        // Bumped for the request, not just for the storage it may create. This is the
-        // one call the frontend makes when a buffer becomes persistently mapped for
-        // writing (BufferObject::AcquireMemoryRange), and a map the backend declines
-        // keeps mutating its shadow with no further API call - so it is what lets
-        // GetSliceEpochCounter stand for "no buffer needs a persistent-map range push".
-        BumpSliceEpoch(*resource);
-
         // Idempotent: an already-backed buffer returns the same mapped base.
         if (resource->persistentMapped && resource->buffer.IsValid() && resource->storageSize == size) {
             return resource->buffer.GetMappedData();
@@ -531,10 +456,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // it from the current shadow - MappedData() is still the shadow here because the
         // frontend adopts (and drops) the shadow only after this returns.
         DeferRelease(std::move(resource->buffer));
-        const VkBufferUsageFlags persistentUsage =
-            kPersistentBackedUsage |
-            (m_initInfo.transformFeedbackUsageEnabled ? kTransformFeedbackUsage : 0);
-        if (!CreateResidentStorage(*resource, size, persistentUsage, kPersistentBackedRequiredFlags)) {
+        if (!CreateResidentStorage(*resource, size, kPersistentBackedUsage, kPersistentBackedRequiredFlags)) {
             resource->persistentMapped = false;
             resource->storageSize = 0;
             resource->usageFlags = 0;
@@ -563,7 +485,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;
         }
 
@@ -585,7 +507,7 @@ 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;
@@ -608,19 +530,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         auto resource = GetOrCreateResource(bufferObject);
         bufferObject->SyncPersistentMappedRange();
 
-        // A persistently mapped resource's storage IS the application's copy of the bytes -
-        // the frontend adopted it in place of the shadow and hands out pointers into it, and
-        // a shader can have written bytes the shadow never saw (a transform feedback
-        // capture). Streaming a second copy would feed this draw the stale shadow, and the
-        // downgrade below would release the storage the application still points at,
-        // breaking the "never recreated" promise AcquirePersistentMap makes.
-        if (resource->persistentMapped) {
-            return AcquireResidentSlice(kind, bufferObject, outSlice);
-        }
-
         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;
         }
 
@@ -631,41 +543,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return true;
         }
 
-        // Idle-content promotion: see the field comments in VkBufferResource. The
-        // streak counts frame BOUNDARIES survived unchanged (the same-frame memo
-        // above swallows repeat draws), so a promotion needs the content stable
-        // for kStreamedPromotionStreak whole frames - one no-op frame does not
-        // trigger the resident round-trip, whose creation upload is itself a
-        // staged copy worth avoiding for content that is about to change again.
-        constexpr Uint32 kStreamedPromotionStreak = 2;
-        if (resource->promotedResident) {
-            if (resource->promotedChangeSerial == changeSerial &&
-                static_cast<VkDeviceSize>(bufferObject->GetSize()) == size) {
-                return AcquireResidentSlice(kind, bufferObject, outSlice);
-            }
-            resource->promotedResident = false;
-            resource->unchangedStreak = 0;
-        } else if (resource->transientChangeSerial == changeSerial && resource->transientSize == size &&
-                   resource->transientFrameSerial != 0) {
-            if (++resource->unchangedStreak >= kStreamedPromotionStreak) {
-                // Promotion moves the buffer off the arena and onto resident storage.
-                resource->promotedResident = true;
-                resource->promotedChangeSerial = changeSerial;
-                BumpSliceEpoch(*resource);
-                if (AcquireResidentSlice(kind, bufferObject, outSlice)) {
-                    return true;
-                }
-                resource->promotedResident = false; // resident creation failed: stream as before
-            }
-        } else {
-            resource->unchangedStreak = 0;
-        }
-
-        // A fresh arena allocation: a different slice than the last call handed back,
-        // and (below) the point where a promoted buffer's resident storage is released.
-        // The stable-promotion exit above returns before this, so a buffer the app has
-        // stopped touching keeps one slice for as long as it keeps its resident storage.
-        BumpSliceEpoch(*resource);
         if (!m_transientUploadArena.Upload(m_currentFrameIndex, bufferObject->MappedData(), size, 16,
                                            outSlice)) {
             return false;
@@ -718,13 +595,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

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

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferObject.cpp

@@ -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,10 +170,22 @@ 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;
     }
 
+    BufferSlice VkBufferObject::GetSlice(VkDeviceSize offset, VkDeviceSize size) const {
+        MOBILEGL_ASSERT(offset <= m_size, "VkBufferObject::GetSlice offset out of range");
+        const VkDeviceSize resolvedSize = (size == VK_WHOLE_SIZE) ? (m_size - offset) : size;
+        MOBILEGL_ASSERT(offset + resolvedSize <= m_size, "VkBufferObject::GetSlice range out of bounds");
+
+        BufferSlice slice{};
+        slice.buffer = m_buffer;
+        slice.offset = offset;
+        slice.size = resolvedSize;
+        slice.mapped = (m_mappedData != nullptr) ? static_cast<Uint8*>(m_mappedData) + offset : nullptr;
+        return slice;
+    }
 } // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferObject.h

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

MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.cpp

@@ -8,75 +8,15 @@
 
 #include "VkClearManager.h"
 
-#include "MG_State/GLState/Core.h"
 #include "MG_Util/Converters/MGToStr/FramebufferEnumConverter.h"
 #include "MG_Util/Converters/MGToStr/TextureEnumConverter.h"
 
-#include <algorithm>
-#include <cmath>
-
 namespace MobileGL::MG_Backend::DirectVulkan {
     static Bool IsCubeMapFaceUploadTarget(TextureUploadTarget target) {
         return target >= TextureUploadTarget::CubeMapPositiveX &&
                target <= TextureUploadTarget::CubeMapNegativeZ;
     }
 
-    VkClearColorValue MakeVkClearColorValue(const ClearAttachmentPayload& payload, Bool formatLacksAlpha) {
-        VkClearColorValue clearValue{};
-        switch (payload.colorEncoding) {
-        case ClearColorEncoding::Int:
-            clearValue.int32[0] = payload.colorInt.x();
-            clearValue.int32[1] = payload.colorInt.y();
-            clearValue.int32[2] = payload.colorInt.z();
-            clearValue.int32[3] = formatLacksAlpha ? 1 : payload.colorInt.w();
-            break;
-        case ClearColorEncoding::Uint:
-            clearValue.uint32[0] = payload.colorUint.x();
-            clearValue.uint32[1] = payload.colorUint.y();
-            clearValue.uint32[2] = payload.colorUint.z();
-            clearValue.uint32[3] = formatLacksAlpha ? 1u : payload.colorUint.w();
-            break;
-        case ClearColorEncoding::Float:
-            clearValue.float32[0] = payload.color.x();
-            clearValue.float32[1] = payload.color.y();
-            clearValue.float32[2] = payload.color.z();
-            clearValue.float32[3] = formatLacksAlpha ? 1.0f : payload.color.w();
-            break;
-        }
-        return clearValue;
-    }
-
-    void PreCompensateSrgbClearColor(ClearAttachmentPayload& payload, VkFormat destinationFormat) {
-        if (payload.colorEncoding != ClearColorEncoding::Float) return;
-        // With GL_FRAMEBUFFER_SRGB enabled GL performs the encoding itself, so the driver doing it
-        // is exactly right and there is nothing to undo.
-        if (MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb)) return;
-        if (ResolveSrgbAttachmentWriteFormat(destinationFormat, false) == destinationFormat) return;
-
-        // sRGB -> linear (GL 4.6 core 8.24), applied to the colour channels only: alpha is stored
-        // linearly in an sRGB format and must pass through untouched.
-        const auto toLinear = [](Float encoded) {
-            const Float value = std::clamp(encoded, 0.0f, 1.0f);
-            return value <= 0.04045f ? value / 12.92f : std::pow((value + 0.055f) / 1.055f, 2.4f);
-        };
-        payload.color = FloatVec4(toLinear(payload.color.x()), toLinear(payload.color.y()),
-                                  toLinear(payload.color.z()), payload.color.w());
-    }
-
-    void ForceOpaqueClearAlpha(ClearAttachmentPayload& payload) {
-        switch (payload.colorEncoding) {
-        case ClearColorEncoding::Int:
-            payload.colorInt = IntVec4(payload.colorInt.x(), payload.colorInt.y(), payload.colorInt.z(), 1);
-            break;
-        case ClearColorEncoding::Uint:
-            payload.colorUint = UintVec4(payload.colorUint.x(), payload.colorUint.y(), payload.colorUint.z(), 1u);
-            break;
-        case ClearColorEncoding::Float:
-            payload.color = FloatVec4(payload.color.x(), payload.color.y(), payload.color.z(), 1.0f);
-            break;
-        }
-    }
-
     static Bool PendingClearMatchesTextureIdentity(const PendingClearKey& key, const TextureIdentity& identity) {
         return key.texture == identity.texture && key.textureLifetimeId == identity.lifetimeId;
     }
@@ -153,7 +93,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         const std::lock_guard<std::mutex> lock(m_mutex);
         m_pendingClears.clear();
         m_aliveObjects.clear();
-        m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
     }
 
     TextureIdentity VkClearManager::MakeTextureIdentity(MG_State::GLState::ITextureObject* texture) {
@@ -188,7 +127,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_pendingClears.erase(key);
         }
         m_aliveObjects.erase(identity);
-        m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
     }
 
     Bool VkClearManager::LockTextureIdentityLocked(const TextureIdentity& identity,
@@ -283,7 +221,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_aliveObjects[MakeTextureIdentity(texture.get())] = texture;
         auto& pending = m_pendingClears[key];
         MergeClearPayload(pending, clearPayload);
-        m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
     }
 
     void VkClearManager::QueueClear(const ClearAttachmentPayload& clearPayload,
@@ -301,7 +238,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_aliveObjects[MakeTextureIdentity(texture.get())] = texture;
         auto& pending = m_pendingClears[key];
         MergeClearPayload(pending, clearPayload);
-        m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
     }
 
     Bool VkClearManager::HasPendingClear(MG_State::GLState::ITextureObject* texture) {
@@ -309,10 +245,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return false;
         }
 
-        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
-            return false;  // per-draw hot path: nothing pending anywhere
-        }
-
         const Uint64 lifetimeId = texture->GetLifetimeId();
         const std::lock_guard<std::mutex> lock(m_mutex);
         for (auto it = m_pendingClears.begin(); it != m_pendingClears.end(); ++it) {
@@ -328,9 +260,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (key.texture == nullptr) {
             return false;
         }
-        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
-            return false;  // per-draw hot path: nothing pending anywhere
-        }
 
         const std::lock_guard<std::mutex> lock(m_mutex);
         if (m_pendingClears.find(key) == m_pendingClears.end()) {
@@ -358,9 +287,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (key.texture == nullptr) {
             return false;
         }
-        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
-            return false;  // per-draw hot path: nothing pending anywhere
-        }
 
         const std::lock_guard<std::mutex> lock(m_mutex);
         if (!LockTextureLocked(key, outTexture)) {
@@ -399,9 +325,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (texture == nullptr) {
             return false;
         }
-        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
-            return false;  // per-draw hot path: nothing pending anywhere
-        }
 
         const Uint64 lifetimeId = texture->GetLifetimeId();
         const std::lock_guard<std::mutex> lock(m_mutex);
@@ -422,9 +345,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return;
         }
 
-        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
-            return;  // per-draw hot path: nothing pending anywhere
-        }
         const TextureIdentity identity = MakeTextureIdentity(texture);
         MGLOG_D("%s: Pop all pending clears for texture %d", __func__, texture->GetExternalIndex());
         const std::lock_guard<std::mutex> lock(m_mutex);
@@ -441,7 +361,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             auto it = m_pendingClears.find(key);
             if (it != m_pendingClears.end()) {
                 m_pendingClears.erase(it);
-            m_pendingCount.store(static_cast<Uint32>(m_pendingClears.size()), std::memory_order_relaxed);
             }
         }
 

MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.h

@@ -14,7 +14,6 @@
 #include "MG_Util/Math/VectorTypes.h"
 
 #include <Includes.h>
-#include <atomic>
 #include <unordered_map>
 
 namespace MobileGL::MG_Backend::DirectVulkan {
@@ -24,41 +23,13 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint32 stencil{};
     };
 
-    // A colour clear reaches us from one of glClear/ClearBufferfv, ClearBufferiv or
-    // ClearBufferuiv, and Vulkan reads VkClearColorValue's union according to the destination
-    // image's format rather than converting between the members - a float written where an
-    // integer format is expected is reinterpreted bit for bit, not rounded. Remember which entry
-    // point supplied the value so the member written when the clear is materialized matches.
-    enum class ClearColorEncoding : Uint8 { Float, Int, Uint };
-
     struct ClearAttachmentPayload {
         GLbitfield mask = 0;
         FloatVec4 color = FloatVec4(0.0f, 0.0f, 0.0f, 0.0f);
-        ClearColorEncoding colorEncoding = ClearColorEncoding::Float;
-        IntVec4 colorInt = IntVec4(0, 0, 0, 0);
-        UintVec4 colorUint = UintVec4(0u, 0u, 0u, 0u);
         Float depth = 1.0f;
         Uint32 stencil = 0;
     };
 
-    // Builds the clear value for `payload` in the union member its encoding calls for.
-    // `formatLacksAlpha` applies GL's rule that a format without an alpha channel reads as one,
-    // expressed in whichever type matches (GL 4.6 core 15.2.3).
-    VkClearColorValue MakeVkClearColorValue(const ClearAttachmentPayload& payload, Bool formatLacksAlpha);
-
-    // Applies that same rule in place, for the paths that have to bake it into the payload before
-    // the destination is known.
-    void ForceOpaqueClearAlpha(ClearAttachmentPayload& payload);
-
-    // vkCmdClearColorImage names the image, so the driver applies the destination format's transfer
-    // function to whatever value it is handed. Every other write path in this backend goes through
-    // the UNORM twin view while GL_FRAMEBUFFER_SRGB is off (ResolveSrgbAttachmentWriteFormat) and
-    // therefore stores the raw value GL asked for. Rewrites `payload` to the linear colour whose
-    // encoding is that raw value, so a direct image clear of an sRGB destination agrees with them.
-    // A no-op for every other format, for integer clear encodings, and when GL is doing the
-    // encoding itself.
-    void PreCompensateSrgbClearColor(ClearAttachmentPayload& payload, VkFormat destinationFormat);
-
     struct PendingClearKey {
         MG_State::GLState::ITextureObject* texture = nullptr;
         Uint64 textureLifetimeId = 0;
@@ -149,19 +120,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                SharedPtr<MG_State::GLState::ITextureObject>& outTexture);
 
         Uint8 m_gcCounter = 0;
-    public:
-        // Lock-free probe for the consecutive-draw fast path: any pending clear
-        // forces the full SetupDraw path (which materializes/consumes it).
-        Bool HasAnyPendingClears() const { return m_pendingCount.load(std::memory_order_relaxed) != 0; }
-
-    private:
         mutable std::mutex m_mutex;
-        // Lock-free mirror of m_pendingClears.size(), maintained under m_mutex
-        // by every mutation. The per-draw probes (HasPendingClear/GetPending*)
-        // read it before taking the lock: during draw batches the pending set
-        // is almost always empty, so this turns several locked map probes per
-        // draw into one relaxed load.
-        std::atomic<Uint32> m_pendingCount{0};
         std::unordered_map<PendingClearKey, ClearAttachmentPayload, PendingClearKeyHash> m_pendingClears;
         std::unordered_map<TextureIdentity, WeakPtr<MG_State::GLState::ITextureObject>, TextureIdentityHash> m_aliveObjects;
     };

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.cpp

@@ -16,21 +16,31 @@
 
 namespace MobileGL::MG_Backend::DirectVulkan {
     static Bool TryResolveSampleCountFlagBits(Int requestedSamples, VkSampleCountFlagBits& outSampleCount) {
-        // GL promises "at least the requested samples", so a non-power-of-two
-        // request (legal in GL, e.g. 3) rounds up to the next Vulkan bit.
-        if (requestedSamples <= 1) {
+        switch (requestedSamples <= 0 ? 1 : requestedSamples) {
+        case 1:
             outSampleCount = VK_SAMPLE_COUNT_1_BIT;
             return true;
-        }
-        if (requestedSamples > 64) {
+        case 2:
+            outSampleCount = VK_SAMPLE_COUNT_2_BIT;
+            return true;
+        case 4:
+            outSampleCount = VK_SAMPLE_COUNT_4_BIT;
+            return true;
+        case 8:
+            outSampleCount = VK_SAMPLE_COUNT_8_BIT;
+            return true;
+        case 16:
+            outSampleCount = VK_SAMPLE_COUNT_16_BIT;
+            return true;
+        case 32:
+            outSampleCount = VK_SAMPLE_COUNT_32_BIT;
+            return true;
+        case 64:
+            outSampleCount = VK_SAMPLE_COUNT_64_BIT;
+            return true;
+        default:
             return false;
         }
-        Uint32 bit = 1;
-        while (bit < static_cast<Uint32>(requestedSamples)) {
-            bit <<= 1;
-        }
-        outSampleCount = static_cast<VkSampleCountFlagBits>(bit);
-        return true;
     }
 
     static VkImageAspectFlags ResolveImageAspectMaskForFormat(VkFormat format) {
@@ -50,11 +60,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
     }
 
-    static Bool ColorFormatLacksAlpha(const MG_State::GLState::ITextureObject* texture) {
-        return texture != nullptr && MG_Util::GetBaseInternalFormatComponentCount(texture->GetFormat()) == 3;
-    }
-
-    [[maybe_unused]] static Float ResolveColorClearAlpha(const MG_State::GLState::ITextureObject* texture, Float requestedAlpha) {
+    static Float ResolveColorClearAlpha(const MG_State::GLState::ITextureObject* texture, Float requestedAlpha) {
         if (texture != nullptr && MG_Util::GetBaseInternalFormatComponentCount(texture->GetFormat()) == 3) {
             return 1.0f;
         }
@@ -87,20 +93,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     static VkImageViewType ResolveAttachmentViewType(
         const MG_State::GLState::FramebufferAttachmentObject& attachment,
         const VkTextureManager::TextureResource& resource) {
-        if (attachment.IsLayered()) {
-            return resource.viewType;
-        }
-        // A non-layered attachment names ONE layer, so the view over it is a plain 2D view whatever
-        // the image's own view type is. The cube-face upload targets always meant this; a cube map
-        // array attached through glFramebufferTextureLayer means it too, and a CUBE_ARRAY view over
-        // a single layer is not a legal attachment. The CUBE arm is inert today - no frontend path
-        // produces a non-layered cube attachment without a face upload target - and is kept for
-        // symmetry with CUBE_ARRAY.
-        if (IsCubeMapFaceUploadTarget(attachment.GetTextureUploadTarget()) ||
-            resource.viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY || resource.viewType == VK_IMAGE_VIEW_TYPE_CUBE) {
-            return VK_IMAGE_VIEW_TYPE_2D;
-        }
-        return resource.viewType;
+        return !attachment.IsLayered() && IsCubeMapFaceUploadTarget(attachment.GetTextureUploadTarget()) ?
+            VK_IMAGE_VIEW_TYPE_2D :
+            resource.viewType;
     }
 
     static MG_State::GLState::ITextureObject* ResolveCompleteColorAttachmentTexture(
@@ -123,7 +118,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());
@@ -132,7 +127,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());
@@ -171,9 +166,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         if (view != VK_NULL_HANDLE) {
             vkDestroyImageView(device, view, nullptr);
         }
-        if (unormTwinView != VK_NULL_HANDLE) {
-            vkDestroyImageView(device, unormTwinView, nullptr);
-        }
         if (image != VK_NULL_HANDLE && allocation != nullptr) {
             vmaDestroyImage(allocator, image, allocation);
         }
@@ -181,7 +173,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         image = VK_NULL_HANDLE;
         allocation = nullptr;
         view = VK_NULL_HANDLE;
-        unormTwinView = VK_NULL_HANDLE;
         layout = VK_IMAGE_LAYOUT_UNDEFINED;
         format = VK_FORMAT_UNDEFINED;
         aspect = VK_IMAGE_ASPECT_NONE;
@@ -189,7 +180,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         sampleCount = VK_SAMPLE_COUNT_1_BIT;
         internalFormat = TextureInternalFormat::Unknown;
         samples = 0;
-        deadSinceFrame = kNeverObservedDead;
     }
 
     VkRenderPassManager::VkRenderPassManager(VkDevice device,
@@ -216,7 +206,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             resource.Destroy(m_device, m_allocator);
         }
         m_renderbufferResources.clear();
-        CollectDeferredRenderbufferReleases(/*destroyAll=*/true); // caller guarantees device idle
         m_pendingRenderbufferClears.clear();
         RenderPassEntry::s_textureResourcesScratch.clear();
         s_activeRenderPass = {};
@@ -224,80 +213,22 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         m_rpFastValid = false;
     }
 
-    Uint64 VkRenderPassManager::RetireAgeFrames() const {
-        // MaxFramesInFlight + 2 covers the frame ring plus one boundary for the
-        // recording-to-submit gap and one because OnPresent runs ahead of Present's
-        // fence wait; the floor of 8 keeps a margin over the default ring of 3 while
-        // still releasing multi-MB attachment memory promptly (the render-pass cache's
-        // 1024-frame retirement would pin it for no additional safety).
-        return std::max<Uint64>(8, static_cast<Uint64>(m_config.MaxFramesInFlight) + 2);
-    }
-
-    void VkRenderPassManager::DeferRenderbufferBackingRelease(RenderbufferResource& resource) {
-        // The superseded backing may still be referenced by in-flight command buffers
-        // (glRenderbufferStorage can respecify a renderbuffer drawn this very frame),
-        // so it is parked and destroyed only after RetireAgeFrames() boundaries.
-        if (resource.image == VK_NULL_HANDLE && resource.view == VK_NULL_HANDLE) {
-            return;
-        }
-        m_deferredRenderbufferReleases.push_back(
-            {resource.image, resource.allocation, resource.view, resource.unormTwinView, m_frameCounter});
-        resource.image = VK_NULL_HANDLE;
-        resource.allocation = nullptr;
-        resource.view = VK_NULL_HANDLE;
-        resource.unormTwinView = VK_NULL_HANDLE;
-    }
-
-    void VkRenderPassManager::CollectDeferredRenderbufferReleases(Bool destroyAll) {
-        if (m_deferredRenderbufferReleases.empty()) {
-            return;
-        }
-        const Uint64 retireAgeFrames = RetireAgeFrames();
-        std::erase_if(m_deferredRenderbufferReleases, [&](DeferredRenderbufferRelease& release) {
-            if (!destroyAll && m_frameCounter - release.deferredAtFrame < retireAgeFrames) {
-                return false;
-            }
-            if (release.view != VK_NULL_HANDLE) {
-                vkDestroyImageView(m_device, release.view, nullptr);
-            }
-            if (release.unormTwinView != VK_NULL_HANDLE) {
-                vkDestroyImageView(m_device, release.unormTwinView, nullptr);
-            }
-            if (release.image != VK_NULL_HANDLE) {
-                vmaDestroyImage(m_allocator, release.image, release.allocation);
-            }
-            return true;
-        });
-    }
-
     void VkRenderPassManager::CollectRenderbufferGarbage() {
-        // Two-phase reclamation: a dead renderbuffer's VkImage may still be referenced by
-        // command buffers submitted up to frames-in-flight frames ago (it was legally
-        // attached and drawn right up to its deletion), so the first observation of an
-        // expired weak reference only stamps the current frame counter; Destroy runs once
-        // enough frame boundaries have passed that the stamping frame's submission fence
-        // has provably been waited (see RetireAgeFrames).
-        const Uint64 retireAgeFrames = RetireAgeFrames();
-        for (auto it = m_renderbufferResources.begin(); it != m_renderbufferResources.end();) {
-            auto& resource = it->second;
+        Vector<MG_State::GLState::RenderbufferObject*> deadRenderbuffers;
+        deadRenderbuffers.reserve(m_renderbufferResources.size());
+        for (auto& [renderbuffer, resource] : m_renderbufferResources) {
             const auto liveRenderbuffer = resource.renderbuffer.lock();
-            if (liveRenderbuffer && liveRenderbuffer.get() == it->first) {
-                resource.deadSinceFrame = RenderbufferResource::kNeverObservedDead;
-                ++it;
-                continue;
+            if (!liveRenderbuffer || liveRenderbuffer.get() != renderbuffer) {
+                deadRenderbuffers.emplace_back(renderbuffer);
             }
-            if (resource.deadSinceFrame == RenderbufferResource::kNeverObservedDead) {
-                resource.deadSinceFrame = m_frameCounter;
-                ++it;
-                continue;
+        }
+        for (auto* renderbuffer : deadRenderbuffers) {
+            auto resourceIt = m_renderbufferResources.find(renderbuffer);
+            if (resourceIt != m_renderbufferResources.end()) {
+                resourceIt->second.Destroy(m_device, m_allocator);
+                m_renderbufferResources.erase(resourceIt);
             }
-            if (m_frameCounter - resource.deadSinceFrame < retireAgeFrames) {
-                ++it;
-                continue;
-            }
-            m_pendingRenderbufferClears.erase(it->first);
-            resource.Destroy(m_device, m_allocator);
-            it = m_renderbufferResources.erase(it);
+            m_pendingRenderbufferClears.erase(renderbuffer);
         }
     }
 
@@ -311,101 +242,19 @@ 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();
-        // 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 VkFormat format = 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),
-        // BlitFramebuffer, CopyTexImage sources, and out-of-render-pass clear materialization.
-        const VkImageUsageFlags imageUsage =
-            ((aspect & VK_IMAGE_ASPECT_COLOR_BIT) != 0 ? VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
-                                                       : VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) |
-            VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-
-        // GL allows the implementation to allocate more samples than requested
-        // (glRenderbufferStorageMultisample only promises "at least"), and devices
-        // like llvmpipe expose 1x/4x but not 2x. Round the request up to the
-        // nearest supported count for this format.
-        if (renderbuffer->GetSamples() > 0) {
-            auto supportedIt = m_attachmentSampleCountsByFormat.find(format);
-            if (supportedIt == m_attachmentSampleCountsByFormat.end()) {
-                VkImageFormatProperties formatProperties{};
-                VkSampleCountFlags supported = VK_SAMPLE_COUNT_1_BIT;
-                if (vkGetPhysicalDeviceImageFormatProperties(m_physicalDevice, format, VK_IMAGE_TYPE_2D,
-                                                             VK_IMAGE_TILING_OPTIMAL, imageUsage, 0,
-                                                             &formatProperties) == VK_SUCCESS) {
-                    supported = formatProperties.sampleCounts;
-                }
-                supportedIt = m_attachmentSampleCountsByFormat.emplace(format, supported).first;
-            }
-            const VkSampleCountFlags supported = supportedIt->second;
-            if ((supported & sampleCount) == 0) {
-                // Smallest supported count above the request, else the largest below it.
-                Uint32 rounded = 0;
-                for (Uint32 bit = static_cast<Uint32>(sampleCount) << 1; bit <= VK_SAMPLE_COUNT_64_BIT; bit <<= 1) {
-                    if ((supported & bit) != 0) {
-                        rounded = bit;
-                        break;
-                    }
-                }
-                if (rounded == 0) {
-                    for (Uint32 bit = static_cast<Uint32>(sampleCount) >> 1; bit != 0; bit >>= 1) {
-                        if ((supported & bit) != 0) {
-                            rounded = bit;
-                            break;
-                        }
-                    }
-                }
-                if (rounded != 0) {
-                    sampleCount = static_cast<VkSampleCountFlagBits>(rounded);
-                }
-            }
+        if ((aspect & VK_IMAGE_ASPECT_COLOR_BIT) != 0) {
+            MGLOG_E("GetOrCreateRenderbufferResource: color renderbuffer %u is not supported by DirectVulkan render passes yet",
+                    renderbuffer->GetExternalIndex());
+            return nullptr;
         }
 
         auto& resource = m_renderbufferResources[renderbuffer.get()];
@@ -419,15 +268,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             resource.samples != renderbuffer->GetSamples();
         if (!needsCreate) {
             resource.renderbuffer = renderbuffer;
-            // A new renderbuffer at a recycled address may adopt a compatible entry that
-            // was already stamped dead; it is alive again, so cancel the aging.
-            resource.deadSinceFrame = RenderbufferResource::kNeverObservedDead;
             return &resource;
         }
 
-        // Respecify: park the old backing for aged destruction instead of destroying
-        // inline - it may still be referenced by in-flight command buffers.
-        DeferRenderbufferBackingRelease(resource);
         resource.Destroy(m_device, m_allocator);
         resource.renderbuffer = renderbuffer;
 
@@ -442,22 +285,16 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         imageInfo.format = format;
         imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
         imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-        imageInfo.usage = imageUsage;
+        imageInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
         imageInfo.samples = sampleCount;
         imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-        // sRGB renderbuffers attach through their UNORM twin while GL_FRAMEBUFFER_SRGB
-        // is disabled, which needs a format-reinterpreting second view.
-        const Bool hasUnormTwin = ResolveSrgbAttachmentWriteFormat(format, false) != format;
-        if (hasUnormTwin) {
-            imageInfo.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
-        }
 
         VkImageFormatProperties imageFormatProperties{};
         const VkResult imageFormatResult = vkGetPhysicalDeviceImageFormatProperties(
             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());
@@ -485,11 +322,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         viewInfo.subresourceRange.layerCount = 1;
         VK_VERIFY(vkCreateImageView(m_device, &viewInfo, nullptr, &resource.view),
                   "vkCreateImageView(renderbuffer)");
-        if (hasUnormTwin) {
-            viewInfo.format = ResolveSrgbAttachmentWriteFormat(format, false);
-            VK_VERIFY(vkCreateImageView(m_device, &viewInfo, nullptr, &resource.unormTwinView),
-                      "vkCreateImageView(renderbuffer unorm twin)");
-        }
 
         resource.layout = VK_IMAGE_LAYOUT_UNDEFINED;
         resource.format = format;
@@ -541,13 +373,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         pending.renderbuffer = renderbuffer;
         pending.payload.mask |= clearPayload.mask;
         if ((clearPayload.mask & GL_COLOR_BUFFER_BIT) != 0) {
-            // The whole colour description, not just the float vector: an integer clear keeps its
-            // value in colorInt/colorUint, and dropping the encoding here would leave the pending
-            // clear reading as an all-zero float one.
             pending.payload.color = clearPayload.color;
-            pending.payload.colorEncoding = clearPayload.colorEncoding;
-            pending.payload.colorInt = clearPayload.colorInt;
-            pending.payload.colorUint = clearPayload.colorUint;
         }
         if ((clearPayload.mask & GL_DEPTH_BUFFER_BIT) != 0) {
             pending.payload.depth = clearPayload.depth;
@@ -560,18 +386,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void VkRenderPassManager::QueueRenderbufferClear(
         GLbitfield mask, const ClearFramebufferPayload& clearPayload,
         const MG_State::GLState::FramebufferObject& drawFbo) {
-        if ((mask & GL_COLOR_BUFFER_BIT) != 0) {
-            // Color renderbuffer draw buffers take the framebuffer-level clear too; texture
-            // attachments are skipped by the per-attachment overload's IsRenderbuffer guard.
-            for (const auto attachmentType : drawFbo.GetDrawBuffers()) {
-                if (attachmentType == FramebufferAttachmentType::None) {
-                    continue;
-                }
-                QueueRenderbufferClear(
-                    ClearAttachmentPayload{.mask = GL_COLOR_BUFFER_BIT, .color = clearPayload.color},
-                    drawFbo.GetAttachment(attachmentType));
-            }
-        }
         if ((mask & GL_DEPTH_BUFFER_BIT) != 0) {
             QueueRenderbufferClear(
                 ClearAttachmentPayload{.mask = GL_DEPTH_BUFFER_BIT, .depth = clearPayload.depth},
@@ -592,18 +406,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     }
 
     VkRenderPassManager::HashType VkRenderPassManager::ComputeHash(
-        const MG_State::GLState::FramebufferObject& fbo, Uint32 swapchainImageIndex, Bool includePendingClear,
-        Bool includeDefaultFboDepthStencil) {
+        const MG_State::GLState::FramebufferObject& fbo, Uint32 swapchainImageIndex, Bool includePendingClear) {
         XXHASH_VERIFY(XXH64_reset(m_hashState, m_config.CacheVersion));
         const Bool isDefaultFbo = fbo.IsDefaultFramebuffer();
         if (isDefaultFbo) {
             XXHASH_VERIFY(XXH64_update(m_hashState, &swapchainImageIndex, sizeof(swapchainImageIndex)));
         }
-        // sRGB attachments switch between their sRGB and UNORM-twin views with this
-        // capability (ResolveSrgbAttachmentWriteFormat), changing the render pass formats.
-        const Bool framebufferSrgbEnabled =
-            MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb);
-        XXHASH_VERIFY(XXH64_update(m_hashState, &framebufferSrgbEnabled, sizeof(framebufferSrgbEnabled)));
         auto& drawBuffers = fbo.GetDrawBuffers();
         XXHASH_VERIFY(XXH64_update(m_hashState, drawBuffers.data(), drawBuffers.size() * sizeof(drawBuffers[0])));
         auto readBuffer = fbo.GetReadBuffer();
@@ -677,17 +485,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                          attachment <= FramebufferAttachmentType::BackRight);
                     if (isDefaultColorAttachment) {
                         currentLayout = m_swapchainObject.GetImageLayout(swapchainImageIndex);
-                        // Content validity feeds the attachment's loadOp (see the
-                        // creation path), so it must key the cache as well.
-                        if (!m_swapchainObject.IsImageContentDefined(swapchainImageIndex)) {
-                            currentLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-                        }
                     } else if (attachment == FramebufferAttachmentType::Depth ||
                                attachment == FramebufferAttachmentType::Stencil) {
                         currentLayout = m_swapchainObject.GetDepthStencilImageLayout(swapchainImageIndex);
-                        if (!m_swapchainObject.IsDepthStencilContentDefined(swapchainImageIndex)) {
-                            currentLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-                        }
                     }
                 } else {
                     auto* textureResource = m_textureManager.SyncTextureAndGetDescriptor(*texture);
@@ -742,49 +542,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             combineFramebufferAttachmentObjHash(drawbuf);
         }
 
-        // The depth-less default-FBO flavor omits the depth/stencil attachment
-        // entirely, so it must hash differently from the depth-full flavor.
-        const Bool depthStencilIncluded = !isDefaultFbo || includeDefaultFboDepthStencil;
-        XXHASH_VERIFY(XXH64_update(m_hashState, &depthStencilIncluded, sizeof(depthStencilIncluded)));
-        if (depthStencilIncluded) {
-            combineFramebufferAttachmentObjHash(FramebufferAttachmentType::Depth);
-            combineFramebufferAttachmentObjHash(FramebufferAttachmentType::Stencil);
-        }
+        combineFramebufferAttachmentObjHash(FramebufferAttachmentType::Depth);
+        combineFramebufferAttachmentObjHash(FramebufferAttachmentType::Stencil);
 
         return XXH64_digest(m_hashState);
     }
 
     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
-        // depth attachment when the caller needs it, when a depth/stencil clear is
-        // pending, or when the active pass already carries it (escalate-only, so
-        // alternating depth-less draws never split an established depth pass).
-        Bool includeDefaultFboDepthStencil = true;
-        if (fbo.IsDefaultFramebuffer()) {
-            Bool activeDefaultHasDepthStencil = false;
-            if (const auto* active = GetActiveRenderPass()) {
-                Bool activeIsSwapchainPass = false;
-                Bool activeHasSwapchainDepthStencil = false;
-                for (const auto& tracked : active->trackedAttachmentLayouts) {
-                    activeIsSwapchainPass |= tracked.target == TrackedAttachmentTarget::SwapchainColor;
-                    activeHasSwapchainDepthStencil |=
-                        tracked.target == TrackedAttachmentTarget::SwapchainDepthStencil;
-                }
-                activeDefaultHasDepthStencil = activeIsSwapchainPass && activeHasSwapchainDepthStencil;
-            }
-            const auto& defaultDepthAtt = fbo.GetAttachment(FramebufferAttachmentType::Depth);
-            const auto& defaultStencilAtt = fbo.GetAttachment(FramebufferAttachmentType::Stencil);
-            const Bool pendingDepthStencilClear =
-                (defaultDepthAtt.IsTexture() && m_clearManager.HasPendingClear(defaultDepthAtt)) ||
-                HasPendingRenderbufferClear(defaultDepthAtt) ||
-                (defaultStencilAtt.IsTexture() && m_clearManager.HasPendingClear(defaultStencilAtt)) ||
-                HasPendingRenderbufferClear(defaultStencilAtt);
-            includeDefaultFboDepthStencil =
-                drawUsesDepthStencil || activeDefaultHasDepthStencil || pendingDepthStencilClear;
-        }
-
+                                                                Uint32 swapchainImageIndex) {
         auto hasPendingClearOnFramebuffer = [&]() -> Bool {
             const auto& drawBuffers = fbo.GetDrawBuffers();
             for (auto attachment : drawBuffers) {
@@ -834,7 +599,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_rpFastFboVersion == fbo.GetObjectVersion() && m_rpFastSwapchainIndex == swapchainImageIndex &&
             m_rpFastTexEpoch == m_textureManager.GetTextureImageEpoch() &&
             m_rpFastRbEpoch == m_renderbufferImageEpoch &&
-            (!fbo.IsDefaultFramebuffer() || m_rpFastHadDepthStencil == includeDefaultFboDepthStencil) &&
             m_rpFastRenderPassHash == activeRenderPass->hash && !hasPendingClearOnFramebuffer()) {
             auto activeIt = m_renderPasses.find(activeRenderPass->hash);
             if (activeIt != m_renderPasses.end()) {
@@ -843,7 +607,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         }
 
-        auto compatibilityHash = ComputeHash(fbo, swapchainImageIndex, false, includeDefaultFboDepthStencil);
+        auto compatibilityHash = ComputeHash(fbo, swapchainImageIndex, false);
         if (activeRenderPass != nullptr &&
             activeRenderPass->CompatibleWith(compatibilityHash) &&
             !hasPendingClearOnFramebuffer()) {
@@ -860,11 +624,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             m_rpFastTexEpoch = m_textureManager.GetTextureImageEpoch();
             m_rpFastRbEpoch = m_renderbufferImageEpoch;
             m_rpFastRenderPassHash = activeRenderPass->hash;
-            m_rpFastHadDepthStencil = activeIt->second.hasDepthStencilAttachment;
             activeIt->second.lastUsedFrame = m_frameCounter;
             return activeIt->second;
         }
-        auto hash = ComputeHash(fbo, swapchainImageIndex, true, includeDefaultFboDepthStencil);
+        auto hash = ComputeHash(fbo, swapchainImageIndex, true);
         auto it = m_renderPasses.find(hash);
         if (it != m_renderPasses.end()) {
             it->second.lastUsedFrame = m_frameCounter;
@@ -919,86 +682,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // assuming default FBO has the right param
         for (Uint32 i = 0; i < colorAttachmentSlotCount; ++i) {
             auto drawbuf = drawbufs[i];
-
-            // Renderbuffer color attachments mirror the texture path below, with the
-            // resource (image/view/format/layout) coming from the render-pass manager's
-            // renderbuffer store instead of the texture manager.
-            if (drawbuf != FramebufferAttachmentType::None && !isDefaultFbo) {
-                const auto& rbAtt = fbo.GetAttachment(drawbuf);
-                if (rbAtt.IsRenderbuffer() && rbAtt.IsComplete()) {
-                    const auto& renderbuffer = rbAtt.GetRenderbuffer();
-                    auto* rbResource = GetOrCreateRenderbufferResource(renderbuffer);
-                    if (rbResource == nullptr || (rbResource->aspect & VK_IMAGE_ASPECT_COLOR_BIT) == 0) {
-                        MGLOG_E_ONCE("GetOrCreateRenderPass: draw buffer slot %u on FBO %u has an unsupported color "
-                                "renderbuffer %u; using VK_ATTACHMENT_UNUSED",
-                                i, fbo.GetExternalIndex(), renderbuffer->GetExternalIndex());
-                        continue;
-                    }
-
-                    const Uint32 rbAttachmentIndex = static_cast<Uint32>(attachmentDescriptions.size());
-                    attachmentDescriptions.emplace_back();
-                    VkAttachmentDescription& rbDesc = attachmentDescriptions.back();
-
-                    ClearAttachmentPayload rbClearPayload{};
-                    Bool rbHasClear = GetPendingRenderbufferClear(renderbuffer.get(), rbClearPayload) &&
-                                      (rbClearPayload.mask & GL_COLOR_BUFFER_BIT) != 0;
-                    if (rbHasClear &&
-                        MG_Util::GetBaseInternalFormatComponentCount(renderbuffer->GetInternalFormat()) == 3) {
-                        // RGB renderbuffers are backed by an RGBA image; the missing alpha reads as 1.
-                        ForceOpaqueClearAlpha(rbClearPayload);
-                    }
-
-                    const VkImageLayout trackedRbLayout = rbResource->layout;
-                    const Bool rbFramebufferSrgb =
-                        MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb);
-                    const VkFormat rbAttachmentFormat =
-                        ResolveSrgbAttachmentWriteFormat(rbResource->format, rbFramebufferSrgb);
-                    rbDesc.flags = 0;
-                    rbDesc.format = rbAttachmentFormat;
-                    rbDesc.samples = rbResource->sampleCount;
-                    rbDesc.loadOp = rbHasClear ? VK_ATTACHMENT_LOAD_OP_CLEAR :
-                                    (trackedRbLayout == VK_IMAGE_LAYOUT_UNDEFINED ? VK_ATTACHMENT_LOAD_OP_DONT_CARE
-                                                                                  : VK_ATTACHMENT_LOAD_OP_LOAD);
-                    rbDesc.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-                    rbDesc.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-                    rbDesc.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-                    rbDesc.initialLayout = (rbHasClear || trackedRbLayout == VK_IMAGE_LAYOUT_UNDEFINED) ?
-                        VK_IMAGE_LAYOUT_UNDEFINED : trackedRbLayout;
-                    rbDesc.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-                    adoptRenderPassSampleCount(rbResource->sampleCount, "color",
-                                               static_cast<Int>(renderbuffer->GetExternalIndex()));
-
-                    if (rbHasClear) {
-                        pendingClearAttachments.emplace_back(PendingClearAttachmentInfo {
-                            .attachmentIndex = rbAttachmentIndex,
-                            .colorAttachmentSlot = i,
-                            .renderbuffer = renderbuffer.get(),
-                            .hasInlinePayload = true,
-                            .inlinePayload = rbClearPayload,
-                        });
-                    }
-
-                    if (width == 0)
-                        width = static_cast<Int>(rbResource->extent.width);
-                    if (height == 0)
-                        height = static_cast<Int>(rbResource->extent.height);
-
-                    trackedAttachmentLayouts.emplace_back(TrackedAttachmentLayoutInfo {
-                        .target = TrackedAttachmentTarget::Renderbuffer,
-                        .renderbuffer = renderbuffer,
-                        .finalLayout = rbDesc.finalLayout,
-                    });
-                    textureResources.emplace_back(nullptr);
-                    attachmentViews.emplace_back(rbAttachmentFormat != rbResource->format ? rbResource->unormTwinView
-                                                                                          : rbResource->view);
-                    MOBILEGL_ASSERT(attachmentViews.back() != VK_NULL_HANDLE,
-                                    "GetOrCreateRenderPass: renderbuffer view missing at color attachment %d", i);
-
-                    colorAttachmentRefs[i].attachment = rbAttachmentIndex;
-                    continue;
-                }
-            }
-
             auto* texture = ResolveCompleteColorAttachmentTexture(fbo, drawbuf, i);
             if (texture == nullptr)
                 continue;
@@ -1017,10 +700,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 case TextureTarget::Texture2D:
                 case TextureTarget::Texture2DArray:
                 case TextureTarget::Texture2DMultisample:
-                case TextureTarget::Texture2DMultisampleArray:
-                case TextureTarget::Texture3D:
-                case TextureTarget::TextureCubeMap:
-                case TextureTarget::TextureCubeMapArray:
                 case TextureTarget::TextureRectangle: {
                     desc.flags = 0;
                     desc.format = isDefaultFbo ?
@@ -1059,13 +738,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         MOBILEGL_ASSERT(swapchainImageIndex < swapchainViews.size(),
                                         "GetOrCreateRenderPass: swapchain image index out of range");
                         trackedColorLayout = m_swapchainObject.GetImageLayout(swapchainImageIndex);
-                        // EGL: a presented color buffer's content is undefined when its
-                        // image comes back around (EGL_BUFFER_DESTROYED, the default
-                        // swap behaviour) - skip the tile load instead of reloading
-                        // stale pixels nobody may rely on.
-                        if (!hasClear && !m_swapchainObject.IsImageContentDefined(swapchainImageIndex)) {
-                            trackedColorLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-                        }
                         trackedAttachmentLayouts.emplace_back(TrackedAttachmentLayoutInfo {
                             .target = TrackedAttachmentTarget::SwapchainColor,
                             .swapchainImageIndex = swapchainImageIndex,
@@ -1079,15 +751,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                         MOBILEGL_ASSERT(textureResource,
                                         "GetOrCreateRenderPass: SyncTextureAndGetDescriptor failed at color attachment %d", i);
                         textureResources.emplace_back(textureResource);
-                        desc.format = ResolveSrgbAttachmentWriteFormat(
-                            textureResource->format,
-                            MG_State::pGLContext->IsCapabilityEnabled(MobileGL::CapabilityInput::FramebufferSrgb));
+                        desc.format = textureResource->format;
                         attachmentSampleCount = textureResource->sampleCount;
                         trackedColorLayout = textureResource->layout;
                         trackedAttachmentLayouts.emplace_back(TrackedAttachmentLayoutInfo {
                             .target = TrackedAttachmentTarget::Texture,
                             .texture = att.GetTexture(),
-                            .textureRaw = att.GetTexture().get(),
                             .textureMipLevel = attachmentMipLevel,
                             .finalLayout = desc.finalLayout,
                         });
@@ -1105,7 +774,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     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;
@@ -1151,17 +820,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         };
         const auto* selectedDepthStencilAttachment = isUsableDepthStencilAttachment(depthAtt) ? &depthAtt :
                                                      (isUsableDepthStencilAttachment(stencilAtt) ? &stencilAtt : nullptr);
-        // Depth-less default-FBO flavor: nothing in this pass touches depth/stencil
-        // and their content is undefined anyway (EGL swap), so drop the attachment
-        // and its whole tile load + store.
-        if (isDefaultFbo && !includeDefaultFboDepthStencil) {
-            selectedDepthStencilAttachment = nullptr;
-        }
         const Bool hasDistinctDepthAndStencilAttachments =
             isUsableDepthStencilAttachment(depthAtt) && isUsableDepthStencilAttachment(stencilAtt) &&
             !sameDepthStencilAttachmentObject(depthAtt, stencilAtt);
         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) {
@@ -1175,12 +838,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkImageLayout trackedDepthLayout = isDefaultFbo ?
                 m_swapchainObject.GetDepthStencilImageLayout(swapchainImageIndex) :
                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-            // EGL 1.5 §3.10.1: every ancillary (depth/stencil) buffer's content is
-            // undefined after a swap, so the first default-FBO pass of a frame can
-            // skip the depth/stencil tile load outright.
-            if (isDefaultFbo && !m_swapchainObject.IsDepthStencilContentDefined(swapchainImageIndex)) {
-                trackedDepthLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-            }
             depthAttachmentDescription.flags = 0;
             VkSampleCountFlagBits depthAttachmentSampleCount = VK_SAMPLE_COUNT_1_BIT;
             Int depthAttachmentId = 0;
@@ -1223,7 +880,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);
             }
@@ -1264,7 +921,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 trackedAttachmentLayouts.emplace_back(TrackedAttachmentLayoutInfo {
                     .target = TrackedAttachmentTarget::Texture,
                     .texture = selectedDepthStencilAttachment->GetTexture(),
-                    .textureRaw = selectedDepthStencilAttachment->GetTexture().get(),
                     .textureMipLevel = attachmentMipLevel,
                     .finalLayout = depthAttachmentDescription.finalLayout,
                 });
@@ -1310,22 +966,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
         const Bool hasDepthStencilAttachment = depthAttachmentRef.attachment != VK_ATTACHMENT_UNUSED;
 
-        // Declare only the used colour-reference span. The GL draw-buffer array
-        // always spans 8 slots, so passes used to declare colorAttachmentCount=8
-        // with trailing VK_ATTACHMENT_UNUSED holes - and Adreno configures its
-        // per-pixel render-backend/export path from the DECLARED count, so every
-        // fragment of every pass paid the 8-target export cost (measured on
-        // Adreno 650 / MC 26.2: 11.9 -> 7.5 ms of GPU time per frame, with the
-        // single-quad swapchain blit pass alone dropping 1.26 -> 0.40 ms).
-        // Interior GL_NONE holes keep their slots so fragment-output locations
-        // still line up; a fragment output at a location past the trimmed count
-        // is discarded, which is exactly GL's semantic for writing to a draw
-        // buffer set to GL_NONE.
-        while (!colorAttachmentRefs.empty() &&
-               colorAttachmentRefs.back().attachment == VK_ATTACHMENT_UNUSED) {
-            colorAttachmentRefs.pop_back();
-        }
-
         // Subpass
         VkSubpassDescription subpassDesc;
         subpassDesc.flags = 0;
@@ -1443,14 +1083,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     void VkRenderPassManager::OnPresent() {
         ++m_frameCounter;
 
-        // Runs every frame boundary, ahead of the render-pass sweep gate below: the walk
-        // is O(#renderbuffer resources) — single digits in practice — and per-frame
-        // invocation keeps dead-resource reclaim latency at the aging bound instead of
-        // coupling it to renderbuffer *use* (the GetOrCreateRenderbufferResource call
-        // site never runs again once an app stops using renderbuffers).
-        CollectRenderbufferGarbage();
-        CollectDeferredRenderbufferReleases(/*destroyAll=*/false);
-
         // Sweep occasionally; evict entries whose last use is far past every
         // in-flight frame so their VkRenderPass/VkFramebuffer can be destroyed
         // safely (RenderPassEntry's destructor releases the handles).
@@ -1460,12 +1092,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             return;
         }
 
-        // Collect the dying handles and notify once after the loop: pipelines hashed
-        // on them share the entries' >kRetireAgeFrames idleness (they are only bound
-        // by draws that hit those entries), so the observer may destroy them
-        // immediately - and a single batched notification costs one pipeline-cache
-        // scan instead of one per evicted pass.
-        Vector<VkRenderPass> destroyedRenderPasses;
         const Uint64 activeHash = s_hasActiveRenderPass ? s_activeRenderPass.hash : 0;
         for (auto it = m_renderPasses.begin(); it != m_renderPasses.end();) {
             const Bool isActive = s_hasActiveRenderPass && it->first == activeHash;
@@ -1473,15 +1099,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 if (m_rpFastValid && m_rpFastRenderPassHash == it->first) {
                     m_rpFastValid = false;
                 }
-                destroyedRenderPasses.push_back(it->second.renderPass);
                 it = m_renderPasses.erase(it);
             } else {
                 ++it;
             }
         }
-        if (!destroyedRenderPasses.empty() && m_evictionObserver != nullptr) {
-            m_evictionObserver->OnRenderPassesDestroyed(destroyedRenderPasses);
-        }
     }
 
     Bool VkRenderPassManager::BeginRenderPass(VkCommandBuffer commandBuffer, RenderPassEntry& renderPassEntry) {
@@ -1515,8 +1137,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                 }
             }
             if ((clearPayload.mask & GL_COLOR_BUFFER_BIT) != 0) {
-                clearValues[pending.attachmentIndex].color =
-                    MakeVkClearColorValue(clearPayload, ColorFormatLacksAlpha(liveTexture.get()));
+                clearValues[pending.attachmentIndex].color = {
+                    clearPayload.color.x(),
+                    clearPayload.color.y(),
+                    clearPayload.color.z(),
+                    ResolveColorClearAlpha(liveTexture.get(), clearPayload.color.w())
+                };
             }
             if ((clearPayload.mask & GL_DEPTH_BUFFER_BIT) != 0) {
                 clearValues[pending.attachmentIndex].depthStencil.depth = clearPayload.depth;
@@ -1530,17 +1156,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         renderPassBeginInfo.pClearValues = clearValues.data();
 
         vkCmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
-        // Pre-pass stream bookkeeping: this pass's attachment images are now
-        // referenced by the open frame recording.
-        if (s_textureManager != nullptr) {
-            for (const auto& tracked : renderPassEntry.trackedAttachmentLayouts) {
-                if (tracked.target == TrackedAttachmentTarget::Texture) {
-                    if (const auto texture = tracked.texture.lock()) {
-                        s_textureManager->StampTextureRecordingUse(texture.get());
-                    }
-                }
-            }
-        }
         for (const auto& pending: renderPassEntry.pendingClearAttachments) {
             if (pending.hasInlinePayload) {
                 if (s_renderPassManager != nullptr) {
@@ -1593,15 +1208,11 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                     case TrackedAttachmentTarget::SwapchainColor:
                         MOBILEGL_ASSERT(s_swapchainObject != nullptr, "EndRenderPass: swapchain object is null");
                         s_swapchainObject->SetImageLayout(trackedAttachment.swapchainImageIndex, trackedAttachment.finalLayout);
-                        // The pass stored into the attachment: its content is defined
-                        // until the image is next presented.
-                        s_swapchainObject->SetImageContentDefined(trackedAttachment.swapchainImageIndex, true);
                         break;
                     case TrackedAttachmentTarget::SwapchainDepthStencil:
                         MOBILEGL_ASSERT(s_swapchainObject != nullptr, "EndRenderPass: swapchain object is null");
                         s_swapchainObject->SetDepthStencilImageLayout(trackedAttachment.swapchainImageIndex,
                                                                       trackedAttachment.finalLayout);
-                        s_swapchainObject->SetDepthStencilContentDefined(trackedAttachment.swapchainImageIndex, true);
                         break;
                     default:
                         MOBILEGL_ASSERT(false, "EndRenderPass: unsupported tracked attachment target=%d",

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.h

@@ -16,7 +16,6 @@
 #include "MG_State/GLState/FramebufferState/FramebufferObject.h"
 
 #include <Includes.h>
-#include <unordered_map>
 #include <vk_mem_alloc.h>
 
 namespace MobileGL::MG_Backend::DirectVulkan {
@@ -43,11 +42,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     struct TrackedAttachmentLayoutInfo {
         TrackedAttachmentTarget target = TrackedAttachmentTarget::Texture;
         WeakPtr<MG_State::GLState::ITextureObject> texture;
-        // Identity-compare shortcut for the per-draw "does the active pass use
-        // this sampled texture" probe: comparing this against a LIVE texture's
-        // address needs no weak_ptr::lock (two refcount atomics per probe).
-        // May dangle once the texture dies - compare only, never dereference.
-        MG_State::GLState::ITextureObject* textureRaw = nullptr;
         WeakPtr<MG_State::GLState::RenderbufferObject> renderbuffer;
         Uint32 textureMipLevel = 0;
         Uint32 swapchainImageIndex = 0;
@@ -101,42 +95,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,
@@ -199,53 +157,19 @@ namespace MobileGL::MG_Backend::DirectVulkan {
     class VkRenderPassManager {
     public:
         using HashType = Uint64;
-
-        // Notified once per OnPresent sweep with every aged-out entry's VkRenderPass
-        // value: pipelines are hashed on the raw handle, and once destroyed the value
-        // may be recycled for an incompatible pass, so dependent caches must purge
-        // everything keyed on them before any new pass can be created (the sweep and
-        // the notification run back-to-back with no creation in between; observers
-        // compare the values, never dereference them). Batched so a mass-idle cohort
-        // (shader-pack switch, dimension exit) costs the observer one pipeline-cache
-        // scan, not one per dying pass. The wholesale paths
-        // (Shutdown/RecreateSwapchain) do not notify - their callers already drop
-        // every pipeline outright.
-        class IEvictionObserver {
-        public:
-            virtual ~IEvictionObserver() = default;
-            virtual void OnRenderPassesDestroyed(const Vector<VkRenderPass>& renderPasses) = 0;
-        };
-
         VkRenderPassManager(VkDevice device,
             VkPhysicalDevice physicalDevice, VmaAllocator allocator, const VulkanRendererConfig& config,
             VkClearManager& clearManager, VkTextureManager& textureManager, SwapchainObject& swapchainObject);
         ~VkRenderPassManager();
 
-        // Observer may be null (no notifications). Not owned.
-        void SetEvictionObserver(IEvictionObserver* observer) { m_evictionObserver = observer; }
-
         Bool Initialize();
         void Shutdown();
 
         HashType ComputeHash(
             const MG_State::GLState::FramebufferObject& fbo,
             Uint32 swapchainImageIndex,
-            Bool includePendingClear = true,
-            Bool includeDefaultFboDepthStencil = true);
-        // drawUsesDepthStencil: whether the operation about to run inside the pass
-        // reads or writes the depth/stencil buffer (depth test or stencil test
-        // enabled, or a depth/stencil clear). Only consulted for the DEFAULT
-        // framebuffer: EGL undefines its ancillary buffers at every swap, so a
-        // default-FBO pass whose draws provably never touch depth/stencil is
-        // created WITHOUT the depth attachment - on a tiler that skips the whole
-        // depth tile load AND store. The flavor only escalates: once a pass with
-        // depth is active, later depth-less draws keep using it, and a depth-using
-        // draw against a depth-less active pass resolves to a new (incompatible)
-        // entry, which the caller's compatibility check turns into a pass split;
-        // the new pass's depth loads DONT_CARE (content was undefined all along).
-        RenderPassEntry& GetOrCreateRenderPass(const MG_State::GLState::FramebufferObject& fbo,
-                                               Uint32 swapchainImageIndex,
-                                               Bool drawUsesDepthStencil = true);
+            Bool includePendingClear = true);
+        RenderPassEntry& GetOrCreateRenderPass(const MG_State::GLState::FramebufferObject& fbo, Uint32 swapchainImageIndex);
         void QueueRenderbufferClear(GLbitfield mask, const ClearFramebufferPayload& clearPayload,
                                     const MG_State::GLState::FramebufferObject& drawFbo);
         void QueueRenderbufferClear(const ClearAttachmentPayload& clearPayload,
@@ -268,20 +192,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         UnorderedMap<Uint64, RenderPassEntry> m_renderPasses;
         // Monotonic frame counter (bumped in OnPresent) for render-pass cache aging.
         Uint64 m_frameCounter = 0;
-        IEvictionObserver* m_evictionObserver = nullptr;
 
         // Bumped whenever a renderbuffer VkImage is (re)created; together with the texture
         // manager's image epoch this invalidates the render-pass fast path on any attachment
         // image recreation.
         Uint64 m_renderbufferImageEpoch = 1;
 
-    public:
-        // Bumped whenever a renderbuffer backing is (re)created; consecutive-draw
-        // snapshots include it so an attachment respecify forces a re-resolve.
-        Uint64 GetRenderbufferImageEpoch() const { return m_renderbufferImageEpoch; }
-
-    private:
-
         // Per-draw fast-path memo for GetOrCreateRenderPass (dirty-flag state tracking): when the
         // framebuffer state is provably unchanged since the last resolution, the active render pass
         // is reused WITHOUT recomputing the expensive per-draw hash. Invalidated by FBO switch /
@@ -294,26 +210,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint64 m_rpFastTexEpoch = 0;
         Uint64 m_rpFastRbEpoch = 0;
         Uint64 m_rpFastRenderPassHash = 0;
-        // Whether the memoized entry carries a depth/stencil attachment; a
-        // default-FBO resolution whose effective depth request differs must
-        // miss the memo (the depth-less/depth-full flavors hash differently).
-        Bool m_rpFastHadDepthStencil = false;
 
-    public:
         struct RenderbufferResource {
-            // deadSinceFrame sentinel: the owning weak reference has not been observed
-            // expired. Dead resources age past every in-flight frame before Destroy
-            // (see CollectRenderbufferGarbage); the GPU may still reference the image
-            // for frames-in-flight frames after the GL object dies.
-            static constexpr Uint64 kNeverObservedDead = UINT64_MAX;
-
             WeakPtr<MG_State::GLState::RenderbufferObject> renderbuffer;
             VkImage image = VK_NULL_HANDLE;
             VmaAllocation allocation = nullptr;
             VkImageView view = VK_NULL_HANDLE;
-            // UNORM reinterpretation of an sRGB image, used as the attachment view while
-            // GL_FRAMEBUFFER_SRGB is disabled (raw writes). Null for non-sRGB formats.
-            VkImageView unormTwinView = VK_NULL_HANDLE;
             VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
             VkFormat format = VK_FORMAT_UNDEFINED;
             VkImageAspectFlags aspect = VK_IMAGE_ASPECT_NONE;
@@ -321,75 +223,25 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT;
             TextureInternalFormat internalFormat = TextureInternalFormat::Unknown;
             Int samples = 0;
-            // m_frameCounter value at which the weak reference was first seen expired.
-            Uint64 deadSinceFrame = kNeverObservedDead;
 
             void Destroy(VkDevice device, VmaAllocator allocator);
         };
 
-        // Public so the renderer's blit/copy/readback bindings can source renderbuffer
-        // attachments the same way texture attachments go through the texture manager.
-        RenderbufferResource* GetOrCreateRenderbufferResource(
-            const SharedPtr<MG_State::GLState::RenderbufferObject>& renderbuffer);
-        Bool GetPendingRenderbufferClear(MG_State::GLState::RenderbufferObject* renderbuffer,
-                                         ClearAttachmentPayload& outPayload) const;
-
-    private:
         struct PendingRenderbufferClear {
             WeakPtr<MG_State::GLState::RenderbufferObject> renderbuffer;
             ClearAttachmentPayload payload{};
         };
 
-        // A superseded renderbuffer backing (glRenderbufferStorage respecify) parked
-        // until enough frame boundaries have passed that no in-flight command buffer
-        // can still reference it; destroyed in OnPresent (see RetireAgeFrames).
-        struct DeferredRenderbufferRelease {
-            VkImage image = VK_NULL_HANDLE;
-            VmaAllocation allocation = nullptr;
-            VkImageView view = VK_NULL_HANDLE;
-            VkImageView unormTwinView = VK_NULL_HANDLE;
-            Uint64 deferredAtFrame = 0;
-        };
-
-        // Node-based std::unordered_map, deliberately NOT the 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.
-        //
-        // 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.)
-        std::unordered_map<MG_State::GLState::RenderbufferObject*, RenderbufferResource> m_renderbufferResources;
+        UnorderedMap<MG_State::GLState::RenderbufferObject*, RenderbufferResource> m_renderbufferResources;
         UnorderedMap<MG_State::GLState::RenderbufferObject*, PendingRenderbufferClear> m_pendingRenderbufferClears;
-        Vector<DeferredRenderbufferRelease> m_deferredRenderbufferReleases;
-        // Supported sample counts per attachment format, so per-draw resource lookups
-        // do not repeat vkGetPhysicalDeviceImageFormatProperties.
-        UnorderedMap<VkFormat, VkSampleCountFlags> m_attachmentSampleCountsByFormat;
 
+        RenderbufferResource* GetOrCreateRenderbufferResource(
+            const SharedPtr<MG_State::GLState::RenderbufferObject>& renderbuffer);
+        Bool GetPendingRenderbufferClear(MG_State::GLState::RenderbufferObject* renderbuffer,
+                                         ClearAttachmentPayload& outPayload) const;
         Bool HasPendingRenderbufferClear(
             const MG_State::GLState::FramebufferAttachmentObject& attachment) const;
         void CollectRenderbufferGarbage();
-        // Frame-boundary margin after which a resource last referenced by a retired
-        // GL object (or superseded backing) is provably past every in-flight frame.
-        Uint64 RetireAgeFrames() const;
-        void DeferRenderbufferBackingRelease(RenderbufferResource& resource);
-        void CollectDeferredRenderbufferReleases(Bool destroyAll);
 
         static inline XXH64_state_t* m_hashState = XXH64_createState();
         static inline ActiveRenderPassInfo s_activeRenderPass{};

MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.cpp

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

MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.h

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

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.h

@@ -13,7 +13,6 @@
 #include <MG_State/GLState/TextureState/TextureObject.h>
 #include <vk_mem_alloc.h>
 #include <unordered_map>
-#include <unordered_set>
 
 namespace MobileGL::MG_State::GLState {
 class ITextureObject;
@@ -28,9 +27,6 @@ public:
     // manager keys its per-draw fast path on this so an attachment's image recreation
     // invalidates the cached render pass (dirty-flag tracking; portable to Vulkan 1.1).
     Uint64 GetTextureImageEpoch() const { return m_textureImageEpoch; }
-    // Bumped whenever any tracked texture resource is erased; cached
-    // TextureResource pointers are valid only while this is unchanged.
-    Uint64 GetResourceEraseEpoch() const { return m_resourceEraseEpoch; }
 
     struct TextureIdentity {
         MG_State::GLState::ITextureObject* texture = nullptr;
@@ -56,20 +52,6 @@ public:
         VkCommandPool commandPool = VK_NULL_HANDLE;
         VkQueue graphicsQueue = VK_NULL_HANDLE;
         Uint32 frameCount = 0;
-        // VK_KHR_image_format_list is enabled: MUTABLE_FORMAT images can name the exact set of
-        // formats they will be viewed as, which is what lets a tiler keep them compressed.
-        Bool imageFormatListSupported = false;
-        // Union of shader stages sampled-read barriers may name on this device; the renderer
-        // builds it from the enabled features because geometry/tessellation stage bits are
-        // invalid in a barrier when their feature is off.
-        VkPipelineStageFlags sampledReadStageMask = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
-                                                    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                                                    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
-        // Family of `graphicsQueue`; the manager creates its own command pool
-        // on it for the recycled upload-batch command buffers, so their parked
-        // allocations never sit in (and fragment) the renderer's shared pool
-        // that frame command buffers churn through every frame.
-        Uint32 graphicsQueueFamilyIndex = 0;
     };
 
     struct TextureResource {
@@ -78,16 +60,12 @@ public:
             Uint32 baseArrayLayer = 0;
             Uint32 layerCount = 1;
             VkImageViewType viewType = VK_IMAGE_VIEW_TYPE_2D;
-            // May differ from the image format: sRGB images attach through their UNORM
-            // twin while GL_FRAMEBUFFER_SRGB is disabled.
-            VkFormat viewFormat = VK_FORMAT_UNDEFINED;
 
             Bool operator==(const AttachmentViewKey& other) const {
                 return mipLevel == other.mipLevel &&
                        baseArrayLayer == other.baseArrayLayer &&
                        layerCount == other.layerCount &&
-                       viewType == other.viewType &&
-                       viewFormat == other.viewFormat;
+                       viewType == other.viewType;
             }
         };
 
@@ -98,8 +76,6 @@ public:
                 hash ^= std::hash<Uint32>{}(key.layerCount) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
                 hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.viewType)) +
                         0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.viewFormat)) +
-                        0x9e3779b9u + (hash << 6) + (hash >> 2);
                 return hash;
             }
         };
@@ -180,25 +156,7 @@ public:
         VkImageViewType viewType = VK_IMAGE_VIEW_TYPE_2D;
         VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT;
         VkImageCreateFlags imageCreateFlags = 0;
-        // Usage the live image was created with. STORAGE is only requested for textures that
-        // have actually been bound to a GL image unit, because on Adreno a storage-capable
-        // image loses UBWC bandwidth compression; a later image binding upgrades the usage
-        // and recreates the image, so the resolved usage has to be part of the compatibility
-        // check that decides whether the existing image can be kept.
-        VkImageUsageFlags usageFlags = 0;
-        // True once this image was (re)resolved while the texture was already marked as an
-        // image-unit texture. Distinguishes "not upgraded yet" from "cannot be upgraded"
-        // (a format whose optimalTilingFeatures lack STORAGE_IMAGE never gains the bit), so
-        // NeedsStorageImagePreparation cannot ask for a recreate that will never happen.
-        Bool storageUsageResolved = false;
         Uint16 syncedTextureParamsVersion = 0;
-        // Recording generation (VkTextureManager::GetRecordingGeneration) of the last
-        // command referencing this image that was recorded into the CURRENT frame
-        // command buffer. An image untouched by the open recording may have its
-        // out-of-pass work (deferred clears, sampled-layout transitions) recorded
-        // into the frame's PRE command buffer - which executes strictly before the
-        // frame's commands - instead of splitting the active render pass.
-        Uint64 lastRecordingGeneration = 0;
         // Snapshot of ITextureObject::GetContentVersion() at the last successful sync;
         // lets SyncTexture skip the whole re-check/re-upload when content is unchanged.
         Uint64 syncedContentVersion = 0;
@@ -231,10 +189,7 @@ public:
             std::swap(this->viewType, that.viewType);
             std::swap(this->sampleCount, that.sampleCount);
             std::swap(this->imageCreateFlags, that.imageCreateFlags);
-            std::swap(this->usageFlags, that.usageFlags);
-            std::swap(this->storageUsageResolved, that.storageUsageResolved);
             std::swap(this->syncedTextureParamsVersion, that.syncedTextureParamsVersion);
-            std::swap(this->lastRecordingGeneration, that.lastRecordingGeneration);
             std::swap(this->syncedContentVersion, that.syncedContentVersion);
             std::swap(this->syncedMipLevelCount, that.syncedMipLevelCount);
         }
@@ -295,8 +250,6 @@ public:
             viewType = VK_IMAGE_VIEW_TYPE_2D;
             sampleCount = VK_SAMPLE_COUNT_1_BIT;
             imageCreateFlags = 0;
-            usageFlags = 0;
-            storageUsageResolved = false;
             syncedTextureParamsVersion = 0;
             syncedContentVersion = 0;
             syncedMipLevelCount = 0;
@@ -313,18 +266,6 @@ public:
     Bool Initialize(const InitInfo& initInfo);
     void Shutdown();
     void BeginFrame(Uint32 frameIndex);
-    // Submits the accumulated texture-upload batch (one command buffer, one
-    // vkQueueSubmit, one pooled fence) if any uploads are pending. MUST run
-    // before any other vkQueueSubmit on the shared graphics queue whose
-    // commands may consume an image the batch writes - the frame command
-    // buffer submit (mid-frame flush, readback, Present) and the
-    // preserve-on-recreate copy are the existing callers. No-op when the
-    // batch is empty.
-    void FlushPendingUploads();
-    // Drains every frame slot's deferred image/view releases. Only valid when
-    // the caller has proven every queue submission complete; used by the
-    // present-less frame-boundary drain.
-    void CollectAllDeferredReleases();
 
     TextureResource* SyncTextureAndGetDescriptor(
         MG_State::GLState::ITextureObject& texture);
@@ -344,46 +285,7 @@ public:
     Bool TransitionTextureForSampling(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
     Bool TransitionTextureForStorageImage(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
 
-    // Recording-generation bookkeeping for the pre-pass command stream. The
-    // generation advances every time the frame command buffer (re)begins
-    // recording; a resource whose stamp does not match was not referenced by
-    // any command in the open recording, so its out-of-pass work may safely
-    // execute ahead of the whole recording (in the pre command buffer).
-    void AdvanceRecordingGeneration() { ++m_recordingGeneration; }
-    void StampResourceRecordingUse(TextureResource& resource) const {
-        resource.lastRecordingGeneration = m_recordingGeneration;
-    }
-    // Map-lookup variant for callers that only hold the GL texture object.
-    void StampTextureRecordingUse(MG_State::GLState::ITextureObject* texture);
-    Bool WasTouchedThisRecording(const TextureResource& resource) const {
-        return resource.lastRecordingGeneration == m_recordingGeneration;
-    }
-    // Records that this texture is bound to a GL image unit, so its image must carry
-    // VK_IMAGE_USAGE_STORAGE_BIT. Must be called before NeedsStorageImagePreparation, and
-    // therefore before the render pass is committed: an image that has to be upgraded is
-    // recreated, which is illegal inside a render pass. Sticky for the texture's lifetime -
-    // GL lets an image binding come and go, and re-creating the image every time it does
-    // would cost far more than the compression it wins back.
-    void MarkStorageImageTexture(MG_State::GLState::ITextureObject& texture);
-    // True when this texture is marked but its live image predates the mark, i.e. the next sync
-    // will recreate it with STORAGE usage and copy the old contents forward. Callers use this to
-    // submit their pending recording first, so that copy cannot read pre-flush content.
-    Bool NeedsStorageUsageUpgrade(MG_State::GLState::ITextureObject& texture) const;
-    // The same ordering question for the other recreate-and-preserve trigger: true when this
-    // texture's live image carries a shorter mip chain than a full one, so defining the missing
-    // levels recreates it and copies the old contents forward.
-    Bool NeedsMipChainGrowth(MG_State::GLState::ITextureObject& texture) const;
-    // Non-mutating probe for the per-draw storage-image fast path: true when preparing this
-    // texture as a storage image may need work that is illegal inside a render pass (resource
-    // creation, dirty-content upload, or a layout transition to GENERAL). Unknown state reports
-    // 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);
@@ -423,9 +325,6 @@ public:
 private:
     // Bumped in SyncTextureResource right after vmaCreateImage(texture). See GetTextureImageEpoch().
     Uint64 m_textureImageEpoch = 1;
-    // See AdvanceRecordingGeneration. Starts above every resource's default
-    // stamp of 0 so a fresh resource counts as untouched.
-    Uint64 m_recordingGeneration = 1;
 
     Bool SyncTexture(MG_State::GLState::ITextureObject &texture,
                      TextureResource &outResource);
@@ -456,31 +355,18 @@ private:
     void DeferViewRelease(VkImageView view);
     void CollectDeferredReleases(Uint32 frameIndex);
     void DestroyDeferredReleases();
-    // Frees the fence/command buffer/staging buffer of every in-flight texture
-    // upload whose fence has signaled (submission order = completion order on
-    // the single queue, so the scan stops at the first still-pending entry).
-    // waitAll blocks on every entry - Shutdown's drain.
-    void ReclaimCompletedUploads(Bool waitAll = false);
     static TextureIdentity MakeTextureIdentity(MG_State::GLState::ITextureObject* texture);
     void EraseTrackedTexture(const TextureIdentity& identity);
     void PruneStaleTextureAliases(MG_State::GLState::ITextureObject* texture);
-    SizeT PruneDeadTextures();
 
     VkDevice m_device = VK_NULL_HANDLE;
     VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
     VmaAllocator m_allocator = nullptr;
     VkCommandPool m_commandPool = VK_NULL_HANDLE;
-    // Dedicated pool for the recycled upload-batch command buffers (see
-    // InitInfo::graphicsQueueFamilyIndex).
-    VkCommandPool m_uploadCommandPool = VK_NULL_HANDLE;
     VkQueue m_graphicsQueue = VK_NULL_HANDLE;
-    Bool m_imageFormatListSupported = false;
     Uint32 m_currentFrameIndex = 0;
 
     Uint8 m_gcCounter = 0;
-    // Frame-boundary GC gate: counts BeginFrame calls, not draws, so texture churn
-    // through non-draw paths (FBO clears, readbacks) still reaches the prune.
-    Uint32 m_gcFrameCounter = 0;
     // Active only between BeginDrawSyncScope/EndDrawSyncScope; identities of
     // textures already fully synced in the current draw (small N -> flat scan).
     Bool m_drawSyncScopeActive = false;
@@ -493,92 +379,9 @@ private:
         TextureResource* resource = nullptr;
     };
     Vector<DrawSyncedTexture> m_drawSyncedThisDraw;
-    // Cross-draw sampled-texture memo: the same few textures (atlas, lightmap)
-    // are resolved on every draw, so cache their resource pointers and skip the
-    // alive/resource map lookups. Node-based std::unordered_map keeps the
-    // pointees stable across inserts; erases bump m_resourceEraseEpoch, which
-    // every memo entry must match. SyncTexture still runs on memo hits, so
-    // content/param freshness is unaffected. A dead-then-reused texture address
-    // cannot false-hit: the new object carries a new lifetime id.
-    struct SyncedTextureMemoEntry {
-        const MG_State::GLState::ITextureObject* texture = nullptr;
-        Uint64 lifetimeId = 0;
-        Uint64 eraseEpoch = 0;
-        TextureResource* resource = nullptr;
-    };
-    static constexpr Uint32 kSyncedTextureMemoSize = 8;
-    SyncedTextureMemoEntry m_syncedTextureMemo[kSyncedTextureMemoSize];
-    Uint32 m_syncedTextureMemoNext = 0;
-    Uint64 m_resourceEraseEpoch = 1;
-    // Formats whose mutable-image probe failed on this device; their images are created
-    // without MUTABLE_FORMAT_BIT so repeat syncs neither re-probe nor flag-mismatch.
-    std::unordered_set<VkFormat> m_mutableFormatUnsupported;
-    // Formats whose 3D images refused VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT. Per format+usage,
-    // exactly like the mutable-format verdict above, so it is answered at image creation and
-    // remembered rather than probed once globally.
-    std::unordered_set<VkFormat> m_2dArrayCompatibleUnsupported;
     std::unordered_map<TextureIdentity, WeakPtr<MG_State::GLState::ITextureObject>, TextureIdentityHash> m_aliveObjects;
     std::unordered_map<TextureIdentity, TextureResource, TextureIdentityHash> m_textureResources;
-    // Textures that have been bound to a GL image unit (see MarkStorageImageTexture).
-    std::unordered_set<TextureIdentity, TextureIdentityHash> m_storageImageTextures;
-    // Supported multisample counts per format, so repeat texture syncs do not
-    // re-query vkGetPhysicalDeviceImageFormatProperties.
-    std::unordered_map<VkFormat, VkSampleCountFlags> m_multisampleCountsByFormat;
     Vector<Vector<TextureResource>> m_deferredReleases;
     Vector<Vector<VkImageView>> m_deferredViewReleases;
-
-    // --- Batched upload machinery ---
-    // Uploads within a frame are recorded into ONE shared command buffer and
-    // submitted with ONE vkQueueSubmit at FlushPendingUploads (the renderer
-    // flushes before every frame-command-buffer submit). Staging memory comes
-    // from a pool of persistently-mapped, reusable blocks instead of a
-    // vmaCreateBuffer per upload.
-    struct UploadStagingBlock {
-        VkBuffer buffer = VK_NULL_HANDLE;
-        VmaAllocation allocation = nullptr;
-        Uint8* mapped = nullptr; // persistently mapped for the block's lifetime
-        VkDeviceSize capacity = 0;
-        VkDeviceSize cursor = 0; // bump cursor while the block backs the open batch
-    };
-    // Opens the batch command buffer lazily (allocates/reuses + begins recording).
-    VkCommandBuffer EnsureUploadBatchOpen();
-    // Bump-allocates `size` staging bytes for the open batch, growing onto a
-    // new/pooled block when the current one cannot fit. Returns the write
-    // pointer; outBuffer/outBaseOffset locate the space for copy commands.
-    Uint8* AcquireUploadStagingSpace(VkDeviceSize size, VkBuffer& outBuffer, VkDeviceSize& outBaseOffset);
-    void RecycleUploadStagingBlock(UploadStagingBlock&& block);
-    // Drops a recorded-but-unsubmitted batch on the floor. Shutdown only: the
-    // device is being torn down, so the lost texel data is unobservable.
-    void DiscardPendingUploadBatch();
-    void DestroyUploadPools();
-
-    Vector<UploadStagingBlock> m_freeUploadStagingBlocks;
-    VkDeviceSize m_freeUploadStagingBytes = 0;
-    Vector<VkCommandBuffer> m_freeUploadCommandBuffers;
-    Vector<VkFence> m_freeUploadFences;
-    Bool m_uploadBatchOpen = false;
-    VkCommandBuffer m_uploadBatchCommandBuffer = VK_NULL_HANDLE;
-    // Blocks whose staging bytes the open batch's copies reference (last =
-    // the block the bump cursor is currently allocating from).
-    Vector<UploadStagingBlock> m_uploadBatchBlocks;
-    // Images the open batch writes; consulted for the rare re-upload-after-
-    // draw flush and by DeferResourceRelease (an unsubmitted command buffer
-    // referencing a deferred-released image would escape every fence-based
-    // destruction proof, so the batch is flushed before the image is parked).
-    Vector<VkImage> m_uploadBatchImages;
-    VkDeviceSize m_uploadBatchStagingBytes = 0;
-
-    // Texture uploads are submitted out-of-band but NOT waited on (waiting
-    // behind the queue serialized the CPU against the previous frame's GPU
-    // work every time an animated atlas re-uploaded). Each flushed batch's
-    // transients are parked here and RECYCLED (fence reset to the fence pool,
-    // command buffer reset to the CB pool, staging blocks back to the block
-    // pool) once the batch fence signals.
-    struct PendingUploadReclaim {
-        VkFence fence = VK_NULL_HANDLE;
-        VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
-        Vector<UploadStagingBlock> stagingBlocks;
-    };
-    Vector<PendingUploadReclaim> m_pendingUploadReclaims;
 };
 } // namespace MobileGL::MG_Backend::DirectVulkan

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

@@ -51,12 +51,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Uint32 instanceCount = 1;
         Uint32 firstVertex = 0;
         Uint32 firstInstance = 0;
-        // Indexed-draw metadata for bounding vertex-stream conversion. baseVertex is the
-        // draw's base-vertex offset; indexRangeIsExactView is true only when the draw
-        // fetches exactly the indices its IndexBufferView describes (direct DrawElements;
-        // multi/indirect forms leave it false because the CPU cannot bound their ranges).
-        Int32 baseVertex = 0;
-        Bool indexRangeIsExactView = false;
     };
 
     struct DrawIndexedCmdParam {
@@ -76,10 +70,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         GLenum indexType = GL_UNSIGNED_SHORT;
         SizeT indexByteOffset = 0;
         SizeT indexByteSize = 0;
-        // Interpret indexByteOffset as a raw client pointer even when an element
-        // array buffer is bound (backend-synthesized index lists, e.g. the
-        // GL_LINE_LOOP -> LINE_STRIP rewrite).
-        Bool forceClientMemory = false;
     };
 
     struct DrawIndexedCmd {
@@ -118,10 +108,7 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         }
     };
 
-    class VulkanRenderer : public IBufferCopyCommandProvider,
-                           public FrameContext::IRecordingObserver,
-                           public VkRenderPassManager::IEvictionObserver,
-                           public ProgramFactory::IEvictionObserver {
+    class VulkanRenderer : public IBufferCopyCommandProvider, public FrameContext::IRecordingObserver {
     public:
         VulkanRenderer(NativeWindowType window, const VulkanRendererConfig& cfg = {});
         ~VulkanRenderer();
@@ -138,31 +125,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // recording, before any render pass.
         void OnFrameCommandRecordingBegan(VkCommandBuffer commandBuffer) override;
 
-        // VkRenderPassManager::IEvictionObserver: the render-pass aging sweep just
-        // destroyed these VkRenderPasses; evict every graphics pipeline hashed on a
-        // dying handle (they share its >1024-boundary idleness, so immediate
-        // destruction is safe) and drop the last-pipeline memo if any went.
-        void OnRenderPassesDestroyed(const Vector<VkRenderPass>& renderPasses) override;
-
-        // ProgramFactory::IEvictionObserver: an aged-out program entry was
-        // destroyed; evict its compute pipeline and graphics pipelines (same
-        // idleness guarantee - they are only bound through draws/dispatches that
-        // stamp the program entry) and purge the descriptor-set cache entries
-        // keyed by its now-recyclable VkDescriptorSetLayout handle.
-        void OnProgramEvicted(ProgramFactory::HashType programHash,
-                              VkDescriptorSetLayout descriptorSetLayout) override;
-
         Bool SetupDraw(FrameContext::FrameData& frame, GLenum mode, Flags<DrawSetupAspect> aspects,
                        const DrawCmdParam& drawParams,
                        const IndexBufferView* pIndexBufferView = nullptr);
-        // ANGLE-style consecutive-draw fast path: SetupDraw snapshots the fully
-        // resolved draw configuration; the next draw whose cheap version/identity
-        // checks all match skips the resolution half (LOD probe, sampled-set
-        // walk, render-pass and pipeline resolution) and jumps straight to the
-        // per-draw tail. Returns false (leaving no side effects that the full
-        // path cannot redo idempotently) whenever anything might have changed.
-        Bool TrySetupDrawFastPath(FrameContext::FrameData& frame, GLenum mode, Flags<DrawSetupAspect> aspects,
-                                  const DrawCmdParam& drawParams, const IndexBufferView* pIndexBufferView);
         void ClearAttachmentsOnActiveRenderPass(VkCommandBuffer commandBuffer,
                                                 const RenderPassEntry& compatibleRenderPassEntry);
 
@@ -181,10 +146,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value);
         void ClearNamedFramebufferfv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
                                      GLenum buffer, GLint drawbuffer, const GLfloat* value);
-        void ClearNamedFramebufferiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                     GLenum buffer, GLint drawbuffer, const GLint* value);
-        void ClearNamedFramebufferuiv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                      GLenum buffer, GLint drawbuffer, const GLuint* value);
         void ClearNamedFramebufferfi(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
                                      GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
         void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
@@ -204,30 +165,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                               GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
         void GenerateMipmap(GLenum target);
         void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
-        // GL_DEPTH_COMPONENT / GL_DEPTH_STENCIL / GL_STENCIL_INDEX readback from the
-        // read framebuffer's depth/stencil attachment (per-aspect buffer copies with
-        // CPU repacking into the requested client layout).
-        void ReadDepthStencilPixels(MG_State::GLState::FramebufferObject& readFbo, GLint x, GLint y, GLsizei width,
-                                    GLsizei height, GLenum format, GLenum type, void* pixels);
-        // Copy-and-repack core shared by depth-stencil ReadPixels and GetTexImage;
-        // expects command recording to be active and any render pass already ended.
-        //
-        // `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.
-        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);
-        // Same-extent depth blit between images of different depth formats: host
-        // round-trip with a per-texel re-encode (see BlitNamedFramebuffer).
-        Bool BlitDepthAcrossFormats(FrameContext::FrameData& frame, VkImage srcImage, VkFormat srcFormat,
-                                    VkImageLayout* srcTrackedLayout, Uint32 srcMipLevel, Uint32 srcBaseArrayLayer,
-                                    VkImage dstImage, VkFormat dstFormat, VkImageLayout* dstTrackedLayout,
-                                    Uint32 dstMipLevel, Uint32 dstBaseArrayLayer, GLint srcX, GLint srcY, GLint dstX,
-                                    GLint dstY, GLint width, GLint height, VkImageLayout srcRestoreLayout,
-                                    VkImageLayout dstRestoreLayout, Bool stencilAspect);
         static SizeT GetReadbackTexelSize(VkFormat sourceFormat);
         static Bool ConvertReadbackPixels(const Uint8* sourcePixels, VkFormat sourceFormat,
                                           GLsizei width, GLsizei height, GLenum destinationFormat,
@@ -313,35 +250,10 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                       const VkTimerQueryManager::TimestampRecord& end) const;
         Uint64 GetTimerQueryTimestampNs(const VkTimerQueryManager::TimestampRecord& record) const;
 
-        // GL_SAMPLES_PASSED occlusion queries: every app draw between Start and Stop is
-        // wrapped in a Vulkan occlusion query slot; the result is the slot sum. Requires
-        // hostQueryReset for slot recycling - Start fails (frontend keeps the query
-        // unsupported) when the device lacks it.
-        Bool StartOcclusionQueryCapture();
-        void StopOcclusionQueryCapture(Vector<Uint32>& outSlots);
-        // Flushes pending commands, waits, sums the slots, and recycles them.
-        Bool ResolveOcclusionQueryResult(const Vector<Uint32>& slots, Uint64& outSamples);
-
         void RequestSwapchainResize(Uint32 width, Uint32 height);
-        // Re-query the surface and report whether the live swapchain no longer matches it
-        // (size or orientation). This - not a VK_SUBOPTIMAL_KHR result - is what decides a
-        // rebuild, so a surface the driver merely considers suboptimal cannot thrash.
-        Bool SwapchainIsOutOfDate();
-        // Returns false when the surface is zero-area (minimized/hidden window):
-        // no new swapchain is installed and presentation must stay suspended.
-        Bool RecreateSwapchain();
+        void RecreateSwapchain();
 
     private:
-        // Tiered emission for an already-set-up multi-draw batch (state bound, index
-        // buffer bound for the indexed form). Tier 1: VK_EXT_multi_draw. Tier 2: one
-        // vkCmdDraw(Indexed)Indirect over a transient command array. Tier 3: unrolled
-        // vkCmdDraw(Indexed) loop. Tier eligibility is per-batch (uniform instance
-        // state for tier 1, firstInstance/feature legality for tier 2); every tier
-        // consumes the same param span, so contiguous-run merging done by the caller
-        // benefits all of them.
-        void EmitMultiDrawIndexed(VkCommandBuffer commandBuffer, const DrawIndexedCmdParam* pParams, Uint32 drawCount);
-        void EmitMultiDraw(VkCommandBuffer commandBuffer, const DrawCmdParam* pParams, Uint32 drawCount);
-
         struct BlitUniformData {
             float srcRect[4] = {0.f, 0.f, 1.f, 1.f};
             float dstRect[4] = {0.f, 0.f, 1.f, 1.f};
@@ -368,31 +280,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;
@@ -450,59 +337,24 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         VkFence AcquirePooledSubmitFence();
         void DestroySubmitFencePool();
         Bool HasPendingRecordedWork() const;
-        // Frame-boundary housekeeping for paths that never reach Present's
-        // tail (present-less readback loops, suspended presentation, blocking
-        // sync waits): runs the same per-frame drains Present performs, but
-        // only when every queue submission has been observed complete AND no
-        // recorded-but-unsubmitted commands exist - i.e. when CPU-GPU overlap
-        // is provably already zero. Never blocks (non-blocking fence poll
-        // only), so the presenting path's frames-in-flight pipelining is
-        // untouched. Returns true when the drain ran.
-        Bool TryDrainFrameTransients();
 
         Vector<SubmitRecord> m_inFlightSubmits;
         Vector<VkFence> m_freeSubmitFences;
         Uint64 m_submitCounter = 0;
         Uint64 m_completedSubmitCounter = 0;
-        // Drains since the last Present, gating the drain's frame-boundary-equivalent
-        // work (arena rewind + cache aging): a presenting app's mid-frame
-        // readbacks/waits must neither churn the transient caches nor accelerate the
-        // aging clocks, while present-less loops still cross a boundary every few
-        // iterations. Reset in Present.
-        Uint32 m_drainsSinceLastPresent = 0;
 
         NativeWindowType m_window = 0;
         void* m_platformDisplay = nullptr;
         void* m_platformLibrary = nullptr;
         void* m_platformCloseDisplay = nullptr;
-        // 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.)
-        Bool m_headlessSurfaceSupported = true;
-        // Android has the same shortfall: no Mali/Adreno driver seen so far exposes
-        // VK_EXT_headless_surface, so a windowless (EGL pbuffer) context gets an
-        // AImageReader's ANativeWindow to hand the WSI instead. Nothing is ever
-        // displayed - the reader's images are simply never acquired. Owned here, so
-        // Shutdown() deletes it.
-        void* m_fallbackImageReader = nullptr;
         VulkanRendererConfig m_config;
         Bool m_swapchainResizeRequested = false;
-        // Presentation is suspended while the window is zero-area (minimized): the
-        // swapchain is unusable/out of date, so Present drops frames instead of
-        // submitting on a signaled fence / presenting never-acquired images.
-        Bool m_presentSuspended = false;
 
         // Vulkan objects
         Bool m_validationLayersEnabled = false;
         Vector<VkExtensionProperties> m_extensions;
         VkInstance m_instance = VK_NULL_HANDLE;
         VkDebugUtilsMessengerEXT m_debugMessenger = VK_NULL_HANDLE;
-        // Fallback reporting channel for drivers that ship the validation layers but
-        // only expose the older VK_EXT_debug_report (Adreno 650 / Vulkan 1.1.128).
-        VkDebugReportCallbackEXT m_debugReportCallback = VK_NULL_HANDLE;
         PhysicalDevice m_physicalDevice;
         VkDevice m_device = VK_NULL_HANDLE;
         VmaAllocator m_allocator = nullptr;
@@ -515,24 +367,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         Bool m_indexTypeUint8ExtensionEnabled = false;
         Bool m_logicOpFeatureEnabled = false;
         Bool m_multiDrawIndirectFeatureEnabled = false;
-        // drawIndirectFirstInstance gates indirect commands whose firstInstance != 0;
-        // cached at device creation because the tier-2 multi-draw path (a transient
-        // VkDrawIndexedIndirectCommand array) is illegal for such a sub-draw without it.
-        Bool m_drawIndirectFirstInstanceFeatureEnabled = false;
-        // VK_EXT_multi_draw: native batched submission for the CPU-side glMultiDraw*
-        // families (tier 1 of the multi-draw dispatch).
-        Bool m_multiDrawExtensionEnabled = false;
-        Uint32 m_maxMultiDrawCount = 0;
-        // Multi-draw dispatch tiers, resolved once at device creation from device support
-        // clamped by MOBILEGL_MAGMA_MULTIDRAW_MODE (a preference, never a demand):
-        //   tier 1 (ext):      one vkCmdDrawMulti(Indexed)EXT           - m_multiDrawAllowExt
-        //   tier 2 (indirect): one vkCmdDraw(Indexed)Indirect batch     - m_multiDrawAllowIndirect
-        //   tier 3 (unroll):   one vkCmdDraw(Indexed) per sub-draw      - always available
-        // m_multiDrawForceUnrollIndirect additionally forces the GPU-parameter
-        // glMultiDraw*Indirect paths onto their per-command loop (mode=unroll only).
-        Bool m_multiDrawAllowExt = false;
-        Bool m_multiDrawAllowIndirect = false;
-        Bool m_multiDrawForceUnrollIndirect = false;
         Bool m_samplerAnisotropyFeatureEnabled = false;
         Bool m_shaderDrawParametersExtensionEnabled = false;
         Bool m_shaderDrawParametersFeatureEnabled = false;
@@ -547,13 +381,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // needs no feature). Both cached at device creation and drive a hard-fail-at-draw when absent.
         Bool m_dualSrcBlendFeatureEnabled = false;
         Bool m_primitiveTopologyListRestartFeatureEnabled = false;
-        // Union of shader stages sampled-read barriers may name; built at device creation
-        // because geometry/tessellation stage bits are invalid in a barrier when their
-        // feature is off (VUID-vkCmdPipelineBarrier-srcStageMask-04090/-04091), and
-        // ALL_GRAPHICS would also serialize against non-shader stages.
-        VkPipelineStageFlags m_sampledReadStageMask = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
-                                                      VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
-                                                      VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
         // Cached at device creation from the graphics queue family properties
         // and device limits; drives timer-query support.
         Uint32 m_timestampValidBits = 0;
@@ -564,102 +391,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                                  VkDeviceSize countBufferOffset, Uint32 maxDrawCount,
                                                                  Uint32 stride);
         static inline PFNDrawIndexedIndirectCountFunc s_vkCmdDrawIndexedIndirectCount = nullptr;
-        // VK_EXT_multi_draw entry points, loaded at device creation when the extension
-        // (and its multiDraw feature) is enabled; null otherwise.
-        static inline PFN_vkCmdDrawMultiEXT s_vkCmdDrawMultiEXT = nullptr;
-        static inline PFN_vkCmdDrawMultiIndexedEXT s_vkCmdDrawMultiIndexedEXT = nullptr;
-
-        // VK_EXT_transform_feedback (GL transform feedback capture)
-        Bool m_transformFeedbackFeatureEnabled = false;
-        // VK_EXT_provoking_vertex. Vulkan's built-in convention is "provoking vertex first"; GL's
-        // default is LAST_VERTEX_CONVENTION, and GL derives BOTH flat shading and the transform
-        // feedback vertex order from it. provokingVertexLast alone fixes flat shading and the
-        // input-assembler capture order and has no dependency on transform feedback; only
-        // transformFeedbackPreservesProvokingVertex does.
-        Bool m_provokingVertexLastEnabled = false;
-        // transformFeedbackPreservesProvokingVertex was actually enabled at device creation. Kept
-        // separate because it is the only thing that arms
-        // VUID-VkGraphicsPipelineCreateInfo-topology-04884, the rule that forbids a TRIANGLE_FAN
-        // pipeline from asking for LAST on a device that cannot preserve a fan's provoking vertex.
-        Bool m_provokingVertexXfbPreserveEnabled = false;
-        // provokingVertexModePerPipeline: when VK_FALSE every pipeline in one render pass instance
-        // must agree on the mode, so glProvokingVertex(GL_FIRST_VERTEX_CONVENTION) cannot be honoured
-        // per draw and every pipeline takes GL's default (LAST) instead.
-        Bool m_provokingVertexModePerPipeline = false;
-        // transformFeedbackPreservesTriangleFanProvokingVertex.
-        Bool m_provokingVertexFanPreserved = false;
-        // Per-pipeline provoking-vertex mode. capturesXfbFromGeometryStage must be a LINK-TIME
-        // property of the program, never the dynamic "is transform feedback active" flag: the
-        // 8-entry m_pipelineMemo and the SetupDrawSnapshot fast path key on programObj.hash and
-        // the pipeline-state value hash, neither of which moves when glBeginTransformFeedback is
-        // called, so a dynamic input here would hand back a stale VkPipeline.
-        VkProvokingVertexModeEXT SelectProvokingVertexMode(VkPrimitiveTopology topology,
-                                                          Bool capturesXfbFromGeometryStage) const;
-        // VK_EXT_vertex_attribute_divisor: without it every non-zero glVertexAttribDivisor
-        // behaves as 1, because that is all Vulkan's instance input rate can express.
-        Bool m_vertexAttributeDivisorEnabled = false;
-        static inline PFN_vkCmdBindTransformFeedbackBuffersEXT s_vkCmdBindTransformFeedbackBuffersEXT = nullptr;
-        static inline PFN_vkCmdBeginTransformFeedbackEXT s_vkCmdBeginTransformFeedbackEXT = nullptr;
-        static inline PFN_vkCmdEndTransformFeedbackEXT s_vkCmdEndTransformFeedbackEXT = nullptr;
-        // Counter buffers (one 4-byte slot per capture binding) let consecutive
-        // draws within one glBeginTransformFeedback append GL-style. Transform feedback
-        // objects can each hold an open, paused span at the same time, so the counters are
-        // per object: one group of four slots each, handed out on first use.
-        static constexpr SizeT kXfbCounterObjectSlots = 16;
-        VkBufferObject m_xfbCounterBuffer;
-        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{};
-        Array<Uint64, kXfbCounterObjectSlots> m_xfbLastSeenGeneration{};
-        // Counter slot group of the bound transform feedback object.
-        Uint32 CurrentXfbCounterSlot();
-        // Wraps a recorded draw with BeginTransformFeedbackEXT/EndTransformFeedbackEXT
-        // when GL transform feedback is active; binds capture buffers on demand.
-        Bool BeginXfbCaptureForDraw(FrameContext::FrameData& frame);
-        void EndXfbCaptureForDraw(FrameContext::FrameData& frame, Bool began);
-        // Makes the captured bytes visible to whatever reads them next. Deferred rather than
-        // recorded next to the capture, because the capturing draw runs inside a render pass
-        // that declares no self-dependency.
-        void MakeXfbWritesVisible();
-        Bool m_xfbWritesPendingVisibility = false;
-        // Wrap one app draw in an occlusion-query slot while a GL_SAMPLES_PASSED
-        // query is active. Returns whether a slot was begun (End must mirror it).
-        Bool BeginOcclusionForDraw(VkCommandBuffer commandBuffer);
-        void EndOcclusionForDraw(VkCommandBuffer commandBuffer, Bool began);
-        Bool m_occlusionQueryPreciseEnabled = false;
-        Bool m_hostQueryResetEnabled = false;
-        PFN_vkResetQueryPool s_vkResetQueryPool = nullptr;
-        VkQueryPool m_occlusionQueryPool = VK_NULL_HANDLE;
-        static constexpr Uint32 kOcclusionQuerySlots = 8192;
-        Uint32 m_occlusionSlotCursor = 0;
-        Bool m_occlusionCaptureActive = false;
-        Vector<Uint32> m_occlusionActiveSlots;
-        // Transform feedback primitive queries: one pool slot per captured draw yields
-        // the (written, needed) pair; GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN sums the
-        // first, GL_PRIMITIVES_GENERATED the second - exact with geometry shaders,
-        // unlike the CPU fallback accounting.
-        Bool m_xfbQueriesSupported = false;
-        PFN_vkCmdBeginQueryIndexedEXT s_vkCmdBeginQueryIndexedEXT = nullptr;
-        PFN_vkCmdEndQueryIndexedEXT s_vkCmdEndQueryIndexedEXT = nullptr;
-        VkQueryPool m_xfbQueryPool = VK_NULL_HANDLE;
-        static constexpr Uint32 kXfbQuerySlots = 8192;
-        Uint32 m_xfbQuerySlotCursor = 0;
-        Bool m_xfbQueryCaptureActive[2] = {false, false}; // [0]=written, [1]=generated
-        Vector<Uint32> m_xfbQueryActiveSlots[2];
-        Bool m_xfbQuerySlotOpen = false;
-        Uint32 m_xfbQueryOpenSlot = 0;
-
-    public:
-        // kind: 0 = PRIMITIVES_WRITTEN, 1 = PRIMITIVES_GENERATED.
-        Bool StartXfbQueryCapture(Uint32 kind);
-        void StopXfbQueryCapture(Uint32 kind, Vector<Uint32>& outSlots);
-        Bool ResolveXfbQueryResult(const Vector<Uint32>& slots, Bool wantGenerated, Uint64& outPrimitives);
-
-    private:
-        void BeginXfbQueryForDraw(VkCommandBuffer commandBuffer);
-        void EndXfbQueryForDraw(VkCommandBuffer commandBuffer);
 
         VkCommandPool m_commandPool = VK_NULL_HANDLE;
 
@@ -673,64 +404,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         // gather + synthetic vertex-input rebuild + payload hash + lookup) when the full pipeline
         // state is unchanged from the previous draw. The key provably covers every pipeline field.
         // Reset per-frame and on pipeline destruction so the cached handle can never dangle.
-        // Small N-way pipeline-resolution memo (round-robin replacement). A
-        // single-entry memo thrashed on draw sequences that alternate a few
-        // pipelines (GUI text/quad program ping-pong), paying the full
-        // payload-hash lookup per draw; eight entries cover such working sets
-        // while keeping the hit path a trivial linear scan.
-        struct PipelineMemoEntry {
-            GLenum mode = 0;
-            Uint64 programHash = 0;
-            Uint64 vertexInputHash = 0;
-            Uint64 renderPassHash = 0;
-            // VALUE hash of the pipeline-relevant fixed-function state (see
-            // ComputePipelineStateHash), not the monotonic pipeline-state version:
-            // the version never repeats, so a per-draw GL_BLEND toggle would miss
-            // all entries forever even though the state alternates between two
-            // values the memo already holds.
-            Uint64 pipelineStateHash = 0;
-            ProgramFactory::CompileOptionFlags transformFlags = {};
-            VkPipeline pipeline = VK_NULL_HANDLE;
-        };
-        static constexpr Uint32 kPipelineMemoSize = 8;
-        PipelineMemoEntry m_pipelineMemo[kPipelineMemoSize];
-        Uint32 m_pipelineMemoCount = 0;
-        Uint32 m_pipelineMemoNext = 0;
-        // Hash of every fixed-function GL state the pipeline payload reads that the
-        // memo key's other fields (mode / program / vertex input / render pass /
-        // transform flags) do not already pin down. Equal hash under an equal rest
-        // of key => byte-identical PipelineCreatePayload. Cached per pipeline-state
-        // version: the version is monotonic and bumps on every pipeline-state
-        // change, so an unchanged (version, colorAttachmentCount) proves the state
-        // bytes are unchanged and the hash can be reused without re-reading them.
-        Uint64 ComputePipelineStateHash(Uint32 colorAttachmentCount) const;
-        Uint m_pipelineStateHashVersion = 0;
-        Uint32 m_pipelineStateHashColorCount = 0;
-        Uint64 m_pipelineStateHash = 0;
-        Bool m_pipelineStateHashValid = false;
-        // GetShaderTransformFlags memo. NOT pure in the pre-transform alone: the
-        // function also reads whether the bound DRAW framebuffer is the default one
-        // (only the default framebuffer gets the Y-flip and rotation bits - an FBO
-        // pass renders unflipped). Keyed on BOTH inputs; missing the FBO bit shipped
-        // an upside-down default-framebuffer pass after any render-to-texture
-        // (minecraft-1.17-main-menu retrace, whole frame flipped).
-        VkSurfaceTransformFlagBitsKHR m_baseTransformFlagsPreTransform =
-            VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR;
-        Bool m_baseTransformFlagsIsDefaultFbo = false;
-        Bool m_baseTransformFlagsKeyValid = false;
-        Uint32 m_baseTransformFlagsCache = 0;
-        // isDefaultFbo must be the default-ness of the CURRENTLY bound draw framebuffer;
-        // every caller already has it in hand from its own guards.
-        Uint32 GetBaseTransformFlagsRaw(Bool isDefaultFbo);
-        // Drops every memoized pipeline handle. Required at command-buffer
-        // boundaries and whenever any pipeline may have been destroyed. Also drops
-        // the cached pipeline-state hash: the same boundaries can retire the GL
-        // context whose monotonic version the cache is keyed on.
-        void InvalidatePipelineMemo() {
-            m_pipelineMemoCount = 0;
-            m_pipelineMemoNext = 0;
-            m_pipelineStateHashValid = false;
-        }
+        Bool m_lastPipelineValid = false;
+        GLenum m_lastPipelineMode = 0;
+        Uint64 m_lastPipelineProgramHash = 0;
+        Uint64 m_lastPipelineVertexInputHash = 0;
+        Uint64 m_lastPipelineRenderPassHash = 0;
+        Uint m_lastPipelineRenderStateVersion = 0;
+        ProgramFactory::CompileOptionFlags m_lastPipelineTransformFlags = {};
+        VkPipeline m_lastPipelineResult = VK_NULL_HANDLE;
         UnorderedMap<ProgramFactory::HashType, VkPipeline> m_computePipelines;
         UniquePtr<ProgramFactory> m_programFactory;
         UniquePtr<UniformManager> m_uniformManager;
@@ -759,143 +440,9 @@ namespace MobileGL::MG_Backend::DirectVulkan {
         ProgramFactory::CompileOptionFlags m_lastSampledSetTransformFlags = {};
         Uint64 m_lastSampledSetBindGeneration = 0;
 
-        // Memo for the per-draw explicit-LOD-0 eligibility probe
-        // (ProgramSamplesOnlySingleLevelTextures): same key family as the
-        // sampled-set memo, plus the sampled textures' params-version sum so a
-        // level-range or filter change re-probes. On a hit the resolved
-        // transform flags are reused, which also collapses the two
-        // GetOrCreateProgram lookups into one.
-        Bool m_lastLodDecisionValid = false;
-        Uint64 m_lastLodProgramLifetimeId = 0;
-        Uint32 m_lastLodProgramVersion = 0;
-        Uint64 m_lastLodBindGeneration = 0;
-        Uint64 m_lastLodParamsSum = 0;
-        ProgramFactory::CompileOptionFlags m_lastLodBaseFlags = {};
-        ProgramFactory::CompileOptionFlags m_lastLodResultFlags = {};
-
-        // 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
-        // protected by the command-buffer-boundary reset plus the mid-frame
-        // pipeline-destruction resets, and monotonic epochs guard everything
-        // that can be destroyed or recreated between draws.
-        struct SetupDrawSnapshot {
-            Bool valid = false;
-            Uint8 aspects = 0;
-            GLenum mode = 0;
-            Uint64 programLifetimeId = 0;
-            Uint32 programVersion = 0;
-            const void* vao = nullptr;
-            // Same rule as VaoDrawMemo::vaoLifetimeId: (address, config version) is not an
-            // identity, because a recycled address can arrive carrying a config version
-            // the dead VAO also had (two mutations to configure one attribute is the
-            // common shape), and "the VAO did not move" would then skip the layout
-            // re-resolve for a different VAO.
-            Uint64 vaoLifetimeId = 0;
-            Uint32 vaoConfigVersion = 0;
-            const void* drawFbo = nullptr;
-            Uint16 fboVersion = 0;
-            Bool drawFboIsDefault = false;
-            Uint renderStateVersion = 0;
-            Uint64 bindGeneration = 0;
-            Uint32 baseTransformFlags = 0;
-            Uint32 resolvedTransformFlags = 0;
-            Uint64 renderPassHash = 0;
-            Uint32 imageIndex = 0;
-            Uint64 textureEraseEpoch = 0;
-            Uint64 textureImageEpoch = 0;
-            Uint64 renderbufferImageEpoch = 0;
-            Uint64 sampledContentSum = 0;
-            Uint64 sampledParamsSum = 0;
-            // Guards the sampler-descriptor reuse hint: bumped by any sampler-object
-            // parameter or texture shape change (see GetSamplingResolutionGeneration),
-            // none of which the sums above cover.
-            Uint64 samplingResolutionGeneration = 0;
-            // Render-pass flavor input (DepthTest || StencilTest at snapshot time).
-            // A pipeline-state change that leaves this equal cannot change which
-            // render pass GetOrCreateRenderPass would pick, so the fast path may
-            // re-resolve just the pipeline against the active pass; a change that
-            // flips it must fall back to the full path's pass selection.
-            Bool drawUsesDepthStencil = false;
-            IntVec2 renderPassExtent = {0, 0};
-            // colorAttachmentCount of the snapshotting draw's render pass: the
-            // pipeline-state hash input, so the fast path can refresh that hash and
-            // probe the pipeline memo after a state change without re-fetching the
-            // render-pass entry (the pass itself is pinned by renderPassHash above).
-            Uint32 renderPassColorCount = 0;
-            VkPipeline pipeline = VK_NULL_HANDLE;
-            // layoutHash of the snapshotting draw's vertex-input state. The pipeline and
-            // the vertex-input pre-flight depend on the VAO only through this (plus the
-            // program, pinned separately), so a changed VAO whose aux memo carries the
-            // same layoutHash re-uses the snapshot's pipeline and pre-flight verdict
-            // outright - the VAO-cycling case Minecraft chunk rendering hits every draw.
-            Uint64 vaoLayoutHash = 0;
-            // Memoised ProgramFactory entry of the snapshotting draw, valid while
-            // (programLifetimeId, programVersion, resolvedTransformFlags) match - all
-            // checked above - AND the factory's cache structure epoch is unchanged (the
-            // cache is open-addressing and holds entries by value, so any insert/erase
-            // moves them). The fast path must re-stamp use through StampProgramUse when
-            // it bypasses GetOrCreateProgram, or the idle sweep could evict a live entry.
-            const ProgramFactory::VkProgramObject* programObj = nullptr;
-            Uint64 programFactoryEpoch = 0;
-            // Per-entry copies of the snapshotting draw's sampled set (the scratch
-            // vectors below hold only the LAST full-path draw's set, which with more
-            // than one snapshot entry is not necessarily this entry's program).
-            // sampledTextures/sampledResources carry the same epoch-guarded pointer
-            // lifetime rules as the scratch originals: textureEraseEpoch (checked
-            // every probe) declines the entry before any erased resource pointer
-            // could be dereferenced. sampledLayouts is the layout VALUE each
-            // resource held when this entry's descriptors were built (the
-            // descriptor-reuse hint needs the SAME layout, not just a sampleable
-            // one), and sampledBindingRecords feeds SampledBindingsUnchanged when
-            // the bind generation moved.
-            Vector<MG_State::GLState::ITextureObject*> sampledTextures;
-            Vector<VkTextureManager::TextureResource*> sampledResources;
-            Vector<VkImageLayout> sampledLayouts;
-            Vector<UniformManager::SampledBindingRecord> sampledBindingRecords;
-        };
-        // Program-keyed snapshot entries: program ping-pong (Sodium switches programs
-        // mid-frame every few draws) would otherwise evict the single snapshot on
-        // every switch and send every draw through the full path. Entries are found
-        // by programLifetimeId (MRU-first probe); every other guard stays per-probe,
-        // so a stale entry declines itself exactly like the old single snapshot did.
-        static constexpr Uint32 kSetupDrawSnapshotCount = 4;
-        SetupDrawSnapshot m_setupDrawSnapshots[kSetupDrawSnapshotCount];
-        Uint32 m_setupDrawSnapshotMru = 0;    // last entry that hit or was filled
-        Uint32 m_setupDrawSnapshotVictim = 0; // round-robin fill cursor when all entries are live
-        void InvalidateSetupDrawSnapshots() {
-            for (auto& snapshot : m_setupDrawSnapshots) {
-                snapshot.valid = false;
-            }
-        }
-
         // Per-draw scratch buffers (clear keeps capacity) — these paths run for every
         // draw call and must not allocate.
         Vector<MG_State::GLState::ITextureObject*> m_sampledTexturesScratch;
-        // Per-binding (texture, effective sampler) lifetime-id records from the same
-        // CollectSampledTextures walk that filled m_sampledTexturesScratch. The fast
-        // path shadow-compares against them (SampledBindingsUnchanged) when the
-        // texture bind generation moved, so a redundant glBindSampler/glBindTexture
-        // storm that resolves to the same bindings keeps the fast path.
-        Vector<UniformManager::SampledBindingRecord> m_sampledBindingRecordsScratch;
-        // Parallel to m_sampledTexturesScratch, refilled by every SetupDraw's
-        // first sampled-texture loop: the resolved backend resources, so the
-        // post-transition loop can skip re-resolving textures whose layout is
-        // already sampleable.
-        Vector<VkTextureManager::TextureResource*> m_sampledResourcesScratch;
         Vector<MG_State::GLState::ITextureObject*> m_storageImageTexturesScratch;
         Vector<VkBuffer> m_vertexBuffersScratch;
         Vector<VkDeviceSize> m_vertexOffsetsScratch;
@@ -941,157 +488,12 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             }
         };
 
-        struct ConvertedVertexStream {
-            BufferSlice slice;
-            // Number of source elements the cached slice covers. A draw needing a prefix of
-            // this range reuses the slice (converted streams are tightly packed); a draw
-            // needing more reconverts and replaces the entry, so per (buffer, layout) a
-            // frame converts at most the largest range any draw asked for.
-            SizeT elementCount = 0;
-            // Pins the source buffer for the frame so its heap address cannot be reused by
-            // a new BufferObject while this pointer-keyed entry is alive.
-            SharedPtr<const MG_State::GLState::BufferObject> sourcePin;
-        };
-        UnorderedMap<ConvertedVertexStreamKey, ConvertedVertexStream, ConvertedVertexStreamKeyHash>
+        UnorderedMap<ConvertedVertexStreamKey, BufferSlice, ConvertedVertexStreamKeyHash>
             m_convertedVertexStreams;
 
-        // One VAO's resolved vkCmdBindVertexBuffers arguments, reusable by a later draw
-        // that would resolve them to the same thing. Consecutive draws in a chunk-renderer
-        // frame keep the program and the vertex layout and only swap the VAO, so a
-        // per-VAO memo turns the second and later draws through each VAO into a validate
-        // plus (usually skipped) rebind.
-        //
-        // Only whole-buffer bindings are memoised. Client-memory and format-converted
-        // streams re-upload from a range that depends on the draw's own vertex/index
-        // range, and synthetic bindings carry glVertexAttrib* values that are not part
-        // of any key here; a layout using any of them is never stored.
-        // Field order is hit-path cache locality, hot to cold: the per-draw validate
-        // reads the scalars and the EBO memo head, then only the first bindingCount
-        // elements of vkBuffers/vkOffsets; the per-binding revalidation arrays at the
-        // tail are touched once per frame at most.
-        struct ResolvedVertexBindings {
-            // Must equal DynamicStateShadow::kMaxShadowedVertexBindings (static_assert in
-            // the .cpp): past that width the bind shadow cannot skip a redundant bind
-            // either, so a wider layout resolves per draw. Minecraft-shaped layouts use four.
-            static constexpr Uint32 kMaxBindings = 8;
-
-            // Frame serial of the last completed resolve OR cross-frame revalidation.
-            // Zero until a resolve completes, and reset to zero before one starts, so a
-            // resolve that bails out midway cannot leave a half-filled entry matchable.
-            // Unlike the original frame-scoped memo, an entry whose buffers are all
-            // resident and unmapped is revalidated across frames (per-binding slice
-            // epoch compares) instead of re-resolved - see TryBindResolvedVertexBindings.
-            Uint64 frameSerial = 0;
-            // Identity of the resolved Vulkan layout: the VAO's content hash
-            // (VertexInputStateFactory::GetOrComputeHash - the same value the factory
-            // keys its entries on) fixes bindings.size(), each binding's base offset,
-            // which bindings are client/converted, and (through the mixed-in buffer
-            // addresses) which buffer each binding reads. Compared against the VAO's
-            // own hash memo on the hit path, so a hit never touches the factory entry.
-            VertexInputStateFactory::HashType vertexInputHash = 0;
-            // The program's vertex input layout: decides the synthetic-binding set and
-            // hence the total binding count.
-            Uint32 activeAttribMask = 0;
-            Uint32 bindingCount = 0;
-            // VkBufferManager::GetSliceEpochCounter() at resolve time. Still equal means
-            // no buffer anywhere changed its slice or was persistently mapped since, which
-            // settles every per-binding question below in one compare.
-            Uint64 sliceEpochCounter = 0;
-            // Any bound buffer already carrying a host map when the slice was resolved.
-            // Such a buffer can mutate its shadow with no API call, so it has to be
-            // re-pushed per draw and the one-compare path above cannot apply.
-            Bool anyBufferMapped = true;
-
-            // Resident element-buffer slice memo (skips the per-draw AcquireResidentSlice
-            // for the VAO's EBO, which cold-chases 500+ distinct resources in a
-            // chunk-cycling frame). Self-validating exactly like the bindings above: a hit
-            // requires the LIVE bound EBO pointer to equal indexBuffer AND either an
-            // unmoved manager-wide slice-epoch counter (nothing anywhere changed slices
-            // or gained a host map, the same one-compare rescue the vertex half uses) or
-            // that buffer's resource still carrying indexSliceEpoch (epochs are minted
-            // from a process-lifetime counter, so a recycled address can never
-            // revalidate). Restart-substituted and streamed EBOs are never stored.
-            // indexFrameSerial tracks the last frame the resource's GPU-use serial was
-            // stamped through this memo; 0 means no index memo. Independent of the
-            // vertex half: both are (pointer, epoch)-validated, so neither can serve
-            // stale state for the other.
-            const MG_State::GLState::BufferObject* indexBuffer = nullptr;
-            Uint64 indexSliceEpoch = 0;
-            // GetSliceEpochCounter() when the resource's epoch was last verified; only
-            // meaningful while indexFrameSerial matches the current frame serial.
-            Uint64 indexSliceEpochCounter = 0;
-            VkBuffer indexVkBuffer = VK_NULL_HANDLE;
-            VkDeviceSize indexSliceOffset = 0;
-            Uint64 indexFrameSerial = 0;
-
-            // Bound per draw (first bindingCount elements).
-            VkBuffer vkBuffers[kMaxBindings] = {};
-            VkDeviceSize vkOffsets[kMaxBindings] = {};
-            // Per binding: the VAO attribute location its buffer comes from, that buffer,
-            // and the buffer's VkBufferManager slice epoch when the slice was resolved.
-            // Only read by the per-frame revalidation and the something-moved fallback.
-            Uint8 attributeLocations[kMaxBindings] = {};
-            const MG_State::GLState::BufferObject* buffers[kMaxBindings] = {};
-            Uint64 sliceEpochs[kMaxBindings] = {};
-        };
-        // One direct-mapped slot of the per-VAO draw-memo table below. A slot belongs to
-        // the object whose (vaoKey, vaoLifetimeId) pair it carries: the address alone
-        // only picks the slot, and the never-reused lifetime id is what proves the slot
-        // is THIS VAO's, so the successor allocated onto a destroyed VAO's address
-        // always misses. That identity check is load-bearing and the content-hash
-        // validations below do NOT stand in for it - a recycled address under a
-        // byte-identical configuration reproduces the content hash exactly, which is
-        // how a destroyed VAO's resolved bindings were once handed to its successor's
-        // draw. The slot is still never dereferenced through vaoKey, and every fact it
-        // carries is still validated against live state before use:
-        //  - layoutHash/layoutAuxMasks are valid only while contentHash equals the LIVE
-        //    VAO's own hash memo (which the VAO's config version guards), so a config
-        //    change or a buffer rebind misses even for the same object.
-        //  - bindings revalidates per draw exactly as before (frame serial, content
-        //    hash, per-binding live buffer pointers and slice epochs).
-        struct alignas(64) VaoDrawMemo {
-            const MG_State::GLState::VertexArrayObject* vaoKey = nullptr;
-            // The VAO's never-reused lifetime id, checked alongside vaoKey. The pointer
-            // ALONE is not an identity: a deleted VAO's heap address is handed straight
-            // back by the next glGenVertexArrays-shaped allocation, and the successor then
-            // matched this slot and inherited the dead object's memos. Both stated
-            // defences failed with it, because both reduce to the content hash and the
-            // content hash's buffer-identity component was itself a recycled heap address.
-            Uint64 vaoLifetimeId = 0;
-            // The VAO content hash (VertexInputStateFactory::GetOrComputeHash) the two
-            // layout facts below were derived from; 0 while nothing valid is stored.
-            Uint64 contentHash = 0;
-            Bool layoutFactsValid = false;
-            // The resolved layout identity + packed (unsupported, location) masks -
-            // the exact values GetBackendAuxMemo used to serve, moved here so the
-            // per-draw probe stays inside this table's one hot line instead of
-            // touching a second cold line of every cycled VAO object.
-            Uint64 layoutHash = 0;
-            Uint64 layoutAuxMasks = 0;
-            ResolvedVertexBindings bindings;
-        };
-        // Fixed-size, allocated on first use, never rehashed or swept: entries are
-        // recycled in place on slot collisions (two-slot probe, older frame serial
-        // evicted), and stale entries self-invalidate through the compares above. A
-        // fixed table also makes every VaoDrawMemo/ResolvedVertexBindings pointer
-        // stable for the duration of a draw, which the EBO memo handoff
-        // (m_currentDrawResolvedEntry) relies on.
-        static constexpr Uint32 kVaoDrawMemoSlotCount = 2048; // power of two
-        Vector<VaoDrawMemo> m_vaoDrawMemoTable;
-        // Finds the slot holding `vao`, or recycles the older of its two candidate
-        // slots into an empty memo keyed on `vao`. Never returns null.
-        VaoDrawMemo* LookupVaoDrawMemo(const MG_State::GLState::VertexArrayObject* vao);
-        // The current draw's memo entry, set by UploadAndBindVertexBuffers and consumed
-        // by the same draw's UploadAndBindIndexBuffer (the EBO memo lives in the same
-        // entry). Valid ONLY within that window: the next draw's lookup can recycle the
-        // slot. Null when the draw's layout is not memoisable.
-        ResolvedVertexBindings* m_currentDrawResolvedEntry = nullptr;
-
         void CreateInstance();
         VkResult SetupDebugMessenger();
         VkResult DestroyDebugMessenger();
-        VkResult SetupDebugReportCallback();
-        void DestroyDebugReportCallback();
         VkDebugUtilsMessengerCreateInfoEXT PopulateDebugMessengerCreateInfo();
         void CreateSurface();
         void PickPhysicalDevice();
@@ -1110,32 +512,14 @@ namespace MobileGL::MG_Backend::DirectVulkan {
             const RenderPassEntry& renderPassEntry);
         VkPipeline GetOrCreateComputePipeline(const ProgramFactory::VkProgramObject& programObj);
         void DestroyComputePipelines();
-        // Takes the frame rather than a command buffer: a first-time storage-usage upgrade has to
-        // flush the pending recording (see the body), which retires the current command buffer.
         Bool PrepareStorageImageTextures(
-            FrameContext::FrameData& frame,
+            VkCommandBuffer commandBuffer,
             const MG_State::GLState::ProgramObject& program,
             const ProgramFactory::VkProgramObject& programObj);
 
-        // The per-draw dynamic-state tail (viewport, scissor, blend constants, depth
-        // bias, line width, stencil), gated behind one render-state-parameters-version
-        // compare per command buffer - see the gate fields in DynamicStateShadow.
-        void ApplyDynamicDrawStateTail(FrameContext::FrameData& frame, const IntVec2& extent, Bool isDefaultFbo);
-
         Bool UploadAndBindVertexBuffers(VkCommandBuffer commandBuffer, const MG_State::GLState::VertexArrayObject& vao,
                                         const ProgramFactory::VkProgramObject& programObj,
-                                        const DrawCmdParam& drawParams,
-                                        const IndexBufferView* pIndexBufferView);
-        // Binds `entry`'s memoised buffers when every input it was resolved from is
-        // still live and unchanged, else returns false and leaves nothing bound.
-        // vaoContentHash is the VAO's memoised content hash (GetBackendHashMemo), which
-        // pins the layout AND the bound buffers without resolving the factory entry.
-        // Non-const entry: a cross-frame revalidation refreshes its serial/epoch stamps.
-        Bool TryBindResolvedVertexBindings(VkCommandBuffer commandBuffer,
-                                           const MG_State::GLState::VertexArrayObject& vao,
-                                           ResolvedVertexBindings& entry,
-                                           Uint64 vaoContentHash,
-                                           Uint32 activeAttribMask, Uint64 frameSerial);
+                                        const DrawCmdParam& drawParams, Bool indexedDraw);
         Bool UploadAndBindIndexBuffer(FrameContext::FrameData& frame,
                                      const MG_State::GLState::VertexArrayObject& vao,
                                       const IndexBufferView* pIndexBufferView = nullptr);
@@ -1151,28 +535,8 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                    GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
                                                    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
                                                    GLenum filter);
-        // Clears one z slice of a VK_IMAGE_TYPE_3D colour image. See the call site in
-        // MaterializePendingClearForTexture for why a transfer clear cannot do this.
-        Bool ClearDepthSliceWithRenderPass(VkCommandBuffer commandBuffer,
-                                           MG_State::GLState::ITextureObject& texture, Uint32 mipLevel,
-                                           Uint32 depthSlice, const VkClearValue& clearValue);
         Bool MaterializePendingClearForTexture(VkCommandBuffer commandBuffer,
                                                MG_State::GLState::ITextureObject& texture);
-        Bool MaterializePendingClearForRenderbuffer(
-            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,
@@ -1184,14 +548,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                            VkImageLayout finalLayout);
         Bool SubmitReadbackCommandsAndWait(FrameContext::FrameData& frame);
 
-    public:
-        // Submits whatever is recorded and waits for it. The CPU is about to read memory
-        // a shader wrote (a mapped shader storage buffer), and coherent host-visible
-        // storage only guarantees visibility once the work that produced it has retired.
-        Bool FinishPendingGpuWork();
-
-    private:
-
         void ShutdownSwapchain();
 
         // Static functions
@@ -1215,10 +571,6 @@ namespace MobileGL::MG_Backend::DirectVulkan {
                                                  const PhysicalDevice& compareWithDevice,
                                                  PhysicalDevice& outBetterDevice);
         static constexpr const char* s_validationLayerNames[] = {"VK_LAYER_KHRONOS_validation"};
-        // VK_KHR_image_format_list: lets MUTABLE_FORMAT images declare their exact view-format
-        // set so the driver can keep bandwidth compression (see CreateLogicalDeviceAndQueues).
-        Bool m_imageFormatListExtensionEnabled = false;
-
         static constexpr const char* s_deviceExtensionNames[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
         static Bool CheckValidationLayerSupport();
 

MobileGL/MG_Backend/DirectVulkan/VkIncludes.h

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

MobileGL/MG_Benchmark/CMakeLists.txt

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

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/Driver/CMakeLists.txt

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

MobileGL/MG_Benchmark/Driver/DriverBench.c

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

MobileGL/MG_Benchmark/Driver/DriverBenchCases.inc

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

MobileGL/MG_Benchmark/Driver/run_driver_bench.sh

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

MobileGL/MG_Impl/CGLImpl/CGLImpl.cpp

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

MobileGL/MG_Impl/CGLImpl/CGLImpl.h

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

MobileGL/MG_Impl/CGLImpl/Exporting/Definitions.cpp

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

MobileGL/MG_Impl/DyldInterpose/DyldInterpose.cpp

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

MobileGL/MG_Impl/DyldInterpose/ExportedSymbols.txt

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

MobileGL/MG_Impl/EGLImpl/EGLImpl.cpp

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

@@ -8,10 +8,6 @@
 
 #include "GL_Buffer.h"
 #include "Validators.h"
-#include "../Texture/GL_Texture.h"
-#include "../Getter/GL_Getter.h"
-#include <MG_Util/Converters/GLToMG/TextureEnumConverter.h>
-#include <MG_Util/Metrics/TextureMetrics.h>
 #include <Config.h>
 #include <MG_State/GLState/Core.h>
 #include <MG_State/GLState/ErrorState/Error.h>
@@ -42,7 +38,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             GetNamedBufferParameteriv,
             GetNamedBufferParameteri64v,
             GetNamedBufferPointerv,
-            GetNamedBufferSubData,
         };
 
         const char* GetBufferOpName(BufferOp op) {
@@ -81,8 +76,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                 return "UnmapNamedBuffer";
             case BufferOp::FlushMappedNamedBufferRange:
                 return "FlushMappedNamedBufferRange";
-            case BufferOp::GetNamedBufferSubData:
-                return "GetNamedBufferSubData";
             case BufferOp::GetNamedBufferParameteriv:
                 return "GetNamedBufferParameteriv";
             case BufferOp::GetNamedBufferParameteri64v:
@@ -96,64 +89,25 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         SharedPtr<MG_State::GLState::BufferObject> GetNamedBufferObject(GLuint buffer, BufferOp op);
 
-        // The size of one cleared element, which is what offset and size must be multiples of
-        // (GL 4.6 core 6.3). `internalformat` is restricted to the buffer-texture format table, and
-        // `format`/`type` describe the client-side pattern, so both are validated here and the
-        // caller only has to know how wide an element is.
         SizeT GetClearPatternSize(GLenum internalformat, GLenum format, GLenum type, BufferOp op) {
-            if (!IsBufferTextureInternalFormat(internalformat)) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", GetBufferOpName(op),
-                        std::format("internalformat 0x{:X} is not one of the sized formats a buffer clear accepts.",
-                                    internalformat)));
-                return 0;
-            }
-
-            // Unlike internalformat, a bad format or type here is INVALID_VALUE rather than
-            // INVALID_ENUM (GL 4.6 core 6.3) - the odd one out among the enum arguments.
-            const TextureInputFormat inputFormat = MG_Util::ConvertGLEnumToTextureInputFormat(format);
-            if (inputFormat == TextureInputFormat::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", GetBufferOpName(op),
-                                                 std::format("format 0x{:X} is not a pixel format.", format)));
-                return 0;
-            }
-
-            const TexturePixelDataType pixelType = MG_Util::ConvertGLEnumToTexturePixelDataType(type);
-            if (pixelType == TexturePixelDataType::Unknown) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", GetBufferOpName(op),
-                                                 std::format("type 0x{:X} is not a pixel type.", type)));
-                return 0;
-            }
-
-            const TextureInternalFormat internal =
-                MG_Util::ConvertGLEnumToTextureInternalFormat(internalformat);
-            const SizeT elementSize = MG_Util::GetSizedInternalFormatSizeInBytes(internal);
-            if (elementSize == 0) {
+            if (format != GL_RED_INTEGER) {
                 MG_State::pGLContext->RecordError(
                     ErrorCode::InvalidEnum,
                     MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", GetBufferOpName(op),
-                                                 std::format("internalformat 0x{:X} has no known element size.",
-                                                             internalformat)));
+                                                 "Only GL_RED_INTEGER buffer clears are currently supported."));
                 return 0;
             }
 
-            // The pattern is replicated verbatim, which is only the whole story while the client
-            // layout already matches the internal format - the case every entry point in practice
-            // uses, and the only one the conversion machinery here can express. Say so rather than
-            // quietly writing a differently-sized pattern.
-            const SizeT sourceSize = MG_Util::GetInputBytesPerPixel(inputFormat, pixelType);
-            if (sourceSize != elementSize) {
-                MGLOG_W_ONCE("%s: clear pattern is %zu bytes but internalformat 0x%X stores %zu; "
-                        "converting between them is not implemented",
-                        GetBufferOpName(op), sourceSize, internalformat, elementSize);
-            }
-            return elementSize;
+            if (internalformat == GL_R8UI && type == GL_UNSIGNED_BYTE) return sizeof(GLubyte);
+            if (internalformat == GL_R32UI && type == GL_UNSIGNED_INT) return sizeof(GLuint);
+
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", GetBufferOpName(op),
+                                             std::format("Unsupported clear format tuple: internalformat=0x{:X}, "
+                                                         "format=0x{:X}, type=0x{:X}",
+                                                         internalformat, format, type)));
+            return 0;
         }
 
         Bool ValidateBufferClearRange(const SharedPtr<MG_State::GLState::BufferObject>& bufferObject, GLintptr offset,
@@ -376,21 +330,12 @@ namespace MobileGL::MG_Impl::GLImpl {
                     } else if (access & BufferMappingAccessBit::Write) {
                         *params = GL_WRITE_ONLY;
                     } else {
-                        *params = GL_READ_WRITE;
+                        *params = 0;
                     }
                 } else {
-                    // Initial value, and what glUnmapBuffer restores (GL 4.6 core table 6.2).
-                    *params = GL_READ_WRITE;
+                    *params = 0;
                 }
                 break;
-            case GL_BUFFER_ACCESS_FLAGS:
-                // The MapBufferRange flags verbatim; glMapBuffer's access enum has already been
-                // normalised into the same bits. Zero while the buffer is not mapped.
-                *params = bufferObject->IsMapped()
-                    ? static_cast<GLint>(
-                          MG_Util::ConvertBufferMappingAccessToGLEnum(bufferObject->GetMappingAccess()))
-                    : 0;
-                break;
             case GL_BUFFER_MAPPED:
                 *params = bufferObject->IsMapped() ? GL_TRUE : GL_FALSE;
                 break;
@@ -862,10 +807,6 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         Range1D mappedRange = bufferObject->GetMappedRange();
         auto mappingAccess = bufferObject->GetMappingAccess();
-        // GL 4.6 6.5: the error is on OVERLAP with the mapped range, i.e. a half-open
-        // intersection test. There used to be a second test below this one asking only
-        // `offset + size >= mappedRange.start`, which rejects every write that starts
-        // before a mapped tail as well - it made a legal disjoint glBufferSubData fail.
         if (bufferObject->IsMapped() && !(mappingAccess & BufferMappingAccessBit::Persistent) &&
             (offset < mappedRange.end) && (offset + size > mappedRange.start)) {
             MG_State::pGLContext->RecordError(
@@ -876,6 +817,18 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
+        if (bufferObject->IsMapped() && !(mappingAccess & BufferMappingAccessBit::Persistent)) {
+            Range1D mappedRange = bufferObject->GetMappedRange();
+            if (offset + size >= mappedRange.start) {
+                MG_State::pGLContext->RecordError(
+                    ErrorCode::InvalidOperation,
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BufferSubData_State",
+                                                 "Cannot modify a mapped buffer object unless it was "
+                                                 "mapped with GL_MAP_PERSISTENT_BIT."));
+                return;
+            }
+        }
+
         bufferObject->UploadSubData({(void*)data, (SizeT)size}, offset);
     }
 
@@ -925,45 +878,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
-        bufferObject->SyncGpuWrites();
-        bufferObject->DownloadSubData(data, static_cast<SizeT>(offset), static_cast<SizeT>(size));
-    }
-
-    void GetNamedBufferSubData_State(GLuint buffer, GLintptr offset, GLsizeiptr size, void* data) {
-        if (!data) {
-            // Match GetBufferSubData_State: a null pointer is a caller bug, not a GL-specified error.
-            return;
-        }
-
-        if (size < 0 || offset < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetNamedBufferSubData_State",
-                                             "Offset and size must be non-negative."));
-            return;
-        }
-
-        auto bufferObject = GetNamedBufferObject(buffer, BufferOp::GetNamedBufferSubData);
-        if (!bufferObject) return;
-
-        if (static_cast<SizeT>(offset) + static_cast<SizeT>(size) > bufferObject->GetSize()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetNamedBufferSubData_State",
-                                             "Offset and size exceed buffer size."));
-            return;
-        }
-
-        if (bufferObject->IsMapped() &&
-            !(bufferObject->GetMappingAccess() & BufferMappingAccessBit::Persistent)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetNamedBufferSubData_State",
-                                             "Cannot read from a buffer object mapped without GL_MAP_PERSISTENT_BIT."));
-            return;
-        }
-
-        bufferObject->SyncGpuWrites();
         bufferObject->DownloadSubData(data, static_cast<SizeT>(offset), static_cast<SizeT>(size));
     }
 
@@ -1006,11 +920,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void BufferStorage_State(GLenum target, GLsizeiptr size, const void* data, GLbitfield flags) {
-        // Error precedence: "no buffer is bound to target" outranks a bad size or bad
-        // flags, so the binding has to be resolved before either is validated.
-        auto bufferObject = GetBoundBufferObject(target, BufferOp::BufferStorage);
-        if (!bufferObject) return;
-
         if (size <= 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
@@ -1019,6 +928,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
         if (!ValidateStorageFlags(flags, BufferOp::BufferStorage)) return;
 
+        auto bufferObject = GetBoundBufferObject(target, BufferOp::BufferStorage);
+        if (!bufferObject) return;
         if (bufferObject->IsImmutableStorage()) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
@@ -1053,10 +964,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void NamedBufferStorage_State(GLuint buffer, GLsizeiptr size, const void* data, GLbitfield flags) {
-        // Same precedence as BufferStorage_State: the buffer-name error comes first.
-        auto bufferObject = GetNamedBufferObject(buffer, BufferOp::NamedBufferStorage);
-        if (!bufferObject) return;
-
         if (size <= 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
@@ -1065,6 +972,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
         if (!ValidateStorageFlags(flags, BufferOp::NamedBufferStorage)) return;
 
+        auto bufferObject = GetNamedBufferObject(buffer, BufferOp::NamedBufferStorage);
+        if (!bufferObject) return;
         if (bufferObject->IsImmutableStorage()) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
@@ -1442,14 +1351,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
         if (!BufferImpl::ValidateBufferBindingPointTarget(bufferTarget)) return;
         if (!BufferImpl::ValidateBufferBindingPointIndex(bufferTarget, pointIndex)) return;
-        if (bufferTarget == BufferTarget::TransformFeedback && MG_State::pGLContext->IsTransformFeedbackActive()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "Transform feedback buffer bindings cannot change while transform "
-                                             "feedback is active."));
-            return;
-        }
         MG_State::pGLContext->TouchBufferBindingPoint(bufferTarget, pointIndex);
 
         auto& point = MG_State::pGLContext->GetBufferBindingPoint(bufferTarget, pointIndex);
@@ -1457,7 +1358,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (buffer == 0) {
             point.Bind(nullptr);
             point.SetRange(Range1D(0, 0));
-            GetBufferBindingSlot(bufferTarget).Bind(nullptr);
             return;
         }
 
@@ -1476,81 +1376,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         } else {
             point.ClearRange();
         }
-        // The indexed bind also binds to the generic binding point of the same target
-        // (GL 4.6 core 6.1.1). Callers rely on it: the texture_gather tests set up their
-        // SSBO with BindBufferBase and then size it through glBufferData on the generic
-        // target alone, which would otherwise raise GL_INVALID_OPERATION and leave the
-        // buffer with no storage.
-        GetBufferBindingSlot(bufferTarget).Bind(bufferObject);
-    }
-
-    // GL 4.6 core 6.1.1: the constraints glBindBufferRange puts on the (offset, size) pair.
-    // Every one of them is INVALID_VALUE, and all of them are checked before a single piece
-    // of state is written - a rejected bind must leave the binding point exactly as it was.
-    // They apply only to a non-zero buffer: buffer 0 detaches the binding point and ignores
-    // offset and size, which is also how glBindBuffersRange spells "reset this element"
-    // (a NULL buffers array, or a zero entry inside one).
-    static Bool ValidateBufferRangeOffsetAndSize(GLenum target, GLintptr offset, GLsizeiptr size,
-                                                 const char* funcName, Bool hasBuffer = true) {
-        if (hasBuffer && size <= 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", funcName,
-                                             std::format("size ({}) must be greater than zero.", size)));
-            return false;
-        }
-        if (offset < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", funcName,
-                                             std::format("offset ({}) must not be negative.", offset)));
-            return false;
-        }
-        // GL_UNIFORM_BUFFER and GL_SHADER_STORAGE_BUFFER each constrain the offset to their own
-        // implementation-defined alignment, which glGetIntegerv already answers.
-        GLenum alignmentQuery = GL_NONE;
-        if (target == GL_SHADER_STORAGE_BUFFER) {
-            alignmentQuery = GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT;
-        } else if (target == GL_UNIFORM_BUFFER) {
-            alignmentQuery = GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT;
-        }
-        if (alignmentQuery != GL_NONE) {
-            GLint alignment = 0;
-            GetIntegerv(alignmentQuery, &alignment);
-            if (alignment > 0 && (offset % static_cast<GLintptr>(alignment)) != 0) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", funcName,
-                        std::format("offset ({}) must be a multiple of {} ({}).", offset,
-                                    MG_Util::ConvertGLEnumToString(alignmentQuery), alignment)));
-                return false;
-            }
-        }
-        // 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) {
-            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)));
-            return false;
-        }
-        return true;
     }
 
     void BindBufferRange_State(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {
@@ -1559,20 +1384,6 @@ 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 (bufferTarget == BufferTarget::TransformFeedback && MG_State::pGLContext->IsTransformFeedbackActive()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "Transform feedback buffer bindings cannot change while transform "
-                                             "feedback is active."));
-            return;
-        }
         MG_State::pGLContext->TouchBufferBindingPoint(bufferTarget, index);
 
         auto& point = MG_State::pGLContext->GetBufferBindingPoint(bufferTarget, index);
@@ -1580,7 +1391,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         if (buffer == 0) {
             point.Bind(nullptr);
             point.SetRange(Range1D(0, 0));
-            GetBufferBindingSlot(bufferTarget).Bind(nullptr);
             return;
         }
 
@@ -1598,8 +1408,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         } else {
             point.ClearRange();
         }
-        // Also the generic binding point, exactly as BindBufferBase (GL 4.6 core 6.1.1).
-        GetBufferBindingSlot(bufferTarget).Bind(bufferObject);
     }
 
     /* @INSERTION_POINT:FUNCTION_IMPLEMENTATION@ */
@@ -1709,10 +1517,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         BufferSubData_State(target, offset, size, data);
     }
 
-    void GetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, void* data) {
-        GetNamedBufferSubData_State(buffer, offset, size, data);
-    }
-
     void GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void* data) {
         GetBufferSubData_State(target, offset, size, data);
     }
@@ -1738,54 +1542,16 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     // ARB_multi_bind: defined by the spec as equivalent to a loop over the single-bind entry
-    // points (with buffer 0 resetting the binding point) - but only AFTER an up-front check
-    // of the whole [first, first + count) range. Looping straight into the single-bind entry
-    // points reports the single-bind INVALID_VALUE for an out-of-range index instead of the
-    // multi-bind INVALID_OPERATION, and binds the in-range prefix before failing.
-    static Bool ValidateMultiBindBufferRange(GLenum target, GLuint first, GLsizei count, const char* funcName) {
-        BufferTarget bufferTarget = MG_Util::ConvertGLEnumToBufferTarget(target);
-        if (!BufferImpl::ValidateBufferBindingPointTarget(bufferTarget)) return false;
-        return BufferImpl::ValidateBufferBindingPointRange(bufferTarget, first, count, funcName);
-    }
-
-    // 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;
-    }
-
+    // points (with buffer 0 resetting the binding point).
     void BindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint* buffers) {
-        if (!ValidateMultiBindBufferRange(target, first, count, __func__)) return;
         for (GLsizei i = 0; i < count; ++i) {
-            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);
         }
     }
 
-    // The (offset, size) constraints are the one part of glBindBuffersRange that stays
-    // per-element: ARB_multi_bind checks them separately for each binding point, leaves that
-    // point unchanged on failure, and still applies the remaining elements - which is exactly
-    // what looping into BindBufferRange_State does. Only the [first, first + count) range is
-    // an up-front, all-or-nothing check. Elements that name buffer 0 (or a NULL buffers array)
-    // reset the binding point through BindBufferBase_State and carry no offset/size to check.
     void BindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets,
                           const GLsizeiptr* sizes) {
-        if (!ValidateMultiBindBufferRange(target, first, count, __func__)) return;
         for (GLsizei i = 0; i < count; ++i) {
-            if (buffers && !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

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

MobileGL/MG_Impl/GLImpl/Buffer/Validators.cpp

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

MobileGL/MG_Impl/GLImpl/Buffer/Validators.h

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

MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.cpp

@@ -11,11 +11,10 @@
 #include <MG_State/GLState/Core.h>
 #include <MG_State/EGLState/Core.h>
 #include <MG_Backend/BackendObjects.h>
-#include "../Getter/GL_Getter.h"
 
 namespace MobileGL::MG_Impl::GLImpl {
-    static Bool ValidateProgramForExecution(const SharedPtr<MG_State::GLState::ProgramObject>& currentProgram,
-                                            const char* functionName) {
+    static Bool ValidateCurrentProgramForExecution(const char* functionName) {
+        const auto& currentProgram = MG_State::pGLContext->GetCurrentProgram();
         if (!currentProgram) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
@@ -34,17 +33,10 @@ namespace MobileGL::MG_Impl::GLImpl {
         return true;
     }
 
-    static Bool ValidateCurrentProgramForExecution(const char* functionName) {
-        return ValidateProgramForExecution(MG_State::pGLContext->GetProgramForDraw(), functionName);
-    }
-
-    // A dispatch resolves its program through the DISPATCH accessor: with a pipeline bound
-    // that is the pipeline's compute stage program, not the graphics composite a draw would
-    // build - which no longer contains a compute stage to find at all.
     static Bool ValidateCurrentProgramForCompute(const char* functionName) {
-        const auto& currentProgram = MG_State::pGLContext->GetProgramForDispatch();
-        if (!ValidateProgramForExecution(currentProgram, functionName)) return false;
+        if (!ValidateCurrentProgramForExecution(functionName)) return false;
 
+        const auto& currentProgram = MG_State::pGLContext->GetCurrentProgram();
         if (currentProgram->GetShaderIndexByStage(ShaderStage::Compute) < 0) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidOperation,
@@ -56,109 +48,7 @@ namespace MobileGL::MG_Impl::GLImpl {
         return true;
     }
 
-    // Primitives a draw of `count` vertices in `mode` assembles (0 for
-    // incomplete primitives). Used for the CPU-side transform feedback
-    // primitive accounting.
-    static Uint64 CountPrimitivesForDraw(GLenum mode, GLsizei count) {
-        if (count <= 0) return 0;
-        switch (mode) {
-        case GL_POINTS: return static_cast<Uint64>(count);
-        case GL_LINES: return static_cast<Uint64>(count / 2);
-        case GL_LINE_STRIP: return count >= 2 ? static_cast<Uint64>(count - 1) : 0;
-        case GL_LINE_LOOP: return count >= 2 ? static_cast<Uint64>(count) : 0;
-        case GL_TRIANGLES: return static_cast<Uint64>(count / 3);
-        case GL_TRIANGLE_STRIP:
-        case GL_TRIANGLE_FAN: return count >= 3 ? static_cast<Uint64>(count - 2) : 0;
-        default: return 0;
-        }
-    }
-
-    // Accumulate the transform feedback primitive counter for a captured draw.
-    // Draws without a geometry stage write exactly the primitives they assemble,
-    // clamped by the capture buffers' remaining capacity (a full buffer stops
-    // recording whole primitives, which is what PRIMITIVES_WRITTEN reports).
-    // Geometry amplification is not modelled here.
-    static void AccountTransformFeedbackPrimitives(GLenum mode, GLsizei count) {
-        if (!MG_State::pGLContext->IsTransformFeedbackActive()) return;
-        // A paused span captures nothing, so a draw made while paused contributes to
-        // PRIMITIVES_GENERATED but not to TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN.
-        if (MG_State::pGLContext->IsTransformFeedbackPaused()) {
-            MG_State::pGLContext->AddTransformFeedbackPausedPrimitives(CountPrimitivesForDraw(mode, count));
-            return;
-        }
-        Uint64 primitives = CountPrimitivesForDraw(mode, count);
-        if (primitives == 0) return;
-        MG_State::pGLContext->AddTransformFeedbackInputPrimitives(primitives);
-
-        Uint64 verticesPerPrimitive = 1;
-        switch (mode) {
-        case GL_LINES:
-        case GL_LINE_STRIP:
-        case GL_LINE_LOOP:
-            verticesPerPrimitive = 2;
-            break;
-        case GL_TRIANGLES:
-        case GL_TRIANGLE_STRIP:
-        case GL_TRIANGLE_FAN:
-            verticesPerPrimitive = 3;
-            break;
-        default:
-            break;
-        }
-
-        const auto& program = MG_State::pGLContext->GetTransformFeedbackProgram();
-        if (program != nullptr) {
-            // Capacity in captured vertices = the tightest bound buffer.
-            Uint64 capacityVertices = ~0ull;
-            for (SizeT i = 0; i < program->GetTransformFeedbackBufferCount(); ++i) {
-                const Uint32 stride = program->GetTransformFeedbackStride(static_cast<Uint32>(i));
-                if (stride == 0) continue;
-                const auto& point = MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::TransformFeedback,
-                                                                                static_cast<Uint>(i));
-                const Range1D range = point.GetRange();
-                const Uint64 bytes = range.end > range.start ? static_cast<Uint64>(range.end - range.start) : 0;
-                capacityVertices = std::min<Uint64>(capacityVertices, bytes / stride);
-            }
-            if (capacityVertices != ~0ull) {
-                const Uint64 usedVertices = MG_State::pGLContext->GetTransformFeedbackCapturedVertices();
-                const Uint64 remainingVertices = capacityVertices > usedVertices ? capacityVertices - usedVertices : 0;
-                primitives = std::min<Uint64>(primitives, remainingVertices / verticesPerPrimitive);
-            }
-        }
-        MG_State::pGLContext->AddTransformFeedbackPrimitives(primitives);
-        MG_State::pGLContext->AddTransformFeedbackCapturedVertices(primitives * verticesPerPrimitive);
-    }
-
-    // Every primitive mode a draw command accepts (GL 4.6 core table 10.1, plus
-    // GL_PATCHES for the tessellation pipeline). Anything else is GL_INVALID_ENUM.
-    static Bool IsAcceptedPrimitiveMode(GLenum mode) {
-        switch (mode) {
-        case GL_POINTS:
-        case GL_LINES:
-        case GL_LINE_LOOP:
-        case GL_LINE_STRIP:
-        case GL_LINES_ADJACENCY:
-        case GL_LINE_STRIP_ADJACENCY:
-        case GL_TRIANGLES:
-        case GL_TRIANGLE_STRIP:
-        case GL_TRIANGLE_FAN:
-        case GL_TRIANGLES_ADJACENCY:
-        case GL_TRIANGLE_STRIP_ADJACENCY:
-        case GL_PATCHES:
-            return true;
-        default:
-            return false;
-        }
-    }
-
     static Bool ValidatePrimitiveModeForBackend(const char* functionName, GLenum mode) {
-        if (!IsAcceptedPrimitiveMode(mode)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName, "mode is not an accepted primitive type."));
-            return false;
-        }
-
         const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
         if (!activeBackendObject) {
             MG_State::pGLContext->RecordError(
@@ -167,6 +57,15 @@ namespace MobileGL::MG_Impl::GLImpl {
             return false;
         }
 
+        if (activeBackendObject->GetBackendType() == BackendType::DirectVulkan && mode == GL_LINE_LOOP) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>(
+                    "MG_Impl/GLImpl", functionName,
+                    "Primitive mode GL_LINE_LOOP is not supported by the DirectVulkan backend."));
+            return false;
+        }
+
         const auto& vao = MG_State::pGLContext->GetBoundVertexArray();
         if (vao && vao->GetExternalIndex() == 0 && !MG_State::IsRelaxedSemanticsActive()) {
             MG_State::pGLContext->RecordError(
@@ -176,133 +75,9 @@ namespace MobileGL::MG_Impl::GLImpl {
             return false;
         }
 
-        // A geometry stage only accepts the primitive types that decompose into its declared
-        // input primitive (GL 4.6 core 11.3.1); anything else is INVALID_OPERATION. GL_PATCHES
-        // is the tessellation pipeline's input and reaches the geometry stage already
-        // converted, so it is not constrained here.
-        const auto& currentProgram = MG_State::pGLContext->GetProgramForDraw();
-        const GLenum gsInput = currentProgram ? currentProgram->GetGeometryInputType() : GL_NONE;
-        if (gsInput != GL_NONE && mode != GL_PATCHES) {
-            Bool compatible = false;
-            switch (gsInput) {
-            case GL_POINTS:
-                compatible = mode == GL_POINTS;
-                break;
-            case GL_LINES:
-                compatible = mode == GL_LINES || mode == GL_LINE_STRIP || mode == GL_LINE_LOOP;
-                break;
-            case GL_LINES_ADJACENCY:
-                compatible = mode == GL_LINES_ADJACENCY || mode == GL_LINE_STRIP_ADJACENCY;
-                break;
-            case GL_TRIANGLES:
-                compatible = mode == GL_TRIANGLES || mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN;
-                break;
-            case GL_TRIANGLES_ADJACENCY:
-                compatible = mode == GL_TRIANGLES_ADJACENCY || mode == GL_TRIANGLE_STRIP_ADJACENCY;
-                break;
-            default:
-                break;
-            }
-            if (!compatible) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", functionName,
-                        "Primitive mode is incompatible with the geometry shader's input primitive type."));
-                return false;
-            }
-        }
-
-        // While transform feedback is active the draw's primitive type must match
-        // the feedback primitive mode (GL 3.3 core 13.2.2). With a geometry shader
-        // the constraint moves to the shader's output primitive type instead, so
-        // the draw mode itself is unconstrained here. A paused span is exempt: it
-        // captures nothing, so there is nothing for the mode to be incompatible with
-        // (GL 4.6 core 13.2.3).
-        if (MG_State::pGLContext->IsTransformFeedbackActive() &&
-            !MG_State::pGLContext->IsTransformFeedbackPaused() &&
-            !(MG_State::pGLContext->GetTransformFeedbackProgram() &&
-              MG_State::pGLContext->GetTransformFeedbackProgram()->GetShaderIndexByStage(ShaderStage::Geometry) >= 0)) {
-            const GLenum feedbackMode = MG_State::pGLContext->GetTransformFeedbackPrimitiveMode();
-            Bool compatible = false;
-            switch (feedbackMode) {
-            case GL_POINTS:
-                compatible = mode == GL_POINTS;
-                break;
-            case GL_LINES:
-                compatible = mode == GL_LINES || mode == GL_LINE_STRIP || mode == GL_LINE_LOOP;
-                break;
-            case GL_TRIANGLES:
-                compatible = mode == GL_TRIANGLES || mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN;
-                break;
-            default:
-                break;
-            }
-            if (!compatible) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", functionName,
-                        "Primitive mode is incompatible with the active transform feedback primitive mode."));
-                return false;
-            }
-        }
-
         return true;
     }
 
-    // Byte size of the command structures the indirect draws read (GL 4.6 core 10.3.10).
-    constexpr SizeT kDrawArraysIndirectCommandBytes = 4 * sizeof(Uint32);
-    constexpr SizeT kDrawElementsIndirectCommandBytes = 5 * sizeof(Uint32);
-
-    // Shared preconditions of every *Indirect draw: `indirect` is a byte offset into the
-    // buffer bound to GL_DRAW_INDIRECT_BUFFER, must be 4-byte aligned, and the whole
-    // command has to lie inside that buffer.
-    static Bool ValidateIndirectDrawSource(const char* functionName, const void* indirect, SizeT commandBytes) {
-        const auto offset = reinterpret_cast<uintptr_t>(indirect);
-        if (offset % 4 != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             "indirect offset must be a multiple of 4."));
-            return false;
-        }
-
-        const auto& buffer = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
-        if (!buffer) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             "No buffer is bound to GL_DRAW_INDIRECT_BUFFER."));
-            return false;
-        }
-
-        if (offset + commandBytes > buffer->GetSize()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             "The indirect command extends past the end of the bound "
-                                             "GL_DRAW_INDIRECT_BUFFER."));
-            return false;
-        }
-        return true;
-    }
-
-    // Index type accepted by the DrawElements family (GL 4.6 core 10.3.9).
-    static Bool ValidateDrawElementsIndexType(const char* functionName, GLenum type) {
-        switch (type) {
-        case GL_UNSIGNED_BYTE:
-        case GL_UNSIGNED_SHORT:
-        case GL_UNSIGNED_INT:
-            return true;
-        default:
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName, "type is not an accepted index type."));
-            return false;
-        }
-    }
-
     void Clear_Backend(GLbitfield mask) {
 #ifdef TRACY_ENABLE
         ZoneScopedC(TRACY_ZONECOLOR_BACKEND);
@@ -481,63 +256,10 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
         if (!ValidateCurrentProgramForCompute(__func__)) return;
-        // GL 4.6 core 19: each num_groups_* must be within GL_MAX_COMPUTE_WORK_GROUP_COUNT
-        // for its dimension. GetIntegeri_v already floors that at the spec minimum.
-        const GLuint numGroups[3] = {numGroupsX, numGroupsY, numGroupsZ};
-        for (GLuint dimension = 0; dimension < 3; ++dimension) {
-            GLint maxGroups = 0;
-            GetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, dimension, &maxGroups);
-            if (numGroups[dimension] > static_cast<GLuint>(std::max(maxGroups, 0))) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                                 "num_groups exceeds GL_MAX_COMPUTE_WORK_GROUP_COUNT for dimension " +
-                                                     std::to_string(dimension) + "."));
-                return;
-            }
-        }
         dispatchCompute(numGroupsX, numGroupsY, numGroupsZ);
     }
 
     void DispatchComputeIndirect(GLintptr indirect) {
-        // Argument and binding validation runs FIRST. Both are properties of the call and of GL
-        // state, so a context whose backend cannot dispatch at all must still report the
-        // argument error the spec names rather than masking every one of them with
-        // "unsupported" - which is what put GL_INVALID_OPERATION where
-        // KHR-GL43.compute_shader.api-indirect expects GL_INVALID_VALUE.
-        //
-        // GL 4.6 core 19: `indirect` is a byte offset into GL_DISPATCH_INDIRECT_BUFFER -
-        // negative or misaligned is INVALID_VALUE, nothing bound is INVALID_OPERATION.
-        if (indirect < 0 || (indirect % 4) != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "indirect must be non-negative and a multiple of 4."));
-            return;
-        }
-        const auto& indirectBuffer =
-            MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DispatchIndirect).GetBoundObject();
-        if (!indirectBuffer) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "No buffer is bound to GL_DISPATCH_INDIRECT_BUFFER."));
-            return;
-        }
-        // ...and the same INVALID_OPERATION covers "the command would source data beyond the end
-        // of the bound buffer object" (GL 4.6 core 19): the dispatch reads three uints starting
-        // at `indirect`.
-        constexpr SizeT kDispatchIndirectCommandSize = 3 * sizeof(Uint32);
-        if (static_cast<SizeT>(indirect) + kDispatchIndirectCommandSize > indirectBuffer->GetSize()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl", __func__,
-                    std::format("indirect ({}) + 12 bytes runs past the end of the {}-byte buffer bound to "
-                                "GL_DISPATCH_INDIRECT_BUFFER.",
-                                indirect, indirectBuffer->GetSize())));
-            return;
-        }
         auto dispatchComputeIndirect = MG_Backend::gBackendFunctionsTable.GL.DispatchComputeIndirect;
         if (!dispatchComputeIndirect) {
             MG_State::pGLContext->RecordError(
@@ -550,28 +272,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         dispatchComputeIndirect(indirect);
     }
 
-    void PatchParameteri(GLenum pname, GLint value) {
-        if (pname != GL_PATCH_VERTICES) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "pname must be GL_PATCH_VERTICES."));
-            return;
-        }
-        GLint maxPatchVertices = 32;
-        GetIntegerv(GL_MAX_PATCH_VERTICES, &maxPatchVertices);
-        if (value <= 0 || value > maxPatchVertices) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "value must be in [1, GL_MAX_PATCH_VERTICES]."));
-            return;
-        }
-        MG_State::pGLContext->SetPatchVertices(static_cast<Uint>(value));
-        if (const auto patchParameteri = MG_Backend::gBackendFunctionsTable.GL.PatchParameteri) {
-            patchParameteri(pname, value);
-        }
-    }
-
     void MemoryBarrier(GLbitfield barriers) {
         auto memoryBarrier = MG_Backend::gBackendFunctionsTable.GL.MemoryBarrier;
         if (!memoryBarrier) {
@@ -607,80 +307,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         MultiDrawArraysIndirect_Backend(mode, indirect, drawcount, stride);
     }
 
-    // ARB_indirect_parameters / GL 4.6 core 10.4: `drawcount` is a byte offset into the buffer
-    // bound to PARAMETER_BUFFER and holds one uint draw count. Three errors have to be raised
-    // before the call reaches a backend, and none of them was
-    // (KHR-GL46.indirect_parameters_tests.MultiDraw{Arrays,Elements}IndirectCount):
-    //   * drawcount not a multiple of four                                  INVALID_VALUE
-    //   * nothing bound to PARAMETER_BUFFER, or the uint at `drawcount`
-    //     lies past its end                                                 INVALID_OPERATION
-    //   * maxdrawcount commands from `indirect` run past the end of the
-    //     buffer bound to DRAW_INDIRECT_BUFFER                              INVALID_OPERATION
-    static Bool ValidateIndirectCountDraw(GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount,
-                                          GLsizei stride, SizeT commandSize, const char* funcName) {
-        if (drawcount < 0 || (drawcount % 4) != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", funcName,
-                                             "drawcount must be non-negative and a multiple of four."));
-            return false;
-        }
-        const auto& parameterBuffer =
-            MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::Parameter).GetBoundObject();
-        if (!parameterBuffer ||
-            static_cast<SizeT>(drawcount) + sizeof(Uint32) > parameterBuffer->GetSize()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", funcName,
-                                             "No buffer is bound to GL_PARAMETER_BUFFER, or drawcount runs past "
-                                             "the end of the one that is."));
-            return false;
-        }
-        if (maxdrawcount < 0 || stride < 0 || indirect < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", funcName,
-                                             "indirect, maxdrawcount and stride must all be non-negative."));
-            return false;
-        }
-        const SizeT effectiveStride = stride != 0 ? static_cast<SizeT>(stride) : commandSize;
-        const auto& indirectBuffer =
-            MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
-        // A zero maxdrawcount sources nothing, so it cannot run past anything.
-        const SizeT requiredBytes =
-            maxdrawcount == 0 ? 0
-                              : static_cast<SizeT>(indirect) +
-                                    static_cast<SizeT>(maxdrawcount - 1) * effectiveStride + commandSize;
-        if (!indirectBuffer || requiredBytes > indirectBuffer->GetSize()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", funcName,
-                                             "maxdrawcount commands would be sourced from beyond the end of the "
-                                             "buffer bound to GL_DRAW_INDIRECT_BUFFER."));
-            return false;
-        }
-        return true;
-    }
-
     void MultiDrawElementsIndirectCount(GLenum mode, GLenum type, const void* indirect, GLintptr drawcount,
                                         GLsizei maxdrawcount, GLsizei stride) {
-        // Argument validation before the backend-availability check: see DispatchComputeIndirect.
-        // DrawElementsIndirectCommand: count, instanceCount, firstIndex, baseVertex, baseInstance.
-        if (!ValidateIndirectCountDraw(reinterpret_cast<GLintptr>(indirect), drawcount, maxdrawcount, stride,
-                                       5 * sizeof(Uint32), __func__)) {
-            return;
-        }
-        // The only two draw entry points that were missing this. Every backend draw path
-        // dereferences GetProgramForDraw() unconditionally, so "no current program" has to be
-        // stopped here or it is a null dereference rather than the INVALID_OPERATION the spec
-        // asks for - reachable through a bound pipeline that supplies no graphics stage.
-        //
-        // AFTER the argument checks, unlike the sibling draw entry points, and deliberately:
-        // the argument rules here are properties of the call rather than of GL state, and
-        // NegativeApiErrorsTest.IndirectParameterDrawsCheckBothBuffers pins the INVALID_VALUE
-        // they produce for a call made with no program bound. Same precedence decision, and
-        // the same reason, as DispatchComputeIndirect above.
-        if (!ValidateCurrentProgramForExecution(__func__)) return;
         auto multiDrawElementsIndirectCount = MG_Backend::gBackendFunctionsTable.GL.MultiDrawElementsIndirectCount;
         if (!multiDrawElementsIndirectCount) {
             MG_State::pGLContext->RecordError(
@@ -694,14 +322,6 @@ namespace MobileGL::MG_Impl::GLImpl {
 
     void MultiDrawArraysIndirectCount(GLenum mode, const void* indirect, GLintptr drawcount,
                                       GLsizei maxdrawcount, GLsizei stride) {
-        // Argument validation before the backend-availability check: see DispatchComputeIndirect.
-        // DrawArraysIndirectCommand: count, instanceCount, first, baseInstance.
-        if (!ValidateIndirectCountDraw(reinterpret_cast<GLintptr>(indirect), drawcount, maxdrawcount, stride,
-                                       4 * sizeof(Uint32), __func__)) {
-            return;
-        }
-        // See MultiDrawElementsIndirectCount, including why this one goes last.
-        if (!ValidateCurrentProgramForExecution(__func__)) return;
         auto multiDrawArraysIndirectCount = MG_Backend::gBackendFunctionsTable.GL.MultiDrawArraysIndirectCount;
         if (!multiDrawArraysIndirectCount) {
             MG_State::pGLContext->RecordError(
@@ -757,8 +377,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     void DrawElementsIndirect(GLenum mode, GLenum type, const void* indirect) {
         if (!ValidateCurrentProgramForExecution(__func__)) return;
         if (!ValidatePrimitiveModeForBackend(__func__, mode)) return;
-        if (!ValidateDrawElementsIndexType(__func__, type)) return;
-        if (!ValidateIndirectDrawSource(__func__, indirect, kDrawElementsIndirectCommandBytes)) return;
         DrawElementsIndirect_Backend(mode, type, indirect);
     }
 
@@ -778,21 +396,18 @@ namespace MobileGL::MG_Impl::GLImpl {
     void DrawArraysIndirect(GLenum mode, const void* indirect) {
         if (!ValidateCurrentProgramForExecution(__func__)) return;
         if (!ValidatePrimitiveModeForBackend(__func__, mode)) return;
-        if (!ValidateIndirectDrawSource(__func__, indirect, kDrawArraysIndirectCommandBytes)) return;
         DrawArraysIndirect_Backend(mode, indirect);
     }
 
     void DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void* indices, GLint basevertex) {
         if (!ValidateCurrentProgramForExecution(__func__)) return;
         if (!ValidatePrimitiveModeForBackend(__func__, mode)) return;
-        AccountTransformFeedbackPrimitives(mode, count);
         DrawElementsBaseVertex_Backend(mode, count, type, indices, basevertex);
     }
 
     void DrawArrays(GLenum mode, GLint first, GLsizei count) {
         if (!ValidateCurrentProgramForExecution(__func__)) return;
         if (!ValidatePrimitiveModeForBackend(__func__, mode)) return;
-        AccountTransformFeedbackPrimitives(mode, count);
         DrawArrays_Backend(mode, first, count);
     }
 
@@ -829,495 +444,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) {
         if (!ValidateCurrentProgramForExecution(__func__)) return;
         if (!ValidatePrimitiveModeForBackend(__func__, mode)) return;
-        AccountTransformFeedbackPrimitives(mode, count);
         DrawElements_Backend(mode, count, type, indices);
     }
 
-    void BeginTransformFeedback(GLenum primitiveMode) {
-        if (primitiveMode != GL_POINTS && primitiveMode != GL_LINES && primitiveMode != GL_TRIANGLES) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "primitiveMode must be GL_POINTS, GL_LINES or GL_TRIANGLES."));
-            return;
-        }
-        if (MG_State::pGLContext->IsTransformFeedbackActive()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "Transform feedback is already active."));
-            return;
-        }
-        const auto& program = MG_State::pGLContext->GetProgramForDraw();
-        if (!program || !program->GetLinkStatus() || program->GetTransformFeedbackVaryingCount() == 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl", __func__,
-                    "No program with transform feedback varyings is active."));
-            return;
-        }
-        // Every capture buffer slot the program's mode uses must have a buffer bound. A slot
-        // of stride 0 - two consecutive gl_NextBuffer entries - captures nothing and so needs
-        // no binding.
-        const SizeT usedBufferCount = program->GetTransformFeedbackBufferCount();
-        for (SizeT i = 0; i < usedBufferCount; ++i) {
-            if (program->GetTransformFeedbackStride(static_cast<Uint32>(i)) == 0) continue;
-            const auto& point = MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::TransformFeedback,
-                                                                            static_cast<Uint>(i));
-            if (point.GetBoundObject() == nullptr) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl", __func__,
-                        "Transform feedback buffer binding point " + std::to_string(i) + " has no buffer bound."));
-                return;
-            }
-        }
-        MG_State::pGLContext->BeginTransformFeedback(primitiveMode, program);
-        if (const auto beginXfb = MG_Backend::gBackendFunctionsTable.GL.BeginTransformFeedback) {
-            beginXfb(primitiveMode);
-        }
-    }
-
-    // Vulkan transform feedback captures triangle strips in plain (i, i+1, i+2)
-    // vertex order, but GL decomposes odd strip triangles as (i+1, i, i+2)
-    // (GL 4.6 table 10.1). With the geometry stage's statically-known strip
-    // lengths the captured records are reordered in place: swap the first two
-    // vertex records of every odd triangle within each emitted strip.
-    static void FixupGsStripCaptureOrder(const SharedPtr<MG_State::GLState::ProgramObject>& program,
-                                         Uint64 inputPrimitives) {
-        // Only Vulkan-order captures need this. A backend that runs the capture on its
-        // own GL/ES driver (it owns the span, hence the EndTransformFeedback entry) has
-        // already produced GL's vertex order, and reordering it again would corrupt it.
-        if (MG_Backend::gBackendFunctionsTable.GL.EndTransformFeedback != nullptr) {
-            return;
-        }
-        if (program == nullptr || !program->HasGsTriangleStripCaptureFixup() || inputPrimitives == 0) {
-            return;
-        }
-        const auto& stripTriangles = program->GetGsStripTriangles();
-
-        // Global triangle indices whose leading vertex pair must swap.
-        Vector<Uint64> swapTriangles;
-        Uint64 triangleBase = 0;
-        for (Uint64 input = 0; input < inputPrimitives; ++input) {
-            for (const Uint32 stripLength : stripTriangles) {
-                for (Uint32 t = 1; t < stripLength; t += 2) {
-                    swapTriangles.push_back(triangleBase + t);
-                }
-                triangleBase += stripLength;
-            }
-        }
-        if (swapTriangles.empty()) {
-            return;
-        }
-
-        for (SizeT bufferIndex = 0; bufferIndex < program->GetTransformFeedbackBufferCount(); ++bufferIndex) {
-            const Uint32 stride = program->GetTransformFeedbackStride(static_cast<Uint32>(bufferIndex));
-            if (stride == 0) continue;
-            const auto& bindingPoint =
-                MG_State::pGLContext->GetBufferBindingPoint(BufferTarget::TransformFeedback,
-                                                            static_cast<Uint>(bufferIndex));
-            const auto& buffer = bindingPoint.GetBoundObject();
-            if (buffer == nullptr) continue;
-            const Range1D range = bindingPoint.GetRange();
-            const Uint8* mapped = buffer->MappedData();
-            if (mapped == nullptr) continue;
-            // The geometry stage amplifies, so the CPU vertex counter does not bound
-            // the capture; the binding range's whole-triangle capacity does.
-            const Uint64 rangeBytes = range.end > range.start ? static_cast<Uint64>(range.end - range.start) : 0;
-            const Uint64 capturedTriangles = std::min<Uint64>(triangleBase, (rangeBytes / stride) / 3);
-
-            // Observed Vulkan capture order for odd strip triangles is (i, i+2, i+1)
-            // (winding preserved by swapping the trailing pair); GL wants
-            // (i+1, i, i+2), which is one rotation away: (a,b,c) -> (c,a,b).
-            Vector<Uint8> scratch(stride);
-            for (const Uint64 triangle : swapTriangles) {
-                if (triangle >= capturedTriangles) break;
-                const SizeT v0Offset = static_cast<SizeT>(range.start) + static_cast<SizeT>(triangle * 3) * stride;
-                const SizeT v1Offset = v0Offset + stride;
-                const SizeT v2Offset = v1Offset + stride;
-                Memcpy(scratch.data(), mapped + v2Offset, stride);
-                buffer->WritebackFromBackend({const_cast<Uint8*>(mapped) + v1Offset, stride}, v2Offset);
-                buffer->WritebackFromBackend({const_cast<Uint8*>(mapped) + v0Offset, stride}, v1Offset);
-                buffer->WritebackFromBackend({scratch.data(), stride}, v0Offset);
-            }
-        }
-    }
-
-    void EndTransformFeedback(void) {
-        if (!MG_State::pGLContext->IsTransformFeedbackActive()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "Transform feedback is not active."));
-            return;
-        }
-        const auto capturedProgram = MG_State::pGLContext->GetTransformFeedbackProgram();
-        const Uint64 inputPrimitives = MG_State::pGLContext->GetTransformFeedbackInputPrimitives();
-        // Closed while the capture state is still active: a backend that captures
-        // through its own driver reads the capture program and buffer bindings here.
-        if (const auto endXfb = MG_Backend::gBackendFunctionsTable.GL.EndTransformFeedback) {
-            endXfb();
-        }
-        MG_State::pGLContext->EndTransformFeedback();
-        // Captured results must be visible to MapBuffer/GetBufferSubData after
-        // End; the capture targets are host-coherent GPU memory, so completing
-        // the GPU work is all that is required.
-        auto& backendGL = MG_Backend::gBackendFunctionsTable.GL;
-        if (backendGL.FenceSync && backendGL.ClientWaitSync) {
-            if (auto sync = backendGL.FenceSync()) {
-                backendGL.ClientWaitSync(sync, GL_SYNC_FLUSH_COMMANDS_BIT, ~0ull);
-                if (backendGL.DeleteSync) {
-                    backendGL.DeleteSync(sync);
-                }
-            }
-        }
-        FixupGsStripCaptureOrder(capturedProgram, inputPrimitives);
-    }
-
-    void PauseTransformFeedback(void) {
-        if (!MG_State::pGLContext->IsTransformFeedbackActive() ||
-            MG_State::pGLContext->IsTransformFeedbackPaused()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "Transform feedback is not active, or is already paused."));
-            return;
-        }
-        MG_State::pGLContext->SetTransformFeedbackPaused(true);
-        if (const auto pauseXfb = MG_Backend::gBackendFunctionsTable.GL.PauseTransformFeedback) {
-            pauseXfb();
-        }
-    }
-
-    void ResumeTransformFeedback(void) {
-        if (!MG_State::pGLContext->IsTransformFeedbackActive() ||
-            !MG_State::pGLContext->IsTransformFeedbackPaused()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "Transform feedback is not paused."));
-            return;
-        }
-        MG_State::pGLContext->SetTransformFeedbackPaused(false);
-        if (const auto resumeXfb = MG_Backend::gBackendFunctionsTable.GL.ResumeTransformFeedback) {
-            resumeXfb();
-        }
-    }
-
-    void GenTransformFeedbacks(GLsizei n, GLuint* ids) {
-        if (n < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "n must be non-negative."));
-            return;
-        }
-        if (n == 0 || ids == nullptr) return;
-        Vector<Uint> names;
-        MG_State::pGLContext->GenTransformFeedbackNames(static_cast<Uint>(n), names);
-        Memcpy(ids, names.data(), static_cast<SizeT>(n) * sizeof(GLuint));
-    }
-
-    void CreateTransformFeedbacks(GLsizei n, GLuint* ids) {
-        if (n < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "n must be non-negative."));
-            return;
-        }
-        if (n == 0 || ids == nullptr) return;
-        Vector<Uint> names;
-        MG_State::pGLContext->GenTransformFeedbackNames(static_cast<Uint>(n), names);
-        // Unlike glGenTransformFeedbacks, the names are objects immediately: there is no bind step
-        // to create them from (GL 4.6 core 13.2.1).
-        for (const Uint name : names) {
-            MG_State::pGLContext->CreateTransformFeedbackObject(name);
-        }
-        Memcpy(ids, names.data(), static_cast<SizeT>(n) * sizeof(GLuint));
-    }
-
-    namespace {
-        // Shared front half of the by-name transform feedback entry points: the object has to exist
-        // (INVALID_OPERATION otherwise) before anything else about the call is looked at.
-        Bool ValidateNamedTransformFeedback(GLuint xfb, const char* functionName) {
-            if (!MG_State::pGLContext->IsTransformFeedbackObject(xfb)) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                                 std::to_string(xfb) + " is not a transform feedback object."));
-                return false;
-            }
-            return true;
-        }
-
-        Bool ValidateTransformFeedbackBufferIndex(GLuint index, const char* functionName) {
-            if (index >= MG_State::GLState::GLContext::MAX_TRANSFORM_FEEDBACK_BUFFERS) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                                 "index exceeds GL_MAX_TRANSFORM_FEEDBACK_BUFFERS."));
-                return false;
-            }
-            return true;
-        }
-
-        // A capture binding may not be changed while the object is capturing (GL 4.6 core 13.2.2).
-        Bool ValidateNamedTransformFeedbackNotActive(GLuint xfb, const char* functionName) {
-            if (MG_State::pGLContext->IsNamedTransformFeedbackActive(xfb)) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                                 "The transform feedback object is capturing."));
-                return false;
-            }
-            return true;
-        }
-
-        SharedPtr<MG_State::GLState::BufferObject> ResolveTransformFeedbackBuffer(GLuint buffer,
-                                                                                 const char* functionName) {
-            if (buffer == 0) return nullptr;
-            if (!MG_State::pGLContext->ValidateBufferName(buffer)) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                                 std::to_string(buffer) + " is not a buffer object."));
-                return nullptr;
-            }
-            return MG_State::pGLContext->GetBufferObject(buffer);
-        }
-    } // namespace
-
-    void TransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer) {
-        if (!ValidateNamedTransformFeedback(xfb, __func__)) return;
-        if (!ValidateTransformFeedbackBufferIndex(index, __func__)) return;
-        if (!ValidateNamedTransformFeedbackNotActive(xfb, __func__)) return;
-        if (buffer != 0 && !MG_State::pGLContext->ValidateBufferName(buffer)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             std::to_string(buffer) + " is not a buffer object."));
-            return;
-        }
-        MG_State::pGLContext->SetNamedTransformFeedbackBinding(xfb, index,
-                                                               ResolveTransformFeedbackBuffer(buffer, __func__), {},
-                                                               false);
-    }
-
-    void TransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {
-        if (!ValidateNamedTransformFeedback(xfb, __func__)) return;
-        if (!ValidateTransformFeedbackBufferIndex(index, __func__)) return;
-        if (!ValidateNamedTransformFeedbackNotActive(xfb, __func__)) return;
-        if (offset < 0 || size <= 0 || (offset % 4) != 0 || (size % 4) != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "offset and size must be non-negative multiples of 4."));
-            return;
-        }
-        if (buffer != 0 && !MG_State::pGLContext->ValidateBufferName(buffer)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             std::to_string(buffer) + " is not a buffer object."));
-            return;
-        }
-        auto bufferObject = ResolveTransformFeedbackBuffer(buffer, __func__);
-        const Range1D range{static_cast<SizeT>(offset), static_cast<SizeT>(offset) + static_cast<SizeT>(size)};
-        MG_State::pGLContext->SetNamedTransformFeedbackBinding(xfb, index, bufferObject, range,
-                                                               bufferObject != nullptr);
-    }
-
-    void GetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint* param) {
-        if (!ValidateNamedTransformFeedback(xfb, __func__)) return;
-        if (!param) return;
-        switch (pname) {
-        case GL_TRANSFORM_FEEDBACK_ACTIVE:
-            *param = MG_State::pGLContext->IsNamedTransformFeedbackActive(xfb) ? GL_TRUE : GL_FALSE;
-            return;
-        case GL_TRANSFORM_FEEDBACK_PAUSED:
-            *param = MG_State::pGLContext->IsNamedTransformFeedbackPaused(xfb) ? GL_TRUE : GL_FALSE;
-            return;
-        default:
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "pname must be GL_TRANSFORM_FEEDBACK_ACTIVE or _PAUSED."));
-            return;
-        }
-    }
-
-    void GetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint* param) {
-        if (!ValidateNamedTransformFeedback(xfb, __func__)) return;
-        if (pname != GL_TRANSFORM_FEEDBACK_BUFFER_BINDING) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "pname must be GL_TRANSFORM_FEEDBACK_BUFFER_BINDING."));
-            return;
-        }
-        if (!ValidateTransformFeedbackBufferIndex(index, __func__)) return;
-        if (!param) return;
-        const auto binding = MG_State::pGLContext->GetNamedTransformFeedbackBinding(xfb, index);
-        *param = binding.Buffer ? static_cast<GLint>(binding.Buffer->GetExternalIndex()) : 0;
-    }
-
-    void GetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64* param) {
-        if (!ValidateNamedTransformFeedback(xfb, __func__)) return;
-        if (pname != GL_TRANSFORM_FEEDBACK_BUFFER_START && pname != GL_TRANSFORM_FEEDBACK_BUFFER_SIZE) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "pname must be GL_TRANSFORM_FEEDBACK_BUFFER_START or _SIZE."));
-            return;
-        }
-        if (!ValidateTransformFeedbackBufferIndex(index, __func__)) return;
-        if (!param) return;
-        const auto binding = MG_State::pGLContext->GetNamedTransformFeedbackBinding(xfb, index);
-        // glTransformFeedbackBufferBase leaves both at zero; only the range form sets them
-        // (GL 4.6 core table 23.48).
-        if (!binding.Buffer || !binding.HasExplicitRange) {
-            *param = 0;
-            return;
-        }
-        *param = (pname == GL_TRANSFORM_FEEDBACK_BUFFER_START)
-                     ? static_cast<GLint64>(binding.Range.start)
-                     : static_cast<GLint64>(binding.Range.end - binding.Range.start);
-    }
-
-    void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) {
-        if (n < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "n must be non-negative."));
-            return;
-        }
-        if (ids == nullptr) return;
-        for (GLsizei i = 0; i < n; ++i) {
-            const GLuint id = ids[i];
-            // Unknown names and 0 are silently ignored; an object whose capture span is
-            // still open is not (GL 4.6 core 13.2.1).
-            if (id == 0 || !MG_State::pGLContext->ValidateTransformFeedbackName(id)) continue;
-            if (id == MG_State::pGLContext->GetBoundTransformFeedbackName() &&
-                MG_State::pGLContext->IsTransformFeedbackActive()) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidOperation,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                                 "Cannot delete a transform feedback object whose capture is active."));
-                continue;
-            }
-            if (const auto deleteXfb = MG_Backend::gBackendFunctionsTable.GL.DeleteTransformFeedback) {
-                deleteXfb(id);
-            }
-            MG_State::pGLContext->MarkTransformFeedbackObjectForDeletion(id);
-        }
-    }
-
-    void BindTransformFeedback(GLenum target, GLuint id) {
-        if (target != GL_TRANSFORM_FEEDBACK) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "target must be GL_TRANSFORM_FEEDBACK."));
-            return;
-        }
-        // A running capture pins its object; only a paused one may be swapped out.
-        if (MG_State::pGLContext->IsTransformFeedbackActive() &&
-            !MG_State::pGLContext->IsTransformFeedbackPaused()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             "Transform feedback is active and not paused."));
-            return;
-        }
-        if (!MG_State::pGLContext->ValidateTransformFeedbackName(id)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                             std::to_string(id) + " is not a transform feedback object name."));
-            return;
-        }
-        MG_State::pGLContext->BindTransformFeedbackObject(id);
-        if (const auto bindXfb = MG_Backend::gBackendFunctionsTable.GL.BindTransformFeedback) {
-            bindXfb(id);
-        }
-    }
-
-    GLboolean IsTransformFeedback(GLuint id) {
-        // Name 0 is the default object, and a name glGenTransformFeedbacks handed out only
-        // becomes the name of an object once it has been bound.
-        return MG_State::pGLContext->IsTransformFeedbackObject(id) ? GL_TRUE : GL_FALSE;
-    }
-
-    // glDrawTransformFeedback[Stream][Instanced]: replays the vertices the named object
-    // captured in its last completed span, as if by glDrawArraysInstanced with that count
-    // (GL 4.6 core 10.3.7).
-    static void DrawTransformFeedbackImpl(const char* functionName, GLenum mode, GLuint id, GLuint stream,
-                                          GLsizei instancecount) {
-        if (!ValidateCurrentProgramForExecution(functionName)) return;
-        if (!ValidatePrimitiveModeForBackend(functionName, mode)) return;
-        if (instancecount < 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName, "instancecount must be non-negative."));
-            return;
-        }
-        // "id is not the name of a transform feedback object" has to mean the same thing here
-        // as it does to glIsTransformFeedback, and the two predicates are not interchangeable:
-        // a name glGenTransformFeedbacks handed out is only reserved until it is first bound,
-        // and only the bind turns it into an object (GL 4.6 core 13.2.1). ValidateTransformFeedbackName
-        // answers the reservation question - the right one for glBindTransformFeedback, which is
-        // what turns a reserved name into an object - so using it here let a generated-but-unbound
-        // name through to the completed-span check below and raised INVALID_OPERATION where the
-        // spec asks for INVALID_VALUE. Name 0 is the default object and always drawable.
-        if (id != 0 && !MG_State::pGLContext->IsTransformFeedbackObject(id)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             std::to_string(id) + " is not a transform feedback object name."));
-            return;
-        }
-        // GL_MAX_VERTEX_STREAMS is 1, so stream 0 is the only one that exists.
-        if (stream != 0) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             "stream must be less than GL_MAX_VERTEX_STREAMS."));
-            return;
-        }
-        // Drawing from an object whose capture is currently open is legal and deliberate:
-        // it is how a transform feedback result is fed straight back into the next span
-        // (ARB_transform_feedback2 lists no such restriction).
-        if (!MG_State::pGLContext->HasTransformFeedbackCompletedSpan(id)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
-                                             "glEndTransformFeedback has never been called for this object."));
-            return;
-        }
-
-        const Uint64 vertices = MG_State::pGLContext->GetTransformFeedbackRecordedVertices(id);
-        if (vertices == 0) return;
-        const auto count = static_cast<GLsizei>(vertices);
-        AccountTransformFeedbackPrimitives(mode, count);
-        if (instancecount == 1) {
-            DrawArrays_Backend(mode, 0, count);
-        } else {
-            DrawArraysInstanced_Backend(mode, 0, count, instancecount);
-        }
-    }
-
-    void DrawTransformFeedback(GLenum mode, GLuint id) {
-        DrawTransformFeedbackImpl(__func__, mode, id, 0, 1);
-    }
-
-    void DrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount) {
-        DrawTransformFeedbackImpl(__func__, mode, id, 0, instancecount);
-    }
-
-    void DrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream) {
-        DrawTransformFeedbackImpl(__func__, mode, id, stream, 1);
-    }
-
-    void DrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount) {
-        DrawTransformFeedbackImpl(__func__, mode, id, stream, instancecount);
-    }
-
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.h

@@ -11,27 +11,8 @@
 
 namespace MobileGL::MG_Impl::GLImpl {
     /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
-    void BeginTransformFeedback(GLenum primitiveMode);
-    void EndTransformFeedback(void);
-    void PauseTransformFeedback(void);
-    void ResumeTransformFeedback(void);
-    void GenTransformFeedbacks(GLsizei n, GLuint* ids);
-    void CreateTransformFeedbacks(GLsizei n, GLuint* ids);
-    void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids);
-    void TransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer);
-    void TransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void GetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint* param);
-    void GetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint* param);
-    void GetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64* param);
-    void BindTransformFeedback(GLenum target, GLuint id);
-    GLboolean IsTransformFeedback(GLuint id);
-    void DrawTransformFeedback(GLenum mode, GLuint id);
-    void DrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount);
-    void DrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream);
-    void DrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
     void DispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ);
     void DispatchComputeIndirect(GLintptr indirect);
-    void PatchParameteri(GLenum pname, GLint value);
     void MemoryBarrier(GLbitfield barriers);
     void MemoryBarrierByRegion(GLbitfield barriers);
     void MultiDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride);

MobileGL/MG_Impl/GLImpl/Exporting/Definitions.cpp

@@ -15,7 +15,6 @@
 #include "../Texture/GL_Texture.h"
 #include "../Drawing/GL_Drawing.h"
 #include "../Program/GL_Program.h"
-#include "../Program/GL_ProgramPipeline.h"
 #include "../RenderState/GL_RenderState.h"
 #include "../Framebuffer/GL_Framebuffer.h"
 #include "../VertexArray/GL_VertexArray.h"
@@ -25,12 +24,12 @@
 #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__) {
@@ -237,12 +236,12 @@ DECLARE_GL_FUNCTION_HEAD(void, DeleteVertexArrays, GLsizei n, const GLuint* arra
 DECLARE_GL_FUNCTION_HEAD(void, GenVertexArrays, GLsizei n, GLuint* arrays) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GenVertexArrays, n, arrays)
 DECLARE_GL_FUNCTION_HEAD(GLboolean, IsVertexArray, GLuint array) DECLARE_GL_FUNCTION_END(GLboolean, IsVertexArray, array)
 DECLARE_GL_FUNCTION_HEAD(void, GetIntegeri_v, GLenum target, GLuint index, GLint* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetIntegeri_v, target, index, data)
-DECLARE_GL_FUNCTION_HEAD(void, BeginTransformFeedback, GLenum primitiveMode) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BeginTransformFeedback, primitiveMode)
-DECLARE_GL_FUNCTION_HEAD(void, EndTransformFeedback) DECLARE_GL_FUNCTION_END_NO_RETURN(void, EndTransformFeedback)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, BeginTransformFeedback, GLenum primitiveMode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BeginTransformFeedback, primitiveMode)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, EndTransformFeedback) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EndTransformFeedback)
 DECLARE_GL_FUNCTION_HEAD(void, BindBufferRange, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindBufferRange, target, index, buffer, offset, size)
 DECLARE_GL_FUNCTION_HEAD(void, BindBufferBase, GLenum target, GLuint index, GLuint buffer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindBufferBase, target, index, buffer)
-DECLARE_GL_FUNCTION_HEAD(void, TransformFeedbackVaryings, GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TransformFeedbackVaryings, program, count, varyings, bufferMode)
-DECLARE_GL_FUNCTION_HEAD(void, GetTransformFeedbackVarying, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTransformFeedbackVarying, program, index, bufSize, length, size, type, name)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, TransformFeedbackVaryings, GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TransformFeedbackVaryings, program, count, varyings, bufferMode)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetTransformFeedbackVarying, GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetTransformFeedbackVarying, program, index, bufSize, length, size, type, name)
 DECLARE_GL_FUNCTION_HEAD(void, VertexAttribIPointer, GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexAttribIPointer, index, size, type, stride, pointer)
 DECLARE_GL_FUNCTION_HEAD(void, GetVertexAttribIiv, GLuint index, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetVertexAttribIiv, index, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetVertexAttribIuiv, GLuint index, GLenum pname, GLuint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetVertexAttribIuiv, index, pname, params)
@@ -293,17 +292,17 @@ DECLARE_GL_FUNCTION_HEAD(void, SamplerParameterfv, GLuint sampler, GLenum pname,
 DECLARE_GL_FUNCTION_HEAD(void, GetSamplerParameteriv, GLuint sampler, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetSamplerParameteriv, sampler, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetSamplerParameterfv, GLuint sampler, GLenum pname, GLfloat* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetSamplerParameterfv, sampler, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, VertexAttribDivisor, GLuint index, GLuint divisor) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexAttribDivisor, index, divisor)
-DECLARE_GL_FUNCTION_HEAD(void, BindTransformFeedback, GLenum target, GLuint id) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindTransformFeedback, target, id)
-DECLARE_GL_FUNCTION_HEAD(void, DeleteTransformFeedbacks, GLsizei n, const GLuint* ids) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DeleteTransformFeedbacks, n, ids)
-DECLARE_GL_FUNCTION_HEAD(void, GenTransformFeedbacks, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GenTransformFeedbacks, n, ids)
-DECLARE_GL_FUNCTION_HEAD(GLboolean, IsTransformFeedback, GLuint id) DECLARE_GL_FUNCTION_END(GLboolean, IsTransformFeedback, id)
-DECLARE_GL_FUNCTION_HEAD(void, PauseTransformFeedback) DECLARE_GL_FUNCTION_END_NO_RETURN(void, PauseTransformFeedback)
-DECLARE_GL_FUNCTION_HEAD(void, ResumeTransformFeedback) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ResumeTransformFeedback)
-DECLARE_GL_FUNCTION_HEAD(void, GetProgramBinary, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramBinary, program, bufSize, length, binaryFormat, binary)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramBinary, GLuint program, GLenum binaryFormat, const void* binary, GLsizei length) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramBinary, program, binaryFormat, binary, length)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramParameteri, GLuint program, GLenum pname, GLint value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramParameteri, program, pname, value)
-DECLARE_GL_FUNCTION_HEAD(void, InvalidateFramebuffer, GLenum target, GLsizei numAttachments, const GLenum* attachments) DECLARE_GL_FUNCTION_END_NO_RETURN(void, InvalidateFramebuffer, target, numAttachments, attachments)
-DECLARE_GL_FUNCTION_HEAD(void, InvalidateSubFramebuffer, GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, InvalidateSubFramebuffer, target, numAttachments, attachments, x, y, width, height)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, BindTransformFeedback, GLenum target, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindTransformFeedback, target, id)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteTransformFeedbacks, GLsizei n, const GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteTransformFeedbacks, n, ids)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GenTransformFeedbacks, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenTransformFeedbacks, n, ids)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsTransformFeedback, GLuint id) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsTransformFeedback, id)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, PauseTransformFeedback) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PauseTransformFeedback)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ResumeTransformFeedback) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ResumeTransformFeedback)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetProgramBinary, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetProgramBinary, program, bufSize, length, binaryFormat, binary)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramBinary, GLuint program, GLenum binaryFormat, const void* binary, GLsizei length) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramBinary, program, binaryFormat, binary, length)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramParameteri, GLuint program, GLenum pname, GLint value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramParameteri, program, pname, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateFramebuffer, GLenum target, GLsizei numAttachments, const GLenum* attachments) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InvalidateFramebuffer, target, numAttachments, attachments)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateSubFramebuffer, GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InvalidateSubFramebuffer, target, numAttachments, attachments, x, y, width, height)
 DECLARE_GL_FUNCTION_HEAD(void, TexStorage2D, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TexStorage2D, target, levels, internalformat, width, height)
 DECLARE_GL_FUNCTION_HEAD(void, TexStorage3D, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TexStorage3D, target, levels, internalformat, width, height, depth)
 DECLARE_GL_FUNCTION_HEAD(void, GetInternalformativ, GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetInternalformativ, target, internalformat, pname, bufSize, params)
@@ -311,21 +310,21 @@ DECLARE_GL_FUNCTION_HEAD(void, DispatchCompute, GLuint num_groups_x, GLuint num_
 DECLARE_GL_FUNCTION_HEAD(void, DispatchComputeIndirect, GLintptr indirect) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DispatchComputeIndirect, indirect)
 DECLARE_GL_FUNCTION_HEAD(void, DrawArraysIndirect, GLenum mode, const void* indirect) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawArraysIndirect, mode, indirect)
 DECLARE_GL_FUNCTION_HEAD(void, DrawElementsIndirect, GLenum mode, GLenum type, const void* indirect) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawElementsIndirect, mode, type, indirect)
-DECLARE_GL_FUNCTION_HEAD(void, FramebufferParameteri, GLenum target, GLenum pname, GLint param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, FramebufferParameteri, target, pname, param)
-DECLARE_GL_FUNCTION_HEAD(void, GetFramebufferParameteriv, GLenum target, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetFramebufferParameteriv, target, pname, params)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, FramebufferParameteri, GLenum target, GLenum pname, GLint param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FramebufferParameteri, target, pname, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetFramebufferParameteriv, GLenum target, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetFramebufferParameteriv, target, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetProgramInterfaceiv, GLuint program, GLenum programInterface, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramInterfaceiv, program, programInterface, pname, params)
 DECLARE_GL_FUNCTION_HEAD(GLuint, GetProgramResourceIndex, GLuint program, GLenum programInterface, const GLchar* name) DECLARE_GL_FUNCTION_END(GLuint, GetProgramResourceIndex, program, programInterface, name)
 DECLARE_GL_FUNCTION_HEAD(void, GetProgramResourceName, GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramResourceName, program, programInterface, index, bufSize, length, name)
 DECLARE_GL_FUNCTION_HEAD(void, GetProgramResourceiv, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramResourceiv, program, programInterface, index, propCount, props, bufSize, length, params)
 DECLARE_GL_FUNCTION_HEAD(GLint, GetProgramResourceLocation, GLuint program, GLenum programInterface, const GLchar* name) DECLARE_GL_FUNCTION_END(GLint, GetProgramResourceLocation, program, programInterface, name)
-DECLARE_GL_FUNCTION_HEAD(void, UseProgramStages, GLuint pipeline, GLbitfield stages, GLuint program) DECLARE_GL_FUNCTION_END_NO_RETURN(void, UseProgramStages, pipeline, stages, program)
-DECLARE_GL_FUNCTION_HEAD(void, ActiveShaderProgram, GLuint pipeline, GLuint program) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ActiveShaderProgram, pipeline, program)
-DECLARE_GL_FUNCTION_HEAD(GLuint, CreateShaderProgramv, GLenum type, GLsizei count, const GLchar* const* strings) DECLARE_GL_FUNCTION_END(GLuint, CreateShaderProgramv, type, count, strings)
-DECLARE_GL_FUNCTION_HEAD(void, BindProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindProgramPipeline, pipeline)
-DECLARE_GL_FUNCTION_HEAD(void, DeleteProgramPipelines, GLsizei n, const GLuint* pipelines) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DeleteProgramPipelines, n, pipelines)
-DECLARE_GL_FUNCTION_HEAD(void, GenProgramPipelines, GLsizei n, GLuint* pipelines) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GenProgramPipelines, n, pipelines)
-DECLARE_GL_FUNCTION_HEAD(GLboolean, IsProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_END(GLboolean, IsProgramPipeline, pipeline)
-DECLARE_GL_FUNCTION_HEAD(void, GetProgramPipelineiv, GLuint pipeline, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramPipelineiv, pipeline, pname, params)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, UseProgramStages, GLuint pipeline, GLbitfield stages, GLuint program) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UseProgramStages, pipeline, stages, program)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ActiveShaderProgram, GLuint pipeline, GLuint program) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ActiveShaderProgram, pipeline, program)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, CreateShaderProgramv, GLenum type, GLsizei count, const GLchar* const* strings) DECLARE_GL_FUNCTION_STUB_END(GLuint, CreateShaderProgramv, type, count, strings)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, BindProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindProgramPipeline, pipeline)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteProgramPipelines, GLsizei n, const GLuint* pipelines) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteProgramPipelines, n, pipelines)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GenProgramPipelines, GLsizei n, GLuint* pipelines) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenProgramPipelines, n, pipelines)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsProgramPipeline, pipeline)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetProgramPipelineiv, GLuint pipeline, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetProgramPipelineiv, pipeline, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform1i, GLuint program, GLint location, GLint v0) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform1i, program, location, v0)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform2i, GLuint program, GLint location, GLint v0, GLint v1) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform2i, program, location, v0, v1)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform3i, GLuint program, GLint location, GLint v0, GLint v1, GLint v2) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform3i, program, location, v0, v1, v2)
@@ -359,8 +358,8 @@ DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix2x4fv, GLuint program, GLint
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix4x2fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix4x2fv, program, location, count, transpose, value)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix3x4fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix3x4fv, program, location, count, transpose, value)
 DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix4x3fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix4x3fv, program, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, ValidateProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ValidateProgramPipeline, pipeline)
-DECLARE_GL_FUNCTION_HEAD(void, GetProgramPipelineInfoLog, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetProgramPipelineInfoLog, pipeline, bufSize, length, infoLog)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ValidateProgramPipeline, GLuint pipeline) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ValidateProgramPipeline, pipeline)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetProgramPipelineInfoLog, GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetProgramPipelineInfoLog, pipeline, bufSize, length, infoLog)
 DECLARE_GL_FUNCTION_HEAD(void, BindImageTexture, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindImageTexture, unit, texture, level, layered, layer, access, format)
 DECLARE_GL_FUNCTION_HEAD(void, GetBooleani_v, GLenum target, GLuint index, GLboolean* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetBooleani_v, target, index, data)
 DECLARE_GL_FUNCTION_HEAD(void, MemoryBarrier, GLbitfield barriers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MemoryBarrier, barriers)
@@ -419,13 +418,13 @@ DECLARE_GL_FUNCTION_HEAD(void, DrawRangeElementsBaseVertex, GLenum mode, GLuint
 DECLARE_GL_FUNCTION_HEAD(void, DrawElementsInstancedBaseVertex, GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawElementsInstancedBaseVertex, mode, count, type, indices, instancecount, basevertex)
 DECLARE_GL_FUNCTION_HEAD(void, FramebufferTexture, GLenum target, GLenum attachment, GLuint texture, GLint level) DECLARE_GL_FUNCTION_END_NO_RETURN(void, FramebufferTexture, target, attachment, texture, level)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PrimitiveBoundingBox, GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PrimitiveBoundingBox, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW)
-DECLARE_GL_FUNCTION_HEAD(GLenum, GetGraphicsResetStatus) DECLARE_GL_FUNCTION_END(GLenum, GetGraphicsResetStatus)
-DECLARE_GL_FUNCTION_HEAD(void, ReadnPixels, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ReadnPixels, x, y, width, height, format, type, bufSize, data)
+DECLARE_GL_FUNCTION_STUB_HEAD(GLenum, GetGraphicsResetStatus) DECLARE_GL_FUNCTION_STUB_END(GLenum, GetGraphicsResetStatus)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ReadnPixels, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ReadnPixels, x, y, width, height, format, type, bufSize, data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformfv, GLuint program, GLint location, GLsizei bufSize, GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformfv, program, location, bufSize, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnUniformiv, GLuint program, GLint location, GLsizei bufSize, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnUniformiv, program, location, bufSize, params)
 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_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_STUB_HEAD(void, PatchParameteri, GLenum pname, GLint value) DECLARE_GL_FUNCTION_STUB_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)
 DECLARE_GL_FUNCTION_HEAD(void, GetTexParameterIiv, GLenum target, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTexParameterIiv, target, pname, params)
@@ -435,7 +434,7 @@ DECLARE_GL_FUNCTION_HEAD(void, SamplerParameterIuiv, GLuint sampler, GLenum pnam
 DECLARE_GL_FUNCTION_HEAD(void, GetSamplerParameterIiv, GLuint sampler, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetSamplerParameterIiv, sampler, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetSamplerParameterIuiv, GLuint sampler, GLenum pname, GLuint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetSamplerParameterIuiv, sampler, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, TexBuffer, GLenum target, GLenum internalformat, GLuint buffer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TexBuffer, target, internalformat, buffer)
-DECLARE_GL_FUNCTION_HEAD(void, TexBufferRange, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TexBufferRange, target, internalformat, buffer, offset, size)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, TexBufferRange, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexBufferRange, target, internalformat, buffer, offset, size)
 DECLARE_GL_FUNCTION_HEAD(void, TexStorage3DMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TexStorage3DMultisample, target, samples, internalformat, width, height, depth, fixedsamplelocations)
 DECLARE_GL_FUNCTION_HEAD(void*, MapBufferRange, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) DECLARE_GL_FUNCTION_END(void*, MapBufferRange, target, offset, length, access)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearIndex, GLfloat c) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearIndex, c)
@@ -910,24 +909,24 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ColorP4ui, GLenum type, GLuint color) DECLAR
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ColorP4uiv, GLenum type, const GLuint* color) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ColorP4uiv, type, color)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SecondaryColorP3ui, GLenum type, GLuint color) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SecondaryColorP3ui, type, color)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, SecondaryColorP3uiv, GLenum type, const GLuint* color) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, SecondaryColorP3uiv, type, color)
-DECLARE_GL_FUNCTION_HEAD(void, Uniform1d, GLint location, GLdouble x) DECLARE_GL_FUNCTION_END_NO_RETURN(void, Uniform1d, location, x)
-DECLARE_GL_FUNCTION_HEAD(void, Uniform2d, GLint location, GLdouble x, GLdouble y) DECLARE_GL_FUNCTION_END_NO_RETURN(void, Uniform2d, location, x, y)
-DECLARE_GL_FUNCTION_HEAD(void, Uniform3d, GLint location, GLdouble x, GLdouble y, GLdouble z) DECLARE_GL_FUNCTION_END_NO_RETURN(void, Uniform3d, location, x, y, z)
-DECLARE_GL_FUNCTION_HEAD(void, Uniform4d, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w) DECLARE_GL_FUNCTION_END_NO_RETURN(void, Uniform4d, location, x, y, z, w)
-DECLARE_GL_FUNCTION_HEAD(void, Uniform1dv, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, Uniform1dv, location, count, value)
-DECLARE_GL_FUNCTION_HEAD(void, Uniform2dv, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, Uniform2dv, location, count, value)
-DECLARE_GL_FUNCTION_HEAD(void, Uniform3dv, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, Uniform3dv, location, count, value)
-DECLARE_GL_FUNCTION_HEAD(void, Uniform4dv, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, Uniform4dv, location, count, value)
-DECLARE_GL_FUNCTION_HEAD(void, UniformMatrix2dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, UniformMatrix2dv, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, UniformMatrix3dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, UniformMatrix3dv, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, UniformMatrix4dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, UniformMatrix4dv, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, UniformMatrix2x3dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, UniformMatrix2x3dv, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, UniformMatrix2x4dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, UniformMatrix2x4dv, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, UniformMatrix3x2dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, UniformMatrix3x2dv, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, UniformMatrix3x4dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, UniformMatrix3x4dv, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, UniformMatrix4x2dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, UniformMatrix4x2dv, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, UniformMatrix4x3dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, UniformMatrix4x3dv, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, GetUniformdv, GLuint program, GLint location, GLdouble* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetUniformdv, program, location, params)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, Uniform1d, GLint location, GLdouble x) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Uniform1d, location, x)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, Uniform2d, GLint location, GLdouble x, GLdouble y) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Uniform2d, location, x, y)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, Uniform3d, GLint location, GLdouble x, GLdouble y, GLdouble z) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Uniform3d, location, x, y, z)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, Uniform4d, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Uniform4d, location, x, y, z, w)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, Uniform1dv, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Uniform1dv, location, count, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, Uniform2dv, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Uniform2dv, location, count, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, Uniform3dv, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Uniform3dv, location, count, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, Uniform4dv, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, Uniform4dv, location, count, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix2dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix2dv, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix3dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix3dv, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix4dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix4dv, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix2x3dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix2x3dv, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix2x4dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix2x4dv, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix3x2dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix3x2dv, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix3x4dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix3x4dv, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix4x2dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix4x2dv, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformMatrix4x3dv, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, UniformMatrix4x3dv, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetUniformdv, GLuint program, GLint location, GLdouble* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetUniformdv, program, location, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(GLint, GetSubroutineUniformLocation, GLuint program, GLenum shadertype, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END(GLint, GetSubroutineUniformLocation, program, shadertype, name)
 DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GetSubroutineIndex, GLuint program, GLenum shadertype, const GLchar* name) DECLARE_GL_FUNCTION_STUB_END(GLuint, GetSubroutineIndex, program, shadertype, name)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetActiveSubroutineUniformiv, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetActiveSubroutineUniformiv, program, shadertype, index, pname, values)
@@ -937,28 +936,28 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, UniformSubroutinesuiv, GLenum shadertype, GL
 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_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)
-DECLARE_GL_FUNCTION_HEAD(void, EndQueryIndexed, GLenum target, GLuint index) DECLARE_GL_FUNCTION_END_NO_RETURN(void, EndQueryIndexed, target, index)
-DECLARE_GL_FUNCTION_HEAD(void, GetQueryIndexediv, GLenum target, GLuint index, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetQueryIndexediv, target, index, pname, params)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform1d, GLuint program, GLint location, GLdouble v0) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform1d, program, location, v0)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform1dv, GLuint program, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform1dv, program, location, count, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform2d, GLuint program, GLint location, GLdouble v0, GLdouble v1) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform2d, program, location, v0, v1)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform2dv, GLuint program, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform2dv, program, location, count, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform3d, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform3d, program, location, v0, v1, v2)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform3dv, GLuint program, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform3dv, program, location, count, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform4d, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform4d, program, location, v0, v1, v2, v3)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniform4dv, GLuint program, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniform4dv, program, location, count, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix2dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix2dv, program, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix3dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix3dv, program, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix4dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix4dv, program, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix2x3dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix2x3dv, program, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix3x2dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix3x2dv, program, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix2x4dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix2x4dv, program, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix4x2dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix4x2dv, program, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix3x4dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix3x4dv, program, location, count, transpose, value)
-DECLARE_GL_FUNCTION_HEAD(void, ProgramUniformMatrix4x3dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ProgramUniformMatrix4x3dv, program, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawTransformFeedback, GLenum mode, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawTransformFeedback, mode, id)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawTransformFeedbackStream, GLenum mode, GLuint id, GLuint stream) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawTransformFeedbackStream, mode, id, stream)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, BeginQueryIndexed, GLenum target, GLuint index, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BeginQueryIndexed, target, index, id)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, EndQueryIndexed, GLenum target, GLuint index) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, EndQueryIndexed, target, index)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryIndexediv, GLenum target, GLuint index, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryIndexediv, target, index, pname, params)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniform1d, GLuint program, GLint location, GLdouble v0) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniform1d, program, location, v0)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniform1dv, GLuint program, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniform1dv, program, location, count, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniform2d, GLuint program, GLint location, GLdouble v0, GLdouble v1) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniform2d, program, location, v0, v1)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniform2dv, GLuint program, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniform2dv, program, location, count, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniform3d, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniform3d, program, location, v0, v1, v2)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniform3dv, GLuint program, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniform3dv, program, location, count, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniform4d, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniform4d, program, location, v0, v1, v2, v3)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniform4dv, GLuint program, GLint location, GLsizei count, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniform4dv, program, location, count, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformMatrix2dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformMatrix2dv, program, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformMatrix3dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformMatrix3dv, program, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformMatrix4dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformMatrix4dv, program, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformMatrix2x3dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformMatrix2x3dv, program, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformMatrix3x2dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformMatrix3x2dv, program, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformMatrix2x4dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformMatrix2x4dv, program, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformMatrix4x2dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformMatrix4x2dv, program, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformMatrix3x4dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformMatrix3x4dv, program, location, count, transpose, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ProgramUniformMatrix4x3dv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ProgramUniformMatrix4x3dv, program, location, count, transpose, value)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribL1d, GLuint index, GLdouble x) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttribL1d, index, x)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribL2d, GLuint index, GLdouble x, GLdouble y) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttribL2d, index, x, y)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexAttribL3d, GLuint index, GLdouble x, GLdouble y, GLdouble z) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexAttribL3d, index, x, y, z)
@@ -977,14 +976,14 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ScissorIndexed, GLuint index, GLint left, GL
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ScissorIndexedv, GLuint index, const GLint* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ScissorIndexedv, index, v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DepthRangeArrayv, GLuint first, GLsizei count, const GLdouble* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DepthRangeArrayv, first, count, v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DepthRangeIndexed, GLuint index, GLdouble n, GLdouble f) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DepthRangeIndexed, index, n, f)
-DECLARE_GL_FUNCTION_HEAD(void, GetFloati_v, GLenum target, GLuint index, GLfloat* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetFloati_v, target, index, data)
-DECLARE_GL_FUNCTION_HEAD(void, GetDoublei_v, GLenum target, GLuint index, GLdouble* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetDoublei_v, target, index, data)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetFloati_v, GLenum target, GLuint index, GLfloat* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetFloati_v, target, index, data)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetDoublei_v, GLenum target, GLuint index, GLdouble* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetDoublei_v, target, index, data)
 DECLARE_GL_FUNCTION_HEAD(void, DrawArraysInstancedBaseInstance, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawArraysInstancedBaseInstance, mode, first, count, instancecount, baseinstance)
 DECLARE_GL_FUNCTION_HEAD(void, DrawElementsInstancedBaseInstance, GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLuint baseinstance) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawElementsInstancedBaseInstance, mode, count, type, indices, instancecount, baseinstance)
 DECLARE_GL_FUNCTION_HEAD(void, DrawElementsInstancedBaseVertexBaseInstance, GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) DECLARE_GL_FUNCTION_END_NO_RETURN(void, DrawElementsInstancedBaseVertexBaseInstance, mode, count, type, indices, instancecount, basevertex, baseinstance)
 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_STUB_HEAD(void, DrawTransformFeedbackInstanced, GLenum mode, GLuint id, GLsizei instancecount) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawTransformFeedbackInstanced, mode, id, instancecount)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawTransformFeedbackStreamInstanced, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawTransformFeedbackStreamInstanced, mode, id, stream, instancecount)
 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)
@@ -997,23 +996,23 @@ DECLARE_GL_FUNCTION_HEAD(void, MultiDrawElementsIndirect, GLenum mode, GLenum ty
 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_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_STUB_HEAD(void, VertexAttribLFormat, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) DECLARE_GL_FUNCTION_STUB_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_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)
-DECLARE_GL_FUNCTION_HEAD(void, GetTransformFeedbackiv, GLuint xfb, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTransformFeedbackiv, xfb, pname, param)
-DECLARE_GL_FUNCTION_HEAD(void, GetTransformFeedbacki_v, GLuint xfb, GLenum pname, GLuint index, GLint* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTransformFeedbacki_v, xfb, pname, index, param)
-DECLARE_GL_FUNCTION_HEAD(void, GetTransformFeedbacki64_v, GLuint xfb, GLenum pname, GLuint index, GLint64* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTransformFeedbacki64_v, xfb, pname, index, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, CreateTransformFeedbacks, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CreateTransformFeedbacks, n, ids)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, TransformFeedbackBufferBase, GLuint xfb, GLuint index, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TransformFeedbackBufferBase, xfb, index, buffer)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, TransformFeedbackBufferRange, GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TransformFeedbackBufferRange, xfb, index, buffer, offset, size)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetTransformFeedbackiv, GLuint xfb, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetTransformFeedbackiv, xfb, pname, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetTransformFeedbacki_v, GLuint xfb, GLenum pname, GLuint index, GLint* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetTransformFeedbacki_v, xfb, pname, index, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetTransformFeedbacki64_v, GLuint xfb, GLenum pname, GLuint index, GLint64* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetTransformFeedbacki64_v, xfb, pname, index, param)
 DECLARE_GL_FUNCTION_HEAD(void, CreateBuffers, GLsizei n, GLuint* buffers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateBuffers, n, buffers)
 DECLARE_GL_FUNCTION_HEAD(void, NamedBufferStorage, GLuint buffer, GLsizeiptr size, const void* data, GLbitfield flags) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedBufferStorage, buffer, size, data, flags)
 DECLARE_GL_FUNCTION_HEAD(void, NamedBufferData, GLuint buffer, GLsizeiptr size, const void* data, GLenum usage) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedBufferData, buffer, size, data, usage)
@@ -1026,32 +1025,32 @@ DECLARE_GL_FUNCTION_HEAD(void, FlushMappedNamedBufferRange, GLuint buffer, GLint
 DECLARE_GL_FUNCTION_HEAD(void, GetNamedBufferParameteriv, GLuint buffer, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedBufferParameteriv, buffer, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetNamedBufferParameteri64v, GLuint buffer, GLenum pname, GLint64* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedBufferParameteri64v, buffer, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetNamedBufferPointerv, GLuint buffer, GLenum pname, void** params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedBufferPointerv, buffer, pname, params)
-DECLARE_GL_FUNCTION_HEAD(void, GetNamedBufferSubData, GLuint buffer, GLintptr offset, GLsizeiptr size, void* data) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedBufferSubData, buffer, offset, size, data)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedBufferSubData, GLuint buffer, GLintptr offset, GLsizeiptr size, void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedBufferSubData, buffer, offset, size, data)
 DECLARE_GL_FUNCTION_HEAD(void, CreateFramebuffers, GLsizei n, GLuint* framebuffers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateFramebuffers, n, framebuffers)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferRenderbuffer, GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferRenderbuffer, framebuffer, attachment, renderbuffertarget, renderbuffer)
-DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferParameteri, GLuint framebuffer, GLenum pname, GLint param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferParameteri, framebuffer, pname, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, NamedFramebufferParameteri, GLuint framebuffer, GLenum pname, GLint param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, NamedFramebufferParameteri, framebuffer, pname, param)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferTexture, GLuint framebuffer, GLenum attachment, GLuint texture, GLint level) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferTexture, framebuffer, attachment, texture, level)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferTextureLayer, GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferTextureLayer, framebuffer, attachment, texture, level, layer)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferDrawBuffer, GLuint framebuffer, GLenum buf) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferDrawBuffer, framebuffer, buf)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferDrawBuffers, GLuint framebuffer, GLsizei n, const GLenum* bufs) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferDrawBuffers, framebuffer, n, bufs)
 DECLARE_GL_FUNCTION_HEAD(void, NamedFramebufferReadBuffer, GLuint framebuffer, GLenum src) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedFramebufferReadBuffer, framebuffer, src)
-DECLARE_GL_FUNCTION_HEAD(void, InvalidateNamedFramebufferData, GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments) DECLARE_GL_FUNCTION_END_NO_RETURN(void, InvalidateNamedFramebufferData, framebuffer, numAttachments, attachments)
-DECLARE_GL_FUNCTION_HEAD(void, InvalidateNamedFramebufferSubData, GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, InvalidateNamedFramebufferSubData, framebuffer, numAttachments, attachments, x, y, width, height)
-DECLARE_GL_FUNCTION_HEAD(void, ClearNamedFramebufferiv, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearNamedFramebufferiv, framebuffer, buffer, drawbuffer, value)
-DECLARE_GL_FUNCTION_HEAD(void, ClearNamedFramebufferuiv, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearNamedFramebufferuiv, framebuffer, buffer, drawbuffer, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateNamedFramebufferData, GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InvalidateNamedFramebufferData, framebuffer, numAttachments, attachments)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, InvalidateNamedFramebufferSubData, GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, InvalidateNamedFramebufferSubData, framebuffer, numAttachments, attachments, x, y, width, height)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearNamedFramebufferiv, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearNamedFramebufferiv, framebuffer, buffer, drawbuffer, value)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearNamedFramebufferuiv, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint* value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearNamedFramebufferuiv, framebuffer, buffer, drawbuffer, value)
 DECLARE_GL_FUNCTION_HEAD(void, ClearNamedFramebufferfv, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat* value) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearNamedFramebufferfv, framebuffer, buffer, drawbuffer, value)
 DECLARE_GL_FUNCTION_HEAD(void, ClearNamedFramebufferfi, GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) DECLARE_GL_FUNCTION_END_NO_RETURN(void, ClearNamedFramebufferfi, framebuffer, buffer, drawbuffer, depth, stencil)
 DECLARE_GL_FUNCTION_HEAD(void, BlitNamedFramebuffer, GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BlitNamedFramebuffer, readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)
 DECLARE_GL_FUNCTION_HEAD(GLenum, CheckNamedFramebufferStatus, GLuint framebuffer, GLenum target) DECLARE_GL_FUNCTION_END(GLenum, CheckNamedFramebufferStatus, framebuffer, target)
-DECLARE_GL_FUNCTION_HEAD(void, GetNamedFramebufferParameteriv, GLuint framebuffer, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedFramebufferParameteriv, framebuffer, pname, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetNamedFramebufferParameteriv, GLuint framebuffer, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetNamedFramebufferParameteriv, framebuffer, pname, param)
 DECLARE_GL_FUNCTION_HEAD(void, GetNamedFramebufferAttachmentParameteriv, GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedFramebufferAttachmentParameteriv, framebuffer, attachment, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, CreateRenderbuffers, GLsizei n, GLuint* renderbuffers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateRenderbuffers, n, renderbuffers)
 DECLARE_GL_FUNCTION_HEAD(void, NamedRenderbufferStorage, GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedRenderbufferStorage, renderbuffer, internalformat, width, height)
 DECLARE_GL_FUNCTION_HEAD(void, NamedRenderbufferStorageMultisample, GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, NamedRenderbufferStorageMultisample, renderbuffer, samples, internalformat, width, height)
 DECLARE_GL_FUNCTION_HEAD(void, GetNamedRenderbufferParameteriv, GLuint renderbuffer, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetNamedRenderbufferParameteriv, renderbuffer, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, CreateTextures, GLenum target, GLsizei n, GLuint* textures) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateTextures, target, n, textures)
-DECLARE_GL_FUNCTION_HEAD(void, TextureBuffer, GLuint texture, GLenum internalformat, GLuint buffer) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureBuffer, texture, internalformat, buffer)
-DECLARE_GL_FUNCTION_HEAD(void, TextureBufferRange, GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureBufferRange, texture, internalformat, buffer, offset, size)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, TextureBuffer, GLuint texture, GLenum internalformat, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TextureBuffer, texture, internalformat, buffer)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, TextureBufferRange, GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TextureBufferRange, texture, internalformat, buffer, offset, size)
 DECLARE_GL_FUNCTION_HEAD(void, TextureStorage1D, GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureStorage1D, texture, levels, internalformat, width)
 DECLARE_GL_FUNCTION_HEAD(void, TextureStorage2D, GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureStorage2D, texture, levels, internalformat, width, height)
 DECLARE_GL_FUNCTION_HEAD(void, TextureStorage3D, GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureStorage3D, texture, levels, internalformat, width, height, depth)
@@ -1061,11 +1060,11 @@ DECLARE_GL_FUNCTION_HEAD(void, TextureSubImage1D, GLuint texture, GLint level, G
 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_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_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_STUB_HEAD(void, CompressedTextureSubImage2D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureSubImage2D, texture, level, xoffset, yoffset, width, height, format, imageSize, data)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureSubImage3D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CompressedTextureSubImage3D, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)
-DECLARE_GL_FUNCTION_HEAD(void, CopyTextureSubImage1D, GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CopyTextureSubImage1D, texture, level, xoffset, x, y, width)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, CopyTextureSubImage1D, GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CopyTextureSubImage1D, texture, level, xoffset, x, y, width)
 DECLARE_GL_FUNCTION_HEAD(void, CopyTextureSubImage2D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CopyTextureSubImage2D, texture, level, xoffset, yoffset, x, y, width, height)
-DECLARE_GL_FUNCTION_HEAD(void, CopyTextureSubImage3D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CopyTextureSubImage3D, texture, level, xoffset, yoffset, zoffset, x, y, width, height)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, CopyTextureSubImage3D, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CopyTextureSubImage3D, texture, level, xoffset, yoffset, zoffset, x, y, width, height)
 DECLARE_GL_FUNCTION_HEAD(void, TextureParameterf, GLuint texture, GLenum pname, GLfloat param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureParameterf, texture, pname, param)
 DECLARE_GL_FUNCTION_HEAD(void, TextureParameterfv, GLuint texture, GLenum pname, const GLfloat* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureParameterfv, texture, pname, param)
 DECLARE_GL_FUNCTION_HEAD(void, TextureParameteri, GLuint texture, GLenum pname, GLint param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, TextureParameteri, texture, pname, param)
@@ -1075,7 +1074,7 @@ DECLARE_GL_FUNCTION_HEAD(void, TextureParameteriv, GLuint texture, GLenum pname,
 DECLARE_GL_FUNCTION_HEAD(void, GenerateTextureMipmap, GLuint texture) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GenerateTextureMipmap, texture)
 DECLARE_GL_FUNCTION_HEAD(void, BindTextureUnit, GLuint unit, GLuint texture) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindTextureUnit, unit, texture)
 DECLARE_GL_FUNCTION_HEAD(void, GetTextureImage, GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTextureImage, texture, level, format, type, bufSize, pixels)
-DECLARE_GL_FUNCTION_HEAD(void, GetCompressedTextureImage, GLuint texture, GLint level, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetCompressedTextureImage, texture, level, bufSize, pixels)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetCompressedTextureImage, GLuint texture, GLint level, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetCompressedTextureImage, texture, level, bufSize, pixels)
 DECLARE_GL_FUNCTION_HEAD(void, GetTextureLevelParameterfv, GLuint texture, GLint level, GLenum pname, GLfloat* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTextureLevelParameterfv, texture, level, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetTextureLevelParameteriv, GLuint texture, GLint level, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTextureLevelParameteriv, texture, level, pname, params)
 DECLARE_GL_FUNCTION_HEAD(void, GetTextureParameterfv, GLuint texture, GLenum pname, GLfloat* params) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTextureParameterfv, texture, pname, params)
@@ -1091,18 +1090,18 @@ DECLARE_GL_FUNCTION_HEAD(void, VertexArrayVertexBuffers, GLuint vaobj, GLuint fi
 DECLARE_GL_FUNCTION_HEAD(void, VertexArrayAttribBinding, GLuint vaobj, GLuint attribindex, GLuint bindingindex) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexArrayAttribBinding, vaobj, attribindex, bindingindex)
 DECLARE_GL_FUNCTION_HEAD(void, VertexArrayAttribFormat, GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexArrayAttribFormat, vaobj, attribindex, size, type, normalized, relativeoffset)
 DECLARE_GL_FUNCTION_HEAD(void, VertexArrayAttribIFormat, GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexArrayAttribIFormat, vaobj, attribindex, size, type, relativeoffset)
-DECLARE_GL_FUNCTION_HEAD(void, VertexArrayAttribLFormat, GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexArrayAttribLFormat, vaobj, attribindex, size, type, relativeoffset)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, VertexArrayAttribLFormat, GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, VertexArrayAttribLFormat, vaobj, attribindex, size, type, relativeoffset)
 DECLARE_GL_FUNCTION_HEAD(void, VertexArrayBindingDivisor, GLuint vaobj, GLuint bindingindex, GLuint divisor) DECLARE_GL_FUNCTION_END_NO_RETURN(void, VertexArrayBindingDivisor, vaobj, bindingindex, divisor)
-DECLARE_GL_FUNCTION_HEAD(void, GetVertexArrayiv, GLuint vaobj, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetVertexArrayiv, vaobj, pname, param)
-DECLARE_GL_FUNCTION_HEAD(void, GetVertexArrayIndexediv, GLuint vaobj, GLuint index, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetVertexArrayIndexediv, vaobj, index, pname, param)
-DECLARE_GL_FUNCTION_HEAD(void, GetVertexArrayIndexed64iv, GLuint vaobj, GLuint index, GLenum pname, GLint64* param) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetVertexArrayIndexed64iv, vaobj, index, pname, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVertexArrayiv, GLuint vaobj, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVertexArrayiv, vaobj, pname, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVertexArrayIndexediv, GLuint vaobj, GLuint index, GLenum pname, GLint* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVertexArrayIndexediv, vaobj, index, pname, param)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetVertexArrayIndexed64iv, GLuint vaobj, GLuint index, GLenum pname, GLint64* param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetVertexArrayIndexed64iv, vaobj, index, pname, param)
 DECLARE_GL_FUNCTION_HEAD(void, CreateSamplers, GLsizei n, GLuint* samplers) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateSamplers, n, samplers)
-DECLARE_GL_FUNCTION_HEAD(void, CreateProgramPipelines, GLsizei n, GLuint* pipelines) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateProgramPipelines, n, pipelines)
-DECLARE_GL_FUNCTION_HEAD(void, CreateQueries, GLenum target, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CreateQueries, target, n, ids)
-DECLARE_GL_FUNCTION_HEAD(void, GetQueryBufferObjecti64v, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetQueryBufferObjecti64v, id, buffer, pname, offset)
-DECLARE_GL_FUNCTION_HEAD(void, GetQueryBufferObjectiv, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetQueryBufferObjectiv, id, buffer, pname, offset)
-DECLARE_GL_FUNCTION_HEAD(void, GetQueryBufferObjectui64v, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetQueryBufferObjectui64v, id, buffer, pname, offset)
-DECLARE_GL_FUNCTION_HEAD(void, GetQueryBufferObjectuiv, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetQueryBufferObjectuiv, id, buffer, pname, offset)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, CreateProgramPipelines, GLsizei n, GLuint* pipelines) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CreateProgramPipelines, n, pipelines)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, CreateQueries, GLenum target, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CreateQueries, target, n, ids)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryBufferObjecti64v, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryBufferObjecti64v, id, buffer, pname, offset)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryBufferObjectiv, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryBufferObjectiv, id, buffer, pname, offset)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryBufferObjectui64v, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryBufferObjectui64v, id, buffer, pname, offset)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryBufferObjectuiv, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryBufferObjectuiv, id, buffer, pname, offset)
 DECLARE_GL_FUNCTION_HEAD(void, GetTextureSubImage, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GetTextureSubImage, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetCompressedTextureSubImage, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetCompressedTextureSubImage, texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnCompressedTexImage, GLenum target, GLint lod, GLsizei bufSize, void* pixels) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnCompressedTexImage, target, lod, bufSize, pixels)
@@ -1273,7 +1272,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord4ivARB, GLenum target, const GL
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord4sARB, GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiTexCoord4sARB, target, s, t, r, q)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord4svARB, GLenum target, const GLshort* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiTexCoord4svARB, target, v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetQueryObjectivARB, GLuint id, GLenum pname, GLint* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetQueryObjectivARB, id, pname, params)
-DECLARE_GL_FUNCTION_HEAD(void, MaxShaderCompilerThreadsARB, GLuint count) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MaxShaderCompilerThreadsARB, count)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, MaxShaderCompilerThreadsARB, GLuint count) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MaxShaderCompilerThreadsARB, count)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PointParameterfARB, GLenum pname, GLfloat param) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PointParameterfARB, pname, param)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PointParameterfvARB, GLenum pname, const GLfloat* params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PointParameterfvARB, pname, params)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GetnTexImageARB, GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* img) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetnTexImageARB, target, level, format, type, bufSize, img)
@@ -1381,7 +1380,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, WindowPos3ivARB, const GLint* v) DECLARE_GL_
 DECLARE_GL_FUNCTION_STUB_HEAD(void, WindowPos3sARB, GLshort x, GLshort y, GLshort z) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, WindowPos3sARB, x, y, z)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, WindowPos3svARB, const GLshort* v) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, WindowPos3svARB, v)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BlendBarrierKHR, void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlendBarrierKHR, )
-DECLARE_GL_FUNCTION_HEAD(void, MaxShaderCompilerThreadsKHR, GLuint count) DECLARE_GL_FUNCTION_END_NO_RETURN(void, MaxShaderCompilerThreadsKHR, count)
+DECLARE_GL_FUNCTION_STUB_HEAD(void, MaxShaderCompilerThreadsKHR, GLuint count) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MaxShaderCompilerThreadsKHR, count)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord1bOES, GLenum texture, GLbyte s) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiTexCoord1bOES, texture, s)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord1bvOES, GLenum texture, const GLbyte* coords) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiTexCoord1bvOES, texture, coords)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, MultiTexCoord2bOES, GLenum texture, GLbyte s, GLbyte t) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, MultiTexCoord2bOES, texture, s, t)
@@ -1849,7 +1848,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, CompressedTextureImage3DEXT, GLuint texture,
 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_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_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_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)
@@ -2584,10 +2583,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, TransformFeedbackStreamAttribsNV, GLsizei co
 DECLARE_GL_FUNCTION_STUB_HEAD(void, BindTransformFeedbackNV, GLenum target, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BindTransformFeedbackNV, target, id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteTransformFeedbacksNV, GLsizei n, const GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteTransformFeedbacksNV, n, ids)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, GenTransformFeedbacksNV, GLsizei n, GLuint* ids) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GenTransformFeedbacksNV, n, ids)
-MOBILEGL_GL_API GLboolean glIsTransformFeedbackNV(GLuint id) {
-    MGLOG_W_ONCE("Stub function: %s(...)", __FUNCTION__);
-    return GL_FALSE;
-}
+DECLARE_GL_FUNCTION_STUB_HEAD(GLboolean, IsTransformFeedbackNV, GLuint id) DECLARE_GL_FUNCTION_STUB_END(GLboolean, IsTransformFeedbackNV, id)
 DECLARE_GL_FUNCTION_STUB_HEAD(void, PauseTransformFeedbackNV, void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, PauseTransformFeedbackNV, )
 DECLARE_GL_FUNCTION_STUB_HEAD(void, ResumeTransformFeedbackNV, void) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ResumeTransformFeedbackNV, )
 DECLARE_GL_FUNCTION_STUB_HEAD(void, DrawTransformFeedbackNV, GLenum mode, GLuint id) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DrawTransformFeedbackNV, mode, id)
@@ -3181,5 +3177,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.h

@@ -14,8 +14,6 @@
 namespace MobileGL::MG_Impl::GLImpl {
     /* @INSERTION_POINT:FUNCTION_DECLARATION@ */
     void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
-    void ReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize,
-                     void* data);
     void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
     void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value);
     void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value);
@@ -58,19 +56,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     void NamedFramebufferReadBuffer(GLuint framebuffer, GLenum src);
     void ClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat* value);
     void ClearNamedFramebufferfi(GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void InvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments);
-    void InvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments,
-                                           GLint x, GLint y, GLsizei width, GLsizei height);
-    void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments);
-    void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y,
-                                  GLsizei width, GLsizei height);
-    void ClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint* value);
-    void ClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint* value);
     GLenum CheckNamedFramebufferStatus(GLuint framebuffer, GLenum target);
-    void GetFramebufferParameteriv(GLenum target, GLenum pname, GLint* params);
-    void FramebufferParameteri(GLenum target, GLenum pname, GLint param);
-    void GetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint* params);
-    void NamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param);
     void GetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params);
     void BlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1,
                               GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
@@ -92,6 +78,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             SharedPtr<MG_State::GLState::ITextureObject> stencilAttachment;
         };
 
-        extern UniquePtr<DefaultFramebufferInfo>& pDefaultFramebufferInfo;
+        extern UniquePtr<DefaultFramebufferInfo> pDefaultFramebufferInfo;
     } // namespace FramebufferImpl
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Framebuffer/Validators.cpp

@@ -7,7 +7,6 @@
 // End of Source File Header
 
 #include "Validators.h"
-#include <MG_Backend/BackendObjects.h>
 #include <MG_State/GLState/Core.h>
 #include <MG_State/GLState/ErrorState/Error.h>
 #include <MG_Util/Converters/GLToStr/GLEnumConverter.h>
@@ -61,26 +60,6 @@ namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl {
         return true;
     }
 
-    Bool ValidateColorAttachmentInRange(FramebufferAttachmentType attachment, const char* caller) {
-        const auto first = static_cast<SizeT>(FramebufferAttachmentType::Color0);
-        const auto index = static_cast<SizeT>(attachment);
-        if (index < first) return true;
-        const auto colorIndex = index - first;
-        const auto limit = static_cast<SizeT>(
-            MG_Backend::pActiveBackendObject ? MG_Backend::pActiveBackendObject->GetDynamicParameters()
-                                                   .MaxColorAttachments
-                                             : static_cast<Int>(MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS));
-        if (colorIndex >= limit) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl/FramebufferImpl", caller,
-                    std::format("Colour attachment {} is beyond GL_MAX_COLOR_ATTACHMENTS ({}).", colorIndex, limit)));
-            return false;
-        }
-        return true;
-    }
-
     Bool ValidateRenderbufferTarget(RenderbufferTarget target) {
         if (target == RenderbufferTarget::Unknown) {
             using namespace MG_Util;
@@ -118,100 +97,4 @@ namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl {
                                          std::format("Renderbuffer name {} is not valid.", index)));
         return false;
     }
-
-    Bool ValidateFramebufferParameterPname(GLenum pname, Bool isDefaultFramebuffer, Bool forSetter,
-                                           const char* caller) {
-        Bool isDefaultParameter = false;
-        switch (pname) {
-        case GL_FRAMEBUFFER_DEFAULT_WIDTH:
-        case GL_FRAMEBUFFER_DEFAULT_HEIGHT:
-        case GL_FRAMEBUFFER_DEFAULT_LAYERS:
-        case GL_FRAMEBUFFER_DEFAULT_SAMPLES:
-        case GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS:
-            isDefaultParameter = true;
-            break;
-        case GL_DOUBLEBUFFER:
-        case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
-        case GL_IMPLEMENTATION_COLOR_READ_TYPE:
-        case GL_SAMPLES:
-        case GL_SAMPLE_BUFFERS:
-        case GL_STEREO:
-            // Queryable only; glFramebufferParameteri sets none of these.
-            if (forSetter) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidEnum,
-                    MakeUnique<GenericErrorInfo>(
-                        "MG_Impl/GLImpl/FramebufferImpl", caller,
-                        std::format("pname {} is not settable on a framebuffer.",
-                                    MG_Util::ConvertGLEnumToString(pname))));
-                return false;
-            }
-            break;
-        default:
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidEnum,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl/FramebufferImpl", caller,
-                    std::format("pname {} is not a framebuffer parameter.",
-                                MG_Util::ConvertGLEnumToString(pname))));
-            return false;
-        }
-
-        // The default framebuffer has no DEFAULT_* state of its own - its shape comes from the
-        // surface - so those names are accepted enums it simply cannot answer or accept.
-        if (isDefaultFramebuffer && isDefaultParameter) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>(
-                    "MG_Impl/GLImpl/FramebufferImpl", caller,
-                    std::format("pname {} does not apply to the default framebuffer.",
-                                MG_Util::ConvertGLEnumToString(pname))));
-            return false;
-        }
-        return true;
-    }
-
-    Bool ValidateReadFramebufferForCopy(const char* caller) {
-        auto& framebufferObject =
-            MG_State::pGLContext->GetFramebufferBindingSlot(FramebufferTarget::Read).GetBoundObject();
-        if (!framebufferObject || !framebufferObject->CheckCompleteness()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidFramebufferOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", caller,
-                                             "Read framebuffer is not framebuffer complete."));
-            return false;
-        }
-
-        const FramebufferAttachmentType readBuffer = framebufferObject->GetReadBuffer();
-        if (readBuffer == FramebufferAttachmentType::None ||
-            !framebufferObject->GetAttachment(readBuffer).IsValid()) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", caller,
-                                             "Read buffer names no attachment of the read framebuffer."));
-            return false;
-        }
-
-        // SAMPLE_BUFFERS is one whenever the read buffer resolves to multisample storage. A
-        // multisample texture says so by its target - its sample count can legally be one - while a
-        // renderbuffer says so by having been given a non-zero sample count.
-        const auto& readAttachment = framebufferObject->GetAttachment(readBuffer);
-        Bool isMultisampled = false;
-        if (readAttachment.IsRenderbuffer() && readAttachment.GetRenderbuffer()) {
-            isMultisampled = readAttachment.GetRenderbuffer()->GetSamples() > 0;
-        } else if (readAttachment.IsTexture() && readAttachment.GetTexture()) {
-            const auto target = readAttachment.GetTexture()->GetTarget();
-            isMultisampled = target == TextureTarget::Texture2DMultisample ||
-                             target == TextureTarget::Texture2DMultisampleArray;
-        }
-        if (isMultisampled) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl/FramebufferImpl", caller,
-                                             "Cannot copy from a multisampled read framebuffer."));
-            return false;
-        }
-
-        return true;
-    }
 } // namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl

MobileGL/MG_Impl/GLImpl/Framebuffer/Validators.h

@@ -14,21 +14,6 @@ namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl {
     Bool ValidateFramebufferTarget(FramebufferTarget target);
     Bool ValidateFramebufferName(Uint index, Bool allowZero = true);
     Bool ValidateFramebufferAttachmentType(FramebufferAttachmentType attachment);
-    // GL_COLOR_ATTACHMENTn is a token per n up to 31, but only the first GL_MAX_COLOR_ATTACHMENTS of
-    // them name an attachment point of a framebuffer object; the rest are INVALID_OPERATION for the
-    // attaching entry points (GL 4.6 core 9.2.7). Non-colour attachments pass through unchanged.
-    Bool ValidateColorAttachmentInRange(FramebufferAttachmentType attachment, const char* caller);
     Bool ValidateRenderbufferTarget(RenderbufferTarget target);
     Bool ValidateRenderbufferName(Uint index, Bool allowZero = true);
-    // The read-framebuffer preconditions the CopyTexSubImage family shares (GL 4.6 core 8.6): the
-    // read framebuffer must be complete, its read buffer must name a real attachment, and it must
-    // not be multisampled. Incompleteness is INVALID_FRAMEBUFFER_OPERATION, the other two are
-    // INVALID_OPERATION.
-    Bool ValidateReadFramebufferForCopy(const char* caller);
-    // The pname sets of glGet/FramebufferParameteri (GL 4.6 core 9.2.3). Order matters and is part
-    // of the contract: a name outside the table is INVALID_ENUM, and only then is a name that the
-    // DEFAULT framebuffer does not answer INVALID_OPERATION. Testing the framebuffer kind first
-    // would turn GL_FRAMEBUFFER_DEFAULT_WIDTH on framebuffer zero into the wrong error.
-    Bool ValidateFramebufferParameterPname(GLenum pname, Bool isDefaultFramebuffer, Bool forSetter,
-                                           const char* caller);
 } // namespace MobileGL::MG_Impl::GLImpl::FramebufferImpl

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.cpp

@@ -23,7 +23,6 @@
 #include <MG_Util/Converters/MGToGL/RenderStateEnumConverter.h>
 #include <MG_State/GLState/FramebufferState/FramebufferObject.h>
 #include <MG_Util/Texture/TextureFormatProcessor.h>
-#include <MG_Util/Async/ShaderCompilePool.h>
 #include <MG_Backend/BackendObjects.h>
 
 namespace MobileGL::MG_Impl::GLImpl {
@@ -51,23 +50,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         constexpr GLint kFrontendMaxTessControlAtomicCounters = 0;
         constexpr GLint kFrontendMaxTessEvaluationAtomicCounters = 0;
         constexpr GLint kFrontendMaxVertexAtomicCounters = 0;
-        // Zero counters means zero buffers to hold them. These have to be ANSWERED rather than
-        // left to the default INVALID_ENUM: a well-behaved application queries the limit exactly
-        // to find out that the stage cannot do this, and an error instead both leaves its output
-        // untouched (so it reads uninitialised memory and may conclude the opposite) and leaves a
-        // GL error pending that surfaces at whatever unrelated call checks next.
-        constexpr GLint kFrontendMaxGeometryAtomicCounterBuffers = 0;
-        constexpr GLint kFrontendMaxTessControlAtomicCounterBuffers = 0;
-        constexpr GLint kFrontendMaxTessEvaluationAtomicCounterBuffers = 0;
-        constexpr GLint kFrontendMaxVertexAtomicCounterBuffers = 0;
-        // One atomic counter is a uint, and a buffer never has to hold more counters than the
-        // combined limit the frontend advertises. GL 4.6 table 23.63 floors this at 32 bytes.
-        constexpr GLint kFrontendMaxAtomicCounterBufferSize =
-            kFrontendMaxCombinedAtomicCounters * static_cast<GLint>(sizeof(GLuint));
-        // KHR_debug minima (GL 4.6 table 23.66); the debug entry points are stubs, but the
-        // limits they advertise still have to be legal.
-        constexpr GLint kFrontendMaxDebugGroupStackDepth = 64;
-        constexpr GLint kFrontendMaxDebugLoggedMessages = 1;
         constexpr GLint kFrontendMaxVertexUniformComponents = 4096;
         constexpr GLint kFrontendMaxVertexUniformVectors = 128;
         constexpr GLint kFrontendMaxVertexUniformBlocks = 14;
@@ -183,30 +165,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return frontendCount;
         }
 
-        // A per-stage or combined BLOCK count is an amount of indexed binding points an
-        // application will occupy, and GL 4.6 table 23.64 orders the two accordingly:
-        // MAX_UNIFORM_BUFFER_BINDINGS >= MAX_COMBINED_UNIFORM_BLOCKS >= every per-stage count,
-        // and the same for the shader-storage family. The two families are answered from
-        // unrelated places here - frontend constants, backend dynamic parameters, and a few
-        // hard-coded TODOs - so nothing kept them ordered, and a backend that reports Vulkan
-        // descriptor-indexing counts advertised 256 compute uniform blocks over 36 binding
-        // points. KHR-GL44.multi_bind.dispatch_bind_buffers_base reads the block count and binds
-        // that many buffers in ONE glBindBuffersBase, which is then INVALID_OPERATION before it
-        // binds anything. Clamping is the only direction available: the binding count is the
-        // capacity of the state layer's indexed-binding array, not a number we may inflate.
-        GLint ClampBlockCountToBindingPoints(GLint blockCount, BufferTarget bufferTarget) {
-            const GLint bindingPoints = static_cast<GLint>(GetIndexedBufferQueryPointCount(bufferTarget));
-            return std::min(std::max(blockCount, 0), bindingPoints);
-        }
-
-        GLint ClampUniformBlockCount(GLint blockCount) {
-            return ClampBlockCountToBindingPoints(blockCount, BufferTarget::Uniform);
-        }
-
-        GLint ClampStorageBlockCount(GLint blockCount) {
-            return ClampBlockCountToBindingPoints(blockCount, BufferTarget::ShaderStorage);
-        }
-
         bool TryDecodeDrawBufferQuery(GLenum pname, SizeT& drawBufferIndex) {
             if (pname == GL_DRAW_BUFFER) {
                 drawBufferIndex = 0;
@@ -255,13 +213,8 @@ namespace MobileGL::MG_Impl::GLImpl {
 
             GLint maxSamples = 0;
             for (const auto& attachment : drawFbo->GetAllAttachmentObjects()) {
-                if (attachment.IsRenderbuffer() && attachment.GetRenderbuffer()) {
-                    maxSamples = std::max(maxSamples, static_cast<GLint>(attachment.GetRenderbuffer()->GetSamples()));
-                } else if (attachment.IsTexture() && attachment.GetTexture()) {
-                    // Multisample texture attachments count too (GL_SAMPLE_BUFFERS must
-                    // report 1 for any multisampled draw framebuffer).
-                    maxSamples = std::max(maxSamples, static_cast<GLint>(attachment.GetTexture()->GetSamples()));
-                }
+                if (!attachment.IsRenderbuffer() || !attachment.GetRenderbuffer()) continue;
+                maxSamples = std::max(maxSamples, static_cast<GLint>(attachment.GetRenderbuffer()->GetSamples()));
             }
             return maxSamples;
         }
@@ -305,60 +258,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return true;
         }
 
-        // GL_TEXTURE_BINDING_* is per-texture-unit state: glGetIntegerv answers for the
-        // active unit, glGetIntegeri_v answers for unit `index`. Both need the same
-        // pname -> target decode, so it lives here instead of being spelled out twice.
-        bool TryDecodeTextureUnitBindingPname(GLenum pname, TextureTarget& outTarget) {
-            switch (pname) {
-            case GL_TEXTURE_BINDING_1D: outTarget = TextureTarget::Texture1D; return true;
-            case GL_TEXTURE_BINDING_1D_ARRAY: outTarget = TextureTarget::Texture1DArray; return true;
-            case GL_TEXTURE_BINDING_2D: outTarget = TextureTarget::Texture2D; return true;
-            case GL_TEXTURE_BINDING_2D_ARRAY: outTarget = TextureTarget::Texture2DArray; return true;
-            case GL_TEXTURE_BINDING_2D_MULTISAMPLE: outTarget = TextureTarget::Texture2DMultisample; return true;
-            case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
-                outTarget = TextureTarget::Texture2DMultisampleArray;
-                return true;
-            case GL_TEXTURE_BINDING_3D: outTarget = TextureTarget::Texture3D; return true;
-            case GL_TEXTURE_BINDING_BUFFER: outTarget = TextureTarget::TextureBuffer; return true;
-            case GL_TEXTURE_BINDING_CUBE_MAP: outTarget = TextureTarget::TextureCubeMap; return true;
-            case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY: outTarget = TextureTarget::TextureCubeMapArray; return true;
-            case GL_TEXTURE_BINDING_RECTANGLE: outTarget = TextureTarget::TextureRectangle; return true;
-            default: return false;
-            }
-        }
-
-        GLint QueryTextureBindingOnUnit(Int unit, TextureTarget target) {
-            auto& textureUnit = MG_State::pGLContext->GetTextureUnitObject(unit);
-            const auto& obj = textureUnit.GetBindingSlot(target).GetBoundObject();
-            return obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
-        }
-
-        GLint QuerySamplerBindingOnUnit(Int unit) {
-            const auto& textureUnit = MG_State::pGLContext->GetTextureUnitObject(unit);
-            const auto& sampler = textureUnit.GetSamplerObject();
-            return sampler ? static_cast<GLint>(sampler->GetExternalIndex()) : 0;
-        }
-
-        // The ARB_viewport_array indexed rectangles. MobileGL keeps exactly one viewport, one
-        // scissor box and one depth range, so every in-range index answers with that single
-        // value - but it has to come from the frontend state the non-indexed getters read.
-        // The generic path at the bottom of GetIntegeri_v is a raw backend passthrough that
-        // has no case for these, so routing them through it returned zeros.
-        Bool IsIndexedViewportQuery(GLenum target) {
-            return target == GL_VIEWPORT || target == GL_SCISSOR_BOX || target == GL_DEPTH_RANGE;
-        }
-
-        // ARB_viewport_array: `index` selects a viewport and MAX_VIEWPORTS bounds it.
-        Bool ValidateViewportQueryIndex(GLuint index, const char* caller) {
-            GLint maxViewports = 0;
-            GetIntegerv(GL_MAX_VIEWPORTS, &maxViewports);
-            if (index < static_cast<GLuint>(std::max(maxViewports, 1))) return true;
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", caller, "Viewport index is out of range."));
-            return false;
-        }
-
         void CopyIntsToBooleans(const GLint* src, SizeT count, GLboolean* dst) {
             for (SizeT i = 0; i < count; ++i) {
                 dst[i] = src[i] ? GL_TRUE : GL_FALSE;
@@ -383,7 +282,7 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         MGLOG_D("glGetString, name: %s", MG_Util::ConvertGLEnumToString(name).c_str());
         if (!activeBackendObject) {
-            MGLOG_E_ONCE("activeBackendObject is not initialized!");
+            MGLOG_E("activeBackendObject is not initialized!");
             return (GLubyte*)"Unknown";
         }
 
@@ -442,7 +341,7 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
         if (!activeBackendObject) {
-            MGLOG_E_ONCE("activeBackendObject is not initialized!");
+            MGLOG_E("activeBackendObject is not initialized!");
             return (GLubyte*)"Unknown";
         }
         const auto& rendererInfo = activeBackendObject->GetRendererInfo();
@@ -566,14 +465,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_STENCIL_TEST:
             *params = MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::StencilTest) ? GL_TRUE : GL_FALSE;
             return;
-        case GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
-        case GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
-        case GL_FRAGMENT_INTERPOLATION_OFFSET_BITS: {
-            GLfloat value = 0.0f;
-            GetFloatv(pname, &value);
-            *params = value != 0.0f ? GL_TRUE : GL_FALSE;
-            return;
-        }
         default:
             break;
         }
@@ -629,19 +520,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             params[1] = dynamicParameters.ViewportBoundsRangeMax;
             return;
         }
-        case GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
-        case GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
-        case GL_FRAGMENT_INTERPOLATION_OFFSET_BITS: {
-            const auto& dynamicParameters = MG_Backend::pActiveBackendObject->GetDynamicParameters();
-            if (pname == GL_MIN_FRAGMENT_INTERPOLATION_OFFSET) {
-                params[0] = dynamicParameters.MinFragmentInterpolationOffset;
-            } else if (pname == GL_MAX_FRAGMENT_INTERPOLATION_OFFSET) {
-                params[0] = dynamicParameters.MaxFragmentInterpolationOffset;
-            } else {
-                params[0] = static_cast<GLfloat>(dynamicParameters.FragmentInterpolationOffsetBits);
-            }
-            return;
-        }
         case GL_DEPTH_CLEAR_VALUE:
             params[0] = MG_State::pGLContext->GetClearDepth();
             return;
@@ -755,14 +633,10 @@ namespace MobileGL::MG_Impl::GLImpl {
                     *data = 0;
                     return;
                 }
-                // GL 4.6 core table 23.4/23.5: *_BUFFER_SIZE reports the size glBindBufferRange
-                // was ASKED for, verbatim. It is not clamped to the buffer's storage, and it does
-                // not follow the buffer when a later glBufferData resizes it - a range may legally
-                // name bytes the buffer does not have yet. Clamping it here answered 0 for the
-                // common conformance shape of binding a range on a buffer that has no storage
-                // yet (KHR-GL43.shader_storage_buffer_object.basic-binding).
                 const Range1D range = bindingPoint.GetRange();
-                *data = static_cast<GLint>(range.end - range.start);
+                const auto start = std::min(range.start, bufferObject->GetSize());
+                const auto end = std::min(range.end, bufferObject->GetSize());
+                *data = static_cast<GLint>(end - start);
                 return;
             }
             default:
@@ -770,71 +644,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
         }
 
-        // Per-texture-unit bindings: GL 4.6 core table 23.19 makes every GL_TEXTURE_BINDING_*
-        // and GL_SAMPLER_BINDING indexed by texture unit. Without this they fell through to
-        // the raw backend passthrough at the bottom, which knows nothing about the
-        // frontend's binding state.
-        if (TextureTarget textureBindingTarget = TextureTarget::Unknown;
-            TryDecodeTextureUnitBindingPname(target, textureBindingTarget) || target == GL_SAMPLER_BINDING) {
-            GLint maxUnits = 0;
-            GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxUnits);
-            maxUnits = std::min<GLint>(maxUnits, MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS);
-            if (index >= static_cast<GLuint>(std::max(maxUnits, 0))) {
-                *data = 0;
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "Texture unit index is out of range."));
-                return;
-            }
-            *data = target == GL_SAMPLER_BINDING
-                ? QuerySamplerBindingOnUnit(static_cast<Int>(index))
-                : QueryTextureBindingOnUnit(static_cast<Int>(index), textureBindingTarget);
-            return;
-        }
-
         switch (target) {
-        // ARB_viewport_array queries the indexed rectangles through glGetIntegeri_v as well
-        // (gl4cMultiBindTests and the viewport_array group both do). The frontend keeps one
-        // viewport and one scissor box, so every in-range index reports that one.
-        case GL_VIEWPORT:
-        case GL_SCISSOR_BOX:
-            if (!ValidateViewportQueryIndex(index, __func__)) return;
-            GetIntegerv(target, data);
-            return;
-        // The vertex buffer binding points of the vertex array object that is bound. Indexed by
-        // binding point, not by attribute (GL 4.6 core 10.3.1).
-        case GL_VERTEX_BINDING_BUFFER:
-        case GL_VERTEX_BINDING_DIVISOR:
-        case GL_VERTEX_BINDING_OFFSET:
-        case GL_VERTEX_BINDING_STRIDE: {
-            if (index >= VertexArrayImpl::GetMaxVertexAttribBindings()) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                                 "Vertex buffer binding index is out of range."));
-                return;
-            }
-            const auto& vao = MG_State::pGLContext->GetBoundVertexArray();
-            if (!vao) {
-                *data = 0;
-                return;
-            }
-            const auto& binding = vao->GetBindingPoint(index);
-            switch (target) {
-            case GL_VERTEX_BINDING_BUFFER:
-                *data = binding.Buffer ? static_cast<GLint>(binding.Buffer->GetExternalIndex()) : 0;
-                return;
-            case GL_VERTEX_BINDING_DIVISOR:
-                *data = static_cast<GLint>(binding.Divisor);
-                return;
-            case GL_VERTEX_BINDING_OFFSET:
-                *data = static_cast<GLint>(binding.Offset);
-                return;
-            default:
-                *data = static_cast<GLint>(binding.Stride);
-                return;
-            }
-        }
         case GL_IMAGE_BINDING_NAME:
         case GL_IMAGE_BINDING_LEVEL:
         case GL_IMAGE_BINDING_LAYERED:
@@ -912,46 +722,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         getIntegeri(target, index, data);
     }
 
-    // GL_ARB_viewport_array's typed indexed getters. They were no-op stubs, which left the
-    // caller's output buffer holding whatever was on the stack. The multi-component indexed
-    // rectangles are answered from the frontend's own viewport/scissor/depth-range state, via
-    // the non-indexed getter of the matching type - GL_DEPTH_RANGE is float state, so putting
-    // it through the integer query would round it to 0/1. Everything else MobileGL answers
-    // indexed is scalar integer-domain state, where converting the integer query is exact.
-    void GetFloati_v(GLenum target, GLuint index, GLfloat* data) {
-        if (!data) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "data pointer cannot be null"));
-            return;
-        }
-        if (IsIndexedViewportQuery(target)) {
-            if (!ValidateViewportQueryIndex(index, __func__)) return;
-            GetFloatv(target, data);
-            return;
-        }
-        GLint ints[4] = {};
-        GetIntegeri_v(target, index, ints);
-        data[0] = static_cast<GLfloat>(ints[0]);
-    }
-
-    void GetDoublei_v(GLenum target, GLuint index, GLdouble* data) {
-        if (!data) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidValue,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "data pointer cannot be null"));
-            return;
-        }
-        if (IsIndexedViewportQuery(target)) {
-            if (!ValidateViewportQueryIndex(index, __func__)) return;
-            GetDoublev(target, data);
-            return;
-        }
-        GLint ints[4] = {};
-        GetIntegeri_v(target, index, ints);
-        data[0] = static_cast<GLdouble>(ints[0]);
-    }
-
     void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) {
         if (!data) {
             MG_State::pGLContext->RecordError(
@@ -988,8 +758,9 @@ namespace MobileGL::MG_Impl::GLImpl {
                     *data = 0;
                     return;
                 }
-                // Verbatim, unclamped - see the GetIntegeri_v arm.
-                *data = static_cast<GLint64>(range.end - range.start);
+                const auto start = std::min(range.start, bufferObject->GetSize());
+                const auto end = std::min(range.end, bufferObject->GetSize());
+                *data = static_cast<GLint64>(end - start);
                 return;
             }
             default:
@@ -997,30 +768,15 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
         }
 
-        // The one indexed pname whose value genuinely needs 64 bits: a vertex buffer binding
-        // offset is an intptr, so taking the 32-bit route below would truncate it.
-        if (target == GL_VERTEX_BINDING_OFFSET) {
-            if (index >= VertexArrayImpl::GetMaxVertexAttribBindings()) {
-                MG_State::pGLContext->RecordError(
-                    ErrorCode::InvalidValue,
-                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
-                                                 "Vertex buffer binding index is out of range."));
-                return;
-            }
-            const auto& vao = MG_State::pGLContext->GetBoundVertexArray();
-            *data = vao ? static_cast<GLint64>(vao->GetBindingPoint(index).Offset) : 0;
+        auto getInteger64i = MG_Backend::gBackendFunctionsTable.GL.GetInteger64i_v;
+        if (!getInteger64i) {
+            *data = 0;
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "Backend does not support indexed integer queries."));
             return;
         }
-
-        // Everything else is 32-bit indexed state that the glGetIntegeri_v pname table already
-        // owns, and GL 4.6 core 22.1 says every indexed query answers every indexed pname.
-        // Handing the leftovers straight to the backend instead made glGetInteger64i_v disagree
-        // with glGetIntegeri_v on the very same pname - GL_MAX_COMPUTE_WORK_GROUP_COUNT read
-        // back 0 while the 32-bit view said 65535 (KHR-GL43.compute_shader.max), because a
-        // frontend-only value simply is not in the driver's table.
-        GLint values[4] = {};
-        GetIntegeri_v(target, index, values);
-        *data = static_cast<GLint64>(values[0]);
+        getInteger64i(target, index, data);
     }
 
     void GetInteger64v(GLenum pname, GLint64* params) {
@@ -1142,13 +898,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             return;
         }
 
-        // Per-texture-unit bindings: the non-indexed query reports the active unit.
-        if (TextureTarget textureBindingTarget = TextureTarget::Unknown;
-            TryDecodeTextureUnitBindingPname(pname, textureBindingTarget)) {
-            *params = QueryTextureBindingOnUnit(MG_State::pGLContext->GetActiveTextureUnit(), textureBindingTarget);
-            return;
-        }
-
         switch (pname) {
         case GL_ACTIVE_TEXTURE:
             *params = MG_State::pGLContext->GetActiveTextureUnit() + GL_TEXTURE0;
@@ -1255,37 +1004,12 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
             return;
         }
-        case GL_DRAW_INDIRECT_BUFFER_BINDING: {
-            auto& obj = MG_State::pGLContext->GetBufferBindingSlot(BufferTarget::DrawIndirect).GetBoundObject();
-            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
-            return;
-        }
-        case GL_MAX_SHADER_COMPILER_THREADS_KHR:
-            // GL_KHR_parallel_shader_compile (GL_MAX_SHADER_COMPILER_THREADS_ARB is the same
-            // 0x91B0). The number of threads MobileGL's compile pool would actually use, so
-            // an application sizing its own submission batches gets a real answer.
-            //
-            // Zero when asynchronous compilation is off, which is the honest reply and the
-            // one the extension defines for an implementation with no compiler threads: the
-            // extension string is withdrawn in that configuration too, so a conforming
-            // application never reaches this query, and one that asks anyway is told there
-            // are none rather than being handed a thread count nothing will use.
-            *params = MG_Util::Async::AsyncShaderCompileEnabled()
-                          ? static_cast<GLint>(MG_Util::Async::ShaderCompilePool::Get().GetThreadCount())
-                          : 0;
-            return;
         case GL_MAX_DEBUG_GROUP_STACK_DEPTH:
-            // KHR_debug floors this at 64 even when the group entry points are stubs: the
-            // limit describes how deep glPushDebugGroup may nest, and 0 is not a legal answer.
-            *params = kFrontendMaxDebugGroupStackDepth;
+            *params = 0; // debug-group entrypoints are stubbed
             return;
         case GL_MAX_DEBUG_MESSAGE_LENGTH:
             *params = 1024; // debug-message entrypoints are stubbed, but KHR_debug requires a valid limit
             return;
-        case GL_MAX_DEBUG_LOGGED_MESSAGES:
-            // Size of the message log ring; KHR_debug requires at least 1.
-            *params = kFrontendMaxDebugLoggedMessages;
-            return;
         case GL_DEBUG_GROUP_STACK_DEPTH:
             *params = 0; // debug-group entrypoints are stubbed
             return;
@@ -1430,7 +1154,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = kFrontendMaxCombinedAtomicCounters;
             return;
         case GL_MAX_COMBINED_UNIFORM_BLOCKS:
-            *params = ClampUniformBlockCount(kFrontendMaxCombinedUniformBlocks);
+            *params = kFrontendMaxCombinedUniformBlocks;
             return;
         case GL_MAX_DUAL_SOURCE_DRAW_BUFFERS:
             *params = 1; // TODO
@@ -1445,7 +1169,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = kFrontendMaxFragmentAtomicCounters;
             return;
         case GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS:
-            *params = ClampStorageBlockCount(16); // TODO
+            *params = 16; // TODO
             return;
         case GL_MAX_FRAGMENT_INPUT_COMPONENTS:
             *params = kFrontendMaxFragmentInputComponents;
@@ -1462,16 +1186,13 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = kFrontendMaxFragmentUniformVectors;
             return;
         case GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
-            *params = ClampUniformBlockCount(kFrontendMaxFragmentUniformBlocks);
+            *params = kFrontendMaxFragmentUniformBlocks;
             return;
         case GL_MAX_GEOMETRY_ATOMIC_COUNTERS:
             *params = kFrontendMaxGeometryAtomicCounters;
             return;
-        case GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS:
-            *params = kFrontendMaxGeometryAtomicCounterBuffers;
-            return;
         case GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS:
-            *params = ClampStorageBlockCount(16); // TODO
+            *params = 16; // TODO
             return;
         case GL_MAX_GEOMETRY_INPUT_COMPONENTS:
             *params = kFrontendMaxGeometryInputComponents;
@@ -1494,7 +1215,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = kFrontendMaxGeometryTotalOutputComponents;
             return;
         case GL_MAX_GEOMETRY_UNIFORM_BLOCKS:
-            *params = ClampUniformBlockCount(kFrontendMaxGeometryUniformBlocks);
+            *params = kFrontendMaxGeometryUniformBlocks;
             return;
         case GL_MAX_GEOMETRY_UNIFORM_COMPONENTS:
             *params = kFrontendMaxGeometryUniformComponents;
@@ -1526,15 +1247,9 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS:
             *params = kFrontendMaxTessControlAtomicCounters;
             return;
-        case GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS:
-            *params = kFrontendMaxTessControlAtomicCounterBuffers;
-            return;
         case GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS:
             *params = kFrontendMaxTessEvaluationAtomicCounters;
             return;
-        case GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS:
-            *params = kFrontendMaxTessEvaluationAtomicCounterBuffers;
-            return;
         case GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS:
             *params = 0;
             return;
@@ -1542,10 +1257,10 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = 0;
             return;
         case GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS:
-            *params = ClampStorageBlockCount(16); // TODO
+            *params = 16; // TODO
             return;
         case GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS:
-            *params = ClampStorageBlockCount(16); // TODO
+            *params = 16; // TODO
             return;
         case GL_MAX_TEXTURE_LOD_BIAS:
             *params = 15; // TODO
@@ -1562,16 +1277,13 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_MAX_VERTEX_ATOMIC_COUNTERS:
             *params = kFrontendMaxVertexAtomicCounters;
             return;
-        case GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS:
-            *params = kFrontendMaxVertexAtomicCounterBuffers;
-            return;
         case GL_MAX_VERTEX_IMAGE_UNIFORMS:
             *params = MG_Backend::pActiveBackendObject
                           ? MG_Backend::pActiveBackendObject->GetDynamicParameters().MaxVertexImageUniforms
                           : MG_Backend::DynamicBackendParameters{}.MaxVertexImageUniforms;
             return;
         case GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS:
-            *params = ClampStorageBlockCount(16); // TODO
+            *params = 16; // TODO
             return;
         case GL_MAX_VERTEX_UNIFORM_COMPONENTS:
             *params = kFrontendMaxVertexUniformComponents;
@@ -1583,7 +1295,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = kFrontendMaxVertexOutputComponents;
             return;
         case GL_MAX_VERTEX_UNIFORM_BLOCKS:
-            *params = ClampUniformBlockCount(kFrontendMaxVertexUniformBlocks);
+            *params = kFrontendMaxVertexUniformBlocks;
             return;
         case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
             *params = 0; // compressed texture upload entrypoints are still unimplemented
@@ -1655,7 +1367,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = 0; // program-binary entrypoints are stubbed
             return;
         case GL_PROGRAM_PIPELINE_BINDING:
-            *params = static_cast<GLint>(MG_State::pGLContext->GetBoundProgramPipelineName());
+            *params = 0; // program-pipeline entrypoints are stubbed
             return;
         case GL_PROGRAM_POINT_SIZE:
             *params = MG_State::pGLContext->IsCapabilityEnabled(CapabilityInput::ProgramPointSize) ? GL_TRUE : GL_FALSE;
@@ -1739,9 +1451,13 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_SAMPLE_MASK_VALUE:
             *params = static_cast<GLint>(MG_State::pGLContext->GetSampleMaskValue());
             return;
-        case GL_SAMPLER_BINDING:
-            *params = QuerySamplerBindingOnUnit(MG_State::pGLContext->GetActiveTextureUnit());
+        case GL_SAMPLER_BINDING: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            const auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& sampler = tu.GetSamplerObject();
+            *params = sampler ? static_cast<GLint>(sampler->GetExternalIndex()) : 0;
             return;
+        }
         case GL_SAMPLES:
             *params = ResolveDrawFramebufferSampleCount();
             return;
@@ -1837,11 +1553,92 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_STEREO:
             *params = 0; // stereo surfaces are not exposed
             return;
+        case GL_TEXTURE_BINDING_1D: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture1D);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_1D_ARRAY: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture1DArray);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_2D: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture2D);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            MGLOG_D("Get GL_TEXTURE_BINDING_2D: %d", *params);
+            return;
+        }
+        case GL_TEXTURE_BINDING_2D_ARRAY: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture2DArray);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_2D_MULTISAMPLE: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture2DMultisample);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture2DMultisampleArray);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_3D: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::Texture3D);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_BUFFER: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::TextureBuffer);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_CUBE_MAP: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::TextureCubeMap);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
+        case GL_TEXTURE_BINDING_RECTANGLE: {
+            Int unit = MG_State::pGLContext->GetActiveTextureUnit();
+            auto& tu = MG_State::pGLContext->GetTextureUnitObject(unit);
+            const auto& slot = tu.GetBindingSlot(TextureTarget::TextureRectangle);
+            const auto& obj = slot.GetBoundObject();
+            *params = obj ? static_cast<GLint>(obj->GetExternalIndex()) : 0;
+            return;
+        }
         case GL_TEXTURE_COMPRESSION_HINT:
             *params = static_cast<GLint>(MG_State::pGLContext->GetHint(pname));
             return;
         case GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
-            *params = MG_Backend::pActiveBackendObject->GetDynamicParameters().TextureBufferOffsetAlignment;
+            *params = 0; // texture-buffer range entrypoints are stubbed
             return;
         case GL_TIMESTAMP: {
             Int64 timestamp = 0;
@@ -1910,22 +1707,20 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = vao ? static_cast<GLint>(vao->GetExternalIndex()) : 0;
             return;
         }
-        // The vertex buffer binding points are per-binding-index state, so the non-indexed getter
-        // has nothing to answer with (GL 4.6 core table 23.4).
-        case GL_VERTEX_BINDING_BUFFER:
         case GL_VERTEX_BINDING_DIVISOR:
+            *params = 0; // vertex-binding entrypoints are stubbed
+            return;
         case GL_VERTEX_BINDING_OFFSET:
+            *params = 0; // vertex-binding entrypoints are stubbed
+            return;
         case GL_VERTEX_BINDING_STRIDE:
-            RecordIndexedOnlyGetterError(__func__, pname);
+            *params = 0; // vertex-binding entrypoints are stubbed
             return;
         case GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET:
-            *params = static_cast<GLint>(VertexArrayImpl::GetMaxVertexAttribRelativeOffset());
+            *params = 0; // vertex-binding entrypoints are stubbed
             return;
         case GL_MAX_VERTEX_ATTRIB_BINDINGS:
-            *params = static_cast<GLint>(VertexArrayImpl::GetMaxVertexAttribBindings());
-            return;
-        case GL_MAX_VERTEX_ATTRIB_STRIDE:
-            *params = static_cast<GLint>(VertexArrayImpl::GetMaxVertexAttribStride());
+            *params = 0; // vertex-binding entrypoints are stubbed
             return;
         case GL_VIEWPORT: {
             const auto& vp = MG_State::pGLContext->GetViewport();
@@ -1954,7 +1749,7 @@ namespace MobileGL::MG_Impl::GLImpl {
 
         const auto& activeBackendObject = MG_Backend::pActiveBackendObject;
         if (!activeBackendObject) {
-            MGLOG_E_ONCE("activeBackendObject is not initialized!");
+            MGLOG_E("activeBackendObject is not initialized!");
             return;
         }
         const auto& rendererInfo = activeBackendObject->GetRendererInfo();
@@ -1983,13 +1778,13 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = dynamicParameters.SubgroupQuadOperationsInAllStages ? GL_TRUE : GL_FALSE;
             break;
         case GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS:
-            *params = ClampStorageBlockCount(dynamicParameters.MaxComputeShaderStorageBlocks);
+            *params = dynamicParameters.MaxComputeShaderStorageBlocks;
             break;
         case GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS:
-            *params = ClampStorageBlockCount(dynamicParameters.MaxCombinedShaderStorageBlocks);
+            *params = dynamicParameters.MaxCombinedShaderStorageBlocks;
             break;
         case GL_MAX_COMPUTE_UNIFORM_BLOCKS:
-            *params = ClampUniformBlockCount(dynamicParameters.MaxComputeUniformBlocks);
+            *params = dynamicParameters.MaxComputeUniformBlocks;
             break;
         case GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS:
             *params = dynamicParameters.MaxComputeTextureImageUnits;
@@ -2091,44 +1886,9 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_MAX_SAMPLE_MASK_WORDS:
             *params = dynamicParameters.MaxSampleMaskWords;
             break;
-        case GL_PATCH_VERTICES:
-            *params = static_cast<GLint>(MG_State::pGLContext->GetPatchVertices());
-            break;
-        case GL_MAX_PATCH_VERTICES:
-            *params = dynamicParameters.MaxPatchVertices;
-            break;
-        case GL_MAX_TESS_GEN_LEVEL:
-            *params = dynamicParameters.MaxTessGenLevel;
-            break;
-        case GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET:
-            *params = dynamicParameters.MinProgramTextureGatherOffset;
-            break;
-        case GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET:
-            *params = dynamicParameters.MaxProgramTextureGatherOffset;
-            break;
         case GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS:
             *params = static_cast<GLint>(GetIndexedBufferQueryPointCount(BufferTarget::ShaderStorage));
             break;
-        case GL_MAX_SHADER_STORAGE_BLOCK_SIZE:
-            // 64-bit state (see GetInteger64v); the 32-bit query saturates, per the GL
-            // state-query conversion rules.
-            *params = static_cast<GLint>(std::min<Uint64>(dynamicParameters.MaxShaderStorageBlockSize,
-                                                          static_cast<Uint64>(INT32_MAX)));
-            break;
-        case GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS:
-            *params = static_cast<GLint>(GetIndexedBufferQueryPointCount(BufferTarget::AtomicCounter));
-            break;
-        case GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE:
-            // The conformance suite splits this evenly across every advertised binding point and
-            // binds all of them in one glBindBuffersRange
-            // (KHR-GL44.multi_bind.functional_bind_buffers_range), so the pair has to divide:
-            // 32 bytes over 36 binding points is a zero-sized range, which BindBufferRange
-            // rejects with INVALID_VALUE before it binds anything. Floor the advertised size at
-            // one counter per binding point.
-            *params = std::max<GLint>(
-                kFrontendMaxAtomicCounterBufferSize,
-                static_cast<GLint>(GetIndexedBufferQueryPointCount(BufferTarget::AtomicCounter) * sizeof(GLuint)));
-            break;
         case GL_MAX_TEXTURE_BUFFER_SIZE:
             *params = dynamicParameters.MaxTextureBufferSize;
             break;
@@ -2141,25 +1901,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
             *params = kFrontendMaxTransformFeedbackSeparateComponents;
             break;
-        // ARB_transform_feedback3 limits. The GL CTS queries these before checking
-        // whether the extension is advertised and requires no GL error; desktop
-        // drivers all accept them, so answer with the separate-attrib capacity and
-        // the single vertex stream the backends provide.
-        case GL_MAX_TRANSFORM_FEEDBACK_BUFFERS:
-            *params = kFrontendMaxTransformFeedbackSeparateAttribs;
-            break;
-        case GL_MAX_VERTEX_STREAMS:
-            *params = 1;
-            break;
-        case GL_TRANSFORM_FEEDBACK_ACTIVE:
-            *params = MG_State::pGLContext->IsTransformFeedbackActive() ? 1 : 0;
-            break;
-        case GL_TRANSFORM_FEEDBACK_PAUSED:
-            *params = MG_State::pGLContext->IsTransformFeedbackPaused() ? 1 : 0;
-            break;
-        case GL_TRANSFORM_FEEDBACK_BINDING:
-            *params = static_cast<GLint>(MG_State::pGLContext->GetBoundTransformFeedbackName());
-            break;
         case GL_MAX_TEXTURE_IMAGE_UNITS:
             *params = dynamicParameters.MaxTextureImageUnits;
             break;
@@ -2216,15 +1957,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_SUBPIXEL_BITS:
             *params = std::max(dynamicParameters.ViewportSubpixelBits, kFrontendSubpixelBits);
             break;
-        case GL_MIN_FRAGMENT_INTERPOLATION_OFFSET:
-            *params = static_cast<GLint>(std::lround(dynamicParameters.MinFragmentInterpolationOffset));
-            break;
-        case GL_MAX_FRAGMENT_INTERPOLATION_OFFSET:
-            *params = static_cast<GLint>(std::lround(dynamicParameters.MaxFragmentInterpolationOffset));
-            break;
-        case GL_FRAGMENT_INTERPOLATION_OFFSET_BITS:
-            *params = dynamicParameters.FragmentInterpolationOffsetBits;
-            break;
         case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
             *params = static_cast<Int>(dynamicParameters.UniformBufferOffsetAlignment);
             break;
@@ -2248,7 +1980,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             *params = static_cast<GLint>(std::lround(dynamicParameters.MaxTextureMaxAnisotropy));
             break;
         default:
-            MGLOG_D("glGetIntegerv: Invalid enum %s (0x%X)", MG_Util::ConvertGLEnumToString(pname).c_str(), pname);
+            MGLOG_E("glGetIntegerv: Invalid enum %s (0x%X)", MG_Util::ConvertGLEnumToString(pname).c_str(), pname);
             MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
                                               MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetIntegerv",
                                                                            std::format("Invalid enum: 0x{:X}", pname)));
@@ -2264,12 +1996,4 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
         return MG_Util::ConvertErrorCodeToGLEnum(error->get()->code);
     }
-
-    GLenum GetGraphicsResetStatus() {
-        // MobileGL does not implement robustness reset notification, so report GL_NO_ERROR
-        // ("no reset detected"). Returning the generic stub's (GLenum)1 makes dEQP read a lost
-        // device after every case (gl3cTestPackages.cpp:121) and, under the default
-        // --deqp-terminate-on-device-lost=enable, tear the whole CTS run down.
-        return GL_NO_ERROR;
-    }
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.h

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

MobileGL/MG_Impl/GLImpl/Program/GL_Program.h

@@ -42,10 +42,6 @@ namespace MobileGL::MG_Impl::GLImpl {
     GLboolean IsProgram(GLuint program);
     GLboolean IsShader(GLuint shader);
     void LinkProgram(GLuint program);
-    // GL_KHR_parallel_shader_compile / GL_ARB_parallel_shader_compile. Both names are the
-    // same entry point; see MaxShaderCompilerThreadsKHR_State for the semantics of count.
-    void MaxShaderCompilerThreadsKHR(GLuint count);
-    void MaxShaderCompilerThreadsARB(GLuint count);
     void ShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length);
     void UseProgram(GLuint program);
     void Uniform1f(GLint location, GLfloat v0);
@@ -141,47 +137,5 @@ namespace MobileGL::MG_Impl::GLImpl {
     GLint GetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar* name);
     GLint GetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar* name);
     void ShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
-    void Uniform1d(GLint location, GLdouble v0);
-    void Uniform1dv(GLint location, GLsizei count, const GLdouble* value);
-    void ProgramUniform1d(GLuint program, GLint location, GLdouble v0);
-    void ProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble* value);
-    void Uniform2d(GLint location, GLdouble v0, GLdouble v1);
-    void Uniform2dv(GLint location, GLsizei count, const GLdouble* value);
-    void ProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void ProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble* value);
-    void Uniform3d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void Uniform3dv(GLint location, GLsizei count, const GLdouble* value);
-    void ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void ProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble* value);
-    void Uniform4d(GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void Uniform4dv(GLint location, GLsizei count, const GLdouble* value);
-    void ProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void ProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble* value);
-    void UniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void ProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void UniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void ProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void ProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void ProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void ProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void ProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void ProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void ProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void ProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value);
-    void GetUniformdv(GLuint program, GLint location, GLdouble* params);
     void ValidateProgram(GLuint program);
-    void ProgramParameteri(GLuint program, GLenum pname, GLint value);
-    GLuint CreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const* strings);
-    void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary);
-    void ProgramBinary(GLuint program, GLenum binaryFormat, const void* binary, GLsizei length);
-    void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode);
-    void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size,
-                                     GLenum* type, GLchar* name);
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Program/GL_ProgramPipeline.cpp

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

MobileGL/MG_Impl/GLImpl/Program/GL_ProgramPipeline.h

@@ -1,23 +0,0 @@
-// MobileGL - MobileGL/MG_Impl/GLImpl/Program/GL_ProgramPipeline.h
-// Copyright (c) 2025-2026 MobileGL-Dev
-// Licensed under the GNU Lesser General Public License v3.0:
-//   https://www.gnu.org/licenses/gpl-3.0.txt
-//   https://www.gnu.org/licenses/lgpl-3.0.txt
-// SPDX-License-Identifier: LGPL-3.0-only
-// End of Source File Header
-
-#pragma once
-#include <Includes.h>
-
-namespace MobileGL::MG_Impl::GLImpl {
-    void GenProgramPipelines(GLsizei n, GLuint* pipelines);
-    void CreateProgramPipelines(GLsizei n, GLuint* pipelines);
-    void DeleteProgramPipelines(GLsizei n, const GLuint* pipelines);
-    void BindProgramPipeline(GLuint pipeline);
-    GLboolean IsProgramPipeline(GLuint pipeline);
-    void GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint* params);
-    void GetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
-    void UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-    void ActiveShaderProgram(GLuint pipeline, GLuint program);
-    void ValidateProgramPipeline(GLuint pipeline);
-} // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Program/ProgramInterface.cpp

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

MobileGL/MG_Impl/GLImpl/Program/ProgramInterface.h

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

MobileGL/MG_Impl/GLImpl/Query/GL_Query.cpp

@@ -7,7 +7,6 @@
 // End of Source File Header
 
 #include "GL_Query.h"
-#include "../Getter/GL_Getter.h"
 #include <Config.h>
 #include <MG_Backend/BackendObjects.h>
 #include <MG_State/GLState/Core.h>
@@ -23,16 +22,11 @@ namespace MobileGL::MG_Impl::GLImpl {
         struct QueryObject {
             GLuint id = 0;
             GLenum target = 0; // 0 = gen'd but never used with BeginQuery/QueryCounter
-            // glCreateQueries makes the object outright; glGenQueries only reserves the name,
-            // and the object appears when the name is first used (GL 4.6 core 4.2.1).
-            Bool created = false;
             MG_Backend::BackendQueryHandle backendHandle = nullptr;
             Bool active = false;
             Bool ended = false;
             Bool resultCached = false;
             Uint64 cachedResult = 0;
-            // Transform feedback primitive counter at BeginQuery time.
-            Uint64 counterSnapshot = 0;
         };
 
         // Query calls may arrive from any thread (launchers migrate the context
@@ -47,11 +41,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         GLuint g_nextQueryId = 1;
         // Id of the query currently active on GL_TIME_ELAPSED (0 = none).
         GLuint g_activeTimeElapsedQueryId = 0;
-        // Ids of the queries active on the transform feedback targets (0 = none).
-        GLuint g_activePrimitivesWrittenQueryId = 0;
-        GLuint g_activePrimitivesGeneratedQueryId = 0;
-        // Id of the query active on GL_SAMPLES_PASSED (0 = none).
-        GLuint g_activeSamplesPassedQueryId = 0;
 
         Bool TimerQueryDisabled() {
             return MG_Config::Features.DisableTimerQuery;
@@ -62,34 +51,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                                               MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", function, message));
         }
 
-        // The by-buffer query getters write the result into a buffer object instead of client
-        // memory. Everything about the query itself - the name, whether it is still active, the
-        // parameter - is checked by GetQueryObjectValue; what is left is the destination, so this
-        // resolves the buffer and confirms the write lands inside it (GL 4.6 core 4.2.1).
-        Bool ResolveQueryResultDestination(GLuint buffer, GLintptr offset, SizeT writeSize, const char* function,
-                                           SharedPtr<MG_State::GLState::BufferObject>& outBuffer) {
-            if (offset < 0) {
-                RecordQueryError(ErrorCode::InvalidValue, function, "Offset cannot be negative.");
-                return false;
-            }
-            if (!MG_State::pGLContext->ValidateBufferObject(buffer)) {
-                RecordQueryError(ErrorCode::InvalidOperation, function, "Buffer object does not exist.");
-                return false;
-            }
-            auto bufferObject = MG_State::pGLContext->GetBufferObject(buffer);
-            if (!bufferObject) {
-                RecordQueryError(ErrorCode::InvalidOperation, function, "Buffer object does not exist.");
-                return false;
-            }
-            if (static_cast<SizeT>(offset) + writeSize > bufferObject->GetSize()) {
-                RecordQueryError(ErrorCode::InvalidOperation, function,
-                                 "The query result does not fit in the buffer object at this offset.");
-                return false;
-            }
-            outBuffer = bufferObject;
-            return true;
-        }
-
         // Callers must hold g_queryObjectsMutex.
         QueryObject* FindQueryObjectLocked(GLuint id) {
             const auto it = g_liveQueryObjects.find(id);
@@ -123,13 +84,8 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
 
         // Shared GetQueryObject* implementation. Returns false when an error
-        // was recorded and no value should be written back. `outValueProduced`, when given,
-        // additionally distinguishes "succeeded with a value" from "succeeded but the result is not
-        // ready" - the GL_QUERY_RESULT_NO_WAIT case, where GL_ARB_query_buffer_object says the
-        // destination is left alone rather than written with a placeholder.
-        Bool GetQueryObjectValue(GLuint id, GLenum pname, const char* function, Uint64& outValue,
-                                 Bool* outValueProduced = nullptr) {
-            if (outValueProduced) *outValueProduced = true;
+        // was recorded and no value should be written back.
+        Bool GetQueryObjectValue(GLuint id, GLenum pname, const char* function, Uint64& outValue) {
             const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
             auto* queryObject = FindQueryObjectLocked(id);
             if (!queryObject) {
@@ -142,41 +98,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
 
             switch (pname) {
-            case GL_QUERY_TARGET:
-                // The target a query was begun with (or created with, for glCreateQueries) - state
-                // the object has carried all along, GL 4.6 core table 23.35.
-                outValue = queryObject->target;
-                return true;
-            case GL_QUERY_RESULT_NO_WAIT: {
-                if (queryObject->resultCached) {
-                    outValue = queryObject->cachedResult;
-                    return true;
-                }
-                Uint64 result = 0;
-                const auto getQueryResult64 = MG_Backend::gBackendFunctionsTable.GL.GetQueryResult64;
-                if (queryObject->backendHandle && getQueryResult64 &&
-                    !getQueryResult64(queryObject->backendHandle, /*wait=*/false, &result)) {
-                    // Not ready. The whole point of the no-wait form is that the caller's
-                    // destination keeps whatever it already held.
-                    if (outValueProduced) *outValueProduced = false;
-                    outValue = 0;
-                    return true;
-                }
-                if (queryObject->target == GL_ANY_SAMPLES_PASSED ||
-                    queryObject->target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
-                    result = result != 0 ? 1 : 0;
-                }
-                if (queryObject->backendHandle) {
-                    if (const auto deleteBackendQuery = MG_Backend::gBackendFunctionsTable.GL.DeleteBackendQuery) {
-                        deleteBackendQuery(queryObject->backendHandle);
-                    }
-                    queryObject->backendHandle = nullptr;
-                }
-                queryObject->cachedResult = result;
-                queryObject->resultCached = true;
-                outValue = result;
-                return true;
-            }
             case GL_QUERY_RESULT_AVAILABLE: {
                 if (queryObject->resultCached || !queryObject->backendHandle) {
                     outValue = 1;
@@ -205,11 +126,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                         outValue = 0;
                         return true;
                     }
-                    // ANY_SAMPLES_PASSED* report a boolean.
-                    if (queryObject->target == GL_ANY_SAMPLES_PASSED ||
-                        queryObject->target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
-                        result = result != 0 ? 1 : 0;
-                    }
                     // Final value produced (or no GetQueryResult64 hook: the
                     // query degrades to a zero result); the backend handle is
                     // consumed and the value cached for later reads.
@@ -228,21 +144,6 @@ namespace MobileGL::MG_Impl::GLImpl {
                 return false;
             }
         }
-
-        template <typename T>
-        void GetQueryBufferObject(GLuint id, GLuint buffer, GLenum pname, GLintptr offset, const char* function) {
-            SharedPtr<MG_State::GLState::BufferObject> bufferObject;
-            if (!ResolveQueryResultDestination(buffer, offset, sizeof(T), function, bufferObject)) return;
-
-            Uint64 value = 0;
-            Bool valueProduced = false;
-            if (!GetQueryObjectValue(id, pname, function, value, &valueProduced)) return;
-            // GL_QUERY_RESULT_NO_WAIT on a result that has not landed writes nothing at all.
-            if (!valueProduced) return;
-
-            const T narrowed = static_cast<T>(value);
-            bufferObject->UploadSubData({const_cast<T*>(&narrowed), sizeof(T)}, static_cast<SizeT>(offset));
-        }
     } // namespace
 
     void GenQueries(GLsizei n, GLuint* ids) {
@@ -263,41 +164,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
     }
 
-    // glCreateQueries differs from glGenQueries in creating the objects outright, with their
-    // target already fixed and the rest of their state at the defaults (GL 4.6 core 4.2.1).
-    void CreateQueries(GLenum target, GLsizei n, GLuint* ids) {
-        switch (target) {
-        case GL_SAMPLES_PASSED:
-        case GL_ANY_SAMPLES_PASSED:
-        case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
-        case GL_TIME_ELAPSED:
-        case GL_TIMESTAMP:
-        case GL_PRIMITIVES_GENERATED:
-        case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
-            break;
-        default:
-            RecordQueryError(ErrorCode::InvalidEnum, __FUNCTION__, "Query target is not accepted.");
-            return;
-        }
-        if (n < 0) {
-            RecordQueryError(ErrorCode::InvalidValue, __FUNCTION__, "n cannot be negative.");
-            return;
-        }
-        if (!ids) {
-            return;
-        }
-        const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
-        for (GLsizei i = 0; i < n; ++i) {
-            const GLuint id = g_nextQueryId++;
-            auto* queryObject = new QueryObject;
-            queryObject->id = id;
-            queryObject->target = target;
-            queryObject->created = true;
-            g_liveQueryObjects[id] = queryObject;
-            ids[i] = id;
-        }
-    }
-
     void DeleteQueries(GLsizei n, const GLuint* ids) {
         if (n < 0) {
             RecordQueryError(ErrorCode::InvalidValue, __FUNCTION__, "n cannot be negative.");
@@ -314,24 +180,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             }
             QueryObject* queryObject = it->second;
             if (queryObject->active) {
-                // Implicitly end before deletion, releasing the matching active slot.
-                if (queryObject->target == GL_SAMPLES_PASSED || queryObject->target == GL_ANY_SAMPLES_PASSED ||
-                    queryObject->target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
-                    if (const auto endOcclusionQuery = MG_Backend::gBackendFunctionsTable.GL.EndOcclusionQuery;
-                        endOcclusionQuery && queryObject->backendHandle) {
-                        endOcclusionQuery(queryObject->backendHandle);
-                    }
-                    queryObject->active = false;
-                    g_activeSamplesPassedQueryId = 0;
-                } else if (queryObject->target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ||
-                           queryObject->target == GL_PRIMITIVES_GENERATED) {
-                    queryObject->active = false;
-                    (queryObject->target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
-                         ? g_activePrimitivesWrittenQueryId
-                         : g_activePrimitivesGeneratedQueryId) = 0;
-                } else {
-                    EndTimeElapsedQueryLocked(queryObject);
-                }
+                EndTimeElapsedQueryLocked(queryObject); // implicitly end before deletion
             }
             if (queryObject->backendHandle) {
                 if (const auto deleteBackendQuery = MG_Backend::gBackendFunctionsTable.GL.DeleteBackendQuery) {
@@ -349,23 +198,16 @@ namespace MobileGL::MG_Impl::GLImpl {
             return GL_FALSE;
         }
         const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
-        // A name from glGenQueries is not yet a query object: it becomes one when it is first
-        // used with BeginQuery/QueryCounter (which is what a non-zero target records), or
-        // immediately if it came from glCreateQueries.
-        const auto* queryObject = FindQueryObjectLocked(id);
-        return (queryObject != nullptr && (queryObject->created || queryObject->target != 0)) ? GL_TRUE : GL_FALSE;
+        // Gen'd ids count as query objects here: the registry creates live
+        // objects at GenQueries time.
+        return FindQueryObjectLocked(id) != nullptr ? GL_TRUE : GL_FALSE;
     }
 
     void BeginQuery(GLenum target, GLuint id) {
-        const Bool isTransformFeedbackQuery =
-            target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN || target == GL_PRIMITIVES_GENERATED;
-        const Bool isOcclusionQuery =
-            (target == GL_SAMPLES_PASSED || target == GL_ANY_SAMPLES_PASSED ||
-             target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) &&
-            MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery != nullptr;
-        if (target != GL_TIME_ELAPSED && !isTransformFeedbackQuery && !isOcclusionQuery) {
-            // GL_TIMESTAMP is not a valid BeginQuery target; the occlusion targets
-            // need backend support.
+        if (target != GL_TIME_ELAPSED) {
+            // Only GL_TIME_ELAPSED timer queries are implemented (occlusion and
+            // primitive queries remain stubs); GL_TIMESTAMP is not a valid
+            // BeginQuery target either.
             RecordQueryError(ErrorCode::InvalidEnum, __FUNCTION__, "Query target is not supported.");
             return;
         }
@@ -379,13 +221,9 @@ namespace MobileGL::MG_Impl::GLImpl {
             RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__, "Query object does not exist.");
             return;
         }
-        GLuint& activeQueryId = isTransformFeedbackQuery
-            ? (target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ? g_activePrimitivesWrittenQueryId
-                                                                  : g_activePrimitivesGeneratedQueryId)
-            : (isOcclusionQuery ? g_activeSamplesPassedQueryId : g_activeTimeElapsedQueryId);
-        if (activeQueryId != 0) {
+        if (g_activeTimeElapsedQueryId != 0) {
             RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__,
-                             "A query is already active on this target.");
+                             "A query is already active on GL_TIME_ELAPSED.");
             return;
         }
         if (queryObject->active) {
@@ -401,72 +239,25 @@ namespace MobileGL::MG_Impl::GLImpl {
         ResetQueryObjectLocked(queryObject); // discard any previous result
         queryObject->target = target;
         queryObject->active = true;
-        if (isTransformFeedbackQuery) {
-            // Prefer real GPU transform-feedback queries (exact with geometry shaders);
-            // the CPU accounting delta stays as the fallback when the backend lacks them.
-            const auto beginXfbPrimitivesQuery = MG_Backend::gBackendFunctionsTable.GL.BeginXfbPrimitivesQuery;
-            queryObject->backendHandle =
-                beginXfbPrimitivesQuery ? beginXfbPrimitivesQuery(target == GL_PRIMITIVES_GENERATED) : nullptr;
-            queryObject->counterSnapshot = MG_State::pGLContext->GetTransformFeedbackPrimitiveCounter();
-        } else if (isOcclusionQuery) {
-            queryObject->backendHandle = MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery();
-        } else {
-            const auto beginTimeElapsedQuery = MG_Backend::gBackendFunctionsTable.GL.BeginTimeElapsedQuery;
-            queryObject->backendHandle =
-                (!TimerQueryDisabled() && beginTimeElapsedQuery) ? beginTimeElapsedQuery() : nullptr;
-        }
-        activeQueryId = id;
+        const auto beginTimeElapsedQuery = MG_Backend::gBackendFunctionsTable.GL.BeginTimeElapsedQuery;
+        queryObject->backendHandle =
+            (!TimerQueryDisabled() && beginTimeElapsedQuery) ? beginTimeElapsedQuery() : nullptr;
+        g_activeTimeElapsedQueryId = id;
     }
 
     void EndQuery(GLenum target) {
-        const Bool isTransformFeedbackQuery =
-            target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN || target == GL_PRIMITIVES_GENERATED;
-        const Bool isOcclusionQuery =
-            (target == GL_SAMPLES_PASSED || target == GL_ANY_SAMPLES_PASSED ||
-             target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) &&
-            MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery != nullptr;
-        if (target != GL_TIME_ELAPSED && !isTransformFeedbackQuery && !isOcclusionQuery) {
+        if (target != GL_TIME_ELAPSED) {
             RecordQueryError(ErrorCode::InvalidEnum, __FUNCTION__, "Query target is not supported.");
             return;
         }
         const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
-        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.");
+        if (g_activeTimeElapsedQueryId == 0) {
+            RecordQueryError(ErrorCode::InvalidOperation, __FUNCTION__, "No query is active on GL_TIME_ELAPSED.");
             return;
         }
-        auto* queryObject = FindQueryObjectLocked(activeQueryId);
+        auto* queryObject = FindQueryObjectLocked(g_activeTimeElapsedQueryId);
         if (!queryObject) {
-            activeQueryId = 0; // should not happen; keep state consistent
-            return;
-        }
-        if (isTransformFeedbackQuery) {
-            if (queryObject->backendHandle) {
-                if (const auto endXfbPrimitivesQuery = MG_Backend::gBackendFunctionsTable.GL.EndXfbPrimitivesQuery) {
-                    endXfbPrimitivesQuery(queryObject->backendHandle);
-                }
-                // Result comes from the GPU query at read time.
-            } else {
-                queryObject->cachedResult =
-                    MG_State::pGLContext->GetTransformFeedbackPrimitiveCounter() - queryObject->counterSnapshot;
-                queryObject->resultCached = true;
-            }
-            queryObject->active = false;
-            queryObject->ended = true;
-            activeQueryId = 0;
-            return;
-        }
-        if (isOcclusionQuery) {
-            if (const auto endOcclusionQuery = MG_Backend::gBackendFunctionsTable.GL.EndOcclusionQuery;
-                endOcclusionQuery && queryObject->backendHandle) {
-                endOcclusionQuery(queryObject->backendHandle);
-            }
-            queryObject->active = false;
-            queryObject->ended = true;
-            activeQueryId = 0;
+            g_activeTimeElapsedQueryId = 0; // should not happen; keep state consistent
             return;
         }
         EndTimeElapsedQueryLocked(queryObject);
@@ -512,25 +303,9 @@ namespace MobileGL::MG_Impl::GLImpl {
         switch (pname) {
         case GL_CURRENT_QUERY: {
             const std::lock_guard<std::mutex> lock(g_queryObjectsMutex);
-            switch (target) {
-            case GL_TIME_ELAPSED:
-                *params = static_cast<GLint>(g_activeTimeElapsedQueryId);
-                break;
-            case GL_SAMPLES_PASSED:
-            case GL_ANY_SAMPLES_PASSED:
-            case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
-                *params = static_cast<GLint>(g_activeSamplesPassedQueryId);
-                break;
-            case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
-                *params = static_cast<GLint>(g_activePrimitivesWrittenQueryId);
-                break;
-            case GL_PRIMITIVES_GENERATED:
-                *params = static_cast<GLint>(g_activePrimitivesGeneratedQueryId);
-                break;
-            default:
-                *params = 0;
-                break;
-            }
+            // Only GL_TIME_ELAPSED queries can be active; GL_TIMESTAMP queries
+            // never are, and other targets remain unimplemented.
+            *params = target == GL_TIME_ELAPSED ? static_cast<GLint>(g_activeTimeElapsedQueryId) : 0;
             return;
         }
         case GL_QUERY_COUNTER_BITS: {
@@ -538,13 +313,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             // time: IsTimerQuerySupported is the dynamic truth (extension /
             // entry points / timestamp valid bits at call time, not at table
             // init), and the MOBILEGL_DISABLE_TIMERQUERY kill switch always
-            // wins.
-            if (target == GL_SAMPLES_PASSED || target == GL_ANY_SAMPLES_PASSED ||
-                target == GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
-                const Bool occlusionSupported = MG_Backend::gBackendFunctionsTable.GL.BeginOcclusionQuery != nullptr;
-                *params = occlusionSupported ? (target == GL_SAMPLES_PASSED ? 32 : 1) : 0;
-                return;
-            }
+            // wins. Non-timer targets remain unimplemented and report 0.
             const Bool timerTarget = target == GL_TIME_ELAPSED || target == GL_TIMESTAMP;
             const auto isTimerQuerySupported = MG_Backend::gBackendFunctionsTable.GL.IsTimerQuerySupported;
             const Bool supported =
@@ -558,26 +327,9 @@ namespace MobileGL::MG_Impl::GLImpl {
         }
     }
 
-    void GetQueryBufferObjectiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
-        GetQueryBufferObject<GLint>(id, buffer, pname, offset, __FUNCTION__);
-    }
-
-    void GetQueryBufferObjectuiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
-        GetQueryBufferObject<GLuint>(id, buffer, pname, offset, __FUNCTION__);
-    }
-
-    void GetQueryBufferObjecti64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
-        GetQueryBufferObject<GLint64>(id, buffer, pname, offset, __FUNCTION__);
-    }
-
-    void GetQueryBufferObjectui64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
-        GetQueryBufferObject<GLuint64>(id, buffer, pname, offset, __FUNCTION__);
-    }
-
     void GetQueryObjectiv(GLuint id, GLenum pname, GLint* params) {
         Uint64 value = 0;
-        Bool valueProduced = false;
-        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value, &valueProduced) || !valueProduced || !params) {
+        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value) || !params) {
             return;
         }
         constexpr Uint64 kMaxInt = static_cast<Uint64>(INT_MAX);
@@ -586,8 +338,7 @@ namespace MobileGL::MG_Impl::GLImpl {
 
     void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) {
         Uint64 value = 0;
-        Bool valueProduced = false;
-        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value, &valueProduced) || !valueProduced || !params) {
+        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value) || !params) {
             return;
         }
         *params = static_cast<GLuint>(value & 0xFFFFFFFFull);
@@ -595,8 +346,7 @@ namespace MobileGL::MG_Impl::GLImpl {
 
     void GetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) {
         Uint64 value = 0;
-        Bool valueProduced = false;
-        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value, &valueProduced) || !valueProduced || !params) {
+        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value) || !params) {
             return;
         }
         *params = static_cast<GLint64>(value);
@@ -604,48 +354,9 @@ namespace MobileGL::MG_Impl::GLImpl {
 
     void GetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) {
         Uint64 value = 0;
-        Bool valueProduced = false;
-        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value, &valueProduced) || !valueProduced || !params) {
+        if (!GetQueryObjectValue(id, pname, __FUNCTION__, value) || !params) {
             return;
         }
         *params = static_cast<GLuint64>(value);
     }
-
-    namespace {
-        // 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. 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 =
-                target == GL_PRIMITIVES_GENERATED || target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN;
-            GLint maxVertexStreams = 1;
-            if (perStreamTarget) {
-                GetIntegerv(GL_MAX_VERTEX_STREAMS, &maxVertexStreams);
-            }
-            if (index < static_cast<GLuint>(std::max(maxVertexStreams, 1))) {
-                return true;
-            }
-            RecordQueryError(ErrorCode::InvalidValue, function,
-                             perStreamTarget ? "index is not less than GL_MAX_VERTEX_STREAMS."
-                                             : "index must be zero for this query target.");
-            return false;
-        }
-    } // namespace
-
-    void BeginQueryIndexed(GLenum target, GLuint index, GLuint id) {
-        if (!ValidateQueryStreamIndex(__FUNCTION__, target, index)) return;
-        BeginQuery(target, id);
-    }
-
-    void EndQueryIndexed(GLenum target, GLuint index) {
-        if (!ValidateQueryStreamIndex(__FUNCTION__, target, index)) return;
-        EndQuery(target);
-    }
-
-    void GetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint* params) {
-        if (!ValidateQueryStreamIndex(__FUNCTION__, target, index)) return;
-        GetQueryiv(target, pname, params);
-    }
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/Query/GL_Query.h

@@ -11,22 +11,14 @@
 
 namespace MobileGL::MG_Impl::GLImpl {
     void GenQueries(GLsizei n, GLuint* ids);
-    void CreateQueries(GLenum target, GLsizei n, GLuint* ids);
     void DeleteQueries(GLsizei n, const GLuint* ids);
     GLboolean IsQuery(GLuint id);
     void BeginQuery(GLenum target, GLuint id);
     void EndQuery(GLenum target);
     void GetQueryiv(GLenum target, GLenum pname, GLint* params);
-    void BeginQueryIndexed(GLenum target, GLuint index, GLuint id);
-    void EndQueryIndexed(GLenum target, GLuint index);
-    void GetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint* params);
     void GetQueryObjectiv(GLuint id, GLenum pname, GLint* params);
     void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params);
     void GetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params);
     void GetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params);
-    void GetQueryBufferObjectiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
-    void GetQueryBufferObjectuiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
-    void GetQueryBufferObjecti64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
-    void GetQueryBufferObjectui64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
     void QueryCounter(GLuint id, GLenum target);
 } // namespace MobileGL::MG_Impl::GLImpl

MobileGL/MG_Impl/GLImpl/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>
@@ -381,18 +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);
-        *data = values[0] != 0 ? GL_TRUE : GL_FALSE;
+        *data = IsEnabledi_State(target, index);
     }
 
     GLboolean IsEnabled_State(GLenum cap) {

MobileGL/MG_Impl/GLImpl/Sampler/GL_Sampler.cpp

@@ -8,8 +8,6 @@
 
 #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>
@@ -30,11 +28,6 @@ namespace MobileGL::MG_Impl::GLImpl {
             case GL_TEXTURE_MAX_LOD:
             case GL_TEXTURE_LOD_BIAS:
                 return true;
-            // Four components, and GL puts no range on them - a border colour outside [0,1] is
-            // clamped when a fixed-point format is sampled, not rejected here. The scalar readers
-            // below would look at one component and invent an error.
-            case GL_TEXTURE_BORDER_COLOR:
-                return true;
             case GL_TEXTURE_MAX_ANISOTROPY_EXT:
                 if (ReadSamplerScalar(param, isFloat, isUnsignedInteger) >= 1.0f) return true;
                 MG_State::pGLContext->RecordError(
@@ -106,20 +99,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_TEXTURE_COMPARE_FUNC:
             samplerObj->SetSamplerCompareFunc(MG_Util::ConvertGLEnumToSamplerCompareFunc(*(const GLint*)param));
             break;
-        case GL_TEXTURE_BORDER_COLOR:
-            // The only four-component sampler parameter: the caller's form decides which
-            // representation is authoritative, and SamplerObject keeps the other two in step.
-            if (isFloat) {
-                const auto* values = (const GLfloat*)param;
-                samplerObj->SetBorderColor(FloatVec4(values[0], values[1], values[2], values[3]));
-            } else if (isUnsignedInteger) {
-                const auto* values = (const GLuint*)param;
-                samplerObj->SetBorderColorUI(UintVec4(values[0], values[1], values[2], values[3]));
-            } else {
-                const auto* values = (const GLint*)param;
-                samplerObj->SetBorderColorI(IntVec4(values[0], values[1], values[2], values[3]));
-            }
-            break;
         default:
             MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
                                               MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "SetSamplerParam_State",
@@ -183,31 +162,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         case GL_TEXTURE_COMPARE_FUNC:
             *(GLuint*)params = MG_Util::ConvertSamplerCompareFuncToGLEnum(samplerObj->GetSamplerCompareFunc());
             break;
-        case GL_TEXTURE_BORDER_COLOR: {
-            if (isFloat) {
-                const auto& color = samplerObj->GetBorderColor();
-                auto* out = (GLfloat*)params;
-                out[0] = color.x();
-                out[1] = color.y();
-                out[2] = color.z();
-                out[3] = color.w();
-            } else if (isUnsignedInteger) {
-                const auto& color = samplerObj->GetBorderColorUI();
-                auto* out = (GLuint*)params;
-                out[0] = color.x();
-                out[1] = color.y();
-                out[2] = color.z();
-                out[3] = color.w();
-            } else {
-                const auto& color = samplerObj->GetBorderColorI();
-                auto* out = (GLint*)params;
-                out[0] = color.x();
-                out[1] = color.y();
-                out[2] = color.z();
-                out[3] = color.w();
-            }
-            break;
-        }
         default:
             MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
                                               MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetSamplerParam_State",
@@ -231,11 +185,6 @@ namespace MobileGL::MG_Impl::GLImpl {
         static thread_local Vector<GLuint> names;
         MG_State::pGLContext->GenSamplerNames(count, names);
         Memcpy(samplers, names.data(), count * sizeof(GLuint));
-        // Unlike textures/buffers, glGenSamplers CREATES the sampler objects: each name
-        // is immediately a sampler (glIsSampler == GL_TRUE before any bind).
-        for (GLsizei i = 0; i < count; ++i) {
-            MG_State::pGLContext->CreateSamplerObject(names[i]);
-        }
     }
 
     void DeleteSamplers_State(GLsizei count, const GLuint* samplers) {
@@ -270,18 +219,9 @@ 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.
-    static GLint GetSamplerBindableTextureUnitCount() {
-        return GetCombinedTextureImageUnitCount();
-    }
-
     void BindSampler_State(GLuint unit, GLuint sampler) {
         MGLOG_D("BindSampler_State: unit = %u, sampler = %u", unit, sampler);
-        if (static_cast<Uint64>(unit) >= static_cast<Uint64>(GetSamplerBindableTextureUnitCount())) {
+        if (unit >= MG_State::GLState::TextureState::MAX_TEXTURE_IMAGE_UNITS) {
             MG_State::pGLContext->RecordError(
                 ErrorCode::InvalidValue,
                 MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BindSampler", "texture unit out of range"));
@@ -320,37 +260,9 @@ namespace MobileGL::MG_Impl::GLImpl {
                 MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BindSamplers", "count must be non-negative"));
             return;
         }
-        // ARB_multi_bind: the whole [first, first + count) range is checked up front and a
-        // range that runs past the last texture unit is INVALID_OPERATION - not the
-        // INVALID_VALUE the single-bind BindSampler_State reports per element, and nothing is
-        // bound when it fails. Both gates read the same limit (see
-        // GetSamplerBindableTextureUnitCount), so an out-of-range multi-bind can no longer slip
-        // past this check and be caught one element at a time with the wrong error class.
-        const GLint maxTextureUnits = GetSamplerBindableTextureUnitCount();
-        if (static_cast<Uint64>(first) + static_cast<Uint64>(count) > static_cast<Uint64>(maxTextureUnits)) {
-            MG_State::pGLContext->RecordError(
-                ErrorCode::InvalidOperation,
-                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "BindSamplers",
-                                             "first + count exceeds the number of texture units."));
-            return;
-        }
 
-        // 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);
         }
     }
 

MobileGL/MG_Impl/GLImpl/Sampler/Validators.cpp

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

MobileGL/MG_Impl/GLImpl/Sync/GL_Sync.cpp

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

MobileGL/MG_Impl/GLImpl/Sync/GL_Sync.h

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