[Perf] (MG_Backend/DirectVulkanTMP): Optimize buffer uploads with staging ring + batched copies.

.clang-tidy

@@ -14,6 +14,7 @@ bugprone-forwarding-reference-overload,
 bugprone-inaccurate-erase,
 bugprone-incorrect-roundings,
 bugprone-integer-division,
+bugprone-lambda-function-name,
 bugprone-macro-parentheses,
 bugprone-macro-repeated-side-effects,
 bugprone-misplaced-operator-in-strlen-in-alloc,
@@ -62,6 +63,7 @@ cert-str34-c,
 cppcoreguidelines-interfaces-global-init,
 cppcoreguidelines-narrowing-conversions,
 cppcoreguidelines-pro-type-member-init,
+cppcoreguidelines-pro-type-static-cast-downcast,
 cppcoreguidelines-slicing,
 google-default-arguments,
 google-runtime-operator,

.gitattributes

@@ -1,4 +0,0 @@
-tools/trace_replay/fixtures/*.tgz filter=lfs diff=lfs merge=lfs -text
-tools/trace_replay/fixtures/*.png filter=lfs diff=lfs merge=lfs -text
-tools/trace_replay/fixtures/openra.tgz -filter -diff -merge -text
-tools/trace_replay/fixtures/openra.0000031249.png -filter -diff -merge -text

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

@@ -1,199 +0,0 @@
-#!/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
-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:-}"
-download_attempts="${MOBILEGL_TRACE_FIXTURE_DOWNLOAD_ATTEMPTS:-5}"
-retry_delay="${MOBILEGL_TRACE_FIXTURE_RETRY_DELAY:-2}"
-
-if ! command -v "${python_bin}" >/dev/null 2>&1 && command -v python >/dev/null 2>&1; then
-  python_bin=python
-fi
-
-if ! [[ "${download_attempts}" =~ ^[1-9][0-9]*$ ]]; then
-  echo "MOBILEGL_TRACE_FIXTURE_DOWNLOAD_ATTEMPTS must be a positive integer: ${download_attempts}" >&2
-  exit 2
-fi
-if ! [[ "${retry_delay}" =~ ^[0-9]+$ ]]; then
-  echo "MOBILEGL_TRACE_FIXTURE_RETRY_DELAY must be a non-negative integer: ${retry_delay}" >&2
-  exit 2
-fi
-
-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')
-
-include="$(IFS=,; echo "${files[*]}")"
-if [ "${case_name}" = "OpenRA" ]; then
-  echo "Fixture files for ${case_name} are stored in Git: ${include}"
-  for file in "${files[@]}"; do
-    test -s "${file}"
-    if head -n 1 "${file}" | grep -q "version https://git-lfs.github.com/spec/v1"; then
-      echo "fixture should not be stored as an LFS pointer: ${file}" >&2
-      exit 1
-    fi
-  done
-  exit 0
-fi
-
-fetch_file_from_mirror() {
-  local file="$1"
-  local url="$2"
-  local metadata
-  local expected_oid
-  local expected_size
-  local tmp_file="${file}.tmp"
-  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}"
-
-  if [ -f "${tmp_file}" ]; then
-    partial_size="$(wc -c < "${tmp_file}" | tr -d '[:space:]')"
-    if [ "${partial_size}" -gt "${expected_size}" ]; then
-      echo "Discarding oversized partial fixture ${tmp_file}: ${partial_size} > ${expected_size}" >&2
-      rm -f "${tmp_file}"
-    elif [ "${partial_size}" = "${expected_size}" ]; then
-      if verify_fixture_file "${tmp_file}" "${file}" "${expected_oid}" "${expected_size}"; then
-        mv "${tmp_file}" "${file}"
-        return 0
-      fi
-      rm -f "${tmp_file}"
-    fi
-  fi
-
-  for ((attempt = 1; attempt <= download_attempts; attempt++)); do
-    partial_size=0
-    if [ -f "${tmp_file}" ]; then
-      partial_size="$(wc -c < "${tmp_file}" | tr -d '[:space:]')"
-    fi
-
-    if [ "${partial_size}" -gt 0 ]; then
-      echo "Resuming mirror download for ${file} at byte ${partial_size} (attempt ${attempt}/${download_attempts})"
-    else
-      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 verify_fixture_file "${tmp_file}" "${file}" "${expected_oid}" "${expected_size}"; then
-        mv "${tmp_file}" "${file}"
-        return 0
-      fi
-      echo "Mirror download failed integrity verification; retrying from the beginning: ${file}" >&2
-      rm -f "${tmp_file}"
-    else
-      curl_status=$?
-      partial_size=0
-      if [ -f "${tmp_file}" ]; then
-        partial_size="$(wc -c < "${tmp_file}" | tr -d '[:space:]')"
-      fi
-
-      if [ "${partial_size}" = "${expected_size}" ]; then
-        if verify_fixture_file "${tmp_file}" "${file}" "${expected_oid}" "${expected_size}"; then
-          mv "${tmp_file}" "${file}"
-          return 0
-        fi
-        rm -f "${tmp_file}"
-        partial_size=0
-      elif [ "${partial_size}" -gt "${expected_size}" ]; then
-        echo "Discarding oversized partial fixture ${tmp_file}: ${partial_size} > ${expected_size}" >&2
-        rm -f "${tmp_file}"
-        partial_size=0
-      elif [ "${curl_status}" -eq 33 ]; then
-        echo "Mirror refused the resume request; retrying from the beginning: ${file}" >&2
-        rm -f "${tmp_file}"
-        partial_size=0
-      fi
-
-      echo "Mirror download attempt ${attempt}/${download_attempts} failed with curl exit ${curl_status}; retained ${partial_size} bytes for resume: ${file}" >&2
-    fi
-
-    if [ "${attempt}" -lt "${download_attempts}" ]; then
-      sleep "${retry_delay}"
-    fi
-  done
-
-  rm -f "${tmp_file}"
-  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}")
-    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}"
-  git lfs install --local
-  git lfs pull --include="${fallback_include}" --exclude=""
-fi
-
-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

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

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

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

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

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

@@ -1,100 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-if [[ $# -ne 3 ]]; then
-  echo "Usage: $0 <aapt2> <plugin-apk> <trace-apk>" >&2
-  exit 64
-fi
-
-aapt2=$1
-plugin_apk=$2
-trace_apk=$3
-
-require() {
-  local needle=$1
-  local content=$2
-  local description=$3
-  if ! grep -Fq -- "$needle" <<<"$content"; then
-    echo "::error::Missing ${description}: ${needle}" >&2
-    exit 1
-  fi
-}
-
-for apk in "$plugin_apk" "$trace_apk"; do
-  [[ -f "$apk" ]] || { echo "::error::APK not found: $apk" >&2; exit 1; }
-done
-
-plugin_manifest=$("$aapt2" dump xmltree --file AndroidManifest.xml "$plugin_apk")
-plugin_resources=$("$aapt2" dump resources "$plugin_apk")
-plugin_resource_text=$(tr -d '"' <<<"$plugin_resources")
-trace_manifest=$("$aapt2" dump xmltree --file AndroidManifest.xml "$trace_apk")
-plugin_contents=$(unzip -Z1 "$plugin_apk")
-
-require 'top.mobilegl.plugin' "$plugin_manifest" 'plugin package name'
-require 'MobileGL' "$plugin_manifest" 'plugin label'
-require 'fclPlugin' "$plugin_manifest" 'legacy plugin marker'
-require 'fclPlugin_V2' "$plugin_manifest" 'V2 plugin marker'
-require 'LIBGL_ES=3:POJAV_RENDERER=opengles3:MOBILEGL_BACKEND_TYPE=DirectGLES' "$plugin_manifest" 'V1 DirectGLES fallback'
-require 'string/config' "$plugin_resources" 'V2 renderer configuration resource'
-require '{displayName:MobileGL,rendererId:opengles3' "$plugin_resource_text" 'V2 MobileGL entry and renderer ID'
-require 'rendererGLPath:**|libMobileGL.so' "$plugin_resource_text" 'V2 GL library path'
-require 'rendererEGLPath:**|libMobileGL.so' "$plugin_resource_text" 'V2 EGL library path'
-require 'key:LIBGL_ES,value:3' "$plugin_resource_text" 'V2 fixed LIBGL_ES variable'
-require 'key:MOBILEGL_BACKEND_TYPE' "$plugin_resource_text" 'V2 backend variable'
-require 'defaultValue:DirectGLES' "$plugin_resource_text" 'V2 DirectGLES default'
-require 'DirectVulkan' "$plugin_resource_text" 'V2 DirectVulkan option'
-require 'key:MOBILEGL_DISABLE_TIMERQUERY' "$plugin_resource_text" 'V2 timer-query toggle'
-require 'key:MOBILEGL_MAGMA_DISABLE_SUBGROUP' "$plugin_resource_text" 'V2 Vulkan subgroup toggle'
-require 'key:MOBILEGL_MAGMA_R11G11B10F_FALLBACK' "$plugin_resource_text" 'V2 Magma format fallback toggle'
-require 'key:MOBILEGL_MAGMA_FRAMESINFLIGHT' "$plugin_resource_text" 'V2 Magma frames-in-flight setting'
-require 'key:MOBILEGL_ESPRYT_AVOID_SAMPLER_MIPMAP_MIN_FILTER' "$plugin_resource_text" 'V2 sampler workaround toggle'
-require 'key:MOBILEGL_COHERENT_AS_FLUSH' "$plugin_resource_text" 'V2 coherent-as-flush toggle'
-require 'key:MOBILEGL_ESPRYT_USE_ANGLE' "$plugin_resource_text" 'V2 ANGLE toggle'
-
-if [[ $(grep -Fc 'fclPlugin_V2' <<<"$plugin_manifest") -ne 1 ]]; then
-  echo '::error::Plugin manifest must expose exactly one V2 descriptor' >&2
-  exit 1
-fi
-
-if ! grep -Eq '^lib/[^/]+/libMobileGL\.so$' <<<"$plugin_contents"; then
-  echo '::error::Plugin APK does not contain libMobileGL.so' >&2
-  exit 1
-fi
-
-# The render server is not trace-only: both flavors carry the control screen, the offscreen
-# service, the on-screen display activity, and (split native builds) the supervisor executable.
-# The plugin APK ships to users, so its build keeps the three components private (manifest
-# placeholder serverComponentsExported=false); only the debuggable trace APK exports them for adb.
-for component in ServerControlActivity MobileGLServerService MobileGLDisplayActivity; do
-  require "$component" "$plugin_manifest" "plugin render server component ($component)"
-  require "$component" "$trace_manifest" "trace render server component ($component)"
-done
-if [[ "${MOBILEGL_CI_DISAGGREGATED:-OFF}" == "ON" ]]; then
-  trace_contents=$(unzip -Z1 "$trace_apk")
-  for entry in "plugin:${plugin_contents}" "trace:${trace_contents}"; do
-    if ! grep -Eq '^lib/[^/]+/libMobileGLServer\.so$' <<<"${entry#*:}"; then
-      echo "::error::${entry%%:*} APK does not contain libMobileGLServer.so (both flavors ship the render server)" >&2
-      exit 1
-    fi
-  done
-fi
-
-require 'top.mobilegl.plugin.trace' "$trace_manifest" 'trace package name'
-require 'top.mobilegl.plugin.TRACE_REPLAY' "$trace_manifest" 'trace replay action'
-if grep -Fq 'fclPlugin' <<<"$trace_manifest"; then
-  echo '::error::Trace APK must not advertise renderer-plugin metadata' >&2
-  exit 1
-fi
-# The trace APK IS a launchable app now: PostActivity (the POST self-test screen) is its
-# entry icon and the bottom navigation bar switches to the render server screen. What is
-# left of the old "no launcher" contract is the count - exactly ONE MAIN activity, so a
-# screen that accidentally grows a launcher entry (ServerControlActivity was one for a day)
-# reds here instead of shipping two icons.
-main_count=$(grep -Fc 'android.intent.action.MAIN' <<<"$trace_manifest")
-if [[ "$main_count" -ne 1 ]]; then
-  echo "::error::Trace APK must expose exactly one launcher activity (PostActivity); found ${main_count} android.intent.action.MAIN" >&2
-  exit 1
-fi
-require 'PostActivity' "$trace_manifest" 'trace launcher activity (PostActivity)'
-
-echo 'Validated unified MobileGL plugin APK and isolated trace APK.'

.github/workflows/apk.yml

@@ -1,790 +0,0 @@
-name: MobileGL APK
-
-on:
-  push:
-    branches:
-      - dev
-      - Feat/Backend-Direct-GLES
-      - Feat/Backend-Direct-Vulkan
-      # TEMPORARY, remove before merging the MGPipe work into dev: the disaggregation
-      # branch runs the full lane on every push so a phase's landing is not gated on
-      # someone remembering to dispatch the workflow by hand.
-      - feat/disaggregated
-      - codex/fix-github-ci
-    # A docs-only push builds nothing this workflow tests (231 emulator legs per run). The Test
-    # workflow keeps running for docs: it hosts the doc citation lint.
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  workflow_dispatch:
-
-# ONE LIVE RUN PER BRANCH, as in test.yml: a superseded push is cancelled rather than left queued
-# behind its successor; a manual dispatch gets a group of its own; dev queues rather than cancels.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name == 'workflow_dispatch' && github.run_id || github.ref }}
-  cancel-in-progress: ${{ github.event_name == 'push' && github.ref != 'refs/heads/dev' }}
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    permissions:
-      actions: write
-      contents: read
-    env:
-      CCACHE_BASEDIR: ${{ github.workspace }}
-      CCACHE_COMPRESS: "true"
-      CCACHE_DIR: ${{ github.workspace }}/.ccache
-      CCACHE_MAXSIZE: 4G
-      CCACHE_NOHASHDIR: "true"
-      MOBILEGL_CMAKE_COMPILER_LAUNCHER: ccache
-      MOBILEGL_CI_DISAGGREGATED: ${{ (github.ref_name == 'feat/disaggregated' || github.ref_name == 'codex/fix-github-ci') && 'ON' || 'OFF' }}
-
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v6
-        with:
-          submodules: recursive
-
-      - name: Set artifact metadata
-        run: |
-          echo "date_today=$(date +'%Y-%m-%d')" >> "$GITHUB_ENV"
-
-      - name: Set up JDK
-        uses: actions/setup-java@v5
-        with:
-          distribution: zulu
-          java-version: '17'
-
-      - name: Android replay lifecycle regression
-        run: python3 tools/trace_replay/test_android_lifecycle.py
-
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6
-        with:
-          gradle-version: 8.10.2
-
-      - name: Restore ccache
-        uses: actions/cache/restore@v5
-        with:
-          path: .ccache
-          key: ${{ runner.os }}-apk-${{ github.job }}-ccache-v1
-          restore-keys: |
-            ${{ runner.os }}-apk-${{ github.job }}-ccache-
-
-      - name: Install ccache
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y ccache
-          ccache --version
-
-      - name: Setup Android SDK
-        uses: android-actions/setup-android@v4
-        with:
-          accept-android-sdk-licenses: false
-          packages: platform-tools
-          cmdline-tools-version: 13114758
-
-      - name: Accept Android SDK licenses
-        run: yes | sdkmanager --licenses >/dev/null
-
-      - name: Install Android NDK
-        run: |
-          sdkmanager "ndk;27.3.13750724"
-          echo "ndk.dir=$ANDROID_HOME/ndk/27.3.13750724" >> android-plugin/local.properties
-
-      - name: Update glslang external sources
-        working-directory: 3rdparty/glslang
-        run: python update_glslang_sources.py
-
-      - name: Build plugin APK
-        run: >-
-          gradle --no-daemon -p android-plugin :app:assemblePluginRelease
-          -Pmobilegl.apkSuffix="${GITHUB_SHA}" -Pmobilegl.logLevel=MOBILEGL_LOG_LEVEL_INFO
-          -Pmobilegl.buildDisaggregated="${MOBILEGL_CI_DISAGGREGATED}"
-          -Pmobilegl.buildDisaggregatedInproc="${MOBILEGL_CI_DISAGGREGATED}"
-          -Pmobilegl.pipePush="${MOBILEGL_CI_DISAGGREGATED}"
-          --parallel --max-workers "$(nproc)"
-        env:
-          SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
-          SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
-          SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
-
-      - name: Download ANGLE x86_64 libraries
-        run: |
-          angle_dir="android-plugin/app/src/trace/jniLibs/x86_64"
-          rm -rf "${angle_dir}"
-          mkdir -p "${angle_dir}"
-
-          package_angle_variant() {
-            variant="$1"
-            commit="$2"
-            egl_sha="$3"
-            gles_sha="$4"
-            source_dir="${RUNNER_TEMP}/mobilegl-angle-${variant}"
-            base="https://raw.githubusercontent.com/FCL-Team/FoldCraftLauncher/${commit}/FCLauncher/src/main/jniLibs/x86_64"
-            mkdir -p "${source_dir}"
-            curl -L --fail --retry 3 -o "${source_dir}/libEGL_angle.so" "${base}/libEGL_angle.so"
-            curl -L --fail --retry 3 -o "${source_dir}/libGLESv2_angle.so" "${base}/libGLESv2_angle.so"
-            echo "${egl_sha}  ${source_dir}/libEGL_angle.so" | sha256sum -c -
-            echo "${gles_sha}  ${source_dir}/libGLESv2_angle.so" | sha256sum -c -
-            for library in libEGL_angle libGLESv2_angle; do
-              filename="${library}_${variant}.so"
-              cp "${source_dir}/${library}.so" "${angle_dir}/${filename}"
-            done
-          }
-
-          package_angle_variant \
-            ec889e6ea831 \
-            f2a3d510dffd8f6540a52e1a7d0c5787d151075b \
-            c41828768d089899fa058ec0bee711a91be88347f29bdb935223da6be1149c40 \
-            e4f820d99f94365c66df868c7740fef142fe5c0cd7c941790a9e30638857ca4d
-          package_angle_variant \
-            90a62123d794 \
-            bdcc96ac11c79001018ae4375eb73cb54a9f682f \
-            d0f4298ccc770cc801fc52e21733521646161e8a4adb3bd0052d9a1b57ee0ca8 \
-            66fdc867e552192d553d59095ea2e3cef4829de65c356f1fd826027b1905972e
-
-      - name: Build retrace APK
-        run: >-
-          gradle --no-daemon -p android-plugin :app:assembleTraceRelease
-          -Pmobilegl.apkSuffix="${GITHUB_SHA}" -Pmobilegl.abis=all
-          -Pmobilegl.debuggableRelease=true -Pmobilegl.logLevel=MOBILEGL_LOG_LEVEL_INFO
-          -Pmobilegl.buildDisaggregated="${MOBILEGL_CI_DISAGGREGATED}"
-          -Pmobilegl.buildDisaggregatedInproc="${MOBILEGL_CI_DISAGGREGATED}"
-          -Pmobilegl.pipePush="${MOBILEGL_CI_DISAGGREGATED}"
-          --parallel --max-workers "$(nproc)"
-        env:
-          SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
-          SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
-          SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
-
-      - name: Show ccache stats
-        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)"
-          plugin_apk="android-plugin/app/build/outputs/apk/plugin/release/MobileGL-plugin-release-${GITHUB_SHA}.apk"
-          trace_apk="android-plugin/app/build/outputs/apk/trace/release/MobileGL-plugin-trace-release-${GITHUB_SHA}.apk"
-          test -f "${plugin_apk}"
-          test -f "${trace_apk}"
-          bash .github/scripts/validate-plugin-apks.sh "$AAPT2" "$plugin_apk" "$trace_apk"
-
-      - name: Verify signed APKs
-        run: |
-          APKSIGNER="$(find "$ANDROID_HOME/build-tools" -name apksigner -type f | sort -V | tail -n 1)"
-          mapfile -t APKS < <(printf '%s\n' \
-            "android-plugin/app/build/outputs/apk/plugin/release/MobileGL-plugin-release-${GITHUB_SHA}.apk" \
-            "android-plugin/app/build/outputs/apk/trace/release/MobileGL-plugin-trace-release-${GITHUB_SHA}.apk")
-          for APK in "${APKS[@]}"; do
-            if [[ ! -f "$APK" ]]; then
-              echo "::error::Expected release APK was not produced: $APK"
-              exit 1
-            fi
-          done
-
-          for APK in "${APKS[@]}"; do
-            if [[ "$APK" == *-unsigned.apk ]]; then
-              echo "::error::Unsigned release APK produced: $APK"
-              exit 1
-            fi
-            "$APKSIGNER" verify --verbose "$APK"
-          done
-
-      - name: Upload plugin APK
-        uses: actions/upload-artifact@v7
-        with:
-          name: MobileGL-plugin-${{ env.date_today }}-${{ github.sha }}
-          path: android-plugin/app/build/outputs/apk/plugin/release/MobileGL-plugin-release-${{ github.sha }}.apk
-          archive: false
-          if-no-files-found: error
-
-      - name: Upload retrace APK
-        uses: actions/upload-artifact@v7
-        with:
-          name: MobileGL-retrace-apk-${{ env.date_today }}-${{ github.sha }}
-          path: android-plugin/app/build/outputs/apk/trace/release/MobileGL-plugin-trace-release-${{ github.sha }}.apk
-          archive: false
-          if-no-files-found: error
-
-  trace-cases:
-    name: trace case matrix
-    runs-on: ubuntu-latest
-    needs: build
-    env:
-      MOBILEGL_CI_DISAGGREGATED: ${{ (github.ref_name == 'feat/disaggregated' || github.ref_name == 'codex/fix-github-ci') && 'ON' || 'OFF' }}
-    outputs:
-      android: ${{ steps.trace-cases.outputs.android }}
-      names: ${{ steps.trace-cases.outputs.names }}
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v6
-
-      - name: Load trace cases
-        id: trace-cases
-        run: |
-          python3 tools/trace_replay/trace_cases.py --self-test-transport-matrices
-          matrix_format=github-apk-matrix
-          if [ "${MOBILEGL_CI_DISAGGREGATED}" = "ON" ]; then
-            matrix_format=github-apk-transport-matrix
-          fi
-          echo "android=$(python3 tools/trace_replay/trace_cases.py --ci --format "${matrix_format}")" >> "$GITHUB_OUTPUT"
-          echo "names=$(python3 tools/trace_replay/trace_cases.py --ci --format names)" >> "$GITHUB_OUTPUT"
-
-  trace-fixtures:
-    name: trace fixture (${{ matrix.case }})
-    runs-on: ubuntu-latest
-    needs: trace-cases
-    strategy:
-      fail-fast: false
-      max-parallel: 4
-      matrix:
-        case: ${{ fromJSON(needs.trace-cases.outputs.names) }}
-    steps:
-      - 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')"
-          stage_dir="trace-fixtures/${safe_case}"
-          mkdir -p "${stage_dir}"
-          python3 tools/trace_replay/trace_cases.py --format fixture-files --case '${{ matrix.case }}' |
-            while IFS= read -r file; do
-              cp "${file}" "${stage_dir}/"
-            done
-
-      - name: Upload trace fixture
-        uses: actions/upload-artifact@v7
-        with:
-          name: MobileGL-trace-fixture-${{ matrix.case }}
-          path: trace-fixtures/**
-          if-no-files-found: error
-
-  android-avd:
-    name: android avd image
-    runs-on: ubuntu-latest
-    env:
-      AVD_NAME: mobilegl-ci
-      ANDROID_AVD_HOME: ${{ github.workspace }}/.android/avd
-      ANDROID_HOME: ${{ github.workspace }}/.android/sdk
-      ANDROID_SDK_ROOT: ${{ github.workspace }}/.android/sdk
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v6
-
-      - name: Setup Android SDK
-        uses: android-actions/setup-android@v4
-        with:
-          accept-android-sdk-licenses: false
-          packages: platform-tools
-          cmdline-tools-version: 13114758
-
-      - name: Accept Android SDK licenses
-        run: yes | sdkmanager --licenses >/dev/null
-
-      - name: Restore Android AVD cache
-        id: android-avd-cache
-        uses: actions/cache@v5
-        with:
-          path: |
-            ${{ env.ANDROID_AVD_HOME }}
-            ${{ env.ANDROID_SDK_ROOT }}/emulator
-            ${{ env.ANDROID_SDK_ROOT }}/platform-tools
-            ${{ env.ANDROID_SDK_ROOT }}/platforms/android-35
-            ${{ env.ANDROID_SDK_ROOT }}/system-images/android-35/google_apis/x86_64
-          key: ${{ runner.os }}-mobilegl-avd-api35-google_apis-x86_64-pixel_6-v2-${{ hashFiles('android-plugin/run-avd-ci.sh') }}
-
-      - name: Create AVD
-        if: steps.android-avd-cache.outputs.cache-hit != 'true'
-        run: |
-          sh android-plugin/run-avd-ci.sh create \
-            --api-level 35 \
-            --target google_apis \
-            --arch x86_64 \
-            --profile pixel_6 \
-            --avd-name "${AVD_NAME}"
-
-  retrace:
-    name: retrace (${{ matrix.backend.name }} / ${{ matrix.transport || 'monolith' }}, ${{ matrix.case.name }})
-    runs-on: ubuntu-latest
-    needs:
-      - build
-      - android-avd
-      - trace-cases
-      - trace-fixtures
-    if: ${{ always() && needs.build.result == 'success' && needs.android-avd.result == 'success' && needs.trace-cases.result == 'success' }}
-    timeout-minutes: 75
-    env:
-      MOBILEGL_CI_TRANSPORT: ${{ matrix.transport || 'monolith' }}
-      MOBILEGL_CI_LANE: ${{ matrix.lane || 'monolith-control' }}
-      AVD_NAME: mobilegl-ci
-      ANDROID_AVD_HOME: ${{ github.workspace }}/.android/avd
-      ANDROID_HOME: ${{ github.workspace }}/.android/sdk
-      ANDROID_SDK_ROOT: ${{ github.workspace }}/.android/sdk
-    strategy:
-      fail-fast: false
-      max-parallel: 4
-      matrix: ${{ fromJSON(needs.trace-cases.outputs.android) }}
-    steps:
-      - name: Set swap space
-        uses: pierotofy/set-swap-space@v1.0
-        with:
-          swap-size-gb: 8
-
-      - name: Checkout repo
-        uses: actions/checkout@v6
-
-      - name: Download trace fixture
-        uses: actions/download-artifact@v8
-        with:
-          name: MobileGL-trace-fixture-${{ matrix.case.name }}
-          path: trace-fixture-download
-
-      - name: Install trace fixture
-        run: |
-          mkdir -p tools/trace_replay/fixtures
-          find trace-fixture-download -type f -exec cp {} tools/trace_replay/fixtures/ \;
-
-      - name: Set artifact metadata
-        run: |
-          echo "date_today=$(date +'%Y-%m-%d')" >> "$GITHUB_ENV"
-          echo "EMULATOR_LOG=${RUNNER_TEMP}/mobilegl-emulator.log" >> "$GITHUB_ENV"
-          echo "EMULATOR_PID_FILE=${RUNNER_TEMP}/mobilegl-emulator.pid" >> "$GITHUB_ENV"
-
-      - name: Setup Android SDK
-        uses: android-actions/setup-android@v4
-        with:
-          accept-android-sdk-licenses: false
-          packages: platform-tools
-          cmdline-tools-version: 13114758
-
-      - name: Accept Android SDK licenses
-        run: yes | sdkmanager --licenses >/dev/null
-
-      - name: Restore Android AVD cache
-        id: android-avd-cache
-        uses: actions/cache/restore@v5
-        with:
-          path: |
-            ${{ env.ANDROID_AVD_HOME }}
-            ${{ env.ANDROID_SDK_ROOT }}/emulator
-            ${{ env.ANDROID_SDK_ROOT }}/platform-tools
-            ${{ env.ANDROID_SDK_ROOT }}/platforms/android-35
-            ${{ env.ANDROID_SDK_ROOT }}/system-images/android-35/google_apis/x86_64
-          key: ${{ runner.os }}-mobilegl-avd-api35-google_apis-x86_64-pixel_6-v2-${{ hashFiles('android-plugin/run-avd-ci.sh') }}
-
-      - name: Download retrace APK
-        uses: actions/download-artifact@v8
-        with:
-          name: MobileGL-plugin-trace-release-${{ github.sha }}.apk
-          path: android-retrace-apks
-
-      - name: Enable KVM
-        run: |
-          echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
-          sudo udevadm control --reload-rules
-          sudo udevadm trigger --name-match=kvm
-
-      - name: Create AVD
-        if: steps.android-avd-cache.outputs.cache-hit != 'true'
-        run: |
-          sh android-plugin/run-avd-ci.sh create \
-            --api-level 35 \
-            --target google_apis \
-            --arch x86_64 \
-            --profile pixel_6 \
-            --avd-name "${AVD_NAME}"
-
-      - name: Launch emulator
-        run: |
-          sh android-plugin/run-avd-ci.sh start \
-            --avd-name "${AVD_NAME}" \
-            --gpu "${{ matrix.backend.gpu }}" \
-            --emulator-log "${EMULATOR_LOG}" \
-            --pid-file "${EMULATOR_PID_FILE}" \
-            --boot-timeout 300
-
-      - name: Retrace and validate
-        env:
-          MOBILEGL_ESPRYT_USE_ANGLE: ${{ matrix.backend.name == 'DirectGLES' && '1' || '0' }}
-          MOBILEGL_TRACE_ANGLE_VARIANT: ${{ matrix.case.name == 'minecraft-1.21.4-fabric-iris-bliss-in-world' && '90a62123d794' || 'ec889e6ea831' }}
-          MOBILEGL_MAGMA_R11G11B10F_FALLBACK: ${{ matrix.backend.name == 'DirectVulkan' && '1' || '0' }}
-          MOBILEGL_MAGMA_FIX_ITERATIONRP_SUBGROUP_SCRATCH: ${{ matrix.backend.name == 'DirectVulkan' && matrix.case.name == 'minecraft-1.21.4-fabric-iris-iterationrp-in-world' && '1' || '0' }}
-          MOBILEGL_MAGMA_DERIVE_NUM_SUBGROUPS: ${{ matrix.backend.name == 'DirectVulkan' && matrix.case.name == 'minecraft-1.21.4-fabric-iris-iterationrp-in-world' && '1' || '0' }}
-          MOBILEGL_MAGMA_ITERATIONRP_FIX_BARRIER: ${{ matrix.backend.name == 'DirectVulkan' && matrix.case.name == 'minecraft-1.21.4-fabric-iris-iterationrp-in-world' && '1' || '0' }}
-        run: |
-          apk_file="android-retrace-apks/MobileGL-plugin-trace-release-${GITHUB_SHA}.apk"
-          test -f "${apk_file}"
-          extra_retrace_args=()
-          if [ "${MOBILEGL_CI_TRANSPORT}" = "inproc" ]; then
-            extra_retrace_args+=(
-              --env "MOBILEGL_TRANSPORT=inproc;MOBILEGL_IPC_ROLE_SPLIT_STATE=1;MOBILEGL_IPC_STRICT_ERRORS=1;MOBILEGL_IPC_RUN_AHEAD=1"
-              --require-inproc
-            )
-          elif [ "${MOBILEGL_CI_TRANSPORT}" = "spawn" ]; then
-            # THE SAME CLIENT KNOBS AS inproc, so the two acceptance lanes differ in exactly one
-            # thing: which PROCESS the server role runs in. They are scrubbed out of the CHILD's
-            # environment by the launcher and read by the client, which is where they belong.
-            #
-            # MOBILEGL_IPC_SERVER_PATH IS DELIBERATELY ABSENT. nativeLibraryDir carries an
-            # install-time hash, so nothing off the device can spell it; TraceReplayActivity
-            # resolves it from getApplicationInfo() when the env asks for spawn, and an explicit
-            # value would override that. --use-pbuffer is NOT optional here: until P12 a spawned
-            # server cannot be handed a window at all, because an ANativeWindow* is a pointer
-            # into the CLIENT's process and SetWindowHandle is refused on the way across with
-            # Fatal{UnmigratedSurface, "AndroidNativeWindow@P12"} (Rule H).
-            extra_retrace_args+=(
-              --env "MOBILEGL_TRANSPORT=spawn;MOBILEGL_IPC_ROLE_SPLIT_STATE=1;MOBILEGL_IPC_STRICT_ERRORS=1;MOBILEGL_IPC_RUN_AHEAD=1"
-              --use-pbuffer
-              --require-spawn
-            )
-          else
-            extra_retrace_args+=(--env "MOBILEGL_TRANSPORT=monolith")
-          fi
-          # Bliss needs the newer signed ANGLE variant plus sampler mipmap
-          # min-filter downgrading on ANGLE llvmpipe.
-          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
-
-          run_retrace() {
-            timeout "$(( ${{ matrix.case.timeout_seconds }} + 300 ))" sh android-plugin/trace-replay-ci.sh \
-              --apk-file "${apk_file}" \
-              --package top.mobilegl.plugin.trace \
-              --backend "${{ matrix.backend.name }}" \
-              --result-root android-retrace-result \
-              --fixture-root android-retrace-fixture \
-              --case "${{ matrix.case.name }}" \
-              --trace-archive "${{ matrix.case.trace_archive }}" \
-              --trace-file "${{ matrix.case.trace_file }}" \
-              --golden "${{ matrix.case.golden }}" \
-              --alternate-golden "${{ matrix.case.alternate_golden || '' }}" \
-              --target-call "${{ matrix.case.target_call }}" \
-              --width "${{ matrix.case.width }}" \
-              --height "${{ matrix.case.height }}" \
-              --ssim-threshold "${{ matrix.case.ssim_threshold || '0.99' }}" \
-              --crop-x "${{ matrix.case.crop_x }}" \
-              --crop-y "${{ matrix.case.crop_y }}" \
-              --crop-width "${{ matrix.case.crop_width }}" \
-              --crop-height "${{ matrix.case.crop_height }}" \
-              --timeout-seconds "${{ matrix.case.timeout_seconds }}" \
-              "${extra_retrace_args[@]}"
-          }
-
-          retrace_status=0
-          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}" \
-              --pid-file "${EMULATOR_PID_FILE}"
-            adb kill-server || true
-            sleep 2
-            sh android-plugin/run-avd-ci.sh start \
-              --avd-name "${AVD_NAME}" \
-              --gpu "${{ matrix.backend.gpu }}" \
-              --emulator-log "${EMULATOR_LOG}" \
-              --pid-file "${EMULATOR_PID_FILE}" \
-              --boot-timeout 300
-            run_retrace
-          elif [ "${retrace_status}" -ne 0 ]; then
-            exit "${retrace_status}"
-          fi
-
-      - name: Collect retrace summary inputs
-        if: always()
-        run: |
-          safe_case="$(printf '%s' '${{ matrix.case.name }}' | sed 's/[^A-Za-z0-9._-]/_/g')"
-          result_dir="android-retrace-result/${safe_case}-${{ matrix.backend.name }}"
-          mkdir -p "${result_dir}"
-          python3 - "${result_dir}/lane.json" <<'PY'
-          import json, os, sys
-          from pathlib import Path
-          Path(sys.argv[1]).write_text(json.dumps({"lane": os.environ["MOBILEGL_CI_LANE"],
-              "transport": os.environ["MOBILEGL_CI_TRANSPORT"]}, indent=2))
-          PY
-          if [ -s "${{ matrix.case.golden }}" ]; then
-            cp "${{ matrix.case.golden }}" "${result_dir}/${safe_case}-${{ matrix.backend.name }}-golden.png"
-          fi
-          if [ -n "${{ matrix.case.alternate_golden || '' }}" ] && [ -s "${{ matrix.case.alternate_golden || '' }}" ]; then
-            cp "${{ matrix.case.alternate_golden || '' }}" "${result_dir}/${safe_case}-${{ matrix.backend.name }}-alternate-golden.png"
-          fi
-
-      - name: Collect emulator diagnostics
-        if: always()
-        run: |
-          mkdir -p android-retrace-result/diagnostics
-          adb devices -l > android-retrace-result/diagnostics/adb-devices.txt || true
-          timeout 30 adb logcat -d -t 1000 > android-retrace-result/diagnostics/logcat.txt || true
-          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()
-        run: |
-          sh android-plugin/run-avd-ci.sh stop \
-            --avd-name "${AVD_NAME}" \
-            --emulator-log "${EMULATOR_LOG}" \
-            --pid-file "${EMULATOR_PID_FILE}"
-
-      - name: Upload Android retrace result
-        if: always()
-        uses: actions/upload-artifact@v7
-        with:
-          name: MobileGL-android-retrace-result-${{ matrix.lane || 'monolith-control' }}-${{ matrix.transport || 'monolith' }}-${{ env.date_today }}-${{ github.sha }}-${{ matrix.backend.name }}-${{ matrix.case.name }}
-          path: android-retrace-result/**
-          if-no-files-found: warn
-
-  retrace-summary:
-    name: retrace summary
-    runs-on: ubuntu-latest
-    needs: retrace
-    if: always()
-    env:
-      MOBILEGL_CI_DISAGGREGATED: ${{ (github.ref_name == 'feat/disaggregated' || github.ref_name == 'codex/fix-github-ci') && 'ON' || 'OFF' }}
-
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v6
-
-      - name: Set artifact metadata
-        run: |
-          echo "date_today=$(date +'%Y-%m-%d')" >> "$GITHUB_ENV"
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v7
-        with:
-          node-version: '22'
-
-      - name: Download Android monolith control results
-        uses: actions/download-artifact@v8
-        with:
-          pattern: MobileGL-android-retrace-result-monolith-control-monolith-*
-          path: retrace-artifacts/monolith-control
-
-      - name: Download Android inproc acceptance results
-        if: env.MOBILEGL_CI_DISAGGREGATED == 'ON'
-        uses: actions/download-artifact@v8
-        with:
-          pattern: MobileGL-android-retrace-result-inproc-acceptance-inproc-*
-          path: retrace-artifacts/inproc-acceptance
-
-      - name: Download Android spawn acceptance results
-        if: env.MOBILEGL_CI_DISAGGREGATED == 'ON'
-        uses: actions/download-artifact@v8
-        with:
-          pattern: MobileGL-android-retrace-result-spawn-acceptance-spawn-*
-          path: retrace-artifacts/spawn-acceptance
-
-      - name: Render monolith control summary
-        run: |
-          node tools/trace_replay/render_retrace_summary.mjs \
-            --input retrace-artifacts/monolith-control \
-            --output-dir android-retrace-summary/monolith-control \
-            --title "MobileGL Android monolith control" \
-            --group-label "Android Emulator / monolith control" \
-            --html mobilegl-android-monolith-control.html
-
-      - name: Render inproc acceptance summary
-        if: env.MOBILEGL_CI_DISAGGREGATED == 'ON'
-        run: |
-          node tools/trace_replay/render_retrace_summary.mjs \
-            --input retrace-artifacts/inproc-acceptance \
-            --output-dir android-retrace-summary/inproc-acceptance \
-            --title "MobileGL Android inproc acceptance" \
-            --group-label "Android Emulator / inproc acceptance" \
-            --html mobilegl-android-inproc-acceptance.html
-
-      - name: Render spawn acceptance summary
-        if: env.MOBILEGL_CI_DISAGGREGATED == 'ON'
-        run: |
-          node tools/trace_replay/render_retrace_summary.mjs             --input retrace-artifacts/spawn-acceptance             --output-dir android-retrace-summary/spawn-acceptance             --title "MobileGL Android spawn acceptance"             --group-label "Android Emulator / spawn acceptance"             --html mobilegl-android-spawn-acceptance.html
-
-      - name: Upload Android monolith control summary
-        uses: actions/upload-artifact@v7
-        with:
-          name: MobileGL-android-monolith-control-summary-${{ github.sha }}
-          path: android-retrace-summary/monolith-control/mobilegl-android-monolith-control.html
-          archive: false
-          if-no-files-found: error
-
-      - name: Upload Android inproc acceptance summary
-        if: env.MOBILEGL_CI_DISAGGREGATED == 'ON'
-        uses: actions/upload-artifact@v7
-        with:
-          name: MobileGL-android-inproc-acceptance-summary-${{ github.sha }}
-          path: android-retrace-summary/inproc-acceptance/mobilegl-android-inproc-acceptance.html
-          archive: false
-          if-no-files-found: error
-
-      - name: Upload Android spawn acceptance summary
-        if: env.MOBILEGL_CI_DISAGGREGATED == 'ON'
-        uses: actions/upload-artifact@v7
-        with:
-          name: MobileGL-android-spawn-acceptance-summary-${{ github.sha }}
-          path: android-retrace-summary/spawn-acceptance/mobilegl-android-spawn-acceptance.html
-          archive: false
-          if-no-files-found: error
-
-  remove-artifact-clutter:
-    name: remove artifact clutter
-    runs-on: ubuntu-latest
-    needs: retrace-summary
-    if: always()
-    permissions:
-      actions: write
-    steps:
-      - name: Delete intermediate Android retrace artifacts
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          # Fail before deletion if either paginated inventory cannot be read.
-          gh api --paginate "repos/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}/jobs?per_page=100" \
-            --jq '.jobs[] | select(.name | startswith("retrace (")) | select(.conclusion == "failure" or .conclusion == "cancelled" or .conclusion == "timed_out" or .conclusion == "action_required") | .name' \
-            > "${RUNNER_TEMP}/cleanup-jobs.txt"
-          gh api --paginate "repos/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}/artifacts?per_page=100" \
-            --jq '.artifacts[] | select(.name | startswith("MobileGL-trace-fixture-") or startswith("MobileGL-android-retrace-result-") or startswith("trace-fixture-") or startswith("retrace-result-")) | [.id, .name] | @tsv' \
-            > "${RUNNER_TEMP}/cleanup-artifacts.txt"
-          declare -A failed_cases=()
-          while IFS= read -r job_name; do
-            case_name="${job_name#retrace (*, }"
-            case_name="${case_name%)}"
-            failed_cases["${case_name}"]=1
-          done < "${RUNNER_TEMP}/cleanup-jobs.txt"
-
-          if ((${#failed_cases[@]})); then
-            echo "Retaining fixtures and results for failed retrace case(s):"
-            printf '  %s\n' "${!failed_cases[@]}"
-          else
-            echo "All retrace jobs succeeded; nothing needs 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
-              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})"
-            gh api --method DELETE "repos/${GITHUB_REPOSITORY}/actions/artifacts/${artifact_id}"
-            ((deleted += 1))
-          done < "${RUNNER_TEMP}/cleanup-artifacts.txt"
-
-          echo "Deleted ${deleted} intermediate Android artifact(s); retained ${retained} failed-retrace fixture(s)."

.github/workflows/benchmark.yml

@@ -0,0 +1,57 @@
+name: Benchmark
+
+on:
+  push:
+    branches: 
+      - dev
+      - Feat/Backend-Direct-GLES
+      - Feat/Backend-Direct-Vulkan
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    env:
+      # BENCH_ROOT: ${{github.workspace}}/MobileGL/MG_Benchmark
+      BENCH_ROOT: ${{github.workspace}}
+
+    steps:
+      - name: Set Swap Space
+        uses: pierotofy/set-swap-space@master
+        with:
+          swap-size-gb: 32
+
+      - name: Checkout repo
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Get CMake
+        uses: lukka/get-cmake@latest
+
+      - name: Update glslang external sources
+        working-directory: ${{env.BENCH_ROOT}}/3rdparty/glslang
+        run: python update_glslang_sources.py
+
+      - name: Install clang-20
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y clang-20 clang++-20 lld-20 libc++-20-dev libc++abi-20-dev libvulkan-dev
+
+      - name: Show installed toolchain
+        run: |
+          clang-20 --version
+          clang++-20 --version
+          ld.lld-20 --version || ld.lld --version || true
+          dpkg -l 'libc++*' || true
+
+      - name: Configure CMake
+        working-directory: ${{env.BENCH_ROOT}}
+        run: cmake -S . -B build-bench -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=clang-20 -DCMAKE_CXX_COMPILER=clang++-20 -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON -DBENCHMARK_ENABLE_TESTING=OFF -DMOBILEGL_BUILD_TEST=OFF -DMOBILEGL_BUILD_BENCHMARK=ON -DCMAKE_POLICY_VERSION_MINIMUM=3.5
+
+      - name: Build
+        working-directory: ${{env.BENCH_ROOT}}/build-bench
+        run: cmake --build .
+
+      - name: Benchmark
+        working-directory: ${{env.BENCH_ROOT}}/build-bench/MobileGL/MG_Benchmark
+        run: ctest -V -C Release

.gitignore

@@ -14,18 +14,4 @@ MobileGLCodeManager
 .vscode
 .clangd
 MobileGL/MG_Test/build
-/build_*
-/cmake-build*
-.idea
-MobileGL/MG*/build*
-MobileGL/MG*/cmake-build*
-/android-plugin/.gradle
-/android-plugin/build
-/android-plugin/app/build
-/android-plugin/app/src/trace/jniLibs
-/android-plugin/local.properties
-tools/trace_replay/work/
-__pycache__/
-*.py[cod]
-/.gradle
-/.trace-work/
+/build_*

.gitmodules

@@ -7,33 +7,12 @@
 [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
 [submodule "3rdparty/xxHash"]
 	path = 3rdparty/xxHash
 	url = https://github.com/Cyan4973/xxHash.git
-[submodule "3rdparty/VulkanMemoryAllocator"]
-	path = 3rdparty/VulkanMemoryAllocator
-	url = https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
-[submodule "3rdparty/Vulkan-Utility-Libraries"]
-	path = 3rdparty/Vulkan-Utility-Libraries
-	url = https://github.com/KhronosGroup/Vulkan-Utility-Libraries.git
-[submodule "3rdparty/Vulkan-Headers"]
-	path = 3rdparty/Vulkan-Headers
-	url = https://github.com/KhronosGroup/Vulkan-Headers.git
-[submodule "3rdparty/SPIRV-Reflect"]
-	path = 3rdparty/SPIRV-Reflect
-	url = https://github.com/KhronosGroup/SPIRV-Reflect.git
-[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
-[submodule "3rdparty/flatbuffers"]
-	path = 3rdparty/flatbuffers
-	url = https://github.com/google/flatbuffers.git

3rdparty/gbm/include/gbm.h

@@ -1,538 +0,0 @@
-/*
- * Copyright © 2011 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Benjamin Franzke <benjaminfranzke@googlemail.com>
- */
-
-#ifndef _GBM_H_
-#define _GBM_H_
-
-#define __GBM__ 1
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/**
- * \file gbm.h
- * \brief Generic Buffer Manager
- */
-
-struct gbm_device;
-struct gbm_bo;
-struct gbm_surface;
-
-/**
- * \mainpage The Generic Buffer Manager
- *
- * This module provides an abstraction that the caller can use to request a
- * buffer from the underlying memory management system for the platform.
- *
- * This allows the creation of portable code whilst still allowing access to
- * the underlying memory manager.
- */
-
-/**
- * Abstraction representing the handle to a buffer allocated by the
- * manager
- */
-union gbm_bo_handle {
-   void *ptr;
-   int32_t s32;
-   uint32_t u32;
-   int64_t s64;
-   uint64_t u64;
-};
-
-/** Format of the allocated buffer */
-enum gbm_bo_format {
-   /** RGB with 8 bits per channel in a 32 bit value */
-   GBM_BO_FORMAT_XRGB8888, 
-   /** ARGB with 8 bits per channel in a 32 bit value */
-   GBM_BO_FORMAT_ARGB8888
-};
-
-
-/**
- * The FourCC format codes are taken from the drm_fourcc.h definition, and
- * re-namespaced. New GBM formats must not be added, unless they are
- * identical ports from drm_fourcc.
- */
-#define __gbm_fourcc_code(a,b,c,d) ((uint32_t)(a) | ((uint32_t)(b) << 8) | \
-			      ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24))
-
-#define GBM_FORMAT_BIG_ENDIAN (1<<31) /* format is big endian instead of little endian */
-
-/* color index */
-#define GBM_FORMAT_C8		__gbm_fourcc_code('C', '8', ' ', ' ') /* [7:0] C */
-
-/* 8 bpp Red */
-#define GBM_FORMAT_R8		__gbm_fourcc_code('R', '8', ' ', ' ') /* [7:0] R */
-
-/* 16 bpp Red */
-#define GBM_FORMAT_R16          __gbm_fourcc_code('R', '1', '6', ' ') /* [15:0] R little endian */
-
-/* 16 bpp RG */
-#define GBM_FORMAT_GR88		__gbm_fourcc_code('G', 'R', '8', '8') /* [15:0] G:R 8:8 little endian */
-
-/* 32 bpp RG */
-#define GBM_FORMAT_RG1616	__gbm_fourcc_code('R', 'G', '3', '2') /* [31:0] R:G 16:16 little endian */
-#define GBM_FORMAT_GR1616	__gbm_fourcc_code('G', 'R', '3', '2') /* [31:0] G:R 16:16 little endian */
-
-/* 8 bpp RGB */
-#define GBM_FORMAT_RGB332	__gbm_fourcc_code('R', 'G', 'B', '8') /* [7:0] R:G:B 3:3:2 */
-#define GBM_FORMAT_BGR233	__gbm_fourcc_code('B', 'G', 'R', '8') /* [7:0] B:G:R 2:3:3 */
-
-/* 16 bpp RGB */
-#define GBM_FORMAT_XRGB4444	__gbm_fourcc_code('X', 'R', '1', '2') /* [15:0] x:R:G:B 4:4:4:4 little endian */
-#define GBM_FORMAT_XBGR4444	__gbm_fourcc_code('X', 'B', '1', '2') /* [15:0] x:B:G:R 4:4:4:4 little endian */
-#define GBM_FORMAT_RGBX4444	__gbm_fourcc_code('R', 'X', '1', '2') /* [15:0] R:G:B:x 4:4:4:4 little endian */
-#define GBM_FORMAT_BGRX4444	__gbm_fourcc_code('B', 'X', '1', '2') /* [15:0] B:G:R:x 4:4:4:4 little endian */
-
-#define GBM_FORMAT_ARGB4444	__gbm_fourcc_code('A', 'R', '1', '2') /* [15:0] A:R:G:B 4:4:4:4 little endian */
-#define GBM_FORMAT_ABGR4444	__gbm_fourcc_code('A', 'B', '1', '2') /* [15:0] A:B:G:R 4:4:4:4 little endian */
-#define GBM_FORMAT_RGBA4444	__gbm_fourcc_code('R', 'A', '1', '2') /* [15:0] R:G:B:A 4:4:4:4 little endian */
-#define GBM_FORMAT_BGRA4444	__gbm_fourcc_code('B', 'A', '1', '2') /* [15:0] B:G:R:A 4:4:4:4 little endian */
-
-#define GBM_FORMAT_XRGB1555	__gbm_fourcc_code('X', 'R', '1', '5') /* [15:0] x:R:G:B 1:5:5:5 little endian */
-#define GBM_FORMAT_XBGR1555	__gbm_fourcc_code('X', 'B', '1', '5') /* [15:0] x:B:G:R 1:5:5:5 little endian */
-#define GBM_FORMAT_RGBX5551	__gbm_fourcc_code('R', 'X', '1', '5') /* [15:0] R:G:B:x 5:5:5:1 little endian */
-#define GBM_FORMAT_BGRX5551	__gbm_fourcc_code('B', 'X', '1', '5') /* [15:0] B:G:R:x 5:5:5:1 little endian */
-
-#define GBM_FORMAT_ARGB1555	__gbm_fourcc_code('A', 'R', '1', '5') /* [15:0] A:R:G:B 1:5:5:5 little endian */
-#define GBM_FORMAT_ABGR1555	__gbm_fourcc_code('A', 'B', '1', '5') /* [15:0] A:B:G:R 1:5:5:5 little endian */
-#define GBM_FORMAT_RGBA5551	__gbm_fourcc_code('R', 'A', '1', '5') /* [15:0] R:G:B:A 5:5:5:1 little endian */
-#define GBM_FORMAT_BGRA5551	__gbm_fourcc_code('B', 'A', '1', '5') /* [15:0] B:G:R:A 5:5:5:1 little endian */
-
-#define GBM_FORMAT_RGB565	__gbm_fourcc_code('R', 'G', '1', '6') /* [15:0] R:G:B 5:6:5 little endian */
-#define GBM_FORMAT_BGR565	__gbm_fourcc_code('B', 'G', '1', '6') /* [15:0] B:G:R 5:6:5 little endian */
-
-/* 24 bpp RGB */
-#define GBM_FORMAT_RGB888	__gbm_fourcc_code('R', 'G', '2', '4') /* [23:0] R:G:B little endian */
-#define GBM_FORMAT_BGR888	__gbm_fourcc_code('B', 'G', '2', '4') /* [23:0] B:G:R little endian */
-
-/* 32 bpp RGB */
-#define GBM_FORMAT_XRGB8888	__gbm_fourcc_code('X', 'R', '2', '4') /* [31:0] x:R:G:B 8:8:8:8 little endian */
-#define GBM_FORMAT_XBGR8888	__gbm_fourcc_code('X', 'B', '2', '4') /* [31:0] x:B:G:R 8:8:8:8 little endian */
-#define GBM_FORMAT_RGBX8888	__gbm_fourcc_code('R', 'X', '2', '4') /* [31:0] R:G:B:x 8:8:8:8 little endian */
-#define GBM_FORMAT_BGRX8888	__gbm_fourcc_code('B', 'X', '2', '4') /* [31:0] B:G:R:x 8:8:8:8 little endian */
-
-#define GBM_FORMAT_ARGB8888	__gbm_fourcc_code('A', 'R', '2', '4') /* [31:0] A:R:G:B 8:8:8:8 little endian */
-#define GBM_FORMAT_ABGR8888	__gbm_fourcc_code('A', 'B', '2', '4') /* [31:0] A:B:G:R 8:8:8:8 little endian */
-#define GBM_FORMAT_RGBA8888	__gbm_fourcc_code('R', 'A', '2', '4') /* [31:0] R:G:B:A 8:8:8:8 little endian */
-#define GBM_FORMAT_BGRA8888	__gbm_fourcc_code('B', 'A', '2', '4') /* [31:0] B:G:R:A 8:8:8:8 little endian */
-
-#define GBM_FORMAT_XRGB2101010	__gbm_fourcc_code('X', 'R', '3', '0') /* [31:0] x:R:G:B 2:10:10:10 little endian */
-#define GBM_FORMAT_XBGR2101010	__gbm_fourcc_code('X', 'B', '3', '0') /* [31:0] x:B:G:R 2:10:10:10 little endian */
-#define GBM_FORMAT_RGBX1010102	__gbm_fourcc_code('R', 'X', '3', '0') /* [31:0] R:G:B:x 10:10:10:2 little endian */
-#define GBM_FORMAT_BGRX1010102	__gbm_fourcc_code('B', 'X', '3', '0') /* [31:0] B:G:R:x 10:10:10:2 little endian */
-
-#define GBM_FORMAT_ARGB2101010	__gbm_fourcc_code('A', 'R', '3', '0') /* [31:0] A:R:G:B 2:10:10:10 little endian */
-#define GBM_FORMAT_ABGR2101010	__gbm_fourcc_code('A', 'B', '3', '0') /* [31:0] A:B:G:R 2:10:10:10 little endian */
-#define GBM_FORMAT_RGBA1010102	__gbm_fourcc_code('R', 'A', '3', '0') /* [31:0] R:G:B:A 10:10:10:2 little endian */
-#define GBM_FORMAT_BGRA1010102	__gbm_fourcc_code('B', 'A', '3', '0') /* [31:0] B:G:R:A 10:10:10:2 little endian */
-
-/* 64 bpp RGB */
-#define GBM_FORMAT_XBGR16161616	__gbm_fourcc_code('X', 'B', '4', '8') /* [63:0] x:B:G:R 16:16:16:16 little endian */
-
-#define GBM_FORMAT_ABGR16161616	__gbm_fourcc_code('A', 'B', '4', '8') /* [63:0] A:B:G:R 16:16:16:16 little endian */
-
-/*
- * Floating point 64bpp RGB
- * IEEE 754-2008 binary16 half-precision float
- * [15:0] sign:exponent:mantissa 1:5:10
- */
-#define GBM_FORMAT_XBGR16161616F __gbm_fourcc_code('X', 'B', '4', 'H') /* [63:0] x:B:G:R 16:16:16:16 little endian */
-
-#define GBM_FORMAT_ABGR16161616F __gbm_fourcc_code('A', 'B', '4', 'H') /* [63:0] A:B:G:R 16:16:16:16 little endian */
-
-/* packed YCbCr */
-#define GBM_FORMAT_YUYV		__gbm_fourcc_code('Y', 'U', 'Y', 'V') /* [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian */
-#define GBM_FORMAT_YVYU		__gbm_fourcc_code('Y', 'V', 'Y', 'U') /* [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian */
-#define GBM_FORMAT_UYVY		__gbm_fourcc_code('U', 'Y', 'V', 'Y') /* [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian */
-#define GBM_FORMAT_VYUY		__gbm_fourcc_code('V', 'Y', 'U', 'Y') /* [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian */
-
-#define GBM_FORMAT_AYUV		__gbm_fourcc_code('A', 'Y', 'U', 'V') /* [31:0] A:Y:Cb:Cr 8:8:8:8 little endian */
-
-/*
- * 2 plane YCbCr
- * index 0 = Y plane, [7:0] Y
- * index 1 = Cr:Cb plane, [15:0] Cr:Cb little endian
- * or
- * index 1 = Cb:Cr plane, [15:0] Cb:Cr little endian
- */
-#define GBM_FORMAT_NV12		__gbm_fourcc_code('N', 'V', '1', '2') /* 2x2 subsampled Cr:Cb plane */
-#define GBM_FORMAT_NV21		__gbm_fourcc_code('N', 'V', '2', '1') /* 2x2 subsampled Cb:Cr plane */
-#define GBM_FORMAT_NV16		__gbm_fourcc_code('N', 'V', '1', '6') /* 2x1 subsampled Cr:Cb plane */
-#define GBM_FORMAT_NV61		__gbm_fourcc_code('N', 'V', '6', '1') /* 2x1 subsampled Cb:Cr plane */
-
-/*
- * 3 plane YCbCr
- * index 0: Y plane, [7:0] Y
- * index 1: Cb plane, [7:0] Cb
- * index 2: Cr plane, [7:0] Cr
- * or
- * index 1: Cr plane, [7:0] Cr
- * index 2: Cb plane, [7:0] Cb
- */
-#define GBM_FORMAT_YUV410	__gbm_fourcc_code('Y', 'U', 'V', '9') /* 4x4 subsampled Cb (1) and Cr (2) planes */
-#define GBM_FORMAT_YVU410	__gbm_fourcc_code('Y', 'V', 'U', '9') /* 4x4 subsampled Cr (1) and Cb (2) planes */
-#define GBM_FORMAT_YUV411	__gbm_fourcc_code('Y', 'U', '1', '1') /* 4x1 subsampled Cb (1) and Cr (2) planes */
-#define GBM_FORMAT_YVU411	__gbm_fourcc_code('Y', 'V', '1', '1') /* 4x1 subsampled Cr (1) and Cb (2) planes */
-#define GBM_FORMAT_YUV420	__gbm_fourcc_code('Y', 'U', '1', '2') /* 2x2 subsampled Cb (1) and Cr (2) planes */
-#define GBM_FORMAT_YVU420	__gbm_fourcc_code('Y', 'V', '1', '2') /* 2x2 subsampled Cr (1) and Cb (2) planes */
-#define GBM_FORMAT_YUV422	__gbm_fourcc_code('Y', 'U', '1', '6') /* 2x1 subsampled Cb (1) and Cr (2) planes */
-#define GBM_FORMAT_YVU422	__gbm_fourcc_code('Y', 'V', '1', '6') /* 2x1 subsampled Cr (1) and Cb (2) planes */
-#define GBM_FORMAT_YUV444	__gbm_fourcc_code('Y', 'U', '2', '4') /* non-subsampled Cb (1) and Cr (2) planes */
-#define GBM_FORMAT_YVU444	__gbm_fourcc_code('Y', 'V', '2', '4') /* non-subsampled Cr (1) and Cb (2) planes */
-
-struct gbm_format_name_desc {
-   char name[5];
-};
-
-/**
- * Flags to indicate the intended use for the buffer - these are passed into
- * gbm_bo_create(). The caller must set the union of all the flags that are
- * appropriate
- *
- * \sa Use gbm_device_is_format_supported() to check if the combination of format
- * and use flags are supported
- */
-enum gbm_bo_flags {
-   /**
-    * Buffer is going to be presented to the screen using an API such as KMS
-    */
-   GBM_BO_USE_SCANOUT      = (1 << 0),
-   /**
-    * Buffer is going to be used as cursor
-    */
-   GBM_BO_USE_CURSOR       = (1 << 1),
-   /**
-    * Deprecated
-    */
-   GBM_BO_USE_CURSOR_64X64 = GBM_BO_USE_CURSOR,
-   /**
-    * Buffer is to be used for rendering - for example it is going to be used
-    * as the storage for a color buffer
-    */
-   GBM_BO_USE_RENDERING    = (1 << 2),
-   /**
-    * Buffer can be used for gbm_bo_write.  This is guaranteed to work
-    * with GBM_BO_USE_CURSOR, but may not work for other combinations.
-    */
-   GBM_BO_USE_WRITE    = (1 << 3),
-   /**
-    * Buffer is linear, i.e. not tiled.
-    */
-   GBM_BO_USE_LINEAR = (1 << 4),
-   /**
-    * Buffer is protected, i.e. encrypted and not readable by CPU or any
-    * other non-secure / non-trusted components nor by non-trusted OpenGL,
-    * OpenCL, and Vulkan applications.
-    */
-   GBM_BO_USE_PROTECTED = (1 << 5),
-
-   /**
-    * The buffer will be used for front buffer rendering.  On some
-    * platforms this may (for example) disable framebuffer compression
-    * to avoid problems with compression flags data being out of sync
-    * with pixel data.
-    */
-   GBM_BO_USE_FRONT_RENDERING = (1 << 6),
-
-   /**
-    * Allow the driver to select fixed-rate compression parameters.
-    */
-   GBM_BO_FIXED_COMPRESSION_DEFAULT = (1 << 7),
-
-   /**
-    * Fixed-rate compression: at least 1bpc, less than 2bpc
-    */
-   GBM_BO_FIXED_COMPRESSION_1BPC = (2 << 7),
-
-   /**
-    * Fixed-rate compression: at least 2bpc, less than 3bpc
-    */
-   GBM_BO_FIXED_COMPRESSION_2BPC = (3 << 7),
-
-   /**
-    * Fixed-rate compression: at least 3bpc, less than 4bpc
-    */
-   GBM_BO_FIXED_COMPRESSION_3BPC = (4 << 7),
-
-   /**
-    * Fixed-rate compression: at least 4bpc, less than 5bpc
-    */
-   GBM_BO_FIXED_COMPRESSION_4BPC = (5 << 7),
-
-   /**
-    * Fixed-rate compression: at least 5bpc, less than 6bpc
-    */
-   GBM_BO_FIXED_COMPRESSION_5BPC = (6 << 7),
-
-   /**
-    * Fixed-rate compression: at least 6bpc, less than 7bpc
-    */
-   GBM_BO_FIXED_COMPRESSION_6BPC = (7 << 7),
-
-   /**
-    * Fixed-rate compression: at least 7bpc, less than 8bpc
-    */
-   GBM_BO_FIXED_COMPRESSION_7BPC = (8 << 7),
-
-   /**
-    * Fixed-rate compression: at least 8bpc, less than 9bpc
-    */
-   GBM_BO_FIXED_COMPRESSION_8BPC = (9 << 7),
-
-   /**
-    * Fixed-rate compression: at least 9bpc, less than 10bpc
-    */
-   GBM_BO_FIXED_COMPRESSION_9BPC = (10 << 7),
-
-   /**
-    * Fixed-rate compression: at least 10bpc, less than 11bpc
-    */
-   GBM_BO_FIXED_COMPRESSION_10BPC = (11 << 7),
-
-   /**
-    * Fixed-rate compression: at least 11bpc, less than 12bpc
-    */
-   GBM_BO_FIXED_COMPRESSION_11BPC = (12 << 7),
-
-   /**
-    * Fixed-rate compression: at least 12bpc, no maximum rate
-    */
-   GBM_BO_FIXED_COMPRESSION_12BPC = (13 << 7),
-
-   /* next available value is (1 << 11) */
-};
-
-#define GBM_BO_FIXED_COMPRESSION_MASK (((1 << 11) - 1) & ~((1 << 7) - 1))
-
-int
-gbm_device_get_fd(struct gbm_device *gbm);
-
-const char *
-gbm_device_get_backend_name(struct gbm_device *gbm);
-
-int
-gbm_device_is_format_supported(struct gbm_device *gbm,
-                               uint32_t format, uint32_t flags);
-
-int
-gbm_device_get_format_modifier_plane_count(struct gbm_device *gbm,
-                                           uint32_t format,
-                                           uint64_t modifier);
-
-void
-gbm_device_destroy(struct gbm_device *gbm);
-
-struct gbm_device *
-gbm_create_device(int fd);
-
-struct gbm_bo *
-gbm_bo_create(struct gbm_device *gbm,
-              uint32_t width, uint32_t height,
-              uint32_t format, uint32_t flags);
-
-struct gbm_bo *
-gbm_bo_create_with_modifiers(struct gbm_device *gbm,
-                             uint32_t width, uint32_t height,
-                             uint32_t format,
-                             const uint64_t *modifiers,
-                             const unsigned int count);
-
-struct gbm_bo *
-gbm_bo_create_with_modifiers2(struct gbm_device *gbm,
-                              uint32_t width, uint32_t height,
-                              uint32_t format,
-                              const uint64_t *modifiers,
-                              const unsigned int count,
-                              uint32_t flags);
-
-#define GBM_BO_IMPORT_WL_BUFFER         0x5501
-#define GBM_BO_IMPORT_EGL_IMAGE         0x5502
-#define GBM_BO_IMPORT_FD                0x5503
-#define GBM_BO_IMPORT_FD_MODIFIER       0x5504
-
-struct gbm_import_fd_data {
-   int fd;
-   uint32_t width;
-   uint32_t height;
-   uint32_t stride;
-   uint32_t format;
-};
-
-#define GBM_MAX_PLANES 4
-
-struct gbm_import_fd_modifier_data {
-   uint32_t width;
-   uint32_t height;
-   uint32_t format;
-   uint32_t num_fds;
-   int fds[GBM_MAX_PLANES];
-   int strides[GBM_MAX_PLANES];
-   int offsets[GBM_MAX_PLANES];
-   uint64_t modifier;
-};
-
-struct gbm_bo *
-gbm_bo_import(struct gbm_device *gbm, uint32_t type,
-              void *buffer, uint32_t flags);
-
-/**
- * Flags to indicate the type of mapping for the buffer - these are
- * passed into gbm_bo_map(). The caller must set the union of all the
- * flags that are appropriate.
- *
- * These flags are independent of the GBM_BO_USE_* creation flags. However,
- * mapping the buffer may require copying to/from a staging buffer.
- *
- * See also: pipe_map_flags
- */
-enum gbm_bo_transfer_flags {
-   /**
-    * Buffer contents read back (or accessed directly) at transfer
-    * create time.
-    */
-   GBM_BO_TRANSFER_READ       = (1 << 0),
-   /**
-    * Buffer contents will be written back at unmap time
-    * (or modified as a result of being accessed directly).
-    */
-   GBM_BO_TRANSFER_WRITE      = (1 << 1),
-   /**
-    * Read/modify/write
-    */
-   GBM_BO_TRANSFER_READ_WRITE = (GBM_BO_TRANSFER_READ | GBM_BO_TRANSFER_WRITE),
-};
-
-void *
-gbm_bo_map(struct gbm_bo *bo,
-           uint32_t x, uint32_t y, uint32_t width, uint32_t height,
-           uint32_t flags, uint32_t *stride, void **map_data);
-
-void
-gbm_bo_unmap(struct gbm_bo *bo, void *map_data);
-
-uint32_t
-gbm_bo_get_width(struct gbm_bo *bo);
-
-uint32_t
-gbm_bo_get_height(struct gbm_bo *bo);
-
-uint32_t
-gbm_bo_get_stride(struct gbm_bo *bo);
-
-uint32_t
-gbm_bo_get_stride_for_plane(struct gbm_bo *bo, int plane);
-
-uint32_t
-gbm_bo_get_format(struct gbm_bo *bo);
-
-uint32_t
-gbm_bo_get_bpp(struct gbm_bo *bo);
-
-uint32_t
-gbm_bo_get_offset(struct gbm_bo *bo, int plane);
-
-struct gbm_device *
-gbm_bo_get_device(struct gbm_bo *bo);
-
-union gbm_bo_handle
-gbm_bo_get_handle(struct gbm_bo *bo);
-
-int
-gbm_bo_get_fd(struct gbm_bo *bo);
-
-uint64_t
-gbm_bo_get_modifier(struct gbm_bo *bo);
-
-int
-gbm_bo_get_plane_count(struct gbm_bo *bo);
-
-union gbm_bo_handle
-gbm_bo_get_handle_for_plane(struct gbm_bo *bo, int plane);
-
-int
-gbm_bo_get_fd_for_plane(struct gbm_bo *bo, int plane);
-
-int
-gbm_bo_write(struct gbm_bo *bo, const void *buf, size_t count);
-
-void
-gbm_bo_set_user_data(struct gbm_bo *bo, void *data,
-		     void (*destroy_user_data)(struct gbm_bo *, void *));
-
-void *
-gbm_bo_get_user_data(struct gbm_bo *bo);
-
-void
-gbm_bo_destroy(struct gbm_bo *bo);
-
-struct gbm_surface *
-gbm_surface_create(struct gbm_device *gbm,
-                   uint32_t width, uint32_t height,
-		   uint32_t format, uint32_t flags);
-
-struct gbm_surface *
-gbm_surface_create_with_modifiers(struct gbm_device *gbm,
-                                  uint32_t width, uint32_t height,
-                                  uint32_t format,
-                                  const uint64_t *modifiers,
-                                  const unsigned int count);
-
-struct gbm_surface *
-gbm_surface_create_with_modifiers2(struct gbm_device *gbm,
-                                   uint32_t width, uint32_t height,
-                                   uint32_t format,
-                                   const uint64_t *modifiers,
-                                   const unsigned int count,
-                                   uint32_t flags);
-
-struct gbm_bo *
-gbm_surface_lock_front_buffer(struct gbm_surface *surface);
-
-void
-gbm_surface_release_buffer(struct gbm_surface *surface, struct gbm_bo *bo);
-
-int
-gbm_surface_has_free_buffers(struct gbm_surface *surface);
-
-void
-gbm_surface_destroy(struct gbm_surface *surface);
-
-char *
-gbm_format_get_name(uint32_t gbm_format, struct gbm_format_name_desc *desc);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

3rdparty/glvnd/README.md

@@ -1,11 +0,0 @@
-# glvnd vendor ABI headers
-
-'libeglabi.h' and 'GLdispatchABI.h' from libglvnd (MIT), copied verbatim with their own licence
-headers intact.
-
-They are here because MobileGL implements the *vendor* half of glvnd's EGL ABI - the side a library
-exposes so the system's 'libEGL.so.1', which IS glvnd, can dispatch to it.  The distribution ships
-the runtime but not these headers in the base image, and a vendored copy of two MIT headers is a
-smaller dependency than a build-time download of a source tree.
-
-Upstream ABI version implemented: 'EGL_VENDOR_ABI_MAJOR_VERSION' 0 (the header pins it).

3rdparty/glvnd/include/glvnd/GLdispatchABI.h

@@ -1,141 +0,0 @@
-/*
- * Copyright (c) 2013, NVIDIA CORPORATION.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and/or associated documentation files (the
- * "Materials"), to deal in the Materials without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Materials, and to
- * permit persons to whom the Materials are furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * unaltered in all copies or substantial portions of the Materials.
- * Any additions, deletions, or changes to the original source files
- * must be clearly indicated in accompanying documentation.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
- */
-
-#include <GL/gl.h>
-
-#if !defined(__GL_DISPATCH_ABI_H)
-#define __GL_DISPATCH_ABI_H
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-/*!
- * \defgroup gldispatchabi GL dispatching ABI
- *
- * This is not a complete ABI, but rather a fragment common to the libEGL and
- * libGLX ABIs.  Changes to this file should be accompanied by a version bump to
- * these client ABIs.
- */
-
-/*!
- * Thread-local implementation used by libglvnd. This is passed into the patch
- * function callback via the type parameter.
- *
- * For most architectures, the vendor library can ignore this parameter, since
- * it will always be the same value. It's used for systems like ARM, where the
- * stubs might be use the ARM or Thumb instruction sets.
- *
- * The stub type does not make any distinction between TLS and TSD stubs. The
- * entire purpose of entrypoint rewriting is to skip the dispatch table in
- * libGLdispatch.so, so it doesn't matter how that dispatch table is stored.
- */
-enum {
-    /*!
-     * Indicates that the stubs aren't defined in assembly. For example, if the
-     * dispatch stubs are written in C. Vendor libraries generally won't see
-     * this value.
-     */
-    __GLDISPATCH_STUB_UNKNOWN,
-
-    /*!
-     * Used for stubs on x86 systems.
-     */
-    __GLDISPATCH_STUB_X86,
-
-    /*!
-     * Used for stubs on x86-64 systems.
-     */
-    __GLDISPATCH_STUB_X86_64,
-
-    /*!
-     * Used for stubs on ARMv7, using the Thumb instruction set.
-     */
-    __GLDISPATCH_STUB_ARMV7_THUMB,
-
-    /*!
-     * Used for stubs on ARMv7, using the normal ARM instruction set.
-     */
-    __GLDISPATCH_STUB_ARMV7_ARM,
-
-    /*!
-     * Used for stubs on ARMv8/aarch64.
-     */
-    __GLDISPATCH_STUB_AARCH64,
-
-    /*!
-     * Used for stubs on x32 builds (x86-64 with 32-bit pointers).
-     */
-    __GLDISPATCH_STUB_X32,
-
-    /*!
-     * Used for stubs on PPC64 systems.
-     */
-    __GLDISPATCH_STUB_PPC64,
-
-    /*!
-     * Used for stubs on PPC64LE systems. Same as PPC64, for compatibility.
-     */
-    __GLDISPATCH_STUB_PPC64LE = __GLDISPATCH_STUB_PPC64,
-
-    /*!
-     * Used for stubs on LOONGARCH/loongarch64.
-     */
-    __GLDISPATCH_STUB_LOONGARCH64,
-};
-
-/*!
- * A callback function called by the vendor library to fetch the address of an
- * entrypoint.
- *
- * The function returns two pointers, one writable and one executable. The two
- * pointers may or may not be the same virtual address, but they will both be
- * mappings of the same physical memory.
- *
- * The vendor library should write its entrypoint to the address returned by
- * \p writePtr, but should use the address from \p execPtr for things like
- * calculating PC-relative offsets.
- *
- * Note that if this function fails, then the vendor library can still try to
- * patch other entrypoints.
- *
- * Note that on ARM, the low-order bit of both \c execPtr and \p writePtr will
- * be zero, even if the stub uses the thumb instruction set. The vendor library
- * should use the \c type parameter of \c initiatePatch to determine which
- * instruction set to use.
- *
- * \param funcName The function name.
- * \param[out] writePtr The pointer that the vendor library can write to.
- * \param[out] execPtr The pointer to the executable code.
- * \return GL_TRUE if the entrypoint exists, or GL_FALSE if it doesn't.
- */
-typedef GLboolean (*DispatchPatchLookupStubOffset)(const char *funcName,
-        void **writePtr, const void **execPtr);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif // __GL_DISPATCH_ABI_H

3rdparty/glvnd/include/glvnd/libeglabi.h

@@ -1,464 +0,0 @@
-/*
- * Copyright (c) 2013, NVIDIA CORPORATION.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and/or associated documentation files (the
- * "Materials"), to deal in the Materials without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Materials, and to
- * permit persons to whom the Materials are furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * unaltered in all copies or substantial portions of the Materials.
- * Any additions, deletions, or changes to the original source files
- * must be clearly indicated in accompanying documentation.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
- */
-
-#if !defined(__LIB_EGL_ABI_H)
-#define __LIB_EGL_ABI_H
-
-#include <stdint.h>
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-
-#include "glvnd/GLdispatchABI.h"
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-/*!
- * \defgroup eglvendorabi EGL Vendor ABI
- *
- * Definition of ABI exported by libEGL.so to libEGL_VENDOR.so libraries.
- *
- * Each vendor is associated with three distinct dispatch table types:
- *
- * - static EGL dispatch table: this is the fixed list of EGL 1.5 entrypoints
- *   provided by the vendor at load time during the initial handshake.
- * - dynamic EGL dispatch table: this is a structure allocated by the API
- *   library at runtime used to manage EGL extension functions which are not
- *   present in the static table.
- * - core GL dispatch table: this is a structure maintained by the API library
- *   which contains both GL core (static) and GL extension (dynamic) functions.
- *
- * @{
- */
-
-/*
- * Rendering API handling:
- *
- * libEGL only supports OpenGL and OpenGL ES, not OpenVG. If OpenVG or any
- * other API is added, then the major version number will be incremented.
- *
- * When the application calls eglBindAPI, libEGL will forward the call to every
- * vendor library. In addition, a vendor library can query the current API from
- * libEGL using the getCurrentApi callback.
- *
- * Vendor libraries are not required to support both GL and GLES, but they must
- * be able to deal with either one as the current rendering API. If a vendor
- * doesn't support the current API, then it should return an error from
- * eglCreateContext.
- */
-
-/*!
- * Current version of the ABI.
- *
- * This version number contains a major number in the high-order 16 bits, and
- * a minor version number in the low-order 16 bits.
- *
- * The major version number is incremented when an interface change will break
- * backwards compatibility with existing vendor libraries. The minor version
- * number is incremented when there's a change but existing vendor libraries
- * will still work.
- */
-#define EGL_VENDOR_ABI_MAJOR_VERSION ((uint32_t) 0)
-#define EGL_VENDOR_ABI_MINOR_VERSION ((uint32_t) 2)
-#define EGL_VENDOR_ABI_VERSION ((EGL_VENDOR_ABI_MAJOR_VERSION << 16) | EGL_VENDOR_ABI_MINOR_VERSION)
-static inline uint32_t EGL_VENDOR_ABI_GET_MAJOR_VERSION(uint32_t version)
-{
-    return version >> 16;
-}
-static inline uint32_t EGL_VENDOR_ABI_GET_MINOR_VERSION(uint32_t version)
-{
-    return version & 0xFFFF;
-}
-
-
-/*!
- * This opaque structure stores function pointers for EGL extension functions.
- * It is allocated at runtime by the API library. Vendor-provided dispatch
- * functions retrieve and operate on this structure using the API below.
- */
-typedef struct __EGLvendorInfoRec __EGLvendorInfo;
-
-/****************************************************************************
- * API library exports                                                      *
- ****************************************************************************/
-
-typedef struct __EGLapiExportsRec {
-    /************************************************************************
-     * The following routines are used by vendor-implemented EGL dispatch
-     * functions to lookup and call into the right vendor.
-     ************************************************************************/
-
-    /*!
-     * This function must be called at the start of every EGL dispatch stub. It
-     * performs any necessary per-call bookkeeping.
-     */
-    void (* threadInit) (void);
-
-    EGLenum (* getCurrentApi)(void);
-
-    /*!
-     * This function retrieves the appropriate current dynamic dispatch table,
-     * if a GL context is current. Otherwise, this returns NULL.
-     */
-    __EGLvendorInfo *(*getCurrentVendor)(void);
-
-    /*!
-     * This retrieves the current context for this thread.
-     */
-    EGLContext (*getCurrentContext)(void);
-
-    /*!
-     * Returns the current display for this thread.
-     */
-    EGLDisplay (*getCurrentDisplay)(void);
-
-    /*!
-     * Returns the current drawable for this thread.
-     */
-    EGLSurface (*getCurrentSurface)(EGLint readDraw);
-
-    /*!
-     * This function retrieves an entry point from the dynamic dispatch table
-     * given an index into the table.
-     */
-    __eglMustCastToProperFunctionPointerType (*fetchDispatchEntry) (__EGLvendorInfo *dynDispatch, int index);
-
-    /*!
-     * Sets the last error for the current thread. The error will be returned
-     * the next time the app calls eglGetError().
-     *
-     * This function will override a call to \c setLastVendor, and vice-versa.
-     */
-    void (* setEGLError) (EGLint errorCode);
-
-    /*!
-     * Notifies libEGL about the vendor library that an EGL function is
-     * dispatched to. This is used to look up the last EGL error code from a
-     * vendor.
-     *
-     * A vendor library may generate an EGL error asynchronously, if it
-     * offloads some EGL functions onto a worker thread. In that case, calling
-     * \c setEGLError to set the last error would not work.
-     *
-     * When an EGL dispatch stubs finds the vendor library, it must call this
-     * function before it dispatches the function call.
-     *
-     * This function will override a call to \c setEGLError, and vice-versa.
-     *
-     * \param vendor The vendor library of the current EGL function call.
-     * \return EGL_TRUE on success, or EGL_FALSE on failure.
-     */
-    EGLBoolean (* setLastVendor) (__EGLvendorInfo *vendor);
-
-    /************************************************************************
-     * These routines are used by vendor dispatch functions to look up
-     * and add mappings between various objects and vendors.
-     ************************************************************************/
-
-    // As far as I can tell, all EGL functions that take a context or drawable
-    // also take an EGLDisplay. So, we don't need any extra functions for
-    // mapping a context/surface/whatever to a EGLDisplay or vendor.
-
-    /*!
-     * Returns the EGL vendor for an EGLDisplay handle.
-     */
-    __EGLvendorInfo *(*getVendorFromDisplay)(EGLDisplay dpy);
-
-    /*!
-     * Returns the EGL vendor for an EGLDeviceEXT handle.
-     */
-    __EGLvendorInfo *(*getVendorFromDevice)(EGLDeviceEXT dev);
-
-    /**
-     * Sets the EGL vendor for an EGLDeviceEXT handle. The dispatch stub for
-     * any function that returns an EGLDeviceEXT handle should call this.
-     *
-     * Supported since ABI version 1.2.
-     */
-    EGLBoolean (* setVendorForDevice)(EGLDeviceEXT dev, __EGLvendorInfo *vendor);
-} __EGLapiExports;
-
-/*****************************************************************************
- * API library imports                                                       *
- *****************************************************************************/
-
-/*!
- * The enum values accepted by \c __EGLapiImports::getVendorString.
- */
-enum
-{
-    /*!
-     * The set of platform extensions that the vendor supports.
-     *
-     * Platform extensions typically just add enums to the existing
-     * eglGetPlatformDisplay function, so we don't need any additional logic
-     * or special handling from libEGL itself.
-     *
-     * As a result, vendor libraries can add these extensions without having
-     * to modify libEGL to match.
-     */
-    __EGL_VENDOR_STRING_PLATFORM_EXTENSIONS,
-};
-
-/*!
- * This structure stores required and optional vendor library callbacks.
- */
-typedef struct __EGLapiImportsRec {
-    /**
-     * Creates an EGLDisplay. This function is used to handle both
-     * \c eglGetDisplay and \c eglGetPlatformDisplay.
-     *
-     * For some platform types, libEGL may be able to identify a specific
-     * vendor to use.
-     *
-     * If libEGL can't figure out which vendor to use on its own, then it will
-     * go through the list of available vendor libraries and call this function
-     * until one succeeds.
-     *
-     * If the application calls eglGetPlatformDisplay, then the parameters are
-     * passed through from the application.
-     *
-     * If the application calls eglGetDisplay, and the native display handle is
-     * not \c EGL_DEFAULT_DISPLAY, then libEGL will try to guess a platform
-     * type, and will pass that platform to the vendor library.
-     *
-     * Lastly, if eglGetDisplay is called with \c EGL_DEFAULT_DISPLAY, then
-     * libEGL will call into each vendor library with \p platform set to
-     * \c EGL_NONE. The vendor library can then select a default display to
-     * return.
-     *
-     * In all cases, if the vendor library can't find a matching EGLDisplay,
-     * then it should return \c EGL_NO_DISPLAY. Any errors should be reported
-     * through the vendor's \c eglGetError function.
-     */
-    EGLDisplay (* getPlatformDisplay) (EGLenum platform, void *nativeDisplay,
-            const EGLAttrib *attrib_list);
-
-    /*!
-     * Checks if the vendor library supports a given client API (that is, the
-     * API value passed to \c eglBindAPI).
-     */
-    EGLBoolean (* getSupportsAPI) (EGLenum api);
-
-    /*!
-     * (OPTIONAL) Returns a string from the vendor library. This is used for
-     * anything that isn't available from eglQueryString.
-     */
-    const char * (* getVendorString) (int name);
-
-    /*
-     * NOTE: libEGL will load all of the vendor libraries up front, so it
-     * handles extension functions slightly differently than EGL.
-     */
-
-    /*!
-     * This retrieves the pointer to the real EGL or core GL function.
-     *
-     * \param procName The name of the function.
-     * \return A pointer to a function, or \c NULL if the vendor does not
-     * support the function.
-     */
-    void * (* getProcAddress) (const char *procName);
-
-    /*!
-     * This retrieves vendor-neutral functions which use the
-     * __EGLdispatchTableDynamic API above to dispatch to the correct vendor.
-     *
-     * A vendor library must provide a dispatch function for all EGL display
-     * extension functions that it supports.
-     *
-     * Client extension functions cannot be dispatched based on an EGDisplay,
-     * so they must be handled in libEGL itself.
-     *
-     * \param procName The name of the function.
-     * \return A pointer to a function, or \c NULL if the vendor does not
-     * support the function or \p procName is not a EGL display function.
-     */
-    void * (*getDispatchAddress) (const char *procName);
-
-    /*!
-     * This notifies the vendor library which dispatch table index is
-     * assigned to a particular EGL extension function.
-     */
-    void (*setDispatchIndex) (const char *procName, int index);
-
-    /*
-     * The vendor library may use the isPatchSupported, initiatePatch,
-     * releasePatch, and patchThreadAttach callbacks to re-write libglvnd's
-     * entrypoints at make current time, provided no other contexts are current
-     * and the TLS model supports this functionality. This is a performance
-     * optimization that may not be available at runtime; the vendor library
-     * must not depend on this functionality for correctness.
-     *
-     * To use this optimization, the vendor library must provide at least the
-     * isPatchSupported and initiatePatch entrypoints.
-     *
-     * Note that these functions are identical to the ones used in GLX.
-     */
-
-    /*!
-     * (OPTIONAL) Checks to see if the vendor library supports patching the
-     * given stub type and size.
-     *
-     * \param type The type of entrypoints. This will be a one of the
-     * __GLDISPATCH_STUB_* values.
-     * \param stubSize The maximum size of the stub that the vendor library can
-     * write, in bytes.
-     * \param lookupStubOffset A callback into libglvnd to look up the address
-     * of each entrypoint.
-     */
-    GLboolean (* isPatchSupported)(int type, int stubSize);
-
-    /*!
-     * (OPTIONAL) Called by libglvnd to request that a vendor library patch its
-     * top-level entrypoints.
-     *
-     * The vendor library should use the \p lookupStubOffset callback to find
-     * the addresses of each entrypoint.
-     *
-     * This function may be called more than once to patch multiple sets of
-     * entrypoints. For example, depending on how they're built, libOpenGL.so
-     * or libGL.so may have their own entrypoints that are separate functions
-     * from the ones in libGLdispatch.
-     *
-     * Note that during this call is the only time that the entrypoints can be
-     * modified. After the call to \c initiatePatch returns, the vendor library
-     * should treat the entrypoints as read-only.
-     *
-     * \param type The type of entrypoints. This will be a one of the
-     * __GLDISPATCH_STUB_* values.
-     * \param stubSize The maximum size of the stub that the vendor library can
-     * write, in bytes.
-     * \param lookupStubOffset A callback into libglvnd to look up the address
-     * of each entrypoint.
-     *
-     * \return GL_TRUE if the vendor library supports patching with this type
-     * and size.
-     */
-    GLboolean (*initiatePatch)(int type,
-                               int stubSize,
-                               DispatchPatchLookupStubOffset lookupStubOffset);
-
-    /*!
-     * (OPTIONAL) Called by libglvnd to notify the current vendor that it no
-     * longer owns the top-level entrypoints.
-     *
-     * Libglvnd will take care of the restoring the entrypoints back to their
-     * original state. The vendor library must not try to modify them.
-     */
-    void (*releasePatch)(void);
-
-    /*!
-     * (OPTIONAL) Called at the start of window-system functions (GLX and EGL).
-     * This callback allows vendor libraries to perform any per-thread
-     * initialization.
-     *
-     * This is basically a workaround for broken applications. A lot of apps
-     * will make one or more invalid GLX/EGL calls on a thread (often including
-     * a MakeCurrent with invalid parameters), and then will try to call an
-     * OpenGL function.
-     *
-     * A non-libglvnd-based driver would be able to initialize any thread state
-     * even on a bogus GLX call, but with libglvnd, those calls wouldn't get
-     * past libGLX.
-     *
-     * This function is optional. If it's \c NULL, then libGLdispatch will
-     * simply ignore it.
-     *
-     * \note This function may be called concurrently from multiple threads.
-     */
-    void (*patchThreadAttach)(void);
-
-    /*!
-     * (OPTIONAL) Tries to determine the platform type for a native display.
-     *
-     * If the vendor library provides this function, then libglvnd will call it
-     * to determine which platform to use for a native display handle in
-     * eglGetDisplay.
-     *
-     * If no vendor library identifies the platform, then libglvnd will fall
-     * back to its own platform detection logic.
-     *
-     * Libglvnd can call this function for any native display handle except
-     * \c EGL_DEFAULT_DISPLAY.
-     *
-     * No matter what the value of \p native_display, the vendor library must
-     * not crash, and must not return a false match. If the vendor library
-     * can't identify the display, then it must return \c EGL_NONE.
-     *
-     * In particular, that means that a vendor library must not return any sort
-     * of default or fallback platform.
-     *
-     * \param native_display The native display handle passed to eglGetDisplay.
-     * \return Either a platform type enum or EGL_NONE.
-     */
-    EGLenum (* findNativeDisplayPlatform) (void *native_display);
-} __EGLapiImports;
-
-/*****************************************************************************/
-
-#define __EGL_MAIN_PROTO_NAME "__egl_Main"
-
-typedef EGLBoolean (* __PFNEGLMAINPROC) (uint32_t version, const __EGLapiExports *exports,
-        __EGLvendorInfo *vendor, __EGLapiImports *imports);
-
-/*!
- * Vendor libraries must export a function called __egl_Main() with the
- * following prototype.
- *
- * This function also performs a handshake based on the ABI version number.
- * Vendor libraries can optionally use the version number to support older
- * versions of the ABI.
- *
- * \param[in] version The ABI version. The upper 16 bits contains the major version
- * number, and the lower 16 bits contains the minor version number.
- *
- * \param[in] exports The table of functions provided by libEGL. This pointer will
- * remain valid for as long as the vendor is loaded.
- *
- * \param[in] vendor The opaque pointer used to identify this vendor library. This
- * may be used in future versions to provide additional per-vendor information.
- *
- * \param[out] imports The function table that the vendor library should fill
- * in. The vendor library must assign every non-optional function in the
- * struct.
- *
- * \return True on success. If the vendor library does not support the
- * requested ABI version or if some other error occurs, then it should return
- * False.
- */
-EGLBoolean __egl_Main(uint32_t version, const __EGLapiExports *exports,
-        __EGLvendorInfo *vendor, __EGLapiImports *imports);
-
-/*!
- * @}
- */
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif /* __LIB_EGL_ABI_H */

MobileGL/Config.h

@@ -14,735 +14,8 @@ 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, 9, 0, "-dev", VersionType::Development};
+    inline const Version CoreVersion = {26, 2, 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"
-    // (case-insensitive).
-    //
-    // Env variables intentionally NOT mirrored here (kept as live std::getenv at their
-    // call sites):
-    //   - 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).
-    struct FeaturesTable {
-        // MOBILEGL_DISABLE_TIMERQUERY: do not advertise or use GPU timer queries.
-        Bool DisableTimerQuery = false;
-        // MOBILEGL_ESPRYT_ENABLE_TEXTURE_VIEW: advertise GL_ARB_texture_view on DirectGLES when
-        // the host ES driver has EXT/OES_texture_view. Off by default: the host extension is
-        // present on Adreno 830 and the functional half of KHR-GL4{2,3}.texture_view still fails
-        // there, because the view's ES internalformat is normalized independently of the storage
-        // it aliases (see BackendObject_DirectGLES::BuildAdvertisedExtensions). The flag exists
-        // so that work can be done without editing the gate.
-        Bool EsprytEnableTextureView = false;
-        // MOBILEGL_ENABLE_SPIRV_VALIDATION: validate generated and transformed SPIR-V.
-        // Disabled by default because validation is a diagnostics-only cost.
-        Bool EnableSpirvValidation = false;
-        // MOBILEGL_ESPRYT_USE_ANGLE: load ANGLE EGL/GLES libraries.
-        Bool EsprytUseAngle = false;
-#if defined(MOBILEGL_TRACE_ANGLE_VARIANTS)
-        // MOBILEGL_TRACE_ANGLE_VARIANT: signed trace-APK ANGLE build short hash.
-        String TraceAngleVariant;
-#endif
-        // MOBILEGL_MAGMA_DISABLE_SUBGROUP: force-disable Vulkan shader subgroup support,
-        // including the opt-in emulated compute path below.
-        Bool MagmaDisableSubgroup = false;
-        // MOBILEGL_MAGMA_EMULATE_SUBGROUP: implement GL_KHR_shader_subgroup's compute
-        // stage on a 32-lane VIRTUAL subgroup lowered to workgroup-shared memory
-        // (ShaderTranspiler::EmulateSubgroupsPass). Strictly a last resort: it only ever
-        // engages when this flag is set AND the device has no native subgroup support at
-        // all - a device with real subgroup operations always uses them natively,
-        // whatever their width (the known iterationRP defect is patched by
-        // MagmaFixIterationRPSubgroupScratch below instead). Off by default.
-        Bool MagmaEmulateSubgroup = false;
-        // MOBILEGL_MAGMA_FIX_ITERATIONRP_SUBGROUP_SCRATCH: patch iterationRP's own bug - the
-        // pack declares `shared vec2 prefixSumCache[32]` for a 512-invocation exposure
-        // reduction and indexes it by gl_SubgroupID, so any device with sub-16-lane
-        // subgroups (8-lane lavapipe -> 64 subgroups) writes shared memory out of
-        // bounds. The pass grows that one array to what the device's topology needs and
-        // touches nothing else; it only rewrites modules positively matching the pack's
-        // reduction fingerprint (ShaderTranspiler::FixIterationRPSubgroupScratchPass),
-        // so every other shader passes through byte-identical - as does iterationRP
-        // itself on >= 16-lane devices. Auto is ON; ForceOff replays the pack's bug
-        // verbatim.
-        QuirkOverride MagmaFixIterationRPSubgroupScratch = QuirkOverride::Auto;
-        // MOBILEGL_MAGMA_ITERATIONRP_FIX_BARRIER: repair Program 203's missing workgroup
-        // rendezvous between its two reductions over prefixSumCache. Off by default and
-        // fingerprint-gated by FixIterationRPBarrierPass when enabled.
-        Bool MagmaIterationRPFixBarrier = false;
-        // MOBILEGL_MAGMA_DERIVE_NUM_SUBGROUPS: replace compute gl_NumSubgroups loads with
-        // ceil(workgroup invocations / gl_SubgroupSize) on the NATIVE subgroup path
-        // (ShaderTranspiler::DeriveNumSubgroupsPass). Auto is ON: GL requires
-        // gl_SubgroupID < gl_NumSubgroups, Adreno's builtin reports 1 while the same
-        // dispatch emits IDs 0..7, and the derived value is the one Vulkan guarantees
-        // whenever the pipeline can request REQUIRE_FULL_SUBGROUPS (which the renderer
-        // does whenever local_size_x is a multiple of the native width). ForceOff returns
-        // to the raw driver builtin.
-        QuirkOverride MagmaDeriveNumSubgroups = QuirkOverride::Auto;
-        // MOBILEGL_ADVERTISE_FP64: add GL_ARB_gpu_shader_fp64 to the advertised extension
-        // string. `double` in a shader always WORKS - it is narrowed to 32 bits before any
-        // module reaches a backend (ShaderTranspiler::DemoteFloat64Pass) - but the extension
-        // promises 64-bit precision, and that is the one thing the narrowing cannot deliver.
-        // Off by default so an application that checks the string before using doubles keeps
-        // its float path; on for measuring what the conformance suite makes of the demoted
-        // precision. See the DemoteFloat64Pass header and the "fp64" POST row.
-        Bool AdvertiseFp64 = false;
-        // MOBILEGL_MAGMA_R11G11B10F_FALLBACK: use fallback format for R11G11B10F on Vulkan.
-        Bool MagmaR11G11B10FFallback = false;
-        // MOBILEGL_MAGMA_FRAMESINFLIGHT: requested Magma frames in flight, defaulting to 3.
-        Uint32 MagmaFramesInFlight = 3;
-        // MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER: GL draws and dispatches Magma records into
-        // one command buffer before it submits it and continues on a fresh one. 0 = unbounded.
-        // Drivers back a command buffer with GPU memory that is only returned when the buffer is
-        // freed; Adreno maps it into the process in 16 KiB chunks, so one ~1M-draw loading frame
-        // exhausts vm.max_map_count. See VulkanRenderer::SplitOversizedRecording.
-        Uint32 MagmaMaxDrawsPerCommandBuffer = 16384;
-        // MOBILEGL_MAGMA_DESCRIPTOR_TRIM_FRAMES: how many consecutive frames (strictly, BeginFrame
-        // epochs) a frame slot's descriptor pools must stay under a quarter full before Magma
-        // hands the slot's whole set cache back and lets it re-grow. 0 = never trim. A loading
-        // frame otherwise keeps its burst of sets (rd12: ~15k, where steady frames use a few dozen)
-        // for the life of the process. See UniformManager::TrimFrameDescriptorPools.
-        Uint32 MagmaDescriptorTrimFrames = 120;
-        // MOBILEGL_ESPRYT_AVOID_SAMPLER_MIPMAP_MIN_FILTER: avoid mipmap min filters in samplers,
-        // resolves certain rendering bugs on ANGLE + llvmpipe.
-        Bool EsprytAvoidSamplerMipmapMinFilter = false;
-        // MOBILEGL_ESPRYT_AVOID_EXPLICIT_LOD_BIAS: leave an already-explicit LOD argument alone when
-        // emulating GL_TEXTURE_LOD_BIAS, instead of adding the bias uniform to it. Injecting
-        // the uniform turns a compile-time-constant LOD into a runtime expression, which
-        // sends ANGLE + llvmpipe down a mip-selection path that dereferences a NULL
-        // descriptor and kills the process. Deviates from spec (Vulkan adds the bias to
-        // OpImageSampleExplicitLod), so it is an avoidance for that stack only.
-        Bool EsprytAvoidExplicitLodBias = false;
-        // MOBILEGL_ESPRYT_UNLOCATED_IO_BLOCKS: emit a tessellation/geometry program's
-        // inter-stage interface blocks WITHOUT their layout(location=) qualifier, letting ES
-        // match them by block name and member sequence instead. The Mali ES driver delivers
-        // nothing at all through a located block once a tessellation or geometry stage is in
-        // the pipeline; the driver POST measures that and turns this on by itself, so Auto is
-        // the right setting everywhere. ForceOn exists so the emulation can be exercised on a
-        // healthy driver - which is what the integration lane does, since llvmpipe and
-        // lavapipe carry a located block correctly and would otherwise never run this code -
-        // and ForceOff is the negative control. See StripIoBlockLocationsPass.
-        QuirkOverride EsprytUnlocatedIoBlocks = QuirkOverride::Auto;
-        // MOBILEGL_POINT_SIZE_DEMOTION: demote gl_PointSize out of tessellation/geometry
-        // stages into an ordinary varying (ShaderCompiler::
-        // DemoteTessellationGeometryPointSizeForProgram) instead of declining such programs
-        // on a device that advertises neither EXT/OES_tessellation_point_size /
-        // geometry_point_size (DirectGLES) nor shaderTessellationAndGeometryPointSize
-        // (DirectVulkan). Auto arms it exactly where the detection says the capability is
-        // absent, which is the right setting everywhere. ForceOn exists so the demotion can
-        // be exercised on a healthy driver - llvmpipe and lavapipe host the built-in
-        // natively and would otherwise never run this code, which is what the pinned
-        // integration lane uses - and ForceOff restores the plain declines (escape hatch /
-        // negative control). Cross-backend by design: the demotion runs in the shared
-        // phase-B chain, so one switch covers both. See DemotePointSizePass.
-        QuirkOverride PointSizeDemotion = QuirkOverride::Auto;
-        // 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
-        // semantics: writes reach the backend without glFlushMappedBufferRange, and
-        // flush calls on rewritten maps become error-free no-ops. Non-persistent maps
-        // keep spec FLUSH_EXPLICIT behavior.
-        Bool CoherentAsFlush = false;
-        // MOBILEGL_TRACE_SKIP_AUTODESTROY: skip teardown in the ELF destructor (Init.cpp).
-        Bool TraceSkipAutodestroy = false;
-        // MOBILEGL_ESPRYT_DISABLE_UBO_RING: force the DirectGLES global-UBO upload back to the
-        // per-draw glBufferSubData path instead of the persistent-mapped ring allocator
-        // (negative control / driver-bug escape hatch).
-        Bool EsprytDisableUboRing = false;
-        // MOBILEGL_ESPRYT_DISABLE_UNPACK_RING: force DirectGLES texture uploads back to
-        // glTexSubImage from the client pointer instead of staging them through the
-        // persistent-mapped unpack-PBO ring (negative control / driver-bug escape
-        // hatch).
-        Bool EsprytDisableUnpackRing = false;
-        // MOBILEGL_ESPRYT_DISABLE_UPLOAD_RING: force DirectGLES app buffer updates
-        // (glBufferSubData / map flushes) back to the immediate driver upload instead
-        // of queueing them for the staged-copy flush through the persistent-mapped
-        // upload ring (negative control / driver-bug escape hatch; the immediate
-        // upload stalls on drivers that resolve the WAR hazard on the CPU, e.g. Mali).
-        Bool EsprytDisableUploadRing = false;
-        // MOBILEGL_ESPRYT_DISABLE_INVALIDATE_FLUSH: skip the glMapBufferRange(WRITE |
-        // INVALIDATE_RANGE) tier of the DirectGLES pending-range flush and go straight
-        // to the upload ring's staged glCopyBufferSubData (negative control / escape
-        // hatch for a driver whose range-invalidating map misbehaves). The map tier is
-        // what keeps a partial write into a large in-flight buffer priced by the RANGE:
-        // on Mali both the immediate glBufferSubData and a staged copy into a busy
-        // mutable store ghost the whole destination on the CPU.
-        Bool EsprytDisableInvalidateFlush = false;
-        // MOBILEGL_DISABLE_LARGE_BUFFER_ADOPTION: keep mesh-arena-sized buffer stores
-        // (>= 16MiB) on the CPU-shadow model instead of backing them with the backend's
-        // persistently+coherently mapped storage at definition time (negative control /
-        // escape hatch). Frontend-scoped: it engages only where the active backend
-        // provides AcquirePersistentMap. With adoption on, an app SubData into a busy
-        // 128MB arena lands GPU-ordered through the backend's resident-subdata op
-        // (BufferObject::LandBytesIntoResidentStore, since 0ee3384b: an in-place write
-        // tore the frames still reading the old bytes) - still no driver-mediated write
-        // into the busy mutable store, which on this class of Mali driver stalls the
-        // thread or ghost-copies the whole arena, and the arena stops costing its size
-        // again in RAM.
-        Bool DisableLargeBufferAdoption = false;
-        // MOBILEGL_ESPRYT_FORCE_DS_READBACK_EMULATION: make DirectGLES skip the native ES
-        // depth/stencil reads and always go through the shader-sampling emulation. Core GL
-        // ES has no depth or stencil readback, but some drivers accept it anyway (Mesa does,
-        // Adreno does not), which means the emulation is dead code on exactly the stack the
-        // headless suite runs on. This forces it live so the scenarios and the CTS can
-        // exercise the path, and gives the device an A/B lever over the same choice.
-        Bool EsprytForceDepthStencilReadbackEmulation = false;
-        // 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_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_MAGMA_DISABLE_ROBUST_BUFFER_ACCESS: leave the Vulkan robustBufferAccess device
-        // feature off. It is enabled by default to match GL's defined out-of-range fetch
-        // behavior; this escape hatch exists to measure or dodge its GPU cost on a device.
-        Bool MagmaDisableRobustBufferAccess = false;
-        // 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;
-        // MOBILEGL_SHADER_CACHE: the three-level, in-memory shader translation memo
-        // (MG_Util/ShaderTranspiler/TranslationCache.h). The levels follow the GL
-        // entry points - L1c memoizes one glCompileShader's PARSE VERDICT, L1 a
-        // linked program's whole front end, L2 DirectGLES's emitted ESSL. Auto is
-        // ON; ForceOff turns ALL THREE off and makes every translation run from
-        // scratch. The escape hatch exists because a wrong cache hit is a silently
-        // miscompiled shader: if a device ever renders differently with the cache
-        // on, one run with this falsy says so.
-        QuirkOverride ShaderTranslationCache = QuirkOverride::Auto;
-        // MOBILEGL_ESPRYT_FORCE_VIEWPORT_ARRAY_EMULATION: DirectGLES' gl_ViewportIndex routing
-        // emulation - the builtin becomes a flat varying, the fragment stage gets a
-        // per-pass gate, and a routed draw is REPLAYED once per distinct viewport state
-        // with the real glViewport/glScissor/glDepthRangef set for it. Auto is ON, and
-        // it is ON even where the driver advertises GL_OES_viewport_array, because that
-        // extension only ever gave the SHADER a compilable name: MobileGL has never
-        // programmed a driver's INDEXED viewport state (SyncRenderState pushes index 0
-        // and nothing else), so on an extension-capable driver every index rasterized as
-        // index 0 exactly as it did without one. ForceOff returns to that behaviour -
-        // the pre-emulation path, extension passthrough where it exists and
-        // LowerViewportIndexPass' demote-to-a-plain-global where it does not - and is
-        // the negative control the emulation is measured against.
-        QuirkOverride EsprytViewportArrayEmulation = QuirkOverride::Auto;
-        // MOBILEGL_ESPRYT_WIDEN_PACKED16_STORAGE: DirectGLES stores GL_RGB565/GL_RGB5(A1)/GL_RGBA4
-        // images as 8-bit-per-channel ES storage (GL_RGB8/GL_RGBA8) instead of the driver's
-        // native 16-bit packed formats. Auto defers to a POST driver-bug probe
-        // (SelfTest::CopyImageMirrorsPacked16FieldOrder): some Mali drivers store SOME
-        // packed16 allocations with a MIRRORED field order (allocation-scoped and
-        // shape/context dependent - the failing 30x30x12 GL_TEXTURE_2D_ARRAYs are mirrored
-        // at every level), so glCopyImageSubData - a raw texel-block move - lands R/G/B/A
-        // reversed whenever exactly one endpoint sits in a mirrored allocation
-        // (KHR-GL4x.copy_image.functional rgb5/rgb5_a1/rgba4 x every *2d_array* pair).
-        // With no 16-bit packed ES image left there is no field order to disagree about; the
-        // client word still round-trips exactly, because the canonical shadow is already
-        // UNorm8 and an n-bit field encodes to UNorm8 and back losslessly for n <= 8.
-        // ForceOn widens on any driver (the llvmpipe suites use it to exercise the widened
-        // path); ForceOff keeps the native narrow storage even where the probe fires - the
-        // negative control that replays the corruption. Costs 2x the memory of the affected
-        // formats where it engages, which is why Auto is probe-gated rather than always-on.
-        QuirkOverride EsprytWidenPacked16Storage = QuirkOverride::Auto;
-        // MOBILEGL_MAGMA_PRIMGEN_QUERY_REROUTE: DirectVulkan's GL_PRIMITIVES_GENERATED
-        // reroute for draws made while transform feedback is INACTIVE. The stream query
-        // (VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT primitivesNeeded) is defined to count
-        // them, but a Mali driver - and Mesa lavapipe - answers 0 unless a capture span is
-        // open, which is exactly the shape the CTS uses to measure the tessellator, so ~29
-        // tessellation tests per tree size a capture buffer from the 0 and die on the
-        // zero-length map. Auto defers to a device probe at renderer bring-up
-        // (SelfTest::RunPrimitivesGeneratedNoXfbProbe), which measures two substitutes on
-        // the same capture-less draws and arms the best proven one: the dedicated
-        // VK_EXT_primitives_generated_query (exact semantics by definition; lavapipe passes
-        // it, rasterizer discard included), else a clipping-invocations pipeline-statistics
-        // pool (see the verdict vocabulary for its rasterizer-discard split). ForceOn pins
-        // the reroute structurally wherever a pool can exist (the arming-observable lane,
-        // immune to the probe's verdict moving), and ForceOff is the negative control that
-        // replays the driver's silence.
-        QuirkOverride MagmaPrimGenQueryReroute = QuirkOverride::Auto;
-        // --- MGPipe (the disaggregation plan's explicit frontend/backend boundary) ---
-        // MOBILEGL_PIPE_PUSH: per-subsystem bitmask selecting which state the frontend
-        // PUSHES over MGPipe instead of leaving the backend to pull it out of GLContext.
-        // 0 - the only shipped value until the migration lands - is "pull everything",
-        // i.e. exactly today's behaviour, and is the default of a PULL build, where the
-        // knob is meaningless anyway. A PUSH build defaults to every subsystem migrated so
-        // far (MG_Pipe::kMGPipeSubsystemsMigratedAtP5e = 0x3fff), so MOBILEGL_PIPE_PUSH=0 in
-        // the environment is the all-pull control and 0x1fff (kMGPipeSubsystemsMigratedAtP4a)
-        // is the "everything before P5e" control P5e's A/B is run against - each phase's
-        // constant survives as the next phase's control, which is why none of them is ever
-        // edited. Accepts decimal or 0x-prefixed hex, and operators pass it as hex, so the
-        // bits are listed here (MG_Pipe/MGPipe.h owns them):
-        //   0x01 render state (create/bind_render_state + set_dynamic_state)
-        //   0x02 pixel pack        0x04 patch state      0x08 vertex attrib defaults
-        //   0x10 residual values   0x20 Espryt slots     0x40 Magma vertex input
-        //   0x80 resources (the resource_* family: the seven BufferBackendOps hooks)
-        //   0x100 vertex input (vertex elements / vertex buffers / index buffer)
-        //   0x200 framebuffer (set_framebuffer_state)              - requires 0x400
-        //   0x400 texture resources (texture + renderbuffer resource_*,
-        //         set_texture_params)                              - requires 0x80 AND 0x800
-        //         (the built-in sampler CSO a set_texture_params record names is minted by
-        //         the sampler family alone, ID-15; the four rows are MG_Impl/Pipe/PipeFill.cpp's
-        //         kMGPipeP4aFamilyDependencies, mirrored bit for bit by Espryt's resolvers)
-        //   0x800 samplers (sampler CSO, sampler view, set_sampler_views /
-        //         bind_sampler_states / set_shader_images)         - requires 0x400
-        //   0x1000 programs (shader CSO, set_draw/dispatch_program, global constants)
-        //   0x2000 buffer binding points (set_shader_buffers, the three indexed binding-point
-        //         classes and the dirty bits 15/16/17)             - requires 0x80
-        //         (every MGPBufferRange::Res names a Buffer handle; P5e)
-        //   A dependency that is not met is REFUSED with one ERROR naming both bits and the
-        //   family runs its legacy arm; it is never half-run.
-        //   1<<63 NOT a subsystem, a BEHAVIOUR: turn OFF client-side content addressing of
-        //         CSOs, so every pipeline-version change mints a fresh CSO and the map is
-        //         never probed. The negative control the CSO design is measured against.
-        Uint64 PipePush = 0;
-        // MOBILEGL_PIPE_VERIFY: per-draw, per-FIELD shadow comparison of the pushed state
-        // against a snapshot taken from GLContext the old way, printing the first field
-        // that differs and the draw serial. Roughly 5-10x slower and never shipped; it is
-        // the semantic gate that replaces byte identity, and it catches the dangerous
-        // direction - a dirty bit that fires too RARELY - which no purity gate can see.
-        Bool PipeVerify = false;
-#if MOBILEGL_PIPE_PUSH
-        // The three knobs of the MOBILEGL_PIPE_VERIFY build (P1 brief D2). Compiled only
-        // under MOBILEGL_PIPE_PUSH so the pull build's FeaturesTable does not change size.
-        // MOBILEGL_PIPE_VERIFY_FATAL: the first divergence aborts (default). 0 logs and
-        // counts instead, for triage and for the lane that must survive to read its own
-        // log. Tri-state parse like PipeLegacyMemos: only an explicit falsy value turns it
-        // off.
-        Bool PipeVerifyFatal = true;
-        // MOBILEGL_PIPE_VERIFY_CORRUPT: a field name from kMGPipeInputFieldNames[]; the
-        // comparator perturbs that field in the SNAPSHOT arm before the entry compare, so a
-        // green verify run goes red naming it (negative control A). Unknown name is
-        // Fatal{PipeVerifyBadKnob}.
-        String PipeVerifyCorrupt;
-        // MOBILEGL_PIPE_POISON_OMIT: <Verb>:<FieldName>; the filler skips the STAMP (not
-        // the value) of that field for that verb, an omission indistinguishable from a
-        // forgotten FillPoints.def row, so that verb's read of it is
-        // Fatal{UnmigratedPipeInput} (negative control B). Unknown name is
-        // Fatal{PipeVerifyBadKnob}.
-        String PipePoisonOmit;
-        // MOBILEGL_PIPE_HANDLE_ABA_CONTROL (negative control C, P2 brief D18): replace the
-        // OBJECT IDENTITY in every DirectVulkan vertex-input memo key with a constant, on
-        // whichever arm the run is on - the pre-handle (address, lifetime id) pair AND the
-        // handle arm's {slot, gen} generation - so a replacement object inherits its dead
-        // predecessor's resolved vertex bindings and HandleRecycleScenario.AbaControl asserts
-        // the WRONG pixels. That is what proves the reproducer still reproduces. D18 wrote
-        // this as "hash the raw BufferObject* instead of its lifetime id"; measured, the heap
-        // block is never handed back, so that spelling collided with nothing and the control
-        // went vacuous - see MagmaPipeArms.h's MagmaPipeAbaControlDefeatsIdentity for the
-        // measurement and for what the control still leaves standing. Under
-        // MOBILEGL_PIPE_PUSH only, so it cannot exist in a shipping pull build.
-        Bool PipeHandleAbaControl = false;
-#endif
-        // MOBILEGL_PIPE_STATS: dump the boundary counters (bytes, calls, roundtrips,
-        // texture pulls, upload shapes, residual-block bytes, index mirror bytes).
-        Bool PipeStats = false;
-        // MOBILEGL_PIPE_LEGACY_MEMOS: keep the pre-handle registries and TwinLookupMemos
-        // alive so the first handle waves have a real old-versus-new arm to be compared
-        // against. ON by default for the whole migration window, deleted with the pull
-        // path itself.
-        Bool PipeLegacyMemos = true;
-        // MOBILEGL_PIPE_TEXEL_RETAIN_MB: LRU budget for texels retained against a
-        // server-initiated texture re-send. Default 0, i.e. OFF: MipmapStorage already
-        // holds a complete CPU shadow, so this cache buys latency, never correctness.
-        Uint32 PipeTexelRetainMb = 0;
-        // MOBILEGL_PIPE_INDEX_MIRROR_MB: budget for the server-side index host mirror,
-        // which is what lets primitive-restart rewriting and multi-draw flattening stay on
-        // the server without shipping index bytes per draw. Over budget it degrades to
-        // per-draw staging, counted separately in the stats.
-        Uint32 PipeIndexMirrorMb = 64;
-        // MOBILEGL_PIPE_STATS_PERIOD: frames per boundary-counter summary line. 120 is the
-        // steady-state cadence; the device retrace harness never reaches the teardown dump
-        // and a trimmed fixture (create-indirect) is shorter than 120 frames, so a run that
-        // needs its numbers at all sets this low enough to land at least one window.
-        Uint32 PipeStatsPeriod = 120;
-        // MOBILEGL_PIPE_STATS_FILE: where the boundary counters' teardown JSON dump goes.
-        // Empty (the default) means no dump; the per-120-frame summary line still goes to
-        // the log whenever PipeStats is on, so a device run needs no writable path.
-        String PipeStatsFile;
-    };
-    extern FeaturesTable Features;
-
-    // ---------------------------------------------------------------------------------
-    // P5: the transport selector and the MOBILEGL_IPC_* family (ARCHITECTURE.md 16, 附 A)
-    // ---------------------------------------------------------------------------------
-    //
-    // MOBILEGL_TRANSPORT = monolith | inproc | spawn | unix:<path> | pipe:<name>.
-    //
-    // WHY `Transport` IS NOT A FeaturesTable MEMBER. ARCHITECTURE.md:580 requires that with
-    // MOBILEGL_BUILD_DISAGGREGATED=OFF it be a `constexpr Monolith`, so that the single hook
-    // in MG_Backend/Init.cpp compiles away entirely rather than becoming a branch nobody can
-    // take. A FeaturesTable member is a runtime field in every build, which is the opposite
-    // of that; it would also resize MG_Config::Features and break G1 (the pull build's
-    // symbol set must not move) for the same reason the MOBILEGL_PIPE_VERIFY knobs above sit
-    // behind their own #if.
-    //
-    // ONE CONSEQUENCE, STATED SO IT IS NOT REDISCOVERED: in a build without the option,
-    // MOBILEGL_TRANSPORT=inproc is ACCEPTED BY THE ENVIRONMENT AND SILENTLY IGNORED - the
-    // parser below does not exist to complain about it, and putting a complaint in the
-    // unconditional part of ConfigLoader would move a pull-build symbol. That is the exact
-    // shape of "the split lane ran monolith and went green", so the gate against it is a
-    // BUILD-level check, not a runtime one: `nm --defined-only libMobileGL.so | grep -i
-    // MG_Remote` must be non-empty in build-split (CONTRACT-P5.md table 3, and the CI job
-    // P5 adds beside build-linux-verify).
-    enum class TransportMode : Uint8 {
-        Monolith = 0,  // today's in-library backend; no MG_Remote object is constructed
-        InProcess = 1, // P5: a real apply thread in this process, over the same G3 codec
-        Spawn = 2,     // P6: fork/exec MobileGLServer, socketpair
-        UnixSocket = 3,// P6: connect to an existing AF_UNIX endpoint (Endpoint = <path>)
-        NamedPipe = 4, // P6: Windows named pipe (Endpoint = <name>)
-    };
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // Parsed once by MG_ConfigLoader::Init(). Defaults to Monolith even here: building the
-    // transport in is not the same as using it, and every existing lane of a build-split
-    // must keep running monolith unless it is asked for one.
-    extern TransportMode Transport;
-    // The <path> of `unix:` / the <name> of `pipe:`. Empty for the other three modes.
-    extern String TransportEndpoint;
-
-    // P7 F1. DID **THIS PROCESS'S OWN CONFIGURATION** ASK FOR A SPLIT TRANSPORT.
-    //
-    // `Transport` alone cannot answer that, and the difference is exactly the one the F1 gate
-    // turns on. A unit fixture assigns `Transport` by hand to put the code under test on its
-    // split arm (ServerLoopTest's main does, and says why) while building no client at all; a
-    // real run gets it from MG_ConfigLoader::Init(), and that run WILL bring a client half up.
-    // Only the second may be held to "never decide a record family's fate from a placeholder
-    // caps mirror" - in the first there is no handshake, no mirror to adopt and nothing the
-    // rule could mean.
-    //
-    // Written once, by InitTransport(), and never cleared: a process does not stop having been
-    // configured. Read by MG_Remote::Client::CapsMirror::RequireFirstSnapshot.
-    extern Bool SplitTransportRequestedByConfig;
-
-    // The MOBILEGL_IPC_* family. A separate table rather than more FeaturesTable members,
-    // for the G1 reason above and because every field here is meaningless without the
-    // transport: a build that cannot reach the MG_Remote code cannot honour one of them.
-    //
-    // P5 lands exactly the knobs P5's own packages read. A later phase's knob is added HERE,
-    // through the integrator, and not invented at its call site - ARCHITECTURE.md:615 holds
-    // the full planned inventory (PRESENT_CREDIT, POLL_ESCALATE, SHADOW_SHM,
-    // INLINE_PAYLOADS, TRACE, ATTACH, RESPAWN, IDLE_EXIT_S), and every one of those belongs
-    // to P6 or later.
-    //
-    // P12 (on-screen server window): MOBILEGL_IPC_SURFACE's two values. See IpcTable::Surface.
-    enum class IpcSurface : Uint8 {
-        Offscreen = 0, // a window surface is the client's own window, as before (the default)
-        Server = 1,    // a window surface is the SERVER's window: WindowKind::ServerOwned
-        Host = 2,      // a window surface draws into frames the DISPLAY HOST owns; the host presents
-    };
-    // IpcTable::AdoptTier when MOBILEGL_IPC_ADOPT_TIER is unset (or unparseable): T0 by default,
-    // with QUIET fallbacks. Not a tier a user can type - the knob admits 0..2.
-    inline constexpr Uint32 kAdoptTierUnset = 3;
-    struct IpcTable {
-        // MOBILEGL_IPC_SERVER_PATH: where to find libMobileGLServer. P6 consumes it; P5
-        // lands the parse because t1's ctest ENVIRONMENT blocks and add_trace_replay_test's
-        // SPLIT variant already carry it, and an environment variable that nothing parses is
-        // indistinguishable from one that is parsed and ignored.
-        String ServerPath;
-        // Control endpoint and data-plane selection are independent of topology.
-        String Control = "fork"; // fork | unix:<path> | tcp://host:port
-        String Data = "auto";    // auto | shm | stream
-        // MOBILEGL_IPC_RING_MB: SEG_CMD size. A RECORD MAY BE AT MOST HALF OF THIS
-        // (RingProducer::MaxRecordBytes), so 8 MiB caps one record at 4 MiB; R-10 makes the
-        // codec publish a max-record-bytes counter rather than assume that is enough.
-        Uint32 RingMb = 8;
-        // MOBILEGL_IPC_STAGE_MB: SEG_STAGE size. Every blob and every var-tail's bytes live
-        // here ONE BLOB AT A TIME: a row whose content can outgrow the segment cuts it at the
-        // stage chunk budget (MGPipeStageChunkBytes, a quarter of this), and a record type with
-        // no cut is Fatal{RingOverrun, "SEG_STAGE"} rather than allowed to exceed it.
-        Uint32 StageMb = 32;
-        // MOBILEGL_IPC_WIRE_DEFERRED_MB (P7 wave 4 M2, ID-P7-32): the SERVER's budget, in MiB,
-        // for orphaned wire buffer stores - the old VkBuffer every glBufferData that crosses the
-        // wire leaves behind - that a GPU command recorded but not yet retired may still name.
-        // Stores no command names are destroyed at once and stores whose last submission has
-        // retired are destroyed at the next park; this bounds the REST. When the parked bytes
-        // exceed it after a sweep, the server flushes what it has recorded and waits for it
-        // (WaitForWireBufferHostAccess's sync point, mid-frame), which retires every one. It is
-        // not a frame count because a frame is not bounded: a snapshot-exiting pbuffer replay
-        // delivers one present for 1.3 M calls. The same sync point also fires above a fixed
-        // 1024 parked stores (VkBufferManager::kWireDeferredCountCeiling), because small
-        // orphans never reach a byte budget. 0 IS THE NEGATIVE CONTROL for both, not "unlimited
-        // by design": no forced sync, so a one-frame respecify-and-draw loop grows without bound
-        // and MagmaWireReclaimScenario's watermark cases must go red.
-        Uint32 WireDeferredMb = 64;
-        // MOBILEGL_IPC_SPIN_US: spin before parking on a doorbell, either direction.
-        Uint32 SpinUs = 50;
-        // MOBILEGL_IPC_EVENT_WAIT_MS (PH-6, ID-P7-2): the SERVER's patience, in ms, for ONE
-        // reverse-channel event that finds SEG_EVENT full under run-ahead. The apply thread
-        // publishes, rings the client and parks until the client drains enough room; a client
-        // that has not made room when this runs out - it stopped draining (NotDraining) or it
-        // drains a slot at a time (TooSlow) - FORFEITS the reverse channel: that event and every
-        // later one is dropped and counted (eventDropped), and the session stops by the ordinary
-        // stop path rather than by Fatal{EventRingOverflow}. A peer that goes away (PeerGone) or
-        // a session that is stopped (Stopped) ends the wait at once instead, so the knob may
-        // exceed ServerLoop::Stop()'s 5000 ms join. It bounds the whole reservation, not one
-        // park, so a trickling peer cannot stretch it - nor can a shm peer that writes the
-        // (peer-writable) eventRingFull latch to 0 itself, though that one keeps the apply
-        // thread spinning rather than parked until the budget runs out. Was a 30000 ms constant
-        // spent twice. Read by the server only (ServerSpawn.cpp passes it to a spawned child);
-        // the lockstep arm (no kCapRunAheadApply, i.e. Magma) never waits and keeps P5C's Fatal.
-        Uint32 EventWaitMs = 2000;
-        // MOBILEGL_IPC_PERSISTENT_BLOCK_KB: block granularity of the persistent-map push.
-        // 0 IS A NEGATIVE CONTROL, NOT "unlimited": it disables the push, and
-        // PersistentCoherentMapScenario must go RED under it (exit gate E3(a)).
-        Uint32 PersistentBlockKb = 64;
-        // MOBILEGL_IPC_PERSISTENT_HASH_SUPPRESS: 1 = the persistent-map push ships only
-        // blocks whose xxHash64 changed since the last push, instead of the whole mapped
-        // range every verb. 0 restores the whole-range push (A/B control).
-        Uint32 PersistentHashSuppress = 1;
-        // MOBILEGL_IPC_BATCH_WAITS: 1 = value-class records (kCtxState / kCtxCso / kCtxObject
-        // with no reply slot) are published without waiting for their own apply; the barrier
-        // is taken at the next pull-reading verb (kCtxVerb syncs, queries, screen rows, and
-        // every reply-slot row), which is the only place BARRIER-PULLED fields are read. 0
-        // restores the per-record barrier of R-1.
-        Uint32 BatchWaits = 1;
-        // MOBILEGL_IPC_CREATE_WINDOW: how many RESOURCE_CREATE answers may be outstanding before the
-        // client waits for one. 1 = every create waits (the shape R-5 shipped with); N > 1 = up to N
-        // creates go out fire-and-forget, their caller reads a PROVISIONAL accept, and the oldest
-        // answer is taken when the window fills.
-        //
-        // DEFAULT 2, AND IT TOOK THREE THINGS TO GET HERE. The deferral was inert for two
-        // measured reasons and one structural one, in the order they were found:
-        //   1. the reply buffer was a ring of the last 8 answers, and between two creates this
-        //      client emits on the order of a thousand records - so the answer was always gone
-        //      (`want=310` on every miss while the ring spanned [1175..1504]);
-        //   2. a residency budget that tried to take answers back early could not help, because
-        //      what displaces an answer is what the SERVER sends, not what the client emits;
-        //   3. and so the fix was RETENTION - a link keeps a declared answer until its reader
-        //      takes it (Transport/ILink.h's RetainsReplies, StreamLink's declared-answer store).
-        //
-        // MEASURED ON THE DEVICE, load frame, both ends rebuilt (create 4,536, records 103,097,
-        // frame-sent identical per op throughout):
-        //     window 1    4,536 blocking takes   28.66 s   (the shape R-5 shipped)
-        //     window 2      2,500               17.27 s
-        //     window 4      1,644               11.02 s
-        // and the round trip does NOT grow as the window deepens (5,285 / 4,082 us against 5,672
-        // at 1), which is the measurement that says the ~5 ms is a WAKEUP the server batches away
-        // rather than its apply throughput - so amortising four creates per wakeup is a real 2.6x.
-        //
-        // 6 IS THE DEFAULT, AND IT IS WHERE THE CURVE FLATTENS - the sweep that says so is the
-        // one the paragraph above asked for, and it moved the ceiling too (kCreateWindowMax is 8
-        // now; the old 4 was derived from a reply pool the window does not run on). Three
-        // interleaved runs per arm on one binary, load frame, create 4,536 sent in every arm:
-        //
-        //     window 4   1,503 blocking takes   13.23 s median   (spread 11.37-16.29)
-        //     window 5   1,277                  11.31 s          (10.61-12.12)
-        //     window 6   1,155                  10.79 s          ( 9.69-10.81)
-        //     window 8     859                  10.96 s          ( 8.92-11.03)
-        //
-        // 4->5 buys 1.92 s, 5->6 buys 0.53 s, 6->8 buys NOTHING (-0.18 s, inside a session noise
-        // of ~1.5-2 s) - so 6 is the smallest window on the flat part and the extra answers a
-        // deeper one holds buy no time. AND PAST THIS POINT THE FRAME IS NOT WAIT-BOUND ANY MORE:
-        // window 8 pays 296 fewer blocking takes than window 6 and the wall clock does not move.
-        // The store is not the constraint either - its peak is logged as it crosses (StreamLink's
-        // P12 line) and reads 6..11 against a cap of 24 at every arm from 5 up. What is left is
-        // the constant ~350-400 creates that block for a reason depth does not reach, and the
-        // 101 MB / 103k records the SERVER has to apply. NOTE THE PREDICATE the whole mechanism rests
-        // on: an answer is retained because the wire DECLARED it will be read - NOT because its
-        // caller was fire-and-forget. The window's own creates are fire-and-forget AND read, so a
-        // flag keyed on wantReply would disable the very mechanism it exists to enable
-        // (docs/Disaggregated/notes/p12/CREATE-WINDOW-MEASURED.md sections 7-11).
-        Uint32 CreateWindow = 10;
-        // MOBILEGL_IPC_PBO_READBACK_SYNC (P9 W1, MG_Remote/CONTRACT-P9.md §1): 1 = a glReadPixels
-        // or glGetTexImage into a bound GL_PIXEL_PACK_BUFFER takes the reply-slot form again -
-        // the client waits for the pixels and uploads them into the buffer itself, as before P9.
-        // 0 (default) sends read_pixels_to_buffer / get_texture_image_to_buffer, waits for
-        // nothing, and marks the buffer GPU-written. The 1 arm is the A/B control and the
-        // red-once of the wait-count gate (PackBufferReadbackScenario): it must show a reply
-        // wait per read.
-        Uint32 PboReadbackSync = 0;
-        // MOBILEGL_IPC_POLL_ESCALATE (P10, MG_Remote/CONTRACT-P10.md §1): a glClientWaitSync with a
-        // zero timeout or a glGetSynciv(GL_SYNC_STATUS) is answered by the client from what the
-        // server reported (kEventFenceSignaled) - "signaled" when it has been, "not yet" otherwise
-        // - and only the Nth "not yet" in a row on one fence crosses as a real round trip, so a
-        // poll loop cannot outlive a late report. 0 = every poll crosses, as before P10: the A/B
-        // arm and the red-once of the no-reply gate (FencePollScenario).
-        Uint32 PollEscalate = 64;
-        // MOBILEGL_IPC_ADOPT_TIER, THE ZERO-COPY SWITCH (ruling ID-P11-14, CONTRACT-P11 B2):
-        // UNSET (kAdoptTierUnset, the default since 2026-09-29, the user's decision) = T0 where the
-        // session can run it, T2 QUIETLY where it cannot (MGLOG_D only, still counted);
-        // 0 = T0 asked by name - a T0 this session cannot use (a stream plane, the server's allow
-        // switch, no AHardwareBuffer, a failed server POST) is T2 plus one named line;
-        // 1 = T1, closed - refused by name, then T2; 2 = emulate (T2: the client keeps the shadow
-        // and pushes). Never a Fatal (MG_Remote/Transport/AdoptTier.h).
-        Uint32 AdoptTier = kAdoptTierUnset;
-        // MOBILEGL_IPC_ALLOW_ADOPT_T0 (server): 1 (default) = grant a client's T0 ask when this
-        // platform and the backend's POST self-test allow it; 0 = never grant it (the session
-        // runs T2 and says so). Read by the server role only; kept through ServerSpawn.
-        Uint32 AllowAdoptT0 = 1;
-        // MOBILEGL_IPC_VERB_BARRIER: 1 = the client blocks at every verb boundary until
-        // appliedSeq reaches its emitSeq (R-1). 0 is the negative control: it is EXPECTED to
-        // be red, because 31 of the 63 PipeInputs fields are still pulled from a live
-        // GLContext by the client's residual fill and a free-running queue lets the server
-        // read a FUTURE value of them.
-        Uint32 VerbBarrier = 1;
-        // MOBILEGL_IPC_RUN_AHEAD (P5e, MG_Remote/CONTRACT-P5E.md §1): 1 = after publishing an
-        // UNBARRIERED record the client returns immediately instead of waiting for its apply.
-        // It is one half of a conjunction and never a switch on its own - the client arms
-        // run-ahead only when the server also publishes kCapRunAheadApply, so on Magma, and on
-        // Espryt before the P5e integration commit, 1 means exactly what 0 means and logs once
-        // saying so.
-        //
-        // 0 IS THE A/B CONTROL AND NOT A NEGATIVE ONE: the server code, the fill decision and
-        // every record are identical on both arms, and the only difference is whether the
-        // client waits. That is what makes "is the picture the same" a question about the wait
-        // rule alone. MOBILEGL_IPC_VERB_BARRIER=0 keeps its own meaning and stays the
-        // lockstep arm's negative control; under run-ahead it is the one that must go red, at
-        // the first barriered row's stale pull.
-        //
-        // Forced to 0 by MOBILEGL_PIPE_VERIFY, beside BatchWaits: the comparator needs a
-        // client-filled gPipeInputs block for every verb, and run-ahead is precisely the
-        // arm that stops filling it.
-        Uint32 RunAhead = 1;
-        // MOBILEGL_IPC_PRESENT_CREDIT (P5e, ruling 4 / ID-92): how many presents the client may
-        // have in flight before it waits for a swap to come back. 1 = the client publishes
-        // frame N+1's records while the server applies and swaps frame N - one frame of
-        // overlap, at most one frame of added latency - and the CREDIT, never the ring's bytes,
-        // is what paces a run-ahead client. 2 is a device MEASUREMENT arm: it buys no CPU on a
-        // client that is already CPU-bound and costs a frame of latency, which is why the
-        // default is 1 and not "as deep as the ring".
-        Uint32 PresentCredit = 1;
-        // MOBILEGL_IPC_CONTROL_TIMEOUT_MS (CONTRACT-P6 §5.4 D5b): how long a spawn/tcp client
-        // waits for the SurfaceReply to one surface-control op (eglCreate*Surface, MakeCurrent,
-        // ...) once the server's backend is up. Its expiry is NOT fatal: the doorbell's death
-        // latch decides dead (device lost) from alive-but-silent (a named diagnostic). The
-        // contract named this knob from P6 on; the client hard-coded its default until P7.
-        Uint32 ControlTimeoutMs = 5000;
-        // MOBILEGL_IPC_COLD_START_MS (P7): the same wait for the three ops a server may bring its
-        // NATIVE backend up inside - CreatePbufferSurface, CreateWindowSurface, MakeCurrent -
-        // until the session's first MakeCurrent is answered ok. The bring-up is lazy (Espryt's
-        // eglInitialize, Magma's Vulkan instance and device), ~100 ms on a workstation and more
-        // than the steady 5 s on a loaded CI runner (retrace-split spawn legs, runs 35671704873
-        // and 35706183230). Never shorter than CONTROL_TIMEOUT_MS; its expiry is the same
-        // non-fatal named answer. The default is the spawn connect budget, for the same reason:
-        // "the server has to create a backend, and a cold software rasteriser is not fast".
-        Uint32 ColdStartMs = 20000;
-        // MOBILEGL_IPC_STRICT_ERRORS: promote a BARRIER-PULLED field read - and, in a split
-        // build, the seven sticky forwards that are otherwise exempt - from "count it in
-        // rsp" to Fatal (R-7.3).
-        Bool StrictErrors = false;
-        // MOBILEGL_IPC_ROLE_SPLIT_STATE (P5f f1, P5F-WIRE-COMPLETENESS.md §4): the dual-block
-        // rehearsal. 1 = the client's residual fill writes a CLIENT-ROLE PipeInputs block and
-        // the backend/applier keep reading the SERVER-ROLE one, so every path that today works
-        // only because the two roles share one object turns into a named
-        // Fatal{UnmigratedPipeInput, "<field>@<verb>"} instead of a silent cross-role read.
-        // Meaningless under monolith transport (the two roles are one thread there, so the
-        // selection folds to the single shared block) and forced off by MOBILEGL_PIPE_VERIFY
-        // (the comparator owns the one fill block it compares against). 0 is not merely the
-        // default, it is the negative control: the lane's distinctness case must go red
-        // without it (P5F §6).
-        Bool RoleSplitState = false;
-        // MOBILEGL_IPC_AUDIT: after a record retires, the server fills the SEG_STAGE bytes
-        // it referenced with 0xDD (R-2.5). This is the ONLY mechanical control that an
-        // inproc implementation did not quietly keep using a pointer past its lifetime.
-        Bool Audit = false;
-        // MOBILEGL_IPC_SERVER_AFFINITY: `auto` (the default, big-core detection borrowed
-        // from ShaderCompilePool), `off`, or an explicit CPU mask. Kept as the raw string
-        // because the resolved mask is logged by whoever starts the apply thread, and the
-        // string is what an operator typed.
-        String ServerAffinity = "auto";
-        // MOBILEGL_IPC_SURFACE (P12, on-screen server window) = offscreen | server. `server` makes
-        // the client a HEADLESS one: eglCreateWindowSurface / eglCreatePlatformWindowSurface accept
-        // any native window including NULL, send ONE CreateWindowSurface naming
-        // WindowKind::ServerOwned (token 0, the size from EGL_WIDTH/EGL_HEIGHT, 0/0 = the server's
-        // own) and no SetWindowHandle, and take the surface's real geometry back from the server.
-        // Meaningful only when this client talks to a remote server (MOBILEGL_TRANSPORT=spawn, the
-        // fork or tcp:// control); under monolith / inproc it is parsed, logged as ignored, and
-        // changes nothing. `offscreen` (the default) is today's behaviour byte for byte.
-        // Pbuffers stay pbuffers in both modes (D4: one mode per session, decided by the first).
-        IpcSurface Surface = IpcSurface::Offscreen;
-    };
-    extern IpcTable Ipc;
-
-    // P12: the one predicate every client-side consumer of MOBILEGL_IPC_SURFACE asks - a window
-    // surface is the server's when the knob says so AND there is a remote server to own it.
-    inline Bool ServerOwnedWindowSurfaces() {
-        return Transport == TransportMode::Spawn && Ipc.Surface == IpcSurface::Server;
-    }
-
-    // P12: the other on-screen shape, and the mirror image of the one above.  The display host
-    // (the Android side that owns the screen) allocates the frames, offers each one over the
-    // host frame bridge, and puts it on the glass when this side says it is drawn - so a
-    // client that asks for this has no window of its own either, and the server takes the
-    // frames rather than making a window.
-    inline Bool HostFrameWindowSurfaces() {
-        return Transport == TransportMode::Spawn && Ipc.Surface == IpcSurface::Host;
-    }
-#else
-    // The whole point: in a build without MG_Remote this folds at compile time, so
-    // `if (MG_Config::Transport != MG_Config::TransportMode::Monolith)` in Init.cpp is a
-    // discarded statement and the pull build gains no symbol, no branch and no byte.
-    inline constexpr TransportMode Transport = TransportMode::Monolith;
-#endif
 } // namespace MobileGL::MG_Config

MobileGL/ConfigLoader.cpp

@@ -1,583 +0,0 @@
-// MobileGL - MobileGL/ConfigLoader.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 "Config.h"
-#if MOBILEGL_PIPE_PUSH
-// For kMGPipeSubsystemsMigratedAtP5e, the push build's PipePush default (the P2, P3a and P4a
-// constants beside it are the phase-by-phase controls, not the default). Push-only, so the
-// pull build's translation unit is unchanged.
-#include <MG_Pipe/MGPipe.h>
-#endif
-
-#include <cerrno>
-#include <cstdlib>
-#if MOBILEGL_BUILD_DISAGGREGATED
-// std::strcmp, for InitIpc's server-role check (P12). Split-only, so the pull build's TU is
-// unchanged (G1).
-#include <cstring>
-#endif
-
-#ifndef _WIN32
-extern char** environ;
-#endif
-
-namespace MobileGL::MG_Config {
-    // Zero/default-initialized at static-init time (all fields have constexpr-friendly
-    // defaults), so it is safe to read even if MG_ConfigLoader::Init has not run yet.
-    FeaturesTable Features;
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // Same contract, and for the same reason: MG_Backend::Init() reads Transport, and a
-    // build order that put it before MG_ConfigLoader::Init() must see Monolith rather than
-    // a torn enum. Defined only here - in a pull build Config.h makes Transport a constexpr
-    // and there is nothing to define.
-    TransportMode Transport = TransportMode::Monolith;
-    String TransportEndpoint;
-    Bool SplitTransportRequestedByConfig = false;
-    IpcTable Ipc;
-#endif
-} // namespace MobileGL::MG_Config
-
-namespace MobileGL::MG_ConfigLoader {
-    static UniquePtr<UnorderedMap<String, String>> acceptedEnvVariablesMap;
-
-    static Bool IsAcceptedPrefix(const String& key) {
-        return (key.compare(0, 6, "LIBGL_") == 0 || key.compare(0, 9, "MOBILEGL_") == 0);
-    }
-
-    inline void InitializeAcceptedEnvVariables() {
-        if (!acceptedEnvVariablesMap) {
-            acceptedEnvVariablesMap = MakeUnique<UnorderedMap<String, String>>();
-        } else {
-            acceptedEnvVariablesMap->clear();
-        }
-
-        char** envPtr = nullptr;
-
-#ifdef _WIN32
-        envPtr = _environ;
-#else // POSIX
-        envPtr = ::environ;
-#endif
-
-        if (envPtr == nullptr) return;
-
-        for (char** env = envPtr; *env != nullptr; ++env) {
-            String entry(*env);
-            SizeT pos = entry.find('=');
-            if (pos != String::npos) {
-                String key = entry.substr(0, pos);
-                String value = entry.substr(pos + 1);
-
-                if (IsAcceptedPrefix(key)) {
-                    (*acceptedEnvVariablesMap)[key] = value;
-                    MGLOG_D("Config: Accepted env variable: %s=%s", key.c_str(), value.c_str());
-                }
-            }
-        }
-    }
-
-    inline void QueryEnvVariable(const String& key, String& outValue, const String& defaultValue) {
-        auto it = acceptedEnvVariablesMap->find(key);
-        if (it != acceptedEnvVariablesMap->end()) {
-            outValue = it->second;
-        } else {
-            outValue = defaultValue;
-        }
-    }
-
-    // Unified truthy rule for boolean feature env variables: set, non-empty, not "0",
-    // and not "false" (case-insensitive).
-    static Bool IsTruthyValue(const String& value) {
-        if (value.empty() || value == "0") {
-            return false;
-        }
-        String lowered = value;
-        std::transform(lowered.begin(), lowered.end(), lowered.begin(),
-                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-        return lowered != "false";
-    }
-
-    inline Bool QueryEnvFlag(const String& key) {
-        auto it = acceptedEnvVariablesMap->find(key);
-        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()) {
-            return defaultValue;
-        }
-
-        const String& value = it->second;
-        char* parseEnd = nullptr;
-        errno = 0;
-        const unsigned long parsedValue = std::strtoul(value.c_str(), &parseEnd, 10);
-        if (parseEnd == value.c_str() || *parseEnd != '\0' || errno == ERANGE || parsedValue < minValue ||
-            parsedValue > maxValue) {
-            MGLOG_W("Config: Ignoring invalid env variable %s='%s'; expected an integer in range [%u, %u], "
-                    "using default %u",
-                    key.c_str(), value.c_str(), minValue, maxValue, defaultValue);
-            return defaultValue;
-        }
-
-        return static_cast<Uint32>(parsedValue);
-    }
-
-    // Same contract as QueryEnvUint32, over 64 bits and accepting an explicit 0x prefix: the
-    // one consumer is a subsystem BITMASK, and a bitmask written in decimal is unreadable.
-    // Decimal otherwise - never strtoull's base 0, whose "leading zero means octal" rule
-    // silently read MOBILEGL_PIPE_PUSH=010 as 8 - and a '-' anywhere is rejected rather than
-    // wrapped, which strtoull would otherwise do without complaint (-1 -> every bit set).
-    inline Uint64 QueryEnvUint64(const String& key, Uint64 defaultValue) {
-        auto it = acceptedEnvVariablesMap->find(key);
-        if (it == acceptedEnvVariablesMap->end()) {
-            return defaultValue;
-        }
-
-        const String& value = it->second;
-        const char* text = value.c_str();
-        int base = 10;
-        if (value.size() > 2 && text[0] == '0' && (text[1] == 'x' || text[1] == 'X')) {
-            text += 2;
-            base = 16;
-        }
-        char* parseEnd = nullptr;
-        errno = 0;
-        const bool negative = value.find('-') != String::npos;
-        const unsigned long long parsedValue = negative ? 0 : std::strtoull(text, &parseEnd, base);
-        if (negative || parseEnd == text || *parseEnd != '\0' || errno == ERANGE) {
-            MGLOG_W("Config: Ignoring invalid env variable %s='%s'; expected a non-negative integer "
-                    "(decimal, or 0x-prefixed hexadecimal), using default %llu",
-                    key.c_str(), value.c_str(), static_cast<unsigned long long>(defaultValue));
-            return defaultValue;
-        }
-
-        return static_cast<Uint64>(parsedValue);
-    }
-
-    inline void InitFeatures() {
-        auto& features = MG_Config::Features;
-        features.DisableTimerQuery = QueryEnvFlag("MOBILEGL_DISABLE_TIMERQUERY");
-        features.EsprytEnableTextureView = QueryEnvFlag("MOBILEGL_ESPRYT_ENABLE_TEXTURE_VIEW");
-        features.EnableSpirvValidation = QueryEnvFlag("MOBILEGL_ENABLE_SPIRV_VALIDATION");
-        features.EsprytUseAngle = QueryEnvFlag("MOBILEGL_ESPRYT_USE_ANGLE");
-#if defined(MOBILEGL_TRACE_ANGLE_VARIANTS)
-        QueryEnvVariable("MOBILEGL_TRACE_ANGLE_VARIANT", features.TraceAngleVariant, "");
-#endif
-        features.MagmaDisableSubgroup = QueryEnvFlag("MOBILEGL_MAGMA_DISABLE_SUBGROUP");
-        features.MagmaEmulateSubgroup = QueryEnvFlag("MOBILEGL_MAGMA_EMULATE_SUBGROUP");
-        features.MagmaFixIterationRPSubgroupScratch =
-            QueryEnvQuirkOverride("MOBILEGL_MAGMA_FIX_ITERATIONRP_SUBGROUP_SCRATCH");
-        features.MagmaIterationRPFixBarrier = QueryEnvFlag("MOBILEGL_MAGMA_ITERATIONRP_FIX_BARRIER");
-        features.MagmaDeriveNumSubgroups = QueryEnvQuirkOverride("MOBILEGL_MAGMA_DERIVE_NUM_SUBGROUPS");
-        features.AdvertiseFp64 = QueryEnvFlag("MOBILEGL_ADVERTISE_FP64");
-        features.MagmaR11G11B10FFallback = QueryEnvFlag("MOBILEGL_MAGMA_R11G11B10F_FALLBACK");
-        features.MagmaFramesInFlight = QueryEnvUint32("MOBILEGL_MAGMA_FRAMESINFLIGHT", 3, 1, 64);
-        features.MagmaMaxDrawsPerCommandBuffer =
-            QueryEnvUint32("MOBILEGL_MAGMA_MAX_DRAWS_PER_COMMAND_BUFFER", 16384, 0, 1u << 24);
-        features.MagmaDescriptorTrimFrames = QueryEnvUint32("MOBILEGL_MAGMA_DESCRIPTOR_TRIM_FRAMES", 120, 0, 1u << 20);
-        features.EsprytAvoidSamplerMipmapMinFilter =
-            QueryEnvFlag("MOBILEGL_ESPRYT_AVOID_SAMPLER_MIPMAP_MIN_FILTER");
-        features.EsprytAvoidExplicitLodBias = QueryEnvFlag("MOBILEGL_ESPRYT_AVOID_EXPLICIT_LOD_BIAS");
-        features.EsprytUnlocatedIoBlocks = QueryEnvQuirkOverride("MOBILEGL_ESPRYT_UNLOCATED_IO_BLOCKS");
-        features.PointSizeDemotion = QueryEnvQuirkOverride("MOBILEGL_POINT_SIZE_DEMOTION");
-        features.CoherentAsFlush = QueryEnvFlag("MOBILEGL_COHERENT_AS_FLUSH");
-        features.TraceSkipAutodestroy = QueryEnvFlag("MOBILEGL_TRACE_SKIP_AUTODESTROY");
-        features.EsprytDisableUboRing = QueryEnvFlag("MOBILEGL_ESPRYT_DISABLE_UBO_RING");
-        features.EsprytDisableUnpackRing = QueryEnvFlag("MOBILEGL_ESPRYT_DISABLE_UNPACK_RING");
-        features.EsprytDisableUploadRing = QueryEnvFlag("MOBILEGL_ESPRYT_DISABLE_UPLOAD_RING");
-        features.EsprytDisableInvalidateFlush = QueryEnvFlag("MOBILEGL_ESPRYT_DISABLE_INVALIDATE_FLUSH");
-        features.DisableLargeBufferAdoption = QueryEnvFlag("MOBILEGL_DISABLE_LARGE_BUFFER_ADOPTION");
-        features.EsprytForceDepthStencilReadbackEmulation =
-            QueryEnvFlag("MOBILEGL_ESPRYT_FORCE_DS_READBACK_EMULATION");
-        features.RelaxedSemantics = QueryEnvFlag("MOBILEGL_RELAXED_SEMANTICS");
-        features.MagmaDisableBlendedDepthWriteQuirk =
-            QueryEnvQuirkOverride("MOBILEGL_MAGMA_DISABLE_BLENDED_DEPTH_WRITE");
-        features.MagmaDisableRobustBufferAccess = QueryEnvFlag("MOBILEGL_MAGMA_DISABLE_ROBUST_BUFFER_ACCESS");
-        features.MagmaMultiDrawMode = QueryEnvMultiDrawMode("MOBILEGL_MAGMA_MULTIDRAW_MODE");
-        features.EsprytMultiDrawMode = QueryEnvGLESMultiDrawMode("MOBILEGL_ESPRYT_MULTIDRAW_MODE");
-        features.AsyncShaderCompile = QueryEnvQuirkOverride("MOBILEGL_ASYNC_SHADER_COMPILE");
-        features.AsyncShaderCompileThreads = QueryEnvUint32("MOBILEGL_ASYNC_SHADER_COMPILE_THREADS", 0, 0, 64);
-        features.AsyncOptimisticShaderStatus =
-            QueryEnvQuirkOverride("MOBILEGL_ASYNC_OPTIMISTIC_SHADER_STATUS");
-        features.ShaderTranslationCache = QueryEnvQuirkOverride("MOBILEGL_SHADER_CACHE");
-        features.EsprytViewportArrayEmulation =
-            QueryEnvQuirkOverride("MOBILEGL_ESPRYT_FORCE_VIEWPORT_ARRAY_EMULATION");
-        features.EsprytWidenPacked16Storage =
-            QueryEnvQuirkOverride("MOBILEGL_ESPRYT_WIDEN_PACKED16_STORAGE");
-        features.MagmaPrimGenQueryReroute = QueryEnvQuirkOverride("MOBILEGL_MAGMA_PRIMGEN_QUERY_REROUTE");
-        // MGPipe. Nothing here needs adding to an allow-list: InitializeAcceptedEnvVariables
-        // accepts every MOBILEGL_ / LIBGL_ prefixed variable in the environment, so a name
-        // that starts with MOBILEGL_ is visible to these queries by construction.
-#if MOBILEGL_PIPE_PUSH
-        // A push build with the knob unset runs every subsystem migrated so far, so the
-        // shipped path is the one the gates measure; MOBILEGL_PIPE_PUSH=0 in the
-        // environment is the all-subsystems-pull control that reproduces P1 exactly, and
-        // kMGPipeSubsystemsMigratedAtP3a (0x1ff) is the phase-by-phase control - P4a's four
-        // subsystems off, everything P3a landed still on.
-        features.PipePush = QueryEnvUint64("MOBILEGL_PIPE_PUSH", MG_Pipe::kMGPipeSubsystemsMigratedAtP5e);
-#else
-        // Meaningless in a pull build: there is nothing to push. Config.h documents 0 as
-        // "pull everything" and that stays literally true.
-        features.PipePush = QueryEnvUint64("MOBILEGL_PIPE_PUSH", 0);
-#endif
-        features.PipeVerify = QueryEnvFlag("MOBILEGL_PIPE_VERIFY");
-#if MOBILEGL_PIPE_PUSH
-        // Defaults ON: read as a tri-state so only an explicitly falsy value turns it off.
-        features.PipeVerifyFatal =
-            QueryEnvQuirkOverride("MOBILEGL_PIPE_VERIFY_FATAL") != MG_Config::QuirkOverride::ForceOff;
-        QueryEnvVariable("MOBILEGL_PIPE_VERIFY_CORRUPT", features.PipeVerifyCorrupt, "");
-        QueryEnvVariable("MOBILEGL_PIPE_POISON_OMIT", features.PipePoisonOmit, "");
-        features.PipeHandleAbaControl = QueryEnvFlag("MOBILEGL_PIPE_HANDLE_ABA_CONTROL");
-#endif
-        features.PipeStats = QueryEnvFlag("MOBILEGL_PIPE_STATS");
-        // Defaults ON, so the flag has to be read as a tri-state rather than as a plain
-        // truthy check: unset must keep the memos, and only an explicitly falsy value may
-        // drop them.
-        features.PipeLegacyMemos =
-            QueryEnvQuirkOverride("MOBILEGL_PIPE_LEGACY_MEMOS") != MG_Config::QuirkOverride::ForceOff;
-        features.PipeTexelRetainMb = QueryEnvUint32("MOBILEGL_PIPE_TEXEL_RETAIN_MB", 0, 0, 4096);
-        features.PipeIndexMirrorMb = QueryEnvUint32("MOBILEGL_PIPE_INDEX_MIRROR_MB", 64, 0, 4096);
-        features.PipeStatsPeriod = QueryEnvUint32("MOBILEGL_PIPE_STATS_PERIOD", 120, 1, 1000000);
-        QueryEnvVariable("MOBILEGL_PIPE_STATS_FILE", features.PipeStatsFile, "");
-    }
-
-    inline void InitBackendType() {
-        String backendTypeStr;
-        QueryEnvVariable("MOBILEGL_BACKEND_TYPE", backendTypeStr, "DirectGLES");
-#define ENTRY(backendType)                                                                                             \
-    if (backendTypeStr == #backendType) {                                                                              \
-        MG_Config::ActiveBackendType = BackendType::backendType;                                                       \
-        MGLOG_I("Config: Active backend type set to " #backendType);                                                   \
-        return;                                                                                                        \
-    }
-        ENTRY(DirectGLES)
-        ENTRY(DirectVulkan)
-        ENTRY(Unknown)
-        MG_Config::ActiveBackendType = BackendType::Unknown;
-#undef ENTRY
-    }
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // MOBILEGL_TRANSPORT = monolith | inproc | spawn | unix:<path> | pipe:<name>
-    // (ARCHITECTURE.md:583). Shaped after InitBackendType above: an exact-name table, then
-    // one fallback that names what it did instead. The two prefixed forms are the only
-    // reason this is not literally that function's ENTRY macro.
-    //
-    // spawn / unix: / pipe: PARSE AND THEN REFUSE. They are P6's, and the refusal is NAMED
-    // rather than silent, because the failure this avoids is a P6 lane that set
-    // MOBILEGL_TRANSPORT=spawn, fell back to monolith, and went green on the wrong arm.
-    // The mode is left at Monolith so nothing half-initializes.
-    inline void InitTransport() {
-        String value;
-        QueryEnvVariable("MOBILEGL_TRANSPORT", value, "monolith");
-        String lowered = value;
-        std::transform(lowered.begin(), lowered.end(), lowered.begin(),
-                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-
-        MG_Config::TransportEndpoint.clear();
-        if (lowered.empty() || lowered == "monolith") {
-            MG_Config::Transport = MG_Config::TransportMode::Monolith;
-            return;
-        }
-        if (lowered == "inproc") {
-            MG_Config::Transport = MG_Config::TransportMode::InProcess;
-            // P7 F1: see Config.h. Set beside the mode, on the two arms that actually resolve
-            // one, and NOT on the two that name a transport and then stay monolith - a process
-            // that was refused its transport brings no client half up either.
-            MG_Config::SplitTransportRequestedByConfig = true;
-            MGLOG_I("Config: MOBILEGL_TRANSPORT=inproc - the MGPipe record stream crosses a real "
-                    "ring to an apply thread");
-            return;
-        }
-        // The three P6 forms. Recognised precisely, so the diagnostic can say "not yet"
-        // rather than "unknown", which are different bugs on the operator's side.
-        // P6 `sm`/`cp`: spawn is IMPLEMENTED. It launches a server process on a
-        // rendezvous of its own and connects to it - the two processes are
-        // independent, so this is `Dial = Connect` with a launcher attached
-        // rather than the fork-coupled shape ARCHITECTURE.md:488 described.
-        if (lowered == "spawn") {
-            MG_Config::Transport = MG_Config::TransportMode::Spawn;
-            MG_Config::SplitTransportRequestedByConfig = true; // P7 F1, as above.
-            // THE SAME SHAPE AS THE inproc LINE ABOVE, AND FOR THE SAME REASON.
-            // run_trace_case.cmake asserts on a distinctive sentence from this
-            // function rather than on `MOBILEGL_TRANSPORT=spawn` alone, because
-            // ConfigLoader logs an `Accepted env variable: KEY=VALUE` line for
-            // every MOBILEGL_* in EVERY build including the pull one - so the
-            // bare KEY=VALUE is satisfied by a monolith library that parsed
-            // nothing (review M-5). A spawn arm with no line of its own could
-            // only have been asserted with the inproc marker, which spawn never
-            // emits: the arm would have been red for a missing sentence rather
-            // than green for a working transport.
-            MGLOG_I("Config: MOBILEGL_TRANSPORT=spawn - the MGPipe record stream crosses a real "
-                    "ring to an apply thread in ANOTHER PROCESS");
-            return;
-        }
-        if (lowered.compare(0, 5, "unix:") == 0 || lowered.compare(0, 5, "pipe:") == 0) {
-            // unix: and pipe: remain P6+ - connecting to an endpoint SOMEBODY
-            // ELSE is listening on needs the server lifecycle to be somebody
-            // else's too, which is P12's. Named, never a silent degrade.
-            MGLOG_E("Config: MOBILEGL_TRANSPORT='%s' names a transport P6 does not implement yet; "
-                    "staying on monolith. This run is NOT a split run.",
-                    value.c_str());
-            MG_Config::Transport = MG_Config::TransportMode::Monolith;
-            return;
-        }
-        MGLOG_W("Config: Ignoring invalid env variable MOBILEGL_TRANSPORT='%s'; expected "
-                "monolith|inproc|spawn|unix:<path>|pipe:<name>, using monolith",
-                value.c_str());
-        MG_Config::Transport = MG_Config::TransportMode::Monolith;
-    }
-
-    // The MOBILEGL_IPC_* family (Config.h IpcTable). Parsed unconditionally rather than only
-    // when Transport != Monolith: a knob that silently means nothing on one arm of an A/B is
-    // how an A/B stops being one, and the ranges below are the diagnostics.
-    inline void InitIpc() {
-        auto& ipc = MG_Config::Ipc;
-        QueryEnvVariable("MOBILEGL_IPC_SERVER_PATH", ipc.ServerPath, "");
-        QueryEnvVariable("MOBILEGL_IPC_CONTROL", ipc.Control, "fork");
-        QueryEnvVariable("MOBILEGL_IPC_DATA", ipc.Data, "auto");
-        // Both ring floors are 1 MiB, not 0: a ring caps ONE record at half its size, and
-        // the catalogue's largest fixed payload (MGPFramebufferState, 304 bytes) plus a
-        // create_shader_state archive already needs far more than a toy ring. The ceilings
-        // are sanity, not policy.
-        ipc.RingMb = QueryEnvUint32("MOBILEGL_IPC_RING_MB", 8, 1, 1024);
-        ipc.StageMb = QueryEnvUint32("MOBILEGL_IPC_STAGE_MB", 32, 1, 4096);
-        // P7 wave 4 M2 (Config.h has the semantics). 0 is admitted ON PURPOSE as the negative
-        // control: no forced sync, and MagmaWireReclaimScenario's watermark case must go red.
-        ipc.WireDeferredMb = QueryEnvUint32("MOBILEGL_IPC_WIRE_DEFERRED_MB", 64, 0, 65536);
-        ipc.SpinUs = QueryEnvUint32("MOBILEGL_IPC_SPIN_US", 50, 0, 1000000);
-        // PH-6 (ID-P7-2; Config.h has the semantics). 0 is NOT admitted: a server with no
-        // patience at all would forfeit a healthy run-ahead client the first time its ring
-        // filled between two of the client's drains, which is an ordinary backlog.
-        ipc.EventWaitMs = QueryEnvUint32("MOBILEGL_IPC_EVENT_WAIT_MS", 2000, 1, 600000);
-        // 0 is admitted ON PURPOSE and is the negative control of exit gate E3(a): it turns
-        // the persistent-map push OFF, and PersistentCoherentMapScenario must go red.
-        ipc.PersistentBlockKb = QueryEnvUint32("MOBILEGL_IPC_PERSISTENT_BLOCK_KB", 64, 0, 65536);
-        // Whole-range push is the 0 arm; with it on (default) only blocks whose
-        // xxHash64 changed since the last push are shipped.
-        ipc.PersistentHashSuppress = QueryEnvUint32("MOBILEGL_IPC_PERSISTENT_HASH_SUPPRESS", 1, 0, 1);
-        ipc.BatchWaits = QueryEnvUint32("MOBILEGL_IPC_BATCH_WAITS", 1, 0, 1);
-        // The create window. DEFAULT 6, and it works because a link that declares RetainsReplies
-        // keeps a declared answer until its reader takes it - Config.h carries the three reasons it
-        // was inert before, the device numbers, and the sweep that put the default at 6 rather
-        // than 4 or 8 (the curve flattens at 6: 4->5 buys 1.92 s, 5->6 0.53 s, 6->8 nothing).
-        // Capped at 8: the retained set is bounded by the window's own depth, the store holds 24
-        // declared answers, and the device sweep showed the wall clock still falling at the old
-        // cap of 4 (see WireTables.cpp's kCreateWindowMax). WireTables.cpp's static_assert and
-        // StreamLink's crossing log are the checks on this number.
-        ipc.CreateWindow = QueryEnvUint32("MOBILEGL_IPC_CREATE_WINDOW", 10, 1, 12);
-        // P9 W1: the pack-buffer readback's A/B and red-once control (Config.h says both).
-        ipc.PboReadbackSync = QueryEnvUint32("MOBILEGL_IPC_PBO_READBACK_SYNC", 0, 0, 1);
-        // P10: fence polls answered locally; 0 is the A/B arm (Config.h).
-        ipc.PollEscalate = QueryEnvUint32("MOBILEGL_IPC_POLL_ESCALATE", 64, 0, 1000000);
-        // The verify harness compares the pushed block against the applier per verb; a
-        // batched queue lets the comparer read a supplied field mid-apply, which is a
-        // torn read rather than a divergence. The batch is therefore off whenever the
-        // shadow comparer is armed.
-        if (MG_Config::Features.PipeVerify) ipc.BatchWaits = 0;
-        // UNSET is T0 with quiet fallbacks (the default since 2026-09-29); 0 asks for T0 by name, 1 is
-        // refused by name, 2 is T2 - settled at the handshake from the data plane (P11 A1/B2,
-        // MG_Remote/Transport/AdoptTier.h). An unparseable value is warned about and reads as unset.
-        ipc.AdoptTier = QueryEnvUint32("MOBILEGL_IPC_ADOPT_TIER", MG_Config::kAdoptTierUnset, 0, 2);
-        // P11 B2: the server's own T0 allow switch (Config.h).
-        ipc.AllowAdoptT0 = QueryEnvUint32("MOBILEGL_IPC_ALLOW_ADOPT_T0", 1, 0, 1);
-        ipc.VerbBarrier = QueryEnvUint32("MOBILEGL_IPC_VERB_BARRIER", 1, 0, 1);
-        // P5e (MG_Remote/CONTRACT-P5E.md §1). The wait rule's A/B, parsed here like every
-        // other IPC knob and armed only where the server publishes kCapRunAheadApply.
-        ipc.RunAhead = QueryEnvUint32("MOBILEGL_IPC_RUN_AHEAD", 1, 0, 1);
-        // ... and forced OFF by the verify harness for BatchWaits' reason, one step further:
-        // run-ahead's whole point is that the client stops filling gPipeInputs for an
-        // unbarriered record, and the comparator has nothing left to compare when it does.
-        if (MG_Config::Features.PipeVerify) ipc.RunAhead = 0;
-        // The present credit (ruling 4). 1 is one frame of overlap; 8 is the ceiling because a
-        // deeper queue buys nothing on a CPU-bound client and pays for it in latency. 0 is NOT
-        // admitted: a credit of zero would mean "publish no present at all".
-        ipc.PresentCredit = QueryEnvUint32("MOBILEGL_IPC_PRESENT_CREDIT", 1, 1, 8);
-        // CONTRACT-P6 D5b's reply bound and P7's cold-start budget (Config.h has the semantics).
-        // Both are floored at 100 ms: a zero bound would declare every live server silent.
-        ipc.ControlTimeoutMs = QueryEnvUint32("MOBILEGL_IPC_CONTROL_TIMEOUT_MS", 5000, 100, 600000);
-        ipc.ColdStartMs = QueryEnvUint32("MOBILEGL_IPC_COLD_START_MS", 20000, 100, 600000);
-        ipc.StrictErrors = QueryEnvFlag("MOBILEGL_IPC_STRICT_ERRORS");
-        ipc.Audit = QueryEnvFlag("MOBILEGL_IPC_AUDIT");
-        QueryEnvVariable("MOBILEGL_IPC_SERVER_AFFINITY", ipc.ServerAffinity, "auto");
-        // P5f f1: the dual-block rehearsal (P5F-WIRE-COMPLETENESS.md §4). Forced OFF by the
-        // verify harness: the comparator's entry compare and compare-at-read hook are built on
-        // there being ONE filled block (the hook pins itself to &gPipeInputs,
-        // PipeFill.cpp's MGPipeVerifyReadHook), which is exactly what the rehearsal splits.
-        ipc.RoleSplitState = QueryEnvFlag("MOBILEGL_IPC_ROLE_SPLIT_STATE");
-        if (MG_Config::Features.PipeVerify && ipc.RoleSplitState) {
-            MGLOG_W("Config: MOBILEGL_IPC_ROLE_SPLIT_STATE=1 is incompatible with "
-                    "MOBILEGL_PIPE_VERIFY (the comparator owns the single fill block); "
-                    "the dual-block rehearsal is OFF for this run");
-            ipc.RoleSplitState = false;
-        }
-
-        // P6 `dl` (CONTRACT-P6 5.3): MOBILEGL_IPC_RESPAWN IS A NAMED REFUSAL, NOT A NO-OP.
-        //
-        // The device-lost latch is deliberately one-way - a session whose server died has
-        // nothing to recover into, because every handle the client minted names an object in a
-        // process that no longer exists. Re-pushing the world onto a fresh server is the work
-        // this knob would turn on, and no stage has written it.
-        //
-        // Refused BY NAME rather than parsed and ignored, for the reason Config.h gives about
-        // the whole IPC family: an environment variable nothing consumes is indistinguishable
-        // from one that is consumed and does nothing, and an operator who set this one would
-        // otherwise conclude that recovery had been tried and had not helped.
-        {
-            String respawn;
-            QueryEnvVariable("MOBILEGL_IPC_RESPAWN", respawn, "");
-            if (!respawn.empty() && respawn != "0") {
-                MGLOG_E("Config: MOBILEGL_IPC_RESPAWN='%s' names a recovery NO STAGE HAS "
-                        "IMPLEMENTED. The device-lost latch is one-way on purpose: every handle "
-                        "this client minted names an object inside the server process, so a new "
-                        "server would have to be re-pushed the entire world before a single verb "
-                        "could land. This run will latch device-lost and stay there.",
-                        respawn.c_str());
-            }
-        }
-
-        // P12 (on-screen): MOBILEGL_IPC_SURFACE = offscreen | server | host (Config.h has the
-        // semantics). An unknown value is named and read as the default, like every knob here.
-        {
-            String surface;
-            QueryEnvVariable("MOBILEGL_IPC_SURFACE", surface, "offscreen");
-            std::transform(surface.begin(), surface.end(), surface.begin(),
-                           [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-            if (surface.empty() || surface == "offscreen") {
-                ipc.Surface = MG_Config::IpcSurface::Offscreen;
-            } else if (surface == "server") {
-                ipc.Surface = MG_Config::IpcSurface::Server;
-            } else if (surface == "host") {
-                ipc.Surface = MG_Config::IpcSurface::Host;
-            } else {
-                MGLOG_W("Config: Ignoring invalid env variable MOBILEGL_IPC_SURFACE='%s'; expected "
-                        "offscreen|server|host, using offscreen",
-                        surface.c_str());
-                ipc.Surface = MG_Config::IpcSurface::Offscreen;
-            }
-            // (Not said by a server process: a spawned server inherits the client's environment,
-            // parses this before RunSession sets its own transport, and has no client half anyway.)
-            const char* role = std::getenv("MOBILEGL_IPC_ROLE");
-            const Bool serverProcess = role != nullptr && std::strcmp(role, "server") == 0;
-            if (ipc.Surface != MG_Config::IpcSurface::Offscreen && !serverProcess &&
-                MG_Config::Transport != MG_Config::TransportMode::Spawn) {
-                // Said, not silently honoured: there is no remote server here to own a window.
-                MGLOG_W("Config: MOBILEGL_IPC_SURFACE=%s is IGNORED - it asks for an on-screen "
-                        "surface (the server's own window, or the frames the display host owns) and "
-                        "this run has no remote server to provide one: MOBILEGL_TRANSPORT is not "
-                        "spawn. Window surfaces stay the client's own",
-                        ipc.Surface == MG_Config::IpcSurface::Server ? "server" : "host");
-            }
-        }
-
-        if (MG_Config::Transport == MG_Config::TransportMode::Monolith) return;
-        // One line, on the arm where these numbers decide behaviour, because every one of
-        // them is a number a bug report has to quote.
-        // CREATE-WINDOW IS IN THIS LINE BECAUSE A RUN HAS TO SAY WHICH WINDOW IT USED. It was
-        // missing while the value was a number nobody varied, and the moment it became one that
-        // changes the wall clock by seconds (the P12 sweep: 28.3 s at 1 down to 10.8 s at 6) a
-        // log that does not name it makes every run ambiguous about its own configuration.
-        MGLOG_I("Config: IPC ring=%uMiB stage=%uMiB wire-deferred=%uMiB spin=%uus event-wait=%ums "
-                "persistent-block=%uKiB create-window=%u pbo-readback-sync=%u poll-escalate=%u "
-                "adopt-tier=%s allow-t0=%u verb-barrier=%u run-ahead=%u present-credit=%u control-timeout=%ums "
-                "cold-start=%ums strict=%d audit=%d role-split-state=%d affinity='%s' surface=%s",
-                ipc.RingMb, ipc.StageMb, ipc.WireDeferredMb, ipc.SpinUs, ipc.EventWaitMs,
-                ipc.PersistentBlockKb, ipc.CreateWindow, ipc.PboReadbackSync, ipc.PollEscalate,
-                ipc.AdoptTier == 0 ? "0" : ipc.AdoptTier == 1 ? "1" : ipc.AdoptTier == 2 ? "2" : "unset(T0)",
-                ipc.AllowAdoptT0,
-                ipc.VerbBarrier, ipc.RunAhead, ipc.PresentCredit, ipc.ControlTimeoutMs, ipc.ColdStartMs,
-                static_cast<int>(ipc.StrictErrors), static_cast<int>(ipc.Audit),
-                static_cast<int>(ipc.RoleSplitState), ipc.ServerAffinity.c_str(),
-                MG_Config::ServerOwnedWindowSurfaces() ? "server" : "offscreen");
-        if (ipc.VerbBarrier == 0) {
-            MGLOG_W("Config: MOBILEGL_IPC_VERB_BARRIER=0 is the R-1 NEGATIVE CONTROL and is "
-                    "expected to fail: the client still pulls 31 of 63 PipeInputs fields from a "
-                    "live GLContext, so an unbarriered queue lets the server read future values");
-        }
-        if (ipc.WireDeferredMb == 0) {
-            MGLOG_W("Config: MOBILEGL_IPC_WIRE_DEFERRED_MB=0 is the M2 NEGATIVE CONTROL: the "
-                    "server never forces a sync for orphaned wire buffer stores, so a long frame "
-                    "that respecifies and draws holds every one of them until the frame ends");
-        }
-        if (ipc.PersistentBlockKb == 0) {
-            MGLOG_W("Config: MOBILEGL_IPC_PERSISTENT_BLOCK_KB=0 is the E3(a) NEGATIVE CONTROL: "
-                    "the persistent-map push is OFF and a coherent-map scenario must go red");
-        }
-    }
-#endif
-
-    void Init() {
-        MGLOG_D("Loading configuration from environment variables...");
-        InitializeAcceptedEnvVariables();
-
-        InitBackendType();
-        InitFeatures();
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // After InitFeatures, so the one line InitIpc logs is the last word on this run's
-        // configuration, and before the accepted-env map is destroyed just below.
-        InitTransport();
-        InitIpc();
-#endif
-
-        // Destroy the map since we won't need it anymore
-        acceptedEnvVariablesMap.reset();
-    }
-} // namespace MobileGL::MG_ConfigLoader

MobileGL/Defines.h

@@ -8,23 +8,11 @@
 
 #pragma once
 
-#include <cstdio>
-
 // ============== 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
@@ -36,11 +24,6 @@
 #ifdef _WIN32
 #define MOBILEGL_EXPORT extern "C" __declspec(dllexport)
 #else
-// Default visibility, which is what the platform's own GL and EGL headers declare their entry
-// points with.  The one place where that is not enough - a vendor library handing glvnd its own
-// entry points, where a reference resolving against the process instead of this library would be a
-// call back into the dispatcher - is answered at link time with -Bsymbolic-functions rather than
-// here, because a second visibility on the same declaration does not compile.
 #define MOBILEGL_EXPORT extern "C" __attribute__((visibility("default")))
 #endif
 
@@ -49,31 +32,9 @@
 #define MOBILEGL_GLX_API MOBILEGL_API
 #define MOBILEGL_GL_API MOBILEGL_API
 #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
 
 #define MOBILEGL_LOG_ENABLE_CONSOLE 0
 #define MOBILEGL_LOG_ENABLE_FILE 1
@@ -102,21 +63,11 @@
 #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 {                                                                                                               \
-            if (!(condition)) {                                                                                            \
-                fprintf(stderr, "Assertion failed" __VA_OPT__(": ") "%s", "" __VA_ARGS__);                                 \
-                fprintf(stderr, "  at %s:%d (%s)\n", __FILE__, __LINE__, __func__);                                       \
-                TRAP;                                                                                                      \
-            }                                                                                                              \
-        } while (0)
-#else
-    #define MOBILEGL_ASSERT(condition, ...)
-#endif
+#define MOBILEGL_ASSERT(condition, ...)                                                                                \
+    do {                                                                                                               \
+        if (!(condition)) {                                                                                            \
+            MGLOG_F("Assertion failed" __VA_OPT__(": ") __VA_ARGS__);                                                  \
+            MGLOG_F("  at %s:%d (%s)", __FILE__, __LINE__, __func__);                                                  \
+            TRAP;                                                                                                      \
+        }                                                                                                              \
+    } while (0)

MobileGL/GlobalObjects.cpp

@@ -10,17 +10,11 @@
 
 namespace MobileGL {
     namespace MG_Config {
-        BackendType ActiveBackendType;
+        BackendType ActiveBackendType = BackendType::DirectVulkanTMP;
     } // 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

@@ -32,14 +32,13 @@
 #include <thread>
 #include <vector>
 #include <cassert>
-#include <climits>
-#include <cstdlib>
 #include <cstdarg>
 #include <cstring>
 #include <numeric>
 #include <expected>
 #include <iostream>
 #include <optional>
+#include <xxhash.h>
 #include <algorithm>
 #include <stdexcept>
 #include <functional>
@@ -49,11 +48,8 @@
 #include <stacktrace>
 #endif
 
-// Include ska::flat_hash_map
-#include <ska/flat_hash_map.hpp>
-
-// Include xxHash
-#include <xxhash.h>
+// Include FastSTL
+#include <FastSTL/UnorderedMap.h>
 
 // Include spirv_cross
 #include <spirv_cross/spirv_cross_c.h>
@@ -64,9 +60,7 @@
 #endif
 #include <EGL/egl.h>
 #define GL_GLEXT_PROTOTYPES
-#ifndef NO_GL_H
 #include "GL/gl.h"
-#endif
 #include <GL/glcorearb.h>
 #undef GL_GLEXT_PROTOTYPES
 
@@ -98,44 +92,13 @@
 #endif
 
 #ifdef __ANDROID__
+#define VK_USE_PLATFORM_ANDROID_KHR
 #include <unistd.h>
 #include <pthread.h>
 #include <android/log.h>
 #include <android/native_window.h>
 #endif
-
-#ifdef __ANDROID__
-#define VK_USE_PLATFORM_ANDROID_KHR
-#elif _WIN32
-#define VK_USE_PLATFORM_WIN32_KHR
-#elif defined(__APPLE__)
-#define VK_USE_PLATFORM_METAL_EXT
-#elif defined(__linux__)
-#define VK_USE_PLATFORM_XLIB_KHR
-typedef struct _XDisplay Display;
-typedef unsigned long XID;
-typedef XID Window;
-typedef unsigned long VisualID;
-#else
-#warning "VK_USE_PLATFORM_*_KHR not defined for this platform!"
-#endif
-#if defined(VK_USE_PLATFORM_XLIB_KHR)
-#pragma push_macro("Bool")
-#pragma push_macro("None")
-#pragma push_macro("Always")
-#pragma push_macro("Status")
-#pragma push_macro("LSBFirst")
-#pragma push_macro("DestroyAll")
-#endif
 #include <vulkan/vulkan.h>
-#if defined(VK_USE_PLATFORM_XLIB_KHR)
-#pragma pop_macro("DestroyAll")
-#pragma pop_macro("LSBFirst")
-#pragma pop_macro("Status")
-#pragma pop_macro("Always")
-#pragma pop_macro("None")
-#pragma pop_macro("Bool")
-#endif
 
 #ifdef TRACY_ENABLE
 #include <tracy/Tracy.hpp>

MobileGL/Init.cpp

@@ -8,227 +8,60 @@
 
 #include "Init.h"
 #include "Config.h"
+#include <MG_Impl/Init.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_Impl/GLImpl/Query/GL_Query.h>
-#include <MG_Util/Async/ShaderCompilePool.h>
-#include <MG_Util/Metrics/PipeStats.h>
-#include <MG_Util/ShaderTranspiler/ShaderCompiler.h>
-#include <MG_State/GLState/ProgramState/ProgramTranslationCache.h>
-#include <MG_Util/ShaderTranspiler/TranslationCache.h>
-#if MOBILEGL_PIPE_VERIFY
-#include <MG_Backend/MGPipe/PipeInputs.h> // MGPipeVerifyFlushSummary, before Debug::Close in DestroyImpl
-#endif
-
-#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;
-        }
-
-        void DestroyImpl(Bool logLifecycle) {
-            if (!g_isInitialized) {
-                return;
-            }
-
-            if (logLifecycle) {
-                MGLOG_I("MobileGL closing...");
-            }
-#if MOBILEGL_BUILD_DISAGGREGATED
-            // P5: the split roles come down FIRST - ARCHITECTURE.md:537's order puts the whole
-            // of it before MobileGL::Destroy(), and this function IS MobileGL::Destroy. A no-op
-            // in a monolith RUN; absent from a monolith BUILD, because G1 admits no new pull
-            // symbol and no resized one (the first version called it unconditionally and moved
-            // DestroyImpl by 32 bytes). See BackendObjects.h for why the position rather than
-            // the call is the load-bearing part.
-            MG_Backend::ShutdownSplitRoles();
-#endif
-            // Before any subsystem the counters name goes away, and before the last frame's
-            // numbers can be lost: emits the final summary line and, when
-            // MOBILEGL_PIPE_STATS_FILE is set, the JSON dump. A no-op when the counters are
-            // off, and idempotent.
-            MG_Util::PipeStats::Shutdown();
-            // First, before anything else is torn down. In-flight compile/link jobs own
-            // their own inputs and are safe against everything below EXCEPT glslang's
-            // process globals and the TShader/TProgram objects hanging off pGLContext,
-            // 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();
-            // Queries die with their contexts for the same reason, and their registry
-            // is the same shape of process-global map: drain it here too, while the
-            // function table can still pair each backend handle with the backend that
-            // minted it.
-            MG_Impl::GLImpl::DestroyAllQueryObjects();
-            MG_Backend::pActiveBackendObject.reset();
-            MG_State::pGLContext.reset();
-            MG_State::pEGLContext.reset();
-            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();
-            // The two-level translation memo. Nothing in it references a glslang object -
-            // both levels hold plain bytes - so this is RSS hygiene rather than a lifetime
-            // requirement, and it is safe either side of FinalizeProcess. Stats first: an
-            // fordebug build gets one line per level saying how the run went.
-            MG_Util::ShaderTranspiler::LogShaderTranslationCacheStats();
-            MG_Util::ShaderTranspiler::ClearShaderTranslationCaches();
-            MG_State::GLState::LogProgramTranslationCacheStats();
-            MG_State::GLState::ClearProgramTranslationCache();
-            MG_Backend::gBackendFunctionsTable = {};
-            g_isInitialized = false;
-#if MOBILEGL_PIPE_VERIFY
-            // BEFORE Close, and from here rather than from a static destructor (V1 fix round 2):
-            // Close() nulls the role's sink and Log.cpp's next write reopens it with "w", so the
-            // FATAL=0 summary the comparator used to write from __run_exit_handlers truncated the
-            // client half of every such run to that one line. Verify builds only - the guard is
-            // the compile definition, not a runtime knob, and the pull build gains no byte (G1).
-            MG_Pipe::MGPipeVerifyFlushSummary();
-#endif
-            if (logLifecycle) {
-                MG_Util::Debug::Close();
-            }
-
-            // TODO: add and use Destroy functions for other subsystems
-        }
-    }
-
-    void Initialize() {
-        if (g_isInitialized) {
-            MGLOG_D("MobileGL already initialized; skipping duplicate Initialize()");
-            return;
-        }
-
+    void MG_Initialize() {
         MG_Util::Debug::InitFile();
         MGLOG_I("Initializing MobileGL...");
-        MG_ConfigLoader::Init();
-        MGLOG_I("Config loaded");
-        // Immediately after the config load and before anything can count: the MGPipe
-        // boundary counters latch their enable flag here, so every counting site in the
-        // two backends is a load of an already-settled global for the rest of the run.
-        MG_Util::PipeStats::Init();
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // F1 (P7 wave 2). THE WIRE COMES UP BEFORE THE FIRST FRONTEND OBJECT IS BORN, and the
-        // ORDER is the fix - not a wait, and not a friendlier default mask.
-        //
-        // MG_State::Init() constructs GLContext, and GLContext's TextureState constructor
-        // materialises one default texture object per target (GL 3.3 core 3.8,
-        // TextureState.cpp:62-71). TextureObjectBase's constructor emits resource_create for
-        // every one of them (TextureState/TextureObject.cpp:168-169), and that emission is
-        // gated, through PipeFill's FamilyIsLive, on
-        // CapsMirror::ServerConsumes(kMGPipeSubsystemTextureResources). In the old order the
-        // mirror was still GENERATION 0 when it was asked - it had no snapshot because the
-        // session had not been started yet, MG_Backend::Init() being what starts it - so it
-        // answered from the placeholder, every one of those creates was withheld, and the log
-        // said so once and then never again:
-        //
-        //     MG_Remote client: the server does not consume MGPipe subsystem 0x400 - this
-        //     family emits NOTHING and the legacy pull path runs for it (R-8). callMask=0x0,
-        //     caps generation 0
-        //
-        // That is not a race and it never was one: the line reproduces byte-for-byte on
-        // lavapipe and on an Adreno 830, because the two Init calls are two statements in one
-        // thread. And "the legacy pull path runs for it" is false under split - the client has
-        // no pull path to fall back to - so the records are simply lost, and only a later
-        // respecify's self-healing create (TextureEmit.h:872) ever brings one back.
-        //
-        // A BOUNDED WAIT INSIDE ServerConsumes CANNOT FIX THIS AND WOULD DEADLOCK: during
-        // MG_State::Init() no handshake is in flight, and the one that will land is started
-        // LATER BY THIS SAME THREAD. The only correct answer is to have already brought it up,
-        // which is what this hook does. ServerConsumes now REFUSES to answer from a
-        // placeholder (CapsMirror.cpp), so a regression of this order is a named Fatal rather
-        // than a whole family of silently dropped records.
-        //
-        // In a build without MOBILEGL_BUILD_DISAGGREGATED this statement does not exist, so
-        // the pull build gains no symbol, no branch and no byte - which is what G1 measures.
-        const Bool splitBackendIsUp = MG_Backend::InitSplitRolesBeforeState();
-#endif
         MG_State::Init();
-        MGLOG_D("MG_State initialized");
-#if MOBILEGL_BUILD_DISAGGREGATED
-        if (!splitBackendIsUp)
-#endif
-        {
-            MG_Backend::Init();
-        }
-        MGLOG_D("MG_Backend initialized");
+        MGLOG_D("MobileGL State initialized");
+        MG_Backend::Init();
+        MGLOG_D("MobileGL Backend initialized");
         MG_Impl::Init();
-        MGLOG_D("MG_Impl initialized");
+        MGLOG_D("MobileGL Implementation 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 MG_Destroy() {
+        MGLOG_I("MobileGL closing...");
+        glslang::FinalizeProcess();
+        delete MG_State::pGLContext;
+        delete MG_Impl::GLImpl::TextureImpl::pProxyTextureManager;
+        delete MG_Impl::GLImpl::FramebufferImpl::pDefaultFramebufferInfo;
+        MG_Util::Debug::Close();
+
+        // TODO: add and use Destroy functions for other subsystems
     }
 
-    void Destroy() {
-        DestroyImpl(true);
+#if defined(__linux__) || defined(__APPLE__)
+    __attribute__((constructor)) static void AutoInit() {
+        MG_Initialize();
     }
 
-    // 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.
+    __attribute__((destructor)) static void AutoDestroy() {
+        MG_Destroy();
+    }
+#endif
+
+#ifdef _WIN32
+    BOOL WINAPI DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
+        switch (ul_reason_for_call) {
+        case DLL_PROCESS_ATTACH:
+            MG_Initialize();
+            break;
+
+        case DLL_PROCESS_DETACH:
+            MG_Destroy();
+            break;
+        }
+        return TRUE;
+    }
+#endif
 } // namespace MobileGL

MobileGL/Init.h

@@ -10,29 +10,6 @@
 #include "Includes.h"
 
 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 {
-        void InitFile();
-    } // namespace MG_Util::Debug
-
-    namespace MG_ConfigLoader {
-        void Init();
-    } // namespace MG_ConfigLoader
-
-    namespace MG_Backend {
-        void Init();
-    } // namespace MG_Backend
-
-    namespace MG_Impl {
-        void Init();
-    } // namespace MG_Impl
-} // namespace MobileGL
+    void MG_Initialize();
+    void MG_Destroy();
+} // namespace MobileGL

MobileGL/MG_Backend/BackendObject.cpp

@@ -7,570 +7,9 @@
 // End of Source File Header
 
 #include "BackendObject.h"
-#include "MG_Util/Converters/MGToStr/TextureEnumConverter.h"
-#include <algorithm>
-#include <cstring>
-#include <iomanip>
-#include <sstream>
 
 namespace MobileGL::MG_Backend {
-    namespace {
-        Bool IsReleaseCurrentRequest(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
-            (void)dpy;
-            return draw == EGL_NO_SURFACE && read == EGL_NO_SURFACE && ctx == EGL_NO_CONTEXT;
-        }
-
-        std::thread::id CurrentThreadKey() {
-            return std::this_thread::get_id();
-        }
-
-        const char* GetFormatCapabilitySupportString(const FormatCapabilityCache& cache,
-                                                     SizeT targetIndex,
-                                                     SizeT formatIndex,
-                                                     FormatCapability capability) {
-            if (HasFormatCapability(cache.FullCaps[targetIndex][formatIndex], capability)) return "Full";
-            if (HasFormatCapability(cache.CaveatCaps[targetIndex][formatIndex], capability)) return "Caveat";
-            return "None";
-        }
-
-        SizeT GetPrintedFormatNameWidth() {
-            SizeT width = 0;
-            for (SizeT formatIndex = 0; formatIndex < kFormatCapabilityFormatCount; ++formatIndex) {
-                const auto format = static_cast<TextureInternalFormat>(formatIndex);
-                width = std::max(width, MG_Util::ConvertTextureInternalFormatToString(format).size());
-            }
-            return width;
-        }
-
-        SizeT GetCapabilityColumnWidth(FormatCapability capability) {
-            SizeT width = std::strlen(GetFormatCapabilityName(capability));
-            width = std::max<SizeT>(width, std::strlen("Caveat"));
-            return width;
-        }
-
-        String BuildFormatCapabilityHeader(SizeT formatNameWidth) {
-            std::ostringstream line;
-            line << std::left << std::setw(static_cast<Int>(formatNameWidth)) << "";
-            for (FormatCapability capability : kReportedFormatCapabilities) {
-                line << " | " << std::left << std::setw(static_cast<Int>(GetCapabilityColumnWidth(capability)))
-                     << GetFormatCapabilityName(capability);
-            }
-            return line.str();
-        }
-
-        String BuildFormatCapabilityRow(const FormatCapabilityCache& cache,
-                                        SizeT targetIndex,
-                                        SizeT formatIndex,
-                                        SizeT formatNameWidth) {
-            const auto format = static_cast<TextureInternalFormat>(formatIndex);
-            std::ostringstream line;
-            line << std::left << std::setw(static_cast<Int>(formatNameWidth))
-                 << MG_Util::ConvertTextureInternalFormatToString(format);
-            for (FormatCapability capability : kReportedFormatCapabilities) {
-                line << " | " << std::left << std::setw(static_cast<Int>(GetCapabilityColumnWidth(capability)))
-                     << GetFormatCapabilitySupportString(cache, targetIndex, formatIndex, capability);
-            }
-            return line.str();
-        }
-    } // namespace
-
-    void FormatCapabilityCache::Clear() {
-        for (auto& row : FullCaps) {
-            row.fill(FormatCapabilityFlags{});
-        }
-        for (auto& row : CaveatCaps) {
-            row.fill(FormatCapabilityFlags{});
-        }
-        for (auto& row : SampleCounts) {
-            for (auto& counts : row) {
-                counts.clear();
-            }
-        }
-    }
-
-    Bool HasFormatCapability(FormatCapabilityFlags caps, FormatCapability capability) {
-        return static_cast<Bool>(caps & capability);
-    }
-
-    SizeT GetFormatCapabilityTargetIndex(TextureTarget target) {
-        if (target == TextureTarget::Unknown || static_cast<Int>(target) < 0 ||
-            static_cast<SizeT>(target) >= kFormatCapabilityTextureTargetCount) {
-            return kFormatCapabilityTargetCount;
-        }
-        return static_cast<SizeT>(target);
-    }
-
-    SizeT GetRenderbufferFormatCapabilityTargetIndex() {
-        return kFormatCapabilityRenderbufferTargetIndex;
-    }
-
-    const char* GetFormatCapabilityName(FormatCapability capability) {
-        switch (capability) {
-        case FormatCapability::Creatable:
-            return "Creatable";
-        case FormatCapability::Sampled:
-            return "Sampled";
-        case FormatCapability::LinearFilter:
-            return "LinearFilter";
-        case FormatCapability::GenerateMipmap:
-            return "GenerateMipmap";
-        case FormatCapability::TextureGather:
-            return "TextureGather";
-        case FormatCapability::TextureShadow:
-            return "TextureShadow";
-        case FormatCapability::FramebufferRenderable:
-            return "FramebufferRenderable";
-        case FormatCapability::FramebufferLayered:
-            return "FramebufferLayered";
-        case FormatCapability::MultisampleTexture:
-            return "MultisampleTexture";
-        case FormatCapability::MultisampleRenderbuffer:
-            return "MultisampleRenderbuffer";
-        case FormatCapability::ColorAttachment:
-            return "ColorAttachment";
-        case FormatCapability::DepthAttachment:
-            return "DepthAttachment";
-        case FormatCapability::StencilAttachment:
-            return "StencilAttachment";
-        case FormatCapability::TextureBuffer:
-            return "TextureBuffer";
-        }
-        return "Unknown";
-    }
-
-    String GetFormatCapabilityTargetName(SizeT targetIndex) {
-        if (targetIndex == kFormatCapabilityRenderbufferTargetIndex) {
-            return "Renderbuffer";
-        }
-        if (targetIndex >= kFormatCapabilityTextureTargetCount) {
-            return "Unknown";
-        }
-        return MG_Util::ConvertTextureTargetToString(static_cast<TextureTarget>(targetIndex));
-    }
-
-    void PrintFormatCapabilities(const FormatCapabilityCache& cache) {
-        const SizeT formatNameWidth = GetPrintedFormatNameWidth();
-
-        MGLOG_D("Backend format capabilities:");
-        for (SizeT targetIndex = 0; targetIndex < kFormatCapabilityTargetCount; ++targetIndex) {
-            MGLOG_D("");
-            const String targetName = GetFormatCapabilityTargetName(targetIndex);
-            MGLOG_D("- %s", targetName.c_str());
-            const String header = BuildFormatCapabilityHeader(formatNameWidth);
-            MGLOG_D("%s", header.c_str());
-            for (SizeT formatIndex = 0; formatIndex < kFormatCapabilityFormatCount; ++formatIndex) {
-                const String row = BuildFormatCapabilityRow(cache, targetIndex, formatIndex, formatNameWidth);
-                MGLOG_D("%s", row.c_str());
-            }
-        }
-    }
-
-    Bool BackendObject::InitializeEGLDisplay(EGLDisplay dpy, EGLint* major, EGLint* minor) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        if (dpy == EGL_NO_DISPLAY) {
-            MGLOG_E("InitializeEGLDisplay failed: invalid EGLDisplay");
-            return false;
-        }
-
-        // A DISPLAY IS A CONNECTION, NOT A RESOURCE THIS BACKEND OWNS, and refusing the second one
-        // refused a caller for a reason that is not there: the surface and context tables are keyed
-        // by the display each was created on, every operation carries its own display handle, and
-        // this field has no reader anywhere - it was the whole of the rule.
-        //
-        // What the rule cost was a compositor.  One asks for the display it will draw into AFTER
-        // probing another, so the second eglInitialize is the one that matters, and a refusal there
-        // is reported one layer up as "no usable DRM render device" - the probe having succeeded
-        // and the real display having failed, with nothing in between that says which was refused.
-        m_eglDisplay = dpy;
-        m_eglDisplayInitialized = true;
-        if (major) {
-            *major = 1;
-        }
-        if (minor) {
-            *minor = 5;
-        }
-        return true;
-    }
-
-    Bool BackendObject::CreateEGLWindowSurface(EGLSurface surface, const WindowHandle& handle) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        return RegisterEGLWindowSurface(surface, handle) && ActivateEGLSurface(surface);
-    }
-
-    Bool BackendObject::ResizeEGLWindowSurface(EGLSurface surface, Uint32 width, Uint32 height) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        auto surfaceIt = m_eglSurfaces.find(surface);
-        if (surfaceIt == m_eglSurfaces.end() || surfaceIt->second.Kind != SurfaceKind::Window) {
-            MGLOG_E("ResizeEGLWindowSurface failed: no window surface is initialized");
-            return false;
-        }
-        surfaceIt->second.Window.Width = width;
-        surfaceIt->second.Window.Height = height;
-        if (m_eglSurface == surface) {
-            m_windowHandle.Width = width;
-            m_windowHandle.Height = height;
-        }
-        return true;
-    }
-
-    // The frame itself is the backend's business (InitHostFrameSurface); what happens here is
-    // the registration every surface kind shares, so the swap path and the state mirrors see
-    // a host-framed surface exactly like any other.
-    Bool BackendObject::CreateEGLHostFrameSurface(EGLSurface surface, Uint32 width, Uint32 height) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        if (!m_eglDisplayInitialized) {
-            MGLOG_E("CreateEGLHostFrameSurface failed: EGL display is not initialized");
-            return false;
-        }
-        if (surface == EGL_NO_SURFACE) {
-            MGLOG_E("CreateEGLHostFrameSurface failed: invalid EGLSurface");
-            return false;
-        }
-        auto& state = m_eglSurfaces[surface];
-        state = EGLSurfaceState{
-            .Kind = SurfaceKind::HostFrame,
-            .Width = static_cast<EGLint>(std::max<Uint32>(width, 1)),
-            .Height = static_cast<EGLint>(std::max<Uint32>(height, 1)),
-        };
-        return ActivateEGLSurface(surface);
-    }
-
-    Bool BackendObject::CreateEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        return RegisterEGLPbufferSurface(surface, width, height) && ActivateEGLSurface(surface);
-    }
-
-    Bool BackendObject::RegisterEGLWindowSurface(EGLSurface surface, const WindowHandle& handle) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        if (!m_eglDisplayInitialized) {
-            MGLOG_E("RegisterEGLWindowSurface failed: EGL display is not initialized");
-            return false;
-        }
-        if (surface == EGL_NO_SURFACE) {
-            MGLOG_E("RegisterEGLWindowSurface failed: invalid EGLSurface");
-            return false;
-        }
-        if (handle.Backend == WindowBackend::Unknown || !handle.Handle) {
-            MGLOG_E("RegisterEGLWindowSurface failed: invalid native window handle");
-            return false;
-        }
-
-        auto& state = m_eglSurfaces[surface];
-        state = EGLSurfaceState{
-            .Kind = SurfaceKind::Window,
-            .Window = handle,
-            .Width = static_cast<EGLint>(std::max<Uint32>(handle.Width, 1)),
-            .Height = static_cast<EGLint>(std::max<Uint32>(handle.Height, 1)),
-        };
-        return true;
-    }
-
-    Bool BackendObject::RegisterEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        if (!m_eglDisplayInitialized) {
-            MGLOG_E("RegisterEGLPbufferSurface failed: EGL display is not initialized");
-            return false;
-        }
-        if (surface == EGL_NO_SURFACE) {
-            MGLOG_E("RegisterEGLPbufferSurface failed: invalid EGLSurface");
-            return false;
-        }
-        if (width <= 0 || height <= 0) {
-            MGLOG_E("RegisterEGLPbufferSurface failed: invalid size %dx%d", width, height);
-            return false;
-        }
-
-        m_eglSurfaces[surface] = EGLSurfaceState{
-            .Kind = SurfaceKind::Pbuffer,
-            .Width = width,
-            .Height = height,
-        };
-        return true;
-    }
-
-    const BackendObject::EGLSurfaceState* BackendObject::GetRegisteredEGLSurface(EGLSurface surface) const {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        auto surfaceIt = m_eglSurfaces.find(surface);
-        return surfaceIt == m_eglSurfaces.end() ? nullptr : &surfaceIt->second;
-    }
-
-    Bool BackendObject::ActivateEGLSurface(EGLSurface surface) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        const auto* surfaceState = GetRegisteredEGLSurface(surface);
-        if (!surfaceState) {
-            MGLOG_E("ActivateEGLSurface failed: EGL surface is not registered");
-            return false;
-        }
-        if (m_eglSurfaceInitialized && m_eglSurface == surface) {
-            return true;
-        }
-
-        if (surfaceState->Kind == SurfaceKind::Window) {
-            SetWindowHandle(surfaceState->Window);
-            if (!InitWindowSurface()) {
-                MGLOG_E("ActivateEGLSurface failed: backend InitWindowSurface failed");
-                return false;
-            }
-        } else if (surfaceState->Kind == SurfaceKind::Pbuffer) {
-            if (!InitPbufferSurface(surfaceState->Width, surfaceState->Height)) {
-                MGLOG_E("ActivateEGLSurface failed: backend InitPbufferSurface failed");
-                return false;
-            }
-        } else if (surfaceState->Kind == SurfaceKind::HostFrame) {
-            if (!InitHostFrameSurface(surfaceState->Width, surfaceState->Height)) {
-                MGLOG_E("ActivateEGLSurface failed: backend InitHostFrameSurface failed");
-                return false;
-            }
-        } else {
-            MGLOG_E("ActivateEGLSurface failed: unsupported surface kind");
-            return false;
-        }
-
-        m_eglSurface = surface;
-        m_eglSurfaceInitialized = true;
-        m_eglSurfaceKind = surfaceState->Kind;
-        m_eglCurrentThreads.clear();
-        m_backendCapabilitiesInitialized = false;
-        return true;
-    }
-
-    Bool BackendObject::MakeEGLCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        const auto threadKey = CurrentThreadKey();
-        if (IsReleaseCurrentRequest(dpy, draw, read, ctx)) {
-            ReleaseEGLCurrentThread(threadKey);
-            return true;
-        }
-
-        if (!m_eglDisplayInitialized || m_eglDisplay != dpy) {
-            MGLOG_E("MakeEGLCurrent failed: EGL display mismatch or not initialized");
-            return false;
-        }
-        // EGL_KHR_surfaceless_context.  A context whose draw and read surfaces are both absent has
-        // no framebuffer of its own to be bound to: the caller draws into framebuffers it binds
-        // itself, and this side only has to have its own GL context current on this thread for the
-        // records that follow.  Everything below this point describes a surface, so none of it
-        // applies - and what is recorded is exactly what was asked for, so a later swap on a
-        // surface that does not exist is never made to look like one that does.
-        if (draw == EGL_NO_SURFACE && read == EGL_NO_SURFACE && ctx != EGL_NO_CONTEXT) {
-            if (!m_backendCapabilitiesInitialized) {
-                if (!InitCapabilities()) {
-                    MGLOG_E("MakeEGLCurrent failed: InitCapabilities failed");
-                    return false;
-                }
-                m_backendCapabilitiesInitialized = true;
-            }
-            ReleaseEGLCurrentThread(threadKey);
-            m_eglCurrentThreads[threadKey] = EGLCurrentState{
-                .Display = dpy,
-                .DrawSurface = EGL_NO_SURFACE,
-                .ReadSurface = EGL_NO_SURFACE,
-                .Context = ctx,
-            };
-            return true;
-        }
-        if (!m_eglSurfaceInitialized) {
-            if (draw != read || !ActivateEGLSurface(draw)) {
-                MGLOG_E("MakeEGLCurrent failed: EGL surface is not initialized");
-                return false;
-            }
-        }
-        if (!GetRegisteredEGLSurface(draw) || !GetRegisteredEGLSurface(read)) {
-            MGLOG_E("MakeEGLCurrent failed: EGL surface is not registered");
-            return false;
-        }
-        if (draw != read) {
-            MGLOG_E("MakeEGLCurrent failed: separate draw/read surfaces are not supported");
-            return false;
-        }
-        if (draw != m_eglSurface && !ActivateEGLSurface(draw)) {
-            MGLOG_E("MakeEGLCurrent failed: EGL surface is not backed by this backend");
-            return false;
-        }
-        if (draw == EGL_NO_SURFACE || read == EGL_NO_SURFACE || ctx == EGL_NO_CONTEXT) {
-            MGLOG_E("MakeEGLCurrent failed: draw/read/context is invalid");
-            return false;
-        }
-
-        if (!m_backendCapabilitiesInitialized) {
-            if (!InitCapabilities()) {
-                MGLOG_E("MakeEGLCurrent failed: InitCapabilities failed");
-                return false;
-            }
-            m_backendCapabilitiesInitialized = true;
-        }
-
-        ReleaseEGLCurrentThread(threadKey);
-        m_eglCurrentThreads[threadKey] = EGLCurrentState{
-            .Display = dpy,
-            .DrawSurface = draw,
-            .ReadSurface = read,
-            .Context = ctx,
-        };
-        return true;
-    }
-
-    void BackendObject::ResetEGLRuntimeState() {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        m_eglSurfaceInitialized = false;
-        m_backendCapabilitiesInitialized = false;
-        m_eglSurfaceKind = SurfaceKind::None;
-        m_eglSurface = EGL_NO_SURFACE;
-        m_windowHandle = {};
-        m_eglCurrentThreads.clear();
-    }
-
-    Bool BackendObject::SwapEGLBuffers(EGLDisplay dpy, EGLSurface draw) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        if (!m_eglDisplayInitialized || m_eglDisplay != dpy) {
-            MGLOG_E("SwapEGLBuffers failed: EGL display mismatch or not initialized");
-            return false;
-        }
-        const auto currentIt = m_eglCurrentThreads.find(CurrentThreadKey());
-        if (currentIt == m_eglCurrentThreads.end()) {
-            MGLOG_E("SwapEGLBuffers failed: no current context attached");
-            return false;
-        }
-        if (currentIt->second.Display != dpy || currentIt->second.DrawSurface != draw ||
-            currentIt->second.Context == EGL_NO_CONTEXT) {
-            MGLOG_E("SwapEGLBuffers failed: draw surface is not current on this thread");
-            return false;
-        }
-        if (!m_eglSurfaceInitialized || draw == EGL_NO_SURFACE || draw != m_eglSurface) {
-            MGLOG_E("SwapEGLBuffers failed: invalid draw surface");
-            return false;
-        }
-
-        // A host-framed surface has no swapchain: presenting it means telling the host the frame
-        // is drawn, because the host is what puts it on the glass.
-        if (m_eglSurfaceKind == SurfaceKind::HostFrame) {
-            return PresentHostFrame();
-        }
-
-        const auto& backendFunctions = GetBackendFunctions();
-        if (!backendFunctions.Present) {
-            MGLOG_E("SwapEGLBuffers failed: backend Present function is null");
-            return false;
-        }
-
-        backendFunctions.Present();
-        return true;
-    }
-
-    void BackendObject::SetEGLSwapInterval(Int interval) {
-        const auto& backendFunctions = GetBackendFunctions();
-        if (backendFunctions.SetSwapInterval) {
-            backendFunctions.SetSwapInterval(interval);
-        }
-    }
-
-    // A backend that has no host-framed surfaces says so by name: the server may ask for one
-    // (MOBILEGL_IPC_SURFACE=host) against a build that cannot serve it, and that has to be a
-    // refusal with a reason rather than a surface that draws nowhere.
-    Bool BackendObject::InitHostFrameSurface(EGLint width, EGLint height) {
-        (void)width;
-        (void)height;
-        MGLOG_E("InitHostFrameSurface: this backend has no host-framed surfaces");
-        return false;
-    }
-
-    Bool BackendObject::PresentHostFrame() {
-        MGLOG_E("PresentHostFrame: this backend has no host-framed surfaces");
-        return false;
-    }
-
-    Bool BackendObject::PresentHostFrameIfCurrent() {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        if (!m_eglSurfaceInitialized || m_eglSurfaceKind != SurfaceKind::HostFrame) return true;
-        return PresentHostFrame();
-    }
-
-    Bool BackendObject::IsEGLSurfaceCurrent(EGLSurface surface) const {
-        if (surface == EGL_NO_SURFACE) {
-            return false;
-        }
-        for (const auto& current : m_eglCurrentThreads) {
-            if (current.second.DrawSurface == surface || current.second.ReadSurface == surface) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    void BackendObject::DestroyPendingEGLSurfaceIfUnused(EGLSurface surface) {
-        auto surfaceIt = m_eglSurfaces.find(surface);
-        if (surfaceIt == m_eglSurfaces.end() || !surfaceIt->second.DestroyPending ||
-            IsEGLSurfaceCurrent(surface)) {
-            return;
-        }
-
-        m_eglSurfaces.erase(surfaceIt);
-        if (m_eglSurface == surface) {
-            OnEGLSurfaceReleased(surface);
-            ResetEGLRuntimeState();
-        }
-    }
-
-    void BackendObject::ReleaseEGLCurrentThread(const std::thread::id& threadKey) {
-        auto currentIt = m_eglCurrentThreads.find(threadKey);
-        if (currentIt == m_eglCurrentThreads.end()) {
-            return;
-        }
-
-        const EGLSurface drawSurface = currentIt->second.DrawSurface;
-        const EGLSurface readSurface = currentIt->second.ReadSurface;
-        m_eglCurrentThreads.erase(currentIt);
-        DestroyPendingEGLSurfaceIfUnused(drawSurface);
-        DestroyPendingEGLSurfaceIfUnused(readSurface);
-    }
-
-    void BackendObject::ReleaseEGLSurface(EGLSurface surface) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        auto surfaceIt = m_eglSurfaces.find(surface);
-        if (surfaceIt == m_eglSurfaces.end()) {
-            return;
-        }
-
-        if (IsEGLSurfaceCurrent(surface)) {
-            surfaceIt->second.DestroyPending = true;
-            return;
-        }
-
-        m_eglSurfaces.erase(surfaceIt);
-        if (m_eglSurface == surface) {
-            OnEGLSurfaceReleased(surface);
-            ResetEGLRuntimeState();
-        }
-    }
-
-    void BackendObject::ReleaseEGLResources() {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
-        ResetEGLRuntimeState();
-        m_eglSurfaces.clear();
-        m_eglDisplay = EGL_NO_DISPLAY;
-        m_eglDisplayInitialized = false;
-    }
-
     void BackendObject::SetWindowHandle(const WindowHandle& handle) {
-        const std::lock_guard<std::recursive_mutex> lock(m_eglStateMutex);
         m_windowHandle = handle;
     }
-
-    const FormatCapabilityCache& BackendObject::GetFormatCapabilities() const {
-        return m_formatCapabilities;
-    }
-
-    FormatCapabilityCache& BackendObject::MutableFormatCapabilities() {
-        return m_formatCapabilities;
-    }
-
-    Bool BackendObject::InitPbufferSurface(EGLint width, EGLint height) {
-        (void)width;
-        (void)height;
-        return false;
-    }
-
-    void BackendObject::OnEGLSurfaceReleased(EGLSurface surface) {
-        (void)surface;
-    }
 } // namespace MobileGL::MG_Backend

MobileGL/MG_Backend/BackendObject.h

@@ -8,136 +8,21 @@
 
 #pragma once
 #include <Includes.h>
-#include "MG_State/GLState/TextureState/TextureEnum.h"
-#if MOBILEGL_BUILD_DISAGGREGATED
-#include <MG_Pipe/MGPipeHandles.h>
-#endif
 
 namespace MobileGL {
-    namespace MG_State::GLState {
-        class FramebufferObject;
-        class ITextureObject;
-        class RenderbufferObject;
-    }
-
     enum class BackendType {
         DirectGLES,
-        DirectVulkan,
+        DirectVulkanTMP,
         BackendTypeCount,
         Unknown = -1
     };
 
     namespace MG_Backend {
-        // One endpoint of a glCopyImageSubData. GL 4.6 core 18.3.2 accepts GL_RENDERBUFFER
-        // alongside the ten whole-image texture targets, and a renderbuffer name lives in a
-        // namespace of its own - so an endpoint is a sum type, not an ITextureObject. At most
-        // one of the two pointers is set; neither is set when the name named nothing, which is
-        // the INVALID_VALUE the frontend validator reports.
-        struct CopyImageEndpoint {
-            SharedPtr<MG_State::GLState::ITextureObject> Texture;
-            SharedPtr<MG_State::GLState::RenderbufferObject> Renderbuffer;
-#if MOBILEGL_BUILD_DISAGGREGATED
-            MG_Pipe::MGPipeHandle TextureHandle = MG_Pipe::kMGPipeNullHandle;
-            MG_Pipe::MGPipeHandle RenderbufferHandle = MG_Pipe::kMGPipeNullHandle;
-#endif
-
-            Bool IsRenderbuffer() const {
-#if MOBILEGL_BUILD_DISAGGREGATED
-                if (!MG_Pipe::MGPipeHandleIsNull(RenderbufferHandle)) return true;
-#endif
-                return Renderbuffer != nullptr;
-            }
-            Bool Exists() const {
-#if MOBILEGL_BUILD_DISAGGREGATED
-                if (!MG_Pipe::MGPipeHandleIsNull(TextureHandle)) return true;
-                if (!MG_Pipe::MGPipeHandleIsNull(RenderbufferHandle)) return true;
-#endif
-                return Texture != nullptr || Renderbuffer != nullptr;
-            }
-        };
-
-        enum class FormatCapability : Uint64 {
-            Creatable = 1ull << 0,
-
-            Sampled = 1ull << 1,
-            LinearFilter = 1ull << 2,
-            GenerateMipmap = 1ull << 3,
-            TextureGather = 1ull << 4,
-            TextureShadow = 1ull << 5,
-
-            FramebufferRenderable = 1ull << 6,
-            FramebufferLayered = 1ull << 7,
-            MultisampleTexture = 1ull << 8,
-            MultisampleRenderbuffer = 1ull << 9,
-
-            ColorAttachment = 1ull << 10,
-            DepthAttachment = 1ull << 11,
-            StencilAttachment = 1ull << 12,
-
-            TextureBuffer = 1ull << 13
-        };
-
-        using FormatCapabilityFlags = Flags<FormatCapability>;
-
-        inline constexpr Array<FormatCapability, 14> kReportedFormatCapabilities = {
-            FormatCapability::Creatable,
-            FormatCapability::Sampled,
-            FormatCapability::LinearFilter,
-            FormatCapability::GenerateMipmap,
-            FormatCapability::TextureGather,
-            FormatCapability::TextureShadow,
-            FormatCapability::FramebufferRenderable,
-            FormatCapability::FramebufferLayered,
-            FormatCapability::MultisampleTexture,
-            FormatCapability::MultisampleRenderbuffer,
-            FormatCapability::ColorAttachment,
-            FormatCapability::DepthAttachment,
-            FormatCapability::StencilAttachment,
-            FormatCapability::TextureBuffer,
-        };
-
-        inline constexpr SizeT kFormatCapabilityTextureTargetCount =
-            static_cast<SizeT>(TextureTarget::TextureTargetCount);
-        inline constexpr SizeT kFormatCapabilityRenderbufferTargetIndex = kFormatCapabilityTextureTargetCount;
-        inline constexpr SizeT kFormatCapabilityTargetCount = kFormatCapabilityTextureTargetCount + 1;
-        inline constexpr SizeT kFormatCapabilityFormatCount =
-            static_cast<SizeT>(TextureInternalFormat::TextureInternalFormatCount);
-
-        using FormatCapabilityTable =
-            Array<Array<FormatCapabilityFlags, kFormatCapabilityFormatCount>, kFormatCapabilityTargetCount>;
-        using FormatSampleCountTable =
-            Array<Array<Vector<Int>, kFormatCapabilityFormatCount>, kFormatCapabilityTargetCount>;
-
-        struct FormatCapabilityCache {
-            FormatCapabilityTable FullCaps{};
-            FormatCapabilityTable CaveatCaps{};
-            FormatSampleCountTable SampleCounts{};
-
-            void Clear();
-        };
-
-        Bool HasFormatCapability(FormatCapabilityFlags caps, FormatCapability capability);
-        SizeT GetFormatCapabilityTargetIndex(TextureTarget target);
-        SizeT GetRenderbufferFormatCapabilityTargetIndex();
-        const char* GetFormatCapabilityName(FormatCapability capability);
-        String GetFormatCapabilityTargetName(SizeT targetIndex);
-        void PrintFormatCapabilities(const FormatCapabilityCache& cache);
-
-        // Opaque backend fence-sync handle, created by GLFunctionsTable::FenceSync
-        // and released by GLFunctionsTable::DeleteSync.
-        using BackendSyncHandle = void*;
-
-        // Opaque backend timer-query handle, created by
-        // GLFunctionsTable::BeginTimeElapsedQuery / QueryCounterTimestamp and
-        // released by GLFunctionsTable::DeleteBackendQuery.
-        using BackendQueryHandle = void*;
-
         struct GLFunctionsTable {
             void (*DrawArrays)(GLenum mode, GLint first, GLsizei count);
             void (*DrawElements)(GLenum mode, GLsizei count, GLenum type, const void* indices);
             void (*DrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const void* indices,
                                            GLint basevertex);
-            void (*MultiDrawArrays)(GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount);
             void (*MultiDrawElements)(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
                                       GLsizei drawcount);
             void (*MultiDrawElementsBaseVertex)(GLenum mode, const GLsizei* count, GLenum type,
@@ -146,10 +31,6 @@ namespace MobileGL {
             void (*MultiDrawElementsIndirect)(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount,
                                               GLsizei stride);
             void (*MultiDrawArraysIndirect)(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride);
-            void (*MultiDrawElementsIndirectCount)(GLenum mode, GLenum type, const void* indirect,
-                                                   GLintptr drawcount, GLsizei maxdrawcount, 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,
@@ -173,405 +54,29 @@ namespace MobileGL {
             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 (*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,
-                                         const SharedPtr<MG_State::GLState::FramebufferObject>& drawFramebuffer,
-                                         GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                                         GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                                         GLbitfield mask, GLenum filter);
             void (*CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
                                    GLsizei height, GLint border);
             void (*CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y,
                                       GLsizei width, GLsizei height);
-            void (*CopyImageSubData)(const CopyImageEndpoint& src,
-                                     GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ,
-                                     const CopyImageEndpoint& dst,
-                                     GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ,
-                                     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);
             void (*GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels);
-            void (*GetTextureImage)(const SharedPtr<MG_State::GLState::ITextureObject>& texture,
-                                    TextureUploadTarget uploadTarget, GLint level, GLenum format, GLenum type,
-                                    GLsizei bufSize, GLvoid* pixels);
-            void (*DispatchCompute)(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ);
-            void (*DispatchComputeIndirect)(GLintptr indirect);
-            void (*MemoryBarrier)(GLbitfield barriers);
-            void (*MemoryBarrierByRegion)(GLbitfield barriers);
-            void (*BindImageTexture)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer,
-                                     GLenum access, GLenum format);
-            // The ONLY indexed query that is genuinely a backend one, and only for the pnames
-            // MG_Impl/GLImpl/Getter/GL_Getter.cpp does not already own. Every indexed pname that
-            // names FRONTEND state - the indexed buffer bindings, the per-unit texture/sampler
-            // bindings, the image-unit bindings, the viewport rectangles, the indexed capabilities
-            // - is answered in GL_Getter::GetIntegeri_v and never reaches this entry; the
-            // 64-bit and float/double widths are derived there from the same answer, which is why
-            // no GetInteger64i_v/GetFloati_v/GetDoublei_v table entry exists. In practice this
-            // leaves GL_MAX_COMPUTE_WORK_GROUP_COUNT / _SIZE (also asked directly by
-            // MG_Util/ShaderTranspiler/CompileEnv.cpp) plus whatever pname the frontend has no
-            // case for at all.
-            void (*GetIntegeri_v)(GLenum target, GLuint index, GLint* data);
-            // There is deliberately NO GetProgramiv entry: glGetProgramiv describes the program
-            // the APPLICATION wrote - link status, the transform-feedback mode, the compute local
-            // size - all of which are frontend link artifacts on ProgramObject, and
-            // MG_Impl/GLImpl/Program/GL_Program.cpp answers every one of them from there. Asking a
-            // backend would mean asking about a DIFFERENT program (a SPIRV-Cross-generated ESSL
-            // one, or a SPIR-V module), in a namespace the application never sees.
-            // 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);
-            // 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
-            // fence right now (e.g. the calling thread does not own the backend
-            // context); the frontend treats such a sync as always signaled.
-            BackendSyncHandle (*FenceSync)();
-            GLenum (*ClientWaitSync)(BackendSyncHandle sync, GLbitfield flags, GLuint64 timeout);
-            void (*WaitSync)(BackendSyncHandle sync, GLbitfield flags, GLuint64 timeout);
-            void (*DeleteSync)(BackendSyncHandle sync);
-            Bool (*GetSyncStatus)(BackendSyncHandle sync); // true = signaled
-            // GL timer-query objects (GL_ARB_timer_query). All entries are
-            // optional (may be null); the frontend then falls back to zero
-            // results and reports GL_QUERY_COUNTER_BITS == 0.
-            // BeginTimeElapsedQuery / QueryCounterTimestamp may themselves
-            // return null when the backend cannot create a query right now;
-            // the frontend treats such a query as immediately available with
-            // a zero result.
-            // Dynamic support check: true only when the live backend can
-            // actually time at the moment of the call (extension / entry
-            // points / timestamp valid bits are known then, not at table
-            // init). Gates the advertised GL_QUERY_COUNTER_BITS.
-            Bool (*IsTimerQuerySupported)();
-            BackendQueryHandle (*BeginTimeElapsedQuery)();            // starts a TIME_ELAPSED span
-            void (*EndTimeElapsedQuery)(BackendQueryHandle query);    // ends the span
-            BackendQueryHandle (*QueryCounterTimestamp)();            // glQueryCounter(GL_TIMESTAMP) one-shot
-            Bool (*IsQueryResultAvailable)(BackendQueryHandle query); // non-blocking
-            // Returns true when a final value was produced (*outNanoseconds
-            // written; the frontend may cache it and release the handle).
-            // Returns false when the result could not be obtained YET - e.g.
-            // a Vulkan wait that refuses to block on a not-yet-submitted
-            // frame serial - in which case the frontend must keep the handle
-            // 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);
-            // Whether GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN should be answered from the
-            // frontend's own accounting wherever that accounting is exact - a capture with no
-            // geometry stage - instead of from the query above. Set by DirectGLES, whose result
-            // is whatever the ES driver's PRIMITIVES_WRITTEN counter says: Adreno reports twice
-            // the written count for a vertex-only capture that follows a large render pass,
-            // where the desktop-exact answer is the one the frontend already computed. Defaults
-            // to false, so a backend that never sets it keeps using its GPU result.
-            Bool PrefersCpuXfbPrimitiveAccounting = false;
-            // Transform feedback capture spans, for backends whose own GL/ES driver
-            // performs the capture (DirectGLES). Both optional; null means the backend
-            // drives capture from its draw recording instead (DirectVulkan). End is
-            // 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 {
             GLFunctionsTable GL;
             void (*Present)();
-            // Optional: applies the app-requested eglSwapInterval to the native
-            // presentation path (null = backend keeps its own pacing policy).
-            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 {
-            Uint64 UniformBufferOffsetAlignment = 256;
-            // GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, which is a SEPARATE limit from the
-            // uniform one and is routinely larger: Adreno 830 reports 32 for uniform buffers and
-            // 64 for storage buffers. Answering the storage query with the uniform value let an
-            // application bind a storage range at an offset the driver cannot address, which it
-            // accepted without error and then wrote somewhere else entirely.
-            Uint64 ShaderStorageBufferOffsetAlignment = 256;
-            // GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT. 1.0 means the backend cannot filter anisotropically,
-            // which is also why the extension is not advertised in that case.
-            Float MaxTextureMaxAnisotropy = 1.0f;
-            Float AliasedLineWidthRangeMin = 1.0f;
-            Float AliasedLineWidthRangeMax = 1.0f;
-            Float SmoothLineWidthRangeMin = 1.0f;
-            Float SmoothLineWidthRangeMax = 1.0f;
-            Float SmoothLineWidthGranularity = 1.0f;
-            Float PointSizeRangeMin = 1.0f;
-            Float PointSizeRangeMax = 1.0f;
-            Float PointSizeGranularity = 1.0f;
-            Int Max3DTextureSize = 16384;
-            Int MaxArrayTextureLayers = 2048;
-            Int MaxCubeMapTextureSize = 16384;
-            Int MaxFramebufferWidth = 16384;
-            Int MaxFramebufferHeight = 16384;
-            Int MaxFramebufferLayers = 2048;
-            Int MaxRenderbufferSize = 16384;
-            Int MaxTextureSize = 16384;
-            Int MaxColorTextureSamples = 1;
-            Int MaxDepthTextureSamples = 1;
-            Int MaxFramebufferSamples = 1;
-            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;
-            Int MaxCombinedTextureImageUnits = 192;
-            Int MaxVertexAttribs = 16;
-            Int MaxComputeShaderStorageBlocks = 8;
-            Int MaxCombinedShaderStorageBlocks = 32;
-            // Per-stage GL_MAX_*_SHADER_STORAGE_BLOCKS. Zero is a legal answer for the four
-            // non-compute, non-fragment stages and these defaults are the spec minimums, not
-            // placeholders: GL 4.6 table 23.64 and ES 3.2 table 21.44 both set the minimum for
-            // vertex, tessellation control, tessellation evaluation and geometry at 0, and only
-            // fragment (8 in GL, 4 in ES) and compute are guaranteed to have any. Every real ARM
-            // GLES driver takes that allowance - a Mali-G925 reports 0 for all four - so a
-            // backend that cannot honour a graphics-stage storage block MUST report 0 here
-            // rather than a hopeful number. Advertising a non-zero count the driver will refuse
-            // does not make the block work; it only moves the failure from an honest
-            // "unsupported" at query time to a backend link error the frontend never surfaces,
-            // after which every draw with that program silently renders nothing.
-            Int MaxVertexShaderStorageBlocks = 0;
-            Int MaxTessControlShaderStorageBlocks = 0;
-            Int MaxTessEvaluationShaderStorageBlocks = 0;
-            Int MaxGeometryShaderStorageBlocks = 0;
-            Int MaxFragmentShaderStorageBlocks = 8;
-            Int MaxComputeUniformBlocks = 12;
-            Int MaxComputeWorkGroupInvocations = 128;
-            // GL_MAX_COMPUTE_WORK_GROUP_COUNT / GL_MAX_COMPUTE_WORK_GROUP_SIZE, one value per
-            // axis. These six, with the invocations limit above, are the only indexed limits a
-            // backend genuinely OWNS - the device answers them (glGetIntegeri_v on DirectGLES,
-            // VkPhysicalDeviceLimits::maxComputeWorkGroupCount/Size on DirectVulkan) - and so
-            // the only ones that survive the retirement of the GetIntegeri_v table entry: they
-            // cross the MGPipe boundary inside MGPCaps, by inclusion of this struct (plan B
-            // section 4.4.1). Every other indexed pname names frontend state. RAW driver
-            // answers, like the invocations limit: GL_Getter and the compile environment floor
-            // them at the shared MIN_COMPUTE_WORK_GROUP_* minimums themselves. The defaults are
-            // the GL 4.3 core minimums (table 23.60) and describe the no-backend case, as
-            // MaxClipDistances' does.
-            Int MaxComputeWorkGroupCount[3] = {65535, 65535, 65535};
-            Int MaxComputeWorkGroupSize[3] = {1024, 1024, 64};
-            Int MaxShaderStorageBufferBindings = 8;
-            Int MaxTextureBufferSize = 65536;
-            // GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT; 1 means the offset is unconstrained.
-            Int TextureBufferOffsetAlignment = 1;
-            Int MaxUniformBufferBindings = 24;
-            Int MaxUniformBlockSize = 16384;
-            Int MaxImageUnits = 8;
-            Int MaxCombinedImageUniforms = 8;
-            Int MaxVertexImageUniforms = 0;
-            Int MaxGeometryImageUniforms = 0;
-            Int MaxFragmentImageUniforms = 8;
-            Int MaxComputeImageUniforms = 8;
-            Int MaxDrawBuffers = 8;
-            Int MaxColorAttachments = 8;
-            // GL_MAX_CLIP_DISTANCES. Zero is a legal answer here, not a placeholder, and a
-            // backend that cannot host a clip distance MUST report it: advertising eight the
-            // backend will refuse does not make gl_ClipDistance work, it only moves the failure
-            // from an honest "unsupported" at query time to a backend shader-compile error the
-            // frontend never surfaces, after which every draw with that program silently renders
-            // nothing. DirectGLES fills it from GL_EXT_clip_cull_distance, DirectVulkan from the
-            // shaderClipDistance device feature. The DEFAULT stays at the GL 4.3 core minimum
-            // because it describes the no-backend case (standalone shader compiles, unit tests),
-            // where there is no device to be honest about and BuildTBuiltInResource still has to
-            // hand glslang a workable gl_MaxClipDistances.
-            Int MaxClipDistances = 8;
-            // GL_MAX_CULL_DISTANCES and GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES, under exactly
-            // the contract stated for MaxClipDistances above: ZERO IS A LEGAL ANSWER and a
-            // backend that cannot host a cull distance MUST report it. The failure this prevents
-            // is worse than the clip one, because cull distance discards the whole primitive:
-            // glslang bounds gl_CullDistance[i] against maxCullDistances and expands
-            // gl_MaxCullDistances from it, SPIRV-Cross then emits
-            // `#extension GL_EXT_clip_cull_distance : require` into the ESSL, and a host driver
-            // without that extension rejects the program in an info log nobody surfaces. These
-            // used to be bare 8s inside BuildTBuiltInResource with no backend consulted at all.
-            // The DEFAULTS are the GL 4.5 core minimums for the same reason MaxClipDistances'
-            // is: they describe the no-backend case (standalone compiles, unit tests).
-            Int MaxCullDistances = 8;
-            Int MaxCombinedClipAndCullDistances = 8;
-            Int MaxViewports = 16;
-            // GL_LAYER_PROVOKING_VERTEX / GL_VIEWPORT_INDEX_PROVOKING_VERTEX: which vertex of a
-            // primitive supplies gl_Layer and gl_ViewportIndex. GL 4.6 table 23.65 makes
-            // GL_UNDEFINED_VERTEX a legal answer for both, and it is the honest default - naming
-            // a convention is a statement about behaviour, so a backend that does not pin one
-            // must not claim it does. DirectGLES fills the layer one from the ES 3.2 query and
-            // the viewport one from GL_OES_viewport_array, and leaves UNDEFINED where the
-            // capability is absent: without the viewport array extension only viewport 0 is ever
-            // rasterized, so no convention selects anything. DirectVulkan keeps UNDEFINED for
-            // both - which vertex provokes is decided per pipeline by
-            // VulkanRenderer::SelectProvokingVertexMode out of VK_EXT_provoking_vertex,
-            // provokingVertexModePerPipeline and the topology, so no single convention is true
-            // of the backend.
-            Uint32 LayerProvokingVertex = GL_UNDEFINED_VERTEX;
-            Uint32 ViewportIndexProvokingVertex = GL_UNDEFINED_VERTEX;
-            Int MaxViewportWidth = 16384;
-            Int MaxViewportHeight = 16384;
-            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 this backend can CONSUME a shader module that still declares 64-bit floats,
-            // i.e. whether `double` survives the transpile instead of being narrowed to `float`
-            // (ShaderTranspiler::DemoteFloat64Pass). Detected, never assumed:
-            //   * DirectVulkan sets it from VkPhysicalDeviceFeatures::shaderFloat64, the feature
-            //     VUID-VkShaderModuleCreateInfo-pCode-08740 requires before a module declaring
-            //     OpCapability Float64 may be created at all. lavapipe has it; Adreno and Mali
-            //     both report VK_FALSE, so no real mobile device does.
-            //   * DirectGLES can NEVER have it. GLSL ES has no 64-bit float type in any version
-            //     or extension, so SPIRV-Cross cannot emit one ("FP64 not supported in ES
-            //     profile") and the demotion there is mathematically mandatory, always.
-            // Defaults to false so a backend that never sets it - and the no-backend case, which
-            // is what standalone shader compiles and the unit tests run under - keeps the
-            // demotion, which is the behaviour that works everywhere.
-            Bool SupportsShaderFloat64 = false;
-            // Whether glVertexAttribLFormat / glVertexArrayAttribLFormat can be honoured, i.e.
-            // whether a 64-bit vertex attribute can actually reach a shader unconverted. Detected,
-            // never assumed: DirectVulkan needs VkPhysicalDeviceFeatures::shaderFloat64 (the
-            // attribute travels as its 32-bit word pair, so no VK_FORMAT_R64* is required, but the
-            // bitcast result is Float64); DirectGLES can never have it, ESSL having no fp64 type at
-            // all. Defaults to false so a backend that never sets it gets the conservative answer.
-            //
-            // INDEPENDENT of SupportsShaderFloat64, and it has to be: this flag decides a VkFormat
-            // from the VAO ATTRIBUTE alone, which does not know what type the shader declared, and
-            // glVertexAttribFormat(GL_DOUBLE) feeding a plain `in vec4` is both legal and common
-            // (KHR-GL43.vertex_attrib_binding.basic-input-case4/5, advanced-bindingUpdate). A
-            // backend with native fp64 that still cannot FETCH 64 bits keeps this false and relies
-            // on the per-MODULE rule in ShaderCompiler::SanitizeAndOptimizeBinary instead: a vertex
-            // module that declares a 64-bit float INPUT is demoted whole, so the two shader-side
-            // halves (PackDoubleVertexInputsPass and VertexInputStateFactory::ToVkVertexFormat)
-            // still see one consistent world.
-            Bool SupportsFloat64VertexAttributes = false;
-            // Whether a TESSELLATION stage of this backend may access gl_PointSize - i.e.
-            // whether a module declaring OpCapability TessellationPointSize can reach the
-            // driver at all. DirectVulkan sets both this and the geometry twin from the one
-            // shaderTessellationAndGeometryPointSize feature; DirectGLES sets them
-            // independently from the EXT/OES_tessellation_point_size /
-            // geometry_point_size extension pairs (PointSizeTier), which really do come
-            // separately. When absent, ProgramSpirvTask demotes the built-in to an ordinary
-            // varying program-wide (ShaderCompiler::
-            // DemoteTessellationGeometryPointSizeForProgram); MOBILEGL_POINT_SIZE_DEMOTION
-            // overrides the detection in either direction at backend init.
-            //
-            // Defaults TRUE, deliberately against the house "assume absent" rule: false
-            // ARMS a rewrite, so the conservative no-backend answer (standalone compiles,
-            // unit tests) is the one that leaves modules untouched. A backend that never
-            // sets it gets standard modules and, at worst, the old honest declines.
-            Bool SupportsTessellationPointSize = true;
-            // The geometry-stage twin (OpCapability GeometryPointSize).
-            Bool SupportsGeometryPointSize = true;
-            Uint64 MaxShaderStorageBlockSize = 128 * 1024 * 1024;
-            Uint32 SubgroupSize = 0;
-            Uint32 SubgroupSupportedStages = 0;
-            Uint32 SubgroupSupportedFeatures = 0;
-            Bool SubgroupQuadOperationsInAllStages = false;
-            GpuVendorKind GpuVendor = GpuVendorKind::Unknown;
+            SizeT UniformBufferOffsetAlignment = 256;
         };
 
         enum class WindowBackend {
             Android,
-            X11,
-            MetalLayer,
-            Win32, // Handle is an HWND
-            // TODO: Wayland, etc.
+            // TODO: X11, Wayland, Windows, macOS, etc.
             WindowBackendCount,
             Unknown = -1
         };
@@ -579,8 +84,6 @@ namespace MobileGL {
         struct WindowHandle {
             WindowBackend Backend = WindowBackend::Unknown;
             void* Handle = nullptr;
-            Uint32 Width = 0;
-            Uint32 Height = 0;
         };
 
         class BackendObject {
@@ -588,32 +91,8 @@ namespace MobileGL {
             virtual ~BackendObject() = default;
 
             virtual void Initialize() = 0;
-            virtual Bool InitCapabilities() = 0;
-            virtual Bool InitWindowSurface() = 0;
-
-            virtual Bool InitializeEGLDisplay(EGLDisplay dpy, EGLint* major, EGLint* minor);
-            virtual Bool CreateEGLWindowSurface(EGLSurface surface, const WindowHandle& handle);
-            virtual Bool ResizeEGLWindowSurface(EGLSurface surface, Uint32 width, Uint32 height);
-            virtual Bool CreateEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height);
-            // The host owns the screen: this side never gets a window of the client's to draw
-            // into, so the surface it draws into is a frame the host allocated and offered over
-            // the host frame bridge.  Each swap tells the host the frame is done and takes the
-            // next; presentation is the host's, not a swapchain's.
-            virtual Bool CreateEGLHostFrameSurface(EGLSurface surface, Uint32 width, Uint32 height);
-            virtual Bool InitHostFrameSurface(EGLint width, EGLint height);
-            virtual Bool PresentHostFrame();
-            // The present RECORD's half of a host-framed swap.  A split client's swap reaches the
-            // server as a present record (ServerVerbSink::OnPresent), never as SwapEGLBuffers, so
-            // without this the host was never told a frame was drawn.  True when the current
-            // surface is not host-framed: there is nothing to present then.
-            Bool PresentHostFrameIfCurrent();
-            virtual Bool MakeEGLCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
-            virtual Bool SwapEGLBuffers(EGLDisplay dpy, EGLSurface draw);
-            // Forwards the app-requested eglSwapInterval to the backend's native
-            // presentation path (no-op for backends without a SetSwapInterval hook).
-            virtual void SetEGLSwapInterval(Int interval);
-            virtual void ReleaseEGLSurface(EGLSurface surface);
-            virtual void ReleaseEGLResources();
+            virtual void InitCapabilities() = 0;
+            virtual void InitWindowSurface() = 0;
 
             void SetWindowHandle(const WindowHandle& handle);
 
@@ -621,60 +100,10 @@ namespace MobileGL {
             virtual String GetBackendAPIVersionString() const = 0;
             virtual const GlobalBackendFunctionsTable& GetBackendFunctions() const = 0;
             virtual const DynamicBackendParameters& GetDynamicParameters() const = 0;
-            const FormatCapabilityCache& GetFormatCapabilities() const;
             virtual BackendType GetBackendType() const = 0;
 
         protected:
-            enum class SurfaceKind {
-                None,
-                Window,
-                Pbuffer,
-                // A surface whose drawing target is a frame the display host owns.  There is no
-                // swapchain behind it: the host puts the frame on the glass when this side says
-                // it is drawn, which is why presenting one is its own call and not a Present.
-                HostFrame
-            };
-
-            struct EGLCurrentState {
-                EGLDisplay Display = EGL_NO_DISPLAY;
-                EGLSurface DrawSurface = EGL_NO_SURFACE;
-                EGLSurface ReadSurface = EGL_NO_SURFACE;
-                EGLContext Context = EGL_NO_CONTEXT;
-            };
-
-            struct EGLSurfaceState {
-                SurfaceKind Kind = SurfaceKind::None;
-                Bool DestroyPending = false;
-                WindowHandle Window;
-                EGLint Width = 1;
-                EGLint Height = 1;
-            };
-
-            void ResetEGLRuntimeState();
-            Bool RegisterEGLWindowSurface(EGLSurface surface, const WindowHandle& handle);
-            Bool RegisterEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height);
-            const EGLSurfaceState* GetRegisteredEGLSurface(EGLSurface surface) const;
-            Bool ActivateEGLSurface(EGLSurface surface);
-            virtual Bool InitPbufferSurface(EGLint width, EGLint height);
-            virtual void OnEGLSurfaceReleased(EGLSurface surface);
-            FormatCapabilityCache& MutableFormatCapabilities();
-
-            mutable std::recursive_mutex m_eglStateMutex;
-            FormatCapabilityCache m_formatCapabilities;
             WindowHandle m_windowHandle;
-            EGLDisplay m_eglDisplay = EGL_NO_DISPLAY;
-            EGLSurface m_eglSurface = EGL_NO_SURFACE;
-            Bool m_eglDisplayInitialized = false;
-            Bool m_eglSurfaceInitialized = false;
-            Bool m_backendCapabilitiesInitialized = false;
-            SurfaceKind m_eglSurfaceKind = SurfaceKind::None;
-            UnorderedMap<std::thread::id, EGLCurrentState> m_eglCurrentThreads;
-            UnorderedMap<EGLSurface, EGLSurfaceState> m_eglSurfaces;
-
-        private:
-            Bool IsEGLSurfaceCurrent(EGLSurface surface) const;
-            void DestroyPendingEGLSurfaceIfUnused(EGLSurface surface);
-            void ReleaseEGLCurrentThread(const std::thread::id& threadKey);
         };
     } // namespace MG_Backend
 } // namespace MobileGL

MobileGL/MG_Backend/BackendObjects.h

@@ -10,50 +10,11 @@
 #include <Includes.h>
 #include "BackendObject.h"
 #include "DirectGLES/BackendObject_DirectGLES.h"
-#include "DirectVulkan/BackendObject_DirectVulkan.h"
+#include "DirectVulkanTMP/BackendObject_DirectVulkanTMP.h"
 
 namespace MobileGL::MG_Backend {
-    extern UniquePtr<BackendObject>& pActiveBackendObject;
+    extern UniquePtr<BackendObject> pActiveBackendObject;
     extern GlobalBackendFunctionsTable gBackendFunctionsTable;
 
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // P5 v1. The counterpart of Init()'s single split hook, and a NO-OP in every run that is
-    // not split. It exists ONLY in a split build: G1 admits no new symbol in the pull build,
-    // so MobileGL/Init.cpp's call sits under the same #if rather than calling a no-op.
-    //
-    // IT MUST RUN FIRST, BEFORE ANYTHING ELSE IN DestroyImpl. ARCHITECTURE.md:537's order is
-    // publish -> the server drains and acks -> stop the apply thread (Kill, then join) -> close
-    // the transport -> the client drains the compile pool -> MobileGL::Destroy() -> release the
-    // sync/query handles; DestroyImpl IS MobileGL::Destroy, so everything before that arrow has
-    // to happen at its top. Two consequences are load-bearing rather than tidy:
-    //
-    //   * the apply thread is JOINED before PipeStats::Shutdown() dumps, so nothing is writing
-    //     a counter while the final line is produced;
-    //   * the apply thread is joined before pActiveBackendObject.reset(), so the server's own
-    //     BackendObject - which is NOT that global (table 3) - is destroyed on the thread that
-    //     owns the context, by ServerLoop::Stop, rather than on the app thread.
-    //
-    // The sync/query registries stay where they are, drained at MobileGL/Init.cpp:62 and :67
-    // BEFORE pActiveBackendObject.reset(). ARCHITECTURE.md:537 puts them after
-    // MobileGL::Destroy(); the two are only reconcilable if a split sync handle is
-    // client-minted and needs no backend call, which is P10's. CONTRACT-P5 4 flags this as a
-    // KNOWN OPEN ITEM and asks v1 to record which way it went: P5 keeps today's order.
-    void ShutdownSplitRoles();
-
-    // F1 (P7 wave 2). Init()'s SPLIT ARM, run BEFORE MG_State::Init() rather than after it.
-    //
-    // Returns true when this process took the split path - whether the bring-up succeeded or
-    // was refused by name - and the caller must then NOT call Init() a second time. Returns
-    // false under MG_Config::TransportMode::Monolith, where there is nothing to bring up and
-    // Init() keeps its own place after MG_State::Init().
-    //
-    // WHY IT EXISTS AT ALL, rather than MobileGL::Initialize simply calling Init() earlier:
-    // the monolith arm of Init() must keep running after MG_State::Init(), because
-    // BackendObject_DirectGLES::Initialize() is the tree's own order for it and moving it is a
-    // pull-build change G1 forbids. So the split arm - and only the split arm - moves.
-    //
-    // It exists ONLY in a split build, for the reason InitServerRoleForSpawn states: a
-    // definition guarded only on the inside still emits a symbol, and G1 measured that.
-    Bool InitSplitRolesBeforeState();
-#endif
+    void Init();
 } // namespace MobileGL::MG_Backend

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.h

@@ -8,43 +8,17 @@
 
 #pragma once
 #include <Includes.h>
-#include "HostFrameTarget.h"
-#include "MG_Backend/HostFrameBridge.h"
-#include "MG_Backend/GbmFrameChannel.h"
 #include "../BackendObject.h"
 #include <MG_Util/BackendLoaders/OpenGL/Loader.h>
 
 namespace MobileGL::MG_Backend::DirectGLES {
-    // Populates the same format-capability cache used by backend startup. The caller
-    // must keep the supplied GLES context current for the duration of this call.
-    void PopulateFormatCapabilities(const MG_External::GLESFunctionsTable& gl,
-                                    const MG_External::GLESCapabilities& capabilities,
-                                    FormatCapabilityCache& cache);
-
-    // Clamps a requested sample count down to what the ES driver can really deliver for this
-    // format on this format-capability target: the probed per-format list when there is one, the
-    // driver's per-class GL_MAX_*_SAMPLES otherwise. The frontend deliberately validates against
-    // the count MobileGL advertises instead (GL_Getter's GetAdvertisedMaxSamples), which on a
-    // driver reporting GL_MAX_INTEGER_SAMPLES 1 is higher than the driver accepts, so every ES
-    // allocation call has to come through here. The shadow state keeps the requested count, so
-    // GL_TEXTURE_SAMPLES and framebuffer completeness still answer what the application asked for.
-    Int ClampSamplesToBackendSupport(SizeT targetIndex, TextureInternalFormat logicalFormat, GLenum imageFormat,
-                                     Int samples);
-
     class BackendObject_DirectGLES : public BackendObject {
     public:
         ~BackendObject_DirectGLES() override;
 
         void Initialize() override;
-        Bool InitCapabilities() override;
-        Bool InitWindowSurface() override;
-        Bool InitializeEGLDisplay(EGLDisplay dpy, EGLint* major, EGLint* minor) override;
-        Bool CreateEGLWindowSurface(EGLSurface surface, const WindowHandle& handle) override;
-        Bool CreateEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height) override;
-        Bool MakeEGLCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) override;
-        Bool SwapEGLBuffers(EGLDisplay dpy, EGLSurface draw) override;
-        void ReleaseEGLSurface(EGLSurface surface) override;
-        void ReleaseEGLResources() override;
+        void InitCapabilities() override;
+        void InitWindowSurface() override;
 
         const RendererInfo& GetRendererInfo() const override;
         String GetBackendAPIVersionString() const override;
@@ -54,50 +28,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
 
         const MG_External::GLESFunctionsTable& GetGLESFunctions() const;
         const MG_External::EGLFunctionsTable& GetEGLFunctions() const;
-        void ApplyGLESCapabilitiesForTesting(const MG_External::GLESCapabilities& capabilities);
 
     private:
         void UpdateDynamicBackendParameters();
-        Bool InitPbufferSurface(EGLint width, EGLint height) override;
-        // A host-framed surface draws into a frame the display host owns; presenting one
-        // tells the host the frame is drawn, because the host is what puts it on the glass.
-        // NOT CreateEGLHostFrameSurface: the base class registers the surface and activates it,
-        // and activation is what reaches InitHostFrameSurface below.  There is nothing about the
-        // EGL side of a host-framed surface this backend needs to do its own way.
-        Bool InitHostFrameSurface(EGLint width, EGLint height) override;
-        Bool PresentHostFrame() override;
-        // Takes the next frame from the host and makes it this context's framebuffer.
-        Bool TakeHostFrame();
-        void DestroyHostFrame();
-        // The canvas the compositor draws into, made once at the first frame's size.
-        Bool EnsureHostFrameCanvas(Uint width, Uint height);
-        // Copies the canvas into the frame about to be presented.
-        void BlitHostFrameCanvas();
-        // What draws resolve to: the canvas when there is one, the frame itself otherwise.
-        const HostFrameTarget& HostFrameDrawTarget() const {
-            return m_hostFrameCanvas.Framebuffer != 0 ? m_hostFrameCanvas : m_hostFrameTarget;
-        }
-        void OnEGLSurfaceReleased(EGLSurface surface) override;
-
-        // MOBILEGL_IPC_SURFACE=host: the frames the display host owns, one at a time, which
-        // is what the host offers - it hands one over and waits for the answer before it
-        // presents it and offers the next.
-        MG_Backend::HostFrameBridge m_hostFrameBridge;
-        // The frames the bridge just took, on to the container: the Wayland compositor over there
-        // renders into this same memory, and the only route to it that end has is the dma-buf
-        // descriptor this channel offers per frame and reads a release back from.
-        MG_Backend::GbmFrameChannel m_gbmFrameChannel;
-        HostFrameTarget m_hostFrameTarget;
-        // A STABLE TARGET IN FRONT OF THE FRAMES.  Every present hands the frame back and takes
-        // a different one, and its renderbuffer is deleted with it - but a compositor attaches
-        // its framebuffers ONCE (kwin: one per daemon buffer, for the life of the process), so
-        // attachments bound to a frame's own renderbuffer named a deleted object from the second
-        // frame on.  The attachments name this instead, and each present copies it into the
-        // frame.  No EGLImage behind it (Image stays null).
-        HostFrameTarget m_hostFrameCanvas;
-        struct AHardwareBuffer* m_hostFrameBuffer = nullptr;
-        MG_Backend::HostFrameOffer m_hostFrameOffer{};
-        Bool m_hostFrameBridgeOpen = false;
 
         Bool m_initialized = false;
         MG_External::EGLFunctionsTable m_EGLFunctions;
@@ -105,29 +38,4 @@ namespace MobileGL::MG_Backend::DirectGLES {
         MG_External::GLESCapabilities m_GLESCapabilities;
         DynamicBackendParameters m_dynamicParameters;
     };
-
-    // Single-source-of-truth helpers shared with the driver POST
-    // (MG_Util/SelfTest/DriverPost.cpp), so the identity strings and extension list
-    // MobileGL reports to applications on this backend cannot drift from what the
-    // POST screen shows.
-
-    // Static identity of the Espryt renderer (renderer/backend names, target GL/GLSL
-    // versions, ExtraVendor). The Extensions vector inside is live backend state that
-    // is reconciled after capability init; callers that need the advertised list for
-    // a known capability set must use BuildAdvertisedExtensions instead.
-    const RendererInfo& GetRendererIdentity();
-
-    // The full OpenGL extension list Espryt advertises (glGetString(GL_EXTENSIONS))
-    // for a device whose timer queries / anisotropic filtering / native indirect draws /
-    // non-zero indirect baseInstance semantics / EXT-OES texture views are (or are not) usable.
-    // The MOBILEGL_DISABLE_TIMERQUERY escape hatch is applied inside.
-    Vector<GLExtension> BuildAdvertisedExtensions(Bool timerQueriesSupported, Bool anisotropicFilteringSupported,
-                                                  Bool drawIndirectSupported,
-                                                  Bool nonZeroIndirectBaseInstanceSupported,
-                                                  Bool textureViewSupported, Bool cubeMapArraySupported);
-
-    // Format: <OpenGL ES Renderer>, OpenGL ES <Major>.<Minor> — the exact string an
-    // initialized backend returns from GetBackendAPIVersionString (and that ends up
-    // inside the application-visible GL_RENDERER string).
-    String FormatBackendAPIVersionString(const String& glesRendererString, Int glesMajor, Int glesMinor);
 } // namespace MobileGL::MG_Backend::DirectGLES

MobileGL/MG_Backend/DirectGLES/ContextEpoch.h

@@ -1,23 +0,0 @@
-// MobileGL - DirectGLES context-owned static state identities (P5f fs).
-#pragma once
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-#include <Config.h>
-#include <MG_Pipe/PipeApply.h>
-
-namespace MobileGL::MG_Backend::DirectGLES {
-    extern Uint g_backendContextGeneration;
-
-    struct ContextEpoch {
-        Uint Native = 0;
-        Uint64 Served = 0;
-        Bool Server = false;
-        Bool operator==(const ContextEpoch&) const = default;
-    };
-
-    inline ContextEpoch CurrentContextEpoch() {
-        const Bool server = MG_Config::Transport != MG_Config::TransportMode::Monolith;
-        return {g_backendContextGeneration, server ? MG_Pipe::MGPipeApplierContextSerial() : 0, server};
-    }
-}
-#endif

MobileGL/MG_Backend/DirectGLES/DirectGLES.h

@@ -8,8 +8,6 @@
 
 #pragma once
 #include <Includes.h>
-#include <MG_Backend/BackendObject.h>
-#include <MG_State/GLState/FramebufferState/FramebufferObject.h>
 #include <MG_State/GLState/TextureState/TextureState.h>
 #include <MG_State/GLState/SamplerState/SamplerObject.h>
 #include <MG_Util/BackendLoaders/OpenGL/Loader.h>
@@ -19,26 +17,6 @@
     operation Utils::CheckGLESError();
 
 namespace MobileGL::MG_Backend::DirectGLES {
-    // Re-establishes the frontend texture-unit bindings on the native ES context.
-    // Content uploads use scratch bindings, so draws and dispatches call this after
-    // texture synchronization.
-    void BindCurrentTextures();
-    // Driver-side color/depth level readback. Returns tightly packed, owned
-    // bytes in the requested pair; never consults a frontend texture or PACK/PBO.
-    // The caller supplies identity and extent, and whether the SOURCE allocation
-    // already uses an image carrier.
-    Bool ReadTextureLevelTight(GLuint texture, TextureTarget target, TextureUploadTarget uploadTarget,
-                               TextureInternalFormat logicalFormat, GLint level, const IntVec3& logicalExtent,
-                               Bool sourceUsesImageCarrier, GLenum format, GLenum type, Vector<Uint8>& bytes);
-#if MOBILEGL_BUILD_DISAGGREGATED
-    Bool ReadTextureImageWire(const MG_Pipe::MGPReadbackInfo& info, Vector<Uint8>& bytes);
-    // Whether the NATIVE texture currently holds `level` of `uploadTarget` at `logicalExtent`
-    // (glGetTexLevelParameteriv). False for a level the driver never allocated - one defined after
-    // the texture's last sync - so a re-mint does not read what is not there. A query the driver
-    // refuses answers true, keeping the caller on its readback path.
-    Bool NativeTextureLevelHasExtent(GLuint texture, TextureTarget target, TextureUploadTarget uploadTarget,
-                                     GLint level, const IntVec3& logicalExtent);
-#endif
     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);
@@ -47,17 +25,12 @@ namespace MobileGL::MG_Backend::DirectGLES {
     void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices);
     void DrawArrays(GLenum mode, GLint first, GLsizei count);
     void DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLint basevertex);
-    void MultiDrawArrays(GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount);
     void MultiDrawElements(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
                            GLsizei drawcount);
     void MultiDrawElementsBaseVertex(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
                                      GLsizei drawcount, const GLint* basevertex);
     void MultiDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride);
-    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);
@@ -73,202 +46,23 @@ namespace MobileGL::MG_Backend::DirectGLES {
                                          GLuint baseinstance);
     void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
     void DrawArraysIndirect(GLenum mode, const void* indirect);
-    void ClearNamedFramebufferfv(const SharedPtr<MG_State::GLState::FramebufferObject>& framebuffer,
-                                 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,
-                              const SharedPtr<MG_State::GLState::FramebufferObject>& drawFramebuffer,
-                              GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                              GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                              GLbitfield mask, GLenum filter);
     void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
                         GLsizei height, GLint border);
     void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
                            GLsizei height);
-    void CopyImageSubData(const CopyImageEndpoint& src,
-                          GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ,
-                          const CopyImageEndpoint& dst,
-                          GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ,
-                          GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
     void GenerateMipmap(GLenum target);
     const GLubyte* GetString(GLenum name);
     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 DispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ);
-    void DispatchComputeIndirect(GLintptr indirect);
-    void MemoryBarrier(GLbitfield barriers);
-    void MemoryBarrierByRegion(GLbitfield barriers);
-    void BindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access,
-                          GLenum format);
-    void GetIntegeri_v(GLenum target, GLuint index, GLint* data);
-    void ShaderStorageBlockBinding(GLuint program, const GLchar* storageBlockName, GLuint storageBlockBinding);
     Bool InitWindowSurface(NativeWindowType window);
-    Bool InitPbufferSurface(EGLint width, EGLint height);
-    Bool MakeCurrent();
-    Bool ReleaseCurrent();
-    // True when the backend ES context is current on the calling thread, i.e.
-    // immediate buffer ops may issue GL calls right now.
-    Bool IsBackendContextCurrentOnThisThread();
-    // GL fence sync objects, backed by native ES fences. FenceSync returns null
-    // (the frontend then falls back to an always-signaled sync) when the calling
-    // thread does not own the ES context. Waits/queries degrade to "signaled" in
-    // the same situation, and handles created under a since-destroyed ES context
-    // are always treated as signaled.
-    BackendSyncHandle FenceSync();
-    GLenum ClientWaitSync(BackendSyncHandle sync, GLbitfield flags, GLuint64 timeout);
-    void WaitSync(BackendSyncHandle sync, GLbitfield flags, GLuint64 timeout);
-    void DeleteSync(BackendSyncHandle sync);
-    Bool GetSyncStatus(BackendSyncHandle sync);
-    // True when GL_EXT_disjoint_timer_query and every entry point the timer
-    // hooks below need are present. Also gates the E_GL_ARB_timer_query
-    // advertisement in BackendObject_DirectGLES::InitCapabilities, and is
-    // registered as the GLFunctionsTable::IsTimerQuerySupported hook: a pure
-    // 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
-    // context or the extension/entry points are missing, and handles created
-    // under a since-destroyed ES context are always treated as complete with
-    // a zero result (mirrors the fence-sync handles above).
-    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
-    // and release the handle). Returns false only when the calling thread
-    // does not own the ES context, so the value is genuinely unobtainable
-    // right now; the handle stays alive and readable later.
-    Bool GetQueryResult64(BackendQueryHandle query, Bool wait, Uint64* outNanoseconds);
-    void DeleteBackendQuery(BackendQueryHandle query);
-    Int64 GetGpuTimestampNs();
     void Present();
-    // Frame-completion watermarks for the buffer-storage pool: CurrentFrameSerial()
-    // is bumped once per Present(); CompletedFrameSerial() is the newest frame whose
-    // GPU work has provably finished (advanced by polling a one-fence-per-frame ring).
-    // 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);
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // P12 review fix: the swap interval an ended server session asked for is not the next one's.
-    // The request outlives the context on purpose (a surface re-created mid-session re-applies it),
-    // so the in-process display server's session end forgets it: the next session starts at the
-    // driver's default until it asks (BackendObject_DirectGLES's destructor under a transport).
-    void ForgetRequestedSwapInterval();
-#endif
     void SetEGLFuncsTable(const MG_External::EGLFunctionsTable& eglFuncs);
     void SetGLESFuncsTable(const MG_External::GLESFunctionsTable& glesFuncs);
     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
-
-    // MOBILEGL_IPC_SURFACE=host: what the client's DEFAULT framebuffer means while a host-framed
-    // surface is current.  Zero everywhere else, because the driver's own 0 IS the EGL surface
-    // then - but on a host-framed surface the pixels belong to a frame the display host owns,
-    // and drawing into the driver's 0 would draw into a pbuffer nobody ever sees.
-    extern Uint g_hostFrameFramebufferId;
-    // WHAT THE HOST FRAME'S STORAGE IS, for the one caller that has to bind it in place of a
-    // storage-less attachment: an imported dma-buf is the display host's frame (same memory, same
-    // size), and the frame's storage is a RENDERBUFFER (HostFrameTarget.cpp binds it with
-    // glFramebufferRenderbuffer).  A texture argument cannot name it, which is why these exist and
-    // why g_hostFrameFramebufferId alone was not enough.  Zero whenever no frame is held.
-    extern Uint g_hostFrameRenderbuffer;
-    extern Uint g_hostFrameWidth;
-    extern Uint g_hostFrameHeight;
-    // TAKE THE FRAME WHEN NOTHING ELSE WILL.  On the anland route the container's compositor never
-    // creates a window surface, so ActivateEGLSurface never runs and InitHostFrameSurface is never
-    // reached: the FIRST proof that the display host's frame is wanted is an ATTACHMENT of an
-    // imported external texture (Managers.cpp's 0x8D65 arm), and that is where the frame has to be
-    // taken.  The host's own offer carries the width/height, so the numbers passed here are only
-    // what the bridge logs.  Answers false (and changes nothing) whenever no backend is up.
-    Bool TakeHostFrameForExternalTexture(Uint width, Uint height);
     extern MG_External::EGLFunctionsTable g_EGLFuncs;
     extern MG_External::GLESFunctionsTable g_GLESFuncs;
     extern MG_External::GLESCapabilities g_GLESCapabilities;

MobileGL/MG_Backend/DirectGLES/HostFrameTarget.cpp

@@ -1,208 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectGLES/HostFrameTarget.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 "HostFrameTarget.h"
-#include "DirectGLES.h"
-#include "Managers.h"
-
-#if MOBILEGL_BUILD_DISAGGREGATED && defined(__ANDROID__)
-
-#include <android/hardware_buffer.h>
-#include <cstring>
-#include <format>
-
-namespace MobileGL::MG_Backend::DirectGLES {
-    namespace {
-        // The four entry points this is spelled in are optional everywhere: the loader's own
-        // tables do not carry them (a missing EGL function there is MGLOG_F), so the extension
-        // strings decide first and the pointers are taken only once they have.
-        using GetNativeClientBufferFn = EGLClientBuffer (*)(const struct AHardwareBuffer*);
-        using CreateImageFn = EGLImageKHR (*)(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const EGLint*);
-        using DestroyImageFn = EGLBoolean (*)(EGLDisplay, EGLImageKHR);
-        using ImageTargetRenderbufferFn = void (*)(GLenum, GLeglImageOES);
-
-        Bool HasExtensionWord(const char* list, const char* word) {
-            if (list == nullptr) return false;
-            const SizeT n = std::strlen(word);
-            for (const char* at = std::strstr(list, word); at != nullptr; at = std::strstr(at + 1, word)) {
-                const Bool startOk = at == list || at[-1] == ' ';
-                const Bool endOk = !at[n] || at[n] == ' ';
-                if (startOk && endOk) return true;
-            }
-            return false;
-        }
-
-        struct EntryPoints {
-            GetNativeClientBufferFn GetNativeClientBuffer = nullptr;
-            CreateImageFn CreateImage = nullptr;
-            DestroyImageFn DestroyImage = nullptr;
-            ImageTargetRenderbufferFn TargetRenderbuffer = nullptr;
-        };
-
-        // Resolved once per process and cached together with the refusal: a driver that lacks one
-        // of these does not grow it later, and the answer names what is missing.
-        const EntryPoints& Resolved(String& why) {
-            static EntryPoints points;
-            static Bool resolved = false;
-            static String refusal;
-            if (!resolved) {
-                resolved = true;
-                if (!g_EGLFuncs.eglGetProcAddress || !g_EGLFuncs.eglQueryString || !g_EGLFuncs.eglGetCurrentDisplay ||
-                    !g_GLESFuncs.glGetString) {
-                    refusal = "the loader has no eglGetProcAddress/eglQueryString/eglGetCurrentDisplay/glGetString";
-                } else {
-                    const char* egl = g_EGLFuncs.eglQueryString(g_EGLFuncs.eglGetCurrentDisplay(), EGL_EXTENSIONS);
-                    const char* gl = reinterpret_cast<const char*>(g_GLESFuncs.glGetString(GL_EXTENSIONS));
-                    if (!HasExtensionWord(egl, "EGL_ANDROID_get_native_client_buffer")) {
-                        refusal = "EGL_ANDROID_get_native_client_buffer is not advertised";
-                    } else if (!HasExtensionWord(egl, "EGL_KHR_image_base")) {
-                        refusal = "EGL_KHR_image_base is not advertised";
-                    } else if (!HasExtensionWord(gl, "GL_OES_EGL_image")) {
-                        refusal = "GL_OES_EGL_image is not advertised";
-                    } else {
-                        points.GetNativeClientBuffer = reinterpret_cast<GetNativeClientBufferFn>(
-                            g_EGLFuncs.eglGetProcAddress("eglGetNativeClientBufferANDROID"));
-                        points.CreateImage =
-                            reinterpret_cast<CreateImageFn>(g_EGLFuncs.eglGetProcAddress("eglCreateImageKHR"));
-                        points.DestroyImage =
-                            reinterpret_cast<DestroyImageFn>(g_EGLFuncs.eglGetProcAddress("eglDestroyImageKHR"));
-                        points.TargetRenderbuffer = reinterpret_cast<ImageTargetRenderbufferFn>(
-                            g_EGLFuncs.eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES"));
-                        if (points.GetNativeClientBuffer == nullptr || points.CreateImage == nullptr ||
-                            points.DestroyImage == nullptr || points.TargetRenderbuffer == nullptr) {
-                            refusal = "eglGetProcAddress gave no eglGetNativeClientBufferANDROID / eglCreateImageKHR / "
-                                      "eglDestroyImageKHR / glEGLImageTargetRenderbufferStorageOES";
-                            points = EntryPoints{};
-                        }
-                    }
-                }
-            }
-            why = refusal;
-            return points;
-        }
-
-        void DrainGLErrors() {
-            if (!g_GLESFuncs.glGetError) return;
-            for (Uint guard = 0; guard < 16 && g_GLESFuncs.glGetError() != GL_NO_ERROR; ++guard) {
-            }
-        }
-    }
-
-    Bool HostFrameTargetSupported(String& why) {
-        const EntryPoints& points = Resolved(why);
-        return points.GetNativeClientBuffer != nullptr;
-    }
-
-    Bool HostFrameTargetCreate(const struct AHardwareBuffer* buffer, HostFrameTarget& target, String& why) {
-        target = HostFrameTarget{};
-        if (buffer == nullptr) {
-            why = "no buffer";
-            return false;
-        }
-        const EntryPoints& points = Resolved(why);
-        if (points.GetNativeClientBuffer == nullptr) return false;
-
-        if (!g_GLESFuncs.glGenRenderbuffers || !g_GLESFuncs.glBindRenderbuffer || !g_GLESFuncs.glGenFramebuffers ||
-            !g_GLESFuncs.glBindFramebuffer || !g_GLESFuncs.glFramebufferRenderbuffer ||
-            !g_GLESFuncs.glCheckFramebufferStatus) {
-            why = "the loader has no glGenRenderbuffers/glBindRenderbuffer/glGenFramebuffers/glBindFramebuffer/"
-                  "glFramebufferRenderbuffer/glCheckFramebufferStatus";
-            return false;
-        }
-
-        AHardwareBuffer_Desc desc{};
-        AHardwareBuffer_describe(buffer, &desc);
-
-        DrainGLErrors();
-        const EGLClientBuffer clientBuffer = points.GetNativeClientBuffer(buffer);
-        if (clientBuffer == nullptr) {
-            why = "eglGetNativeClientBufferANDROID returned null";
-            return false;
-        }
-        const EGLint imageAttribs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
-        const EGLImageKHR image =
-            points.CreateImage(g_EGLFuncs.eglGetCurrentDisplay(), EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
-                               clientBuffer, imageAttribs);
-        if (image == EGL_NO_IMAGE_KHR) {
-            why = "eglCreateImageKHR(EGL_NATIVE_BUFFER_ANDROID) refused the host frame";
-            return false;
-        }
-
-        GLuint renderbuffer = 0;
-        g_GLESFuncs.glGenRenderbuffers(1, &renderbuffer);
-        g_GLESFuncs.glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
-        points.TargetRenderbuffer(GL_RENDERBUFFER, reinterpret_cast<GLeglImageOES>(image));
-        const GLenum renderbufferError = g_GLESFuncs.glGetError ? g_GLESFuncs.glGetError() : GL_NO_ERROR;
-        if (renderbufferError != GL_NO_ERROR) {
-            why = std::format("glEGLImageTargetRenderbufferStorageOES -> 0x{:04x}", renderbufferError);
-            g_GLESFuncs.glDeleteRenderbuffers(1, &renderbuffer);
-            points.DestroyImage(g_EGLFuncs.eglGetCurrentDisplay(), image);
-            return false;
-        }
-
-        GLuint framebuffer = 0;
-        g_GLESFuncs.glGenFramebuffers(1, &framebuffer);
-        g_GLESFuncs.glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
-        g_GLESFuncs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer);
-        const GLenum status = g_GLESFuncs.glCheckFramebufferStatus(GL_FRAMEBUFFER);
-        if (status != GL_FRAMEBUFFER_COMPLETE) {
-            why = std::format("the host frame as a color attachment -> framebuffer status 0x{:04x}", status);
-            g_GLESFuncs.glDeleteFramebuffers(1, &framebuffer);
-            g_GLESFuncs.glDeleteRenderbuffers(1, &renderbuffer);
-            points.DestroyImage(g_EGLFuncs.eglGetCurrentDisplay(), image);
-            return false;
-        }
-
-        target.Image = image;
-        target.Renderbuffer = renderbuffer;
-        target.Framebuffer = framebuffer;
-        target.Width = desc.width;
-        target.Height = desc.height;
-        MGLOG_I("host frame target: %ux%d as framebuffer %u (stride %u, format 0x%x)", desc.width, desc.height,
-                framebuffer, desc.stride, desc.format);
-        return true;
-    }
-
-    void HostFrameTargetBind(const HostFrameTarget& target) {
-        if (target.Framebuffer == 0) return;
-        // THROUGH THE ENGINE'S SHADOW, never raw: a raw bind would leave the shadow claiming
-        // the previous framebuffer and false-skip the next re-bind (FramebufferImpl, Managers.h).
-        FramebufferImpl::BindFramebufferId(GL_FRAMEBUFFER, target.Framebuffer);
-    }
-
-    void HostFrameTargetDestroy(HostFrameTarget& target) {
-        if (target.Framebuffer != 0 && g_GLESFuncs.glDeleteFramebuffers)
-            g_GLESFuncs.glDeleteFramebuffers(1, &target.Framebuffer);
-        if (target.Renderbuffer != 0 && g_GLESFuncs.glDeleteRenderbuffers)
-            g_GLESFuncs.glDeleteRenderbuffers(1, &target.Renderbuffer);
-        if (target.Image != nullptr) {
-            String why;
-            const EntryPoints& points = Resolved(why);
-            if (points.DestroyImage != nullptr && g_EGLFuncs.eglGetCurrentDisplay)
-                points.DestroyImage(g_EGLFuncs.eglGetCurrentDisplay(), static_cast<EGLImageKHR>(target.Image));
-        }
-        target = HostFrameTarget{};
-    }
-}
-
-#else  // !(MOBILEGL_BUILD_DISAGGREGATED && __ANDROID__)
-
-namespace MobileGL::MG_Backend::DirectGLES {
-    Bool HostFrameTargetSupported(String& why) {
-        why = "host frames are a disaggregated Android path";
-        return false;
-    }
-    Bool HostFrameTargetCreate(const struct AHardwareBuffer*, HostFrameTarget&, String& why) {
-        why = "host frames are a disaggregated Android path";
-        return false;
-    }
-    void HostFrameTargetBind(const HostFrameTarget&) {}
-    void HostFrameTargetDestroy(HostFrameTarget& target) { target = HostFrameTarget{}; }
-}
-
-#endif

MobileGL/MG_Backend/DirectGLES/HostFrameTarget.h

@@ -1,52 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectGLES/HostFrameTarget.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 <EGL/egl.h>
-#include <EGL/eglext.h>
-
-struct AHardwareBuffer;
-
-namespace MobileGL::MG_Backend::DirectGLES {
-    // THE FRAME THE DISPLAY HOST IS ABOUT TO SCAN OUT, AS A DRAW TARGET.
-    //
-    // The display host (the Android side that owns the screen) allocates its frames itself and
-    // offers each one over a socket as an AHardwareBuffer.  That is not a convenience: measured
-    // on the device, AHardwareBuffer_createFromHandle accepts an AHardwareBuffer this side
-    // allocated and refuses one the display queue handed over (gralloc BAD_VALUE), so the frames
-    // a render server can draw into are the ones the host made for it.
-    //
-    // What this makes of such a frame: an EGLImage the driver accepts as a renderbuffer, and a
-    // framebuffer that is the drawing target while that frame is the current one.  None of
-    // Android's window machinery is involved - no ANativeWindow, no SurfaceFlinger - which is
-    // the point: the host puts the frame on the glass when this side says it is drawn.
-    struct HostFrameTarget {
-        void* Image = nullptr;   // EGLImageKHR; opaque here so this header stays free of EGL types
-        Uint Renderbuffer = 0;
-        Uint Framebuffer = 0;
-        Uint Width = 0;
-        Uint Height = 0;
-    };
-
-    // Whether the driver advertises what this is spelled in.  False is answered with the missing
-    // name in `why`, never an abort: a server that cannot take host frames has to be able to
-    // say so.
-    Bool HostFrameTargetSupported(String& why);
-
-    // Imports `buffer` as a render target.  On failure `target` is left empty and `why` says
-    // which call refused; no GL name is leaked.
-    Bool HostFrameTargetCreate(const struct AHardwareBuffer* buffer, HostFrameTarget& target, String& why);
-
-    // Binds the target as the current draw framebuffer, called when its frame becomes current.
-    void HostFrameTargetBind(const HostFrameTarget& target);
-
-    // Drops the GL names and the EGLImage.  The AHardwareBuffer belongs to the bridge, which
-    // releases it; this never touches it.
-    void HostFrameTargetDestroy(HostFrameTarget& target);
-}

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

@@ -1,785 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectGLES/SlotTables.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 <MG_Pipe/MGPipeHandles.h>
-
-#if MOBILEGL_PIPE_PUSH
-#include <MG_Impl/Pipe/SlotAllocator.h>
-#endif
-#if MOBILEGL_BUILD_DISAGGREGATED
-#include <MG_Pipe/PipeSessionFail.h>
-#endif
-
-// Espryt 0b, the first Track H slice: the DENSE, {slot, gen}-keyed twin table that replaces
-// StateBackendObjectRegistry's UnorderedMap<StateObject*, Entry>.
-//
-// What changes, and why each of them is the point:
-//
-//  * The KEY stops being a frontend heap address. It is MGPipeHandle{Slot, Gen}, minted by the
-//    client's MGPipeSlotAllocator off the frontend object's GetLifetimeId(). A recycled heap
-//    address cannot reproduce a handle, so the weak_ptr the registry carried per entry purely
-//    to catch that (its Entry::stateRef, used as an IDENTITY test) stops being an identity
-//    mechanism, and OwnerEquals / TwinLookupMemo x3 / UnitSamplerLookupMemo's owner compare all
-//    lose their reason to exist.
-//  * The lookup stops being a hash probe into an open-addressed map and becomes one bounds
-//    check plus one array index, so a returned BackendPtr* is NOT invalidated by the next Find
-//    on the table. That kills the hazard Managers.h documents at length, and with it the
-//    by-value copy plus second Find that SyncTextureObjectToBackend paid to survive it.
-//  * Slots are dense per kind, which is what lets the server side (ARCHITECTURE.md 10.1,
-//    MG_Remote/Server/PipeObjectTables) be an array rather than an object graph.
-//
-// Death is ANNOUNCED, and that is what lets this table have no garbage collector - the
-// deliverable ROADMAP.md:18 spells "GC" in and the one D13 makes a precondition of the switch-
-// over. All six re-keyed object classes raise MG_State::GLState::NotifyStateObjectDestroyed()
-// from their destructor (BufferBackendOps' shape, one entry point for six kinds), the backend
-// consumes it in Managers.cpp, and OnFrontendObjectDestroyed() below drops the twin in EVERY
-// table of the kind and returns the slot, at the moment the frontend object's last SharedPtr
-// goes. So:
-//   * there is NO draw-path tick, NO creation tick and NO sweep of any kind on this arm. The
-//     seven CollectGarbageIfNeeded call sites in DirectGLES.cpp drive the LEGACY registry only;
-//   * a twin, and the driver storage it owns, is freed when the application lets go of the
-//     object rather than up to 64 creations or 1024 draw ticks later. That is what
-//     Managers.h's "dead gigabytes" note asked for.
-//
-// EVERY HOLDER OF THE KIND, not one. Two live tables of one kind is a real configuration - the
-// ScopedDirectGLESTextureBindings fixture keeps a by-value copy of the Texture registry for the
-// length of a test, and a context reset does the same in reverse - and the slot allocator
-// erases its lifetimeId -> slot mapping on Free, so a notice delivered to one holder and
-// resolved again by the next would find nothing to resolve. Every table therefore links itself
-// into a per-table-type list at construction and out at destruction, and one notice resolves
-// the handle ONCE, drops the twin in each holder BY HANDLE, and frees the slot once, last. No
-// holder can be left naming a live entry for a dead object, and there is nothing a sweep could
-// still find. (The list is per table TYPE; the kind is the type's template parameter, and each
-// of the six kinds has exactly one table type in this backend. Magma's subsystem-4 table mints
-// out of its own per-renderer allocator, not MGPipeSlots(), so it is not a holder here.)
-//
-// The weak_ptr per entry survives as the MONOLITH-GLUE half of the table's identity: the
-// minting GetOrCreate stores it, NoteStateForHandle/StateForHandle read it, and the legacy
-// death notice walks it. It is never an identity test - that is what Gen is for - and it is
-// never read to decide whether an entry is dead: a destructor that runs after exit() has begun
-// has its notice dropped by InProcessTeardown(), and that twin is then a DELIBERATE leak (the
-// process is exiting, the driver reclaims the object, and a twin destructor must not call into
-// a driver that may already be unloaded), not something to be collected later.
-//
-// P5e (id, CONTRACT-P5E §4.1): ForEachLive() NO LONGER HANDS IT OUT. It answers
-// fn(MGPipeHandle, const BackendPtr&), because a walk that produced a frontend SharedPtr out
-// of server memory was the last place the server could hold one across records - and a caller
-// that still needs the object (the detach walk) asks StateForHandle for it BY HANDLE, inside
-// the scope that names the debt, so the read is one greppable site rather than a property of
-// the iteration.
-//
-// P3+ DEBT, recorded rather than hidden: this header is under MG_Backend/ and it MINTS
-// handles (MGPipeSlots().Acquire below) off a frontend SharedPtr's GetLifetimeId().
-// MGPipeHandles.h:13-16 says a handle is minted by the CLIENT and never by the server, and
-// under a real split neither the frontend object nor its lifetime id exists on this side of
-// the wire. This is monolith glue: the minting and the lifetimeId -> handle resolution both
-// belong on the client, and the backend should receive the handle in the verb payload. It is
-// NOT part of "Track H done" and check_include_closure.py does not probe MG_Backend headers,
-// so nothing catches it automatically.
-//
-// P5c (hd, CONTRACT-P5C §3.1) is what gives the debt teeth: with an active transport the
-// minting GetOrCreate, HandleOf and OnFrontendObjectDestroyed raise
-// Fatal{RoleViolation, "MGPipeSlots"} when reached from the apply thread (the same check the
-// allocator's own three entries carry, repeated here so the refusal names this surface), and
-// the split paths resolve through GetOrCreate(handle) / ReleaseByHandle instead.
-//
-// P5f (fr): the frontend-keyed half survives only as MONOLITH GLUE. HandleOf,
-// GetOrCreate(StatePtr), NoteStateForHandle and StateForHandle refuse EVERY transport
-// apply before touching a frontend object, with or without a barrier or named scope.
-// Find(StateObject*) delegates to HandleOf; handle-only iteration never reads stateRef.
-// The registry guard is independent of Magma's legacy allocator debt scope.
-namespace MobileGL::MG_Backend::DirectGLES {
-
-#if MOBILEGL_PIPE_PUSH
-
-    // Declared in Managers.h as well; repeated here because this header is included from it
-    // before that declaration, and the table below is the arming site on this arm (D13: "the
-    // arming site moves to the slot table's first insertion").
-    void EnsureProcessTeardownSentinel();
-
-    // What the two knobs add up to. Split out as a PURE function of them so a test can drive
-    // every combination without needing a process per combination.
-    enum class EsprytSlotArmVerdict {
-        Handles, // kMGPipeSubsystemEsprytSlots is set: the {slot, gen} tables run.
-        Legacy,  // the bit is clear and the legacy address-keyed registry is reachable.
-        NoArm,   // the bit is clear AND MOBILEGL_PIPE_LEGACY_MEMOS=0 made the legacy arm
-                 // unreachable, so the operator asked for a configuration with no arm at all.
-    };
-
-    EsprytSlotArmVerdict ClassifyEsprytSlotArm(Bool subsystemBitSet, Bool legacyMemosEnabled);
-
-    // This process's verdict, read off MG_Config::Features. Latches nothing and stops nothing.
-    EsprytSlotArmVerdict CurrentEsprytSlotArmVerdict();
-
-    // Says, at backend bring-up, that the knobs leave no arm - and does NOT stop.
-    //
-    // The stop cannot live here, and that is the whole point of the split. Backend context
-    // creation runs inside eglMakeCurrent, and the integration harness pre-flights exactly that
-    // sequence in a FORKED CHILD (MG_IntegrationTest/Harness/HeadlessGL.cpp): a child that dies
-    // on a signal is reported as "no usable GPU/display/ICD" and every scenario in the lane is
-    // SKIPPED - i.e. the lane goes green having run nothing, on the very pair of env vars the
-    // D14/D18 A/B is driven with, which is what ROADMAP.md:7 forbids. So bring-up only
-    // DIAGNOSES; the stop is raised by ResolveEsprytSlotTablesArm() at the first twin lookup,
-    // which happens in the test body where the harness reports it as a failure.
-    //
-    // The CALL SITE (InitDisplayAndContext in DirectGLES.cpp) is pinned by
-    // DirectGLESSlotTable.EglBringUpUnderTheArmlessKnobPairReturnsInsteadOfStopping, which runs
-    // the real bring-up entry point under the pair in a forked child: edit that site back to
-    // ResolveEsprytSlotTablesArm() and the case fails naming both knobs.
-    void DiagnoseEsprytSlotArm();
-
-    // Reads the config, logs, installs the death-notice consumer, and STOPS when the operator
-    // left no arm at all. Cold: called exactly once per process, from the latch below - i.e. at
-    // the first twin lookup, which is the first moment an arm is actually needed. A process
-    // that never twins anything needs no arm and is not stopped.
-    Bool ResolveEsprytSlotTablesArm();
-
-    // True when this process runs the {slot, gen} arm. Fixed for the life of the process: the
-    // two arms hold their twins in different containers, so flipping mid-run would strand them.
-    //
-    // INLINE on purpose. Every Find / GetOrCreate / HandleOf / ForEachLive on the twin tables
-    // consults it, i.e. it is on the per-draw path several times per draw. As an out-of-line
-    // function in Managers.cpp (no LTO in any shipped configuration) that was a call through
-    // the PLT per lookup; here the caller sees a guard-variable load and a perfectly-predicted
-    // branch, and the arm dispatch folds into the caller.
-    inline Bool EsprytSlotTablesEnabled() {
-        static const Bool enabled = ResolveEsprytSlotTablesArm();
-        return enabled;
-    }
-
-    template <typename StateObject, typename BackendObject, MG_Pipe::MGPipeKind kKind>
-    class BackendSlotTable {
-    public:
-        using StatePtr = SharedPtr<StateObject>;
-        using StateWeakPtr = std::weak_ptr<StateObject>;
-        using BackendPtr = SharedPtr<BackendObject>;
-
-        // The largest slot index this table will grow to for a handle that ARRIVED in a call's
-        // payload. Slots are dense and allocated per kind, so a million of one kind is already
-        // far past any application's live object count; the cap is here because the alternative
-        // is letting a corrupt 32-bit slot decide a vector resize. See GetOrCreate(MGPipeHandle).
-        static constexpr Uint32 kMaxHandleSlot = 1u << 20;
-
-        // P5e (id), CONTRACT-P5E §4.3: THE COMPOSITE BAND, and it is a P5e PREREQUISITE rather
-        // than a follow-up. ShaderCso's top 1/16 of slot space (from
-        // kMGPipeShaderCsoCompositeSlotBase = 983040) is the program-pipeline composites'
-        // (MGPipeHandles.h); EntryAt below indexes m_slots BY SLOT and resizes to it, so a
-        // single composite used to grow g_backendProgramObjects to ~983k entries of ~40 B -
-        // ~40 MB for one program pipeline. Today that is reachable only through
-        // GetOrCreate(StatePtr) for a composite program; after the rekey the by-handle
-        // resolution IS the ordinary path, so every composite bind would pay it.
-        //
-        // A SECOND VECTOR RATHER THAN MORE OF THE FIRST, exactly as the allocator
-        // (SlotAllocator.h's KindState::BandSlots) and the applier (PipeApply.h's
-        // CompositeShaderCsos) already do, and for the same reason: both spaces stay dense
-        // against their own high-water mark, which is the property that lets the server index
-        // rather than hash. The band is EMPTY for every kind but ShaderCso and costs those
-        // kinds one empty Vector per table.
-        static constexpr Bool kHasCompositeBand = (kKind == MG_Pipe::MGPipeKind::ShaderCso);
-        static constexpr SizeT kMaxBandSlots =
-            MG_Pipe::kMGPipeShaderCsoSlotLimit - MG_Pipe::kMGPipeShaderCsoCompositeSlotBase;
-
-        struct Entry {
-            BackendPtr backend;
-            // THE MONOLITH-GLUE HALF of the entry (P5e, CONTRACT-P5E §4.1): written by the
-            // minting GetOrCreate and by NoteStateForHandle, read only by StateForHandle and
-            // the legacy death notice. Never compared against another object to decide identity
-            // - that is what Gen is for - never dereferenced for its address, and never read to
-            // decide whether the slot is dead: death is announced, not discovered. ForEachLive
-            // stopped reading it at P5e: a walk that handed a frontend SharedPtr out of server
-            // memory on every step was the last place the server could hold one across records.
-            StateWeakPtr stateRef;
-            // The generation this entry's twin was built for. An entry whose Gen no longer
-            // matches the allocator's is a twin of the slot's PREVIOUS owner.
-            Uint32 Gen = 0;
-            Bool Live = false;
-        };
-
-        // Every constructor links the table into the per-type holder list and the destructor
-        // unlinks it, so a by-value copy (the ScopedDirectGLESTextureBindings fixture's saved
-        // registry) is a holder for exactly as long as it exists. Copy and move carry the
-        // ENTRIES and the memo; the links are the table's own and are never copied.
-        BackendSlotTable() { LinkHolder(); }
-        BackendSlotTable(const BackendSlotTable& other):
-            m_slots(other.m_slots),
-            m_band(other.m_band),
-            m_nullTwin(other.m_nullTwin),
-            m_memoLifetimeId(other.m_memoLifetimeId),
-            m_memoHandle(other.m_memoHandle) {
-            LinkHolder();
-        }
-        BackendSlotTable(BackendSlotTable&& other) noexcept:
-            m_slots(std::move(other.m_slots)),
-            m_band(std::move(other.m_band)),
-            m_nullTwin(std::move(other.m_nullTwin)),
-            m_memoLifetimeId(other.m_memoLifetimeId),
-            m_memoHandle(other.m_memoHandle) {
-            other.m_slots.clear();
-            other.m_band.clear();
-            other.ForgetHandle();
-            LinkHolder();
-        }
-        BackendSlotTable& operator=(const BackendSlotTable& other) {
-            if (this != &other) {
-                m_slots = other.m_slots;
-                m_band = other.m_band;
-                m_nullTwin = other.m_nullTwin;
-                m_memoLifetimeId = other.m_memoLifetimeId;
-                m_memoHandle = other.m_memoHandle;
-            }
-            return *this;
-        }
-        BackendSlotTable& operator=(BackendSlotTable&& other) noexcept {
-            if (this != &other) {
-                m_slots = std::move(other.m_slots);
-                m_band = std::move(other.m_band);
-                m_nullTwin = std::move(other.m_nullTwin);
-                m_memoLifetimeId = other.m_memoLifetimeId;
-                m_memoHandle = other.m_memoHandle;
-                other.m_slots.clear();
-                other.m_band.clear();
-                other.ForgetHandle();
-            }
-            return *this;
-        }
-        ~BackendSlotTable() { UnlinkHolder(); }
-
-        // Resolve-or-create. The handle comes from the client allocator keyed on the frontend
-        // object's lifetime id, so two calls for the same live object always land on the same
-        // slot, and a successor object at the same heap address never does.
-        BackendPtr& GetOrCreate(const StatePtr& stateObj) {
-            // No assert on null here, unlike the map arm: null is TOLERATED, so a DEBUG build
-            // must not trap where the release build quietly does the documented thing.
-            if (stateObj == nullptr) {
-                // The registry this replaces inserted a null KEY and handed back that entry's
-                // twin (DirectGLES.cpp's SyncTextureObjectToBackend documents relying on
-                // exactly that tolerance), so a release build never dereferenced null here.
-                // Keep the shape exactly, INCLUDING across calls: the map kept its null-keyed
-                // entry, so a second null call was handed the same twin the first one got.
-                // Resetting here instead would have destroyed it - an arm difference in the one
-                // path that documents relying on this. One per-table parking slot, never live,
-                // never handed a handle, because a null object has no identity and
-                // therefore cannot have a {slot, gen}.
-                return m_nullTwin;
-            }
-
-            // D13: the teardown sentinel is armed by the slot table's first insertion. Twin
-            // creation is the moment a driver-owned id starts needing a guarded destructor;
-            // this is the cold path, so the once-guard costs nothing per draw. On the legacy
-            // arm StateBackendObjectRegistry::GetOrCreate arms it itself.
-            EnsureProcessTeardownSentinel();
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-            // This overload mints from frontend identity and is monolith-only. Refuse
-            // before either the client object or allocator is touched, even when a
-            // legacy named scope is open and the current record is barriered.
-            MG_Pipe::MGPipeRefuseFrontendKeyedRegistryFromApplyThread("GetOrCreate(StatePtr)");
-#endif
-
-            const MG_Pipe::MGPipeHandle handle =
-                MG_Pipe::MGPipeSlots().Acquire(kKind, stateObj->GetLifetimeId());
-            MOBILEGL_ASSERT(!MG_Pipe::MGPipeHandleIsNull(handle),
-                            "MGPipe slot space of kind %u is exhausted",
-                            static_cast<Uint32>(kKind));
-            Entry& entry = EntryAt(handle.Slot);
-            if (entry.Live && entry.Gen != handle.Gen) {
-                // The slot was reclaimed and handed to a new object: the twin at it describes
-                // driver ids the new state object never made.
-                entry.backend.reset();
-            }
-            entry.Gen = handle.Gen;
-            entry.Live = true;
-            entry.stateRef = stateObj;
-            // No creation tick and no sweep here. The registry this replaces needed both,
-            // because nothing told it a texture or a renderbuffer had been DELETED and object
-            // CHURN rather than draw count is what made that urgent. Every one of the six kinds
-            // now announces its own death from its destructor, so a dead twin's slot is already
-            // back before the next creation asks for one.
-            RememberHandle(stateObj->GetLifetimeId(), handle);
-            return entry.backend;
-        }
-
-        // P3a: resolve-or-create BY HANDLE, and it is the shape that discharges the debt this
-        // header records against itself at the top of the file.
-        //
-        // The overload above mints - it calls MGPipeSlots().Acquire off a frontend object's
-        // lifetime id, from inside MG_Backend - which is monolith glue: a handle is minted by
-        // the CLIENT, and under a real split neither the object nor its lifetime id exists on
-        // this side. This overload never touches the allocator at all. The handle ARRIVED, in
-        // the call's payload, already minted by the side that owns minting; all this does is
-        // index the slot, notice a generation that no longer matches (the slot was recycled,
-        // so the twin at it describes driver ids the new resource never made) and hand back
-        // the twin pointer. FindByHandle beside it is the same shape and already existed.
-        //
-        // No StatePtr, therefore no Entry::stateRef unless a caller that holds the object notes
-        // it (NoteStateForHandle): a handle-keyed entry has no frontend object to weakly hold
-        // by itself. P5e (§4.1) makes that stop mattering for the iteration - ForEachLive keys
-        // on Live && backend, so such an entry is VISIBLE to the walk and it is StateForHandle,
-        // asked by the one caller that needs the object, that answers null for it. Which is the
-        // same set the old stateRef-locking walk produced, decided at one site instead of in
-        // the loop.
-        //
-        // Death stays ANNOUNCED, as it is on the other overload: for a handle-keyed kind the
-        // announcement is the family's own destroy call, not the shared death notice, and the
-        // slot is freed by the CLIENT after that call returns.
-        //
-        // UNUSED AT THE CONTRACT COMMIT, deliberately: it is a member of a class template, so
-        // an uninstantiated one costs nothing anywhere, and the backend package is what gives
-        // it its first caller.
-        BackendPtr& GetOrCreate(MG_Pipe::MGPipeHandle handle) {
-            MOBILEGL_ASSERT(!MG_Pipe::MGPipeHandleIsNull(handle),
-                            "GetOrCreate(handle) named the reserved null handle");
-            if (MG_Pipe::MGPipeHandleIsNull(handle)) return m_nullTwin;
-
-            // A slot index that ARRIVED in a payload indexes a vector this call would RESIZE,
-            // and nothing between the payload and here bounds it: the applier's blob gates sit
-            // in front of the vertex-input family, not in front of the resource family, which
-            // dispatches ops->Create(record.Res, ...) straight through. There is no allocator
-            // constant to check against on this side - the allocator is the client's - so this
-            // is a sanity cap and is documented as one: kMaxHandleSlot entries of one kind is
-            // already orders of magnitude past any real GL object count, while a corrupt 32-bit
-            // slot asks for a four-billion-entry resize.
-            if (handle.Slot >= kMaxHandleSlot) {
-#if MOBILEGL_BUILD_DISAGGREGATED
-                // PH-2: handle.Slot is peer supplied on the disaggregated arm. Release builds
-                // must publish a named protocol fault instead of silently returning m_nullTwin.
-                MG_Pipe::MGPipeSessionFail( // @Ph-declined (ID-P7-1): PH-2 stays Fatal, CONTRACT-P7 §12
-                    MG_Pipe::MGPipeFatalFamily::ProtocolCorruption,
-                    "MGPipe: Fatal{ProtocolCorruption, \"BackendSlotTable.HandleSlot\"} - "
-                    "GetOrCreate(handle) named slot %u, past this table's %u bound",
-                    handle.Slot, kMaxHandleSlot);
-#else
-                MOBILEGL_ASSERT(false, "GetOrCreate(handle) named slot %u, past this table's %u bound",
-                                handle.Slot, kMaxHandleSlot);
-                return m_nullTwin;
-#endif
-            }
-
-            // Same arming as the minting overload, and for the same reason: twin creation is
-            // the moment a driver-owned id starts needing a guarded destructor.
-            EnsureProcessTeardownSentinel();
-
-            // THE TWO DIRECTIONS ARE NOT SYMMETRIC HERE, where they are on the minting overload.
-            // There the handle comes straight out of MGPipeSlots().Acquire and can never be
-            // BEHIND the entry, so a bare `!=` only ever means "the slot was recycled forward".
-            // Here the handle arrived in a payload, so `handle.Gen < entry.Gen` is a reachable
-            // input, and adopting it would destroy the INCUMBENT LIVE twin - a driver buffer id,
-            // a persistent map, a pooled store, released by a defaulted destructor that issues
-            // no glDeleteBuffers and no pool enrolment - and then stamp the slot back to the
-            // dead resource's generation, after which the incumbent's own FindByHandle refuses
-            // it and it is silently handed a fresh, empty twin. That is a leak AND a resource
-            // that loses its storage with no diagnostic, i.e. the shape commit d7655247 fixed
-            // and the thing MGPipeHandle::Gen exists to prevent. So: forward is a recycle and
-            // resets the twin, BACKWARD is refused - which is the same answer FindByHandle
-            // below already gives the same input.
-            Entry& entry = EntryAt(handle.Slot);
-            if (entry.Live && entry.Gen > handle.Gen) {
-#if MOBILEGL_BUILD_DISAGGREGATED
-                // PH-2: a stale peer generation must not silently shed the incumbent twin in a
-                // release server. The funnel names the exact identity fault and notifies the peer.
-                MG_Pipe::MGPipeSessionFail( // @Ph-declined (ID-P7-1): PH-2 stays Fatal, CONTRACT-P7 §12
-                    MG_Pipe::MGPipeFatalFamily::ProtocolCorruption,
-                    "MGPipe: Fatal{ProtocolCorruption, \"BackendSlotTable.Generation\"} - "
-                    "GetOrCreate(handle) named generation %u at slot %u, behind live generation %u",
-                    handle.Gen, handle.Slot, entry.Gen);
-#else
-                MOBILEGL_ASSERT(false,
-                                "GetOrCreate(handle) named generation %u at slot %u, which is BEHIND "
-                                "the live entry's %u - refusing rather than destroying the incumbent",
-                                handle.Gen, handle.Slot, entry.Gen);
-                return m_nullTwin;
-#endif
-            }
-            if (entry.Live && entry.Gen != handle.Gen) entry.backend.reset();
-            entry.Gen = handle.Gen;
-            entry.Live = true;
-            return entry.backend;
-        }
-
-        // The generation of the LIVE entry at this slot, or 0 when the slot is out of range or
-        // holds no live entry. It exists so a caller can DIAGNOSE - in a release build, where
-        // MOBILEGL_ASSERT is inert - the refusal GetOrCreate(handle) above performs silently.
-        Uint32 LiveGenAt(Uint32 slot) const {
-            const Entry* const entry = EntryOrNull(slot);
-            if (entry == nullptr) return 0;
-            return entry->Live ? entry->Gen : 0;
-        }
-
-        // Remember/read the frontend object last used by the monolith sync path.
-        // Handles supplied to the server never need this weak state. Neither method
-        // touches the allocator, so each carries its own unconditional apply guard.
-        void NoteStateForHandle(MG_Pipe::MGPipeHandle handle, const StatePtr& stateObj) {
-#if MOBILEGL_BUILD_DISAGGREGATED
-            MG_Pipe::MGPipeRefuseFrontendKeyedRegistryFromApplyThread("NoteStateForHandle");
-#endif
-            if (MG_Pipe::MGPipeHandleIsNull(handle)) return;
-            Entry* const entry = EntryOrNull(handle.Slot);
-            if (entry == nullptr || !entry->Live || entry->Gen != handle.Gen) return;
-            entry->stateRef = stateObj;
-        }
-
-        // The frontend object noted for this handle, or null. The handle answers identity;
-        // this answers only "which object was this twin last synced from".
-        StatePtr StateForHandle(MG_Pipe::MGPipeHandle handle) const {
-#if MOBILEGL_BUILD_DISAGGREGATED
-            MG_Pipe::MGPipeRefuseFrontendKeyedRegistryFromApplyThread("StateForHandle");
-#endif
-            if (MG_Pipe::MGPipeHandleIsNull(handle)) return nullptr;
-            const Entry* const entry = EntryOrNull(handle.Slot);
-            if (entry == nullptr || !entry->Live || entry->Gen != handle.Gen) return nullptr;
-            return entry->stateRef.lock();
-        }
-
-        // P3a: the death half of the overload above, for a kind whose announcement is its own
-        // destroy CALL rather than the shared death notice (D-L). Hands the twin OUT rather
-        // than destroying it in place, because the caller may still have to decide what
-        // happens to the driver id it owns - Espryt pools it, deletes it, or parks it on the
-        // deferred-release list when no context is current on this thread - and every one of
-        // those outcomes has to be reached with the entry already retired, so a re-entrant
-        // GetOrCreate from a twin destructor cannot resurrect it.
-        //
-        // The slot itself is NOT freed here: it belongs to the kind, and for a handle-keyed
-        // kind the CLIENT frees it after the destroy call returns (SlotAllocator.h:60 - the
-        // Gen bump rides the next handout, so a double free cannot skip a generation). An
-        // entry whose Gen no longer matches is a twin of the slot's previous owner and is
-        // left alone: the successor's own GetOrCreate resets it.
-        BackendPtr ReleaseByHandle(MG_Pipe::MGPipeHandle handle) {
-            if (MG_Pipe::MGPipeHandleIsNull(handle)) return BackendPtr{};
-            if (m_memoHandle.Slot == handle.Slot) ForgetHandle();
-            Entry* const entry = EntryOrNull(handle.Slot);
-            if (entry == nullptr || !entry->Live || entry->Gen != handle.Gen) return BackendPtr{};
-            BackendPtr dead = std::move(entry->backend);
-            entry->backend.reset();
-            entry->stateRef.reset();
-            entry->Live = false;
-            return dead;
-        }
-
-        // Null when no live twin of this object exists. Unlike the registry's Find this NEVER
-        // mutates the table, so the returned pointer survives any later Find on it; only a
-        // GetOrCreate that grows the vector can move it, and callers that hold one across a
-        // possible insertion still copy the BackendPtr out.
-        BackendPtr* Find(StateObject* stateObj) {
-            if (stateObj == nullptr) return nullptr;
-            return FindByHandle(HandleOf(stateObj));
-        }
-
-        const BackendPtr* Find(StateObject* stateObj) const {
-            return const_cast<BackendSlotTable*>(this)->Find(stateObj);
-        }
-
-        BackendPtr* FindByHandle(MG_Pipe::MGPipeHandle handle) {
-            if (MG_Pipe::MGPipeHandleIsNull(handle)) return nullptr;
-            Entry* const entry = EntryOrNull(handle.Slot);
-            if (entry == nullptr || !entry->Live || entry->Gen != handle.Gen) return nullptr;
-            return &entry->backend;
-        }
-
-        // The handle this object's twin is keyed on, or the null handle. This is what a backend
-        // memo stores instead of a raw pointer, a GL name or a bare lifetime id.
-        //
-        // A NULL answer is never memoised. The memo is per table and the allocator is per
-        // kind, so with two holders of one kind the OTHER table can be the one that acquires;
-        // a cached "no handle" here would then outlive the twin's creation over there, and
-        // nothing on this table's own acquire path would ever refresh it. A miss costs the
-        // allocator probe it always cost; a hit is refreshed the moment anyone acquires.
-        MG_Pipe::MGPipeHandle HandleOf(const StateObject* stateObj) const {
-            if (stateObj == nullptr) return MG_Pipe::kMGPipeNullHandle;
-#if MOBILEGL_BUILD_DISAGGREGATED
-            // Resolve frontend identity only in the monolith path. A cache hit is
-            // subject to the same guard as a fresh allocator lookup.
-            MG_Pipe::MGPipeRefuseFrontendKeyedRegistryFromApplyThread("HandleOf");
-#endif
-            const Uint64 lifetimeId = stateObj->GetLifetimeId();
-            if (lifetimeId == m_memoLifetimeId) return m_memoHandle;
-            const MG_Pipe::MGPipeHandle handle =
-                MG_Pipe::MGPipeSlots().FindByLifetimeId(kKind, lifetimeId);
-            if (!MG_Pipe::MGPipeHandleIsNull(handle)) RememberHandle(lifetimeId, handle);
-            return handle;
-        }
-
-        // P2 step e2's backend half. The frontend object with this lifetime id has just been
-        // DESTROYED: resolve its handle ONCE, drop its twin in EVERY table of this type, and
-        // return the slot to the allocator - in that order, because the allocator forgets the
-        // lifetime id on Free and a holder told second could no longer resolve it.
-        //
-        // The slot is returned whether or not any holder still had a twin at it: the lifetime
-        // id is dead and MG_State never hands one out twice, so nothing can acquire it again,
-        // and a slot minted for it that no table holds (a table reset with `= {}` drops its
-        // entries without freeing) would otherwise stay allocated for the life of the process.
-        //
-        // STATIC, and deliberately so: a notice is about an object, not about a table, and
-        // "which table holds it" is exactly the question that produced the two-holder leak.
-        // Returns whether the object had a slot of this kind, i.e. whether anything was freed;
-        // a second call for the same id answers false because the allocator no longer maps it.
-        static Bool OnFrontendObjectDestroyed(Uint64 lifetimeId) {
-#if MOBILEGL_BUILD_DISAGGREGATED
-            // P5c (hd): the Find/Free pair below is monolith-only with an active transport -
-            // a frontend death is announced to the server by the object_death record (ct),
-            // and a direct call from the apply thread is Fatal{RoleViolation, "MGPipeSlots"}.
-            MG_Pipe::MGPipeRefuseAllocatorFromApplyThread("OnFrontendObjectDestroyed");
-#endif
-            const MG_Pipe::MGPipeHandle handle =
-                MG_Pipe::MGPipeSlots().FindByLifetimeId(kKind, lifetimeId);
-            if (MG_Pipe::MGPipeHandleIsNull(handle)) return false;
-            for (BackendSlotTable* holder = s_firstHolder; holder != nullptr;) {
-                // The successor is read BEFORE the release: ReleaseTwinAt runs the twin's
-                // destructor, which is a driver call, and nothing that outlives it may be a
-                // reference into this holder.
-                BackendSlotTable* const next = holder->m_nextHolder;
-                holder->ReleaseTwinAt(handle);
-                holder = next;
-            }
-            MG_Pipe::MGPipeSlots().Free(kKind, handle);
-            return true;
-        }
-
-        // P5c (ct), CONTRACT-P5C.md §5.2: the handle-keyed half of the above, for a death that
-        // arrived AS A WIRE RECORD (object_death) rather than as the shared notice. The
-        // handle IS the resolution - it crossed in the record's payload - so the client's
-        // allocator is never asked: under an active transport MGPipeSlots() is a client-only
-        // surface (rule E, §3.1) and this function runs on the apply thread. Every holder
-        // lets go exactly as the notice arm does, in the same successor-first order. What
-        // does NOT happen here is the allocator Free: the slot's owner - the client -
-        // returned it itself after the record went out (PipeFill.cpp's NotifyAndFree), and a
-        // double Free would be refused by generation anyway. Idempotent against the kind's
-        // own delete opcode, exactly as the notice arm is: a twin the delete already released
-        // fails ReleaseTwinAt's generation check and the walk moves on.
-        static Bool ReleaseTwinByHandle(MG_Pipe::MGPipeHandle handle) {
-            if (MG_Pipe::MGPipeHandleIsNull(handle)) return false;
-            Bool released = false;
-            for (BackendSlotTable* holder = s_firstHolder; holder != nullptr;) {
-                BackendSlotTable* const next = holder->m_nextHolder;
-                released = holder->ReleaseTwinAt(handle) || released;
-                holder = next;
-            }
-            return released;
-        }
-
-        // How many tables of this type exist right now. For the tests that pin the holder
-        // list; nothing on a shipping path asks.
-        static Uint32 HolderCount() {
-            Uint32 count = 0;
-            for (const BackendSlotTable* holder = s_firstHolder; holder != nullptr;
-                 holder = holder->m_nextHolder) {
-                ++count;
-            }
-            return count;
-        }
-
-        // P5e (id), CONTRACT-P5E §4.1: fn(MGPipeHandle, const BackendPtr& twin) over every
-        // live, twinned entry. Replaces the registry's begin()/end(), whose iterator exposed
-        // the raw frontend address as the map key - the one place the backend read an identity
-        // it must not have - and replaces P3a's own fn(StatePtr, BackendPtr), which handed a
-        // frontend SharedPtr OUT OF SERVER MEMORY on every step.
-        //
-        // WHAT THE CALLER LOST AND HOW IT GETS IT BACK, because the two are not the same thing.
-        // The walk no longer locks Entry::stateRef, so a caller that needs the frontend object
-        // asks StateForHandle(handle) for it - which is the same weak reference, read at one
-        // named site inside the scope that owns the debt, instead of at every step of an
-        // iteration. Coverage is UNCHANGED by construction: an entry ForEachLive used to skip
-        // because its stateRef did not lock is one whose StateForHandle answers null, and the
-        // caller skips it there instead.
-        //
-        // The handle is the entry's own {slot, gen}, band-aware: a composite ShaderCso's slot
-        // is reported as kMGPipeShaderCsoCompositeSlotBase + its band index, i.e. the slot the
-        // client minted, never the index into m_band.
-        template <typename Fn>
-        void ForEachLive(Fn&& fn) const {
-            // Index loop and a COPIED twin, not a range-for over references: fn is arbitrary
-            // backend code, and a nested GetOrCreate on this table would resize m_slots and
-            // invalidate both the iterator and any reference into the vector that outlives the
-            // call. The one caller today happens not to insert; that is not a property the
-            // walk should depend on.
-            for (SizeT index = 0; index < m_slots.size(); ++index) {
-                const Entry& entry = m_slots[index];
-                if (!entry.Live || !entry.backend) continue;
-                const BackendPtr twin = entry.backend;
-                fn(MG_Pipe::MGPipeHandle{static_cast<Uint32>(index), entry.Gen}, twin);
-            }
-            for (SizeT index = 0; index < m_band.size(); ++index) {
-                const Entry& entry = m_band[index];
-                if (!entry.Live || !entry.backend) continue;
-                const BackendPtr twin = entry.backend;
-                fn(MG_Pipe::MGPipeHandle{
-                       static_cast<Uint32>(index) + MG_Pipe::kMGPipeShaderCsoCompositeSlotBase,
-                       entry.Gen},
-                   twin);
-            }
-        }
-
-        Uint32 LiveCount() const {
-            Uint32 count = 0;
-            for (const Entry& entry : m_slots) {
-                if (entry.Live) ++count;
-            }
-            for (const Entry& entry : m_band) {
-                if (entry.Live) ++count;
-            }
-            return count;
-        }
-
-        // The band's own live count, so a case can tell "the composite is twinned" from "the
-        // ordinary table grew to reach it" - which is the whole assertion the band exists for
-        // and is untestable from LiveCount alone.
-        Uint32 CompositeLiveCount() const {
-            Uint32 count = 0;
-            for (const Entry& entry : m_band) {
-                if (entry.Live) ++count;
-            }
-            return count;
-        }
-
-        // How many entries each space has ALLOCATED, live or not. A leak case asserts on these
-        // rather than on LiveCount: growth is what the band prevents, and a dense table that
-        // never shrinks is invisible to a liveness count.
-        SizeT OrdinaryCapacityForTest() const { return m_slots.size(); }
-        SizeT CompositeCapacityForTest() const { return m_band.size(); }
-
-    private:
-        // Drop the twin at `handle` if THIS table holds it. Frees nothing: the slot belongs to
-        // the kind, not to the table, and OnFrontendObjectDestroyed returns it once, after
-        // every holder has let go.
-        Bool ReleaseTwinAt(MG_Pipe::MGPipeHandle handle) {
-            // Forget the memo whenever it names this slot, even if this table has no entry
-            // there: a memo can be a handle learned from the allocator for an object another
-            // holder twinned, and it must not survive the slot's next handout.
-            if (m_memoHandle.Slot == handle.Slot) ForgetHandle();
-            // The twin's destructor is a driver call and could, in principle, re-enter
-            // GetOrCreate on this table and resize m_slots. So NOTHING that outlives the
-            // destructor may be a reference into m_slots: the twin is moved out into a local,
-            // the entry is finished with, and only then is the local released.
-            BackendPtr dead;
-            {
-                Entry* const entry = EntryOrNull(handle.Slot);
-                if (entry == nullptr || !entry->Live || entry->Gen != handle.Gen) return false;
-                dead = std::move(entry->backend);
-                entry->backend.reset();
-                entry->stateRef.reset();
-                entry->Live = false;
-            }
-            dead.reset();
-            return true;
-        }
-
-        // ---- P5e (id): the two slot spaces, resolved in ONE place ---------------------------
-        //
-        // Every reader and writer below goes through these three, so a caller that forgot the
-        // band cannot exist - the shape MGPipeSlotAllocator::EntryOf already uses one level
-        // out. kHasCompositeBand folds to `false` at compile time for the five non-ShaderCso
-        // instantiations, so their band is dead code and an empty Vector.
-        static constexpr Bool SlotIsBanded(Uint32 slot) {
-            return kHasCompositeBand && MG_Pipe::MGPipeIsCompositeShaderSlot(slot);
-        }
-        static constexpr SizeT IndexOfSlot(Uint32 slot) {
-            return SlotIsBanded(slot)
-                       ? static_cast<SizeT>(slot - MG_Pipe::kMGPipeShaderCsoCompositeSlotBase)
-                       : static_cast<SizeT>(slot);
-        }
-
-        // The entry a slot names, or null when its space has never grown that far. NEVER grows:
-        // a lookup that resized would turn every miss into an allocation, which is the hazard
-        // Find documents.
-        Entry* EntryOrNull(Uint32 slot) {
-            Vector<Entry>& table = SlotIsBanded(slot) ? m_band : m_slots;
-            const SizeT index = IndexOfSlot(slot);
-            if (index >= table.size()) return nullptr;
-            return &table[index];
-        }
-        const Entry* EntryOrNull(Uint32 slot) const {
-            return const_cast<BackendSlotTable*>(this)->EntryOrNull(slot);
-        }
-
-        // Grows the right space to hold `slot`. Every caller bounds `slot` first - the minting
-        // overload because the allocator produced it, the handle overload against
-        // kMaxHandleSlot - because this is the one place a client-supplied number decides an
-        // allocation size. A composite slot grows m_band by (slot - base) + 1, so the ordinary
-        // table never learns the band exists.
-        Entry& EntryAt(Uint32 slot) {
-            Vector<Entry>& table = SlotIsBanded(slot) ? m_band : m_slots;
-            const SizeT index = IndexOfSlot(slot);
-            if (index >= table.size()) table.resize(index + 1);
-            return table[index];
-        }
-
-        void RememberHandle(Uint64 lifetimeId, MG_Pipe::MGPipeHandle handle) const {
-            m_memoLifetimeId = lifetimeId;
-            m_memoHandle = handle;
-        }
-        void ForgetHandle() const {
-            m_memoLifetimeId = 0;
-            m_memoHandle = MG_Pipe::kMGPipeNullHandle;
-        }
-
-        // The holder list: intrusive and doubly linked, so registering and unregistering are
-        // two pointer writes with no allocation, and its head is a constant-initialised
-        // static - which is what lets the process-lifetime registry globals in Managers.cpp
-        // link themselves in from their own constructors with no initialisation-order
-        // question to answer. Single-threaded, like every table it links (the tables live and
-        // die on the context thread, as the notice they answer does).
-        void LinkHolder() {
-            m_prevHolder = nullptr;
-            m_nextHolder = s_firstHolder;
-            if (s_firstHolder != nullptr) s_firstHolder->m_prevHolder = this;
-            s_firstHolder = this;
-        }
-        void UnlinkHolder() {
-            if (m_prevHolder != nullptr) {
-                m_prevHolder->m_nextHolder = m_nextHolder;
-            } else {
-                s_firstHolder = m_nextHolder;
-            }
-            if (m_nextHolder != nullptr) m_nextHolder->m_prevHolder = m_prevHolder;
-            m_prevHolder = nullptr;
-            m_nextHolder = nullptr;
-        }
-
-        static inline BackendSlotTable* s_firstHolder = nullptr;
-        BackendSlotTable* m_prevHolder = nullptr;
-        BackendSlotTable* m_nextHolder = nullptr;
-
-        // Indexed by MGPipeHandle::Slot; [0] is the reserved slot and is never live.
-        Vector<Entry> m_slots;
-        // P5e (id): the ShaderCso COMPOSITE band, indexed by (slot -
-        // kMGPipeShaderCsoCompositeSlotBase) and EMPTY for every other kind. See
-        // kHasCompositeBand above for why it is a second vector and not more of the first.
-        Vector<Entry> m_band;
-        // Handed back by GetOrCreate for a null state object. Never live, never handed a handle.
-        BackendPtr m_nullTwin;
-
-        // ONE-entry resolution memo, lifetimeId -> handle. It exists because without it every
-        // resolution goes through the allocator's ByLifetimeId hash, which the deleted
-        // TwinLookupMemos existed to avoid and which D13 promises to replace with "direct slot
-        // indexing".
-        //
-        // It is one entry and therefore only helps a caller that asks for the SAME object twice
-        // running - ResolveVaoTwin and SyncCurrentProgram do, once per draw each. Two callers
-        // it does NOT help, recorded rather than claimed away: BindCurrentFBO resolves BOTH
-        // targets in a frame, and ResolveUnitSamplerBackend asks for a different sampler per
-        // texture unit, so both thrash a single-entry memo and pay the probe P1 did not (P1 had
-        // a per-unit memo and a direct-mapped 6-slot array there). Making the memo per-unit /
-        // per-target is the fix, and G11 - the device-side gate that would price it - is owed.
-        //
-        // It cannot serve a stale answer, by three independent arguments:
-        //   * the key is a lifetime id, which MG_State never hands out twice, so a recycled
-        //     heap address cannot hit this memo the way it could hit an address-keyed one;
-        //   * a null answer is never stored, so another holder's acquire cannot be hidden by
-        //     a "no handle" this table remembered earlier; and
-        //   * even a hit for a slot that has since been freed and re-handed is caught, because
-        //     the caller resolves the handle through FindByHandle, which compares Gen.
-        // Cleared anyway when a death notice names the memoised slot. 0 is never a live
-        // lifetime id (MG_State's counters start at 1), so a zeroed memo is a guaranteed miss.
-        mutable Uint64 m_memoLifetimeId = 0;
-        mutable MG_Pipe::MGPipeHandle m_memoHandle = MG_Pipe::kMGPipeNullHandle;
-    };
-
-#endif // MOBILEGL_PIPE_PUSH
-} // namespace MobileGL::MG_Backend::DirectGLES

MobileGL/MG_Backend/DirectGLES/Utils.h

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

MobileGL/MG_Backend/DirectGLES/WireTextureReadback.inc

@@ -1,463 +0,0 @@
-// Included in DirectGLES.cpp after the native packed-word readback helper.
-// A storage promotion needs the driver's own texels as owned tight rows, not
-// client PACK layout or a fallback into a frontend texture's potentially stale
-// shadow.
-    class ScopedWireTextureReadLevel {
-    public:
-        ScopedWireTextureReadLevel(GLuint texture, GLenum target, GLint level)
-            : m_texture(texture), m_target(target) {
-            switch (target) {
-            case GL_TEXTURE_2D: m_binding = GL_TEXTURE_BINDING_2D; break;
-            case GL_TEXTURE_3D: m_binding = GL_TEXTURE_BINDING_3D; break;
-            case GL_TEXTURE_2D_ARRAY: m_binding = GL_TEXTURE_BINDING_2D_ARRAY; break;
-            case GL_TEXTURE_CUBE_MAP: m_binding = GL_TEXTURE_BINDING_CUBE_MAP; break;
-            case GL_TEXTURE_CUBE_MAP_ARRAY: m_binding = GL_TEXTURE_BINDING_CUBE_MAP_ARRAY; break;
-            default: return;
-            }
-            GLint previous = 0;
-            DrainESErrors();
-            g_GLESFuncs.glGetIntegerv(m_binding, &previous);
-            g_GLESFuncs.glBindTexture(m_target, m_texture);
-            g_GLESFuncs.glGetTexParameteriv(m_target, GL_TEXTURE_BASE_LEVEL, &m_baseLevel);
-            g_GLESFuncs.glGetTexParameteriv(m_target, GL_TEXTURE_MAX_LEVEL, &m_maxLevel);
-            m_saved = g_GLESFuncs.glGetError() == GL_NO_ERROR;
-            if (m_saved) {
-                // ES framebuffer completeness can reject a defined level whose
-                // base level or intervening mip chain is missing/inconsistent.
-                // Read this existing native image as the sole base level. The
-                // logical GL parameters and every cached copy remain unchanged.
-                g_GLESFuncs.glTexParameteri(m_target, GL_TEXTURE_BASE_LEVEL, level);
-                g_GLESFuncs.glTexParameteri(m_target, GL_TEXTURE_MAX_LEVEL, level);
-                m_valid = g_GLESFuncs.glGetError() == GL_NO_ERROR;
-            }
-            g_GLESFuncs.glBindTexture(m_target, static_cast<GLuint>(previous));
-        }
-
-        ~ScopedWireTextureReadLevel() {
-            if (!m_saved) return;
-            // The packed-word path can use its own texture scratch binding.
-            // Save the binding at restoration time too; do not assume an active
-            // texture unit or make the backend's binding cache forget a bind.
-            GLint previous = 0;
-            g_GLESFuncs.glGetIntegerv(m_binding, &previous);
-            g_GLESFuncs.glBindTexture(m_target, m_texture);
-            g_GLESFuncs.glTexParameteri(m_target, GL_TEXTURE_BASE_LEVEL, m_baseLevel);
-            g_GLESFuncs.glTexParameteri(m_target, GL_TEXTURE_MAX_LEVEL, m_maxLevel);
-            g_GLESFuncs.glBindTexture(m_target, static_cast<GLuint>(previous));
-        }
-
-        Bool Valid() const { return m_valid; }
-
-    private:
-        GLuint m_texture;
-        GLenum m_target;
-        GLenum m_binding = GL_NONE;
-        GLint m_baseLevel = 0, m_maxLevel = 0;
-        Bool m_saved = false, m_valid = false;
-    };
-
-    static Bool ReadWireColorRowsTight(GLsizei width, GLsizei height, GLenum format, GLenum type,
-                                      Bool forceOpaqueAlpha, const NormalizedImageCarrierRead& carrier,
-                                      Vector<Uint8>& bytes) {
-        ReadbackChannelMapping mapping{};
-        if (!GetReadbackChannelMapping(format, mapping)) return false;
-        const SizeT pixelBytes = GetReadbackDstPixelSize(mapping, type);
-        if (!pixelBytes || width <= 0 || height <= 0) return false;
-        const GLenum componentType = QueryReadAttachmentComponentType();
-        const Bool integerAttachment = componentType == GL_INT || componentType == GL_UNSIGNED_INT;
-        if (carrier.Active() ? (mapping.isInteger || !integerAttachment)
-                             : mapping.isInteger != integerAttachment) return false;
-
-        GLint implFormat = 0, implType = 0;
-        g_GLESFuncs.glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &implFormat);
-        g_GLESFuncs.glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &implType);
-        struct Candidate { GLenum format, type; };
-        Vector<Candidate> candidates;
-        if (carrier.Active()) {
-            candidates.push_back({GL_RGBA_INTEGER, GL_UNSIGNED_INT});
-        } else if (mapping.isInteger) {
-            if (GetWideReadChannelCount(implFormat) > 0 && IsIntegerReadFormat(implFormat) &&
-                (implType == GL_INT || implType == GL_UNSIGNED_INT))
-                candidates.push_back({static_cast<GLenum>(implFormat), static_cast<GLenum>(implType)});
-            candidates.push_back({GL_RGBA_INTEGER, componentType == GL_INT ? GLenum(GL_INT) : GLenum(GL_UNSIGNED_INT)});
-        } else {
-            if (GetWideReadChannelCount(implFormat) > 0 && !IsIntegerReadFormat(implFormat) &&
-                (CanDecodeWideSourceType(implType) ||
-                 (implFormat == GL_RGBA && implType == GL_UNSIGNED_INT_2_10_10_10_REV)))
-                candidates.push_back({static_cast<GLenum>(implFormat), static_cast<GLenum>(implType)});
-            if (componentType == GL_FLOAT) candidates.push_back({GL_RGBA, GL_FLOAT});
-            if (componentType == GL_SIGNED_NORMALIZED) {
-                candidates.push_back({GL_RGBA, GL_SHORT});
-                candidates.push_back({GL_RGBA, GL_BYTE});
-            } else candidates.push_back({GL_RGBA, GL_UNSIGNED_BYTE});
-        }
-        ScopedPixelPackBuffer packBuffer(0);
-        ScopedPackState packState(PixelStoreImpl::PackState{1, 0, 0, 0});
-        const SizeT pixels = static_cast<SizeT>(width) * static_cast<SizeT>(height);
-        Vector<Uint8> wide;
-        GLenum wideType = GL_NONE;
-        Int channels = 0;
-        DrainESErrors();
-        for (const auto candidate : candidates) {
-            channels = GetWideReadChannelCount(candidate.format);
-            wide.resize(pixels * static_cast<SizeT>(channels) * GetReadbackComponentSize(candidate.type));
-            g_GLESFuncs.glReadPixels(0, 0, width, height, candidate.format, candidate.type, wide.data());
-            if (g_GLESFuncs.glGetError() == GL_NO_ERROR) { wideType = candidate.type; break; }
-        }
-        if (wideType == GL_NONE) return false;
-
-        if (carrier.Active()) {
-            Vector<Uint8> decoded(pixels * 4 * sizeof(Float));
-            auto* dst = reinterpret_cast<Float*>(decoded.data());
-            const auto* src = reinterpret_cast<const Uint32*>(wide.data());
-            for (SizeT i = 0; i < pixels; ++i) {
-                for (SizeT c = 0; c < 4; ++c) {
-                    const Float divisor = static_cast<Float>(carrier.ChannelMax[c]);
-                    dst[i * 4 + c] = carrier.SignedNormalized
-                        ? std::max(static_cast<Float>(static_cast<Int16>(static_cast<Uint16>(src[i * 4 + c]))) / divisor, -1.0f)
-                        : static_cast<Float>(src[i * 4 + c]) / divisor;
-                }
-            }
-            wide = Move(decoded); wideType = GL_FLOAT; channels = 4;
-        } else if (wideType == GL_UNSIGNED_INT_2_10_10_10_REV) {
-            Vector<Uint8> decoded(pixels * 4 * sizeof(Float));
-            auto* dst = reinterpret_cast<Float*>(decoded.data());
-            for (SizeT i = 0; i < pixels; ++i) {
-                Uint32 word = 0;
-                Memcpy(&word, wide.data() + i * sizeof(word), sizeof(word));
-                dst[i * 4] = static_cast<Float>(word & 1023u) / 1023.0f;
-                dst[i * 4 + 1] = static_cast<Float>((word >> 10) & 1023u) / 1023.0f;
-                dst[i * 4 + 2] = static_cast<Float>((word >> 20) & 1023u) / 1023.0f;
-                dst[i * 4 + 3] = static_cast<Float>((word >> 30) & 3u) / 3.0f;
-            }
-            wide = Move(decoded); wideType = GL_FLOAT; channels = 4;
-        }
-        if (channels < 4) ExpandNarrowWideRead(wide, pixels, channels, wideType);
-        if (forceOpaqueAlpha) ForceWideReadAlphaToOne(wide, pixels, wideType);
-        Vector<Uint8> converted(pixels * pixelBytes);
-        const SizeT sourceRowBytes = static_cast<SizeT>(width) * 4 * GetReadbackComponentSize(wideType);
-        for (GLsizei row = 0; row < height; ++row)
-            ReadbackImpl::ConvertWideReadbackRow(wide.data() + static_cast<SizeT>(row) * sourceRowBytes,
-                converted.data() + static_cast<SizeT>(row) * width * pixelBytes, width, wideType, mapping, type);
-        bytes = Move(converted);
-        return true;
-    }
-
-    static Bool ReadWireDepthStencilLevelTight(GLuint texture, TextureTarget target,
-                                               TextureUploadTarget uploadTarget, GLint level,
-                                               const IntVec3& extent, GLenum format, GLenum type,
-                                               Vector<Uint8>& bytes) {
-        const SizeT pixelBytes = MG_Util::GetInputBytesPerPixel(
-            MG_Util::ConvertGLEnumToTextureInputFormat(format), MG_Util::ConvertGLEnumToTexturePixelDataType(type));
-        if (!pixelBytes) return false;
-        const Bool needDepth = format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL;
-        const Bool needStencil = format == GL_STENCIL_INDEX || format == GL_DEPTH_STENCIL;
-        ScopedFramebufferBinding bindings(true, false);
-        GLuint fbo = 0;
-        g_GLESFuncs.glGenFramebuffers(1, &fbo);
-        struct DeleteFbo { GLuint id; ~DeleteFbo() { g_GLESFuncs.glDeleteFramebuffers(1, &id); } } cleanup{fbo};
-        FramebufferImpl::BindFramebufferId(GL_READ_FRAMEBUFFER, fbo);
-        ScopedPixelPackBuffer packBuffer(0);
-        ScopedPackState packState(PixelStoreImpl::PackState{1, 0, 0, 0});
-        const GLenum nativeTarget = TextureImpl::ConvertTextureTargetToBackendGLEnum(target);
-        const GLenum point = needDepth ? (needStencil ? GL_DEPTH_STENCIL_ATTACHMENT : GL_DEPTH_ATTACHMENT)
-                                      : GL_STENCIL_ATTACHMENT;
-        const SizeT count = static_cast<SizeT>(extent.x()) * extent.y();
-        Vector<Uint8> result(count * extent.z() * pixelBytes);
-        if (g_GLESFuncs.glMemoryBarrier) g_GLESFuncs.glMemoryBarrier(GL_ALL_BARRIER_BITS);
-        g_GLESFuncs.glFinish();
-        for (GLint z = 0; z < extent.z(); ++z) {
-            if (nativeTarget == GL_TEXTURE_3D || nativeTarget == GL_TEXTURE_2D_ARRAY ||
-                nativeTarget == GL_TEXTURE_CUBE_MAP_ARRAY)
-                g_GLESFuncs.glFramebufferTextureLayer(GL_READ_FRAMEBUFFER, point, texture, level, z);
-            else
-                g_GLESFuncs.glFramebufferTexture2D(GL_READ_FRAMEBUFFER, point,
-                    TextureImpl::ConvertTextureUploadTargetToBackendGLEnum(uploadTarget), texture, level);
-            g_GLESFuncs.glReadBuffer(GL_NONE);
-            if (g_GLESFuncs.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) return false;
-            Vector<Float> depth;
-            Vector<Uint8> stencil;
-            if (needDepth && !ReadDepthValuesNative(0, 0, extent.x(), extent.y(), depth)) return false;
-            if (needStencil && !ReadStencilBytesNative(0, 0, extent.x(), extent.y(), stencil)) return false;
-            auto* dst = result.data() + count * z * pixelBytes;
-            for (SizeT i = 0; i < count; ++i) {
-                if (format == GL_DEPTH_STENCIL) {
-                    const Uint32 s = stencil[i];
-                    if (type == GL_UNSIGNED_INT_24_8) {
-                        const Uint32 packed = (NormalizedDepthToUnsigned(depth[i], 16777215.0) << 8) | s;
-                        Memcpy(dst + i * pixelBytes, &packed, sizeof(packed));
-                    } else if (type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) {
-                        Memcpy(dst + i * pixelBytes, &depth[i], sizeof(Float));
-                        Memcpy(dst + i * pixelBytes + sizeof(Float), &s, sizeof(s));
-                    } else return false;
-                } else if (type == GL_FLOAT) {
-                    const Float value = needDepth ? depth[i] : static_cast<Float>(stencil[i]);
-                    Memcpy(dst + i * pixelBytes, &value, sizeof(value));
-                } else if (type == GL_HALF_FLOAT) {
-                    const Uint16 value = MG_Util::EncodeFloatToHalfBits(
-                        needDepth ? depth[i] : static_cast<Float>(stencil[i]));
-                    Memcpy(dst + i * pixelBytes, &value, sizeof(value));
-                } else {
-                    const Bool signedType = type == GL_BYTE || type == GL_SHORT || type == GL_INT;
-                    const Double maximum = signedType
-                        ? (pixelBytes == 1 ? 127.0 : pixelBytes == 2 ? 32767.0 : 2147483647.0)
-                        : (pixelBytes == 1 ? 255.0 : pixelBytes == 2 ? 65535.0 : 4294967295.0);
-                    const Uint32 value = needDepth ? NormalizedDepthToUnsigned(depth[i], maximum) : stencil[i];
-                    if (pixelBytes == 1) dst[i] = static_cast<Uint8>(value);
-                    else if (pixelBytes == 2) { const Uint16 v = static_cast<Uint16>(value); Memcpy(dst + i * 2, &v, 2); }
-                    else if (pixelBytes == 4) Memcpy(dst + i * 4, &value, 4);
-                    else return false;
-                }
-            }
-        }
-        bytes = Move(result);
-        return true;
-    }
-
-    Bool ReadTextureLevelTight(GLuint texture, TextureTarget target, TextureUploadTarget uploadTarget,
-                               TextureInternalFormat logicalFormat, GLint level, const IntVec3& logicalExtent,
-                               Bool sourceUsesImageCarrier, GLenum format, GLenum type, Vector<Uint8>& bytes) {
-        if (!texture || level < 0 || TextureImpl::IsMultisampleTextureTarget(target)) return false;
-        const IntVec3 extent = TextureImpl::GetBackendUploadSize(target, logicalExtent);
-        const GLenum nativeTarget = TextureImpl::ConvertTextureTargetToBackendGLEnum(target);
-        ScopedWireTextureReadLevel readLevel(texture, nativeTarget, level);
-        if (!readLevel.Valid()) return false;
-        if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL || format == GL_STENCIL_INDEX)
-            return ReadWireDepthStencilLevelTight(texture, target, uploadTarget, level, extent, format, type, bytes);
-        ReadbackChannelMapping mapping{};
-        if (!GetReadbackChannelMapping(format, mapping)) return false;
-        const SizeT pixelBytes = GetReadbackDstPixelSize(mapping, type);
-        if (!pixelBytes || extent.x() <= 0 || extent.y() <= 0 || extent.z() <= 0) return false;
-        const GLenum faceTarget = TextureImpl::ConvertTextureUploadTargetToBackendGLEnum(uploadTarget);
-        const auto widening = sourceUsesImageCarrier
-            ? TextureImpl::GetImageBindableStorageWidening(logicalFormat) : TextureImpl::ImageBindableStorageWidening{};
-        const SizeT sliceBytes = static_cast<SizeT>(extent.x()) * extent.y() * pixelBytes;
-        Vector<Uint8> result(sliceBytes * static_cast<SizeT>(extent.z()));
-        if (g_GLESFuncs.glMemoryBarrier) g_GLESFuncs.glMemoryBarrier(GL_ALL_BARRIER_BITS);
-        g_GLESFuncs.glFinish();
-
-        // A raw packed word may have redundant encodings or NaN payloads. Read
-        // it through R32UI when the source really still uses that native layout.
-        const Bool rawPacked = !widening && MG_Util::PixelStoreProcessor::IsRawPackedPixelTransfer(
-            logicalFormat, MG_Util::ConvertGLEnumToTextureInputFormat(format),
-            MG_Util::ConvertGLEnumToTexturePixelDataType(type));
-        if (rawPacked && pixelBytes == sizeof(Uint32)) {
-            const GLint face = uploadTarget >= TextureUploadTarget::CubeMapPositiveX &&
-                               uploadTarget <= TextureUploadTarget::CubeMapNegativeZ
-                ? static_cast<GLint>(uploadTarget) - static_cast<GLint>(TextureUploadTarget::CubeMapPositiveX) : 0;
-            for (GLint layer = 0; layer < extent.z(); ++layer)
-                if (!ReadPackedLevelWordsViaScratch(texture, nativeTarget, level, face + layer, extent.x(), extent.y(),
-                        reinterpret_cast<Uint32*>(result.data() + static_cast<SizeT>(layer) * sliceBytes))) return false;
-            bytes = Move(result);
-            return true;
-        }
-
-        NormalizedImageCarrierRead carrier{};
-        if (widening && widening.CarriesNormalizedCodes()) {
-            for (SizeT c = 0; c < 4; ++c) carrier.ChannelMax[c] = widening.ChannelMax[c];
-            carrier.SignedNormalized = widening.SignedNormalized;
-        }
-        TempFBOBinder binder(true);
-        auto& framebuffer = binder.Framebuffer();
-        for (GLint layer = 0; layer < extent.z(); ++layer) {
-            if (nativeTarget == GL_TEXTURE_3D || nativeTarget == GL_TEXTURE_2D_ARRAY || nativeTarget == GL_TEXTURE_CUBE_MAP_ARRAY)
-                ScratchFBOImpl::EnsureColorAttachmentLayer(framebuffer, GL_READ_FRAMEBUFFER, texture, level, layer);
-            else
-                ScratchFBOImpl::EnsureColorAttachment2D(framebuffer, GL_READ_FRAMEBUFFER, texture, faceTarget, level);
-            ScratchFBOImpl::EnsureReadBuffer(framebuffer, GL_COLOR_ATTACHMENT0);
-            const GLenum status = g_GLESFuncs.glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
-            if (status != GL_FRAMEBUFFER_COMPLETE) {
-                MGLOG_E_ONCE("Espryt wire texture readback: framebuffer status=0x%x texture=%u level=%d target=0x%x",
-                            status, texture, level, nativeTarget);
-                return false;
-            }
-            Vector<Uint8> slice;
-            if (!ReadWireColorRowsTight(extent.x(), extent.y(), format, type,
-                    TextureImpl::BackendTextureFormatAddsAlpha(logicalFormat, target), carrier, slice) ||
-                slice.size() != sliceBytes) return false;
-            Memcpy(result.data() + static_cast<SizeT>(layer) * sliceBytes, slice.data(), sliceBytes);
-        }
-        bytes = Move(result);
-        return true;
-    }
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // P9 W2-a. The store's Defined-ness follows the client's respecifies; the driver's follows the
-    // twin's last sync. A re-mint asks this before reading a level back, because a level defined
-    // after that sync (null data, or null data plus a partial upload) is not on the driver yet and
-    // its FBO attachment is incomplete - which used to end the session at
-    // Fatal{ResourceUnavailable, "image-promotion-readback"} on legal GL.
-    Bool NativeTextureLevelHasExtent(GLuint texture, TextureTarget target, TextureUploadTarget uploadTarget,
-                                     GLint level, const IntVec3& logicalExtent) {
-        if (!texture || level < 0 || !g_GLESFuncs.glGetTexLevelParameteriv) return true;
-        const IntVec3 extent = TextureImpl::GetBackendUploadSize(target, logicalExtent);
-        const GLenum nativeTarget = TextureImpl::ConvertTextureTargetToBackendGLEnum(target);
-        GLenum binding = GL_NONE;
-        switch (nativeTarget) {
-        case GL_TEXTURE_2D: binding = GL_TEXTURE_BINDING_2D; break;
-        case GL_TEXTURE_3D: binding = GL_TEXTURE_BINDING_3D; break;
-        case GL_TEXTURE_2D_ARRAY: binding = GL_TEXTURE_BINDING_2D_ARRAY; break;
-        case GL_TEXTURE_CUBE_MAP: binding = GL_TEXTURE_BINDING_CUBE_MAP; break;
-        case GL_TEXTURE_CUBE_MAP_ARRAY: binding = GL_TEXTURE_BINDING_CUBE_MAP_ARRAY; break;
-        default: return true;
-        }
-        // A cube's levels are per face; every other target answers for the whole level.
-        const GLenum queryTarget = nativeTarget == GL_TEXTURE_CUBE_MAP
-            ? TextureImpl::ConvertTextureUploadTargetToBackendGLEnum(uploadTarget) : nativeTarget;
-        DrainESErrors();
-        GLint previous = 0;
-        g_GLESFuncs.glGetIntegerv(binding, &previous);
-        g_GLESFuncs.glBindTexture(nativeTarget, texture);
-        GLint width = 0, height = 0, depth = 0;
-        g_GLESFuncs.glGetTexLevelParameteriv(queryTarget, level, GL_TEXTURE_WIDTH, &width);
-        g_GLESFuncs.glGetTexLevelParameteriv(queryTarget, level, GL_TEXTURE_HEIGHT, &height);
-        g_GLESFuncs.glGetTexLevelParameteriv(queryTarget, level, GL_TEXTURE_DEPTH, &depth);
-        const Bool answered = g_GLESFuncs.glGetError() == GL_NO_ERROR;
-        g_GLESFuncs.glBindTexture(nativeTarget, static_cast<GLuint>(previous));
-        if (!answered) return true;
-        const Bool layered = nativeTarget == GL_TEXTURE_3D || nativeTarget == GL_TEXTURE_2D_ARRAY ||
-                             nativeTarget == GL_TEXTURE_CUBE_MAP_ARRAY;
-        return width == extent.x() && height == extent.y() && (!layered || depth == extent.z());
-    }
-
-    // P8-E (notes/p8/E.md). MGITEST_ESPRYT_REFUSE_TEXTURE_READBACK_EXTENT=<w>x<h>, READ BY THE SERVER:
-    // a colour level of exactly that extent is treated as one the driver refused to attach - what an
-    // Adreno does for RGB16 and the 16-bit SNORM formats, and what no host driver can be made to do.
-    // Scoped by the extent so the tcp lane's shared supervisor can carry it for the whole lane: only
-    // the scenario that builds that extent (CopyImageStoreReadbackScenario) ever meets it.
-    static Bool WireTextureReadbackRefusedForTesting(const IntVec3& extent) {
-        static const IntVec3 s_refused = [] {
-            const char* value = std::getenv("MGITEST_ESPRYT_REFUSE_TEXTURE_READBACK_EXTENT");
-            if (value == nullptr) return IntVec3{0, 0, 0};
-            char* end = nullptr;
-            const long width = std::strtol(value, &end, 10);
-            if (end == value || *end != 'x') return IntVec3{0, 0, 0};
-            const long height = std::strtol(end + 1, nullptr, 10);
-            if (width <= 0 || height <= 0) return IntVec3{0, 0, 0};
-            return IntVec3{static_cast<Int>(width), static_cast<Int>(height), 1};
-        }();
-        return s_refused.x() > 0 && extent == s_refused;
-    }
-
-    // P8-E: THE STORE ROUTE, for a level the driver refused to read back. The server's staged store
-    // is the only CPU copy of the level on this side, and it answers only while its bytes ARE the
-    // level: every byte crossed (IsCovered), at the extent asked for, and the texture was never
-    // written by the driver except by copies the store followed (!IsDriverWritten - see
-    // StagedTextureStore's P8-E block and FollowCopyImageInStagedStore). The conversion is
-    // GetTexImageViaShadowConversion's, into tight rows: a packed format read with its own type
-    // takes the stored words verbatim, everything else decodes to wide RGBA and converts row by row.
-    // Anything else DECLINES BY NAME: the reply is an error, and the client's
-    // Fatal{ReplyError, "ReadPixels"} ends the session instead of handing back bytes the driver has
-    // since overwritten.
-    static Bool ReadWireLevelFromStagedStore(MG_Pipe::MGPipeHandle res, TextureInternalFormat logicalFormat,
-                                             TextureUploadTarget uploadTarget, GLint level, const IntVec3& extent,
-                                             GLenum format, GLenum type, Vector<Uint8>& bytes) {
-        auto& store = MG_Remote::Server::ServerStagedTexture();
-        const Uint64 key = MG_Remote::Server::StagedTextureStore::KeyForHandle(res);
-        const auto target = static_cast<Uint16>(uploadTarget);
-        const auto mip = static_cast<Uint16>(level);
-        ReadbackChannelMapping mapping{};
-        const SizeT pixelBytes = GetReadbackChannelMapping(format, mapping) ? GetReadbackDstPixelSize(mapping, type) : 0;
-        const SizeT texels = static_cast<SizeT>(std::max(extent.x(), 0)) * static_cast<SizeT>(std::max(extent.y(), 0)) *
-                             static_cast<SizeT>(std::max(extent.z(), 0));
-        const char* declined = nullptr;
-        if (!store.CopiesIntoServerStorage()) {
-            declined = "this arm keeps no staged store";
-        } else if (store.IsDriverWritten(key)) {
-            declined = "the driver has written the texture since its bytes crossed";
-        } else if (!store.IsCovered(key, target, mip)) {
-            declined = "not every byte of the level crossed";
-        } else if (store.LevelExtentOrUndefined(key, target, mip) != extent) {
-            declined = "the staged level is not the extent asked for";
-        } else if (pixelBytes == 0 || texels == 0) {
-            declined = "the format/type pair has no readback mapping";
-        }
-        Vector<Uint8> out;
-        if (declined == nullptr) {
-            const Uint8* staged = store.RequireLevelBytes(key, target, mip, "texture-readback-from-store");
-            if (MG_Util::PixelStoreProcessor::IsRawPackedPixelTransfer(
-                    logicalFormat, MG_Util::ConvertGLEnumToTextureInputFormat(format),
-                    MG_Util::ConvertGLEnumToTexturePixelDataType(type))) {
-                if (store.LevelByteSize(key, target, mip) != texels * pixelBytes) {
-                    declined = "the staged words are not the client's word size";
-                } else {
-                    out.assign(staged, staged + texels * pixelBytes);
-                }
-            } else {
-                Vector<Uint8> wide;
-                Bool isInteger = false;
-                Bool isSigned = false;
-                if (!MG_Util::PixelStoreProcessor::DecodeShadowDataToWideRGBA(logicalFormat, staged, texels, wide,
-                                                                             isInteger, isSigned)) {
-                    declined = "the staged format has no wide decoding";
-                } else if (mapping.isInteger != isInteger) {
-                    declined = "an integer read of a normalized level, or the reverse";
-                } else {
-                    const GLenum wideType = isInteger ? (isSigned ? GL_INT : GL_UNSIGNED_INT) : GL_FLOAT;
-                    const SizeT rowTexels = static_cast<SizeT>(extent.x());
-                    const SizeT rows = texels / rowTexels;
-                    const SizeT wideRowBytes = rowTexels * 4 * GetReadbackComponentSize(wideType);
-                    out.resize(texels * pixelBytes);
-                    for (SizeT row = 0; row < rows; ++row) {
-                        ReadbackImpl::ConvertWideReadbackRow(wide.data() + row * wideRowBytes,
-                                                             out.data() + row * rowTexels * pixelBytes, rowTexels,
-                                                             wideType, mapping, type);
-                    }
-                }
-            }
-        }
-        if (declined != nullptr) {
-            MGLOG_E_ONCE("MGPipe: texture {%u,%u} level %d: the driver refused the readback and the staged store "
-                         "cannot answer it (%s) - DECLINED (texture-readback-store-declined)",
-                         res.Slot, res.Gen, level, declined);
-            return false;
-        }
-        MGLOG_W_ONCE("MGPipe: texture {%u,%u} level %d: the driver refused the readback (internal format %u); "
-                     "answered from the server's staged store (texture-readback-from-store)",
-                     res.Slot, res.Gen, level, static_cast<unsigned>(logicalFormat));
-        bytes = Move(out);
-        return true;
-    }
-
-    Bool ReadTextureImageWire(const MG_Pipe::MGPReadbackInfo& info, Vector<Uint8>& bytes) {
-        const auto* record = PipeTextureRecordForHandle(info.Res);
-        if (!record) return false;
-        TextureTarget target = TextureTarget::Unknown;
-        for (Int i = 0; i < static_cast<Int>(TextureTarget::TextureTargetCount); ++i)
-            if (MG_Pipe::MGPipeResourceTargetForTextureTarget(static_cast<TextureTarget>(i)) == record->Desc.Target)
-                target = static_cast<TextureTarget>(i);
-        if (target == TextureTarget::Unknown) return false;
-        const auto twin = TextureImpl::SyncTextureToBackendByHandle(info.Res);
-        if (!twin) return false;
-        const Bool wholeCube = info.Target == GL_TEXTURE_CUBE_MAP;
-        const IntVec3 extent{static_cast<Int>(info.Box.W), static_cast<Int>(info.Box.H),
-                            wholeCube ? 1 : static_cast<Int>(info.Box.D)};
-        const auto logicalFormat = static_cast<TextureInternalFormat>(record->Desc.InternalFormat);
-        // The R32UI word leg never goes through a framebuffer, so the knob leaves it alone (it is
-        // ReadTextureLevelTight's first choice for exactly these reads).
-        const Bool packedWordRead =
-            !twin->RequiresImageBindableStorage() &&
-            MG_Util::PixelStoreProcessor::IsRawPackedPixelTransfer(
-                logicalFormat, MG_Util::ConvertGLEnumToTextureInputFormat(info.Format),
-                MG_Util::ConvertGLEnumToTexturePixelDataType(info.Type)) &&
-            MG_Util::GetInputBytesPerPixel(MG_Util::ConvertGLEnumToTextureInputFormat(info.Format),
-                                           MG_Util::ConvertGLEnumToTexturePixelDataType(info.Type)) == sizeof(Uint32);
-        const Bool refusedForTesting = !packedWordRead && WireTextureReadbackRefusedForTesting(extent);
-        Vector<Uint8> result;
-        for (Int face = 0; face < (wholeCube ? 6 : 1); ++face) {
-            const auto uploadTarget = wholeCube
-                ? static_cast<TextureUploadTarget>(static_cast<Int>(TextureUploadTarget::CubeMapPositiveX) + face)
-                : MG_Util::ConvertGLEnumToTextureUploadTarget(info.Target);
-            Vector<Uint8> slice;
-            if (refusedForTesting ||
-                !ReadTextureLevelTight(twin->GetBackendTextureId(), target, uploadTarget, logicalFormat, info.Level,
-                    extent, twin->RequiresImageBindableStorage(), info.Format, info.Type, slice)) {
-                if (!ReadWireLevelFromStagedStore(info.Res, logicalFormat, uploadTarget, info.Level, extent,
-                                                  info.Format, info.Type, slice)) return false;
-            }
-            result.insert(result.end(), slice.begin(), slice.end());
-        }
-        bytes = Move(result);
-        return true;
-    }
-#endif // MOBILEGL_BUILD_DISAGGREGATED

MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.h

@@ -1,87 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.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 "../BackendObject.h"
-#include <MG_Util/BackendLoaders/Vulkan/Loader.h>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    // Populates the same format-capability cache used by backend startup. Passing the
-    // instance-resolved function keeps standalone callers independent of global loader
-    // initialization; the physical device must remain valid for the duration of the call.
-    void PopulateFormatCapabilities(VkPhysicalDevice physicalDevice,
-                                    PFN_vkGetPhysicalDeviceFormatProperties getFormatProperties,
-                                    const MG_External::VulkanCapabilities& capabilities,
-                                    FormatCapabilityCache& cache);
-
-    class BackendObject_DirectVulkan : public BackendObject {
-    public:
-        BackendObject_DirectVulkan();
-        ~BackendObject_DirectVulkan() override;
-
-        void Initialize() override;
-        Bool InitWindowSurface() override;
-        Bool InitCapabilities() override;
-        Bool InitializeEGLDisplay(EGLDisplay dpy, EGLint* major, EGLint* minor) override;
-        Bool CreateEGLWindowSurface(EGLSurface surface, const WindowHandle& handle) override;
-        Bool ResizeEGLWindowSurface(EGLSurface surface, Uint32 width, Uint32 height) override;
-        Bool CreateEGLPbufferSurface(EGLSurface surface, EGLint width, EGLint height) override;
-        Bool MakeEGLCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) override;
-        Bool SwapEGLBuffers(EGLDisplay dpy, EGLSurface draw) override;
-        void SetEGLSwapInterval(Int interval) override;
-        void ReleaseEGLSurface(EGLSurface surface) override;
-        void ReleaseEGLResources() override;
-
-        const RendererInfo& GetRendererInfo() const override;
-        String GetBackendAPIVersionString() const override;
-        const GlobalBackendFunctionsTable& GetBackendFunctions() const override;
-        const DynamicBackendParameters& GetDynamicParameters() const override;
-        BackendType GetBackendType() const override;
-        void ApplyVulkanCapabilitiesForTesting(const MG_External::VulkanCapabilities& capabilities);
-
-    private:
-        Bool InitPbufferSurface(EGLint width, EGLint height) override;
-        void OnEGLSurfaceReleased(EGLSurface surface) override;
-        void UpdateAdvertisedExtensions();
-        void UpdateDynamicBackendParameters();
-
-        Bool m_initialized = false;
-        DynamicBackendParameters m_dynamicParameters;
-        MG_External::VulkanCapabilities m_vulkanCaps;
-        RendererInfo m_rendererInfo;
-    };
-
-    // Single-source-of-truth helpers shared with the driver POST
-    // (MG_Util/SelfTest/DriverPost.cpp), so the identity strings and extension list
-    // MobileGL reports to applications on this backend cannot drift from what the
-    // POST screen shows.
-
-    // Static identity of the Magma renderer (renderer/backend names, target GL/GLSL
-    // versions, ExtraVendor) with the baseline extension advertisement (no runtime-gated
-    // capabilities). A live backend copies this in its constructor and
-    // reconciles the Extensions in UpdateAdvertisedExtensions once real capabilities
-    // exist; callers that need the advertised list for a known capability set must
-    // use BuildAdvertisedExtensions instead.
-    const RendererInfo& GetRendererIdentity();
-
-    // The full OpenGL extension list Magma advertises (glGetString(GL_EXTENSIONS)) for
-    // a device with the given raw capabilities. The MOBILEGL_MAGMA_DISABLE_SUBGROUP and
-    // MOBILEGL_DISABLE_TIMERQUERY escape hatches are applied inside, so callers pass
-    // the detected device support (passing an already-gated value is harmless).
-    Vector<GLExtension> BuildAdvertisedExtensions(Bool shaderSubgroupSupported, Bool timerQueriesSupported,
-                                                  Bool anisotropicFilteringSupported,
-                                                  Bool nonZeroIndirectBaseInstanceSupported,
-                                                  Bool cubeMapArraySupported);
-
-    // Format: <GPU Name>, Vulkan <Vulkan Version>, Driver <Driver Version> — the exact
-    // string an initialized backend returns from GetBackendAPIVersionString (and that
-    // ends up inside the application-visible GL_RENDERER string).
-    String FormatBackendAPIVersionString(const String& deviceName, const String& vulkanApiVersionString,
-                                         const String& driverVersionString);
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/DescriptorPoolCensus.h

@@ -1,29 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/DescriptorPoolCensus.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 <cstdint>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    // A count of Magma's per-frame descriptor pools and the sets they hold (UniformManager), for
-    // tests. Dependency-free on purpose: the integration scenarios include it next to the system GL
-    // headers. They link the static library on desktop; the shipping shared library is built with
-    // hidden visibility, so on Android nothing outside the library can call GetDescriptorPoolCensus.
-    struct DescriptorPoolCensus {
-        bool available = false;         // false when no Magma renderer is live (e.g. the DirectGLES backend)
-        uint32_t frameSlots = 0;
-        uint32_t pools = 0;             // descriptor pools across every frame slot
-        uint32_t maxPoolsInOneSlot = 0;
-        uint64_t capacitySets = 0;      // sum of maxSets over those pools
-        uint64_t cachedSets = 0;        // sets allocated from them and held in the per-layout caches
-        uint64_t slotTrims = 0;         // whole-slot trims since the renderer came up
-    };
-
-    DescriptorPoolCensus GetDescriptorPoolCensus();
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/DirectVulkan.h

@@ -1,160 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/DirectVulkan.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 <MG_Backend/BackendObject.h>
-#include "Renderer/VulkanRenderer.h"
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    extern UniquePtr<VulkanRenderer>& pVulkanRenderer;
-
-    // Generation of the live VulkanRenderer instance, mirroring DirectGLES's
-    // g_syncContextGeneration. BackendObject_DirectVulkan bumps it wherever
-    // pVulkanRenderer is reset or recreated; fence and timer-query handles
-    // stamped with an older generation are stale and resolve as signaled /
-    // available with zero results instead of dereferencing the destroyed
-    // renderer's frame serials and query-pool slots.
-    Uint64 GetRendererGeneration();
-    void BumpRendererGeneration();
-
-#if MOBILEGL_BUILD_DISAGGREGATED && MOBILEGL_PIPE_PUSH
-    // P7 wave 2 package C (CONTRACT-P7 §5.5). Magma's StateObjectDeathOps table, installed
-    // from BackendObject_DirectVulkan::Initialize() so that GetStateObjectDeathOps() is
-    // non-null on every Magma role that owns a backend. See the definition for what the one
-    // arm does and for the inproc gap it closes. Push-only and disaggregated-only: a pull
-    // build declares no notice at all (StateObjectDeathNotice.h) and has nothing to emit.
-    void InstallStateObjectDeathOps();
-    // True when the notice currently installed is this backend's. Read by MG_Test so the
-    // install can be asserted without a death having to happen first.
-    Bool StateObjectDeathOpsInstalled();
-#endif
-
-    // 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);
-    void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices);
-    void DrawArrays(GLenum mode, GLint first, GLsizei count);
-    void DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLint basevertex);
-    void MultiDrawArrays(GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount);
-    void MultiDrawElements(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                           GLsizei drawcount);
-    void MultiDrawElementsBaseVertex(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices,
-                                     GLsizei drawcount, const GLint* basevertex);
-    void MultiDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride);
-    void MultiDrawArraysIndirect(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride);
-    void MultiDrawElementsIndirectCount(GLenum mode, GLenum type, const void* indirect, GLintptr drawcount,
-                                        GLsizei maxdrawcount, 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);
-    void DrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void* indices,
-                                                     GLsizei instancecount, GLint basevertex, GLuint baseinstance);
-    void DrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void* indices,
-                                         GLsizei instancecount, GLint basevertex);
-    void DrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void* indices,
-                                           GLsizei instancecount, GLuint baseinstance);
-    void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount);
-    void DrawElementsIndirect(GLenum mode, GLenum type, const void* indirect);
-    void DrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount,
-                                         GLuint baseinstance);
-    void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-    void DrawArraysIndirect(GLenum mode, const void* indirect);
-    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,
-                              const SharedPtr<MG_State::GLState::FramebufferObject>& drawFramebuffer,
-                              GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                              GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                              GLbitfield mask, GLenum filter);
-    void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width,
-                        GLsizei height, GLint border);
-    void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width,
-                           GLsizei height);
-    void CopyImageSubData(const CopyImageEndpoint& src,
-                          GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ,
-                          const CopyImageEndpoint& dst,
-                          GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ,
-                          GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
-    void GenerateMipmap(GLenum target);
-    void DispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ);
-    void DispatchComputeIndirect(GLintptr indirect);
-    void MemoryBarrier(GLbitfield barriers);
-    void MemoryBarrierByRegion(GLbitfield barriers);
-    void BindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access,
-                          GLenum format);
-    void GetIntegeri_v(GLenum target, GLuint index, GLint* data);
-    void ShaderStorageBlockBinding(GLuint program, const GLchar* storageBlockName, GLuint storageBlockBinding);
-    void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels);
-    void GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels);
-    void GetTextureImage(const SharedPtr<MG_State::GLState::ITextureObject>& texture, TextureUploadTarget uploadTarget,
-                         GLint level, GLenum format, GLenum type, GLsizei bufSize, GLvoid* pixels);
-    // GL fence sync objects, mapped onto the renderer's frame-serial busy
-    // tracking: a fence captures the frame serial current at creation and is
-    // signaled once every command recorded under that serial has completed on
-    // the GPU.
-    BackendSyncHandle FenceSync();
-    GLenum ClientWaitSync(BackendSyncHandle sync, GLbitfield flags, GLuint64 timeout);
-    void WaitSync(BackendSyncHandle sync, GLbitfield flags, GLuint64 timeout);
-    void DeleteSync(BackendSyncHandle sync);
-    Bool GetSyncStatus(BackendSyncHandle sync);
-    // GPU timer queries (GL_TIME_ELAPSED spans and GL_TIMESTAMP one-shots),
-    // backed by per-frame VkQueryPool timestamp slots. All hooks degrade
-    // gracefully: null handles when the renderer is absent, the device lacks
-    // timestamp support, or the frame's pool is exhausted.
-    // Dynamic support check (GLFunctionsTable::IsTimerQuerySupported): true
-    // 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);
-    // Returns true when a final value was produced (outNanoseconds set; the
-    // frontend may cache it and release the handle), false when the result
-    // cannot be obtained yet (e.g. a wait refused because the records' frame
-    // serial is the current unsubmitted frame) - the handle then stays
-    // readable later.
-    Bool GetQueryResult64(BackendQueryHandle query, Bool wait, Uint64* outNanoseconds);
-    void DeleteBackendQuery(BackendQueryHandle query);
-    // Always 0: Vulkan cannot synchronously sample the GPU clock (timestamps
-    // only exist as vkCmdWriteTimestamp results); the frontend falls back.
-    Int64 GetGpuTimestampNs();
-    void Present();
-    // eglSwapInterval. Remembered across renderers: one created for a later window surface
-    // starts from the app's last request (GetRequestedSwapInterval) instead of the default.
-    void SetSwapInterval(Int interval);
-    Optional<Int> GetRequestedSwapInterval();
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // The swap interval an ended server session asked for is not the next one's, the same rule as
-    // DirectGLES::ForgetRequestedSwapInterval: under a transport ~BackendObject_DirectVulkan forgets
-    // it, so the next session starts at the default until it asks.
-    void ForgetRequestedSwapInterval();
-#endif
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/DirectVulkanResourceState.h

@@ -1,20 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/DirectVulkanResourceState.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;
-}
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    GLuint GetShaderStorageBlockIndex(const MG_State::GLState::ProgramObject& program, const String& name);
-    GLuint GetShaderStorageBlockBinding(const MG_State::GLState::ProgramObject& program, GLuint blockIndex);
-}

MobileGL/MG_Backend/DirectVulkan/Renderer/BufferArena.cpp

@@ -1,154 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/BufferArena.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 "BufferArena.h"
-#if MOBILEGL_BUILD_DISAGGREGATED
-#include <Config.h>
-#endif
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    Bool BufferArena::Initialize(const BufferArenaDesc& desc) {
-        Shutdown();
-
-        MOBILEGL_ASSERT(desc.allocator != nullptr, "BufferArena::Initialize requires valid allocator");
-        MOBILEGL_ASSERT(desc.frameCount > 0, "BufferArena::Initialize requires non-zero frame count");
-        MOBILEGL_ASSERT(desc.usage != 0, "BufferArena::Initialize requires non-zero buffer usage");
-
-        m_desc = desc;
-        m_frames.clear();
-        m_frames.resize(desc.frameCount);
-        m_deferredReleases.resize(desc.frameCount);
-        return true;
-    }
-
-    void BufferArena::Shutdown() {
-        for (auto& frame : m_frames) {
-            frame.buffer.Destroy();
-            frame.writeCursor = 0;
-        }
-        m_frames.clear();
-        m_deferredReleases.clear();
-        m_desc = {};
-    }
-
-    void BufferArena::BeginFrame(Uint32 frameIndex) {
-        CollectDeferredReleases(frameIndex);
-        ResetFrame(frameIndex);
-    }
-
-    void BufferArena::ResetFrame(Uint32 frameIndex) {
-        AssertValidFrameIndex(frameIndex);
-        m_frames[frameIndex].writeCursor = 0;
-    }
-
-    void BufferArena::CollectDeferredReleases(Uint32 frameIndex) {
-        AssertValidFrameIndex(frameIndex);
-        m_deferredReleases[frameIndex].clear();
-    }
-
-    Bool BufferArena::Allocate(Uint32 frameIndex, VkDeviceSize size, VkDeviceSize alignment, BufferSlice& outSlice) {
-        AssertValidFrameIndex(frameIndex);
-        MOBILEGL_ASSERT(size > 0, "BufferArena::Allocate requires non-zero size");
-
-        auto& frame = m_frames[frameIndex];
-        const VkDeviceSize resolvedAlignment = alignment > 0 ? alignment : 1;
-        const VkDeviceSize offset = (frame.writeCursor + resolvedAlignment - 1) & ~(resolvedAlignment - 1);
-        const VkDeviceSize endOffset = offset + size;
-
-        if (!EnsureCapacity(frameIndex, endOffset)) {
-            return false;
-        }
-
-        frame.writeCursor = endOffset;
-        outSlice = frame.buffer.GetSlice(offset, size);
-        return outSlice.IsValid();
-    }
-
-    Bool BufferArena::Upload(Uint32 frameIndex, const void* data, VkDeviceSize size, VkDeviceSize alignment,
-                             BufferSlice& outSlice) {
-        MOBILEGL_ASSERT(data != nullptr || size == 0, "BufferArena::Upload data pointer is null");
-        if (!Allocate(frameIndex, size, alignment, outSlice)) {
-            return false;
-        }
-
-        if (outSlice.mapped != nullptr) {
-            Memcpy(outSlice.mapped, data, static_cast<SizeT>(size));
-            return true;
-        }
-
-        return m_frames[frameIndex].buffer.Upload(data, size, outSlice.offset);
-    }
-
-    VkDeviceSize BufferArena::GetWriteCursor(Uint32 frameIndex) const {
-        AssertValidFrameIndex(frameIndex);
-        return m_frames[frameIndex].writeCursor;
-    }
-
-    Uint32 BufferArena::GetFrameCount() const {
-        return static_cast<Uint32>(m_frames.size());
-    }
-
-    Bool BufferArena::EnsureCapacity(Uint32 frameIndex, VkDeviceSize requiredEndOffset) {
-        AssertValidFrameIndex(frameIndex);
-        auto& frame = m_frames[frameIndex];
-        auto& buffer = frame.buffer;
-
-        if (buffer.IsValid() && buffer.GetSize() >= requiredEndOffset) {
-            return true;
-        }
-
-        VkDeviceSize newCapacity = buffer.IsValid() ? buffer.GetSize() : 0;
-        if (newCapacity < m_desc.minBufferSize) {
-            newCapacity = m_desc.minBufferSize;
-        }
-        if (newCapacity == 0) {
-            newCapacity = requiredEndOffset;
-        }
-        while (newCapacity < requiredEndOffset) {
-            newCapacity *= 2;
-        }
-
-        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));
-        }
-
-        VkBufferObjectDesc bufferDesc{};
-        bufferDesc.allocator = m_desc.allocator;
-        bufferDesc.size = newCapacity;
-        bufferDesc.usage = m_desc.usage;
-        bufferDesc.memoryUsage = m_desc.memoryUsage;
-        bufferDesc.allocationFlags = m_desc.allocationFlags;
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // Split staging may also be the destination of a GPU UBO range copy.
-        // Persistent host writes must be coherent: Upload deliberately writes
-        // the mapped pointer without a per-range VMA flush.
-        if (MG_Config::Transport != MG_Config::TransportMode::Monolith && m_desc.persistentlyMapped) {
-            bufferDesc.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
-        }
-#endif
-        if (!buffer.Create(bufferDesc)) {
-            return false;
-        }
-        if (m_desc.persistentlyMapped && buffer.Map() == nullptr) {
-            buffer.Destroy();
-            return false;
-        }
-
-        frame.writeCursor = 0;
-        return true;
-    }
-
-    void BufferArena::AssertValidFrameIndex(Uint32 frameIndex) const {
-        MOBILEGL_ASSERT(frameIndex < m_frames.size(), "BufferArena frame index out of range");
-    }
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/BufferArena.h

@@ -1,56 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/BufferArena.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 "BufferSlice.h"
-#include "VkBufferObject.h"
-#include "../VkIncludes.h"
-#include <Includes.h>
-#include <vk_mem_alloc.h>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    struct BufferArenaDesc {
-        VmaAllocator allocator = nullptr;
-        Uint32 frameCount = 0;
-        VkBufferUsageFlags usage = 0;
-        VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_AUTO;
-        VmaAllocationCreateFlags allocationFlags = 0;
-        VkDeviceSize minBufferSize = 0;
-        Bool persistentlyMapped = false;
-    };
-
-    class BufferArena {
-    public:
-        Bool Initialize(const BufferArenaDesc& desc);
-        void Shutdown();
-
-        void BeginFrame(Uint32 frameIndex);
-        void ResetFrame(Uint32 frameIndex);
-        void CollectDeferredReleases(Uint32 frameIndex);
-
-        Bool Allocate(Uint32 frameIndex, VkDeviceSize size, VkDeviceSize alignment, BufferSlice& outSlice);
-        Bool Upload(Uint32 frameIndex, const void* data, VkDeviceSize size, VkDeviceSize alignment, BufferSlice& outSlice);
-
-        VkDeviceSize GetWriteCursor(Uint32 frameIndex) const;
-        Uint32 GetFrameCount() const;
-
-    private:
-        struct FrameResources {
-            VkBufferObject buffer;
-            VkDeviceSize writeCursor = 0;
-        };
-
-        Bool EnsureCapacity(Uint32 frameIndex, VkDeviceSize requiredEndOffset);
-        void AssertValidFrameIndex(Uint32 frameIndex) const;
-
-        BufferArenaDesc m_desc{};
-        Vector<FrameResources> m_frames;
-        Vector<Vector<VkBufferObject>> m_deferredReleases;
-    };
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/BufferSlice.h

@@ -1,23 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/BufferSlice.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 "../VkIncludes.h"
-#include <Includes.h>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    struct BufferSlice {
-        VkBuffer buffer = VK_NULL_HANDLE;
-        VkDeviceSize offset = 0;
-        VkDeviceSize size = 0;
-        void* mapped = nullptr;
-
-        Bool IsValid() const { return buffer != VK_NULL_HANDLE; }
-    };
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/FrameContext.cpp

@@ -1,473 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/FrameContext.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 "FrameContext.h"
-#if MOBILEGL_BUILD_DISAGGREGATED
-#include <Config.h>
-#endif
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    VkResult FrameContext::Initialize(VkDevice device, VkCommandPool commandPool, Uint32 frameCount) {
-        Destroy(device, commandPool);
-        m_frames.assign(frameCount, {});
-        currentFrameIndex = 0;
-        m_device = device;
-        m_commandPool = commandPool;
-
-        Vector<VkCommandBuffer> commandBuffers(frameCount * 2, VK_NULL_HANDLE);
-        VkCommandBufferAllocateInfo allocInfo{};
-        allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
-        allocInfo.commandPool = commandPool;
-        allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-        allocInfo.commandBufferCount = frameCount * 2;
-        VkResult result = vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data());
-        if (result != VK_SUCCESS) {
-            return result;
-        }
-        for (Uint32 i = 0; i < frameCount; ++i) {
-            m_frames[i].commandBuffer = commandBuffers[i];
-            m_frames[i].preCommandBuffer = commandBuffers[frameCount + i];
-        }
-
-        VkSemaphoreCreateInfo semaphoreInfo{VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO};
-        VkFenceCreateInfo fenceInfo{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
-        fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
-
-        for (Uint32 i = 0; i < frameCount; ++i) {
-            result = CreateSyncObjectsForFrame(device, i, semaphoreInfo, fenceInfo);
-            if (result != VK_SUCCESS) {
-                Destroy(device, commandPool);
-                return result;
-            }
-        }
-
-        return VK_SUCCESS;
-    }
-
-    void FrameContext::Destroy(VkDevice device, VkCommandPool commandPool) {
-        const Uint32 frameCount = static_cast<Uint32>(m_frames.size());
-        Vector<VkCommandBuffer> commandBuffers(frameCount * 2, VK_NULL_HANDLE);
-        for (Uint32 i = 0; i < frameCount; ++i) {
-            commandBuffers[i] = m_frames[i].commandBuffer;
-            commandBuffers[frameCount + i] = m_frames[i].preCommandBuffer;
-        }
-
-        for (Uint32 i = 0; i < frameCount; ++i) {
-            DestroySyncObjectsForFrame(device, i);
-        }
-        DestroySwapchainSemaphores(device);
-        if (device != VK_NULL_HANDLE && commandPool != VK_NULL_HANDLE && !m_frames.empty()) {
-            for (auto& frame : m_frames) {
-                FreeRetiredCommandBuffers(frame);
-            }
-            vkFreeCommandBuffers(device, commandPool, frameCount * 2, commandBuffers.data());
-        }
-        m_frames.clear();
-        currentFrameIndex = 0;
-        m_device = VK_NULL_HANDLE;
-        m_commandPool = VK_NULL_HANDLE;
-    }
-
-    FrameContext::FrameData& FrameContext::GetCurrent() {
-        MOBILEGL_ASSERT(!m_frames.empty(), "FrameContext is not initialized");
-        return m_frames[currentFrameIndex];
-    }
-
-    const FrameContext::FrameData& FrameContext::GetCurrent() const {
-        MOBILEGL_ASSERT(!m_frames.empty(), "FrameContext is not initialized");
-        return m_frames[currentFrameIndex];
-    }
-
-    Bool FrameContext::IsCommandRecording() const {
-        return GetCurrent().isCommandRecording;
-    }
-
-    void FrameContext::AdvanceToNext() {
-        MOBILEGL_ASSERT(!m_frames.empty(), "FrameContext is not initialized");
-        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,
-                                                         const VkCommandBufferInheritanceInfo* pInheritanceInfo) {
-        auto& frame = GetCurrent();
-        MOBILEGL_ASSERT(!frame.isCommandRecording, "BeginCommandRecording called while command buffer is already recording");
-
-        frame.hasCommandBufferRecorded = false;
-        VK_VERIFY(vkResetCommandBuffer(frame.commandBuffer, 0), "BeginCommandRecording, vkResetCommandBuffer");
-
-        VkCommandBufferBeginInfo beginInfo{};
-        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-        beginInfo.flags = flags;
-        beginInfo.pInheritanceInfo = pInheritanceInfo;
-        VK_VERIFY(vkBeginCommandBuffer(frame.commandBuffer, &beginInfo), "BeginCommandRecording, vkBeginCommandBuffer");
-
-        frame.isCommandRecording = true;
-        if (m_recordingObserver != nullptr) {
-            m_recordingObserver->OnFrameCommandRecordingBegan(frame.commandBuffer);
-        }
-        return frame.commandBuffer;
-    }
-
-    void FrameContext::EndCommandRecording() {
-        auto& frame = GetCurrent();
-        MOBILEGL_ASSERT(frame.isCommandRecording, "EndCommandRecording called without active command buffer recording");
-        VK_VERIFY(vkEndCommandBuffer(frame.commandBuffer), "EndCommandRecording, vkEndCommandBuffer");
-        frame.isCommandRecording = false;
-        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) {
-            return VK_SUCCESS;
-        }
-
-        m_swapchainImageRenderFinishedSemaphores.assign(swapchainImageCount, VK_NULL_HANDLE);
-        VkSemaphoreCreateInfo semaphoreInfo{VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO};
-        for (Uint32 imageIndex = 0; imageIndex < swapchainImageCount; ++imageIndex) {
-            VkResult result =
-                vkCreateSemaphore(device, &semaphoreInfo, nullptr, &m_swapchainImageRenderFinishedSemaphores[imageIndex]);
-            if (result != VK_SUCCESS) {
-                DestroySwapchainSemaphores(device);
-                return result;
-            }
-        }
-        return VK_SUCCESS;
-    }
-
-    void FrameContext::DestroySwapchainSemaphores(VkDevice device) {
-        if (device != VK_NULL_HANDLE) {
-            for (auto semaphore : m_swapchainImageRenderFinishedSemaphores) {
-                if (semaphore != VK_NULL_HANDLE) {
-                    vkDestroySemaphore(device, semaphore, nullptr);
-                }
-            }
-        }
-        m_swapchainImageRenderFinishedSemaphores.clear();
-    }
-
-    Bool FrameContext::TransitionToPresent(VkImage image, VkImageLayout oldLayout, VkImageLayout presentLayout) {
-        auto& frame = GetCurrent();
-        if (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;
-
-        VkImageMemoryBarrier presentBarrier{};
-        presentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-        presentBarrier.srcAccessMask = 0;
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // A layout transition writes the image too. Order it after the wire
-        // render pass's storeOp, clears and copies instead of relying on the old
-        // per-draw queue-idle path. This applies even when contents are discarded.
-        if (MG_Config::Transport != MG_Config::TransportMode::Monolith)
-            presentBarrier.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
-#endif
-        presentBarrier.dstAccessMask = 0;
-        presentBarrier.oldLayout = oldLayout;
-        presentBarrier.newLayout = presentLayout;
-        presentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-        presentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-        presentBarrier.image = image;
-        presentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-        presentBarrier.subresourceRange.baseMipLevel = 0;
-        presentBarrier.subresourceRange.levelCount = 1;
-        presentBarrier.subresourceRange.baseArrayLayer = 0;
-        presentBarrier.subresourceRange.layerCount = 1;
-        vkCmdPipelineBarrier(commandBuffer,
-#if MOBILEGL_BUILD_DISAGGREGATED
-                             MG_Config::Transport != MG_Config::TransportMode::Monolith
-                                 ? VK_PIPELINE_STAGE_ALL_COMMANDS_BIT : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-#else
-                             VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-#endif
-                             VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0,
-                             nullptr, 0, nullptr, 1, &presentBarrier);
-
-        if (openedRecording) {
-            EndCommandRecording();
-        }
-        return true;
-    }
-
-    FrameContext::SubmitInfoPacket FrameContext::GetSubmitInfo(Bool shouldSubmitCommandBuffer,
-                                                               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.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.signalSemaphoreCount = 1;
-        packet.submitInfo.pSignalSemaphores = &packet.signalSemaphore;
-        return packet;
-    }
-
-    FrameContext::PresentInfoPacket FrameContext::GetPresentInfo(VkSwapchainKHR swapchain, Uint32 imageIndex) const {
-        AssertValidSwapchainImageIndex(imageIndex);
-        PresentInfoPacket packet{};
-        packet.waitSemaphore = m_swapchainImageRenderFinishedSemaphores[imageIndex];
-        packet.swapchain = swapchain;
-        packet.imageIndex = imageIndex;
-
-        packet.presentInfo.waitSemaphoreCount = 1;
-        packet.presentInfo.pWaitSemaphores = &packet.waitSemaphore;
-        packet.presentInfo.swapchainCount = 1;
-        packet.presentInfo.pSwapchains = &packet.swapchain;
-        packet.presentInfo.pImageIndices = &packet.imageIndex;
-        packet.presentInfo.pResults = nullptr;
-        return packet;
-    }
-
-    VkResult FrameContext::WaitAndAcquireNextImage(VkDevice device, VkSwapchainKHR swapchain, Uint32& outImageIndex,
-                                                   Uint64 timeout, VkFence acquireFence) {
-        auto& frame = GetCurrent();
-        VkResult result = vkWaitForFences(device, 1, &frame.imageInFlightFence, VK_TRUE, timeout);
-        if (result != VK_SUCCESS) {
-            return result;
-        }
-        // Under disaggregation VulkanRenderer waits every registered fence
-        // through this slot's last submit before calling here. That aggregate
-        // proof covers mid-frame pooled-fence flushes too; the slot fence alone
-        // would not. Initialize's first acquire has no prior submissions.
-        FreeRetiredCommandBuffers(frame);
-
-        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) {
-            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;
-    }
-
-    Uint32 FrameContext::GetCurrentFrameIndex() const {
-        return currentFrameIndex;
-    }
-
-    Uint32 FrameContext::GetFrameCount() const {
-        return static_cast<Uint32>(m_frames.size());
-    }
-
-    void FrameContext::SetRecordingObserver(IRecordingObserver* observer) {
-        m_recordingObserver = observer;
-    }
-
-    VkResult FrameContext::RetireCurrentCommandBuffer(Bool retirePreCommandBuffer) {
-        MOBILEGL_ASSERT(m_device != VK_NULL_HANDLE && m_commandPool != VK_NULL_HANDLE,
-                        "RetireCurrentCommandBuffer requires an initialized FrameContext");
-        auto& frame = GetCurrent();
-        MOBILEGL_ASSERT(!frame.isCommandRecording,
-                        "RetireCurrentCommandBuffer called while the command buffer is still recording");
-        MOBILEGL_ASSERT(!frame.isPreCommandRecording,
-                        "RetireCurrentCommandBuffer called while the pre-pass stream is still recording");
-
-        VkCommandBufferAllocateInfo allocInfo{};
-        allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
-        allocInfo.commandPool = m_commandPool;
-        allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-        allocInfo.commandBufferCount = 1;
-        VkCommandBuffer replacement = VK_NULL_HANDLE;
-        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.commandBuffer = replacement;
-        return VK_SUCCESS;
-    }
-
-    void FrameContext::FreeRetiredCommandBuffers(FrameData& frame) {
-        if (frame.retiredCommandBuffers.empty()) {
-            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);
-            }
-        }
-        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");
-    }
-
-    void FrameContext::AssertValidSwapchainImageIndex(Uint32 imageIndex) const {
-        MOBILEGL_ASSERT(imageIndex < m_swapchainImageRenderFinishedSemaphores.size(),
-                        "FrameContext swapchain image index out of range");
-    }
-
-    VkResult FrameContext::CreateSyncObjectsForFrame(VkDevice device, Uint32 frameIndex,
-                                                     const VkSemaphoreCreateInfo& semaphoreInfo,
-                                                     const VkFenceCreateInfo& fenceInfo) {
-        AssertValidFrameIndex(frameIndex);
-        DestroySyncObjectsForFrame(device, frameIndex);
-
-        auto& frame = m_frames[frameIndex];
-        VkResult result =
-            vkCreateSemaphore(device, &semaphoreInfo, nullptr, &frame.imageAvailableSemaphore);
-        if (result != VK_SUCCESS) {
-            return result;
-        }
-
-        result = vkCreateFence(device, &fenceInfo, nullptr, &frame.imageInFlightFence);
-        if (result != VK_SUCCESS) {
-            vkDestroySemaphore(device, frame.imageAvailableSemaphore, nullptr);
-            frame.imageAvailableSemaphore = VK_NULL_HANDLE;
-            return result;
-        }
-
-        frame.hasCommandBufferRecorded = false;
-        frame.isCommandRecording = false;
-        frame.imageAvailableSemaphoreConsumed = false;
-        return VK_SUCCESS;
-    }
-
-    void FrameContext::DestroySyncObjectsForFrame(VkDevice device, Uint32 frameIndex) {
-        AssertValidFrameIndex(frameIndex);
-        auto& frame = m_frames[frameIndex];
-        if (device != VK_NULL_HANDLE && frame.imageInFlightFence != VK_NULL_HANDLE) {
-            vkDestroyFence(device, frame.imageInFlightFence, nullptr);
-        }
-        frame.imageInFlightFence = VK_NULL_HANDLE;
-
-        if (device != VK_NULL_HANDLE && frame.imageAvailableSemaphore != VK_NULL_HANDLE) {
-            vkDestroySemaphore(device, frame.imageAvailableSemaphore, nullptr);
-        }
-        frame.imageAvailableSemaphore = VK_NULL_HANDLE;
-        frame.isCommandRecording = false;
-        frame.hasCommandBufferRecorded = false;
-        frame.imageAvailableSemaphoreConsumed = false;
-    }
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/FrameContext.h

@@ -1,147 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/FrameContext.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 "../VkIncludes.h"
-#include <Includes.h>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    class FrameContext {
-    public:
-        // Notified immediately after a frame command buffer begins recording
-        // (before any render pass has been begun); every BeginCommandRecording
-        // caller funnels through this single seam. Implemented by the renderer
-        // to prepare per-frame timer-query pools (vkCmdResetQueryPool must be
-        // recorded outside a render pass).
-        class IRecordingObserver {
-        public:
-            virtual ~IRecordingObserver() = default;
-            virtual void OnFrameCommandRecordingBegan(VkCommandBuffer commandBuffer) = 0;
-        };
-
-        struct SubmitInfoPacket {
-            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};
-            VkSubmitInfo submitInfo{VK_STRUCTURE_TYPE_SUBMIT_INFO};
-        };
-
-        struct PresentInfoPacket {
-            VkSemaphore waitSemaphore = VK_NULL_HANDLE;
-            VkSwapchainKHR swapchain = VK_NULL_HANDLE;
-            Uint32 imageIndex = 0;
-            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;
-            // Submit-tracker index of this slot's most recent queue submission
-            // (written by the renderer at submit time).
-            Uint64 lastSubmitIndex = 0;
-        };
-
-        VkResult Initialize(VkDevice device, VkCommandPool commandPool, Uint32 frameCount);
-        void Destroy(VkDevice device, VkCommandPool commandPool);
-
-        // Lifecycle functions
-        FrameData& GetCurrent();
-        const FrameData& GetCurrent() const;
-        Bool IsCommandRecording() const;
-        void AdvanceToNext();
-        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,
-                                 VkImageLayout presentLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
-        SubmitInfoPacket GetSubmitInfo(Bool shouldSubmitCommandBuffer, Uint32 swapchainImageIndex) const;
-        PresentInfoPacket GetPresentInfo(VkSwapchainKHR swapchain, Uint32 imageIndex) const;
-        VkResult WaitAndAcquireNextImage(VkDevice device, VkSwapchainKHR swapchain, Uint32& outImageIndex,
-                                         Uint64 timeout = UINT64_MAX, VkFence acquireFence = VK_NULL_HANDLE);
-
-        // 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();
-
-        Uint32 GetCurrentFrameIndex() const;
-        Uint32 GetFrameCount() const;
-
-        // Observer may be null (no notifications). Not owned.
-        void SetRecordingObserver(IRecordingObserver* observer);
-
-    private:
-        void AssertValidFrameIndex(Uint32 frameIndex) const;
-        void AssertValidSwapchainImageIndex(Uint32 imageIndex) const;
-
-        VkResult CreateSyncObjectsForFrame(VkDevice device, Uint32 frameIndex,
-                                           const VkSemaphoreCreateInfo& semaphoreInfo,
-                                           const VkFenceCreateInfo& fenceInfo);
-        void DestroySyncObjectsForFrame(VkDevice device, Uint32 frameIndex);
-        void FreeRetiredCommandBuffers(FrameData& frame);
-
-        Vector<FrameData> m_frames;
-        Vector<VkSemaphore> m_swapchainImageRenderFinishedSemaphores;
-        Uint32 currentFrameIndex = 0;
-        IRecordingObserver* m_recordingObserver = nullptr;
-        // Stored at Initialize for retired-command-buffer management.
-        VkDevice m_device = VK_NULL_HANDLE;
-        VkCommandPool m_commandPool = VK_NULL_HANDLE;
-    };
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/MagmaPipeArms.h

@@ -1,611 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/MagmaPipeArms.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>
-#if MOBILEGL_PIPE_PUSH
-// kMGPipeSubsystem* - the runtime bitmask's named bits - and MGPipeHandle itself. Both are
-// header-only constant/POD declarations, and both are push-only, so the pull build's include
-// graph is unchanged (G1).
-#include <MG_Pipe/MGPipe.h>
-#include <MG_Pipe/MGPipeHandles.h>
-#endif
-
-#include <cstdlib>
-
-// Magma's arm selector for the P2 Track H / render-state re-keys (P2 brief D14), and the
-// {slot, gen} mint the re-keyed sites are written against.
-//
-// Two switches decide which arm a re-keyed site runs, and they are NOT the same switch:
-//
-//   MOBILEGL_PIPE_PUSH (compile)          - is the pushed state there to be keyed on at all
-//   Features.PipePush  (runtime bitmask)  - is THIS subsystem migrated in THIS run
-//   MOBILEGL_PIPE_LEGACY_MEMOS (compile)  - is the pre-handle arm compiled beside it
-//   Features.PipeLegacyMemos (runtime)    - may the pre-handle arm be ENTERED in this run
-//
-// ARCHITECTURE.md 9.6's point: once a handle wave lands, a clear MOBILEGL_PIPE_PUSH bit is
-// only a valid A/B while the legacy arm is still compiled, because with the bit clear the
-// backend would otherwise still run the re-keyed code. So a clear bit selects the legacy
-// arm, and a run that has explicitly disabled the legacy arm may not fall into it.
-//
-// D14 spends that last sentence at STARTUP, not per draw: "a Track-H subsystem whose bit is
-// clear is a startup Fatal{PipeLegacyMemosDisabled}". Nothing in the draw path aborts, and
-// nothing outside Track H consults the legacy-memo lever at all - see
-// MagmaPipeValidateSubsystemConfiguration below for both halves of that rule.
-//
-// The whole header is inert in a pull build: MOBILEGL_PIPE_PUSH is 0 there, every helper
-// below is behind it, and the pull build's translation units are byte-identical (G1).
-namespace MobileGL::MG_Backend::DirectVulkan {
-
-#if MOBILEGL_PIPE_PUSH
-    // Is `subsystemBit` (MG_Pipe/MGPipe.h's kMGPipeSubsystem*) migrated in this run?
-    inline Bool MagmaPipeSubsystemOn(Uint64 subsystemBit) {
-        return (MG_Config::Features.PipePush & subsystemBit) != 0;
-    }
-
-    // ---------------------------------------------------------------------------------
-    // D14's startup gate
-    // ---------------------------------------------------------------------------------
-    //
-    // Called once from VulkanRenderer::Initialize(), i.e. only when Magma is the backend
-    // that is actually running. It answers exactly one question and it answers it before the
-    // first draw: is there an arm for Magma's Track-H subsystem in this configuration?
-    //
-    // Three deliberate boundaries, each of which the per-draw shape this replaces got wrong:
-    //
-    //  * ONLY Magma's own Track-H bit is checked. Espryt's bit 5 is Espryt's business (a
-    //    DirectVulkan run does not execute one line of DirectGLES' re-key), so
-    //    MOBILEGL_PIPE_PUSH=0x20 must not kill a Magma run, and MOBILEGL_PIPE_PUSH=0x40 must
-    //    not kill an Espryt one.
-    //  * bit 0 (kMGPipeSubsystemRenderState) is NOT Track H and is NOT fatal. It is not a
-    //    memo re-key at all: it decides where the pipeline memo's STATE KEY comes from, and
-    //    a clear bit there simply means the client is not pushing render-state CSOs in this
-    //    run, which GetOrCreatePipeline answers with its own state hash. D14 labels bits 5
-    //    and 6 "Track H" and labels bit 0 nothing of the sort.
-    //  * it is Fatal at STARTUP, once, not on a draw. A per-draw abort inside
-    //    GetOrCreatePipeline turns a configuration mistake into a mid-frame crash and puts a
-    //    branch nobody needs on the hottest path in the backend.
-    //
-    // [declared deviation from D14, review v2 minor 2] D14's runtime row reads "false: the
-    // legacy arm is never entered", and D14's compile-switch row names ComputePipelineStateHash
-    // as part of the pre-handle arm. Those two together would make MOBILEGL_PIPE_LEGACY_MEMOS=0
-    // with bit 0 CLEAR a contradiction: the pipeline memo has no CSO handle to key on, so it
-    // keys on a state hash, and in a build that compiles the pre-handle arm that hash IS
-    // ComputePipelineStateHash. Magma does not make that fatal - bit 0 is not Track H, and
-    // there is a correct answer (the state hash) where for bits 5/6 there is none - but it no
-    // longer does it SILENTLY: the combination is named once, at startup, right here.
-    inline void MagmaPipeValidateSubsystemConfiguration() {
-        if (!MG_Config::Features.PipeLegacyMemos &&
-            !MagmaPipeSubsystemOn(MG_Pipe::kMGPipeSubsystemRenderState)) {
-            MGLOG_W("MGPipe: MOBILEGL_PIPE_LEGACY_MEMOS=0 with kMGPipeSubsystemRenderState (bit 0 "
-                    "of MOBILEGL_PIPE_PUSH) clear - Magma's pipeline memo has no CSO handle to key "
-                    "on, so every draw whose pipeline-state version moved runs the pre-handle STATE "
-                    "HASH instead. That is not a Track-H subsystem and not fatal, but it is not the "
-                    "handle arm either: set bit 0 (MOBILEGL_PIPE_PUSH=0x%llx) if this run was meant "
-                    "to measure it.",
-                    static_cast<unsigned long long>(MG_Config::Features.PipePush |
-                                                    MG_Pipe::kMGPipeSubsystemRenderState));
-        }
-#if MOBILEGL_PIPE_LEGACY_MEMOS
-        // The pre-handle arm is compiled AND the operator has not forbidden entering it, so a
-        // clear bit is an ordinary, valid A/B: the site takes the legacy arm.
-        if (MG_Config::Features.PipeLegacyMemos) return;
-#endif
-        if (MagmaPipeSubsystemOn(MG_Pipe::kMGPipeSubsystemMagmaVertexInput)) return;
-#if MOBILEGL_PIPE_LEGACY_MEMOS
-        const char* const why = "this run has MOBILEGL_PIPE_LEGACY_MEMOS=0";
-#else
-        const char* const why =
-            "this build has cmake -DMOBILEGL_PIPE_LEGACY_MEMOS=OFF, which compiles no such arm";
-#endif
-        MGLOG_F("MGPipe: Fatal{PipeLegacyMemosDisabled} Magma's Track-H subsystem "
-                "(kMGPipeSubsystemMagmaVertexInput, bit 6 of MOBILEGL_PIPE_PUSH) is clear, so the "
-                "vertex-input cache and the VAO draw memo want the pre-handle arm - but %s. Set "
-                "bit 6 (MOBILEGL_PIPE_PUSH=0x%llx, or the default 0x%llx), or allow the legacy arm.",
-                why,
-                static_cast<unsigned long long>(MG_Config::Features.PipePush |
-                                                MG_Pipe::kMGPipeSubsystemMagmaVertexInput),
-                static_cast<unsigned long long>(MG_Pipe::kMGPipeSubsystemsMigratedAtP2));
-        std::abort();
-    }
-
-    // "Does this Track-H site run the handle arm?" - the ONE question every re-keyed Track-H
-    // site asks, so that they cannot disagree with each other or with the startup gate.
-    inline Bool MagmaPipeTrackHArmIsHandles(Uint64 trackHBit) {
-#if MOBILEGL_PIPE_LEGACY_MEMOS
-        return MagmaPipeSubsystemOn(trackHBit);
-#else
-        // No pre-handle arm exists in this build, and MagmaPipeValidateSubsystemConfiguration
-        // has already made a clear bit a startup Fatal, so the handle arm is the only arm a
-        // running process can be on.
-        (void)trackHBit;
-        return true;
-#endif
-    }
-
-    // ---------------------------------------------------------------------------------
-    // Negative control C (P2 brief D18): MOBILEGL_PIPE_HANDLE_ABA_CONTROL
-    // ---------------------------------------------------------------------------------
-    //
-    // "Is the object-identity half of every vertex-input memo key deliberately defeated in
-    // this run?" - the ONE question the control's sites ask, for the same reason
-    // MagmaPipeTrackHArmIsHandles exists: three sites deciding separately could disagree,
-    // and a control that defeats two of three guards proves nothing.
-    //
-    // WHAT IT DEFEATS, AND WHY IT IS SPELLED AS "REPLACE THE IDENTITY WITH A CONSTANT"
-    // RATHER THAN "USE THE HEAP ADDRESS".
-    //
-    // D18 wrote the control as "hash attr.Buffer.get() instead of GetLifetimeId(), and skip
-    // the vaoLifetimeId compare", on the theory that a deleted object's replacement lands at
-    // the freed heap block and so reproduces the key. Measured, it does not: in
-    // HandleRecycleScenario the GL NAMES come back (glGen* hands the deleted name straight
-    // out) but the C++ heap blocks do not - a VertexArrayObject is 3920 bytes, too large for
-    // glibc's tcache, so its chunk goes to the unsorted bin and is split by the very next
-    // allocation the replacement path makes. Four create/delete cycles in one run produced
-    // four distinct addresses, ~1 MiB apart. With no address reuse there is nothing for
-    // "hash the address" to collide with: the replacement hashes differently, indexes a
-    // different memo slot, and inherits nothing - so the arm asserted stale pixels and saw
-    // fresh ones, which is a FAILING negative control that had stopped controlling anything.
-    //
-    // So the control no longer asks the allocator for the collision; it manufactures it. On
-    // both arms the object identity is replaced by a constant, which is the strongest form of
-    // "the allocator handed the block back" and is deterministic. That covers strictly more
-    // than D18's spelling, and in particular it reaches the arm P2 SHIPS: on the handle arm
-    // the constant defeats the OBJECT IDENTITY THAT SELECTS THE SLOT - the key the handle arm
-    // ships - so the replacement VAO is handed the dead one's memo entry and its content hash.
-    // Defeating only the retired lifetime-id/address guards would leave that key untested,
-    // which is exactly the vacuity this control exists to catch.
-    //
-    // WHAT IT DOES NOT COVER, AND WHY NO REPRODUCER OF THIS SHAPE CAN [fix-aba review v1,
-    // MAJOR 1]. It does NOT exercise the GENERATION half of {slot, gen}:
-    //
-    //   * THIS MINT still has no death notification, and that is now a narrower statement than
-    //     it was. P7 wave 2 package C gives DirectVulkan a StateObjectDeathOps table
-    //     (DirectVulkan.cpp's g_magmaStateObjectDeathOps, CONTRACT-P7 §5.5), so
-    //     NotifyStateObjectDestroyed DOES have a consumer on this backend - but that consumer's
-    //     one job is to emit the `object_death` RECORD so the server drops its twin, and it
-    //     never touches these per-renderer identity tables: they are the SERVER-side renderer's
-    //     own, the notice is raised on the CLIENT thread, and an Acquire/retire from the wrong
-    //     side is precisely the cross-role read CONTRACT-P5C §3.1 forbids. So a slot here still
-    //     returns to the free list only through OnFrameBoundary's age sweep (kSweepInterval
-    //     256, kRetireAgeBoundaries 1024, below), and everything the two bullets below derive
-    //     from that is unchanged;
-    //   * HandleRecycleScenario issues five frame boundaries, so the free list is empty when
-    //     the replacement VAO acquires and it gets a BRAND-NEW slot at Gen 1 (measured:
-    //     redVao slot=2 gen=1, greenVao slot=3 gen=1). The knob-off FRESH verdict there is
-    //     decided by the SLOT alone, and deleting the ++Gen below leaves all four arms green;
-    //   * a genuine slot REUSE needs >= 1024 idle boundaries after the dead object's last
-    //     draw, which necessarily puts the two draws in different frames - and the only memo
-    //     that carries a GPU slice rather than a layout, ResolvedVertexBindings, declines
-    //     across frames by design. The two requirements are mutually exclusive, so the
-    //     generation is out of reach of any same-frame pixel reproducer for this memo.
-    //
-    // The generation is covered where it IS expressible, over this mint and the claim rule
-    // MagmaPipeClaimSlotMemos below: MG_Test/Pipe/MagmaPipeIdentityTest.cpp drives a real
-    // retire -> reuse and asserts that a memo stamped at {slot, gen=N} is not served at
-    // {slot, gen=N+1} with the knob off and IS served with it on. Deleting the ++Gen reds that
-    // suite; it is the only place in the tree where that deletion is caught.
-    //
-    // Everything the control does NOT defeat is as load-bearing as what it does. It never
-    // touches a guard that is not an IDENTITY guard: the resolved-bindings memo's frame
-    // serial, its slice-epoch compares and its host-map check all stay in force, so a green
-    // AbaControl arm still means "a replacement object was handed its dead predecessor's
-    // resolved vertex bindings because the identity halves of the keys were defeated", not
-    // "every safety net was switched off until something broke".
-    //
-    // Off by default (Config.h), set only by the HandleRecycle AbaControl ctest lanes, and
-    // #if MOBILEGL_PIPE_PUSH throughout, so no shipping pull build can even parse it.
-    // P4a (BRIEF-P4A.md D-I2, G8): WHICH KINDS THIS ANSWER COVERS, and it is not "all of them".
-    //
-    // P4a mints six more client-side kinds - Texture, Renderbuffer, Framebuffer, SamplerCso,
-    // SamplerViewCso and ShaderCso - and requires the ABA control to defeat "the identity half
-    // of P4a's memo keys as well", because a control that only defeats the guards a phase
-    // RETIRED says nothing about the key that phase SHIPS.
-    //
-    // On Magma there is no such key to defeat, and that is a fact about the roadmap rather than
-    // an omission here. MagmaPipeIdentityTables below mints exactly TWO kinds,
-    // VertexElementsCso and Buffer; a texture, a framebuffer, a sampler, a view and a program
-    // are all still reached from their frontend objects on this backend, and moving them onto
-    // handles is P7's work (ROADMAP.md:24 - "Magma anything"; P4a leaves MG_Backend/DirectVulkan
-    // untouched apart from this file). So the honest statement is per KIND, and it is spelled as
-    // code rather than as a comment so that a caller cannot read the blanket answer above and
-    // conclude the knob covers its kind:
-    //
-    //   * for the two kinds this backend really keys on {slot, gen}, the knob defeats the
-    //     identity exactly as it always has (MagmaPipeClaimSlotMemos);
-    //   * for P4a's six there is nothing here to defeat, so the answer is FALSE - and
-    //     MG_IntegrationTest's HandleRecycleScenario reads that through its own build probe and
-    //     makes those cases' AbaControl arm assert the CORRECT pixels while SAYING that it is
-    //     not controlling anything for that kind. It does not assert a corruption that no code
-    //     on this tree can produce, which would be a permanently red always-on lane.
-    //
-    // WHAT MAKES IT TRUE LATER, in one sentence, so the next reader does not have to derive it:
-    // when a backend grows a Features.PipeHandleAbaControl consumer over its P4a object slot
-    // tables - one `if` in GetOrCreate / FindByHandle, the shape MagmaPipeClaimSlotMemos already
-    // has for vertex input - this function's per-kind answer becomes that consumer's, the
-    // integration probe finds the consumer, and the six cases flip to expecting the corruption.
-    inline Bool MagmaPipeAbaControlDefeatsIdentity() {
-        return MG_Config::Features.PipeHandleAbaControl;
-    }
-
-    // WHICH KINDS THIS BACKEND ACTUALLY KEYS ON {slot, gen}, and therefore which kinds the knob
-    // above has an identity to defeat at all. `kind` is MG_Pipe::MGPipeKind.
-    //
-    // EXHAUSTIVE, WITH NO `default:`, for MG_IntegrationTest/Harness/PipeSlotPeek.cpp's reason:
-    // a kind added to MGPipeKind without a decision here must be a -Wswitch warning in this
-    // file rather than a row that silently inherits somebody else's answer. Being wrong in the
-    // "covered" direction is the expensive one - a control asserting a corruption nobody can
-    // produce is a permanently red always-on lane - so an undecided kind must never read true,
-    // and with no `default:` there is no arm for it to read true from.
-    //
-    // constexpr AND PINNED BY static_assert BELOW, which is what stops it rotting the way a
-    // predicate with no caller does: MagmaPipeIdentityTables mints exactly two kinds, the
-    // asserts say so in both directions, and the file no longer compiles if the tables and this
-    // statement of them ever part company. (Review F-m5: the earlier form had no caller at all
-    // and could not make anything red or green.)
-    inline constexpr Bool MagmaPipeAbaControlKindIsRekeyedHere(MG_Pipe::MGPipeKind kind) {
-        switch (kind) {
-            // The two MagmaPipeIdentityTables really mints.
-            case MG_Pipe::MGPipeKind::VertexElementsCso:
-            case MG_Pipe::MGPipeKind::Buffer:
-                return true;
-            // P4a's six object classes: still reached from their frontend objects on this
-            // backend (Magma's object paths are P7, ROADMAP.md:24), so there is no key here for
-            // the knob to defeat.
-            case MG_Pipe::MGPipeKind::Texture:
-            case MG_Pipe::MGPipeKind::Renderbuffer:
-            case MG_Pipe::MGPipeKind::Framebuffer:
-            case MG_Pipe::MGPipeKind::SamplerCso:
-            case MG_Pipe::MGPipeKind::SamplerViewCso:
-            case MG_Pipe::MGPipeKind::ShaderCso:
-            // ...and everything else this backend does not mint a handle for.
-            case MG_Pipe::MGPipeKind::None:
-            case MG_Pipe::MGPipeKind::Xfb:
-            case MG_Pipe::MGPipeKind::RenderStateCso:
-            case MG_Pipe::MGPipeKind::Fence:
-            case MG_Pipe::MGPipeKind::Query:
-            case MG_Pipe::MGPipeKind::Context:
-            case MG_Pipe::MGPipeKind::KindCount:
-                return false;
-        }
-        return false;
-    }
-
-    static_assert(MagmaPipeAbaControlKindIsRekeyedHere(MG_Pipe::MGPipeKind::VertexElementsCso),
-                  "MagmaPipeIdentityTables mints VertexElementsCso: the knob has an identity to "
-                  "defeat for it");
-    static_assert(MagmaPipeAbaControlKindIsRekeyedHere(MG_Pipe::MGPipeKind::Buffer),
-                  "MagmaPipeIdentityTables mints Buffer: the knob has an identity to defeat for it");
-    static_assert(!MagmaPipeAbaControlKindIsRekeyedHere(MG_Pipe::MGPipeKind::Texture) &&
-                      !MagmaPipeAbaControlKindIsRekeyedHere(MG_Pipe::MGPipeKind::Renderbuffer) &&
-                      !MagmaPipeAbaControlKindIsRekeyedHere(MG_Pipe::MGPipeKind::Framebuffer) &&
-                      !MagmaPipeAbaControlKindIsRekeyedHere(MG_Pipe::MGPipeKind::SamplerCso) &&
-                      !MagmaPipeAbaControlKindIsRekeyedHere(MG_Pipe::MGPipeKind::SamplerViewCso) &&
-                      !MagmaPipeAbaControlKindIsRekeyedHere(MG_Pipe::MGPipeKind::ShaderCso),
-                  "P4a's six object classes are not keyed on {slot, gen} on this backend, so "
-                  "HandleRecycleScenario's six AbaControl arms must NOT expect a corruption here. "
-                  "Wiring one of them is what flips this assert, this predicate and that arm - and "
-                  "MG_IntegrationTest's two-symbol probe over MG_Backend/DirectVulkan is what "
-                  "carries the answer into the lane");
-
-    // THERE IS DELIBERATELY NO PER-KIND WRAPPER HERE, and review F-v2-m3 is why. An earlier
-    // round carried `MagmaPipeAbaControlCoversKind(kind)` - the conjunction of the two
-    // statements above - and it had no caller anywhere in the tree: the knob's only two
-    // consumers (VulkanRenderer.cpp's VAO draw memo and VertexInputStateFactory.cpp's pipeline
-    // key) each hold ONE kind, VertexElementsCso, by construction, so the kind is not a
-    // variable at either site. A conjunction no build ever evaluates cannot be pinned the way
-    // the predicate above is pinned - it is not constexpr, because it reads MG_Config::Features,
-    // so no static_assert can reach it - which makes it exactly the rot F-m5 was raised about,
-    // one level up: an `&&` whose operands could be inverted or dropped with nothing to say so.
-    //
-    // The two pieces stand alone instead, and each is pinned by something that runs:
-    // MagmaPipeAbaControlKindIsRekeyedHere is constexpr and asserted in BOTH directions by the
-    // three static_asserts above, which compile in every Magma build; MagmaPipeAbaControlDefeats
-    // Identity is the knob, and its two consumers are what make it true or false. A call site
-    // that ever does hold a variable kind writes the `&&` there, where a build will run it.
-
-    // The single consumer-table entry every VAO collapses onto while the control is on. Slot
-    // 0 is a real, ordinary entry of both tables (MagmaPipeSlotIndex maps the first allocatable
-    // handle onto it), so nothing about the tables changes shape for the control's sake.
-    inline constexpr Uint32 kMagmaPipeAbaControlSlotIndex = 0;
-
-    // ---------------------------------------------------------------------------------
-    // The {slot, gen} mint
-    // ---------------------------------------------------------------------------------
-    //
-    // Maps a frontend object's never-reused lifetime id to a dense {slot, gen}. Three
-    // properties, and the third is the one review v2 got wrong:
-    //
-    //   1. exact identity - Gen moves whenever a slot changes owner, so a stale handle can
-    //      never match a live object even if the allocator hands back the same heap address
-    //      (the ABA HandleRecycleScenario reproduces);
-    //   2. dense slots - the slot IS an index, so a consumer's per-slot table needs no hash,
-    //      no probe and no mix;
-    //   3. NO CAPACITY CLIFF. A live object's handle never changes while the object is being
-    //      drawn, whatever the working set size.
-    //
-    // Property 3 is why this is not the fixed 2-way set-associative LRU the previous round
-    // shipped. That structure evicted a LIVE object once the working set passed its capacity,
-    // and every consumer memo keyed on the handle died with it: measured on a verbatim
-    // transcription, 54% of uses lost their handle at 2500 live VAOs against 2048 entries, and
-    // 20% at 1024 live VAOs once the lifetime ids are sparse (an app that creates and destroys
-    // VAOs, which is the Minecraft chunk shape this exists for). Two of the three memos it
-    // fed - the content-hash memo and the resolved-state memo - had NO capacity before this
-    // package: they were unbounded mutable fields on VertexArrayObject. Introducing eviction
-    // there turns one ComputeHash per VAO reconfiguration into one per DRAW, and, once the
-    // buffer table thrashes too, makes the vertex-input content hash a per-draw value that
-    // inserts a fresh heap-allocated BackendVertexInputState into an unbounded map on every
-    // draw. That is a worse leak than the one it was introduced to avoid.
-    //
-    // So: grow on demand, and reclaim by AGE instead of by capacity.
-    //
-    //   * Acquire hits an UnorderedMap<lifetimeId, slotIndex>, in front of which sits a
-    //     one-entry memo. Every re-keyed site in a draw asks about the SAME VAO, so the memo
-    //     turns the five-or-six acquisitions a draw makes into one map probe plus five Uint64
-    //     compares - less than the address multiply plus two-way probe the pre-handle arm ran.
-    //   * OnFrameBoundary retires slots whose object has not been drawn for
-    //     kRetireAgeBoundaries boundaries and returns them to a free list, so the table's
-    //     footprint tracks the LIVE DRAWN working set, not objects ever created. That is the
-    //     property MG_Impl/Pipe/SlotAllocator cannot have here: nothing in P2 can call its
-    //     Free (the tracker emits no object-class state, BufferBackendOps::OnDestroy is handed
-    //     a BackendBufferResource rather than the BufferObject, and VertexArrayObject has no
-    //     death hook at all - adding one is D13's explicit-destroy work, which covers Espryt's
-    //     six kinds, not VertexElementsCso), so an allocator here would grow by one SlotState
-    //     plus one map node per object EVER created, for the life of the process, on a
-    //     platform with an LMK. Age-based reclamation is the stand-in for the death
-    //     notification, and it is exactly as ABA-proof, because reuse bumps Gen.
-    //   * A retire costs at most one memo recompute if the object is drawn again - the same
-    //     price a cache miss costs - and it is charged only to objects that went idle for
-    //     ~1024 frames, never to a hot one.
-    //
-    // Memory: one map node plus one 24-byte Entry per live object, i.e. tens of bytes against
-    // the kilobyte a VertexArrayObject or a BufferObject already costs the frontend. There is
-    // no capacity to size off a device measurement because there is no capacity; what the
-    // device run in D.4.2 can still want is the number itself, so the high-water mark is
-    // logged at MGLOG_D on the allocate-a-new-slot branch (once per new object, never on a
-    // draw - ROADMAP.md:7).
-    //
-    // Single-threaded, like the rest of the renderer. Owned per VulkanRenderer (see
-    // MagmaPipeIdentityTables): a process-global would share one table, and one reclamation
-    // clock, across two live contexts.
-    class MagmaPipeIdentityTable {
-    public:
-        explicit MagmaPipeIdentityTable(const char* kindName) : m_kindName(kindName) {}
-
-        // Slots ever minted. A consumer table indexed by MagmaPipeSlotIndex() needs this many
-        // entries; MagmaPipeSlotTable below grows itself, so nobody has to ask.
-        Uint32 Count() const { return static_cast<Uint32>(m_entries.size()); }
-        // Objects currently holding a slot - the live working set this table tracks.
-        Uint32 LiveCount() const { return static_cast<Uint32>(m_index.size()); }
-
-        MG_Pipe::MGPipeHandle Acquire(Uint64 lifetimeId) {
-            // Unreachable: MG_State hands out lifetime ids from 1 precisely so that a
-            // zero-initialised memo slot cannot carry a live object's id. Guarded anyway so
-            // that a zero can never be minted into a slot and then indexed with.
-            if (lifetimeId == 0) return MG_Pipe::kMGPipeNullHandle;
-            // The one-entry front memo. Cleared by any retire, so it can never serve a slot
-            // that has been handed back to the free list.
-            if (lifetimeId == m_lastLifetimeId) {
-                m_entries[m_lastIndex].LastUse = m_boundary;
-                return m_lastHandle;
-            }
-            Uint32 index = 0;
-            const auto it = m_index.find(lifetimeId);
-            if (it != m_index.end()) {
-                index = it->second;
-            } else {
-                index = ClaimSlot();
-                m_entries[index].LifetimeId = lifetimeId;
-                m_index.emplace(lifetimeId, index);
-            }
-            Entry& entry = m_entries[index];
-            entry.LastUse = m_boundary;
-            m_lastLifetimeId = lifetimeId;
-            m_lastIndex = index;
-            m_lastHandle = MG_Pipe::MGPipeHandle{index + MG_Pipe::kMGPipeFirstAllocatableSlot,
-                                                 entry.Gen};
-            return m_lastHandle;
-        }
-
-        // Ages the table and returns idle slots to the free list. Same shape and the same
-        // self-gating as VertexInputStateFactory::OnFrameBoundary, which is what the reclaimed
-        // slots' consumers use.
-        void OnFrameBoundary() {
-            ++m_boundary;
-            if ((m_boundary % kSweepInterval) != 0) return;
-            SizeT retired = 0;
-            for (auto it = m_index.begin(); it != m_index.end();) {
-                Entry& entry = m_entries[it->second];
-                if ((m_boundary - entry.LastUse) > kRetireAgeBoundaries) {
-                    entry.LifetimeId = 0;
-                    m_freeSlots.push_back(it->second);
-                    it = m_index.erase(it);
-                    ++retired;
-                } else {
-                    ++it;
-                }
-            }
-            if (retired != 0) {
-                // A retired slot's Gen has not moved yet - it moves when the slot is reused -
-                // so a front memo pointing at one would still hand out a handle the consumer
-                // tables would accept. Drop it.
-                m_lastLifetimeId = 0;
-                m_lastHandle = MG_Pipe::kMGPipeNullHandle;
-                MGLOG_D("MagmaPipeIdentityTable(%s): retired %zu idle slots, %u live of %u minted",
-                        m_kindName, retired, LiveCount(), Count());
-            }
-        }
-
-    private:
-        // Sweep cadence and retirement age, deliberately the same numbers
-        // VertexInputStateFactory::OnFrameBoundary uses for the entries these slots key: a slot
-        // retired earlier than its cache entry would mint a new handle for an object whose
-        // entry is still live and still correct, which is a pure waste.
-        static constexpr Uint64 kSweepInterval = 256;
-        static constexpr Uint64 kRetireAgeBoundaries = 1024;
-
-        struct Entry {
-            Uint64 LifetimeId = 0;
-            Uint64 LastUse = 0;
-            // Moves ONLY on slot reuse, never on respecify: an object that keeps its slot keeps
-            // its generation, which is what makes a memo survive a reconfiguration.
-            Uint32 Gen = 0;
-        };
-
-        Uint32 ClaimSlot() {
-            while (!m_freeSlots.empty()) {
-                const Uint32 index = m_freeSlots.back();
-                m_freeSlots.pop_back();
-                // MGPipeHandles.h:52-58 defends the Gen wrap only in a debug allocator, and
-                // MOBILEGL_ASSERT is compiled out of every build P2 runs (Defines.h: asserts are
-                // live only at MOBILEGL_LOG_ACTIVE_LEVEL == DEBUG). So the wrap is handled on the
-                // RELEASE path instead of asserted: a slot that has been reused 2^32 times is
-                // permanently retired rather than wrapped, because a wrapped Gen would let a
-                // stale handle match a live object. It costs one slot.
-                if (m_entries[index].Gen == ~Uint32{0}) {
-                    MGLOG_W("MagmaPipeIdentityTable(%s): slot %u reached generation 2^32-1 and is "
-                            "retired for good; {slot, gen} stays unique",
-                            m_kindName, index + MG_Pipe::kMGPipeFirstAllocatableSlot);
-                    continue;
-                }
-                ++m_entries[index].Gen;
-                return index;
-            }
-            const Uint32 index = static_cast<Uint32>(m_entries.size());
-            m_entries.push_back(Entry{});
-            m_entries[index].Gen = 1;
-            // The high-water mark, at powers of two from 1024 up: at most a handful of lines
-            // for a whole session, emitted from the allocate-a-NEW-slot branch, i.e. once per
-            // object this backend has ever seen and never on a draw (ROADMAP.md:7).
-            //
-            // [narrow, declared deviation from D20's "MGLOG_D for anything non-critical"] This
-            // one is I, not D, because D is compiled out of every build that ships and of every
-            // build P2 measures, and this line IS the measurement review v2's MAJOR 1 asks for:
-            // the live-object high-water mark of minecraft-1.21.4-in-world and
-            // ...-sodium-in-world, which nothing on desktop reaches and no gate here can see.
-            // The structure no longer has a capacity to size off it, so the number is evidence
-            // rather than a tuning input - but D.4.2 should still read it out of the device log,
-            // and it cannot read a line that was compiled away.
-            const SizeT minted = m_entries.size();
-            if (minted >= 1024 && (minted & (minted - 1)) == 0) {
-                MGLOG_I("MagmaPipeIdentityTable(%s): high-water %zu slots minted, %u live",
-                        m_kindName, minted, LiveCount());
-            }
-            return index;
-        }
-
-        const char* m_kindName = "";
-        Uint64 m_boundary = 0;
-        Vector<Entry> m_entries;
-        Vector<Uint32> m_freeSlots;
-        UnorderedMap<Uint64, Uint32> m_index;
-        // One-entry front memo (see Acquire). m_lastLifetimeId == 0 means "empty": a live
-        // object's lifetime id is never 0.
-        Uint64 m_lastLifetimeId = 0;
-        Uint32 m_lastIndex = 0;
-        MG_Pipe::MGPipeHandle m_lastHandle = MG_Pipe::kMGPipeNullHandle;
-    };
-
-    // The two mints one renderer owns. Per renderer, NOT process-global: two live contexts (or
-    // a context recreation, which destroys and rebuilds the renderer) would otherwise share one
-    // table and one reclamation clock, and both consumer tables are per-instance already.
-    class MagmaPipeIdentityTables {
-    public:
-        // A VAO is kind VertexElementsCso: that is the gallium-shaped CSO a vertex array
-        // resolves to, and the only kind in MGPipeKind that names vertex-input state.
-        MG_Pipe::MGPipeHandle HandleOf(MG_Pipe::MGPipeKind kind, Uint64 lifetimeId) {
-            return kind == MG_Pipe::MGPipeKind::Buffer ? m_buffers.Acquire(lifetimeId)
-                                                       : m_vaos.Acquire(lifetimeId);
-        }
-        void OnFrameBoundary() {
-            m_vaos.OnFrameBoundary();
-            m_buffers.OnFrameBoundary();
-        }
-        const MagmaPipeIdentityTable& Vaos() const { return m_vaos; }
-        const MagmaPipeIdentityTable& Buffers() const { return m_buffers; }
-
-    private:
-        MagmaPipeIdentityTable m_vaos{"VertexElementsCso"};
-        MagmaPipeIdentityTable m_buffers{"Buffer"};
-    };
-
-    // The table entry a handle names. Every per-slot table Magma keeps is indexed by this.
-    //
-    // A null handle has no slot, and it is unreachable here: both lifetime-id sources start at
-    // 1 (VertexArrayObject.cpp, BufferObject.cpp), so Acquire's zero guard never fires. The
-    // ternary, not the assertion, is what has effect in a shipped build (Defines.h compiles
-    // MOBILEGL_ASSERT out at INFO), and slot 0 of a consumer table is a real entry that a null
-    // handle can never match, because MGPipeHandleIsNull is also what the consumers compare.
-    inline Uint32 MagmaPipeSlotIndex(const MG_Pipe::MGPipeHandle& handle) {
-        MOBILEGL_ASSERT(!MG_Pipe::MGPipeHandleIsNull(handle),
-                        "a null MGPipeHandle has no slot to index a per-slot table with");
-        return MG_Pipe::MGPipeHandleIsNull(handle)
-                   ? 0u
-                   : handle.Slot - MG_Pipe::kMGPipeFirstAllocatableSlot;
-    }
-
-    // A grow-on-demand per-slot table whose ENTRY ADDRESSES NEVER MOVE.
-    //
-    // D12.4 asks for a grow-on-demand Vector, and with an unbounded mint that is what a
-    // consumer needs - but a Vector that grows relocates its elements, and the draw path holds
-    // references into these entries across nested calls. Chunks of kChunkEntries are appended
-    // instead: the Vector of owning pointers reallocates, the chunks never do, so an entry
-    // reference is valid for the life of the table. That is the same guarantee the fixed table
-    // it replaces gave, without the fixed capacity.
-    template <typename T, Uint32 kChunkEntries = 256>
-    class MagmaPipeSlotTable {
-    public:
-        T& operator[](Uint32 index) {
-            const Uint32 chunk = index / kChunkEntries;
-            while (m_chunks.size() <= chunk) {
-                m_chunks.push_back(MakeUnique<Chunk>());
-            }
-            return m_chunks[chunk]->Entries[index % kChunkEntries];
-        }
-        SizeT Capacity() const { return m_chunks.size() * kChunkEntries; }
-
-    private:
-        struct Chunk {
-            T Entries[kChunkEntries] = {};
-        };
-        Vector<UniquePtr<Chunk>> m_chunks;
-    };
-
-    // The claim rule every per-slot memo table uses, in one place so that the rule and the
-    // negative control that defeats it cannot drift apart between consumers - and so that the
-    // unit suite which drives a REAL slot reuse (MG_Test/Pipe/MagmaPipeIdentityTest.cpp) tests
-    // this code rather than a copy of it.
-    //
-    // The SLOT picks the entry; the WHOLE handle - Gen included - decides whether the entry is
-    // this object's. A slot the mint recycled for a different object comes back with a moved
-    // Gen, so the compare fails and the entry is cleared rather than inherited. That is the
-    // half HandleRecycleScenario cannot reach (see MagmaPipeAbaControlDefeatsIdentity).
-    //
-    // With negative control C on, every object collapses onto one entry and the entry is handed
-    // back UNCLEARED and UNCLAIMED - at once "the replacement reproduced its predecessor's
-    // slot" and "the slot was reused and Gen did not move".
-    //
-    // `Memos` needs a MG_Pipe::MGPipeHandle member named Owner and a default constructor that
-    // means "empty"; VertexInputStateFactory::VaoBackendMemos is the one production instance.
-    template <typename Memos, Uint32 kChunkEntries>
-    inline Memos& MagmaPipeClaimSlotMemos(MagmaPipeSlotTable<Memos, kChunkEntries>& table,
-                                          const MG_Pipe::MGPipeHandle& handle) {
-        if (MagmaPipeAbaControlDefeatsIdentity()) {
-            return table[kMagmaPipeAbaControlSlotIndex];
-        }
-        Memos& memos = table[MagmaPipeSlotIndex(handle)];
-        if (!(memos.Owner == handle)) {
-            memos = Memos{};
-            memos.Owner = handle;
-        }
-        return memos;
-    }
-#endif // MOBILEGL_PIPE_PUSH
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/MagmaProgramSource.h

@@ -1,224 +0,0 @@
-// MobileGL - server-owned program input for Magma (P5f fm).
-#pragma once
-
-#include <MG_State/GLState/ProgramState/ProgramObject.h>
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-#include <MG_Pipe/PipeApply.h>
-#include <MG_State/GLState/ProgramState/ProgramArtifactsCodec.h>
-#include "../DirectVulkanResourceState.h"
-// P7 wave 2 package C, OQ-8: spirv_reflect.h is GONE from this header, and its absence is the
-// gate. Everything this class needed it for - the storage-block index space - now travels in
-// the archive (LinkArtifacts::storageBlocks), so the SPIR-V reflector is off the Magma wire
-// draw path entirely. A future edit that re-adds the include is re-adding a per-draw reflect,
-// because a MagmaProgramSource is constructed once per draw and can memoise nothing.
-#endif
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // A borrowed view, valid only while its frontend object or server record lives.
-    // It never constructs a ProgramObject on the server. Post-link mutable values
-    // come from the record tails, not from the archive's link-time defaults.
-    class MagmaProgramSource {
-    public:
-        using Program = MG_State::GLState::ProgramObject;
-        MagmaProgramSource(const Program& program) : m_frontend(&program) {}
-        MagmaProgramSource(MG_Pipe::MGPipeHandle handle, const MG_Pipe::MGPipeShaderCsoRecord& record)
-            : m_handle(handle), m_record(&record) {
-            MOBILEGL_ASSERT(record.Archive != nullptr, "Magma program record has no archive");
-        }
-
-        Bool IsWire() const { return m_record != nullptr; }
-        MG_Pipe::MGPipeHandle Handle() const { return m_handle; }
-        const Program* Frontend() const { return m_frontend; }
-        Uint GetExternalIndex() const { return IsWire() ? m_handle.Slot : m_frontend->GetExternalIndex(); }
-        Uint64 GetLifetimeId() const {
-            return IsWire() ? (Uint64(m_handle.Gen) << 32) | m_handle.Slot : m_frontend->GetLifetimeId();
-        }
-        Bool GetLinkStatus() const { return IsWire() ? m_record->Desc.LinkStatus != 0 : m_frontend->GetLinkStatus(); }
-        Bool GetSpirvStatus() const { return IsWire() ? m_record->Desc.SpirvStatus != 0 : m_frontend->GetSpirvStatus(); }
-        Bool PointSizeDemoted() const { return IsWire() ? m_record->Desc.PointSizeDemoted != 0 : m_frontend->PointSizeDemoted(); }
-        Bool GetSpirvValidationEnabled() const {
-            return IsWire() ? m_record->Desc.EnableSpirvValidation != 0 : m_frontend->GetSpirvValidationEnabled();
-        }
-        const Vector<Vector<Uint>>& GetGeneratedSpirv() const {
-            return IsWire() ? m_record->Archive->Spirv.generatedSpirv : m_frontend->GetGeneratedSpirv();
-        }
-        Vector<ShaderStage> GetLinkedShaderStages() const {
-            if (!IsWire()) return m_frontend->GetLinkedShaderStages();
-            Vector<ShaderStage> result;
-            for (const auto stage : m_record->Archive->LinkedStages) result.push_back(static_cast<ShaderStage>(stage));
-            return result;
-        }
-        Bool HasLinkedShaderStage(ShaderStage stage) const {
-            if (!IsWire()) return m_frontend->HasLinkedShaderStage(stage);
-            const auto& stages = m_record->Archive->LinkedStages;
-            return std::find(stages.begin(), stages.end(), static_cast<Uint32>(stage)) != stages.end();
-        }
-        Bool GetBackendHashMemo(Uint flags, Uint64& hash) const {
-            // A view has no lifetime in which a memo can safely persist. The server
-            // factory's content cache still owns compiled programs; hash from current
-            // archive + binding tails rather than borrowing the client's mutable memo.
-            return !IsWire() && m_frontend->GetBackendHashMemo(flags, hash);
-        }
-        void SetBackendHashMemo(Uint flags, Uint64 hash) const {
-            if (!IsWire()) m_frontend->SetBackendHashMemo(flags, hash);
-        }
-        Uint64 GetBackendStateVersion() const { return IsWire() ? m_record->Serial : m_frontend->GetBackendStateVersion(); }
-        Uint64 GetBlockBindingVersion() const { return IsWire() ? m_record->BindingsSerial : m_frontend->GetBlockBindingVersion(); }
-        Uint64 GetImageUnitVersion() const { return IsWire() ? m_record->BindingsSerial : m_frontend->GetImageUnitVersion(); }
-        Uint64 GetLinkVersion() const { return IsWire() ? m_record->Serial : m_frontend->GetLinkVersion(); }
-
-        const void* GetUBOData() const { return IsWire() ? m_record->GlobalConstants.data() : m_frontend->GetUBOData(); }
-        Uint GetUBOSize() const { return IsWire() ? static_cast<Uint>(m_record->GlobalConstants.size()) : m_frontend->GetUBOSize(); }
-        Uint32 GetUBOContentVersion() const { return IsWire() ? m_record->GlobalConstantsVersion : m_frontend->GetUBOContentVersion(); }
-        Int GetActiveUniformBlocksCount() const {
-            return IsWire() ? static_cast<Int>(Link().glBlockIndexToTProgram.size()) : m_frontend->GetActiveUniformBlocksCount();
-        }
-        Uint GetUniformBlockIndex(const char* name) const {
-            if (!IsWire()) return m_frontend->GetUniformBlockIndex(name);
-            auto found = Link().uniformBlockIndexByName.find(name);
-            if (found == Link().uniformBlockIndexByName.end()) found = Link().uniformBlockIndexByName.find(String(name) + "[0]");
-            return found == Link().uniformBlockIndexByName.end() ? GL_INVALID_INDEX : found->second;
-        }
-        Uint GetUniformBlockBinding(Uint index) const {
-            if (!IsWire()) return m_frontend->GetUniformBlockBinding(index);
-            return index < m_record->BlockBindings.size() ? static_cast<Uint>(m_record->BlockBindings[index]) : 0;
-        }
-        const String& GetUniformBlockName(Uint index) const {
-            if (!IsWire()) return m_frontend->GetUniformBlockName(index);
-            const auto* block = Block(index);
-            static const String empty;
-            return block ? block->name : empty;
-        }
-        Uint GetUBOSizeAt(Uint index) const {
-            if (!IsWire()) return m_frontend->GetUBOSizeAt(index);
-            const auto* block = Block(index);
-            return block ? (static_cast<Uint>(block->size) + 15u) & ~15u : 0;
-        }
-        Bool IsValidUniformLocation(Int location) const {
-            return IsWire() ? Program::IsValidUniformLocation(Link(), location) : m_frontend->IsValidUniformLocation(location);
-        }
-        Bool UniformLocationsAliasSameUniform(Int a, Int b) const {
-            if (!IsWire()) return m_frontend->UniformLocationsAliasSameUniform(a, b);
-            return IsValidUniformLocation(a) && IsValidUniformLocation(b) &&
-                Link().uniformIndexInTProgram[a] == Link().uniformIndexInTProgram[b];
-        }
-        GLenum GetUniformType(Uint location) const {
-            if (!IsWire()) return m_frontend->GetUniformType(location);
-            return IsValidUniformLocation(static_cast<Int>(location))
-                ? Program::UniformAtIn(Link(), Link().uniformIndexInTProgram[location]).glDefineType : 0;
-        }
-        Int GetUniformSamplerOrImageUnitIndex(Uint location) const {
-            if (!IsWire()) return m_frontend->GetUniformSamplerOrImageUnitIndex(location);
-            const auto& units = m_record->SamplerUnits;
-            const auto found = std::lower_bound(units.begin(), units.end(), location,
-                [](const MG_Pipe::MGPProgramSamplerUnit& unit, Uint value) { return unit.Location < value; });
-            return found != units.end() && found->Location == location ? found->Unit : -1;
-        }
-        Int GetUniformLocation(const String& name) const {
-            if (!IsWire()) return m_frontend->GetUniformLocation(name);
-            const auto& locations = Link().uniformLocations;
-            auto found = locations.find(name);
-            if (found != locations.end()) return static_cast<Int>(found->second);
-            if (name.empty()) return -1;
-            found = locations.find(name + "[0]");
-            if (found != locations.end()) return static_cast<Int>(found->second);
-            if (name.back() != ']' || name.size() < 4) return -1;
-            const SizeT bracket = name.rfind('[');
-            if (bracket == String::npos || bracket + 1 >= name.size() - 1) return -1;
-            Uint element = 0;
-            for (SizeT i = bracket + 1; i < name.size() - 1; ++i) {
-                if (name[i] < '0' || name[i] > '9') return -1;
-                element = element * 10 + static_cast<Uint>(name[i] - '0');
-                if (element > 0x0fffffffu) return -1;
-            }
-            found = locations.find(name.substr(0, bracket) + "[0]");
-            if (found == locations.end()) found = locations.find(name.substr(0, bracket));
-            if (found == locations.end()) return -1;
-            const Int base = static_cast<Int>(found->second);
-            if (!IsValidUniformLocation(base)) return -1;
-            const Int tIndex = Link().uniformIndexInTProgram[base];
-            if (!Program::UniformAtIn(Link(), tIndex).type.isArray ||
-                static_cast<GLint>(element) >= Program::GetUniformArraySizeByTIndex(Link(), tIndex)) return -1;
-            const Int location = base + static_cast<Int>(element);
-            return UniformLocationsAliasSameUniform(base, location) ? location : -1;
-        }
-
-        SizeT GetTransformFeedbackVaryingCount() const { return IsWire() ? Link().xfbVaryings.size() : m_frontend->GetTransformFeedbackVaryingCount(); }
-        const Vector<MG_State::GLState::XfbVarying>& GetTransformFeedbackVaryings() const {
-            return IsWire() ? Link().xfbVaryings : m_frontend->GetTransformFeedbackVaryings();
-        }
-        SizeT GetTransformFeedbackBufferCount() const { return IsWire() ? Link().xfbStrides.size() : m_frontend->GetTransformFeedbackBufferCount(); }
-        Uint32 GetTransformFeedbackStride(Uint index) const {
-            if (!IsWire()) return m_frontend->GetTransformFeedbackStride(index);
-            return index < Link().xfbStrides.size() ? Link().xfbStrides[index] : 0;
-        }
-        GLenum GetTransformFeedbackBufferMode() const {
-            return IsWire() ? Link().xfbBufferMode : m_frontend->GetTransformFeedbackBufferMode();
-        }
-        // P7 wave 2 package C, OQ-8 (CONTRACT-P7 §5.3): READ OUT OF THE ARCHIVE.
-        //
-        // What stood here re-ran spvReflectCreateShaderModule over EVERY stage module of the
-        // program, and it did so PER DRAW: a MagmaProgramSource is a borrowed view that
-        // WireDraw.inc's WireProgramSource constructs afresh for each wire draw, so the lazy
-        // `m_storageBlocksReady` latch could never outlive one. The list it rebuilt is a pure
-        // function of the linked program, so it is now built once at link time and travels in
-        // the archive (LinkArtifacts::storageBlocks), which takes the SPIR-V reflector off the
-        // wire draw path entirely - this header no longer includes spirv_reflect.h at all.
-        Uint GetShaderStorageBlockIndex(const String& name) const {
-            if (!IsWire()) return DirectVulkan::GetShaderStorageBlockIndex(*m_frontend, name);
-            const auto& blocks = Link().storageBlocks;
-            // The archive carries NORMALISED names (the array subscript stripped), because
-            // that is the spelling SPIRV-Reflect's type_name gives and the spelling
-            // ProgramFactory::ReflectLayout looks up. A caller that still holds a GL-style
-            // "Foo[2]" gets the same second chance it always had.
-            const auto find = [&blocks](const String& key) {
-                return std::find_if(blocks.begin(), blocks.end(),
-                    [&](const MG_State::GLState::StorageBlockReflection& block) {
-                        return block.name == key;
-                    });
-            };
-            auto found = find(name);
-            if (found == blocks.end() && !name.empty() && name.back() == ']') {
-                const auto bracket = name.rfind('[');
-                if (bracket != String::npos) found = find(name.substr(0, bracket));
-            }
-            return found == blocks.end() ? GL_INVALID_INDEX
-                                         : static_cast<Uint>(found - blocks.begin());
-        }
-        Uint GetShaderStorageBlockBinding(Uint index) const {
-            if (!IsWire()) return DirectVulkan::GetShaderStorageBlockBinding(*m_frontend, index);
-            const auto& blocks = Link().storageBlocks;
-            if (index >= blocks.size()) return 0;
-            const auto& block = blocks[index];
-            // THE OVERRIDE STILL WINS, and it still comes off the RECORD rather than the
-            // archive: glShaderStorageBlockBinding is a post-link mutable and the archive
-            // carries link-time defaults only (rule on MagmaProgramSource, and the reason
-            // StorageBlockReflection::binding is documented as the DECLARED binding).
-            for (const auto& override : m_record->StorageOverrides) {
-                if (override.Name == block.name) return override.Binding;
-            }
-            return block.binding;
-        }
-
-    private:
-        const MG_State::GLState::LinkArtifacts& Link() const { return m_record->Archive->Link; }
-        const MG_State::GLState::BlockReflection* Block(Uint index) const {
-            if (index >= Link().glBlockIndexToTProgram.size()) return nullptr;
-            const Int tIndex = Link().glBlockIndexToTProgram[index];
-            return tIndex >= 0 && static_cast<SizeT>(tIndex) < Link().blockReflection.size()
-                ? &Link().blockReflection[tIndex] : nullptr;
-        }
-        const Program* m_frontend = nullptr;
-        MG_Pipe::MGPipeHandle m_handle = MG_Pipe::kMGPipeNullHandle;
-        const MG_Pipe::MGPipeShaderCsoRecord* m_record = nullptr;
-        // P7 OQ-8: the two mutables that memoised the per-draw reflect are gone with it. They
-        // were `mutable` precisely because this class is a borrowed const view - and that is
-        // also why they never helped: a view lives for one draw, so the latch was cold every
-        // time it was read.
-    };
-#else
-    using MagmaProgramSource = MG_State::GLState::ProgramObject;
-#endif
-}

MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.cpp

@@ -1,663 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.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 "PipelineFactory.h"
-
-#include <algorithm>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    static const char* PrimitiveTopologyToString(VkPrimitiveTopology topology) {
-        switch (topology) {
-        ENUM_STR_CASE(VK_PRIMITIVE_TOPOLOGY_POINT_LIST)
-        ENUM_STR_CASE(VK_PRIMITIVE_TOPOLOGY_LINE_LIST)
-        ENUM_STR_CASE(VK_PRIMITIVE_TOPOLOGY_LINE_STRIP)
-        ENUM_STR_CASE(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
-        ENUM_STR_CASE(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP)
-        ENUM_STR_CASE(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN)
-        ENUM_STR_CASE(VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY)
-        ENUM_STR_CASE(VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY)
-        ENUM_STR_CASE(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY)
-        ENUM_STR_CASE(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY)
-        ENUM_STR_CASE(VK_PRIMITIVE_TOPOLOGY_PATCH_LIST)
-        default:
-            return "VK_PRIMITIVE_TOPOLOGY_UNKNOWN";
-        }
-    }
-
-    static const char* SampleCountToString(VkSampleCountFlagBits sampleCount) {
-        switch (sampleCount) {
-        ENUM_STR_CASE(VK_SAMPLE_COUNT_1_BIT)
-        ENUM_STR_CASE(VK_SAMPLE_COUNT_2_BIT)
-        ENUM_STR_CASE(VK_SAMPLE_COUNT_4_BIT)
-        ENUM_STR_CASE(VK_SAMPLE_COUNT_8_BIT)
-        ENUM_STR_CASE(VK_SAMPLE_COUNT_16_BIT)
-        ENUM_STR_CASE(VK_SAMPLE_COUNT_32_BIT)
-        ENUM_STR_CASE(VK_SAMPLE_COUNT_64_BIT)
-        default:
-            return "VK_SAMPLE_COUNT_UNKNOWN";
-        }
-    }
-
-    static const char* CullModeToString(VkCullModeFlags cullMode) {
-        switch (cullMode) {
-        case VK_CULL_MODE_NONE:
-            return "VK_CULL_MODE_NONE";
-        case VK_CULL_MODE_FRONT_BIT:
-            return "VK_CULL_MODE_FRONT_BIT";
-        case VK_CULL_MODE_BACK_BIT:
-            return "VK_CULL_MODE_BACK_BIT";
-        case VK_CULL_MODE_FRONT_AND_BACK:
-            return "VK_CULL_MODE_FRONT_AND_BACK";
-        default:
-            return "VK_CULL_MODE_UNKNOWN";
-        }
-    }
-
-    static const char* CompareOpToString(VkCompareOp compareOp) {
-        switch (compareOp) {
-        ENUM_STR_CASE(VK_COMPARE_OP_NEVER)
-        ENUM_STR_CASE(VK_COMPARE_OP_LESS)
-        ENUM_STR_CASE(VK_COMPARE_OP_EQUAL)
-        ENUM_STR_CASE(VK_COMPARE_OP_LESS_OR_EQUAL)
-        ENUM_STR_CASE(VK_COMPARE_OP_GREATER)
-        ENUM_STR_CASE(VK_COMPARE_OP_NOT_EQUAL)
-        ENUM_STR_CASE(VK_COMPARE_OP_GREATER_OR_EQUAL)
-        ENUM_STR_CASE(VK_COMPARE_OP_ALWAYS)
-        default:
-            return "VK_COMPARE_OP_UNKNOWN";
-        }
-    }
-
-    static const char* LogicOpToString(VkLogicOp logicOp) {
-        switch (logicOp) {
-        ENUM_STR_CASE(VK_LOGIC_OP_CLEAR)
-        ENUM_STR_CASE(VK_LOGIC_OP_AND)
-        ENUM_STR_CASE(VK_LOGIC_OP_AND_REVERSE)
-        ENUM_STR_CASE(VK_LOGIC_OP_COPY)
-        ENUM_STR_CASE(VK_LOGIC_OP_AND_INVERTED)
-        ENUM_STR_CASE(VK_LOGIC_OP_NO_OP)
-        ENUM_STR_CASE(VK_LOGIC_OP_XOR)
-        ENUM_STR_CASE(VK_LOGIC_OP_OR)
-        ENUM_STR_CASE(VK_LOGIC_OP_NOR)
-        ENUM_STR_CASE(VK_LOGIC_OP_EQUIVALENT)
-        ENUM_STR_CASE(VK_LOGIC_OP_INVERT)
-        ENUM_STR_CASE(VK_LOGIC_OP_OR_REVERSE)
-        ENUM_STR_CASE(VK_LOGIC_OP_COPY_INVERTED)
-        ENUM_STR_CASE(VK_LOGIC_OP_OR_INVERTED)
-        ENUM_STR_CASE(VK_LOGIC_OP_NAND)
-        ENUM_STR_CASE(VK_LOGIC_OP_SET)
-        default:
-            return "VK_LOGIC_OP_UNKNOWN";
-        }
-    }
-
-    PipelineFactory::PipelineFactory(VkDevice device, const VulkanRendererConfig& config):
-        m_device(device), m_config(config) {
-        MOBILEGL_ASSERT(m_device != VK_NULL_HANDLE, "PipelineFactory: device is null");
-
-        if (m_config.DisablePipelineCache) {
-            MGLOG_I("DirectVulkan: pipeline cache disabled");
-            return;
-        }
-
-        VkPipelineCacheCreateInfo pipelineCacheInfo{VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO};
-        VK_VERIFY(vkCreatePipelineCache(m_device, &pipelineCacheInfo, nullptr, &m_pipelineCache),
-                  "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) {
-            vkDestroyPipelineCache(m_device, m_pipelineCache, nullptr);
-            m_pipelineCache = VK_NULL_HANDLE;
-        }
-    }
-
-    PipelineFactory::HashType PipelineFactory::ComputeHash(const PipelineCreatePayload& payload) const {
-        XXHASH_VERIFY(XXH64_reset(m_hashState, m_config.CacheVersion));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.programHash, sizeof(payload.programHash)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.vertexInputHash, sizeof(payload.vertexInputHash)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.pipelineLayout, sizeof(payload.pipelineLayout)));
-#if MOBILEGL_BUILD_DISAGGREGATED
-        if (payload.wireRenderPassCompatibilityId != 0) {
-            constexpr Uint64 wireDomain = 0x5749524552504b59ull;
-            XXHASH_VERIFY(XXH64_update(m_hashState, &wireDomain, sizeof(wireDomain)));
-            XXHASH_VERIFY(XXH64_update(m_hashState, &payload.wireRenderPassCompatibilityId,
-                                      sizeof(payload.wireRenderPassCompatibilityId)));
-        } else
-#endif
-        {
-            XXHASH_VERIFY(XXH64_update(m_hashState, &payload.renderPass, sizeof(payload.renderPass)));
-        }
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.colorAttachmentCount, sizeof(payload.colorAttachmentCount)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.rasterizationSamples, sizeof(payload.rasterizationSamples)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.sampleShadingEnable, sizeof(payload.sampleShadingEnable)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.minSampleShading, sizeof(payload.minSampleShading)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.sampleMask, sizeof(payload.sampleMask)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.subpass, sizeof(payload.subpass)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.topology, sizeof(payload.topology)));
-        XXHASH_VERIFY(
-            XXH64_update(m_hashState, &payload.primitiveRestartEnable, sizeof(payload.primitiveRestartEnable)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.patchControlPoints, sizeof(payload.patchControlPoints)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.passthroughTessControlKey,
-                                   sizeof(payload.passthroughTessControlKey)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.viewportCount, sizeof(payload.viewportCount)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.polygonMode, sizeof(payload.polygonMode)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.cullMode, sizeof(payload.cullMode)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.frontFace, sizeof(payload.frontFace)));
-        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)));
-        XXHASH_VERIFY(
-            XXH64_update(m_hashState, &payload.rasterizerDiscardEnable, sizeof(payload.rasterizerDiscardEnable)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.logicOpEnable, sizeof(payload.logicOpEnable)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.stencilTestEnable, sizeof(payload.stencilTestEnable)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.depthCompareOp, sizeof(payload.depthCompareOp)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.logicOp, sizeof(payload.logicOp)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.frontStencilFailOp, sizeof(payload.frontStencilFailOp)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.frontStencilPassOp, sizeof(payload.frontStencilPassOp)));
-        XXHASH_VERIFY(
-            XXH64_update(m_hashState, &payload.frontStencilDepthFailOp, sizeof(payload.frontStencilDepthFailOp)));
-        XXHASH_VERIFY(
-            XXH64_update(m_hashState, &payload.frontStencilCompareOp, sizeof(payload.frontStencilCompareOp)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.backStencilFailOp, sizeof(payload.backStencilFailOp)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &payload.backStencilPassOp, sizeof(payload.backStencilPassOp)));
-        XXHASH_VERIFY(
-            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,
-                payload.colorBlendAttachments.data(),
-                sizeof(payload.colorBlendAttachments[0]) * payload.colorAttachmentCount));
-        }
-        return XXH64_digest(m_hashState);
-    }
-
-    VkPipeline PipelineFactory::GetOrCreatePipeline(const PipelineCreatePayload& payload) {
-        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;
-        }
-
-        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,
-#if MOBILEGL_BUILD_DISAGGREGATED
-                                                 // Wire pipelines outlive their creator pass and
-                                                 // may serve another compatible pass in flight.
-                                                 // Never evict them by a recycled native handle.
-                                                 payload.wireRenderPassCompatibilityId != 0 ? VK_NULL_HANDLE :
-#endif
-                                                 payload.renderPass,
-                                                 m_frameCounter});
-        return pipeline;
-    }
-
-    void PipelineFactory::DestroyAll() {
-        for (auto& pair : m_cache) {
-            if (pair.second.pipeline != VK_NULL_HANDLE) {
-                vkDestroyPipeline(m_device, pair.second.pipeline, nullptr);
-            }
-        }
-        m_cache.clear();
-    }
-
-    Uint32 PipelineFactory::OnFrameBoundary() {
-        ++m_frameCounter;
-
-        // Sweep cadence and retire age mirror VkRenderPassManager::OnPresent: an entry
-        // idle for more than kRetireAgeFrames frame boundaries cannot be referenced by
-        // any in-flight command buffer (frames-in-flight <= MOBILEGL_MAGMA_FRAMESINFLIGHT),
-        // so immediate vkDestroyPipeline is safe. The caller must drop its "last
-        // pipeline" memo when this returns non-zero: the memo can return a cached
-        // handle without touching this cache, so an evicted pipeline may still be
-        // memoized (present-less flush loops never reset the memo per frame).
-        constexpr Uint64 kSweepInterval = 256;
-        constexpr Uint64 kRetireAgeFrames = 1024;
-        if ((m_frameCounter % kSweepInterval) != 0) {
-            return 0;
-        }
-
-        Uint32 evicted = 0;
-        for (auto it = m_cache.begin(); it != m_cache.end();) {
-            if (m_frameCounter - it->second.lastUsedFrame > kRetireAgeFrames) {
-                if (it->second.pipeline != VK_NULL_HANDLE) {
-                    vkDestroyPipeline(m_device, it->second.pipeline, nullptr);
-                }
-                it = m_cache.erase(it);
-                ++evicted;
-            } else {
-                ++it;
-            }
-        }
-        if (evicted > 0) {
-            MGLOG_D("PipelineFactory::OnFrameBoundary: evicted %u idle pipelines (%zu remain)", evicted,
-                    m_cache.size());
-        }
-        return evicted;
-    }
-
-    Uint32 PipelineFactory::EvictByRenderPasses(const Vector<VkRenderPass>& renderPasses) {
-        if (renderPasses.empty() || m_cache.empty()) {
-            return 0;
-        }
-        // Sorted-batch membership test keeps a mass eviction (shader-pack switch,
-        // dimension exit) at one O(cache * log batch) scan instead of one full scan
-        // per dying pass.
-        Vector<VkRenderPass> sortedPasses = renderPasses;
-        std::sort(sortedPasses.begin(), sortedPasses.end());
-        Uint32 evicted = 0;
-        for (auto it = m_cache.begin(); it != m_cache.end();) {
-            if (std::binary_search(sortedPasses.begin(), sortedPasses.end(), it->second.renderPass)) {
-                if (it->second.pipeline != VK_NULL_HANDLE) {
-                    vkDestroyPipeline(m_device, it->second.pipeline, nullptr);
-                }
-                it = m_cache.erase(it);
-                ++evicted;
-            } else {
-                ++it;
-            }
-        }
-        if (evicted > 0) {
-            MGLOG_D("PipelineFactory::EvictByRenderPasses: evicted %u pipelines for %zu destroyed render passes",
-                    evicted, sortedPasses.size());
-        }
-        return evicted;
-    }
-
-    Uint32 PipelineFactory::EvictByProgramHash(HashType programHash) {
-        Uint32 evicted = 0;
-        for (auto it = m_cache.begin(); it != m_cache.end();) {
-            if (it->second.programHash == programHash) {
-                if (it->second.pipeline != VK_NULL_HANDLE) {
-                    vkDestroyPipeline(m_device, it->second.pipeline, nullptr);
-                }
-                it = m_cache.erase(it);
-                ++evicted;
-            } else {
-                ++it;
-            }
-        }
-        if (evicted > 0) {
-            MGLOG_D("PipelineFactory::EvictByProgramHash: evicted %u pipelines for program hash 0x%llx",
-                    evicted, static_cast<unsigned long long>(programHash));
-        }
-        return evicted;
-    }
-
-    VkPipeline PipelineFactory::CreatePipeline(const PipelineCreatePayload& payload) const {
-        MOBILEGL_ASSERT(payload.stages != nullptr && !payload.stages->empty(), "PipelineFactory: stages are empty");
-        MOBILEGL_ASSERT(payload.vertexInputState != nullptr, "PipelineFactory: vertexInputState is null");
-        MOBILEGL_ASSERT(payload.pipelineLayout != VK_NULL_HANDLE, "PipelineFactory: pipelineLayout is null");
-        MOBILEGL_ASSERT(payload.renderPass != VK_NULL_HANDLE, "PipelineFactory: renderPass is null");
-        MOBILEGL_ASSERT(payload.colorAttachmentCount <= PipelineCreatePayload::kMaxColorAttachments,
-                "PipelineFactory: colorAttachmentCount=%u is unexpectedly large",
-                payload.colorAttachmentCount);
-        MGLOG_D("PipelineFactory::CreatePipeline: programHash=0x%llx vertexInputHash=0x%llx colorAttachmentCount=%u subpass=%u",
-            static_cast<unsigned long long>(payload.programHash),
-            static_cast<unsigned long long>(payload.vertexInputHash),
-            payload.colorAttachmentCount,
-            payload.subpass);
-
-        static constexpr VkDynamicState kDynamicStates[] = {
-            VK_DYNAMIC_STATE_VIEWPORT,
-            VK_DYNAMIC_STATE_SCISSOR,
-            VK_DYNAMIC_STATE_BLEND_CONSTANTS,
-            VK_DYNAMIC_STATE_DEPTH_BIAS,
-            VK_DYNAMIC_STATE_LINE_WIDTH,
-            VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
-            VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
-            VK_DYNAMIC_STATE_STENCIL_REFERENCE
-        };
-
-        VkPipelineDynamicStateCreateInfo dynamicState{};
-        dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
-        dynamicState.dynamicStateCount = static_cast<uint32_t>(std::size(kDynamicStates));
-        dynamicState.pDynamicStates = kDynamicStates;
-
-        VkPipelineInputAssemblyStateCreateInfo ia{VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO};
-        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};
-        // Both counts move together: GL has one scissor rectangle per viewport, and Vulkan
-        // requires viewportCount == scissorCount whenever both are dynamic
-        // (VUID-VkPipelineViewportStateCreateInfo-scissorCount-04136). The caller has already
-        // clamped this to the device's multiViewport capability.
-        vpci.viewportCount = std::max<Uint32>(payload.viewportCount, 1u);
-        vpci.scissorCount = vpci.viewportCount;
-
-        VkPipelineRasterizationStateCreateInfo raster{VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO};
-        raster.polygonMode = payload.polygonMode;
-        raster.cullMode = payload.cullMode;
-        raster.frontFace = payload.frontFace;
-        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;
-        ms.sampleShadingEnable = payload.sampleShadingEnable ? VK_TRUE : VK_FALSE;
-        // Ignored by Vulkan unless sampleShadingEnable is set, but written unconditionally so the
-        // struct's bytes match the hash the payload was keyed by.
-        ms.minSampleShading = payload.minSampleShading;
-        // GL_SAMPLE_MASK / glSampleMaski. Left at nullptr - which Vulkan reads as all-ones - until
-        // now, so glSampleMaski was a silent no-op on this backend while DirectGLES forwarded it.
-        // The pointer has to outlive the vkCreateGraphicsPipelines call, which the payload does.
-        ms.pSampleMask = payload.sampleMask;
-
-        VkPipelineDepthStencilStateCreateInfo depthStencil{VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO};
-        depthStencil.depthTestEnable = payload.depthTestEnable ? VK_TRUE : VK_FALSE;
-        depthStencil.depthWriteEnable = payload.depthWriteEnable ? VK_TRUE : VK_FALSE;
-        depthStencil.depthCompareOp = payload.depthCompareOp;
-        depthStencil.depthBoundsTestEnable = VK_FALSE;
-        depthStencil.stencilTestEnable = payload.stencilTestEnable ? VK_TRUE : VK_FALSE;
-        if (payload.stencilTestEnable) {
-            depthStencil.front.failOp = payload.frontStencilFailOp;
-            depthStencil.front.passOp = payload.frontStencilPassOp;
-            depthStencil.front.depthFailOp = payload.frontStencilDepthFailOp;
-            depthStencil.front.compareOp = payload.frontStencilCompareOp;
-            depthStencil.front.compareMask = 0xffffffffu;
-            depthStencil.front.writeMask = 0xffffffffu;
-            depthStencil.front.reference = 0;
-            depthStencil.back.failOp = payload.backStencilFailOp;
-            depthStencil.back.passOp = payload.backStencilPassOp;
-            depthStencil.back.depthFailOp = payload.backStencilDepthFailOp;
-            depthStencil.back.compareOp = payload.backStencilCompareOp;
-            depthStencil.back.compareMask = 0xffffffffu;
-            depthStencil.back.writeMask = 0xffffffffu;
-            depthStencil.back.reference = 0;
-        }
-
-        Vector<VkPipelineColorBlendAttachmentState> colorAttachments(payload.colorAttachmentCount);
-        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.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;
-        gpi.pDepthStencilState = &depthStencil;
-        gpi.pColorBlendState = &blend;
-        gpi.pDynamicState = &dynamicState;
-        gpi.layout = payload.pipelineLayout;
-        gpi.renderPass = payload.renderPass;
-        gpi.subpass = payload.subpass;
-
-        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),
-                    result,
-                    static_cast<unsigned long long>(payload.programHash),
-                    static_cast<unsigned long long>(payload.vertexInputHash),
-                    gpi.stageCount,
-                    PrimitiveTopologyToString(payload.topology),
-                    payload.topology,
-                    payload.colorAttachmentCount,
-                    SampleCountToString(payload.rasterizationSamples),
-                    payload.rasterizationSamples,
-                    payload.subpass);
-            MGLOG_F("PipelineFactory::CreatePipeline state: cullMode=%s(0x%x) frontFace=%d depthTest=%d depthWrite=%d depthCompare=%s(%d) depthBias=%d rasterizerDiscard=%d stencilTest=%d logicOpEnable=%d logicOp=%s(%d)",
-                    CullModeToString(payload.cullMode),
-                    static_cast<Uint32>(payload.cullMode),
-                    payload.frontFace,
-                    payload.depthTestEnable ? 1 : 0,
-                    payload.depthWriteEnable ? 1 : 0,
-                    CompareOpToString(payload.depthCompareOp),
-                    payload.depthCompareOp,
-                    payload.depthBiasEnable ? 1 : 0,
-                    payload.rasterizerDiscardEnable ? 1 : 0,
-                    payload.stencilTestEnable ? 1 : 0,
-                    payload.logicOpEnable ? 1 : 0,
-                    LogicOpToString(payload.logicOp),
-                    payload.logicOp);
-            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",
-                        i,
-                        attachment.blendEnable == VK_TRUE ? 1 : 0,
-                        static_cast<Uint32>(attachment.colorWriteMask),
-                        attachment.srcColorBlendFactor,
-                        attachment.dstColorBlendFactor,
-                        attachment.colorBlendOp,
-                        attachment.srcAlphaBlendFactor,
-                        attachment.dstAlphaBlendFactor,
-                        attachment.alphaBlendOp);
-            }
-        }
-        VK_VERIFY(result, "vkCreateGraphicsPipelines");
-        return pipeline;
-    }
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.h

@@ -1,205 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.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 "Config.h"
-#include "../VkIncludes.h"
-#include "MG_State/GLState/FramebufferState/FramebufferObject.h"
-#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;
-
-        struct PipelineCreatePayload {
-            static constexpr Uint32 kMaxColorAttachments = MG_State::GLState::FramebufferObject::MAX_DRAW_BUFFERS;
-
-            HashType programHash = 0;
-            HashType vertexInputHash = 0;
-            VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
-            VkRenderPass renderPass = VK_NULL_HANDLE;
-#if MOBILEGL_BUILD_DISAGGREGATED
-            // Nonzero is an exact, renderer-lifetime compatibility identity.
-            // renderPass remains the valid creation handle, not the cache key.
-            Uint64 wireRenderPassCompatibilityId = 0;
-#endif
-            Uint32 colorAttachmentCount = 1;
-            VkSampleCountFlagBits rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
-            // glEnable(GL_SAMPLE_SHADING) + glMinSampleShading, which Vulkan bakes into the
-            // pipeline rather than exposing as dynamic state - so both are part of the pipeline's
-            // identity and both are hashed. The renderer leaves the enable false unless the
-            // device's sampleRateShading feature was enabled
-            // (VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784).
-            Bool sampleShadingEnable = false;
-            Float minSampleShading = 0.0f;
-            // glEnable(GL_SAMPLE_MASK) + glSampleMaski, the fixed-function coverage mask, already
-            // reduced to what GL says this draw gets (VulkanRenderer::ResolveEffectiveSampleMask:
-            // all-ones unless the target is genuinely multisampled). Pipeline state like the two
-            // above - Vulkan has no dynamic sample mask before VK_EXT_extended_dynamic_state3 -
-            // so it is hashed with them, and all-ones has to keep producing the pipeline a null
-            // pSampleMask always did.
-            //
-            // TWO words, though GL only ever fills the first. GL_MAX_SAMPLE_MASK_WORDS is clamped
-            // to 1 on both backends, so glSampleMaski writes index 0 and nothing else - but the
-            // count Vulkan READS is ceil(rasterizationSamples / 32), which is 2 on a 64-sample
-            // target, and GetAdvertisedMaxSamples does not cap the driver's sample count. A
-            // single Uint32 here let such a pipeline read one word past the member (the next
-            // struct field). The second word is all-ones: full coverage for samples 32..63, which
-            // is the only honest answer when GL has no state describing them.
-            Uint32 sampleMask[2] = {0xffffffffu, 0xffffffffu};
-            Uint32 subpass = 0;
-            VkPrimitiveTopology topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-            Bool primitiveRestartEnable = false;
-            // GL_PATCH_VERTICES; only read for a PATCH_LIST topology.
-            Uint32 patchControlPoints = 3;
-            // ProgramFactory::ComputePassthroughTessControlKey of the synthesized pass-through
-            // tessellation control stage below, or 0 when this pipeline has none. Hashed, because
-            // the levels glPatchParameterfv set are compiled INTO that module and are not a
-            // function of the program or of patchControlPoints - see the note on
-            // passthroughTessControlStage.
-            Uint64 passthroughTessControlKey = 0;
-            // How many of ARB_viewport_array's viewports this pipeline rasterizes into. 1 for
-            // every program that never assigns gl_ViewportIndex, which is all of them outside the
-            // conformance suite - the wide shape costs a longer vkCmdSetViewport/Scissor per state
-            // change and can cost hardware fast paths, so it is opt-in per program. Baked into the
-            // pipeline (viewportCount is not dynamic without VK_EXT_extended_dynamic_state) and
-            // therefore hashed; the DYNAMIC viewport/scissor arrays the draw pushes must have
-            // exactly this many elements (VUID-vkCmdDraw-viewportCount-03417/-03418).
-            Uint32 viewportCount = 1;
-            VkPolygonMode polygonMode = VK_POLYGON_MODE_FILL;
-            VkCullModeFlags cullMode = VK_CULL_MODE_BACK_BIT;
-            VkFrontFace frontFace = VK_FRONT_FACE_CLOCKWISE;
-            // 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;
-            Bool rasterizerDiscardEnable = false;
-            Bool logicOpEnable = false;
-            Bool stencilTestEnable = false;
-            VkCompareOp depthCompareOp = VK_COMPARE_OP_ALWAYS;
-            VkLogicOp logicOp = VK_LOGIC_OP_COPY;
-            VkStencilOp frontStencilFailOp = VK_STENCIL_OP_KEEP;
-            VkStencilOp frontStencilPassOp = VK_STENCIL_OP_KEEP;
-            VkStencilOp frontStencilDepthFailOp = VK_STENCIL_OP_KEEP;
-            VkCompareOp frontStencilCompareOp = VK_COMPARE_OP_ALWAYS;
-            VkStencilOp backStencilFailOp = VK_STENCIL_OP_KEEP;
-            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 directly: it is a pure function of the program, of patchControlPoints and
-            // of the default tessellation levels - the first two of which ComputeHash already
-            // mixes in, and the third of which arrives through passthroughTessControlKey above.
-            VkPipelineShaderStageCreateInfo passthroughTessControlStage{};
-            const VkPipelineVertexInputStateCreateInfo* vertexInputState = nullptr;
-            // Diagnostic only; may be null. Read solely from the pipeline-creation failure path.
-            const Vector<ShaderStageSpirvDigest>* stageSpirvDigests = nullptr;
-        };
-
-        explicit PipelineFactory(VkDevice device, const VulkanRendererConfig& config);
-        ~PipelineFactory();
-        PipelineFactory(const PipelineFactory&) = delete;
-
-        HashType ComputeHash(const PipelineCreatePayload& payload) const;
-        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;
-        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

@@ -1,660 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.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 "../VkIncludes.h"
-#include "PipelineFactory.h"
-#include "MagmaProgramSource.h"
-#include "MG_State/GLState/ProgramState/ShaderObject.h"
-#include "MG_State/GLState/TextureState/TextureEnum.h"
-
-#include <Includes.h>
-#include <spirv_reflect.h>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    enum class SamplerNumericDomain : Uint8 {
-        Unknown = 0,
-        Float,
-        SignedInteger,
-        UnsignedInteger,
-    };
-
-    class ProgramFactory {
-    public:
-        enum class DescriptorBindingKind : Uint8 {
-            None = 0,
-            UniformBufferDynamic,
-            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
-        };
-
-        enum class CompileOptionBit : Uint {
-            None = 0,
-            PositionYFlip = 1 << 0,
-            PositionZRemap = 1 << 1,
-            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;
-
-        // The gl_PerVertex members a pass-through tessellation control stage may have to carry,
-        // in the order glslang declares them - which is the order a redeclaration must use.
-        // Which of them exist is a function of the neighbouring stage's GLSL VERSION
-        // (gl_CullDistance joins the block at #version 450), so the mask is read off that
-        // stage's SPIR-V rather than assumed. See ReflectPerVertexInputMembers.
-        enum class PerVertexMemberBit : Uint32 {
-            Position = 1u << 0,
-            PointSize = 1u << 1,
-            ClipDistance = 1u << 2,
-            CullDistance = 1u << 3,
-        };
-        // What a program parsed below #version 450 carries, and the fallback when a module's
-        // block cannot be read.
-        static constexpr Uint32 kDefaultPerVertexMembers =
-            static_cast<Uint32>(PerVertexMemberBit::Position) | static_cast<Uint32>(PerVertexMemberBit::PointSize) |
-            static_cast<Uint32>(PerVertexMemberBit::ClipDistance);
-
-        struct UpdateAfterBindLimits {
-            Bool enabled = false;
-            Uint32 maxPerStageSamplers = 0;
-            Uint32 maxPerStageUniformBuffers = 0;
-            Uint32 maxPerStageStorageBuffers = 0;
-            Uint32 maxPerStageSampledImages = 0;
-            Uint32 maxPerStageStorageImages = 0;
-            Uint32 maxPerStageResources = 0;
-            Uint32 maxSetSamplers = 0;
-            Uint32 maxSetUniformBuffers = 0;
-            Uint32 maxSetUniformBuffersDynamic = 0;
-            Uint32 maxSetStorageBuffers = 0;
-            Uint32 maxSetStorageBuffersDynamic = 0;
-            Uint32 maxSetSampledImages = 0;
-            Uint32 maxSetStorageImages = 0;
-        };
-
-        struct VkProgramObject {
-            static constexpr Uint32 kMaxVertexInputLocations = 32;
-
-            HashType hash = 0;
-            Vector<VkPipelineShaderStageCreateInfo> stages;
-            Vector<VkShaderModule> modules;
-            // Parallel to stages; identifies the exact module bytes handed to the driver when a
-            // pipeline creation fails. Sixteen bytes per stage instead of keeping the SPIR-V.
-            Vector<ShaderStageSpirvDigest> stageSpirvDigests;
-
-            // Layout data (previously in separate VkProgramLayout)
-            VkDescriptorSetLayout descriptorSetLayout = VK_NULL_HANDLE;
-            // True only when this layout passed every descriptor-indexing feature and
-            // update-after-bind limit gate at reflection time. It controls both the
-            // layout/binding flags and the pool class used by UniformManager.
-            Bool usesUpdateAfterBind = false;
-            VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
-            Vector<DescriptorBindingKind> bindingKinds;
-            // The bindings this program actually declares, ascending. bindingKinds is sized to the
-            // 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{};
-            Uint32 activeFragmentOutputLocationMask = 0;
-            Array<GLenum, kMaxVertexInputLocations> fragmentOutputTypes{};
-            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;
-            // Some pre-rasterization stage assigns gl_ViewportIndex. Its pipeline declares
-            // viewportCount = the renderer's rasterizable viewport count instead of 1, and its
-            // draws push the whole viewport/scissor array; every other program keeps the
-            // single-viewport fast path untouched. Part of the program's identity (folded into
-            // the pipeline hash through programHash), so no memo can serve the wrong shape.
-            Bool writesViewportIndexBuiltin = false;
-            // This program has a tessellation EVALUATION stage and no tessellation CONTROL
-            // stage. GL allows that (4.6 core 11.2.2: with no control shader the input patch
-            // is passed through unmodified, the output patch size is PATCH_VERTICES, and the
-            // levels come from the PATCH_DEFAULT_*_LEVEL state); Vulkan does not - either both
-            // tessellation stages are present or neither
-            // (VUID-VkGraphicsPipelineCreateInfo-pStages-00730). So the draw path has to supply
-            // the pass-through stage GL describes; see GetOrCreatePassthroughTessControlStage.
-            // True when this program was built AS a transform-feedback capture variant but its
-            // last pre-rasterization module does NOT carry the Xfb execution mode - so the
-            // renderer must decline the capture span instead of issuing
-            // vkCmdBeginTransformFeedbackEXT against it
-            // (VUID-vkCmdBeginTransformFeedbackEXT-None-04128).
-            //
-            // Two ways to get here, and neither is visible from GL state, which is all
-            // BeginXfbCaptureForDraw otherwise consults: the clip/XFB validation backstop had to
-            // rewind past the capture decoration, or XfbCaptureDecoratePass resolved none of the
-            // requested varyings and returned without changing anything (its own MGLOG_E path)
-            // while its runner still reported success. Both used to ship a non-Xfb module under
-            // an Xfb-flagged cache entry - the flag and the layout are part of the program cache
-            // key, so it was sticky for every later captured draw of the program, not a glitch.
-            Bool xfbCaptureDeclined = false;
-            // The program has a tessellation or geometry module declaring TessellationPointSize /
-            // GeometryPointSize on a device whose shaderTessellationAndGeometryPointSize feature
-            // is off, so a pipeline built from it is invalid usage
-            // (VUID-RuntimeSpirv-PointSize-06439). Its draws are refused in SetupDraw rather than
-            // handed to the driver - the same contract PipelineFactory's half-tessellated refusal
-            // implements one level up, and the counterpart of the DirectGLES arm that reports a
-            // driver with neither point-size extension by name.
-            //
-            // Sticky by construction, which is what makes ONE log line honest: the flag lives on
-            // the cache entry, so every later draw of the same program variant reads the same
-            // answer instead of re-deciding it.
-            Bool pointSizeCapabilityUnsupported = false;
-            Bool needsPassthroughTessControl = false;
-            // ...and the pass-through this renderer can synthesize carries gl_Position and
-            // nothing else, so it is only correct when the evaluation stage's inputs are
-            // built-ins. A user-defined varying would arrive at the evaluation stage
-            // UNWRITTEN once a control stage sits between it and the vertex stage, which is
-            // silently wrong pixels rather than a crash - so those programs are declined
-            // instead (PipelineFactory::CreatePipeline refuses the pipeline and the draw is
-            // skipped). See ReflectPassthroughTessControlNeed.
-            Bool passthroughTessControlEmulatable = false;
-            // Which gl_PerVertex members the evaluation stage's `in gl_PerVertex gl_in[]` block
-            // actually carries, as a PerVertexMemberBit mask read off its SPIR-V. The synthesized
-            // control stage has to redeclare the SAME shape: glslang appends gl_CullDistance to
-            // that block from #version 450 upward, so a 450/460 program - and every ESSL program,
-            // which the source processor rewrites to "#version 460 core" - carries four members
-            // where a 430 program carries three. A fixed three-member pass-through fed the
-            // evaluation stage a differently-shaped block, which is the black-frame-no-error case
-            // this whole family is written around.
-            Uint32 passthroughPerVertexMembers = 0;
-            // Frame-boundary counter value of the last GetOrCreateProgram hit; drives
-            // cache eviction (see OnFrameBoundary). Mutable: the draw snapshot's memoised
-            // entry pointer re-stamps use through a const reference (StampProgramUse).
-            mutable Uint64 lastUsedFrame = 0;
-
-            static inline VkDevice s_device = VK_NULL_HANDLE;
-
-            VkProgramObject() = default;
-            VkProgramObject(const VkProgramObject&) = delete;
-            VkProgramObject& operator=(const VkProgramObject&) = delete;
-            VkProgramObject(VkProgramObject&& other) noexcept {
-                hash = other.hash;
-                stages = std::move(other.stages);
-                modules = std::move(other.modules);
-                // Must travel with `modules`: these digests name the SPIR-V those exact
-                // shader modules were built from, and the pipeline-failure diagnostics
-                // print the two together. Leaving it behind used to merely lose the
-                // digests on a rehash; now that the cache is a robin-hood table, insertion
-                // SWAPS two entries, and a field that no move touches stays behind in the
-                // slot - pairing one program's modules with another program's digests, so
-                // a pipeline failure would be reported against the wrong SPIR-V.
-                stageSpirvDigests = std::move(other.stageSpirvDigests);
-                descriptorSetLayout = other.descriptorSetLayout;
-                usesUpdateAfterBind = other.usesUpdateAfterBind;
-                pipelineLayout = other.pipelineLayout;
-                bindingKinds = std::move(other.bindingKinds);
-                activeBindings = std::move(other.activeBindings);
-                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);
-                samplerNumericDomainByBinding = std::move(other.samplerNumericDomainByBinding);
-                storageImageFormatByBinding = std::move(other.storageImageFormatByBinding);
-                storageImageUsesBindingFormatByBinding =
-                    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;
-                activeFragmentOutputLocationMask = other.activeFragmentOutputLocationMask;
-                fragmentOutputTypes = other.fragmentOutputTypes;
-                rasterizationProducerStage = other.rasterizationProducerStage;
-                producerOutputComponentCount = other.producerOutputComponentCount;
-                fragmentInputComponentCount = other.fragmentInputComponentCount;
-                fragmentReplacesDepth = other.fragmentReplacesDepth;
-                readsBaseVertexBuiltin = other.readsBaseVertexBuiltin;
-                writesViewportIndexBuiltin = other.writesViewportIndexBuiltin;
-                needsPassthroughTessControl = other.needsPassthroughTessControl;
-                passthroughTessControlEmulatable = other.passthroughTessControlEmulatable;
-                passthroughPerVertexMembers = other.passthroughPerVertexMembers;
-                lastUsedFrame = other.lastUsedFrame;
-                other.hash = 0;
-                other.descriptorSetLayout = VK_NULL_HANDLE;
-                other.usesUpdateAfterBind = false;
-                other.pipelineLayout = VK_NULL_HANDLE;
-                other.hasStorageImages = false;
-                other.declinedDescriptors = false;
-                other.globalUboBinding = -1;
-                other.activeVertexInputLocationMask = 0;
-                other.activeFragmentOutputLocationMask = 0;
-                other.rasterizationProducerStage = ShaderStage::Unknown;
-                other.producerOutputComponentCount = 0;
-                other.fragmentInputComponentCount = 0;
-                other.fragmentReplacesDepth = false;
-                other.readsBaseVertexBuiltin = false;
-                other.writesViewportIndexBuiltin = false;
-                other.needsPassthroughTessControl = false;
-                other.passthroughTessControlEmulatable = false;
-                other.passthroughPerVertexMembers = 0;
-                other.lastUsedFrame = 0;
-            }
-            VkProgramObject& operator=(VkProgramObject&& other) noexcept {
-                if (this == &other) {
-                    return *this;
-                }
-                Destroy();
-                hash = other.hash;
-                stages = std::move(other.stages);
-                modules = std::move(other.modules);
-                stageSpirvDigests = std::move(other.stageSpirvDigests); // travels with `modules` - see the move ctor
-                descriptorSetLayout = other.descriptorSetLayout;
-                usesUpdateAfterBind = other.usesUpdateAfterBind;
-                pipelineLayout = other.pipelineLayout;
-                bindingKinds = std::move(other.bindingKinds);
-                activeBindings = std::move(other.activeBindings);
-                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);
-                samplerNumericDomainByBinding = std::move(other.samplerNumericDomainByBinding);
-                storageImageFormatByBinding = std::move(other.storageImageFormatByBinding);
-                storageImageUsesBindingFormatByBinding =
-                    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;
-                activeFragmentOutputLocationMask = other.activeFragmentOutputLocationMask;
-                fragmentOutputTypes = other.fragmentOutputTypes;
-                rasterizationProducerStage = other.rasterizationProducerStage;
-                producerOutputComponentCount = other.producerOutputComponentCount;
-                fragmentInputComponentCount = other.fragmentInputComponentCount;
-                fragmentReplacesDepth = other.fragmentReplacesDepth;
-                readsBaseVertexBuiltin = other.readsBaseVertexBuiltin;
-                writesViewportIndexBuiltin = other.writesViewportIndexBuiltin;
-                needsPassthroughTessControl = other.needsPassthroughTessControl;
-                passthroughTessControlEmulatable = other.passthroughTessControlEmulatable;
-                passthroughPerVertexMembers = other.passthroughPerVertexMembers;
-                lastUsedFrame = other.lastUsedFrame;
-                other.hash = 0;
-                other.descriptorSetLayout = VK_NULL_HANDLE;
-                other.usesUpdateAfterBind = false;
-                other.pipelineLayout = VK_NULL_HANDLE;
-                other.hasStorageImages = false;
-                other.declinedDescriptors = false;
-                other.globalUboBinding = -1;
-                other.activeVertexInputLocationMask = 0;
-                other.activeFragmentOutputLocationMask = 0;
-                other.rasterizationProducerStage = ShaderStage::Unknown;
-                other.producerOutputComponentCount = 0;
-                other.fragmentInputComponentCount = 0;
-                other.fragmentReplacesDepth = false;
-                other.readsBaseVertexBuiltin = false;
-                other.writesViewportIndexBuiltin = false;
-                other.needsPassthroughTessControl = false;
-                other.passthroughTessControlEmulatable = false;
-                other.passthroughPerVertexMembers = 0;
-                other.lastUsedFrame = 0;
-                return *this;
-            }
-
-            ~VkProgramObject() {
-                Destroy();
-            }
-
-        private:
-            void Destroy() {
-                if (s_device != VK_NULL_HANDLE) {
-                    if (pipelineLayout != VK_NULL_HANDLE) {
-                        vkDestroyPipelineLayout(s_device, pipelineLayout, nullptr);
-                        pipelineLayout = VK_NULL_HANDLE;
-                    }
-                    if (descriptorSetLayout != VK_NULL_HANDLE) {
-                        vkDestroyDescriptorSetLayout(s_device, descriptorSetLayout, nullptr);
-                        descriptorSetLayout = VK_NULL_HANDLE;
-                    }
-                    for (auto module : modules) {
-                        if (module != VK_NULL_HANDLE) {
-                            vkDestroyShaderModule(s_device, module, nullptr);
-                        }
-                    }
-                }
-                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;
-        };
-
-        // How this factory's compute modules implement GL_KHR_shader_subgroup. Computed
-        // once at renderer initialization (SubgroupSupportPolicy.h + the device's
-        // subgroup properties) so lowering can never disagree with the advertised
-        // capabilities. Native subgroup operations always execute natively; the two
-        // repair passes patch modules AROUND them, and the emulation only replaces them
-        // on opted-in devices with no subgroup support at all.
-        struct SubgroupLoweringPolicy {
-            Bool emulateSubgroups = false;      // MOBILEGL_MAGMA_EMULATE_SUBGROUP, no-native-support devices
-            Bool fixIterationRPSubgroupScratch = false; // patch iterationRP's under-declared scratch
-            Bool fixIterationRPBarrier = false; // repair Program 203's shared-scratch race
-            Bool deriveNumSubgroups = false;    // repair the NumSubgroups builtin
-            Bool requireFullSubgroups = false;  // computeFullSubgroups enabled on the device
-            Uint32 nativeSubgroupSize = 0;
-            // Full-subgroup launches are bounded by this device limit; a dispatch whose
-            // workgroup needs more subgroups than this cannot request the flag.
-            Uint32 maxComputeWorkgroupSubgroups = 0;
-            // VkPhysicalDeviceLimits::maxComputeSharedMemorySize; bounds the scratch the
-            // emulation pass may add (0 falls back to the Vulkan minimum, 16384).
-            Uint32 maxComputeSharedMemoryBytes = 0;
-        };
-
-        explicit ProgramFactory(VkDevice device, const VulkanRendererConfig& config, Uint32 maxBindings,
-                                Bool shaderDrawParametersEnabled,
-                                Bool unformattedFloatStorageImagesEnabled,
-                                Bool tessellationAndGeometryPointSizeEnabled,
-                                Bool enableSpirvValidation,
-                                UpdateAfterBindLimits updateAfterBindLimits,
-                                SubgroupLoweringPolicy subgroupPolicy)
-            : m_device(device), m_maxBindings(maxBindings), m_config(config),
-              m_shaderDrawParametersEnabled(shaderDrawParametersEnabled),
-              m_unformattedFloatStorageImagesEnabled(unformattedFloatStorageImagesEnabled),
-              m_tessellationAndGeometryPointSizeEnabled(tessellationAndGeometryPointSizeEnabled),
-              m_enableSpirvValidation(enableSpirvValidation),
-              m_updateAfterBindLimits(updateAfterBindLimits),
-              m_subgroupPolicy(subgroupPolicy) {
-            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(const ProgramFactory&) = delete;
-
-        HashType ComputeHash(const MagmaProgramSource& program, CompileOptionFlags flags) const;
-        const VkProgramObject& GetOrCreateProgram(
-            const MagmaProgramSource& 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);
-        // The same question for an IMAGE uniform (`image2D`, `uimageBuffer`, ...), which the
-        // sampler form above deliberately does not answer. Kept separate rather than folded in
-        // because the two are asked in different places for different reasons: a sampler's domain
-        // decides a sampled VIEW format, an image's decides what a placeholder descriptor for an
-        // UNBOUND image unit must be (see UniformManager::AcquireUnboundTexelBufferView and
-        // GetUnboundStorageImageTexture) - a formatless `writeonly` declaration reflects no
-        // format at all, and the numeric domain is then the only thing that constrains it.
-        static SamplerNumericDomain UniformTypeToImageNumericDomain(GLenum glType);
-        // True when any entry point declares the DepthReplacing execution mode, i.e. the
-        // shader assigns gl_FragDepth. Exposed so the blended depth-write quirk's exemption
-        // can be pinned by tests. A false negative loses the exemption, so such a shader is
-        // 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);
-        // True when an entry point writes the ViewportIndex builtin (gl_ViewportIndex), i.e. when
-        // the program can route primitives to a viewport other than 0 and its pipeline therefore
-        // has to declare more than one. Asks about OUTPUT variables because that is the direction
-        // a pre-rasterization stage declares it in.
-        static Bool ReflectedWritesViewportIndexBuiltin(const SpvReflectShaderModule& reflectModule);
-        static Bool ReflectedDeclaresOutputBuiltin(const SpvReflectShaderModule& reflectModule, SpvBuiltIn builtin);
-
-        // The pass-through tessellation control stage GL 4.6 core 11.2.2 describes for a
-        // program that has an evaluation stage and no control stage, for an input patch of
-        // `patchVertices` control points. Returned BY VALUE (a stage description is a POD, and
-        // the cache below is a rehashing map, so a pointer into it would not survive the next
-        // distinct patch size). `.module == VK_NULL_HANDLE` means the stage could not be built:
-        // the caller then has no control stage to inject, and CreatePipeline refuses the
-        // pipeline rather than handing the driver a half-tessellated one.
-        //
-        // Keyed on the patch size, the six default tessellation levels AND the gl_PerVertex
-        // member set, because all three decide what the generator emits. The size comes from
-        // PATCH_VERTICES and the levels from PATCH_DEFAULT_OUTER_LEVEL / PATCH_DEFAULT_INNER_LEVEL
-        // - draw state rather than link state, and the CTS case that motivated this links at the
-        // default 3 and draws at 4. The member set comes from the neighbouring evaluation stage's
-        // own SPIR-V, so two programs at different GLSL versions need different modules. The
-        // pipeline cache re-keys on the same inputs, so the module a pipeline was built with is
-        // part of that pipeline's identity. Compiling is bounded by the number of distinct
-        // (size, levels, members) combinations a program draws with - one or two in practice -
-        // and only ever happens for the rare program that has no control stage at all.
-        VkPipelineShaderStageCreateInfo GetOrCreatePassthroughTessControlStage(Uint32 patchVertices,
-                                                                              const FloatVec4& defaultOuterLevel,
-                                                                              const FloatVec2& defaultInnerLevel,
-                                                                              Uint32 perVertexMembers);
-
-        // Source of the module above. Exposed for tests: the generated GLSL is the whole
-        // contract with the evaluation stage, so it is worth pinning independently of a device.
-        static String BuildPassthroughTessControlSource(Uint32 patchVertices, const FloatVec4& defaultOuterLevel,
-                                                        const FloatVec2& defaultInnerLevel, Uint32 perVertexMembers);
-
-        // The identity of one such module: everything the generator bakes in, folded into a
-        // 64-bit key over the raw bits (so -0.0 and +0.0 key apart, which is harmless, and NaN
-        // keys to itself, which is what matters). Shared with PipelineFactory, which mixes the
-        // same value into the pipeline hash so a pipeline can never be handed a module built for
-        // different levels or a different block shape.
-        static Uint64 ComputePassthroughTessControlKey(Uint32 patchVertices, const FloatVec4& defaultOuterLevel,
-                                                       const FloatVec2& defaultInnerLevel, Uint32 perVertexMembers);
-
-        // The PerVertexMemberBit mask of the INPUT per-vertex block a module declares, read
-        // straight out of its SPIR-V (OpMemberDecorate ... BuiltIn on the struct behind the one
-        // Input variable that is an array of a Block-decorated struct). Zero when the module has
-        // no such block. Exposed for tests, which is the only way to pin the shape agreement
-        // without a device.
-        static Uint32 ReflectPerVertexInputMembers(const Vector<Uint>& spirv);
-
-    private:
-        struct ProgramLookupCache {
-            const MG_State::GLState::ProgramObject* program = nullptr;
-            Uint32 backendStateVersion = 0;
-            CompileOptionFlags flags{};
-            HashType hash = 0;
-        };
-
-        static TextureTarget UniformTypeToTextureTarget(GLenum glType);
-        // `stages` is ALWAYS ProgramObject::GetLinkedShaderStages() - one entry per module of
-        // `spirv`, at the same index. Taking the stages rather than the shader objects is what
-        // keeps the program's live attach list, which is a longer and differently-indexed list
-        // the moment a glAttachShader lands after the link, from being passed here by mistake.
-        void ReflectVertexInputs(const Vector<ShaderStage>& stages,
-                     const Vector<Vector<Uint>>& spirv,
-                     VkProgramObject& entry) const;
-        void ReflectViewportIndexUsage(const Vector<ShaderStage>& stages,
-                                       const Vector<Vector<Uint>>& spirv,
-                                       VkProgramObject& entry) const;
-        void ReflectFragmentOutputs(const Vector<ShaderStage>& stages,
-                        const Vector<Vector<Uint>>& spirv,
-                        VkProgramObject& entry) const;
-        void ReflectLayout(const MagmaProgramSource& program, const Vector<Vector<Uint>>& spirv,
-                           VkProgramObject& entry) const;
-        // Fills needsPassthroughTessControl / passthroughTessControlEmulatable off the linked
-        // modules. Const and reflection-only: it decides nothing about the pipeline, it only
-        // records what the evaluation stage's input interface is made of.
-        void ReflectPassthroughTessControlNeed(const Vector<ShaderStage>& stages,
-                                               const Vector<Vector<Uint>>& spirv,
-                                               VkProgramObject& entry) const;
-
-        VkDevice m_device = VK_NULL_HANDLE;
-        Uint32 m_maxBindings = 0;
-        UnorderedMap<HashType, VkProgramObject> m_cache;
-        const VulkanRendererConfig& m_config;
-        // True when the device enabled shaderDrawParameters; gates the InstanceIndex rebase pass
-        // (which needs the DrawParameters capability / gl_BaseInstance builtin).
-        Bool m_shaderDrawParametersEnabled = false;
-        // True only when the logical device enabled both
-        // shaderStorageImageReadWithoutFormat and shaderStorageImageWriteWithoutFormat.
-        Bool m_unformattedFloatStorageImagesEnabled = false;
-        // True when the logical device enabled shaderTessellationAndGeometryPointSize. When it is
-        // FALSE a program whose tessellation or geometry module declares TessellationPointSize /
-        // GeometryPointSize is refused at build time (see VkProgramObject::
-        // pointSizeCapabilityUnsupported) instead of being handed to the driver as invalid usage.
-        Bool m_tessellationAndGeometryPointSizeEnabled = false;
-        // Startup snapshot used only by internally synthesized shader modules, which do not
-        // originate from a ProgramLinkTask.
-        Bool m_enableSpirvValidation = false;
-        // Device feature and limit gate resolved before vkCreateDevice. Keeping it in
-        // the factory lets each reflected layout choose ordinary descriptors when its
-        // own counts would exceed the update-after-bind budget.
-        UpdateAfterBindLimits m_updateAfterBindLimits{};
-        SubgroupLoweringPolicy m_subgroupPolicy{};
-        // See SetDefaultFramebufferHeight. 0 means "not known yet"; the FragCoordYFlip bit is
-        // never set before the swapchain exists, so no variant can be compiled against it.
-        Uint32 m_defaultFramebufferHeight = 0;
-        mutable ProgramLookupCache m_lastLookup;
-        // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
-        Uint64 m_frameCounter = 0;
-        // See GetCacheStructureEpoch(). Starts at 1 so a zero-initialized memo can never match.
-        Uint64 m_cacheStructureEpoch = 1;
-        IEvictionObserver* m_evictionObserver = nullptr;
-        // Pass-through tessellation control stages by the identity of what was compiled into
-        // them - the input patch size and the six default tessellation levels, folded into one
-        // 64-bit key by ComputePassthroughTessControlKey (the levels are float state, so the map
-        // cannot simply be keyed on the patch size any more). A failed build is cached as
-        // VK_NULL_HANDLE so a broken generator costs one compile, not one per draw.
-        //
-        // Hard-capped, because the key is application-controlled: glPatchParameterfv clamps
-        // nothing, so an application that recomputes a level per frame mints a new key per frame.
-        // Reaching the cap destroys every module and starts over (see the flush in
-        // GetOrCreatePassthroughTessControlStage); the cap is far above what any program that
-        // holds its levels still will ever need. The gl_PerVertex member set is in the key too
-        // and adds only a handful of values, so it does not move the cap in practice.
-        static constexpr SizeT kMaxPassthroughTessControlStages = 64;
-        UnorderedMap<Uint64, VkPipelineShaderStageCreateInfo> m_passthroughTessControlStages;
-        static inline XXH64_state_t* m_hashState = XXH64_createState();
-    };
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/SubmitFencePrefix.h

@@ -1,41 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/SubmitFencePrefix.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 <cstdint>
-#include <vector>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-
-// Collect every fence in the ordered submission prefix. Waiting on only the last matching
-// frame-serial record is insufficient: the same serial may have an earlier in-flight submit.
-template <typename Records, typename Fence>
-bool CollectSubmitFencePrefix(const Records& records, std::uint64_t submitIndex,
-                              Fence nullFence, std::vector<Fence>& fences) {
-    fences.clear();
-    bool foundTarget = false;
-    for (const auto& record : records) {
-        if (record.submitIndex > submitIndex) {
-            break;
-        }
-        if (record.fence == nullFence) {
-            fences.clear();
-            return false;
-        }
-        fences.push_back(record.fence);
-        foundTarget = foundTarget || record.submitIndex == submitIndex;
-    }
-    if (!foundTarget) {
-        fences.clear();
-        return false;
-    }
-    return true;
-}
-
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/SwapchainObject.cpp

@@ -1,583 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/SwapchainObject.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 "SwapchainObject.h"
-
-#include <span>
-
-#include "MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h"
-#include "MG_State/GLState/TextureState/TextureObject2D.h"
-
-#if MOBILEGL_PIPE_PUSH
-// P5c ev: the surface-changed event's producer callback, installed by the server session.
-#include <MG_Pipe/MGPipeCallbacks.h>
-#endif
-
-#if defined(__has_include)
-#if __has_include(<vulkan/vk_enum_string_helper.h>)
-#include <vulkan/vk_enum_string_helper.h>
-#define MOBILEGL_HAS_VK_ENUM_STRING_HELPER 1
-#else
-#define MOBILEGL_HAS_VK_ENUM_STRING_HELPER 0
-#endif
-#else
-#define MOBILEGL_HAS_VK_ENUM_STRING_HELPER 0
-#endif
-
-#if !MOBILEGL_HAS_VK_ENUM_STRING_HELPER
-static const char* string_VkFormat(VkFormat) {
-    return "VkFormat(unknown)";
-}
-
-static const char* string_VkColorSpaceKHR(VkColorSpaceKHR) {
-    return "VkColorSpaceKHR(unknown)";
-}
-
-static const char* string_VkPresentModeKHR(VkPresentModeKHR presentMode) {
-    switch (presentMode) {
-    case VK_PRESENT_MODE_IMMEDIATE_KHR:
-        return "VK_PRESENT_MODE_IMMEDIATE_KHR";
-    case VK_PRESENT_MODE_MAILBOX_KHR:
-        return "VK_PRESENT_MODE_MAILBOX_KHR";
-    case VK_PRESENT_MODE_FIFO_KHR:
-        return "VK_PRESENT_MODE_FIFO_KHR";
-    case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
-        return "VK_PRESENT_MODE_FIFO_RELAXED_KHR";
-    default:
-        return "VkPresentModeKHR(unknown)";
-    }
-}
-
-static const char* string_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR) {
-    return "VkSurfaceTransformFlagBitsKHR(unknown)";
-}
-#endif
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    namespace {
-        Bool HasStencilComponent(VkFormat format) {
-            return format == VK_FORMAT_D24_UNORM_S8_UINT || format == VK_FORMAT_D32_SFLOAT_S8_UINT;
-        }
-
-        VkFormat FindSupportedDepthStencilFormat(VkPhysicalDevice physicalDevice) {
-            const VkFormat candidates[] = {VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT,
-                                           VK_FORMAT_D32_SFLOAT};
-            for (VkFormat format : candidates) {
-                VkFormatProperties props{};
-                vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &props);
-                if ((props.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0) {
-                    return format;
-                }
-            }
-            return VK_FORMAT_UNDEFINED;
-        }
-
-        Uint32 FindMemoryType(VkPhysicalDevice physicalDevice, Uint32 typeFilter, VkMemoryPropertyFlags properties) {
-            VkPhysicalDeviceMemoryProperties memProperties{};
-            vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties);
-
-            for (Uint32 i = 0; i < memProperties.memoryTypeCount; i++) {
-                if ((typeFilter & (1 << i)) &&
-                    (memProperties.memoryTypes[i].propertyFlags & properties) == properties) {
-                    return i;
-                }
-            }
-
-            MOBILEGL_ASSERT(false, "Failed to find suitable memory type.");
-            return 0;
-        }
-    } // namespace
-
-    SwapchainObject::SwapchainCapabilities SwapchainObject::GetSwapchainCapabilities(VkPhysicalDevice physicalDevice,
-                                                                                      VkSurfaceKHR surface) {
-        SwapchainCapabilities swapchainCapabilities{};
-
-        VK_VERIFY(
-            vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, &swapchainCapabilities.capabilities));
-
-        Uint32 formatCount = 0;
-        VK_VERIFY(vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &formatCount, nullptr));
-        if (formatCount != 0) {
-            swapchainCapabilities.surfaceFormats.resize(formatCount);
-            VK_VERIFY(vkGetPhysicalDeviceSurfaceFormatsKHR(
-                physicalDevice, surface, &formatCount, swapchainCapabilities.surfaceFormats.data()));
-        }
-
-        Uint32 presentModeCount = 0;
-        VK_VERIFY(
-            vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &presentModeCount, nullptr));
-        if (presentModeCount != 0) {
-            swapchainCapabilities.presentModes.resize(presentModeCount);
-            VK_VERIFY(vkGetPhysicalDeviceSurfacePresentModesKHR(
-                physicalDevice, surface, &presentModeCount, swapchainCapabilities.presentModes.data()));
-        }
-
-        return swapchainCapabilities;
-    }
-
-    VkSurfaceFormatKHR SwapchainObject::ChooseSwapchainSurfaceFormat(
-        const Vector<VkSurfaceFormatKHR>& availableFormats) {
-        for (const auto& availableFormat : availableFormats) {
-            if ((availableFormat.format == VK_FORMAT_B8G8R8A8_UNORM ||
-                 availableFormat.format == VK_FORMAT_R8G8B8A8_UNORM) &&
-                availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
-                return availableFormat;
-            }
-        }
-        for (const auto& availableFormat : availableFormats) {
-            if ((availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB ||
-                 availableFormat.format == VK_FORMAT_R8G8B8A8_SRGB) &&
-                availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
-                return availableFormat;
-            }
-        }
-
-        // TODO: Properly rank other formats
-        return availableFormats[0];
-    }
-
-    VkPresentModeKHR SwapchainObject::ChooseSwapchainPresentMode(
-        const Vector<VkPresentModeKHR>& availablePresentModes, Optional<Int> swapInterval) {
-        static constexpr VkPresentModeKHR s_unthrottledPresentModes[]{
-            VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR};
-        static constexpr VkPresentModeKHR s_vsyncPresentModes[]{VK_PRESENT_MODE_FIFO_KHR};
-        static constexpr VkPresentModeKHR s_adaptiveVsyncPresentModes[]{VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-                                                                         VK_PRESENT_MODE_FIFO_KHR};
-        std::span<const VkPresentModeKHR> ranked = s_desiredPresentModes;
-        if (swapInterval) {
-            if (*swapInterval == 0) {
-                ranked = s_unthrottledPresentModes;
-            } else if (*swapInterval > 0) {
-                ranked = s_vsyncPresentModes;
-            } else {
-                ranked = s_adaptiveVsyncPresentModes;
-            }
-        }
-        for (auto desiredPresentMode : ranked) {
-            if (std::find(availablePresentModes.begin(), availablePresentModes.end(), desiredPresentMode) !=
-                availablePresentModes.end()) {
-                return desiredPresentMode;
-            }
-        }
-
-        // TODO: Properly rank other modes
-        return availablePresentModes[0];
-    }
-
-    const char* SwapchainObject::GetPresentModeName(VkPresentModeKHR presentMode) {
-        return string_VkPresentModeKHR(presentMode);
-    }
-
-    void SwapchainObject::Create(VkDevice device, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                 Uint32 graphicsQueueFamily, Uint32 presentQueueFamily, Uint32 minImageCountHint,
-                                 VkExtent2D desiredExtent, Optional<Int> swapInterval) {
-        const auto swapchainCapabilities = GetSwapchainCapabilities(physicalDevice, surface);
-        MOBILEGL_ASSERT(swapchainCapabilities.IsComplete(),
-                        "SwapchainObject::Create failed: incomplete swapchain capabilities");
-
-        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));
-        }
-
-        const auto pickedSurfaceFormat = ChooseSwapchainSurfaceFormat(swapchainCapabilities.surfaceFormats);
-        MGLOG_I("Picked surface format: [%s, %s]", string_VkFormat(pickedSurfaceFormat.format),
-                string_VkColorSpaceKHR(pickedSurfaceFormat.colorSpace));
-
-        MGLOG_I("Got %d present modes:", swapchainCapabilities.presentModes.size());
-        for (const auto& pm : swapchainCapabilities.presentModes) {
-            MGLOG_D("    %s", string_VkPresentModeKHR(pm));
-        }
-
-        const auto presentMode = ChooseSwapchainPresentMode(swapchainCapabilities.presentModes, swapInterval);
-        MGLOG_I("Picked present mode: %s", string_VkPresentModeKHR(presentMode));
-        m_presentMode = presentMode;
-        m_supportedPresentModes = swapchainCapabilities.presentModes;
-
-        const auto& swapchainCaps = swapchainCapabilities.capabilities;
-        Uint32 targetImageCount = std::max<Uint32>(minImageCountHint, swapchainCaps.minImageCount);
-        if (swapchainCaps.maxImageCount != 0) {
-            targetImageCount = std::min(targetImageCount, swapchainCaps.maxImageCount);
-        }
-        MGLOG_I("Set minImageCount = %u", targetImageCount);
-        MGLOG_I("Swapchain currentTransform = %s",
-                string_VkSurfaceTransformFlagBitsKHR(swapchainCaps.currentTransform));
-
-        VkSwapchainCreateInfoKHR createInfo{VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR};
-        createInfo.surface = surface;
-        createInfo.minImageCount = targetImageCount;
-        createInfo.imageFormat = pickedSurfaceFormat.format;
-        createInfo.imageColorSpace = pickedSurfaceFormat.colorSpace;
-        createInfo.imageExtent = swapchainCaps.currentExtent;
-        if (createInfo.imageExtent.width == UINT32_MAX || createInfo.imageExtent.height == UINT32_MAX) {
-            createInfo.imageExtent.width = std::clamp(desiredExtent.width,
-                                                      swapchainCaps.minImageExtent.width,
-                                                      swapchainCaps.maxImageExtent.width);
-            createInfo.imageExtent.height = std::clamp(desiredExtent.height,
-                                                       swapchainCaps.minImageExtent.height,
-                                                       swapchainCaps.maxImageExtent.height);
-        }
-        const VkExtent2D defaultFramebufferExtent = createInfo.imageExtent;
-        if (swapchainCaps.currentTransform == VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR ||
-            swapchainCaps.currentTransform == VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) {
-            std::swap(createInfo.imageExtent.width, createInfo.imageExtent.height);
-        }
-
-        createInfo.imageArrayLayers = 1;
-        const VkImageUsageFlags requiredImageUsage =
-            VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-        MOBILEGL_ASSERT((swapchainCaps.supportedUsageFlags & requiredImageUsage) == requiredImageUsage,
-                        "Swapchain does not support required usage flags (COLOR_ATTACHMENT | TRANSFER_DST). "
-                        "supportedUsageFlags=0x%x",
-                        static_cast<Uint32>(swapchainCaps.supportedUsageFlags));
-
-        VkImageUsageFlags imageUsage = requiredImageUsage;
-        if ((swapchainCaps.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) != 0) {
-            imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-        }
-        createInfo.imageUsage = imageUsage;
-        MGLOG_I("Swapchain imageUsage = 0x%x (supportedUsageFlags = 0x%x)", static_cast<Uint32>(createInfo.imageUsage),
-                static_cast<Uint32>(swapchainCaps.supportedUsageFlags));
-        Uint32 queueFamilyIndices[] = {graphicsQueueFamily, presentQueueFamily};
-        if (graphicsQueueFamily != presentQueueFamily) {
-            createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
-            createInfo.queueFamilyIndexCount = 2;
-            createInfo.pQueueFamilyIndices = queueFamilyIndices;
-        } else {
-            createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
-            createInfo.queueFamilyIndexCount = 0;
-            createInfo.pQueueFamilyIndices = nullptr;
-        }
-        createInfo.preTransform = swapchainCaps.currentTransform;
-        MGLOG_I("Set swapchain preTransform = %s", string_VkSurfaceTransformFlagBitsKHR(createInfo.preTransform));
-        const VkCompositeAlphaFlagBitsKHR compositeAlphaCandidates[] = {
-            VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
-            VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
-            VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
-            VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
-        };
-        createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
-        for (auto candidate : compositeAlphaCandidates) {
-            if ((swapchainCaps.supportedCompositeAlpha & candidate) != 0) {
-                createInfo.compositeAlpha = candidate;
-                break;
-            }
-        }
-        createInfo.presentMode = presentMode;
-        createInfo.clipped = VK_TRUE;
-        createInfo.oldSwapchain = VK_NULL_HANDLE;
-
-        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));
-
-        Uint32 imageCount = 0;
-        VK_VERIFY(vkGetSwapchainImagesKHR(device, m_swapchain, &imageCount, nullptr));
-
-        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);
-
-        MGLOG_I("Swapchain created, extent = %dx%d, swapchain imageCount = %d", m_extent.width, m_extent.height,
-                imageCount);
-
-        // Properly initialize Default FBO here
-        auto& defaultFBOInfo = MG_Impl::GLImpl::FramebufferImpl::pDefaultFramebufferInfo;
-        const Int extentWidth = static_cast<Int>(defaultFramebufferExtent.width);
-        const Int extentHeight = static_cast<Int>(defaultFramebufferExtent.height);
-        const SizeT defaultAttachmentByteSize =
-            static_cast<SizeT>(defaultFramebufferExtent.width) *
-            static_cast<SizeT>(defaultFramebufferExtent.height) * 4;
-
-        TextureInternalFormat depthFormat = TextureInternalFormat::Depth24Stencil8;
-        switch (m_depthStencilFormat) {
-            case VK_FORMAT_D24_UNORM_S8_UINT:
-                depthFormat = TextureInternalFormat::Depth24Stencil8;
-                break;
-            case VK_FORMAT_D32_SFLOAT_S8_UINT:
-                depthFormat = TextureInternalFormat::Depth32FStencil8;
-                break;
-            case VK_FORMAT_D32_SFLOAT:
-                depthFormat = TextureInternalFormat::DepthComponent32F;
-                break;
-            default:
-                depthFormat = TextureInternalFormat::Depth24Stencil8;
-                break;
-        }
-
-        // The default FBO's stencil attachment must track the swapchain extent:
-        // FramebufferObject::CheckCompleteness requires every valid attachment
-        // to share the same dimensions, and Init.cpp leaves a 512x512 placeholder.
-        // Without this the retrace-layer glReadPixels snapshot fails with
-        // GL_INVALID_FRAMEBUFFER_OPERATION on DirectVulkan.
-        TextureInternalFormat stencilFormat = TextureInternalFormat::Depth24Stencil8;
-        switch (m_depthStencilFormat) {
-            case VK_FORMAT_D32_SFLOAT_S8_UINT:
-                stencilFormat = TextureInternalFormat::Depth32FStencil8;
-                break;
-            case VK_FORMAT_D24_UNORM_S8_UINT:
-                stencilFormat = TextureInternalFormat::Depth24Stencil8;
-                break;
-            default:
-                // No stencil plane; mirror the depth format for consistency.
-                stencilFormat = depthFormat;
-                break;
-        }
-
-#if MOBILEGL_PIPE_PUSH
-        if (MG_Pipe::gMGPipeCallbacks.OnSurfaceChanged != nullptr) {
-            // P5c ev (CONTRACT-P5C §4.2): with an active transport the default FBO's
-            // attachments are CLIENT memory and this thread may not write them - the backend
-            // fills MGPSurfaceInfo and posts, and the client's consumer replays exactly the
-            // allocate/format writes of the monolith arm below on the GL thread. The two
-            // formats are always equal by the switches above, so one InternalFormat carries
-            // both. The callback's presence IS the transport probe - the server session
-            // installs it at Accept, and under monolith nobody ever does.
-            MG_Pipe::MGPSurfaceInfo info{};
-            info.Width = defaultFramebufferExtent.width;
-            info.Height = defaultFramebufferExtent.height;
-            info.InternalFormat = static_cast<Uint32>(depthFormat);
-            info.Samples = 1;
-            info.Layers = 1;
-            info.IsDefault = 1;
-            MG_Pipe::gMGPipeCallbacks.OnSurfaceChanged(&info);
-        } else
-#endif
-        {
-            auto* colorTex = static_cast<MG_State::GLState::TextureObject2D*>(defaultFBOInfo->colorAttachment.get());
-            colorTex->AllocateStorage(
-                TextureUploadTarget::Texture2D, 0, {
-                    {extentWidth, extentHeight, 1},
-                    defaultAttachmentByteSize}); // TODO: 4 is format size
-            auto* depthTex = static_cast<MG_State::GLState::TextureObject2D*>(defaultFBOInfo->depthAttachment.get());
-            depthTex->SetInternalFormat(depthFormat);
-            depthTex->AllocateStorage(TextureUploadTarget::Texture2D, 0, {
-                {extentWidth, extentHeight, 1},
-                defaultAttachmentByteSize}); // TODO: 4 is format size
-
-            auto* stencilTex = static_cast<MG_State::GLState::TextureObject2D*>(defaultFBOInfo->stencilAttachment.get());
-            stencilTex->SetInternalFormat(stencilFormat);
-            stencilTex->AllocateStorage(TextureUploadTarget::Texture2D, 0, {
-                {extentWidth, extentHeight, 1},
-                defaultAttachmentByteSize}); // TODO: 4 is format size
-        }
-
-    }
-
-    void SwapchainObject::CreateDepthStencilResources(VkDevice device, VkPhysicalDevice physicalDevice) {
-        DestroyDepthStencilResources(device);
-
-        const auto imageCount = static_cast<Uint32>(m_images.size());
-        if (imageCount == 0) {
-            return;
-        }
-
-        m_depthStencilFormat = FindSupportedDepthStencilFormat(physicalDevice);
-        MOBILEGL_ASSERT(m_depthStencilFormat != VK_FORMAT_UNDEFINED, "No supported depth/stencil format found.");
-
-        m_depthStencilImages.assign(imageCount, VK_NULL_HANDLE);
-        m_depthStencilImageMemories.assign(imageCount, VK_NULL_HANDLE);
-        m_depthStencilImageViews.assign(imageCount, VK_NULL_HANDLE);
-        m_depthStencilImageLayouts.assign(imageCount, VK_IMAGE_LAYOUT_UNDEFINED);
-
-        for (Uint32 i = 0; i < imageCount; ++i) {
-            VkImageCreateInfo imageInfo{};
-            imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
-            imageInfo.imageType = VK_IMAGE_TYPE_2D;
-            imageInfo.extent.width = m_extent.width;
-            imageInfo.extent.height = m_extent.height;
-            imageInfo.extent.depth = 1;
-            imageInfo.mipLevels = 1;
-            imageInfo.arrayLayers = 1;
-            imageInfo.format = m_depthStencilFormat;
-            imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
-            imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-            imageInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-            imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
-            imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-            VK_VERIFY(vkCreateImage(device, &imageInfo, nullptr, &m_depthStencilImages[i]), "vkCreateImage(depth)");
-
-            VkMemoryRequirements memRequirements{};
-            vkGetImageMemoryRequirements(device, m_depthStencilImages[i], &memRequirements);
-
-            VkMemoryAllocateInfo allocInfo{};
-            allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
-            allocInfo.allocationSize = memRequirements.size;
-            allocInfo.memoryTypeIndex =
-                FindMemoryType(physicalDevice, memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-            VK_VERIFY(vkAllocateMemory(device, &allocInfo, nullptr, &m_depthStencilImageMemories[i]),
-                      "vkAllocateMemory(depth)");
-            VK_VERIFY(vkBindImageMemory(device, m_depthStencilImages[i], m_depthStencilImageMemories[i], 0),
-                      "vkBindImageMemory(depth)");
-
-            VkImageViewCreateInfo viewInfo{};
-            viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
-            viewInfo.image = m_depthStencilImages[i];
-            viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
-            viewInfo.format = m_depthStencilFormat;
-            viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-            if (HasStencilComponent(m_depthStencilFormat)) {
-                viewInfo.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
-            }
-            viewInfo.subresourceRange.baseMipLevel = 0;
-            viewInfo.subresourceRange.levelCount = 1;
-            viewInfo.subresourceRange.baseArrayLayer = 0;
-            viewInfo.subresourceRange.layerCount = 1;
-            VK_VERIFY(vkCreateImageView(device, &viewInfo, nullptr, &m_depthStencilImageViews[i]),
-                      "vkCreateImageView(depth)");
-        }
-    }
-
-    void SwapchainObject::DestroyDepthStencilResources(VkDevice device) {
-        for (auto view : m_depthStencilImageViews) {
-            if (view != VK_NULL_HANDLE) {
-                vkDestroyImageView(device, view, nullptr);
-            }
-        }
-        m_depthStencilImageViews.clear();
-
-        for (auto image : m_depthStencilImages) {
-            if (image != VK_NULL_HANDLE) {
-                vkDestroyImage(device, image, nullptr);
-            }
-        }
-        m_depthStencilImages.clear();
-
-        for (auto memory : m_depthStencilImageMemories) {
-            if (memory != VK_NULL_HANDLE) {
-                vkFreeMemory(device, memory, nullptr);
-            }
-        }
-        m_depthStencilImageMemories.clear();
-        m_depthStencilImageLayouts.clear();
-        m_depthStencilFormat = VK_FORMAT_UNDEFINED;
-    }
-
-    void SwapchainObject::Shutdown(VkDevice device) {
-        DestroyDepthStencilResources(device);
-
-        for (auto imageView : m_imageViews) {
-            vkDestroyImageView(device, imageView, nullptr);
-        }
-        m_imageViews.clear();
-
-        if (m_swapchain != VK_NULL_HANDLE) {
-            vkDestroySwapchainKHR(device, m_swapchain, nullptr);
-            m_swapchain = VK_NULL_HANDLE;
-        }
-
-        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];
-    }
-
-    VkImageLayout SwapchainObject::GetImageLayout(Uint32 index) const {
-        MOBILEGL_ASSERT(index < m_imageLayouts.size(), "Swapchain image layout index out of range");
-        return m_imageLayouts[index];
-    }
-
-    void SwapchainObject::SetImageLayout(Uint32 index, VkImageLayout layout) {
-        MOBILEGL_ASSERT(index < m_imageLayouts.size(), "Swapchain image layout index out of range");
-        m_imageLayouts[index] = layout;
-    }
-
-    VkImage SwapchainObject::GetDepthStencilImage(Uint32 index) const {
-        MOBILEGL_ASSERT(index < m_depthStencilImages.size(), "Swapchain depth/stencil image index out of range");
-        return m_depthStencilImages[index];
-    }
-
-    VkImageView SwapchainObject::GetDepthStencilImageView(Uint32 index) const {
-        MOBILEGL_ASSERT(index < m_depthStencilImageViews.size(),
-                        "Swapchain depth/stencil image view index out of range");
-        return m_depthStencilImageViews[index];
-    }
-
-    VkImageLayout SwapchainObject::GetDepthStencilImageLayout(Uint32 index) const {
-        MOBILEGL_ASSERT(index < m_depthStencilImageLayouts.size(),
-                        "Swapchain depth/stencil image layout index out of range");
-        return m_depthStencilImageLayouts[index];
-    }
-
-    void SwapchainObject::SetDepthStencilImageLayout(Uint32 index, VkImageLayout layout) {
-        MOBILEGL_ASSERT(index < m_depthStencilImageLayouts.size(),
-                        "Swapchain depth/stencil image layout index out of range");
-        m_depthStencilImageLayouts[index] = layout;
-    }
-
-    void SwapchainObject::CreateImageViews(VkDevice device) {
-        m_imageViews.resize(m_images.size(), VK_NULL_HANDLE);
-        for (SizeT i = 0; i < m_imageViews.size(); i++) {
-            VkImageViewCreateInfo createInfo{};
-            createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
-            createInfo.image = m_images[i];
-            createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
-            createInfo.format = m_surfaceFormat.format;
-            createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
-            createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
-            createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
-            createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
-            createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-            createInfo.subresourceRange.baseMipLevel = 0;
-            createInfo.subresourceRange.levelCount = 1;
-            createInfo.subresourceRange.baseArrayLayer = 0;
-            createInfo.subresourceRange.layerCount = 1;
-            VK_VERIFY(vkCreateImageView(device, &createInfo, nullptr, &m_imageViews[i]));
-        }
-        MGLOG_I("Swapchain image views created");
-    }
-
-#undef VK_VERIFY
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/SwapchainObject.h

@@ -1,110 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/SwapchainObject.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 "../VkIncludes.h"
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    class SwapchainObject {
-    public:
-        struct SwapchainCapabilities {
-            VkSurfaceCapabilitiesKHR capabilities;
-            Vector<VkSurfaceFormatKHR> surfaceFormats;
-            Vector<VkPresentModeKHR> presentModes;
-
-            Bool IsComplete() const {
-                return !surfaceFormats.empty() && !presentModes.empty();
-            }
-        };
-
-        static SwapchainCapabilities GetSwapchainCapabilities(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface);
-        static VkSurfaceFormatKHR ChooseSwapchainSurfaceFormat(const Vector<VkSurfaceFormatKHR>& availableFormats);
-        // swapInterval is the app's eglSwapInterval, empty until it asks (s_desiredPresentModes
-        // ranks the modes then). 0 wants IMMEDIATE, else MAILBOX, else FIFO; >= 1 wants FIFO,
-        // which cannot skip vblanks, so 2 and up pace like 1; a negative interval (adaptive
-        // vsync) wants FIFO_RELAXED, else FIFO.
-        static VkPresentModeKHR ChooseSwapchainPresentMode(const Vector<VkPresentModeKHR>& availablePresentModes,
-                                                           Optional<Int> swapInterval = Nullopt);
-        static const char* GetPresentModeName(VkPresentModeKHR presentMode);
-
-        void Create(VkDevice device, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, Uint32 graphicsQueueFamily,
-                    Uint32 presentQueueFamily, Uint32 minImageCountHint, VkExtent2D desiredExtent,
-                    Optional<Int> swapInterval);
-        void Shutdown(VkDevice device);
-
-        VkSwapchainKHR GetHandle() const { return m_swapchain; }
-        VkPresentModeKHR GetPresentMode() const { return m_presentMode; }
-        // The surface's present modes as queried when this swapchain was created.
-        const Vector<VkPresentModeKHR>& GetSupportedPresentModes() const { return m_supportedPresentModes; }
-        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; }
-        VkFormat GetDepthStencilFormat() const { return m_depthStencilFormat; }
-        const Vector<VkImageView>& GetDepthStencilImageViews() const { return m_depthStencilImageViews; }
-        VkImage GetDepthStencilImage(Uint32 index) const;
-        VkImageView GetDepthStencilImageView(Uint32 index) const;
-        VkImageLayout GetDepthStencilImageLayout(Uint32 index) const;
-        void SetDepthStencilImageLayout(Uint32 index, VkImageLayout layout);
-        VkImage GetImage(Uint32 index) const;
-        VkImageLayout GetImageLayout(Uint32 index) const;
-        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);
-        void DestroyDepthStencilResources(VkDevice device);
-        static constexpr VkPresentModeKHR s_desiredPresentModes[] {
-            VK_PRESENT_MODE_MAILBOX_KHR,
-            VK_PRESENT_MODE_IMMEDIATE_KHR,
-            VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-            VK_PRESENT_MODE_FIFO_KHR
-        };
-
-        VkSwapchainKHR m_swapchain = VK_NULL_HANDLE;
-        VkPresentModeKHR m_presentMode = VK_PRESENT_MODE_FIFO_KHR;
-        Vector<VkPresentModeKHR> m_supportedPresentModes;
-        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;
-        Vector<VkImageLayout> m_imageLayouts;
-
-        VkFormat m_depthStencilFormat = VK_FORMAT_UNDEFINED;
-        Vector<VkImage> m_depthStencilImages;
-        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

@@ -1,664 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/UniformDescriptorBinder.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 "ProgramFactory.h"
-#include "MagmaProgramSource.h"
-#include "VkBufferManager.h"
-#include "VkSamplerManager.h"
-#include "VkTextureManager.h"
-#include "WirePlaceholderKey.h"
-#include "../DescriptorPoolCensus.h"
-#include "../VkIncludes.h"
-#include <Includes.h>
-
-namespace MobileGL::MG_State::GLState {
-    class ITextureObject;
-    class ProgramObject;
-    class SamplerObject;
-}
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    class UniformManager {
-    public:
-        struct SamplerBindingOverride {
-            Uint32 binding = 0;
-            Uint32 element = 0;
-            MG_State::GLState::ITextureObject* texture = nullptr;
-            const MG_State::GLState::SamplerObject* sampler = nullptr;
-            VkImageView imageView = VK_NULL_HANDLE;
-            VkImageLayout imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-            Bool forceNearestFiltering = false;
-        };
-
-        struct SamplerImageFeedbackBinding {
-            Uint32 samplerBinding = 0;
-            Uint32 samplerElement = 0;
-            MG_State::GLState::ITextureObject* texture = nullptr;
-            const MG_State::GLState::SamplerObject* sampler = nullptr;
-            SamplerNumericDomain numericDomain = SamplerNumericDomain::Unknown;
-        };
-
-        // `physicalDevice` is only ever asked for format properties: a placeholder descriptor for
-        // an unbound texel-buffer binding has to be built from a format the DEVICE accepts as a
-        // texel buffer, and there is no other route to that answer from here.
-        Bool Initialize(VkDevice device, VkPhysicalDevice physicalDevice, VkBufferManager* bufferManager,
-                        ProgramFactory* programFactory,
-                        VkDeviceSize minUniformBufferOffsetAlignment, Uint32 frameCount,
-                        Uint32 maxBindings = 16, Uint32 setsPerFrame = 64,
-                        VkTextureManager* textureManager = nullptr, VkSamplerManager* samplerManager = nullptr);
-        void Shutdown();
-
-        void BeginFrame(Uint32 frameIndex);
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // A present-less wire frame may run arbitrarily many draws. Before its
-        // descriptor cursor reaches this budget, the renderer retires the
-        // submission that last used the sets and rewinds every layout cursor.
-        static constexpr Uint32 kWireDescriptorSetBudget = 2048;
-        Bool WireDescriptorSetBudgetReached(Uint32 frameIndex) const;
-        SizeT RewindWireDescriptorSets(Uint32 frameIndex);
-        // How the wire arm answers a STORAGE image unit that GL 4.6 core 8.26 makes invalid (no
-        // texture, or a (level, layer) its texture lacks): a load returns zero, a store and an
-        // atomic are discarded. `deviceNullDescriptor` is the renderer's enablement of
-        // VK_EXT_robustness2's nullDescriptor at device creation. With it the unit binds a NULL
-        // storage-image descriptor, which is exactly that rule. Without it (or under
-        // MGITEST_MAGMA_FORCE_PRIVATE_IMAGE_PLACEHOLDER=1, the host lanes' way onto this arm) the
-        // unit binds a placeholder PRIVATE to its unit (per shape), cleared before each use, so no
-        // two units ever alias; what that cannot give is a load of the SAME unit after its own
-        // store inside one pass reading zero, nor privacy past kWirePrivateStoragePlaceholderCap
-        // placeholders (CONTRACT-P7 §12). Called after Initialize.
-        void SetWireInvalidStorageImageArm(Bool deviceNullDescriptor);
-#endif
-        // 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 PER-LAYOUT eviction path for the
-        // caches - a live layout's entry must never be purged on its own (its sets would be
-        // unreachable pool slots), so there is deliberately no age-based sweep here. The
-        // other path, TrimFrameDescriptorPools, drops a slot's whole cache together with
-        // the pools behind it.
-        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 MagmaProgramSource& 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 MagmaProgramSource& program,
-                                      const ProgramFactory::VkProgramObject& programObj,
-                                      const Vector<SampledBindingRecord>& previousRecords) const;
-        Bool CollectStorageImageTextures(const MagmaProgramSource& program,
-                                         const ProgramFactory::VkProgramObject& programObj,
-                                         Vector<MG_State::GLState::ITextureObject*>& outTextures) const;
-        Bool CollectSamplerImageFeedback(
-            const MagmaProgramSource& program,
-            const ProgramFactory::VkProgramObject& programObj,
-            Vector<SamplerImageFeedbackBinding>& outBindings) const;
-        static Bool SamplerOverlapsWritableImageSubresource(Int samplerBaseLevel, Int samplerMaxLevel,
-                                                             GLint imageLevel, GLenum imageAccess);
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // Resolve lazy texture uploads/promotions before the caller captures the
-        // command buffer passed to BindProgramUniformBuffers. Preparation may
-        // submit older work, but descriptor recording must never rotate it.
-        Bool PrepareWireTextureResources(const MagmaProgramSource& program,
-                                          const ProgramFactory::VkProgramObject& programObj);
-#endif
-        // 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 MagmaProgramSource& program,
-                                       const ProgramFactory::VkProgramObject& programObj,
-                                       Uint32 frameIndex,
-                                       VkPipelineBindPoint bindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                       const SamplerBindingOverride* samplerBindingOverride = nullptr,
-                                       Bool samplerDescriptorsUnchangedHint = false,
-                                       const Vector<SamplerBindingOverride>* samplerBindingOverrides = nullptr);
-
-        // Pure format-policy helper kept public for host regression tests. Formatted storage
-        // images use their shader qualifier; transformed float images use glBindImageTexture's
-        // format and never silently fall back to the backing image format.
-        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 MagmaProgramSource& program,
-                                                          const ProgramFactory::VkProgramObject& programObj);
-
-        // ---- per-frame descriptor pools ----------------------------------------------------
-        // Each frame slot owns a list of pools. The first is the base pool (non-update-after-bind,
-        // setsPerFrame sets) and is never destroyed while the manager lives; every later one was
-        // added by GrowFrameDescriptorPool when an allocation found no room. A pool serves one
-        // updateAfterBind flavour, because a set can only come from a pool created with the flag
-        // its layout was.
-        struct DescriptorPoolBucket {
-            VkDescriptorPool handle = VK_NULL_HANDLE;
-            Uint32 maxSets = 0;
-            Uint32 allocatedSets = 0;
-            Bool updateAfterBind = false;
-        };
-        // One pool's maxSets never exceeds this. It bounds one pool's driver memory: CreateDescriptorPool
-        // declares 8 descriptors of each of 6 types per set, so a 4096-set pool asks for 196,608
-        // descriptors - about 12 MiB at 64 bytes each on a driver that backs every declared one.
-        static constexpr Uint32 kMaxDescriptorPoolSets = 4096;
-        // The growth policy, pure so the host tests can drive it: the size of the next pool a slot
-        // adds for `updateAfterBind` layouts, given the slot's existing pools. Twice the LARGEST pool
-        // of that flavour, capped at kMaxDescriptorPoolSets; `initialMaxSets` when the slot has no
-        // pool of that flavour yet. So a frame that needs N sets adds O(log N) pools while N stays
-        // under the cap, and one more pool per kMaxDescriptorPoolSets sets beyond it. Taking the
-        // largest (not the first) pool is the point: the first same-flavour pool is the oldest,
-        // smallest one, and doubling IT made every grown pool the same size.
-        static Uint32 NextDescriptorPoolMaxSets(const Vector<DescriptorPoolBucket>& pools, Bool updateAfterBind,
-                                                Uint32 initialMaxSets);
-        // Trim policy (see TrimFrameDescriptorPools). A slot is "quiet" in an epoch whose peak set
-        // count times kDescriptorTrimHeadroom still fits its capacity; a slot that has been quiet for
-        // MOBILEGL_MAGMA_DESCRIPTOR_TRIM_FRAMES consecutive epochs, and holds at least
-        // kDescriptorTrimMinCapacity sets, is trimmed. The headroom is what keeps the trim from
-        // thrashing: geometric growth leaves a re-grown slot at least a third full (the pool a growth
-        // adds is at most twice the largest before it, so at most twice everything the slot held, and
-        // the epoch that grew it needed more than that), so the epoch that grew a slot is never quiet
-        // for it. The floor keeps a slot sized for ordinary
-        // frames from being trimmed at all - the trim exists to give back a burst.
-        static constexpr Uint32 kDescriptorTrimHeadroom = 4;
-        static constexpr Uint32 kDescriptorTrimMinCapacity = 1024;
-        // For tests (DescriptorPoolCensus.h): pools, capacity, cached sets and trims over every slot.
-        DescriptorPoolCensus GetDescriptorPoolCensus() const;
-
-    private:
-
-        // 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;
-            Uint32 cursor = 0;
-        };
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // ResolveWireImageDescriptor emits no pNext chain. Key every view-create
-        // value explicitly: hash collisions must never alias different windows,
-        // formats or swizzles. The root handle and allocation epoch also prevent
-        // a recycled native image handle from reviving an older view.
-        struct WireImageViewKey {
-            MG_Pipe::MGPipeHandle root{};
-            VkImage image = VK_NULL_HANDLE;
-            Uint64 imageEpoch = 0;
-            VkImageViewCreateFlags flags = 0;
-            VkImageViewType type = VK_IMAGE_VIEW_TYPE_2D;
-            VkFormat format = VK_FORMAT_UNDEFINED;
-            VkComponentMapping components{};
-            VkImageSubresourceRange range{};
-
-            Bool operator==(const WireImageViewKey& other) const {
-                return root == other.root && image == other.image && imageEpoch == other.imageEpoch &&
-                       flags == other.flags && type == other.type && format == other.format &&
-                       components.r == other.components.r && components.g == other.components.g &&
-                       components.b == other.components.b && components.a == other.components.a &&
-                       range.aspectMask == other.range.aspectMask && range.baseMipLevel == other.range.baseMipLevel &&
-                       range.levelCount == other.range.levelCount && range.baseArrayLayer == other.range.baseArrayLayer &&
-                       range.layerCount == other.range.layerCount;
-            }
-        };
-
-        struct WireImageViewKeyHash {
-            SizeT operator()(const WireImageViewKey& key) const;
-        };
-
-        struct WirePlaceholderImage {
-            VkImage image = VK_NULL_HANDLE;
-            VkDeviceMemory memory = VK_NULL_HANDLE;
-            VkImageView view = VK_NULL_HANDLE;
-            VkSampler sampler = VK_NULL_HANDLE;
-            VkRenderPass clearPass = VK_NULL_HANDLE;
-            VkFramebuffer clearFramebuffer = VK_NULL_HANDLE;
-            VkFormat format = VK_FORMAT_UNDEFINED;
-            VkImageAspectFlags aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-            VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
-            VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
-            Uint32 layers = 1;
-        };
-        // Keyed by shape, and a storage placeholder on the arm without a null descriptor by its
-        // image unit too (WirePlaceholderKey.h: ChooseWirePlaceholderKey, and its cap).
-        mutable UnorderedMap<WirePlaceholderKey, WirePlaceholderImage, WirePlaceholderKeyHash> m_wirePlaceholderImages;
-        // How many of those are private to a unit (against kWirePrivateStoragePlaceholderCap).
-        mutable SizeT m_wirePrivateStoragePlaceholders = 0;
-        // See SetWireInvalidStorageImageArm.
-        Bool m_wireInvalidStorageImagesBindNull = false;
-        // boundStorageFormat: for a storage binding with no reflected format, the format the
-        // unit's glBindImageTexture named, when the unit holds a texture it cannot address
-        // (GL 4.6 core 8.26); UNDEFINED keeps the numeric-domain R32 default. `unit` is the image
-        // unit of a storage binding (what its private placeholder is private to); unused for a sampler.
-        Bool ResolveWirePlaceholderImage(VkCommandBuffer commandBuffer, const MagmaProgramSource& program,
-            const ProgramFactory::VkProgramObject& programObj, Uint32 binding, Bool storage,
-            VkDescriptorImageInfo& out, VkFormat boundStorageFormat = VK_FORMAT_UNDEFINED, Uint32 unit = ~0u) const;
-        void DestroyWirePlaceholderImage(WirePlaceholderImage& image) const;
-#endif
-
-        // descriptorSetCacheByLayout is the per-frame set cache: BeginFrame rewinds every cursor, so
-        // a slot re-writes the sets it allocated in earlier frames instead of allocating new ones, and
-        // the cache only ever grows - except through TrimFrameDescriptorPools, which gives a slot's
-        // whole burst back at once (and OnDescriptorSetLayoutDestroyed, one dead layout at a time).
-        struct FrameResources {
-            Vector<DescriptorPoolBucket> descriptorPools;
-            UnorderedMap<VkDescriptorSetLayout, DescriptorSetCacheEntry> descriptorSetCacheByLayout;
-            Vector<VkBufferView> texelBufferViews;
-#if MOBILEGL_BUILD_DISAGGREGATED
-            mutable Vector<VkImageView> wireImageViews;
-            // Own views in the vector above until this slot's fence/idle proof.
-            // Cache hits preserve the handle, enabling descriptor-content reuse.
-            mutable UnorderedMap<WireImageViewKey, VkImageView, WireImageViewKeyHash> wireImageViewCache;
-#endif
-            Uint32 activeDescriptorPoolIndex = 0;
-            Uint32 allocatedSetsThisFrame = 0;
-            Uint32 peakAllocatedSetsThisFrame = 0;
-            // Sum of maxSets over descriptorPools, kept in step by Initialize, Grow and Trim.
-            Uint64 capacitySets = 0;
-            // Consecutive epochs (see NoteEndedEpochForTrim) that were quiet for THIS slot's capacity.
-            Uint32 quietEpochs = 0;
-        };
-
-        static Bool ResolveSamplerTexture(const MagmaProgramSource& 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 MagmaProgramSource& 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 MagmaProgramSource& program,
-            const ProgramFactory::VkProgramObject& programObj, Uint32 binding, Uint32 element);
-        // `numericDomain` is the sampler's class, and it matters only for the multisample arm -
-        // see GetFallbackMultisampleTexture for why the single-sampled fallback can ignore it.
-        SharedPtr<MG_State::GLState::ITextureObject> GetFallbackTexture(
-            TextureTarget target, SamplerNumericDomain numericDomain) const;
-        // The multisample arm of GetFallbackTexture. One object per (target, numeric domain) and
-        // no upload path: a multisample image cannot be written by a transfer, so its texels stay
-        // undefined - which is what GL promises for a texelFetch on an incomplete multisample
-        // texture - and it cannot carry MUTABLE_FORMAT, so its format has to match the sampler's
-        // class outright rather than being reinterpreted at view time.
-        SharedPtr<MG_State::GLState::ITextureObject> GetFallbackMultisampleTexture(
-            TextureTarget target, SamplerNumericDomain numericDomain) const;
-        // ---- placeholders for UNBOUND image-backed descriptors -------------------------
-        // GL lets a program declare `samplerBuffer`, `imageBuffer` or `image2D` and bind nothing
-        // to the unit it names: the fetch is then undefined (GL 4.6 core 8.9 for an incomplete
-        // buffer texture, 8.26 for an image unit with no texture) - undefined VALUES, not a
-        // dropped draw. Vulkan has no unwritten descriptor, so something valid has to sit in the
-        // set or the whole draw or dispatch is lost, which is what these two build. Same shape as
-        // VkBufferManager::AcquireUnboundStorageDescriptor, one level up: per FORMAT rather than
-        // one shared object, because a descriptor whose format disagrees with the shader's
-        // declaration is invalid Vulkan even when nothing ever reads it.
-        //
-        // `declaredFormat` is the format the SHADER declared (VK_FORMAT_UNDEFINED for a sampled
-        // texel buffer, which never carries one, or for a formatless `writeonly` image);
-        // `numericDomain` decides the format when there is no declaration and is the fallback
-        // class when the device cannot use the declared one as a texel buffer.
-        VkBufferView AcquireUnboundTexelBufferView(VkFormat declaredFormat, SamplerNumericDomain numericDomain,
-                                                   Bool storage);
-        // A 1x1 (x1 layer, or 6 faces for a cube) texture of `format`, shaped for `target` so the
-        // view the descriptor gets has the view type the shader's image declaration demands.
-        // Null for a target with no single-sampled placeholder shape - multisample images, whose
-        // descriptor needs a multisample view that this cannot stand in for.
-        SharedPtr<MG_State::GLState::ITextureObject> GetUnboundStorageImageTexture(TextureTarget target,
-                                                                                    VkFormat format) const;
-        // The (target, format) pair a storage-image binding's placeholder is keyed by, resolved
-        // from reflection alone. False when the binding has no placeholder shape.
-        Bool ResolveUnboundStorageImagePlaceholder(const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                                   TextureTarget& outTarget, VkFormat& outFormat) const;
-        // `element` indexes a sampler ARRAY inside one binding; each element carries its own
-        // independently assigned GL texture unit, so it selects the texture, the sampler
-        // override and the fallback separately from its neighbours.
-        //
-        // 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 MagmaProgramSource& program,
-                                      const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                      Uint32 element, VkDescriptorImageInfo& outImageInfo,
-                                      Bool trustUnchangedHint = false) const;
-#if MOBILEGL_BUILD_DISAGGREGATED
-        Bool ResolveWireImageDescriptor(VkCommandBuffer commandBuffer, const MagmaProgramSource& program,
-                                       const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                       Uint32 element, Bool storage, VkDescriptorImageInfo& out) const;
-        Bool ResolveWireTexelBufferDescriptor(const MagmaProgramSource& program,
-                                             const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                             Uint32 frameIndex, Bool storage, VkBufferView& out);
-        Uint32 m_wireFrameIndex = 0;
-        VkDeviceSize m_wireStorageOffsetAlignment = 1;
-        VkDeviceSize m_wireTexelOffsetAlignment = 1;
-        VkDeviceSize m_wireMaxUniformRange = ~VkDeviceSize{0};
-        VkDeviceSize m_wireMaxStorageRange = ~VkDeviceSize{0};
-        Uint32 m_wireMaxTexelElements = ~Uint32{0};
-#endif
-        Bool ResolveSamplerDescriptorOverride(const SamplerBindingOverride& samplerBindingOverride,
-                                              VkDescriptorImageInfo& outImageInfo) const;
-        Bool ResolveTexelBufferDescriptor(const MagmaProgramSource& 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 MagmaProgramSource& 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 MagmaProgramSource& 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.
-        Bool ResolveStorageImageDescriptor(VkCommandBuffer commandBuffer,
-                                           const MagmaProgramSource& program,
-                                           const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                           Uint32 element, 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 {
-            Bool directBindable = false;
-            VkBuffer buffer = VK_NULL_HANDLE;
-            VkDeviceSize range = 0;         // reflected block size; constant across draws (hashed)
-            VkDeviceSize dynamicOffset = 0; // block range start; moves per draw (NOT hashed)
-            const void* payload = nullptr;  // fallback UploadTransient path
-            VkDeviceSize payloadSize = 0;
-        };
-#if MOBILEGL_BUILD_DISAGGREGATED
-        Bool ResolveWireUniformBufferPayload(const MagmaProgramSource& program, Uint32 blockIndex,
-                                             Uint32 bindingPoint, UboBindResult& out) const;
-#endif
-        Bool ResolveUniformBufferPayload(const MagmaProgramSource& 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 MagmaProgramSource& program,
-                                         const ProgramFactory::VkProgramObject& programObj, Uint32 binding,
-                                         Uint32 arrayElement, Uint32 frameIndex, VkBuffer& outBuffer,
-                                         VkDeviceSize& outRange, Uint32& outDynamicOffset);
-        // The vkCmdBindDescriptorSets tail shared by the full walk and the
-        // dynamic-offset-only rebind: skips the driver call when this exact
-        // binding is already live on the command buffer (see the bind-dedup
-        // shadow below), otherwise binds and refreshes the shadow.
-        void BindDescriptorSetDeduped(VkCommandBuffer commandBuffer, VkPipelineBindPoint bindPoint,
-                                      VkPipelineLayout pipelineLayout, VkDescriptorSet descriptorSet,
-                                      const Vector<Uint32>& dynamicOffsets);
-        Bool CreateDescriptorPool(Uint32 maxSets, Bool updateAfterBind, VkDescriptorPool& outPool) const;
-        Bool GrowFrameDescriptorPool(FrameResources& frame, Uint32 frameIndex, Bool updateAfterBind);
-        // An epoch is the stretch between two BeginFrame calls: one frame, or the part of one between
-        // two drains (VulkanRenderer::TryDrainFrameTransients). Called by BeginFrame with the epoch
-        // that just ended, it updates every slot's quiet count - a burst in any slot counts against
-        // all of them, so bursts that land in the other slots still hold a slot's trim off.
-        void NoteEndedEpochForTrim(Uint32 epochPeakSets);
-        // Gives a slot's whole descriptor burst back: clears its per-layout cache, destroys every
-        // grown pool and resets the base pool, so the slot re-grows geometrically from setsPerFrame.
-        // Whole-slot rather than per-set: vkFreeDescriptorSets fragments a pool and can never empty
-        // a grown one. Called only from BeginFrame, which runs only when no pending command buffer
-        // references the slot's sets:
-        //   - Present path (VulkanRenderer::Present, after WaitAndAcquireNextImage): the slot's
-        //     imageInFlightFence has been waited. That fence rides the slot's LAST submission - the
-        //     Present submit - and every mid-frame submission of the slot (FlushPendingCommands,
-        //     SplitOversizedRecording, readbacks) went to the same queue earlier, so the fence's
-        //     signal covers them (vkQueueSubmit's fence scope includes all earlier submissions).
-        //   - Drain path (VulkanRenderer::TryDrainFrameTransients): every submission has been
-        //     observed complete and no recording is open.
-        // Sets are per slot: a slot's sets are only ever bound into recordings made while it is the
-        // current slot, so trimming one slot never touches another slot's in-flight work.
-        void TrimFrameDescriptorPools(FrameResources& frame, Uint32 frameIndex);
-        // Drops every handle this class holds to a descriptor set outside the per-layout caches.
-        void InvalidateDescriptorSetMemos();
-        VkResult AllocateDescriptorSetsFromActivePool(
-            Uint32 frameIndex, const ProgramFactory::VkProgramObject& programObj, VkDescriptorSet& outDescriptorSet);
-        VkResult AcquireDescriptorSet(Uint32 frameIndex,
-                                      const ProgramFactory::VkProgramObject& programObj,
-                                      VkDescriptorSet& outDescriptorSet);
-
-        VkDevice m_device = VK_NULL_HANDLE;
-        VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
-        VkBufferManager* m_bufferManager = nullptr;
-        ProgramFactory* m_programFactory = nullptr;
-        Vector<FrameResources> m_frames;
-
-        VkDeviceSize m_minDynamicOffsetAlignment = 1;
-        Uint32 m_frameCount = 0;
-        Uint32 m_maxBindings = 0;
-        Uint32 m_setsPerFrame = 0;
-        Uint32 m_peakDescriptorSetsObserved = 0;
-        // MOBILEGL_MAGMA_DESCRIPTOR_TRIM_FRAMES, latched at Initialize (0 = never trim).
-        Uint32 m_trimQuietEpochs = 0;
-        // The slot whose epoch is open (the last one BeginFrame was called for); valid once
-        // m_epochOpen is set. Its peak is the ended epoch's peak at the next BeginFrame.
-        Uint32 m_epochSlot = 0;
-        Bool m_epochOpen = false;
-        Uint64 m_descriptorSlotTrims = 0;
-        VkTextureManager* m_textureManager = nullptr;
-        VkSamplerManager* m_samplerManager = nullptr;
-        mutable SharedPtr<MG_State::GLState::ITextureObject> m_fallbackTexture2D;
-        // Keyed by (arrayed, numeric domain); see GetFallbackMultisampleTexture. Lazily populated,
-        // never evicted - at most six tiny 1x1 images - and torn down with the manager.
-        mutable UnorderedMap<Uint32, SharedPtr<MG_State::GLState::ITextureObject>> m_fallbackMultisampleTextures;
-        // See AcquireUnboundTexelBufferView / GetUnboundStorageImageTexture. Both are lazily
-        // populated, never evicted (a program's declared formats are a fixed, tiny set) and torn
-        // down with the manager. The texel views are keyed by format AND by storage-vs-sampled
-        // because the two descriptor kinds demand different format FEATURES of the device, so one
-        // format can be usable for one and not the other. Deliberately NOT the per-frame
-        // texelBufferViews list: those are destroyed at every frame boundary, and these must
-        // outlive it or the placeholder would be rebuilt for every unbound binding every frame.
-        UnorderedMap<Uint64, VkBufferView> m_unboundTexelBufferViews;
-        mutable UnorderedMap<Uint64, SharedPtr<MG_State::GLState::ITextureObject>> m_unboundStorageImageTextures;
-
-        // Per-draw scratch buffers for BindProgramUniformBuffers: reused (clear keeps
-        // capacity) so the descriptor-write path stops allocating on every draw.
-        Vector<VkWriteDescriptorSet> m_writesScratch;
-        Vector<VkDescriptorBufferInfo> m_bufferInfosScratch;
-        Vector<VkDescriptorImageInfo> m_imageInfosScratch;
-        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.
-        // P7 M2 round 2 (ID-P7-43): a WIRE store can die MID-FRAME on the reclaim
-        // path (VkBufferManager::DeferredWireRelease), and the next mint can hand
-        // its VkBuffer handle value back - a heap pointer under lavapipe - so "the
-        // same VkBuffer+range" is no longer proof of the same store. The memo
-        // therefore records VkBufferManager::GetWireStoreDestroyEpoch() and misses
-        // once any wire store has been destroyed since; the descriptor-reuse
-        // signature below folds the same epoch in. On the wire arm this memo is
-        // never consulted (SetupWireDraw passes no sampler hint), so the field is
-        // the defensive half; the signature is the half the wire arm reaches.
-        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;
-#if MOBILEGL_BUILD_DISAGGREGATED
-            Uint64 wireStoreDestroyEpoch = 0;
-#endif
-        };
-        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;
-
-        // Per-binding fast path over VkSamplerManager's content-hashed sampler cache, which
-        // stays the source of truth: its key hashes all sampler+texture state, so two distinct
-        // sampler objects with identical state still resolve to one VkSampler. This memo only
-        // skips recomputing that hash. Across a draw batch the bound sampler set is stable, so a
-        // binding whose sampler (lifetime id + version, bumped on every setter) and texture
-        // (lifetime id + params version, bumped on the format/border-color setters that feed the
-        // key) are unchanged recycles the VkSampler it resolved last draw; a param change bumps
-        // a version and forces a re-resolve. Both objects are keyed by a never-reused monotonic
-        // lifetime id, so a freed-and-reallocated sampler or texture at the same heap address
-        // always gets a fresh id and misses (a raw pointer would false-hit that ABA) - so a
-        // stale guess can only miss and fall through to the hash, never resolve wrong. Still
-        // reset each frame alongside the descriptor-set cache. Indexed by binding, but the
-        // whole-descriptor entry is additionally keyed by program lifetime: Vulkan binding
-        // numbers are layout-local and unrelated programs routinely reuse binding 0/1.
-        struct SamplerResolveMemo {
-            Uint64 infoProgramLifetimeId = 0;
-            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/VertexInputStateBuilder.cpp

@@ -1,64 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateBuilder.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 "VertexInputStateBuilder.h"
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    VertexInputStateBuilder::VertexInputStateBuilder() {
-        Reset();
-    }
-
-    void VertexInputStateBuilder::Reset() {
-        m_bindings.clear();
-        m_attributes.clear();
-
-        m_state = {};
-        m_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
-        m_state.vertexBindingDescriptionCount = 0;
-        m_state.pVertexBindingDescriptions = nullptr;
-        m_state.vertexAttributeDescriptionCount = 0;
-        m_state.pVertexAttributeDescriptions = nullptr;
-    }
-
-    VertexInputStateBuilder& VertexInputStateBuilder::AddBinding(
-        Uint32 binding, Uint32 stride, VkVertexInputRate inputRate) {
-        VkVertexInputBindingDescription desc{};
-        desc.binding = binding;
-        desc.stride = stride;
-        desc.inputRate = inputRate;
-        m_bindings.push_back(desc);
-        return *this;
-    }
-
-    VertexInputStateBuilder& VertexInputStateBuilder::AddAttribute(
-        Uint32 location, Uint32 binding, VkFormat format, Uint32 offset) {
-        VkVertexInputAttributeDescription desc{};
-        desc.location = location;
-        desc.binding = binding;
-        desc.format = format;
-        desc.offset = offset;
-        m_attributes.push_back(desc);
-        return *this;
-    }
-
-    const VkPipelineVertexInputStateCreateInfo& VertexInputStateBuilder::Build() {
-        m_state.vertexBindingDescriptionCount = static_cast<Uint32>(m_bindings.size());
-        m_state.pVertexBindingDescriptions = m_bindings.empty() ? nullptr : m_bindings.data();
-        m_state.vertexAttributeDescriptionCount = static_cast<Uint32>(m_attributes.size());
-        m_state.pVertexAttributeDescriptions = m_attributes.empty() ? nullptr : m_attributes.data();
-        return m_state;
-    }
-
-    const Vector<VkVertexInputBindingDescription>& VertexInputStateBuilder::GetBindings() const {
-        return m_bindings;
-    }
-
-    const Vector<VkVertexInputAttributeDescription>& VertexInputStateBuilder::GetAttributes() const {
-        return m_attributes;
-    }
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateBuilder.h

@@ -1,31 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateBuilder.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_Backend::DirectVulkan {
-    class VertexInputStateBuilder {
-    public:
-        VertexInputStateBuilder();
-
-        void Reset();
-        VertexInputStateBuilder& AddBinding(
-            Uint32 binding, Uint32 stride, VkVertexInputRate inputRate = VK_VERTEX_INPUT_RATE_VERTEX);
-        VertexInputStateBuilder& AddAttribute(Uint32 location, Uint32 binding, VkFormat format, Uint32 offset);
-
-        const VkPipelineVertexInputStateCreateInfo& Build();
-        const Vector<VkVertexInputBindingDescription>& GetBindings() const;
-        const Vector<VkVertexInputAttributeDescription>& GetAttributes() const;
-
-    private:
-        VkPipelineVertexInputStateCreateInfo m_state{};
-        Vector<VkVertexInputBindingDescription> m_bindings;
-        Vector<VkVertexInputAttributeDescription> m_attributes;
-    };
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.cpp

@@ -1,865 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.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 "VertexInputStateFactory.h"
-#include "MagmaPipeArms.h"
-#include "MG_Util/Converters/MGToStr/DataTypeConverter.h"
-#include <MG_Backend/BackendObjects.h>
-#if MOBILEGL_BUILD_DISAGGREGATED
-#include <Config.h>
-#include <MG_Remote/Server/ServerLoop.h>
-#endif
-#include <utility>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    VertexInputStateFactory::HashType VertexInputStateFactory::ComputeHash(
-        const MG_State::GLState::VertexArrayObject& vao) const {
-        XXHASH_VERIFY(XXH64_reset(m_hashState, m_config.CacheVersion));
-
-        for (Int i = 0; i < MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS; ++i) {
-            const auto& attr = vao.GetAttribute(i);
-
-            XXHASH_VERIFY(XXH64_update(m_hashState, &attr.Enabled, sizeof(attr.Enabled)));
-            if (!attr.Enabled) {
-                continue;
-            }
-
-            XXHASH_VERIFY(XXH64_update(m_hashState, &attr.Size, sizeof(attr.Size)));
-            XXHASH_VERIFY(XXH64_update(m_hashState, &attr.Type, sizeof(attr.Type)));
-            XXHASH_VERIFY(XXH64_update(m_hashState, &attr.Normalized, sizeof(attr.Normalized)));
-            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.
-            //
-            // P2 D12.4 / ARCHITECTURE.md 9.5: under the handle arm the identity is the
-            // buffer's {slot, gen} rather than its lifetime id - "lifetimeId -> gen mixed
-            // into every server-side content hash". The two are equally ABA-proof (the
-            // allocator maps one onto the other and bumps Gen only on slot REUSE); what
-            // changes is that the key is now the identity the SERVER will be handed once
-            // buffers travel as handles, instead of a number only the client can mint.
-            Uint64 bufferKey = attr.Buffer ? attr.Buffer->GetLifetimeId() : 0;
-#if MOBILEGL_PIPE_PUSH
-            if (attr.Buffer) {
-                // The SAME arm question the other four re-keyed sites ask, through the same
-                // helper: a site that decided for itself could silently key on the pre-handle
-                // identity while its neighbours keyed on the handle.
-                if (MagmaPipeTrackHArmIsHandles(MG_Pipe::kMGPipeSubsystemMagmaVertexInput)) {
-                    const MG_Pipe::MGPipeHandle handle =
-                        m_identity->HandleOf(MG_Pipe::MGPipeKind::Buffer, attr.Buffer->GetLifetimeId());
-                    bufferKey = static_cast<Uint64>(handle.Slot) | (static_cast<Uint64>(handle.Gen) << 32);
-                }
-                if (MagmaPipeAbaControlDefeatsIdentity()) {
-                    // Negative control C (P2 brief D18), on WHICHEVER arm this run is on - the
-                    // pre-handle lifetime id and the handle's {slot, gen} are the same guard
-                    // wearing two hats, and a control that defeated only the retired one would
-                    // say nothing about the key P2 ships.
-                    //
-                    // The identity is replaced by a constant rather than by the raw
-                    // BufferObject*, because the address is not recycled in practice and so
-                    // never collides (see MagmaPipeAbaControlDefeatsIdentity). Zero is what a
-                    // key with NO buffer identity in it looks like - the exact defect this
-                    // hash was fixed for: "the hash is what TryBindResolvedVertexBindings
-                    // accepts as proof that a memoised binding still reads the buffer it was
-                    // resolved from", and with the identity gone it accepts a binding resolved
-                    // from a different buffer. HandleRecycleScenario.AbaControl then draws a
-                    // replacement VAO and gets its dead predecessor's vertex data.
-                    bufferKey = 0;
-                }
-            }
-#endif
-            XXHASH_VERIFY(XXH64_update(m_hashState, &bufferKey, sizeof(bufferKey)));
-        }
-
-        return XXH64_digest(m_hashState);
-    }
-
-#if MOBILEGL_PIPE_PUSH
-    VertexInputStateFactory::VaoBackendMemos& VertexInputStateFactory::MemosFor(
-        const MG_State::GLState::VertexArrayObject& vao) const {
-        const MG_Pipe::MGPipeHandle handle =
-            m_identity->HandleOf(MG_Pipe::MGPipeKind::VertexElementsCso, vao.GetLifetimeId());
-        // One entry per mintable slot, grown on demand: the mint has no capacity, so neither
-        // does this, and no two live VAOs can share an entry however large the working set is.
-        // There is no probe in front of it because the mint itself is one - a one-entry memo
-        // hit for every acquisition after this draw's first, and a hash probe otherwise.
-        //
-        // The claim rule - the slot picks the entry, the whole handle (Gen included) decides
-        // whose it is - and negative control C's defeat of it are MagmaPipeArms.h's
-        // MagmaPipeClaimSlotMemos, so that the unit suite which drives a REAL slot reuse
-        // (MG_Test/Pipe/MagmaPipeIdentityTest.cpp) exercises this code and not a copy of it.
-        // What the control defeats HERE is the identity that SELECTS the entry: every VAO
-        // collapses onto one, handed back uncleared, so the replacement inherits the dead
-        // VAO's content hash and its resolved-entry pointer. The GENERATION half is the unit
-        // suite's business, for the reason MagmaPipeAbaControlDefeatsIdentity spells out.
-        return MagmaPipeClaimSlotMemos(m_vaoMemos, handle);
-    }
-#endif
-
-#if MOBILEGL_PIPE_PUSH
-    Bool VertexInputStateFactory::TryGetMemoizedHash(const MG_State::GLState::VertexArrayObject& vao,
-                                                     Uint64& outHash) const {
-        if (MagmaPipeTrackHArmIsHandles(MG_Pipe::kMGPipeSubsystemMagmaVertexInput)) {
-            const VaoBackendMemos& memos = MemosFor(vao);
-            if (memos.HashConfigVersion != vao.GetConfigVersion()) return false;
-            outHash = memos.Hash;
-            return true;
-        }
-#if MOBILEGL_PIPE_LEGACY_MEMOS
-        return vao.GetBackendHashMemo(outHash);
-#else
-        return false;
-#endif
-    }
-#endif
-
-    VertexInputStateFactory::HashType VertexInputStateFactory::GetOrComputeHash(
-        const MG_State::GLState::VertexArrayObject& vao) const {
-        HashType hash = 0;
-#if MOBILEGL_PIPE_PUSH
-        // P2 D12.5: the same memo, on the backend's side of the boundary.
-        if (MagmaPipeTrackHArmIsHandles(MG_Pipe::kMGPipeSubsystemMagmaVertexInput)) {
-            VaoBackendMemos& memos = MemosFor(vao);
-            if (memos.HashConfigVersion == vao.GetConfigVersion()) {
-                return memos.Hash;
-            }
-            hash = ComputeHash(vao);
-            memos.Hash = hash;
-            memos.HashConfigVersion = vao.GetConfigVersion();
-            return hash;
-        }
-#endif
-#if MOBILEGL_PIPE_LEGACY_MEMOS
-        if (!vao.GetBackendHashMemo(hash)) {
-            hash = ComputeHash(vao);
-            vao.SetBackendHashMemo(hash);
-        }
-#endif
-        return hash;
-    }
-
-    const VertexInputStateFactory::BackendVertexInputState& VertexInputStateFactory::GetOrCreateVertexInputState(
-        const MG_State::GLState::VertexArrayObject& vao) {
-#if MOBILEGL_PIPE_PUSH
-        // P2 D12.5: the same per-draw fast path, but the resolved-entry pointer lives in this
-        // factory's slot-indexed table instead of on the frontend VAO. The eviction epoch
-        // survives the move and is still what stops a stale pointer being dereferenced: the
-        // POINTEE is a cache entry this factory can erase at a frame boundary, and moving the
-        // memo does not change that.
-        if (MagmaPipeTrackHArmIsHandles(MG_Pipe::kMGPipeSubsystemMagmaVertexInput)) {
-            VaoBackendMemos& memos = MemosFor(vao);
-            if (memos.StateConfigVersion == vao.GetConfigVersion() && memos.State != nullptr &&
-                memos.StateEpoch == m_evictionEpoch) {
-                const auto* memoEntry = static_cast<const BackendVertexInputState*>(memos.State);
-                memoEntry->lastUsedFrameBoundary = m_frameBoundaryCounter;
-                return *memoEntry;
-            }
-            const BackendVertexInputState& resolved =
-                GetOrCreateVertexInputState(vao, GetOrComputeHash(vao));
-            // MemosFor is re-taken rather than kept live across GetOrCreateVertexInputState:
-            // the reference is not worth holding across a call that can resize the table.
-            VaoBackendMemos& stamp = MemosFor(vao);
-            stamp.State = &resolved;
-            stamp.StateEpoch = m_evictionEpoch;
-            stamp.StateConfigVersion = vao.GetConfigVersion();
-            // The AUX memo is deliberately NOT stamped here: its two words already live in
-            // VulkanRenderer::VaoDrawMemo (layoutHash / layoutAuxMasks) and its getter has no
-            // live reader anywhere, so the handle arm retires it rather than moving it.
-            return resolved;
-        }
-#endif
-#if !MOBILEGL_PIPE_LEGACY_MEMOS
-        // Unreachable: with no legacy arm compiled MagmaPipeTrackHArmIsHandles is a compile-
-        // time true, so the handle arm above always returns. Written out rather than left to
-        // fall off the end so the function still has a return on every path a compiler sees.
-        return GetOrCreateVertexInputState(vao, GetOrComputeHash(vao));
-#else
-        // 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;
-#endif // MOBILEGL_PIPE_LEGACY_MEMOS
-    }
-
-    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;
-        }
-
-        VertexInputStateBuilder builder;
-        Vector<SizeT> bindingBufferKeys;
-        Vector<SizeT> bindingBaseOffsets;
-        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) {
-            const auto& attr = vao.GetAttribute(location);
-            if (!attr.Enabled) {
-                continue;
-            }
-
-            VkFormat sourceVkFormat =
-                ToVkVertexFormat(attr.Type, attr.Size, attr.Normalized, attr.IsInteger, attr.IsBgra, attr.IsLong);
-            VertexStreamConversion conversion = VertexStreamConversion::None;
-            // Gated on the SAME flag ToVkVertexFormat gates its 64-bit path on, and that is
-            // load-bearing rather than belt-and-braces: the narrowing is only correct because the
-            // shader's `dvec` input is a `vec` by the time the pipeline is built, and what
-            // guarantees that is the flag being clear. It is clear on every backend today, and a
-            // program with a 64-bit float vertex input is demoted WHOLE for the same reason even
-            // where the device has native fp64 (ProgramSpirvTask::GenerateSpirv). With the flag
-            // set, a dvec3/dvec4 would be declined by ToVkVertexFormat AND left 64-bit in the
-            // module, so a float32 stream would be fed to a Float64 input.
-            const Bool narrowFloat64Arrays =
-#if MOBILEGL_BUILD_DISAGGREGATED
-                // P5c (hd, CONTRACT-P5C §3.7): with an active transport the answer is the
-                // SERVER's own backend's - the client caps mirror is client memory (rule E).
-                MG_Config::Transport != MG_Config::TransportMode::Monolith
-                    ? (MG_Remote::Server::ServerLoopInstance().Backend() == nullptr ||
-                       !MG_Remote::Server::ServerLoopInstance().Backend()
-                            ->GetDynamicParameters()
-                            .SupportsFloat64VertexAttributes)
-                    :
-#endif
-                MG_Backend::pActiveBackendObject == nullptr ||
-                !MG_Backend::pActiveBackendObject->GetDynamicParameters().SupportsFloat64VertexAttributes;
-            if (sourceVkFormat == VK_FORMAT_UNDEFINED && attr.Type == DataType::Float64 && narrowFloat64Arrays) {
-                // No native 64-bit fetch here (see ToVkVertexFormat's Float64 case), but the
-                // source bytes are ordinary IEEE-754 doubles and DemoteFloat64Pass has already
-                // narrowed every dvec input to a vec, so the array is narrowed to match rather
-                // than dropped. Mirrors what DirectGLES does for the same state.
-                const VkFormat narrowedFormat = ToFloat32VertexFormat(attr.Size);
-                if (narrowedFormat != VK_FORMAT_UNDEFINED && SupportsVertexBufferFormat(narrowedFormat)) {
-                    sourceVkFormat = narrowedFormat;
-                    conversion = VertexStreamConversion::Float64ToFloat32;
-                    MGLOG_W_ONCE("Vertex attribute location=%u is a 64-bit (GL_DOUBLE) array; fetching it at "
-                            "float32 precision through format=%d (size=%d long=%s)",
-                            location, static_cast<Int>(narrowedFormat), attr.Size, attr.IsLong ? "true" : "false");
-                }
-            }
-            if (sourceVkFormat == VK_FORMAT_UNDEFINED) {
-                MGLOG_E_ONCE("Unsupported vertex attribute layout (location=%u, type=%s, size=%d): the array is "
-                        "enabled but cannot be mapped to a VkFormat",
-                        location, MG_Util::ConvertDataTypeToString(attr.Type).c_str(), attr.Size);
-                unsupportedAttribMask |= (1u << location);
-                continue;
-            }
-
-            VkFormat vkFormat = sourceVkFormat;
-            if (conversion == VertexStreamConversion::None && !SupportsVertexBufferFormat(vkFormat)) {
-                if (IsScaledIntegerVertexFormat(vkFormat)) {
-                    const VkFormat fallbackFormat = ToFloat32VertexFormat(attr.Size);
-                    if (fallbackFormat != VK_FORMAT_UNDEFINED && SupportsVertexBufferFormat(fallbackFormat)) {
-                        vkFormat = fallbackFormat;
-                        conversion = VertexStreamConversion::ScaledIntegerToFloat32;
-                        MGLOG_W_ONCE("Vertex attribute location=%u format=%d lacks "
-                                "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),
-                                MG_Util::ConvertDataTypeToString(attr.Type).c_str(), attr.Size,
-                                attr.Normalized ? "true" : "false", attr.IsInteger ? "true" : "false");
-                    }
-                }
-
-                if (conversion == VertexStreamConversion::None) {
-                    MGLOG_E_ONCE("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);
-                    unsupportedAttribMask |= (1u << location);
-                    continue;
-                }
-            }
-
-            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 "
-                        "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 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))) {
-                // 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 "
-                        "(offset=%zu stride=%u required=%zu); using a tightly packed stream",
-                        location, attr.Offset, sourceStride, requiredAlignment);
-            }
-
-            Uint32 stride = sourceStride;
-            // A converted stream is tightly packed, so its stride is the converted element
-            // size - unless the source stride is zero, which does not describe a packing at
-            // all but "never advance". That survives the conversion unchanged: the draw path
-            // converts exactly one element and every vertex reads it.
-            if (sourceStride != 0) {
-                if (conversion == VertexStreamConversion::Repack) {
-                    stride = static_cast<Uint32>(attribByteSize);
-                } else if (conversion == VertexStreamConversion::ScaledIntegerToFloat32 ||
-                           conversion == VertexStreamConversion::Float64ToFloat32) {
-                    stride = static_cast<Uint32>(attr.Size * static_cast<Int>(sizeof(Float)));
-                }
-            }
-            const VkVertexInputRate inputRate =
-                (attr.Divisor == 0) ? VK_VERTEX_INPUT_RATE_VERTEX : VK_VERTEX_INPUT_RATE_INSTANCE;
-
-            const SizeT bufferKey = reinterpret_cast<SizeT>(attr.Buffer.get());
-            const Uint32 binding = static_cast<Uint32>(bindingBufferKeys.size());
-            bindingBufferKeys.push_back(bufferKey);
-            bindingBaseOffsets.push_back(attr.Buffer ? attr.Offset : 0);
-            bindingAttributeLocations.push_back(location);
-            bindingUsesClientMemory.push_back(attr.Buffer == nullptr);
-            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;
-        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);
-        entry.bindingUsesClientMemory = std::move(bindingUsesClientMemory);
-        entry.bindingConversions = std::move(bindingConversions);
-        entry.unsupportedAttribMask = unsupportedAttribMask;
-        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;
-    }
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-    Bool VertexInputStateFactory::BuildWireVertexInput(const MG_Pipe::MGPipeVertexElementsRecord& elements,
-            const MG_Pipe::MGPipeApplierState& state, Uint32 activeMask, BackendVertexInputState& out) const {
-        out = BackendVertexInputState{};
-        for (Uint32 location = 0; location < elements.AttributeCount; ++location) {
-            const auto& attr = elements.Attributes[location];
-            if (!attr.Enabled || !(activeMask & (1u << location))) continue;
-            // P7 wave 2 package C, CONTRACT-P7 §3.2 `vertex-layout`: THE ONE STRING BECAME TWO
-            // VERDICTS, and the split is by what the reason is ABOUT rather than by severity.
-            //
-            // Every reason here used to return false, and the single caller answered that with
-            // one P7-marked MagmaWireFatal - an abort, bypassing Session::Fail, invisible
-            // to the census gate and with no equivalent on the monolith arm at all. But the
-            // reasons are not one kind of thing:
-            //
-            //   * `buffer-window` is a statement about the RECORD: an enabled attribute the
-            //     program reads names a slot outside the window set_vertex_buffers published.
-            //     Nothing about the device or the format is involved; the two halves of the
-            //     protocol disagree about what crossed. It stays a named Fatal through the hook
-            //     (see the caller), and it is load-bearing rather than defensive - it is what
-            //     caught the Redmi VAO hash collision fixed in 376c04be.
-            //
-            //   * every other reason is a statement about what VULKAN CAN EXPRESS on this
-            //     device: a GL type with no VkFormat, a format without
-            //     VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, a component size we cannot compute, an
-            //     offset sum that does not fit. The monolith arm has had an answer for these
-            //     since it was written, and it is not an abort: mask the attribute out of the
-            //     vertex input state and carry on (the `unsupportedAttribMask |= ...; continue;`
-            //     sites in GetOrCreateVertexInputState above). The draw path then decides,
-            //     loudly and once, whether the masked attribute was one the program actually
-            //     reads. This arm now does exactly that, which is what "same observable as the
-            //     monolith lane" means for this row.
-            //
-            // THE COUNT: the contract says "the other six"; there are SEVEN return sites below
-            // it, because `offset-overflow` was added after the audit's count and is an
-            // arithmetic guard rather than a shape one. It is masked with the rest: an
-            // attribute whose base offsets cannot be added is one Vulkan cannot fetch, the
-            // monolith arm never computes that sum at all, and masking is strictly safer than
-            // a Fatal for a number no application can reach on purpose. Recorded in
-            // notes/p7/magma-c.md rather than silently reconciled.
-            const auto describe = [&](const char* reason, VkFormat format) {
-                MGLOG_E_ONCE("Magma wire vertex layout: %s location=%u type=%u size=%u normalized=%u integer=%u long=%u bgra=%u stride=%d offset=%llu format=%d bufferWindow=%u+%u activeMask=0x%x",
-                    reason, location, attr.Type, static_cast<Uint32>(attr.Size), static_cast<Uint32>(attr.Normalized),
-                    static_cast<Uint32>(attr.IsInteger), static_cast<Uint32>(attr.IsLong), static_cast<Uint32>(attr.IsBgra),
-                    attr.Stride, static_cast<unsigned long long>(attr.Offset), static_cast<Int>(format),
-                    state.VertexBufferStart, state.VertexBufferCount, activeMask);
-            };
-            // The protocol verdict: the caller turns a false into the named Fatal.
-            const auto reject = [&](const char* reason, VkFormat format = VK_FORMAT_UNDEFINED) {
-                describe(reason, format);
-                return false;
-            };
-            // The device verdict: MGLOG_E_ONCE + mask + continue, the monolith arm's shape.
-            // MGLOG_E_ONCE and not MGLOG_E, also the monolith arm's: an unmappable attribute is
-            // a property of the VAO and the device, so it repeats every draw, and the per-draw
-            // line is what made the old abort look preferable to whoever wrote it.
-            const auto maskOut = [&](const char* reason, VkFormat format = VK_FORMAT_UNDEFINED) {
-                describe(reason, format);
-                out.unsupportedAttribMask |= 1u << location;
-            };
-            // set_vertex_buffers is flattened PER ATTRIBUTE (VertexInputEmit.h), not
-            // indexed by the original ARB binding point in attr.BindingIndex.
-            if (location < state.VertexBufferStart ||
-                location - state.VertexBufferStart >= state.VertexBufferCount) return reject("buffer-window");
-            const auto& buffer = state.VertexBuffers[location];
-            const auto type = static_cast<DataType>(attr.Type);
-            if (attr.Stride < 0 || attr.Size < 1 || attr.Size > 4) { maskOut("attribute-shape"); continue; }
-            VkFormat format = ToVkVertexFormat(type, attr.Size, attr.Normalized, attr.IsInteger,
-                                               attr.IsBgra, attr.IsLong);
-            auto conversion = VertexStreamConversion::None;
-            if (format == VK_FORMAT_UNDEFINED && type == DataType::Float64) {
-                const auto* backend = MG_Remote::Server::ServerLoopInstance().Backend();
-                if (backend && backend->GetDynamicParameters().SupportsFloat64VertexAttributes) {
-                    // Exactly the monolith arm's answer for the same state: with native fp64
-                    // the module KEPT its 64-bit inputs (DemoteFloat64Pass did not run), so
-                    // narrowing the stream would feed float32 to a Float64 input - and the
-                    // monolith build therefore leaves sourceVkFormat UNDEFINED and falls into
-                    // its own mask-out below. Same place, same mask.
-                    maskOut("native-fp64-format");
-                    continue;
-                }
-                format = ToFloat32VertexFormat(attr.Size);
-                conversion = VertexStreamConversion::Float64ToFloat32;
-            }
-            if (format == VK_FORMAT_UNDEFINED) { maskOut("format-map"); continue; }
-            if (!SupportsVertexBufferFormat(format)) {
-                if (!IsScaledIntegerVertexFormat(format)) { maskOut("native-format-feature", format); continue; }
-                format = ToFloat32VertexFormat(attr.Size);
-                conversion = VertexStreamConversion::ScaledIntegerToFloat32;
-                if (!SupportsVertexBufferFormat(format)) { maskOut("converted-format-feature", format); continue; }
-            }
-            const SizeT elementSize = GetAttributeByteSize(type, attr.Size, attr.IsBgra);
-            if (!elementSize) { maskOut("element-size", format); continue; }
-            const Uint64 offset = attr.Offset + buffer.Offset;
-            if (offset < attr.Offset) { maskOut("offset-overflow", format); continue; }
-            const SizeT alignment = (type == DataType::Int2101010Rev || type == DataType::Uint2101010Rev)
-                ? elementSize : GetComponentSize(type);
-            if (conversion == VertexStreamConversion::None && alignment > 1 &&
-                (offset % alignment || static_cast<Uint32>(attr.Stride) % alignment))
-                conversion = VertexStreamConversion::Repack;
-            Uint32 stride = static_cast<Uint32>(attr.Stride);
-            if (stride && conversion != VertexStreamConversion::None)
-                stride = conversion == VertexStreamConversion::Repack ? static_cast<Uint32>(elementSize)
-                    : static_cast<Uint32>(attr.Size) * sizeof(Float);
-            const Uint32 binding = static_cast<Uint32>(out.bindings.size());
-            out.bindings.push_back({binding, stride,
-                buffer.Divisor ? VK_VERTEX_INPUT_RATE_INSTANCE : VK_VERTEX_INPUT_RATE_VERTEX});
-            out.attributes.push_back({location, binding, format, 0});
-            out.bindingAttributeLocations.push_back(location);
-            out.bindingBaseOffsets.push_back(static_cast<SizeT>(offset));
-            out.bindingConversions.push_back(conversion);
-            if (buffer.Divisor > 1) out.bindingDivisors.push_back({binding, buffer.Divisor});
-            out.attributeLocationMask |= 1u << location;
-        }
-        // Native handles/offsets do not decide the pipeline layout. Include only the
-        // resolved binding/attribute/divisor values, including a legal zero stride.
-        Uint64 hash = XXH64(out.bindings.data(), out.bindings.size() * sizeof(out.bindings[0]), 0);
-        hash = XXH64(out.attributes.data(), out.attributes.size() * sizeof(out.attributes[0]), hash);
-        hash = XXH64(out.bindingDivisors.data(),
-            out.bindingDivisors.size() * sizeof(out.bindingDivisors[0]), hash);
-        // THE MASK IS PART OF THE LAYOUT NOW, for the same reason the monolith entry's hash
-        // carries it (the XXH64_update over unsupportedAttribMask in GetOrCreateVertexInputState
-        // above). Before this package the mask was always zero here, so leaving it out of the
-        // hash was free; now two VAOs can produce the SAME bindings, attributes and divisors
-        // and differ only in which enabled attribute was masked out, and a hash blind to that
-        // would serve one of them the other's pipeline.
-        out.layoutHash = XXH64(&out.unsupportedAttribMask, sizeof(out.unsupportedAttribMask), hash);
-        out.state.vertexBindingDescriptionCount = static_cast<Uint32>(out.bindings.size());
-        out.state.pVertexBindingDescriptions = out.bindings.data();
-        out.state.vertexAttributeDescriptionCount = static_cast<Uint32>(out.attributes.size());
-        out.state.pVertexAttributeDescriptions = out.attributes.data();
-        if (!out.bindingDivisors.empty()) {
-            out.divisorState.vertexBindingDivisorCount = static_cast<Uint32>(out.bindingDivisors.size());
-            out.divisorState.pVertexBindingDivisors = out.bindingDivisors.data();
-            out.state.pNext = &out.divisorState;
-        }
-        return true;
-    }
-#endif
-
-    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. Advance through the
-                // process-wide source so the value stays unique across factory
-                // instances (see the member comment). With no legacy arm the memos
-                // live in this factory and die with it, so a per-instance bump is
-                // enough - P2 D12.5.
-#if MOBILEGL_PIPE_LEGACY_MEMOS
-                m_evictionEpoch = ++s_evictionEpochSource;
-#else
-                ++m_evictionEpoch;
-#endif
-            } else {
-                ++it;
-            }
-        }
-    }
-
-    VkFormat VertexInputStateFactory::ToVkVertexFormat(DataType type, Int size, Bool normalized, Bool isInteger,
-                                                       Bool isBgra, Bool isLong) {
-        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
-            // components back into R,G,B,A order for the shader.
-            switch (type) {
-            case DataType::Uint8:
-                return VK_FORMAT_B8G8R8A8_UNORM;
-            case DataType::Uint2101010Rev:
-                return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
-            case DataType::Int2101010Rev:
-                return VK_FORMAT_A2R10G10B10_SNORM_PACK32;
-            default:
-                return VK_FORMAT_UNDEFINED;
-            }
-        }
-        switch (type) {
-        case DataType::Uint2101010Rev:
-            // Packed 2_10_10_10 travels the float-normalizing path only; size is always 4. SNORM/UNORM
-            // normalize, SSCALED/USCALED cast the packed field to float.
-            if (isInteger || size != 4) return VK_FORMAT_UNDEFINED;
-            return normalized ? VK_FORMAT_A2B10G10R10_UNORM_PACK32 : VK_FORMAT_A2B10G10R10_USCALED_PACK32;
-        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.
-            //
-            // ... as long as the shader half still runs. It does not when the backend has declared
-            // no 64-bit vertex attribute support: DemoteFloat64Pass has already narrowed every
-            // `dvec` input to a `vec` by then, so PackDoubleVertexInputsPass finds nothing to pack
-            // and a UINT-formatted attribute would be fed to a float input - garbage with no
-            // diagnostic anywhere. Declining here hands the attribute to the caller's
-            // Float64ToFloat32 fallback instead, which narrows the source doubles to match the
-            // demoted `vec` input - the same thing DirectGLES does for the same state. The
-            // frontend RECORDS the format either way, so this gate is the only thing standing
-            // between a legal glVertexAttribLFormat and a mismatched pipeline.
-            if (
-#if MOBILEGL_BUILD_DISAGGREGATED
-                // P5c (hd, CONTRACT-P5C §3.7): see the narrowFloat64Arrays site above.
-                MG_Config::Transport != MG_Config::TransportMode::Monolith
-                    ? (MG_Remote::Server::ServerLoopInstance().Backend() == nullptr ||
-                       !MG_Remote::Server::ServerLoopInstance().Backend()
-                            ->GetDynamicParameters()
-                            .SupportsFloat64VertexAttributes)
-                    :
-#endif
-                MG_Backend::pActiveBackendObject == nullptr ||
-                !MG_Backend::pActiveBackendObject->GetDynamicParameters().SupportsFloat64VertexAttributes) {
-                return VK_FORMAT_UNDEFINED;
-            }
-            if (!isLong || isInteger || normalized) return VK_FORMAT_UNDEFINED;
-            switch (size) {
-            case 1: return VK_FORMAT_R32G32_UINT;
-            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;
-            case 2: return VK_FORMAT_R32G32_SFLOAT;
-            case 3: return VK_FORMAT_R32G32B32_SFLOAT;
-            case 4: return VK_FORMAT_R32G32B32A32_SFLOAT;
-            default: return VK_FORMAT_UNDEFINED;
-            }
-        case DataType::Float16:
-            // GL_HALF_FLOAT is a floating-point array type: it is never an integer attribute, and
-            // GL_TRUE for `normalized` is ignored for float types rather than selecting a *NORM format.
-            if (isInteger) return VK_FORMAT_UNDEFINED;
-            switch (size) {
-            case 1: return VK_FORMAT_R16_SFLOAT;
-            case 2: return VK_FORMAT_R16G16_SFLOAT;
-            case 3: return VK_FORMAT_R16G16B16_SFLOAT;
-            case 4: return VK_FORMAT_R16G16B16A16_SFLOAT;
-            default: return VK_FORMAT_UNDEFINED;
-            }
-        case DataType::Int32:
-            if (!isInteger || normalized) return VK_FORMAT_UNDEFINED;
-            switch (size) {
-            case 1: return VK_FORMAT_R32_SINT;
-            case 2: return VK_FORMAT_R32G32_SINT;
-            case 3: return VK_FORMAT_R32G32B32_SINT;
-            case 4: return VK_FORMAT_R32G32B32A32_SINT;
-            default: return VK_FORMAT_UNDEFINED;
-            }
-        case DataType::Uint32:
-            if (!isInteger || normalized) return VK_FORMAT_UNDEFINED;
-            switch (size) {
-            case 1: return VK_FORMAT_R32_UINT;
-            case 2: return VK_FORMAT_R32G32_UINT;
-            case 3: return VK_FORMAT_R32G32B32_UINT;
-            case 4: return VK_FORMAT_R32G32B32A32_UINT;
-            default: return VK_FORMAT_UNDEFINED;
-            }
-        case DataType::Int16:
-            switch (size) {
-            case 1:
-                return isInteger ? VK_FORMAT_R16_SINT : (normalized ? VK_FORMAT_R16_SNORM : VK_FORMAT_R16_SSCALED);
-            case 2:
-                return isInteger ? VK_FORMAT_R16G16_SINT
-                                 : (normalized ? VK_FORMAT_R16G16_SNORM : VK_FORMAT_R16G16_SSCALED);
-            case 3:
-                return isInteger ? VK_FORMAT_R16G16B16_SINT
-                                 : (normalized ? VK_FORMAT_R16G16B16_SNORM : VK_FORMAT_R16G16B16_SSCALED);
-            case 4:
-                return isInteger ? VK_FORMAT_R16G16B16A16_SINT
-                                 : (normalized ? VK_FORMAT_R16G16B16A16_SNORM : VK_FORMAT_R16G16B16A16_SSCALED);
-            default: return VK_FORMAT_UNDEFINED;
-            }
-        case DataType::Uint16:
-            switch (size) {
-            case 1:
-                return isInteger ? VK_FORMAT_R16_UINT : (normalized ? VK_FORMAT_R16_UNORM : VK_FORMAT_R16_USCALED);
-            case 2:
-                return isInteger ? VK_FORMAT_R16G16_UINT
-                                 : (normalized ? VK_FORMAT_R16G16_UNORM : VK_FORMAT_R16G16_USCALED);
-            case 3:
-                return isInteger ? VK_FORMAT_R16G16B16_UINT
-                                 : (normalized ? VK_FORMAT_R16G16B16_UNORM : VK_FORMAT_R16G16B16_USCALED);
-            case 4:
-                return isInteger ? VK_FORMAT_R16G16B16A16_UINT
-                                 : (normalized ? VK_FORMAT_R16G16B16A16_UNORM : VK_FORMAT_R16G16B16A16_USCALED);
-            default: return VK_FORMAT_UNDEFINED;
-            }
-        case DataType::Int8:
-            switch (size) {
-            case 1:
-                return isInteger ? VK_FORMAT_R8_SINT : (normalized ? VK_FORMAT_R8_SNORM : VK_FORMAT_R8_SSCALED);
-            case 2:
-                return isInteger ? VK_FORMAT_R8G8_SINT
-                                 : (normalized ? VK_FORMAT_R8G8_SNORM : VK_FORMAT_R8G8_SSCALED);
-            case 3:
-                return isInteger ? VK_FORMAT_R8G8B8_SINT
-                                 : (normalized ? VK_FORMAT_R8G8B8_SNORM : VK_FORMAT_R8G8B8_SSCALED);
-            case 4:
-                return isInteger ? VK_FORMAT_R8G8B8A8_SINT
-                                 : (normalized ? VK_FORMAT_R8G8B8A8_SNORM : VK_FORMAT_R8G8B8A8_SSCALED);
-            default: return VK_FORMAT_UNDEFINED;
-            }
-        case DataType::Uint8:
-            switch (size) {
-            case 1:
-                return isInteger ? VK_FORMAT_R8_UINT : (normalized ? VK_FORMAT_R8_UNORM : VK_FORMAT_R8_USCALED);
-            case 2:
-                return isInteger ? VK_FORMAT_R8G8_UINT
-                                 : (normalized ? VK_FORMAT_R8G8_UNORM : VK_FORMAT_R8G8_USCALED);
-            case 3:
-                return isInteger ? VK_FORMAT_R8G8B8_UINT
-                                 : (normalized ? VK_FORMAT_R8G8B8_UNORM : VK_FORMAT_R8G8B8_USCALED);
-            case 4:
-                return isInteger ? VK_FORMAT_R8G8B8A8_UINT
-                                 : (normalized ? VK_FORMAT_R8G8B8A8_UNORM : VK_FORMAT_R8G8B8A8_USCALED);
-            default: return VK_FORMAT_UNDEFINED;
-            }
-        default:
-            return VK_FORMAT_UNDEFINED;
-        }
-    }
-
-    SizeT VertexInputStateFactory::GetComponentSize(DataType type) {
-        switch (type) {
-        case DataType::Int8:
-        case DataType::Uint8:
-            return 1;
-        case DataType::Int16:
-        case DataType::Uint16:
-        case DataType::Float16:
-            return 2;
-        case DataType::Int32:
-        case DataType::Uint32:
-        case DataType::Float32:
-        case DataType::Fixed32:
-            return 4;
-        case DataType::Float64:
-            return 8;
-        default:
-            return 0;
-        }
-    }
-
-    SizeT VertexInputStateFactory::GetAttributeByteSize(DataType type, Int size, Bool isBgra) {
-        // The packed 2_10_10_10 types are a single 32-bit word for all 4 components; GL_BGRA is always
-        // 4 components (GL_UNSIGNED_BYTE x4 = 4 bytes, or a packed word = 4 bytes) -- both are 4 bytes.
-        if (type == DataType::Int2101010Rev || type == DataType::Uint2101010Rev || isBgra) {
-            return 4;
-        }
-        const SizeT componentSize = GetComponentSize(type);
-        return componentSize == 0 ? 0 : componentSize * static_cast<SizeT>(size);
-    }
-
-    Bool VertexInputStateFactory::IsScaledIntegerVertexFormat(VkFormat format) {
-        switch (format) {
-        case VK_FORMAT_R8_USCALED:
-        case VK_FORMAT_R8_SSCALED:
-        case VK_FORMAT_R8G8_USCALED:
-        case VK_FORMAT_R8G8_SSCALED:
-        case VK_FORMAT_R8G8B8_USCALED:
-        case VK_FORMAT_R8G8B8_SSCALED:
-        case VK_FORMAT_R8G8B8A8_USCALED:
-        case VK_FORMAT_R8G8B8A8_SSCALED:
-        case VK_FORMAT_R16_USCALED:
-        case VK_FORMAT_R16_SSCALED:
-        case VK_FORMAT_R16G16_USCALED:
-        case VK_FORMAT_R16G16_SSCALED:
-        case VK_FORMAT_R16G16B16_USCALED:
-        case VK_FORMAT_R16G16B16_SSCALED:
-        case VK_FORMAT_R16G16B16A16_USCALED:
-        case VK_FORMAT_R16G16B16A16_SSCALED:
-            return true;
-        default:
-            return false;
-        }
-    }
-
-    VkFormat VertexInputStateFactory::ToFloat32VertexFormat(Int componentCount) {
-        switch (componentCount) {
-        case 1: return VK_FORMAT_R32_SFLOAT;
-        case 2: return VK_FORMAT_R32G32_SFLOAT;
-        case 3: return VK_FORMAT_R32G32B32_SFLOAT;
-        case 4: return VK_FORMAT_R32G32B32A32_SFLOAT;
-        default: return VK_FORMAT_UNDEFINED;
-        }
-    }
-
-    Bool VertexInputStateFactory::SupportsVertexBufferFormat(VkFormat format) const {
-        if (m_physicalDevice == VK_NULL_HANDLE || format == VK_FORMAT_UNDEFINED) {
-            return false;
-        }
-#if MOBILEGL_BUILD_DISAGGREGATED
-        if (MG_Config::Transport != MG_Config::TransportMode::Monolith) {
-            const auto found = m_wireVertexFormatSupport.find(format);
-            if (found != m_wireVertexFormatSupport.end()) return found->second;
-            VkFormatProperties properties{};
-            vkGetPhysicalDeviceFormatProperties(m_physicalDevice, format, &properties);
-            const Bool supported = (properties.bufferFeatures & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT) != 0;
-            m_wireVertexFormatSupport.emplace(format, supported);
-            return supported;
-        }
-#endif
-        VkFormatProperties properties{};
-        vkGetPhysicalDeviceFormatProperties(m_physicalDevice, format, &properties);
-        return (properties.bufferFeatures & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT) != 0;
-    }
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.h

@@ -1,227 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.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
-// MG_Pipe::MGPipeHandle for the P2 D12.5 memo table below. A header of constexpr constants,
-// so the pull build gains nothing from it.
-#include <MG_Pipe/MGPipeHandles.h>
-#if MOBILEGL_BUILD_DISAGGREGATED
-#include <MG_Pipe/PipeApply.h>
-#endif
-
-#include "Config.h"
-#include "MagmaPipeArms.h"
-#include "VertexInputStateBuilder.h"
-#include "MG_State/GLState/VertexArrayState/VertexArrayObject.h"
-#include <Includes.h>
-#include "../VkIncludes.h"
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    class VertexInputStateFactory {
-    public:
-        using HashType = Uint64;
-
-        enum class VertexStreamConversion : Uint8 {
-            None = 0,
-            Repack,
-            ScaledIntegerToFloat32,
-            // GL_DOUBLE source data narrowed to a tightly packed float32 stream: the fetch half
-            // of the fp64 demotion the shader side already does unconditionally.
-            Float64ToFloat32,
-        };
-
-        struct BackendVertexInputState {
-            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;
-            Vector<SizeT> bindingBaseOffsets;
-            Vector<Uint32> bindingAttributeLocations;
-            Vector<Bool> bindingUsesClientMemory;
-            Vector<VertexStreamConversion> bindingConversions;
-            // Locations whose array is ENABLED but whose GL format has no VkFormat mapping. They are
-            // 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
-            };
-        };
-
-#if MOBILEGL_PIPE_PUSH
-        // The mint is the RENDERER's (MagmaPipeIdentityTables), not a process-global and not
-        // this factory's: VulkanRenderer::LookupVaoDrawMemo has to derive the same {slot, gen}
-        // for the same VAO, and a table that outlived the context it was minted for would share
-        // one reclamation clock across two live contexts (review v2 minor 4).
-        VertexInputStateFactory(const VulkanRendererConfig& config, VkPhysicalDevice physicalDevice,
-                                MagmaPipeIdentityTables& identity):
-            m_config(config), m_physicalDevice(physicalDevice), m_identity(&identity) {}
-#else
-        VertexInputStateFactory(const VulkanRendererConfig& config, VkPhysicalDevice physicalDevice):
-            m_config(config), m_physicalDevice(physicalDevice) {}
-#endif
-        ~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.
-        HashType GetOrComputeHash(const MG_State::GLState::VertexArrayObject& vao) const;
-#if MOBILEGL_PIPE_PUSH
-        // The VAO's content hash IF it has already been memoized, without computing one.
-        // P2 D12.5: the three draw-path readers that used to ask the VAO object this
-        // question ask the factory instead, because that is where the memo lives once the
-        // frontend object stops carrying the backend's state.
-        Bool TryGetMemoizedHash(const MG_State::GLState::VertexArrayObject& vao, Uint64& outHash) const;
-#endif
-        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
-        // an unknown/unsupported type.
-        static SizeT GetAttributeByteSize(DataType type, Int size, Bool isBgra);
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // A wire VAO is a layout record plus a separate per-attribute buffer window.
-        // No frontend VAO identity, address or memo participates in this layout.
-        Bool BuildWireVertexInput(const MG_Pipe::MGPipeVertexElementsRecord& elements,
-                                  const MG_Pipe::MGPipeApplierState& state, Uint32 activeMask,
-                                  BackendVertexInputState& out) const;
-#endif
-
-    private:
-        static VkFormat ToVkVertexFormat(DataType type, Int size, Bool normalized, Bool isInteger, Bool isBgra = false,
-                                         Bool isLong = false);
-        static Bool IsScaledIntegerVertexFormat(VkFormat format);
-        static VkFormat ToFloat32VertexFormat(Int componentCount);
-        Bool SupportsVertexBufferFormat(VkFormat format) const;
-
-#if MOBILEGL_PIPE_PUSH
-        // ---- P2 D12.5: the backend's memos, off the frontend VAO and into the backend ----
-        //
-        // The two facts that used to live as `mutable` fields on VertexArrayObject
-        // (Get/SetBackendHashMemo and Get/SetBackendStateMemo), kept here instead, keyed on
-        // the VAO's {slot, gen} and guarded by exactly the same config version. A frontend
-        // state object holding the backend's raw pointer is what P2 retires: under split the
-        // backend is in another process and its cache entry has no address a client could
-        // store, so the memo has to live on the side that owns the pointee.
-        //
-        // The AUX memo is not carried over: its two words moved into VaoDrawMemo::layoutHash
-        // and layoutAuxMasks long ago and its getter has no live reader anywhere in the tree,
-        // so the handle arm simply stops writing it (D12.5 says delete rather than move).
-        struct VaoBackendMemos {
-            // Whose memos these are. The identity table can recycle a slot for a different
-            // VAO under LRU pressure, and the handle compare - Gen included - is what says
-            // the contents are this object's and not its predecessor's.
-            MG_Pipe::MGPipeHandle Owner = MG_Pipe::kMGPipeNullHandle;
-            Uint64 Hash = 0;
-            Uint32 HashConfigVersion = ~0u;
-            const void* State = nullptr;
-            Uint64 StateEpoch = 0;
-            Uint32 StateConfigVersion = ~0u;
-        };
-        // Grow-on-demand (D12.4), one entry per slot the renderer's mint has ever handed
-        // out, and NO CAPACITY: these two memos had none before this package either - they
-        // were unbounded mutable fields on the VertexArrayObject itself - and re-introducing
-        // eviction here is what review v2 rejected. MagmaPipeSlotTable grows in chunks so an
-        // entry reference stays valid across the nested GetOrCreateVertexInputState call.
-        // 48 B per live VAO, reclaimed with the slot when the object goes idle.
-        mutable MagmaPipeSlotTable<VaoBackendMemos> m_vaoMemos;
-        // The renderer's {slot, gen} mint (see the constructor). Never null under push.
-        MagmaPipeIdentityTables* m_identity = nullptr;
-        // The entry belonging to `vao`, claimed (and cleared) if the slot currently holds
-        // someone else's.
-        VaoBackendMemos& MemosFor(const MG_State::GLState::VertexArrayObject& vao) const;
-#endif
-
-        const VulkanRendererConfig& m_config;
-        VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // Physical-device format capabilities never change during this factory's
-        // lifetime. The wire path rebuilds layouts without the legacy VAO memo.
-        mutable UnorderedMap<VkFormat, Bool> m_wireVertexFormatSupport;
-#endif
-        // 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.
-        //
-        // Drawn from a process-wide source, never a per-instance counter: the VAO
-        // memos outlive this factory (they live on the frontend context's VAOs, the renderer
-        // is destroyed and recreated on EGL surface release/re-create), so a fresh
-        // factory restarting at a dead factory's epoch value would honor its
-        // dangling entry pointers. The constructor takes a value strictly greater
-        // than anything a predecessor ever stamped, so a dead factory's memo can
-        // never compare equal here - the same never-reused idiom as the lifetime ids.
-        // Single-threaded like the rest of the factory (renderer-thread only).
-        //
-        // P2 D12.5: the process-wide source is the LEGACY arm's need. It exists because the
-        // memos live on the frontend VAOs and therefore outlive the factory. The handle arm's
-        // memo table is owned by this factory and dies with it, so a per-instance counter is
-        // enough there and the epoch shrinks back to what it looks like it should be.
-#if MOBILEGL_PIPE_LEGACY_MEMOS
-        static inline Uint64 s_evictionEpochSource = 0;
-        Uint64 m_evictionEpoch = ++s_evictionEpochSource;
-#else
-        Uint64 m_evictionEpoch = 1;
-#endif
-        static inline XXH64_state_t* m_hashState = XXH64_createState();
-    };
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.h

@@ -1,430 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.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 "BufferArena.h"
-#include "MG_State/GLState/BufferState/BufferObject.h"
-#include "../VkIncludes.h"
-#include <Includes.h>
-#include <vk_mem_alloc.h>
-#if MOBILEGL_BUILD_DISAGGREGATED
-#include "MG_Pipe/MGPipeTypes.h"
-#include <unordered_map>
-#endif
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    enum class BufferKind : Uint8 {
-        Vertex,
-        Index,
-        Uniform,
-        TextureBuffer,
-        ShaderStorage,
-        Indirect,
-    };
-
-    struct VkBufferManagerInitInfo {
-        VmaAllocator allocator = nullptr;
-        Uint32 frameCount = 0;
-        VkDeviceSize minUploadBytes = 4 * 1024 * 1024;
-        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).
-    // Owned (refcounted) by the frontend BufferObject; the manager holds only weak
-    // references (for shutdown) plus strong references on deferred-release lists.
-    class VkBufferResource : public MG_State::GLState::BackendBufferResource {
-    public:
-        ~VkBufferResource() override = default;
-
-        // Resident storage (may be invalid for streaming-only buffers).
-        VkBufferObject buffer;
-        VkDeviceSize storageSize = 0;
-        VkBufferUsageFlags usageFlags = 0;
-        // Frame serial of the last GPU reference; drives busy tracking.
-        Uint64 lastUseSerial = 0;
-        // Set when an immediate op could not be applied; forces a full re-upload
-        // on the next AcquireResidentSlice.
-        Bool pendingFullUpload = false;
-        // Backs a zero-copy coherent persistent map (PipeResource GPU residency): the
-        // buffer is HOST_VISIBLE+COHERENT, persistently mapped, carries every usage and is
-        // 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,
-    // for staged buffer-range copies. Implemented by VulkanRenderer.
-    class IBufferCopyCommandProvider {
-    public:
-        virtual ~IBufferCopyCommandProvider() = default;
-        virtual VkCommandBuffer AcquireBufferCopyCommandBuffer() = 0;
-    };
-
-    class VkBufferManager {
-    public:
-        Bool Initialize(const VkBufferManagerInitInfo& initInfo);
-        void Shutdown();
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // Registered before caps publication; the initialized renderer owns the storage.
-        static void RegisterWireResourceOps();
-        // Transport resources are owned by their complete wire handle, never by a
-        // frontend BufferObject. Acquires expose the full GPU store, without a CPU
-        // pointer: CPU consumers must use ReadWireBuffer for ordered, current bytes.
-        Bool AcquireWireSlice(BufferKind kind, MG_Pipe::MGPipeHandle res, BufferSlice& outSlice);
-        Bool ReadWireBuffer(MG_Pipe::MGPipeHandle res, Uint64 offset, Uint64 size, void* dst);
-        Bool CopyWireBufferRangeToSlice(MG_Pipe::MGPipeHandle res, Uint64 offset, Uint64 size,
-                                        const BufferSlice& dst);
-        // P7 A.1, the sub-word half of the one above: the same copy for a window whose start
-        // or end does not land on a four-byte boundary. The read of the APPLICATION's store is
-        // rounded OUT to whole words and clamped to the store's end, so the widened window can
-        // never touch a byte the application does not own; it lands in a transient staging
-        // slice, and only the staging -> dst shift is sub-word - inside our own arena, where an
-        // unaligned region cannot alias anything else. vkCmdCopyBuffer places no alignment rule
-        // on a region's offsets or size (unlike vkCmdUpdateBuffer / vkCmdFillBuffer), so the
-        // shift is a plain legal copy. `dstSkip` is the byte inside `dst` the window starts at.
-        // This retires `uniform-buffer-byte-tail`.
-        Bool CopyWireBufferSubWordRangeToSlice(MG_Pipe::MGPipeHandle res, Uint64 offset, Uint64 size,
-                                               Uint32 frameIndex, const BufferSlice& dst, Uint64 dstSkip);
-        void MarkWireBufferGpuWritten(MG_Pipe::MGPipeHandle res, Uint64 offset, Uint64 size);
-        // P8-D: whether a shader write was marked on this store since the last indirect draw
-        // read it natively, clearing the mark. The caller records the INDIRECT_COMMAND_READ
-        // barrier before the draw when this answers true. Transfer writes need no mark: their own
-        // after-barriers already make them visible to MEMORY_READ at ALL_COMMANDS.
-        Bool TakeWireIndirectReadBarrier(MG_Pipe::MGPipeHandle res);
-        // P8-D: every WaitForWireBufferHostAccess that actually waited, over this manager's life -
-        // the attribution base a caller reads before and after its own ReadWireBuffer.
-        Uint64 GetWireHostWaitCount() const { return m_wireHostWaits; }
-
-        // Resource-op entry points. All run on the server apply owner.
-        void CreateWireBuffer(MG_Pipe::MGPipeHandle res, const MG_Pipe::MGPResourceDesc& desc);
-        void RespecifyWireBuffer(MG_Pipe::MGPipeHandle res, const MG_Pipe::MGPResourceDesc& desc,
-                                 const void* initialBytes);
-        void WriteWireBuffer(MG_Pipe::MGPipeHandle res, Uint64 offset, Uint64 size, const void* bytes);
-        void FlushWireBuffer(MG_Pipe::MGPipeHandle res, Uint64 offset, Uint64 size, const void* bytes);
-        void ReadbackWireBuffer(MG_Pipe::MGPipeHandle res, Uint64 offset, Uint64 size);
-        void DestroyWireBuffer(MG_Pipe::MGPipeHandle res);
-        // P11 B2 (T0): make the client's AHardwareBuffer `ahb` (a BLOB of `size` bytes) buffer
-        // `res`'s store - a VkBuffer on memory imported through
-        // VK_ANDROID_external_memory_android_hardware_buffer, host-visible and mapped like every
-        // wire store, so every wire path (draw binds, WriteWireBuffer's ordered copy, CPU readers)
-        // applies unchanged. The T2 store it replaces goes through DeferWireRelease. False = not
-        // imported (the T2 store is untouched and the client is DECLINED).
-        Bool ImportWireBuffer(MG_Pipe::MGPipeHandle res, void* ahb, Uint64 size);
-        // The POST self-test of the sustained-lock pattern on this device (see the definition).
-        static Bool SelfTestWireImport(char* why, Uint64 whyBytes);
-#endif
-
-        // 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
-        // and including `serial` is complete. Raises the completed floor so
-        // GetCompletedSerial reflects real fence progress instead of only the
-        // frameSerial-minus-frameCount inference.
-        void NotifyFrameSerialComplete(Uint64 serial);
-        void SetCopyCommandProvider(IBufferCopyCommandProvider* provider);
-
-        Bool UploadTransient(BufferKind kind, Uint32 frameIndex, const void* data, VkDeviceSize size,
-                             VkDeviceSize alignment, BufferSlice& outSlice);
-
-        // The descriptor a shader storage block gets when the program declares it and the
-        // application bound no buffer at its GL binding point. GL 4.6 core 7.8 makes that a
-        // legal state - the block simply has no store, so reads are undefined and writes go
-        // nowhere - whereas Vulkan has no such thing as an unwritten descriptor, so something
-        // real has to sit in the set or the whole draw/dispatch is lost. One zero-filled
-        // buffer, created once and shared by every unbound binding: bindings that are only
-        // declared (the case this exists for) never touch it, and one that is actually read
-        // sees zeros, which is inside GL's "undefined". robustBufferAccess bounds anything
-        // that indexes past it.
-        BufferSlice AcquireUnboundStorageDescriptor();
-
-        // The store a texel-buffer descriptor - `samplerBuffer` or `imageBuffer` - gets when the
-        // unit the program's uniform names has no buffer texture on it, or the buffer texture on
-        // it has no GL buffer attached. Both are legal GL states that make a fetch return
-        // undefined values (GL 4.6 core 8.9: a buffer texture with no attached buffer object is
-        // incomplete, and sampling an incomplete texture is undefined - not a lost draw), and both
-        // used to take the whole draw or dispatch with them. The VIEW over this - one per format,
-        // and the descriptor is a VkBufferView, not a buffer - is built by
-        // UniformManager::AcquireUnboundTexelBufferView.
-        BufferSlice AcquireUnboundTexelBufferDescriptor();
-
-        // Draw-time acquire for resident (device-storage) buffers: ensures the
-        // resource exists and is fully uploaded, marks it used this frame.
-        Bool AcquireResidentSlice(BufferKind kind, const SharedPtr<MG_State::GLState::BufferObject>& bufferObject,
-                                  BufferSlice& outSlice);
-        // Draw-time acquire for streamed buffers: uploads the whole shadow into
-        // the per-frame arena (cached by change serial), releasing any resident
-        // storage the buffer may still own.
-        Bool AcquireStreamedSlice(BufferKind kind, const SharedPtr<MG_State::GLState::BufferObject>& bufferObject,
-                                  BufferSlice& outSlice);
-
-        // Zero-copy persistent map (PipeResource GPU residency): create (once) a
-        // HOST_VISIBLE+COHERENT, persistently mapped resident buffer carrying every usage,
-        // seed it from the shadow, and return its mapped base for the app to write into
-        // directly. Idempotent. Returns nullptr on failure (frontend keeps its shadow).
-        void* AcquirePersistentMap(MG_State::GLState::BufferObject& bufferObject);
-
-        // Immediate ops, dispatched from the frontend BufferBackendOps table.
-        void OnRespecify(MG_State::GLState::BufferObject& bufferObject);
-        void OnSubData(MG_State::GLState::BufferObject& bufferObject, SizeT offset, SizeT size);
-        void OnResidentSubData(MG_State::GLState::BufferObject& bufferObject, SizeT offset, DataPtr data);
-        void OnFlushMappedRange(MG_State::GLState::BufferObject& bufferObject, Range1D range,
-                                Flags<BufferMappingAccessBit> appAccess);
-        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; }
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // Bumped every time this manager destroys a WIRE store's VkBuffer (see
-        // m_wireStoreDestroyEpoch). Unchanged since a memo was taken means no VkBuffer handle
-        // that memo names can have been freed and re-minted in between, which is the one
-        // fact a handle-keyed memo of wire descriptors needs and cannot read off the handle.
-        Uint64 GetWireStoreDestroyEpoch() const { return m_wireStoreDestroyEpoch; }
-#endif
-        // 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.
-        Uint64 GetCompletedSerial() const;
-        // Busy = potentially referenced by GPU work that has not been fenced yet
-        // (including commands recorded for the current, unsubmitted frame).
-        Bool IsResourceBusy(const VkBufferResource& resource) const;
-        // Hand the manager a buffer to destroy once the frame that recorded commands
-        // naming it has completed. The renderer's blit path needs a device-local
-        // scratch store for one recorded operation, which cannot be a stack local:
-        // the glBlitFramebuffer that records the commands returns long before the
-        // command buffer is submitted.
-        void DeferRelease(VkBufferObject&& buffer);
-
-    private:
-#if MOBILEGL_BUILD_DISAGGREGATED
-        struct WireBufferResource {
-            VkBufferObject buffer;
-            Uint64 size = 0;
-            Uint64 lastUseSerial = 0;
-            // P7 wave 2 package B3: the submission expected to carry the most recent GPU use
-            // of this buffer - the busy predicate's DEFENCE term, not its guarantee (see
-            // WriteWireBuffer). IsSubmitIndexComplete polls the real fence and reports an
-            // unsubmitted index as incomplete, but the stamp is taken before the draw is
-            // recorded and a mid-draw flush can submit it without the draw.
-            Uint64 lastUseSubmitIndex = 0;
-            Bool gpuWritesPending = false;
-            // Only ranges actually submitted by resource_subdata are covered. No
-            // shadow is retained: flush cannot replay stale bytes over GPU writes.
-            Vector<Range1D> stagedCoverage;
-            // P11 B2 (T0): `buffer` is the client's imported AHardwareBuffer. Its readback posts
-            // no bytes (the client reads its own pages once the wait below it is done).
-            Bool imported = false;
-            // P8-D: a shader write was marked (MarkWireBufferGpuWritten) and no indirect draw has
-            // recorded its INDIRECT_COMMAND_READ barrier since (TakeWireIndirectReadBarrier).
-            Bool indirectReadBarrierPending = false;
-        };
-        // P8-D: see GetWireHostWaitCount.
-        Uint64 m_wireHostWaits = 0;
-        static Uint64 WireBufferKey(MG_Pipe::MGPipeHandle res) {
-            return (static_cast<Uint64>(res.Gen) << 32) | res.Slot;
-        }
-        WireBufferResource* FindWireBuffer(MG_Pipe::MGPipeHandle res);
-        Bool WaitForWireBufferHostAccess(WireBufferResource& resource);
-        // P11 B2: the serial a T0 store's release waits behind (never "destroy at once").
-        Uint64 T0ReleaseSerial(Uint64 lastUseSerial) const;
-
-        // P7 wave 4 (M2), ID-P7-27: THE WIRE ARM'S ORPHANS NEED A RECLAIM THAT IS NOT A FRAME
-        // BOUNDARY.
-        //
-        // RespecifyWireBuffer - which is every glBufferData that crosses the wire - orphans the
-        // old store unconditionally, because unlike OnRespecify it has no shadow to upload in
-        // place from and no cheap way to know the client is re-sending the same size. The orphan
-        // is legitimate (M1 measured the conditional-orphan mirror: 6701 live against 6702).
-        // What was missing is the RECLAIM. DeferRelease parks into m_deferredBufferReleases,
-        // whose only sweep is CollectDeferredReleases from a frame boundary, and on a pbuffer
-        // replay the server sees ONE present record for the whole run - so on
-        // minecraft-1.21.4-fabric-iris-bsl-esc-menu-854 the buckets held 25,923 dead stores
-        // against 28 live wire buffers, one memfd mapping each, and the server died in scudo's
-        // secondary allocator.
-        //
-        // So a wire store is parked HERE instead, with the facts that say when it is dead, and
-        // THE DEFER PATH ITSELF RECLAIMS - every park sweeps, and the frame boundary is only one
-        // more sweep point (CollectDeferredReleases), never the one this depends on:
-        //
-        //   * `lastUseSerial == 0` - read BEFORE RespecifyWireBuffer zeroes it. Zero means no
-        //     GPU command has named the store since it was minted or since the last host-access
-        //     wait proved every recorded command complete (WaitForWireBufferHostAccess); every
-        //     path that hands the store to the GPU stamps m_frameSerial, which starts at 1. Such
-        //     a store is destroyed at the park and never enters the list.
-        //   * `submitIndex` - the renderer's GetSyncPointSubmitIndex() at park time, which is by
-        //     construction the LAST submission that can name this store: every command that
-        //     names it was recorded before the park (the record left behind a bumped slice
-        //     epoch, so no memo can hand it out again), and a recorded command is either already
-        //     submitted (<= m_submitCounter) or in the batch that becomes m_submitCounter + 1.
-        //     IsSubmitIndexComplete(submitIndex) is a fence observation, so this is the gate
-        //     that empties the set MID-FRAME - the shape CollectWireObjects already uses for
-        //     the wire image/view tables.
-        //   * THE RENDERER IS IDLE - IsSubmitIndexComplete(GetSyncPointSubmitIndex()): nothing
-        //     is recorded and every submission has retired. Then every parked store is dead,
-        //     including one tagged for a batch that was abandoned rather than submitted (a
-        //     minimized Present drops its recording), whose own index may never complete.
-        //
-        // THE FRAME-SERIAL FLOOR IS DELIBERATELY NOT A PROOF HERE. It cannot move inside a
-        // frame (NotifyFrameSerialComplete refuses the current serial), so it frees nothing in
-        // the one-present replay this exists for; the submit index above is the fact that CAN
-        // move mid-frame, and it is a fence observation rather than a count.
-        //
-        // AND EVERY DESTROY HERE HAPPENS MID-FRAME, which the memos above this manager were not
-        // written for. UniformManager's descriptor memos are keyed on the VkBuffer HANDLE, and
-        // before M2 a wire store only ever died at the same boundary that clears those memos
-        // (UniformManager::BeginFrame, from Present or a drain). A store destroyed here can
-        // have its handle value re-minted by the next Create - a heap pointer under lavapipe -
-        // while a memo still maps that handle to a descriptor set baked to the dead store's
-        // memory: silent wrong bytes, no Fatal (ID-P7-43). m_wireStoreDestroyEpoch is the
-        // fact the memos fold in: every wire-store destroy bumps it, so a memo taken before
-        // the destroy cannot match after it. Deliberately NOT m_sliceEpochCounter, which every
-        // WriteWireBuffer bumps and which would defeat the memo on every glBufferSubData.
-        struct DeferredWireRelease {
-            VkBufferObject buffer;
-            Uint64 lastUseSerial = 0;
-            Uint64 submitIndex = 0;
-            // Cached: GetSize() is gone once the object is destroyed, and the watermark's
-            // running total has to stay exact as entries leave.
-            Uint64 bytes = 0;
-        };
-        // Park a wire store, sweep, then hold the watermark. `lastUseSerial` is the releasing
-        // resource's, captured before the caller resets it.
-        void DeferWireRelease(VkBufferObject&& buffer, Uint64 lastUseSerial);
-        // Destroy every parked store proven dead by the rules above. Returns how many.
-        SizeT SweepDeferredWireReleases();
-        // MOBILEGL_IPC_WIRE_DEFERRED_MB (Config.h has the semantics): when the parked bytes
-        // still exceed the budget after a sweep, take the sync point WaitForWireBufferHostAccess
-        // takes - flush what is recorded, wait for it - and sweep again, which retires every
-        // parked store, because none can be tagged past the sync point it just waited out.
-        void EnforceWireDeferredWatermark();
-        // ...and the same sync point when more than this many stores are parked, whatever their
-        // bytes (see the definition for the measurement). Not a knob: it bounds an object count
-        // the byte budget cannot see, and MOBILEGL_IPC_WIRE_DEFERRED_MB=0 disables it too.
-        static constexpr SizeT kWireDeferredCountCeiling = 1024;
-        // Teardown: the caller has proven the device idle (Shutdown / RecreateTransientArenas).
-        void DestroyAllDeferredWireReleases();
-        // THE one Fatal{ResourceUnavailable, "buffer-write-sync"} site (rule I: no second abort
-        // for the census to count), shared by the host write that cannot wait for the GPU and
-        // the watermark that cannot. `site` says which.
-        [[noreturn]] static void WireBufferSyncFatal(const char* site);
-        // The wbuf[] gauges (PipeStats.h, Gauge::WireBuffers..WireDeferredSyncs). The peaks are
-        // taken at the two points the numbers can rise - a park and a mint - and published when
-        // the stats channel is on; MagmaWireReclaimScenario reads them off the server's line.
-        void NoteWireStorePeaks();
-        void PublishWireReclaimGauges();
-#endif
-        Bool InitializeTransientArenas();
-        static VkBufferUsageFlags GetVkBufferUsage(BufferKind kind);
-        VkBufferResource* GetOrCreateResource(const SharedPtr<MG_State::GLState::BufferObject>& bufferObject);
-        static VkBufferResource* ResourceOf(MG_State::GLState::BufferObject& bufferObject);
-        Bool CreateResidentStorage(VkBufferResource& resource, VkDeviceSize size, VkBufferUsageFlags usage,
-                                   VkMemoryPropertyFlags requiredFlags = 0);
-        // Swap storage (conditional orphan) and refill it from the shadow copy.
-        Bool SwapStorageAndUploadAll(VkBufferResource& resource, MG_State::GLState::BufferObject& bufferObject);
-        // Record a staging-slice copy into the resident storage, ordered against
-        // in-flight and already-recorded GPU work.
-        Bool StagedRangeCopy(VkBufferResource& resource, const void* data,
-                             SizeT offset, SizeT size);
-#if MOBILEGL_BUILD_DISAGGREGATED
-        Bool StagedWireRangeCopy(WireBufferResource& resource, const void* data, SizeT offset, SizeT size);
-#endif
-        void CollectDeferredReleases(Uint32 frameIndex);
-        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;
-        // See AcquireUnboundStorageDescriptor. Lazily created, never re-created, torn down
-        // with the manager.
-        VkBufferObject m_unboundStorageBuffer;
-        // See AcquireUnboundTexelBufferDescriptor. Same lifetime rules.
-        VkBufferObject m_unboundTexelBuffer;
-        IBufferCopyCommandProvider* m_copyProvider = nullptr;
-        Vector<Vector<VkBufferObject>> m_deferredBufferReleases;
-        Vector<Vector<SharedPtr<VkBufferResource>>> m_deferredResourceReleases;
-        Vector<WeakPtr<VkBufferResource>> m_liveResources;
-#if MOBILEGL_BUILD_DISAGGREGATED
-        std::unordered_map<Uint64, WireBufferResource> m_wireBuffers;
-        // See DeferredWireRelease. ONE FLAT LIST rather than the per-frame-slot buckets above:
-        // the whole point is that these entries do not wait for a frame slot to come round.
-        Vector<DeferredWireRelease> m_deferredWireReleases;
-        // Bytes currently parked in that list, kept exact so the watermark needs no walk.
-        Uint64 m_deferredWireBytes = 0;
-        // Live VkBuffers this arm owns: the stores held by m_wireBuffers plus the parked ones.
-        // Maintained rather than counted, because the publish runs on every park.
-        Uint64 m_wireStoreCount = 0;
-        // Run maxima of the two numbers above and the watermark's sync count, for the gauges.
-        Uint64 m_wireStoreCountPeak = 0;
-        Uint64 m_deferredWireBytesPeak = 0;
-        Uint64 m_wireDeferredSyncs = 0;
-        // See GetWireStoreDestroyEpoch and the DeferredWireRelease comment. Bumped on every
-        // path that destroys a wire store's VkBuffer, and never reset (not even by Shutdown),
-        // for m_sliceEpochCounter's reason: a memo taken before a re-initialize must not match
-        // a handle minted after it.
-        Uint64 m_wireStoreDestroyEpoch = 0;
-#endif
-    // 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

@@ -1,256 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferObject.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 "VkBufferObject.h"
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-#include <MG_Remote/Transport/AdoptT0.h>
-#endif
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-#if MOBILEGL_BUILD_DISAGGREGATED
-    void VkBufferObject::MoveExternalFrom(VkBufferObject& other) {
-        m_device = other.m_device;
-        m_externalMemory = other.m_externalMemory;
-        m_externalAhb = other.m_externalAhb;
-        m_externalCoherent = other.m_externalCoherent;
-        other.m_device = VK_NULL_HANDLE;
-        other.m_externalMemory = VK_NULL_HANDLE;
-        other.m_externalAhb = nullptr;
-        other.m_externalCoherent = true;
-    }
-
-    void VkBufferObject::AdoptExternal(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize size,
-                                       void* mapped, Bool coherent, void* ahb) {
-        Destroy();
-        m_device = device;
-        m_buffer = buffer;
-        m_externalMemory = memory;
-        m_mappedData = mapped;
-        m_size = size;
-        m_externalCoherent = coherent;
-        m_externalAhb = ahb;
-    }
-#endif
-
-    VkBufferObject::VkBufferObject(VkBufferObject&& other) noexcept {
-        m_allocator = other.m_allocator;
-        m_buffer = other.m_buffer;
-        m_allocation = other.m_allocation;
-        m_mappedData = other.m_mappedData;
-        m_size = other.m_size;
-#if MOBILEGL_BUILD_DISAGGREGATED
-        MoveExternalFrom(other);
-#endif
-
-        other.m_allocator = nullptr;
-        other.m_buffer = VK_NULL_HANDLE;
-        other.m_allocation = nullptr;
-        other.m_mappedData = nullptr;
-        other.m_size = 0;
-    }
-
-    VkBufferObject& VkBufferObject::operator=(VkBufferObject&& other) noexcept {
-        if (this == &other) {
-            return *this;
-        }
-
-        Destroy();
-
-        m_allocator = other.m_allocator;
-        m_buffer = other.m_buffer;
-        m_allocation = other.m_allocation;
-        m_mappedData = other.m_mappedData;
-        m_size = other.m_size;
-#if MOBILEGL_BUILD_DISAGGREGATED
-        MoveExternalFrom(other);
-#endif
-
-        other.m_allocator = nullptr;
-        other.m_buffer = VK_NULL_HANDLE;
-        other.m_allocation = nullptr;
-        other.m_mappedData = nullptr;
-        other.m_size = 0;
-        return *this;
-    }
-
-    VkBufferObject::~VkBufferObject() {
-        Destroy();
-    }
-
-    Bool VkBufferObject::Create(const VkBufferObjectDesc& desc) {
-        return Create(desc.allocator, desc.size, desc.usage, desc.memoryUsage, desc.allocationFlags,
-                      desc.requiredFlags);
-    }
-
-    Bool VkBufferObject::Create(VmaAllocator allocator, VkDeviceSize size, VkBufferUsageFlags usage,
-                                VmaMemoryUsage memoryUsage, VmaAllocationCreateFlags allocationFlags,
-                                VkMemoryPropertyFlags requiredFlags) {
-        MOBILEGL_ASSERT(allocator != nullptr, "VkBufferObject::Create requires valid VMA allocator");
-        MOBILEGL_ASSERT(size > 0, "VkBufferObject::Create requires non-zero size");
-
-        Destroy();
-        m_allocator = allocator;
-
-        VkBufferCreateInfo bufferInfo{};
-        bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-        bufferInfo.size = size;
-        bufferInfo.usage = usage;
-        bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-
-        VmaAllocationCreateInfo allocationInfo{};
-        allocationInfo.usage = memoryUsage;
-        allocationInfo.flags = allocationFlags;
-        allocationInfo.requiredFlags = requiredFlags;
-
-        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);
-            m_allocator = nullptr;
-            m_buffer = VK_NULL_HANDLE;
-            m_allocation = nullptr;
-            m_size = 0;
-            return false;
-        }
-
-        m_size = size;
-        return true;
-    }
-
-    void VkBufferObject::Destroy() {
-#if MOBILEGL_BUILD_DISAGGREGATED
-        if (m_externalMemory != VK_NULL_HANDLE) {
-            // P11 B2 (T0): an imported AHardwareBuffer store. Reached through the wire arm's
-            // deferred release, i.e. once no submission can still name it.
-            if (m_mappedData != nullptr) vkUnmapMemory(m_device, m_externalMemory);
-            if (m_buffer != VK_NULL_HANDLE) vkDestroyBuffer(m_device, m_buffer, nullptr);
-            vkFreeMemory(m_device, m_externalMemory, nullptr);
-            MG_Remote::Transport::AdoptT0::ReleaseImported(m_externalAhb);
-            m_mappedData = nullptr;
-            m_buffer = VK_NULL_HANDLE;
-            m_externalMemory = VK_NULL_HANDLE;
-            m_externalAhb = nullptr;
-            m_device = VK_NULL_HANDLE;
-            m_externalCoherent = true;
-            m_size = 0;
-            return;
-        }
-#endif
-        Unmap();
-        if (m_allocator != nullptr && m_buffer != VK_NULL_HANDLE && m_allocation != nullptr) {
-            vmaDestroyBuffer(m_allocator, m_buffer, m_allocation);
-        }
-        m_buffer = VK_NULL_HANDLE;
-        m_allocation = nullptr;
-        m_allocator = nullptr;
-        m_size = 0;
-    }
-
-    void* VkBufferObject::Map() {
-        MOBILEGL_ASSERT(IsValid(), "VkBufferObject::Map called on invalid buffer");
-
-        if (m_mappedData != nullptr) {
-            return m_mappedData;
-        }
-
-        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);
-            m_mappedData = nullptr;
-            return nullptr;
-        }
-
-        return m_mappedData;
-    }
-
-    void VkBufferObject::Unmap() {
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // An imported store stays mapped for its life (Destroy unmaps it).
-        if (m_externalMemory != VK_NULL_HANDLE) return;
-#endif
-        if (!IsValid() || m_mappedData == nullptr) {
-            m_mappedData = nullptr;
-            return;
-        }
-
-        vmaUnmapMemory(m_allocator, m_allocation);
-        m_mappedData = nullptr;
-    }
-
-    Bool VkBufferObject::Upload(const void* data, VkDeviceSize size, VkDeviceSize offset) {
-        MOBILEGL_ASSERT(IsValid(), "VkBufferObject::Upload called on invalid buffer");
-        MOBILEGL_ASSERT(data != nullptr || size == 0, "VkBufferObject::Upload data pointer is null");
-        MOBILEGL_ASSERT(offset + size <= m_size, "VkBufferObject::Upload out of range");
-
-        if (size == 0) {
-            return true;
-        }
-
-        const Bool wasMapped = IsMapped();
-        void* mapped = wasMapped ? m_mappedData : Map();
-        if (mapped == nullptr) {
-            MGLOG_E_ONCE("VkBufferObject::Upload failed: unable to map buffer");
-            return false;
-        }
-
-        Memcpy(static_cast<Uint8*>(mapped) + offset, data, static_cast<SizeT>(size));
-#if MOBILEGL_BUILD_DISAGGREGATED
-        if (m_externalMemory != VK_NULL_HANDLE) {
-            if (m_externalCoherent) return true;
-            VkMappedMemoryRange range{VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE};
-            range.memory = m_externalMemory;
-            range.offset = 0;
-            range.size = VK_WHOLE_SIZE;
-            return vkFlushMappedMemoryRanges(m_device, 1, &range) == VK_SUCCESS;
-        }
-#endif
-        const VkResult flushResult = vmaFlushAllocation(m_allocator, m_allocation, offset, size);
-        if (flushResult != VK_SUCCESS) {
-            MGLOG_E_ONCE("VkBufferObject::Upload failed: vmaFlushAllocation returned %d", flushResult);
-            if (!wasMapped) {
-                Unmap();
-            }
-            return false;
-        }
-        if (!wasMapped) {
-            Unmap();
-        }
-        return true;
-    }
-
-    Bool VkBufferObject::Invalidate(VkDeviceSize size, VkDeviceSize offset) {
-        MOBILEGL_ASSERT(IsValid(), "VkBufferObject::Invalidate called on invalid buffer");
-        MOBILEGL_ASSERT(IsMapped(), "VkBufferObject::Invalidate requires mapped memory");
-        MOBILEGL_ASSERT(offset <= m_size, "VkBufferObject::Invalidate offset out of range");
-
-        const VkDeviceSize resolvedSize = size == VK_WHOLE_SIZE ? m_size - offset : size;
-        MOBILEGL_ASSERT(offset + resolvedSize <= m_size, "VkBufferObject::Invalidate range out of bounds");
-        if (resolvedSize == 0) {
-            return true;
-        }
-#if MOBILEGL_BUILD_DISAGGREGATED
-        if (m_externalMemory != VK_NULL_HANDLE) {
-            if (m_externalCoherent) return true;
-            VkMappedMemoryRange range{VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE};
-            range.memory = m_externalMemory;
-            range.offset = 0;
-            range.size = VK_WHOLE_SIZE;
-            return vkInvalidateMappedMemoryRanges(m_device, 1, &range) == VK_SUCCESS;
-        }
-#endif
-
-        const VkResult result = vmaInvalidateAllocation(m_allocator, m_allocation, offset, resolvedSize);
-        if (result != VK_SUCCESS) {
-            MGLOG_E_ONCE("VkBufferObject::Invalidate failed: vmaInvalidateAllocation returned %d", result);
-            return false;
-        }
-        return true;
-    }
-
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferObject.h

@@ -1,101 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferObject.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 "BufferSlice.h"
-#include "../VkIncludes.h"
-#include <Includes.h>
-#include <vk_mem_alloc.h>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    struct VkBufferObjectDesc {
-        VmaAllocator allocator = nullptr;
-        VkDeviceSize size = 0;
-        VkBufferUsageFlags usage = 0;
-        VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_AUTO;
-        VmaAllocationCreateFlags allocationFlags = 0;
-        // Memory property bits the allocation MUST satisfy (e.g. HOST_VISIBLE|HOST_COHERENT
-        // for a persistently-mapped buffer the app writes into without explicit flushes).
-        VkMemoryPropertyFlags requiredFlags = 0;
-    };
-
-    class VkBufferObject {
-    public:
-        VkBufferObject() = default;
-        ~VkBufferObject();
-
-        VkBufferObject(const VkBufferObject&) = delete;
-        VkBufferObject& operator=(const VkBufferObject&) = delete;
-        VkBufferObject(VkBufferObject&& other) noexcept;
-        VkBufferObject& operator=(VkBufferObject&& other) noexcept;
-
-        Bool Create(const VkBufferObjectDesc& desc);
-        Bool Create(VmaAllocator allocator, VkDeviceSize size, VkBufferUsageFlags usage,
-                    VmaMemoryUsage memoryUsage, VmaAllocationCreateFlags allocationFlags = 0,
-                    VkMemoryPropertyFlags requiredFlags = 0);
-        void Destroy();
-
-        void* Map();
-        void Unmap();
-        Bool Upload(const void* data, VkDeviceSize size, VkDeviceSize offset = 0);
-        Bool Invalidate(VkDeviceSize size = VK_WHOLE_SIZE, VkDeviceSize offset = 0);
-
-        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;
-        }
-        void* GetMappedData() const { return m_mappedData; }
-        Bool IsMapped() const { return m_mappedData != nullptr; }
-        Bool IsValid() const {
-#if MOBILEGL_BUILD_DISAGGREGATED
-            if (m_externalMemory != VK_NULL_HANDLE) return m_buffer != VK_NULL_HANDLE;
-#endif
-            return m_allocator != nullptr && m_buffer != VK_NULL_HANDLE && m_allocation != nullptr;
-        }
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // P11 B2 (T0): a store whose memory is NOT this allocator's - a client's AHardwareBuffer
-        // imported with VK_ANDROID_external_memory_android_hardware_buffer into `memory` (a
-        // dedicated allocation bound to `buffer`, mapped persistently at `mapped`). It behaves
-        // like any mapped store (GetSlice, Upload, Invalidate), and Destroy frees the buffer and
-        // the memory and drops `ahb` - which is why the store goes through the wire arm's
-        // serial-gated deferred release like every other: the AHardwareBuffer is let go only once
-        // no submission can still name it. `coherent` = the memory type is HOST_COHERENT.
-        void AdoptExternal(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize size,
-                           void* mapped, Bool coherent, void* ahb);
-        Bool IsExternal() const { return m_externalMemory != VK_NULL_HANDLE; }
-#endif
-
-    private:
-        VmaAllocator m_allocator = nullptr;
-        VkBuffer m_buffer = VK_NULL_HANDLE;
-        VmaAllocation m_allocation = nullptr;
-        void* m_mappedData = nullptr;
-        VkDeviceSize m_size = 0;
-#if MOBILEGL_BUILD_DISAGGREGATED
-        VkDevice m_device = VK_NULL_HANDLE;
-        VkDeviceMemory m_externalMemory = VK_NULL_HANDLE;
-        void* m_externalAhb = nullptr;
-        Bool m_externalCoherent = true;
-        void MoveExternalFrom(VkBufferObject& other);
-#endif
-    };
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.cpp

@@ -1,537 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.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 "VkClearManager.h"
-
-// For the shared ResolveAttachmentLayerCount (and the ToVulkanLevelExtent it is built on): the
-// clear key's layer span has to be the same one the render pass builds its attachment view from.
-#include "VkTextureManager.h"
-
-#include "MG_State/GLState/Core.h"
-#include <MG_Pipe/PipeInputsSwitch.h>
-#include "MG_Util/Converters/MGToStr/FramebufferEnumConverter.h"
-#include "MG_Util/Converters/MGToStr/TextureEnumConverter.h"
-
-#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 (MGB_CTX->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;
-    }
-
-    static Uint32 ResolveAttachmentBaseArrayLayer(TextureUploadTarget target) {
-        if (!IsCubeMapFaceUploadTarget(target)) {
-            return 0;
-        }
-        return static_cast<Uint32>(target) - static_cast<Uint32>(TextureUploadTarget::CubeMapPositiveX);
-    }
-
-    static Uint32 ResolveAttachmentBaseArrayLayer(
-        const MG_State::GLState::FramebufferAttachmentObject& attachment) {
-        if (attachment.IsLayered()) {
-            return 0;
-        }
-        const TextureUploadTarget uploadTarget = attachment.GetTextureUploadTarget();
-        if (!IsCubeMapFaceUploadTarget(uploadTarget)) {
-            return static_cast<Uint32>(std::max(attachment.GetTextureLayer(), 0));
-        }
-        return ResolveAttachmentBaseArrayLayer(uploadTarget);
-    }
-
-    // ResolveAttachmentLayerCount used to be duplicated here, reading attachment.GetSize().z()
-    // raw - no ToVulkanLevelExtent remap for a 1D array, no six-faces arm for a cube map. That is
-    // not a cosmetic difference: the count below is not key-only, it is written straight into
-    // VkImageSubresourceRange::layerCount by MaterializePendingClearForTexture, which then POPS
-    // the entry - so a layered cube map's glClear reached one face and the other five were lost
-    // for good, while the very same queued clear cleared all six through the render pass's
-    // LOAD_OP_CLEAR. The helper now lives once, in VkTextureManager.h beside ToVulkanLevelExtent.
-
-    static const MG_State::GLState::FramebufferAttachmentObject* GetClearableAttachment(
-        const MG_State::GLState::FramebufferObject& drawFbo, FramebufferAttachmentType attachmentType) {
-        if (attachmentType == FramebufferAttachmentType::None) {
-            return nullptr;
-        }
-
-        const auto& attachment = drawFbo.GetAttachment(attachmentType);
-        if (!attachment.IsTexture() || attachment.IsRenderbuffer()) {
-            return nullptr;
-        }
-
-        return &attachment;
-    }
-
-    // The texture a pending clear is actually ABOUT. A clear issued through a GL texture view
-    // (ARB_texture_view) targets the storage it views, so it must queue against - and be found
-    // by - the storage texture; keying it on the view instead left the clear invisible to every
-    // materialisation done through the parent's name (and vice versa), so the image stayed in
-    // VK_IMAGE_LAYOUT_UNDEFINED and the readback was dropped as unreadable.
-    static MG_State::GLState::ITextureObject* ClearStorageTextureOf(MG_State::GLState::ITextureObject* texture) {
-        if (texture == nullptr) {
-            return nullptr;
-        }
-        const auto& storageOwner = texture->GetViewStorageOwner();
-        return storageOwner ? storageOwner.get() : texture;
-    }
-
-    PendingClearKey VkClearManager::MakePendingClearKey(MG_State::GLState::ITextureObject* rawTexture, Uint32 mipLevel,
-                                                        Uint32 baseArrayLayer, Uint32 layerCount) {
-        MG_State::GLState::ITextureObject* texture = ClearStorageTextureOf(rawTexture);
-        if (rawTexture != nullptr && texture != rawTexture) {
-            // The caller named a level and a layer of the VIEW; the key describes the STORAGE, so
-            // both have to be shifted into its numbering (GL 4.6 core 8.18). Without this a clear
-            // of a view's level 0 would collide with a clear of the storage's level 0 even when
-            // the view opened onto level 1.
-            mipLevel += static_cast<Uint32>(rawTexture->GetViewMinLevel());
-            baseArrayLayer += static_cast<Uint32>(rawTexture->GetViewMinLayer());
-        }
-        return PendingClearKey {
-            .texture = texture,
-            .textureLifetimeId = texture ? texture->GetLifetimeId() : 0,
-            .mipLevel = mipLevel,
-            .baseArrayLayer = baseArrayLayer,
-            .layerCount = layerCount,
-        };
-    }
-
-    PendingClearKey VkClearManager::MakePendingClearKey(
-        const MG_State::GLState::FramebufferAttachmentObject& attachment) {
-        MOBILEGL_ASSERT(attachment.IsTexture() && !attachment.IsRenderbuffer(),
-                        "MakePendingClearKey requires a texture framebuffer attachment");
-        auto* texture = attachment.GetTexture().get();
-        MOBILEGL_ASSERT(texture != nullptr, "MakePendingClearKey: texture attachment resolved to null");
-        const Uint32 mipLevel = static_cast<Uint32>(std::max(attachment.GetTextureLevel(), 0));
-        const Uint32 baseArrayLayer = ResolveAttachmentBaseArrayLayer(attachment);
-        const Uint32 layerCount = ResolveAttachmentLayerCount(attachment);
-        return MakePendingClearKey(texture, mipLevel, baseArrayLayer, layerCount);
-    }
-
-    Bool VkClearManager::Initialize() {
-        return true;
-    }
-
-    void VkClearManager::Shutdown() {
-        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) {
-        // Same rule as VkTextureManager::MakeTextureIdentity: a GL texture view is identified by
-        // the storage it views. A clear posted against a view and one posted against its parent
-        // target the same image, so they have to coalesce rather than queue independently.
-        if (texture != nullptr) {
-            const auto& storageOwner = texture->GetViewStorageOwner();
-            if (storageOwner) {
-                texture = storageOwner.get();
-            }
-        }
-        return TextureIdentity {
-            .texture = texture,
-            .lifetimeId = texture ? texture->GetLifetimeId() : 0,
-        };
-    }
-
-    void VkClearManager::MergeClearPayload(ClearAttachmentPayload& dst, const ClearAttachmentPayload& src) {
-        dst.mask |= src.mask;
-        if ((src.mask & GL_COLOR_BUFFER_BIT) != 0) {
-            // The whole colour story travels together (same rule as
-            // VkRenderPassManager::QueueRenderbufferClear): a glClearBufferiv/uiv
-            // payload carries its value in colorInt/colorUint and its branch selector
-            // in colorEncoding - dropping them here would leave the pending clear
-            // reading as an all-zero float one.
-            dst.color = src.color;
-            dst.colorEncoding = src.colorEncoding;
-            dst.colorInt = src.colorInt;
-            dst.colorUint = src.colorUint;
-        }
-        if ((src.mask & GL_DEPTH_BUFFER_BIT) != 0) {
-            dst.depth = src.depth;
-        }
-        if ((src.mask & GL_STENCIL_BUFFER_BIT) != 0) {
-            dst.stencil = src.stencil;
-        }
-    }
-
-    void VkClearManager::ErasePendingClearsForTextureLocked(const TextureIdentity& identity) {
-        Vector<PendingClearKey> keysToErase;
-        keysToErase.reserve(m_pendingClears.size());
-        for (auto it = m_pendingClears.begin(); it != m_pendingClears.end(); ++it) {
-            if (PendingClearMatchesTextureIdentity(it->first, identity)) {
-                keysToErase.emplace_back(it->first);
-            }
-        }
-        for (const auto& key : keysToErase) {
-            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,
-                                                   SharedPtr<MG_State::GLState::ITextureObject>& outTexture) {
-        outTexture.reset();
-        if (identity.texture == nullptr) {
-            return false;
-        }
-
-        auto aliveIt = m_aliveObjects.find(identity);
-        if (aliveIt == m_aliveObjects.end()) {
-            ErasePendingClearsForTextureLocked(identity);
-            return false;
-        }
-
-        outTexture = aliveIt->second.lock();
-        if (!outTexture || outTexture.get() != identity.texture || outTexture->GetLifetimeId() != identity.lifetimeId) {
-            ErasePendingClearsForTextureLocked(identity);
-            outTexture.reset();
-            return false;
-        }
-
-        return true;
-    }
-
-    Bool VkClearManager::LockTextureLocked(const PendingClearKey& key,
-                                           SharedPtr<MG_State::GLState::ITextureObject>& outTexture) {
-        return LockTextureIdentityLocked(TextureIdentity{
-            .texture = key.texture,
-            .lifetimeId = key.textureLifetimeId,
-        }, outTexture);
-    }
-
-    void VkClearManager::QueueClear(GLbitfield mask, const ClearFramebufferPayload& clearPayload,
-                                    const MG_State::GLState::FramebufferObject& drawFbo) {
-        if (mask & GL_COLOR_BUFFER_BIT) {
-            auto& drawbufs = drawFbo.GetDrawBuffers();
-            // This should automatically work on default & offscreen FBO
-            for (auto drawbuf: drawbufs) {
-                const auto* attachment = GetClearableAttachment(drawFbo, drawbuf);
-                if (!attachment) {
-                    continue;
-                }
-
-                QueueClear({
-                    .mask = GL_COLOR_BUFFER_BIT,
-                    .color = clearPayload.color
-                }, *attachment);
-
-                MGLOG_D("%s: %s (texture %d) - color = (%.2f, %.2f, %.2f, %.2f)", __func__,
-                    MG_Util::ConvertFramebufferAttachmentTypeToString(drawbuf).c_str(),
-                    attachment->GetTexture()->GetExternalIndex(),
-                    clearPayload.color[0], clearPayload.color[1], clearPayload.color[2], clearPayload.color[3]);
-            }
-        }
-
-        if (mask & GL_DEPTH_BUFFER_BIT) {
-            const auto* attachment = GetClearableAttachment(drawFbo, FramebufferAttachmentType::Depth);
-            if (attachment) {
-                QueueClear({
-                    .mask = GL_DEPTH_BUFFER_BIT,
-                    .depth = clearPayload.depth,
-                }, *attachment);
-
-                MGLOG_D("%s: Depth (texture %d) - depth = (%.2f)", __func__,
-                    attachment->GetTexture()->GetExternalIndex(), clearPayload.depth);
-            }
-        }
-
-        if (mask & GL_STENCIL_BUFFER_BIT) {
-            const auto* attachment = GetClearableAttachment(drawFbo, FramebufferAttachmentType::Stencil);
-            if (attachment) {
-                QueueClear({
-                    .mask = GL_STENCIL_BUFFER_BIT,
-                    .stencil = clearPayload.stencil,
-                }, *attachment);
-
-                MGLOG_D("%s: Stencil (texture %d) - stencil = (%u)", __func__,
-                    attachment->GetTexture()->GetExternalIndex(), clearPayload.stencil);
-            }
-        }
-    }
-
-    void VkClearManager::QueueClear(const ClearAttachmentPayload& clearPayload,
-                                    const SharedPtr<MG_State::GLState::ITextureObject>& texture) {
-        if (clearPayload.mask == 0 || !texture) {
-            return;
-        }
-
-        const auto& storageOwner = texture->GetViewStorageOwner();
-        const SharedPtr<MG_State::GLState::ITextureObject>& storageTexture = storageOwner ? storageOwner : texture;
-        const PendingClearKey key = MakePendingClearKey(storageTexture.get());
-        const std::lock_guard<std::mutex> lock(m_mutex);
-        m_aliveObjects[MakeTextureIdentity(storageTexture.get())] = storageTexture;
-        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,
-                                    const MG_State::GLState::FramebufferAttachmentObject& attachment) {
-        if (clearPayload.mask == 0 || !attachment.IsTexture() || attachment.IsRenderbuffer()) {
-            return;
-        }
-        const auto texture = attachment.GetTexture();
-        if (!texture) {
-            return;
-        }
-
-        const PendingClearKey key = MakePendingClearKey(attachment);
-        // The alive entry must hold the STORAGE object, because the key names it:
-        // LockTextureIdentityLocked cross-checks the two, and registering a view here under its
-        // storage's identity made every lookup of this clear fail that check and silently report
-        // "nothing pending" - which is how a clear issued through a view's framebuffer vanished.
-        const auto& storageOwner = texture->GetViewStorageOwner();
-        const SharedPtr<MG_State::GLState::ITextureObject>& storageTexture = storageOwner ? storageOwner : texture;
-        const std::lock_guard<std::mutex> lock(m_mutex);
-        m_aliveObjects[MakeTextureIdentity(storageTexture.get())] = storageTexture;
-        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) {
-        if (texture == nullptr) {
-            return false;
-        }
-
-        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
-            return false;  // per-draw hot path: nothing pending anywhere
-        }
-
-        texture = ClearStorageTextureOf(texture);
-        const Uint64 lifetimeId = texture->GetLifetimeId();
-        const std::lock_guard<std::mutex> lock(m_mutex);
-        for (auto it = m_pendingClears.begin(); it != m_pendingClears.end(); ++it) {
-            if (it->first.texture == texture && it->first.textureLifetimeId == lifetimeId) {
-                SharedPtr<MG_State::GLState::ITextureObject> liveTexture;
-                return LockTextureLocked(it->first, liveTexture);
-            }
-        }
-        return false;
-    }
-
-    Bool VkClearManager::HasPendingClear(const PendingClearKey& key) {
-        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()) {
-            return false;
-        }
-
-        SharedPtr<MG_State::GLState::ITextureObject> liveTexture;
-        return LockTextureLocked(key, liveTexture);
-    }
-
-    Bool VkClearManager::HasPendingClear(const MG_State::GLState::FramebufferAttachmentObject& attachment) {
-        if (!attachment.IsTexture() || attachment.IsRenderbuffer() || !attachment.GetTexture()) {
-            return false;
-        }
-        return HasPendingClear(MakePendingClearKey(attachment));
-    }
-
-    Bool VkClearManager::GetPendingClear(const PendingClearKey& key, ClearAttachmentPayload& outPayload) {
-        SharedPtr<MG_State::GLState::ITextureObject> liveTexture;
-        return GetPendingClear(key, outPayload, liveTexture);
-    }
-
-    Bool VkClearManager::GetPendingClear(const PendingClearKey& key, ClearAttachmentPayload& outPayload,
-                                         SharedPtr<MG_State::GLState::ITextureObject>& outTexture) {
-        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)) {
-            return false;
-        }
-        auto it = m_pendingClears.find(key);
-        if (it == m_pendingClears.end()) {
-            outTexture.reset();
-            return false;
-        }
-
-        outPayload = it->second;
-        MGLOG_D("%s: Got pending clear for texture@%p lifetime=%llu, mip=%u layer=%u count=%u mask=0x%x clear value: color = (%.2f, %.2f, %.2f, %.2f), depth = (%.2f), stencil = (%u)", __func__,
-            static_cast<void*>(key.texture),
-            static_cast<unsigned long long>(key.textureLifetimeId),
-            key.mipLevel, key.baseArrayLayer, key.layerCount,
-            static_cast<Uint32>(outPayload.mask),
-            outPayload.color[0], outPayload.color[1], outPayload.color[2], outPayload.color[3],
-            outPayload.depth,
-            outPayload.stencil);
-        return true;
-    }
-
-    Bool VkClearManager::GetPendingClear(const MG_State::GLState::FramebufferAttachmentObject& attachment,
-                                         ClearAttachmentPayload& outPayload) {
-        if (!attachment.IsTexture() || attachment.IsRenderbuffer() || !attachment.GetTexture()) {
-            MGLOG_D("%s: Failed getting pending clear for non-texture framebuffer attachment", __func__);
-            return false;
-        }
-        return GetPendingClear(MakePendingClearKey(attachment), outPayload);
-    }
-
-    Bool VkClearManager::GetPendingClears(MG_State::GLState::ITextureObject* texture,
-                                          Vector<PendingClearEntry>& outEntries) {
-        outEntries.clear();
-        if (texture == nullptr) {
-            return false;
-        }
-        if (m_pendingCount.load(std::memory_order_relaxed) == 0) {
-            return false;  // per-draw hot path: nothing pending anywhere
-        }
-
-        texture = ClearStorageTextureOf(texture);
-        const Uint64 lifetimeId = texture->GetLifetimeId();
-        const std::lock_guard<std::mutex> lock(m_mutex);
-        SharedPtr<MG_State::GLState::ITextureObject> liveTexture;
-        if (!LockTextureIdentityLocked(MakeTextureIdentity(texture), liveTexture)) {
-            return false;
-        }
-        for (auto it = m_pendingClears.begin(); it != m_pendingClears.end(); ++it) {
-            if (it->first.texture == texture && it->first.textureLifetimeId == lifetimeId) {
-                outEntries.emplace_back(PendingClearEntry{.key = it->first, .payload = it->second});
-            }
-        }
-        return !outEntries.empty();
-    }
-
-    void VkClearManager::PopPendingClear(MG_State::GLState::ITextureObject* texture) {
-        if (texture == nullptr) {
-            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);
-        ErasePendingClearsForTextureLocked(identity);
-    }
-
-    void VkClearManager::PopPendingClear(const PendingClearKey& key) {
-        if (key.texture == nullptr) {
-            return;
-        }
-
-        {
-            const std::lock_guard<std::mutex> lock(m_mutex);
-            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);
-            }
-        }
-
-        MGLOG_D("%s: Pop pending clear for texture@%p lifetime=%llu mip=%u layer=%u count=%u", __func__,
-                static_cast<void*>(key.texture), static_cast<unsigned long long>(key.textureLifetimeId),
-                key.mipLevel, key.baseArrayLayer, key.layerCount);
-    }
-
-    void VkClearManager::PopPendingClear(const MG_State::GLState::FramebufferAttachmentObject& attachment) {
-        if (!attachment.IsTexture() || attachment.IsRenderbuffer() || !attachment.GetTexture()) {
-            return;
-        }
-        PopPendingClear(MakePendingClearKey(attachment));
-    }
-
-    SizeT VkClearManager::CollectGarbage() {
-        const std::lock_guard<std::mutex> lock(m_mutex);
-        m_gcCounter++;
-        if (m_gcCounter != 0) {
-            return 0;
-        }
-
-        Vector<TextureIdentity> expiredTextures;
-        expiredTextures.reserve(m_aliveObjects.size());
-        for (auto it = m_aliveObjects.begin(); it != m_aliveObjects.end(); ++it) {
-            if (it->second.expired()) {
-                expiredTextures.emplace_back(it->first);
-            }
-        }
-        if (expiredTextures.empty()) {
-            return 0;
-        }
-
-        for (const auto& identity : expiredTextures) {
-            ErasePendingClearsForTextureLocked(identity);
-        }
-        return expiredTextures.size();
-    }
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.h

@@ -1,169 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.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 "../VkIncludes.h"
-#include "../VulkanRendererConfig.h"
-#include "MG_State/GLState/FramebufferState/FramebufferObject.h"
-#include "MG_Util/Math/VectorTypes.h"
-
-#include <Includes.h>
-#include <atomic>
-#include <unordered_map>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    struct ClearFramebufferPayload {
-        FloatVec4 color;
-        Float depth{};
-        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;
-        Uint32 mipLevel = 0;
-        Uint32 baseArrayLayer = 0;
-        Uint32 layerCount = 1;
-
-        Bool operator==(const PendingClearKey& other) const {
-            return texture == other.texture && textureLifetimeId == other.textureLifetimeId &&
-                   mipLevel == other.mipLevel &&
-                   baseArrayLayer == other.baseArrayLayer && layerCount == other.layerCount;
-        }
-    };
-
-    struct TextureIdentity {
-        MG_State::GLState::ITextureObject* texture = nullptr;
-        Uint64 lifetimeId = 0;
-
-        Bool operator==(const TextureIdentity& other) const {
-            return texture == other.texture && lifetimeId == other.lifetimeId;
-        }
-    };
-
-    struct PendingClearEntry {
-        PendingClearKey key{};
-        ClearAttachmentPayload payload{};
-    };
-
-    struct PendingClearKeyHash {
-        SizeT operator()(const PendingClearKey& key) const {
-            const SizeT textureHash = std::hash<MG_State::GLState::ITextureObject*>{}(key.texture);
-            const SizeT textureLifetimeHash = std::hash<Uint64>{}(key.textureLifetimeId);
-            const SizeT mipHash = std::hash<Uint32>{}(key.mipLevel);
-            const SizeT layerHash = std::hash<Uint32>{}(key.baseArrayLayer);
-            const SizeT layerCountHash = std::hash<Uint32>{}(key.layerCount);
-            SizeT hash = textureHash;
-            hash ^= textureLifetimeHash + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-            hash ^= mipHash + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-            hash ^= layerHash + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-            hash ^= layerCountHash + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-            return hash;
-        }
-    };
-
-    struct TextureIdentityHash {
-        SizeT operator()(const TextureIdentity& key) const {
-            SizeT hash = std::hash<MG_State::GLState::ITextureObject*>{}(key.texture);
-            hash ^= std::hash<Uint64>{}(key.lifetimeId) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-            return hash;
-        }
-    };
-
-    class VkClearManager {
-    public:
-        static PendingClearKey MakePendingClearKey(const MG_State::GLState::FramebufferAttachmentObject& attachment);
-        // Resolves a GL texture view to the storage it views before keying; see the definition.
-        static PendingClearKey MakePendingClearKey(MG_State::GLState::ITextureObject* rawTexture, Uint32 mipLevel = 0,
-                                                   Uint32 baseArrayLayer = 0, Uint32 layerCount = 1);
-
-        Bool Initialize();
-        void Shutdown();
-
-        void QueueClear(GLbitfield mask, const ClearFramebufferPayload& clearPayload, const MG_State::GLState::FramebufferObject& drawFbo);
-        void QueueClear(
-            const ClearAttachmentPayload& clearPayload,
-            const SharedPtr<MG_State::GLState::ITextureObject>& texture);
-        void QueueClear(const ClearAttachmentPayload& clearPayload,
-                        const MG_State::GLState::FramebufferAttachmentObject& attachment);
-        Bool HasPendingClear(MG_State::GLState::ITextureObject* texture);
-        Bool HasPendingClear(const PendingClearKey& key);
-        Bool HasPendingClear(const MG_State::GLState::FramebufferAttachmentObject& attachment);
-        Bool GetPendingClear(const PendingClearKey& key, ClearAttachmentPayload& outPayload);
-        Bool GetPendingClear(const PendingClearKey& key, ClearAttachmentPayload& outPayload,
-                             SharedPtr<MG_State::GLState::ITextureObject>& outTexture);
-        Bool GetPendingClear(const MG_State::GLState::FramebufferAttachmentObject& attachment,
-                             ClearAttachmentPayload& outPayload);
-        Bool GetPendingClears(MG_State::GLState::ITextureObject* texture, Vector<PendingClearEntry>& outEntries);
-        void PopPendingClear(MG_State::GLState::ITextureObject* texture);
-        void PopPendingClear(const PendingClearKey& key);
-        void PopPendingClear(const MG_State::GLState::FramebufferAttachmentObject& attachment);
-        SizeT CollectGarbage();
-    private:
-        static TextureIdentity MakeTextureIdentity(MG_State::GLState::ITextureObject* texture);
-        static void MergeClearPayload(ClearAttachmentPayload& dst, const ClearAttachmentPayload& src);
-        void ErasePendingClearsForTextureLocked(const TextureIdentity& identity);
-        Bool LockTextureIdentityLocked(const TextureIdentity& identity,
-                                      SharedPtr<MG_State::GLState::ITextureObject>& outTexture);
-        Bool LockTextureLocked(const PendingClearKey& key,
-                               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;
-    };
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.h

@@ -1,422 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.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 "SwapchainObject.h"
-#include "VkClearManager.h"
-#include "VkTextureManager.h"
-#include "../VkIncludes.h"
-#include "../VulkanRendererConfig.h"
-#include "MG_State/GLState/FramebufferState/FramebufferObject.h"
-
-#include <Includes.h>
-#include <unordered_map>
-#include <vk_mem_alloc.h>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    enum class TrackedAttachmentTarget : Uint8 {
-        Texture,
-        Renderbuffer,
-        SwapchainColor,
-        SwapchainDepthStencil
-    };
-
-    struct PendingClearAttachmentInfo {
-        // Index into the render pass attachment descriptions (VkRenderPassBeginInfo::pClearValues space).
-        Uint32 attachmentIndex = 0;
-        // Index into the subpass pColorAttachments (VkClearAttachment::colorAttachment space) — the GL
-        // draw-buffer slot. Differs from attachmentIndex when earlier slots are GL_NONE/incomplete.
-        // Only meaningful for color clears.
-        Uint32 colorAttachmentSlot = 0;
-        PendingClearKey key{};
-        MG_State::GLState::RenderbufferObject* renderbuffer = nullptr;
-        Bool hasInlinePayload = false;
-        ClearAttachmentPayload inlinePayload{};
-    };
-
-    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;
-        VkImageLayout finalLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-    };
-
-    struct DepthStencilAttachmentLoadInfo {
-        VkAttachmentLoadOp depthLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
-        VkAttachmentLoadOp stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
-        VkImageLayout initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-    };
-
-    DepthStencilAttachmentLoadInfo ResolveDepthStencilAttachmentLoadInfo(
-        VkImageLayout trackedLayout, Bool clearDepth, Bool clearStencil);
-    IntVec2 ResolveRenderPassFramebufferExtent(Bool isDefaultFbo, const TextureSize& attachmentExtent,
-                                               VkExtent2D swapchainExtent);
-
-    struct RenderPassEntry {
-        static inline VkDevice s_device;
-        static inline Vector<VkTextureManager::TextureResource*> s_textureResourcesScratch;
-        Uint64 hash = 0;
-        VkRenderPass renderPass = VK_NULL_HANDLE;
-        VkFramebuffer framebuffer = VK_NULL_HANDLE;
-        Uint64 compatibilityHash = 0;
-        Vector<PendingClearAttachmentInfo> pendingClearAttachments;
-        Vector<TrackedAttachmentLayoutInfo> trackedAttachmentLayouts;
-        Uint32 attachmentCount = 0;
-        Uint32 colorAttachmentCount = 0;
-        Bool hasDepthStencilAttachment = false;
-        VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_1_BIT;
-        IntVec2 extent = {0, 0};
-        // VkFramebufferCreateInfo::layers of the entry's framebuffer (>1 for layered GL attachments).
-        Uint32 layers = 1;
-        // Frame counter value of the last GetOrCreateRenderPass hit; drives cache eviction.
-        Uint64 lastUsedFrame = 0;
-
-        RenderPassEntry() = default;
-        RenderPassEntry(const RenderPassEntry&) = delete;
-        RenderPassEntry(RenderPassEntry&& that) noexcept {
-            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);
-        }
-        // 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,
-            VkFramebuffer framebuffer,
-            Uint64 compatibilityHash,
-            const Vector<PendingClearAttachmentInfo>& pendingClearAttachments,
-            const Vector<TrackedAttachmentLayoutInfo>& trackedAttachmentLayouts,
-            Uint32 attachmentCount,
-            Uint32 colorAttachmentCount,
-            Bool hasDepthStencilAttachment,
-            VkSampleCountFlagBits sampleCount,
-            IntVec2 extent, Uint32 layers):
-            hash(hash),
-            renderPass(renderpass),
-            framebuffer(framebuffer),
-            compatibilityHash(compatibilityHash),
-            pendingClearAttachments(Move(pendingClearAttachments)),
-            trackedAttachmentLayouts(Move(trackedAttachmentLayouts)),
-            attachmentCount(attachmentCount),
-            colorAttachmentCount(colorAttachmentCount),
-            hasDepthStencilAttachment(hasDepthStencilAttachment),
-            sampleCount(sampleCount),
-            extent(extent),
-            layers(layers)
-        {}
-
-        ~RenderPassEntry() {
-            if (renderPass != VK_NULL_HANDLE) {
-                vkDestroyRenderPass(s_device, renderPass, nullptr);
-            }
-            if (framebuffer != VK_NULL_HANDLE) {
-                vkDestroyFramebuffer(s_device, framebuffer, nullptr);
-            }
-        }
-
-        Bool CompatibleWith(const RenderPassEntry& that) const {
-            return this->compatibilityHash == that.compatibilityHash;
-        }
-
-        Bool CompatibleWith(Uint64 compatibilityHash) const {
-            return this->compatibilityHash == compatibilityHash;
-        }
-    };
-
-    struct ActiveRenderPassInfo {
-        Uint64 hash = 0;
-        Uint64 compatibilityHash = 0;
-        Vector<TrackedAttachmentLayoutInfo> trackedAttachmentLayouts;
-        IntVec2 extent = {0, 0};
-
-        Bool CompatibleWith(const RenderPassEntry& that) const {
-            return compatibilityHash == that.compatibilityHash;
-        }
-
-        Bool CompatibleWith(Uint64 thatCompatibilityHash) const {
-            return compatibilityHash == thatCompatibilityHash;
-        }
-    };
-
-    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).
-        //
-        // Returns NULLPTR when this framebuffer cannot be represented as a Vulkan render pass at
-        // all - a texture the texture manager declined to back (an unsupported format or sample
-        // count), or an attachment view it cannot construct (a layer span the image has no room
-        // for, a 3D image whose format was refused 2D-array compatibility). This used to be
-        // unrepresentable: the function returned a reference, so the only thing the two fallible
-        // calls it builds on could do was trip a MOBILEGL_ASSERT - which is compiled out of every
-        // INFO build - and then dereference the null resource, or hand VK_NULL_HANDLE to
-        // vkCreateFramebuffer. That took the whole process down (51 lost CTS records over 21
-        // bodies, one runner restart each) where a declined draw is merely a wrong picture.
-        //
-        // EVERY caller must handle nullptr by dropping the operation, exactly as the draw path
-        // already drops a draw whose sampler descriptor could not be resolved
-        // (UniformManager::BindProgramUniformBuffers). The failure paths log MGLOG_E_ONCE
-        // themselves, so a caller needs no message of its own.
-        [[nodiscard]] RenderPassEntry* GetOrCreateRenderPass(const MG_State::GLState::FramebufferObject& fbo,
-                                                             Uint32 swapchainImageIndex,
-                                                             Bool drawUsesDepthStencil = true);
-        void QueueRenderbufferClear(GLbitfield mask, const ClearFramebufferPayload& clearPayload,
-                                    const MG_State::GLState::FramebufferObject& drawFbo);
-        void QueueRenderbufferClear(const ClearAttachmentPayload& clearPayload,
-                                    const MG_State::GLState::FramebufferAttachmentObject& attachment);
-        void PopPendingRenderbufferClear(MG_State::GLState::RenderbufferObject* renderbuffer);
-        // Frame boundary hook: ages the render-pass cache and evicts long-unused
-        // entries (their command buffers retired many frames ago).
-        void OnPresent();
-        static Bool BeginRenderPass(VkCommandBuffer commandBuffer, RenderPassEntry& renderPassEntry);
-        static Bool EndRenderPass(VkCommandBuffer commandBuffer);
-        static ActiveRenderPassInfo* GetActiveRenderPass();
-    private:
-        VkDevice m_device = VK_NULL_HANDLE;
-        VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
-        VmaAllocator m_allocator = nullptr;
-        const VulkanRendererConfig& m_config;
-        VkClearManager& m_clearManager;
-        VkTextureManager& m_textureManager;
-        SwapchainObject& m_swapchainObject;
-        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 /
-        // version change, swapchain rotation, any attachment image recreation (the two epochs),
-        // or a pending clear. Portable to Vulkan 1.1 (no dynamic_rendering / imageless FB needed).
-        Bool m_rpFastValid = false;
-        const MG_State::GLState::FramebufferObject* m_rpFastFbo = nullptr;
-        // The FBO's never-reused lifetime id joins the raw pointer + Uint16 version:
-        // a deleted FBO reallocated at the same address whose fresh setup performed
-        // the same number of version bumps would otherwise compare equal (both count
-        // from 0), serving the dead framebuffer's pass to the new object.
-        Uint64 m_rpFastFboLifetimeId = 0;
-        Uint16 m_rpFastFboVersion = 0;
-        Uint32 m_rpFastSwapchainIndex = 0;
-        Uint64 m_rpFastTexEpoch = 0;
-        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;
-            VkExtent2D extent = {0, 0};
-            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*, 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;
-
-        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{};
-        static inline Bool s_hasActiveRenderPass = false;
-        static inline VkClearManager* s_clearManager = nullptr;
-        static inline VkTextureManager* s_textureManager = nullptr;
-        static inline SwapchainObject* s_swapchainObject = nullptr;
-        static inline VkRenderPassManager* s_renderPassManager = nullptr;
-    };
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.cpp

@@ -1,697 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.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 "VkSamplerManager.h"
-
-#include "MG_State/GLState/Core.h"
-
-#include <algorithm>
-#include <cmath>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    namespace {
-#if MOBILEGL_BUILD_DISAGGREGATED
-        // An accessor view over the wire's POD values, not a GL object with constructor,
-        // lifetime ID, allocator hooks or mutation callbacks. Both sources below use
-        // one sampler policy, including format-sensitive border-color conversion.
-        struct SamplerParametersSource {
-            const SamplerParameters& Params;
-            SamplerWrapMode GetWrapS() const { return Params.wrapS; }
-            SamplerWrapMode GetWrapT() const { return Params.wrapT; }
-            SamplerWrapMode GetWrapR() const { return Params.wrapR; }
-            SamplerFilterMode GetMinFilter() const { return Params.minFilter; }
-            SamplerFilterMode GetMagFilter() const { return Params.magFilter; }
-            SamplerMipmapMode GetMipmapMode() const { return Params.mipmapMode; }
-            Float GetMinLod() const { return Params.minLod; }
-            Float GetMaxLod() const { return Params.maxLod; }
-            Float GetLodBias() const { return Params.lodBias; }
-            Float GetMaxAnisotropy() const { return Params.maxAnisotropy; }
-            SamplerCompareMode GetCompareMode() const { return Params.compareMode; }
-            SamplerCompareFunc GetSamplerCompareFunc() const { return Params.compareFunc; }
-            const FloatVec4& GetBorderColor() const { return Params.borderColor; }
-            const IntVec4& GetBorderColorI() const { return Params.borderColorI; }
-            const UintVec4& GetBorderColorUI() const { return Params.borderColorUI; }
-            // Cache identity is entirely content-based; these fields are diagnostics.
-            Uint GetExternalIndex() const { return 0; }
-            Uint16 GetVersion() const { return 0; }
-        };
-
-        template <class SamplerSource>
-        Bool UsesBorderColor(const SamplerSource& sampler) {
-#else
-        Bool UsesBorderColor(const MG_State::GLState::SamplerObject& sampler) {
-#endif
-            return sampler.GetWrapS() == SamplerWrapMode::ClampToBorder ||
-                   sampler.GetWrapT() == SamplerWrapMode::ClampToBorder ||
-                   sampler.GetWrapR() == SamplerWrapMode::ClampToBorder;
-        }
-
-        // The numeric domain the texture is SAMPLED in. Vulkan splits VkBorderColor into a float
-        // family and an integer family and requires the sampler's choice to match the image view's
-        // format (a float border on an integer view, or the reverse, is undefined) - so the domain
-        // comes from the TEXTURE, while the value comes from whichever GL entry point wrote it.
-        enum class BorderColorDomain {
-            Float,
-            SignedInteger,
-            UnsignedInteger
-        };
-
-        BorderColorDomain ResolveBorderColorDomain(TextureInternalFormat format) {
-            switch (format) {
-            case TextureInternalFormat::R8I:
-            case TextureInternalFormat::R16I:
-            case TextureInternalFormat::R32I:
-            case TextureInternalFormat::RG8I:
-            case TextureInternalFormat::RG16I:
-            case TextureInternalFormat::RG32I:
-            case TextureInternalFormat::RGB8I:
-            case TextureInternalFormat::RGB16I:
-            case TextureInternalFormat::RGB32I:
-            case TextureInternalFormat::RGBA8I:
-            case TextureInternalFormat::RGBA16I:
-            case TextureInternalFormat::RGBA32I:
-                return BorderColorDomain::SignedInteger;
-            case TextureInternalFormat::R8UI:
-            case TextureInternalFormat::R16UI:
-            case TextureInternalFormat::R32UI:
-            case TextureInternalFormat::RG8UI:
-            case TextureInternalFormat::RG16UI:
-            case TextureInternalFormat::RG32UI:
-            case TextureInternalFormat::RGB8UI:
-            case TextureInternalFormat::RGB16UI:
-            case TextureInternalFormat::RGB32UI:
-            case TextureInternalFormat::RGBA8UI:
-            case TextureInternalFormat::RGBA16UI:
-            case TextureInternalFormat::RGBA32UI:
-            case TextureInternalFormat::RGB10A2UI:
-                return BorderColorDomain::UnsignedInteger;
-            default:
-                return BorderColorDomain::Float;
-            }
-        }
-
-        Bool IsSignedNormalizedFormat(TextureInternalFormat format) {
-            switch (format) {
-            case TextureInternalFormat::R8Snorm:
-            case TextureInternalFormat::R16Snorm:
-            case TextureInternalFormat::RG8Snorm:
-            case TextureInternalFormat::RG16Snorm:
-            case TextureInternalFormat::RGB8Snorm:
-            case TextureInternalFormat::RGB16Snorm:
-            case TextureInternalFormat::RGBA8Snorm:
-            case TextureInternalFormat::RGBA16Snorm:
-                return true;
-            default:
-                return false;
-            }
-        }
-
-        // GL 4.6 core 8.14.2: "The border values are clamped before they are used, according to the
-        // format in which texture components are stored. For signed and unsigned normalized
-        // fixed-point formats, border values are clamped to [-1,1] and [0,1] respectively. For
-        // floating-point and integer formats, border values are clamped to the representable range of
-        // the format." Every clause of that sentence is a real case here - the clamp is not just the
-        // normalized one.
-        //
-        // Only the 32-bit float formats are genuinely unclamped: every finite float is representable
-        // in them. Half-float has a finite maximum, and the two packed "float" formats are UNSIGNED,
-        // so a negative border on them must come back as 0 rather than as a negative number the
-        // driver delivers verbatim through VK_BORDER_COLOR_FLOAT_CUSTOM_EXT.
-        struct FloatBorderRange {
-            Bool clamped = true;
-            Float minValue = 0.0f;
-            Float maxValue = 1.0f;
-        };
-
-        FloatBorderRange ResolveFloatBorderRange(TextureInternalFormat format, Bool isSignedNormalized) {
-            switch (format) {
-            case TextureInternalFormat::R32F:
-            case TextureInternalFormat::RG32F:
-            case TextureInternalFormat::RGB32F:
-            case TextureInternalFormat::RGBA32F:
-                return {false, 0.0f, 0.0f};
-            case TextureInternalFormat::R16F:
-            case TextureInternalFormat::RG16F:
-            case TextureInternalFormat::RGB16F:
-            case TextureInternalFormat::RGBA16F:
-                return {true, -65504.0f, 65504.0f};
-            // Unsigned packed floats: no sign bit at all. 65024 is the largest 11-bit float; the
-            // 10-bit blue channel tops out lower (64512) and RGB9E5 higher (65408), but the bound
-            // that matters for correctness is the lower one, and a single conservative upper bound
-            // costs nothing a real border colour will ever notice.
-            case TextureInternalFormat::R11FG11FB10F:
-                return {true, 0.0f, 64512.0f};
-            case TextureInternalFormat::RGB9E5:
-                return {true, 0.0f, 65408.0f};
-            default:
-                return {true, isSignedNormalized ? -1.0f : 0.0f, 1.0f};
-            }
-        }
-
-        // Per-component representable range of an integer texture format, as Int64 so that the whole
-        // signed and unsigned 32-bit ranges are expressible in one type and the clamp can be written
-        // once for both domains. Alpha is carried separately because RGB10_A2UI is the one format
-        // whose alpha is narrower than its colour channels.
-        struct IntegerBorderRange {
-            Int64 rgbMin = 0;
-            Int64 rgbMax = 0;
-            Int64 alphaMin = 0;
-            Int64 alphaMax = 0;
-        };
-
-        IntegerBorderRange ResolveIntegerBorderRange(TextureInternalFormat format) {
-            const auto uniform = [](Int64 low, Int64 high) { return IntegerBorderRange{low, high, low, high}; };
-            switch (format) {
-            case TextureInternalFormat::R8I:
-            case TextureInternalFormat::RG8I:
-            case TextureInternalFormat::RGB8I:
-            case TextureInternalFormat::RGBA8I:
-                return uniform(-128, 127);
-            case TextureInternalFormat::R16I:
-            case TextureInternalFormat::RG16I:
-            case TextureInternalFormat::RGB16I:
-            case TextureInternalFormat::RGBA16I:
-                return uniform(-32768, 32767);
-            case TextureInternalFormat::R8UI:
-            case TextureInternalFormat::RG8UI:
-            case TextureInternalFormat::RGB8UI:
-            case TextureInternalFormat::RGBA8UI:
-                return uniform(0, 255);
-            case TextureInternalFormat::R16UI:
-            case TextureInternalFormat::RG16UI:
-            case TextureInternalFormat::RGB16UI:
-            case TextureInternalFormat::RGBA16UI:
-                return uniform(0, 65535);
-            case TextureInternalFormat::R32UI:
-            case TextureInternalFormat::RG32UI:
-            case TextureInternalFormat::RGB32UI:
-            case TextureInternalFormat::RGBA32UI:
-                return uniform(0, 4294967295LL);
-            case TextureInternalFormat::RGB10A2UI:
-                return {0, 1023, 0, 3};
-            default:
-                // The signed 32-bit formats, and anything unexpected: the full int32 range, i.e. a
-                // clamp that cannot alter a value the GL entry points could have carried.
-                return uniform(-2147483648LL, 2147483647LL);
-            }
-        }
-
-        Bool IsDepthTextureFormat(TextureInternalFormat format) {
-            switch (format) {
-            case TextureInternalFormat::DepthComponent:
-            case TextureInternalFormat::DepthComponent16:
-            case TextureInternalFormat::DepthComponent24:
-            case TextureInternalFormat::DepthComponent32:
-            case TextureInternalFormat::DepthComponent32F:
-            case TextureInternalFormat::Depth24Stencil8:
-            case TextureInternalFormat::Depth32FStencil8:
-            case TextureInternalFormat::DepthStencil:
-                return true;
-            default:
-                return false;
-            }
-        }
-
-        Bool NearlyEqual(Float lhs, Float rhs) {
-            return std::fabs(lhs - rhs) <= 1e-6f;
-        }
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-        template <class SamplerSource>
-        Float ResolveEffectiveMaxLod(const SamplerSource& sampler) {
-#else
-        Float ResolveEffectiveMaxLod(const MG_State::GLState::SamplerObject& sampler) {
-#endif
-            if (sampler.GetMipmapMode() == SamplerMipmapMode::None) {
-                return 0.0f;
-            }
-            return sampler.GetMaxLod();
-        }
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-        template <class SamplerSource>
-        Float ResolveEffectiveMinLod(const SamplerSource& sampler, Float effectiveMaxLod) {
-#else
-        Float ResolveEffectiveMinLod(const MG_State::GLState::SamplerObject& sampler, Float effectiveMaxLod) {
-#endif
-            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.
-#if MOBILEGL_BUILD_DISAGGREGATED
-        template <class SamplerSource>
-        Float ResolveSingleLevelMaxLod(const SamplerSource& sampler, Bool singleLevelView) {
-#else
-        Float ResolveSingleLevelMaxLod(const MG_State::GLState::SamplerObject& sampler, Bool singleLevelView) {
-#endif
-            const Float maxLod = ResolveEffectiveMaxLod(sampler);
-            return singleLevelView ? std::min(maxLod, 0.25f) : maxLod;
-        }
-    } // namespace
-
-    Bool VkSamplerManager::Initialize(const InitInfo& initInfo) {
-        Shutdown();
-
-        m_device = initInfo.device;
-        m_config = initInfo.config;
-        m_samplerAnisotropySupported = initInfo.samplerAnisotropySupported;
-        m_maxSamplerAnisotropy = std::max(initInfo.maxSamplerAnisotropy, 1.0f);
-        m_customBorderColorSupported = initInfo.customBorderColorSupported;
-        m_maxCustomBorderColorSamplers = initInfo.maxCustomBorderColorSamplers;
-        m_customBorderColorSamplerCount = 0;
-        MOBILEGL_ASSERT(m_device != VK_NULL_HANDLE && m_config != nullptr,
-                        "VkSamplerManager::Initialize failed: invalid initialization info");
-        return true;
-    }
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-    template <class SamplerSource>
-    Float VkSamplerManager::ResolveEffectiveMaxAnisotropy(const SamplerSource& sampler,
-#else
-    Float VkSamplerManager::ResolveEffectiveMaxAnisotropy(const MG_State::GLState::SamplerObject& sampler,
-#endif
-                                                           Bool forceNearestFiltering) const {
-        if (!m_samplerAnisotropySupported) return 1.0f;
-        if (forceNearestFiltering) return 1.0f;
-        // VUID-VkSamplerCreateInfo-anisotropyEnable-01071/01072: anisotropy requires both filters to
-        // be LINEAR and the value to sit within [1, limits.maxSamplerAnisotropy].
-        if (sampler.GetMinFilter() != SamplerFilterMode::Linear ||
-            sampler.GetMagFilter() != SamplerFilterMode::Linear) {
-            return 1.0f;
-        }
-        return std::clamp(sampler.GetMaxAnisotropy(), 1.0f, m_maxSamplerAnisotropy);
-    }
-
-    void VkSamplerManager::Shutdown() {
-        for (auto& [_, sampler] : m_samplers) {
-            if (m_device != VK_NULL_HANDLE && sampler.handle != VK_NULL_HANDLE) {
-                vkDestroySampler(m_device, sampler.handle, nullptr);
-            }
-            sampler.handle = VK_NULL_HANDLE;
-        }
-        m_samplers.clear();
-
-        m_device = VK_NULL_HANDLE;
-        m_config = nullptr;
-        m_frameBoundaryCounter = 0;
-        m_customBorderColorSupported = false;
-        m_maxCustomBorderColorSamplers = 0;
-        m_customBorderColorSamplerCount = 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);
-                }
-                if (entry.usesCustomBorderColor && m_customBorderColorSamplerCount > 0) {
-                    --m_customBorderColorSamplerCount;
-                }
-                it = m_samplers.erase(it);
-            } else {
-                ++it;
-            }
-        }
-    }
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-    template <class SamplerSource>
-    Uint64 VkSamplerManager::BuildSamplerKey(const SamplerSource& sampler,
-#else
-    Uint64 VkSamplerManager::BuildSamplerKey(const MG_State::GLState::SamplerObject& sampler,
-#endif
-                                             Bool forceNearestFiltering, Bool singleLevelView,
-                                             const ResolvedBorderColor& borderColor) 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)));
-        const auto magFilter = sampler.GetMagFilter();
-        XXHASH_VERIFY(XXH64_update(m_hashState, &magFilter, sizeof(magFilter)));
-        const auto mipmapMode = sampler.GetMipmapMode();
-        XXHASH_VERIFY(XXH64_update(m_hashState, &mipmapMode, sizeof(mipmapMode)));
-        const auto wrapS = sampler.GetWrapS();
-        XXHASH_VERIFY(XXH64_update(m_hashState, &wrapS, sizeof(wrapS)));
-        const auto wrapT = sampler.GetWrapT();
-        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 minLod = ResolveEffectiveMinLod(sampler, maxLod);
-        XXHASH_VERIFY(XXH64_update(m_hashState, &minLod, sizeof(minLod)));
-        XXHASH_VERIFY(XXH64_update(m_hashState, &maxLod, sizeof(maxLod)));
-        const auto lodBias = sampler.GetLodBias();
-        XXHASH_VERIFY(XXH64_update(m_hashState, &lodBias, sizeof(lodBias)));
-        // The RESOLVED value, not the GL request: samplers that only differ in an anisotropy Vulkan
-        // will not apply (NEAREST filtering, or requests past the device limit) must still share one
-        // VkSampler, while two samplers that really do differ must not collide onto the first one's.
-        const auto maxAnisotropy = ResolveEffectiveMaxAnisotropy(sampler, forceNearestFiltering);
-        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();
-        XXHASH_VERIFY(XXH64_update(m_hashState, &compareFunc, sizeof(compareFunc)));
-        // The resolved enum AND, when it is one of the *_CUSTOM_EXT values, the sixteen bytes of the
-        // colour itself: two samplers that differ only in a custom border colour carry the same enum
-        // and would otherwise collide onto whichever one was created first.
-        XXHASH_VERIFY(XXH64_update(m_hashState, &borderColor.color, sizeof(borderColor.color)));
-        if (borderColor.isCustom) {
-            XXHASH_VERIFY(XXH64_update(m_hashState, &borderColor.customValue, sizeof(borderColor.customValue)));
-        }
-        return XXH64_digest(m_hashState);
-    }
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-    template <class SamplerSource>
-    VkSampler VkSamplerManager::GetOrCreateSamplerImpl(const SamplerSource& sampler,
-                                                       TextureInternalFormat format,
-#else
-    VkSampler VkSamplerManager::GetOrCreateSampler(const MG_State::GLState::SamplerObject& sampler,
-                                                   const MG_State::GLState::ITextureObject& texture,
-#endif
-                                                   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;
-        // Resolved once and used for both the key and the create-info; see ResolvedBorderColor.
-#if MOBILEGL_BUILD_DISAGGREGATED
-        const ResolvedBorderColor borderColor = ResolveBorderColor(sampler, format);
-#else
-        const ResolvedBorderColor borderColor = ResolveBorderColor(sampler, texture);
-#endif
-        const Uint64 key = BuildSamplerKey(sampler, forceNearestFiltering, singleLevelView, borderColor);
-        auto it = m_samplers.find(key);
-        if (it != m_samplers.end()) {
-            it->second.lastUsedFrameBoundary = m_frameBoundaryCounter;
-            return it->second.handle;
-        }
-
-        VkSamplerCreateInfo samplerInfo{};
-        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.addressModeU = ToVkAddressMode(sampler.GetWrapS());
-        samplerInfo.addressModeV = ToVkAddressMode(sampler.GetWrapT());
-        samplerInfo.addressModeW = ToVkAddressMode(sampler.GetWrapR());
-        samplerInfo.mipLodBias = sampler.GetLodBias();
-        // Must use the same resolver as BuildSamplerKey - a divergence would either collide two
-        // different samplers or silently create duplicates.
-        const Float maxAnisotropy = ResolveEffectiveMaxAnisotropy(sampler, forceNearestFiltering);
-        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.minLod = ResolveEffectiveMinLod(sampler, samplerInfo.maxLod);
-        samplerInfo.borderColor = borderColor.color;
-        samplerInfo.unnormalizedCoordinates = VK_FALSE;
-
-        // VK_EXT_custom_border_color. `format` stays UNDEFINED, which is legal only because
-        // customBorderColorWithoutFormat was required alongside customBorderColors at device
-        // creation - a GL sampler object has no idea which texture it will be paired with.
-        VkSamplerCustomBorderColorCreateInfoEXT customBorderColorInfo{};
-        if (borderColor.isCustom) {
-            customBorderColorInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
-            customBorderColorInfo.customBorderColor = borderColor.customValue;
-            customBorderColorInfo.format = VK_FORMAT_UNDEFINED;
-            customBorderColorInfo.pNext = samplerInfo.pNext;
-            samplerInfo.pNext = &customBorderColorInfo;
-        }
-
-        VkSampler vkSampler = VK_NULL_HANDLE;
-        VK_VERIFY(vkCreateSampler(m_device, &samplerInfo, nullptr, &vkSampler), "vkCreateSampler(texture)");
-
-        SamplerCacheEntry entry{};
-        entry.handle = vkSampler;
-        entry.externalIndex = sampler.GetExternalIndex();
-        entry.version = sampler.GetVersion();
-        entry.lastUsedFrameBoundary = m_frameBoundaryCounter;
-        entry.usesCustomBorderColor = borderColor.isCustom;
-        if (entry.usesCustomBorderColor) {
-            ++m_customBorderColorSamplerCount;
-        }
-        m_samplers[key] = entry;
-        return vkSampler;
-    }
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-    VkSampler VkSamplerManager::GetOrCreateSampler(const MG_State::GLState::SamplerObject& sampler,
-                                                   const MG_State::GLState::ITextureObject& texture,
-                                                   Bool forceNearestFiltering, Uint32 viewLevelCount) {
-        return GetOrCreateSamplerImpl(sampler, texture.GetFormat(), forceNearestFiltering, viewLevelCount);
-    }
-
-    VkSampler VkSamplerManager::GetOrCreateSamplerFromParameters(const SamplerParameters& parameters,
-        TextureInternalFormat format, Bool forceNearestFiltering, Uint32 viewLevelCount) {
-        return GetOrCreateSamplerImpl(SamplerParametersSource{parameters}, format,
-                                       forceNearestFiltering, viewLevelCount);
-    }
-#endif
-
-    VkFilter VkSamplerManager::ToVkFilter(SamplerFilterMode mode) {
-        return mode == SamplerFilterMode::Nearest ? VK_FILTER_NEAREST : VK_FILTER_LINEAR;
-    }
-
-    VkSamplerMipmapMode VkSamplerManager::ToVkMipmapMode(SamplerMipmapMode mode) {
-        switch (mode) {
-        case SamplerMipmapMode::Nearest:
-            return VK_SAMPLER_MIPMAP_MODE_NEAREST;
-        case SamplerMipmapMode::Linear:
-            return VK_SAMPLER_MIPMAP_MODE_LINEAR;
-        case SamplerMipmapMode::None:
-        default:
-            return VK_SAMPLER_MIPMAP_MODE_NEAREST;
-        }
-    }
-
-    VkSamplerAddressMode VkSamplerManager::ToVkAddressMode(SamplerWrapMode mode) {
-        switch (mode) {
-        case SamplerWrapMode::ClampToEdge:
-            return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-        case SamplerWrapMode::MirroredRepeat:
-            return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
-        case SamplerWrapMode::Repeat:
-            return VK_SAMPLER_ADDRESS_MODE_REPEAT;
-        case SamplerWrapMode::ClampToBorder:
-            return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
-        case SamplerWrapMode::MirrorClampToEdge:
-            return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
-        default:
-            return VK_SAMPLER_ADDRESS_MODE_REPEAT;
-        }
-    }
-
-    VkCompareOp VkSamplerManager::ToVkCompareOp(SamplerCompareFunc func) {
-        switch (func) {
-        case SamplerCompareFunc::Never:
-            return VK_COMPARE_OP_NEVER;
-        case SamplerCompareFunc::Less:
-            return VK_COMPARE_OP_LESS;
-        case SamplerCompareFunc::Equal:
-            return VK_COMPARE_OP_EQUAL;
-        case SamplerCompareFunc::LessEqual:
-            return VK_COMPARE_OP_LESS_OR_EQUAL;
-        case SamplerCompareFunc::Greater:
-            return VK_COMPARE_OP_GREATER;
-        case SamplerCompareFunc::NotEqual:
-            return VK_COMPARE_OP_NOT_EQUAL;
-        case SamplerCompareFunc::GreaterEqual:
-            return VK_COMPARE_OP_GREATER_OR_EQUAL;
-        case SamplerCompareFunc::Always:
-        default:
-            return VK_COMPARE_OP_ALWAYS;
-        }
-    }
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-    template <class SamplerSource>
-    VkSamplerManager::ResolvedBorderColor VkSamplerManager::ResolveBorderColor(
-        const SamplerSource& sampler, TextureInternalFormat format) const {
-#else
-    VkSamplerManager::ResolvedBorderColor VkSamplerManager::ResolveBorderColor(
-        const MG_State::GLState::SamplerObject& sampler, const MG_State::GLState::ITextureObject& texture) const {
-#endif
-        ResolvedBorderColor resolved{};
-        if (!UsesBorderColor(sampler)) {
-            return resolved; // FLOAT_TRANSPARENT_BLACK, never sampled
-        }
-
-        // 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.
-#if !MOBILEGL_BUILD_DISAGGREGATED
-        const auto format = texture.GetFormat();
-#endif
-        const auto domain = ResolveBorderColorDomain(format);
-        const Bool canUseCustom = m_customBorderColorSupported && m_maxCustomBorderColorSamplers > 0 &&
-                                  m_customBorderColorSamplerCount < m_maxCustomBorderColorSamplers;
-
-        if (domain != BorderColorDomain::Float) {
-            // An integer image view REQUIRES an integer border colour, whatever the value is - even
-            // (0,0,0,1). The value itself is whichever integer form the application wrote; a float
-            // border on an integer texture is nonsense GL leaves undefined, so the derived integer
-            // representation (a plain cast) is as good an answer as any.
-            //
-            // Clamped to the format's representable range FIRST, per GL 4.6 core 8.14.2, and read
-            // through Int64 so the whole signed and unsigned 32-bit ranges are expressible at once.
-            //
-            // Which representation to start from is the TEXTURE's domain, not the entry-point form
-            // the application used. GL 4.6 core 8.10 stores an "I"-form border colour unmodified with
-            // an integer internal data type and does not define a sign conversion between the two
-            // integer forms, so the stored bits are reinterpreted in the sampled format's own
-            // signedness. Measured, not assumed: a border of -1 written with glTexParameterIiv
-            // against a GL_R8UI texture samples as 255 on the ES driver, i.e. as 0xFFFFFFFF clamped
-            // to the format's maximum - see the IntegerBorderColorScenario case that pins it. Picking
-            // the representation by the FORM instead would answer 0 here, which is a defensible
-            // reading of the same spec text but puts DirectVulkan at odds with DirectGLES - and
-            // DirectGLES cannot deviate, it forwards the value to the driver verbatim. Cross-backend
-            // agreement decides it.
-            const auto range = ResolveIntegerBorderRange(format);
-            const auto& borderColorI = sampler.GetBorderColorI();
-            const auto& borderColorUI = sampler.GetBorderColorUI();
-            const Bool startFromUnsigned = domain == BorderColorDomain::UnsignedInteger;
-            Int64 clamped[4];
-            for (SizeT channel = 0; channel < 4; ++channel) {
-                const Int64 raw = startFromUnsigned ? static_cast<Int64>(borderColorUI[channel])
-                                                    : static_cast<Int64>(borderColorI[channel]);
-                const Int64 low = channel == 3 ? range.alphaMin : range.rgbMin;
-                const Int64 high = channel == 3 ? range.alphaMax : range.rgbMax;
-                clamped[channel] = std::clamp(raw, low, high);
-            }
-
-            // Matched against the CLAMPED value, so a border the format cannot hold still lands on
-            // the palette entry it clamps to rather than missing every one of them.
-            const Bool allZeroRgb = clamped[0] == 0 && clamped[1] == 0 && clamped[2] == 0;
-            if (allZeroRgb && clamped[3] == 0) {
-                resolved.color = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
-                return resolved;
-            }
-            if (allZeroRgb && clamped[3] == 1) {
-                resolved.color = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
-                return resolved;
-            }
-            if (clamped[0] == 1 && clamped[1] == 1 && clamped[2] == 1 && clamped[3] == 1) {
-                resolved.color = VK_BORDER_COLOR_INT_OPAQUE_WHITE;
-                return resolved;
-            }
-            if (canUseCustom) {
-                resolved.color = VK_BORDER_COLOR_INT_CUSTOM_EXT;
-                resolved.isCustom = true;
-                for (SizeT channel = 0; channel < 4; ++channel) {
-                    if (domain == BorderColorDomain::UnsignedInteger) {
-                        resolved.customValue.uint32[channel] = static_cast<Uint32>(clamped[channel]);
-                    } else {
-                        resolved.customValue.int32[channel] = static_cast<Int32>(clamped[channel]);
-                    }
-                }
-                return resolved;
-            }
-            // No custom colour available: pick the nearest of the three integer palette entries
-            // rather than always answering transparent black, which is what turned an integer border
-            // of (-1,-1,-1,-1) into 0 and broke the CTS's clamped-texel detection outright.
-            const Bool opaque = clamped[3] != 0;
-            const Bool bright = clamped[0] != 0 || clamped[1] != 0 || clamped[2] != 0;
-            resolved.color = !opaque ? VK_BORDER_COLOR_INT_TRANSPARENT_BLACK
-                                     : (bright ? VK_BORDER_COLOR_INT_OPAQUE_WHITE : VK_BORDER_COLOR_INT_OPAQUE_BLACK);
-            return resolved;
-        }
-
-        // Float domain. GL 4.6 core 8.14.2/8.23: the border colour is interpreted in the texture's
-        // format, so it is clamped to that format's representable range first. Without the clamp the
-        // CTS's border of (255,255,255,255) on a GL_RGBA8 texture matched none of the palette entries
-        // and fell through to transparent black - every border texel sampled 0 where the test wanted
-        // 255. The range is per format class, not just the normalized [0,1] / [-1,1] pair: only the
-        // 32-bit float formats are unclamped.
-        FloatVec4 borderColor = sampler.GetBorderColor();
-        if (const auto range = ResolveFloatBorderRange(format, IsSignedNormalizedFormat(format)); range.clamped) {
-            borderColor = FloatVec4(std::clamp(borderColor.x(), range.minValue, range.maxValue),
-                                    std::clamp(borderColor.y(), range.minValue, range.maxValue),
-                                    std::clamp(borderColor.z(), range.minValue, range.maxValue),
-                                    std::clamp(borderColor.w(), range.minValue, range.maxValue));
-        }
-
-        // A depth texture samples one component, so only x decides - and its alpha reads as 1.
-        if (IsDepthTextureFormat(format)) {
-            if (NearlyEqual(borderColor.x(), 1.0f)) {
-                resolved.color = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
-                return resolved;
-            }
-            if (NearlyEqual(borderColor.x(), 0.0f)) {
-                resolved.color = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
-                return resolved;
-            }
-        }
-
-        const Bool rgbZero = NearlyEqual(borderColor.x(), 0.0f) && NearlyEqual(borderColor.y(), 0.0f) &&
-                             NearlyEqual(borderColor.z(), 0.0f);
-        if (rgbZero && NearlyEqual(borderColor.w(), 0.0f)) {
-            resolved.color = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
-            return resolved;
-        }
-        if (rgbZero && NearlyEqual(borderColor.w(), 1.0f)) {
-            resolved.color = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
-            return resolved;
-        }
-        if (NearlyEqual(borderColor.x(), 1.0f) && NearlyEqual(borderColor.y(), 1.0f) &&
-            NearlyEqual(borderColor.z(), 1.0f) && NearlyEqual(borderColor.w(), 1.0f)) {
-            resolved.color = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
-            return resolved;
-        }
-
-        if (canUseCustom) {
-            resolved.color = VK_BORDER_COLOR_FLOAT_CUSTOM_EXT;
-            resolved.isCustom = true;
-            resolved.customValue.float32[0] = borderColor.x();
-            resolved.customValue.float32[1] = borderColor.y();
-            resolved.customValue.float32[2] = borderColor.z();
-            resolved.customValue.float32[3] = borderColor.w();
-            return resolved;
-        }
-
-        // Nearest of the three float palette entries. Transparent black stays the answer for a
-        // transparent border, which is what the old unconditional fallback got right by accident.
-        const Bool opaque = borderColor.w() >= 0.5f;
-        const Bool bright = (borderColor.x() + borderColor.y() + borderColor.z()) >= 1.5f;
-        resolved.color = !opaque ? VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK
-                                 : (bright ? VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE : VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK);
-        return resolved;
-    }
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.h

@@ -1,143 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.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 "../VkIncludes.h"
-#include "../VulkanRendererConfig.h"
-#include <Includes.h>
-#include <MG_State/GLState/SamplerState/SamplerObject.h>
-
-namespace MobileGL::MG_State::GLState {
-class SamplerObject;
-class ITextureObject;
-}
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-class VkSamplerManager {
-public:
-    struct InitInfo {
-        VkDevice device = VK_NULL_HANDLE;
-        const VulkanRendererConfig* config = nullptr;
-        // The samplerAnisotropy device feature was requested and granted at vkCreateDevice.
-        Bool samplerAnisotropySupported = false;
-        // VkPhysicalDeviceLimits::maxSamplerAnisotropy.
-        Float maxSamplerAnisotropy = 1.0f;
-        // VK_EXT_custom_border_color was enabled with BOTH customBorderColors and
-        // customBorderColorWithoutFormat; see VulkanRenderer::m_customBorderColorFeatureEnabled.
-        Bool customBorderColorSupported = false;
-        // VkPhysicalDeviceCustomBorderColorPropertiesEXT::maxCustomBorderColorSamplers. A hard device
-        // limit on how many LIVE samplers may carry a custom border colour, so the cache counts them
-        // and falls back to the snapped predefined value once it is reached.
-        Uint32 maxCustomBorderColorSamplers = 0;
-    };
-
-    Bool Initialize(const InitInfo& initInfo);
-    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);
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // The applier owns these values: effective bound/builtin sampler parameters and
-    // the sampled texture view's format/range. No frontend object is constructed.
-    VkSampler GetOrCreateSamplerFromParameters(const SamplerParameters& parameters,
-        TextureInternalFormat format, Bool forceNearestFiltering = false, Uint32 viewLevelCount = 0);
-#endif
-    // 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();
-
-    // What GL_TEXTURE_BORDER_COLOR resolves to for one (sampler, texture) pair. `color` is always a
-    // legal VkBorderColor; when `isCustom` it is one of the *_CUSTOM_EXT values and `customValue`
-    // carries the actual components in a VkSamplerCustomBorderColorCreateInfoEXT.
-    //
-    // Resolved ONCE per GetOrCreateSampler call and threaded into both the cache key and the
-    // create-info, so the two cannot disagree - the same discipline the resolved anisotropy needs,
-    // and here it also makes the maxCustomBorderColorSamplers fallback deterministic: whether a
-    // custom colour was affordable is decided before the key is built, not twice with a budget
-    // change in between.
-    struct ResolvedBorderColor {
-        VkBorderColor color = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
-        VkClearColorValue customValue{};
-        Bool isCustom = false;
-    };
-
-private:
-    struct SamplerCacheEntry {
-        VkSampler handle = VK_NULL_HANDLE;
-        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;
-        // Counted against maxCustomBorderColorSamplers for as long as this entry lives.
-        Bool usesCustomBorderColor = false;
-    };
-
-#if MOBILEGL_BUILD_DISAGGREGATED
-    template <class SamplerSource>
-    VkSampler GetOrCreateSamplerImpl(const SamplerSource& sampler, TextureInternalFormat format,
-                                     Bool forceNearestFiltering, Uint32 viewLevelCount);
-    template <class SamplerSource>
-    Uint64 BuildSamplerKey(const SamplerSource& sampler, Bool forceNearestFiltering,
-#else
-    Uint64 BuildSamplerKey(const MG_State::GLState::SamplerObject& sampler, Bool forceNearestFiltering,
-#endif
-                           Bool singleLevelView, const ResolvedBorderColor& borderColor) const;
-    static VkFilter ToVkFilter(SamplerFilterMode mode);
-    static VkSamplerMipmapMode ToVkMipmapMode(SamplerMipmapMode mode);
-    static VkSamplerAddressMode ToVkAddressMode(SamplerWrapMode mode);
-    static VkCompareOp ToVkCompareOp(SamplerCompareFunc func);
-#if MOBILEGL_BUILD_DISAGGREGATED
-    template <class SamplerSource>
-    ResolvedBorderColor ResolveBorderColor(const SamplerSource& sampler, TextureInternalFormat format) const;
-#else
-    ResolvedBorderColor ResolveBorderColor(const MG_State::GLState::SamplerObject& sampler,
-                                           const MG_State::GLState::ITextureObject& texture) const;
-#endif
-    // The anisotropy Vulkan will actually apply: 1.0 (i.e. disabled) unless the feature is on and
-    // the sampler filters linearly both ways, otherwise the GL request clamped to the device limit.
-    // GL happily carries GL_TEXTURE_MAX_ANISOTROPY on a NEAREST sampler (Blaze3D's blocks do exactly
-    // that) while Vulkan forbids anisotropyEnable there, so the GL value must never be forwarded raw.
-#if MOBILEGL_BUILD_DISAGGREGATED
-    template <class SamplerSource>
-    Float ResolveEffectiveMaxAnisotropy(const SamplerSource& sampler,
-#else
-    Float ResolveEffectiveMaxAnisotropy(const MG_State::GLState::SamplerObject& sampler,
-#endif
-                                        Bool forceNearestFiltering) const;
-
-    VkDevice m_device = VK_NULL_HANDLE;
-    const VulkanRendererConfig* m_config = nullptr;
-    Bool m_samplerAnisotropySupported = false;
-    Float m_maxSamplerAnisotropy = 1.0f;
-    Bool m_customBorderColorSupported = false;
-    Uint32 m_maxCustomBorderColorSamplers = 0;
-    // Live cache entries carrying a custom border colour. Kept in step with the entries themselves
-    // in exactly the three places one can appear or disappear: creation, the OnFrameBoundary sweep,
-    // and Shutdown.
-    Uint32 m_customBorderColorSamplerCount = 0;
-    UnorderedMap<Uint64, SamplerCacheEntry> m_samplers;
-    // Monotonic frame-boundary counter (bumped in OnFrameBoundary) for cache aging.
-    Uint64 m_frameBoundaryCounter = 0;
-    static inline XXH64_state_t* m_hashState = XXH64_createState();
-};
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.h

@@ -1,916 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.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 "../VkIncludes.h"
-#include <Includes.h>
-#include <MG_State/GLState/FramebufferState/FramebufferObject.h>
-#include <MG_State/GLState/TextureState/TextureObject.h>
-#include <vk_mem_alloc.h>
-#include <algorithm>
-#include <unordered_map>
-#include <unordered_set>
-
-#include <Config.h>
-#if MOBILEGL_BUILD_DISAGGREGATED
-// The handle-keyed arm's key type. Header-only POD, disagg-only, exactly the shape
-// MagmaPipeArms.h already gives this directory.
-#include <MG_Pipe/MGPipeHandles.h>
-#endif
-
-namespace MobileGL::MG_State::GLState {
-class ITextureObject;
-}
-#if MOBILEGL_BUILD_DISAGGREGATED
-namespace MobileGL::MG_Pipe {
-struct MGPipeResourceRecord;
-}
-#endif
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-enum class SamplerNumericDomain : Uint8;
-
-// What VkFormat a GL internal format is BACKED with, and how a shadow upload has to be reshaped to
-// fit it. This is not the same question as "is there an exact VkFormat for this GL format", which is
-// what ConvertTextureInternalFormatToVkEnum answers: several GL formats have no Vulkan twin at all
-// (RGBA2, RGBA12) and several three-channel ones are deliberately widened to their four-channel twin
-// because Vulkan devices rarely support the 3-channel layouts.
-//
-// SHARED, and it must stay the only answer to that question. A renderbuffer and a texture of the
-// same GL format have to resolve to the SAME VkFormat or every blit, resolve and glCopyImageSubData
-// between them crosses a size-incompatible pair, which vkCmdCopyImage leaves undefined
-// (VUID-vkCmdCopyImage-srcImage-01548). The renderbuffer path used to carry a hand-maintained second
-// copy of this table that was missing four rows - RGBA2, RGBA4, RGB5A1 and RGBA12 - so those four
-// renderbuffer formats either got no image at all or a 16-bit-packed one facing a 32-bit texture.
-struct TextureFormatInfo {
-    VkFormat format = VK_FORMAT_UNDEFINED;
-    // The GL format has three channels and is carried in a four-channel image; a shadow upload has
-    // to be expanded, inserting `alphaBytes` after every `componentByteCount * 3` source bytes.
-    Bool expandRgbToRgba = false;
-    Uint32 componentByteCount = 0;
-    Array<Uint8, 4> alphaBytes = {0, 0, 0, 0};
-};
-
-// Callers that only need the backing VkFormat (a renderbuffer has no shadow upload to reshape) take
-// `.format` and ignore the rest.
-TextureFormatInfo ResolveTextureFormatInfo(TextureInternalFormat format);
-
-// A GL 1D-ARRAY level keeps its LAYER COUNT in the state-side HEIGHT: that is what
-// glTexImage2D(GL_TEXTURE_1D_ARRAY, width, layers) means, and the frontend records the level
-// as {width, layers, 1} (see GL_Texture.cpp's AllocateStorage and the completeness walk in
-// TextureObject.cpp, which shrinks only x down the chain). Vulkan packs it the other way: a
-// 1D array is a VK_IMAGE_TYPE_1D image whose extent.height MUST be 1 and whose layers live in
-// arrayLayers - i.e. in the slot this backend reads out of z. So every place that turns a GL
-// level size into Vulkan image geometry has to move the count across first, and every GL-space
-// sub-box that rides along with it has to move its y the same way. DirectGLES performs the
-// identical remap onto the ES 2D array it maps 1D arrays to (GetBackendUploadSize).
-//
-// Applied to nothing else: a 2D array, a cube array and a 3D texture all already carry their
-// depth/layer count in z, which is where the Vulkan side expects it.
-inline IntVec3 ToVulkanLevelExtent(TextureTarget stateTarget, const IntVec3& glTexelSize) {
-    if (stateTarget == TextureTarget::Texture1DArray) {
-        return {glTexelSize.x(), 1, glTexelSize.y()};
-    }
-    return glTexelSize;
-}
-
-// How many Vulkan array layers (or, for a 3D image, z slices) a GL framebuffer attachment spans.
-//
-// THE ONE COPY, deliberately. This used to exist twice - privately in VkRenderPassManager.cpp and
-// again in VkClearManager.cpp - and the two are not independent: the render pass builds the
-// attachment view and VkFramebufferCreateInfo::layers from one, while the CLEAR key built from the
-// other is written verbatim into VkImageSubresourceRange::layerCount when a queued glClear is
-// materialised outside a render pass (MaterializePendingClearForTexture). They are two consumers
-// of the same GL clear, so any disagreement means the same glClear produces two different pictures
-// depending only on which path happens to consume it first - and the materialise path then POPS
-// the entry, so the other one never runs. Fixing one copy and leaving the other is exactly how
-// that split gets introduced; keep them the same function.
-//
-// Two shapes make this more than `size.z()`:
-//   * GL_TEXTURE_1D_ARRAY keeps its layer count in the state-side HEIGHT (see ToVulkanLevelExtent
-//     just above), so z reads 1 and every layer above the first was silently dropped.
-//   * GL_TEXTURE_CUBE_MAP is attached layered as its REPRESENTATIVE upload target, the +X face
-//     (ResolveRepresentableFramebufferTextureUploadTarget), and one face's level size has z = 1 -
-//     but a layered cube attachment names all six faces (GL 4.6 core 9.2.8), which are the image's
-//     six array layers. A cube ARRAY needs no such arm: its representative target carries 6n in z.
-inline Uint32 ResolveAttachmentLayerCount(const MG_State::GLState::FramebufferAttachmentObject& attachment) {
-    if (!attachment.IsLayered()) {
-        return 1u;
-    }
-    const auto& texture = attachment.GetTexture();
-    const TextureTarget target = texture != nullptr ? texture->GetTarget() : TextureTarget::Unknown;
-    if (target == TextureTarget::TextureCubeMap) {
-        return 6u;
-    }
-    return static_cast<Uint32>(std::max(ToVulkanLevelExtent(target, attachment.GetSize()).z(), 1));
-}
-
-// A GL framebuffer attachment's level/layer, and a GL image unit's, are relative to the texture
-// the application NAMED. When that texture was created by glTextureView (ARB_texture_view) they
-// are relative to the VIEW, and have to be shifted into the storage image's numbering before they
-// can index a Vulkan subresource - DirectVulkan gives a view no image of its own, it shares the
-// storage texture's (VkTextureManager::StorageTextureOf).
-//
-// Apply EXACTLY ONCE, at the boundary where a GL level/layer becomes a subresource index. Every
-// GetOrCreate*View entry point below expects values that have already been through here, and so
-// does everything that reads or copies an attachment directly. Both are identity on a plain
-// texture (TEXTURE_VIEW_MIN_LEVEL / MIN_LAYER are 0 there), so the conversion is unconditional
-// and there is no second, view-only code path to keep in step.
-inline Uint32 ToStorageMipLevel(const MG_State::GLState::ITextureObject* texture, Int glLevel) {
-    const Uint32 level = static_cast<Uint32>(glLevel > 0 ? glLevel : 0);
-    return texture != nullptr ? level + static_cast<Uint32>(texture->GetViewMinLevel()) : level;
-}
-
-inline Uint32 ToStorageArrayLayer(const MG_State::GLState::ITextureObject* texture, Int glLayer) {
-    const Uint32 layer = static_cast<Uint32>(glLayer > 0 ? glLayer : 0);
-    return texture != nullptr ? layer + static_cast<Uint32>(texture->GetViewMinLayer()) : layer;
-}
-
-class VkTextureManager {
-public:
-    // Monotonic epoch bumped whenever a texture VkImage is (re)created. The render-pass
-    // 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;
-        Uint64 lifetimeId = 0;
-
-        Bool operator==(const TextureIdentity& other) const {
-            return texture == other.texture && lifetimeId == other.lifetimeId;
-        }
-    };
-
-    struct TextureIdentityHash {
-        SizeT operator()(const TextureIdentity& key) const {
-            SizeT hash = std::hash<MG_State::GLState::ITextureObject*>{}(key.texture);
-            hash ^= std::hash<Uint64>{}(key.lifetimeId) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-            return hash;
-        }
-    };
-
-    struct InitInfo {
-        VkDevice device = VK_NULL_HANDLE;
-        VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
-        VmaAllocator allocator = nullptr;
-        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 {
-        struct AttachmentViewKey {
-            Uint32 mipLevel = 0;
-            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;
-            }
-        };
-
-        struct AttachmentViewKeyHash {
-            SizeT operator()(const AttachmentViewKey& key) const {
-                SizeT hash = std::hash<Uint32>{}(key.mipLevel);
-                hash ^= std::hash<Uint32>{}(key.baseArrayLayer) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(key.layerCount) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.viewType)) +
-                        0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.viewFormat)) +
-                        0x9e3779b9u + (hash << 6) + (hash >> 2);
-                return hash;
-            }
-        };
-
-        struct StorageImageViewKey {
-            Uint32 mipLevel = 0;
-            Uint32 baseArrayLayer = 0;
-            Uint32 layerCount = 1;
-            VkImageViewType viewType = VK_IMAGE_VIEW_TYPE_2D;
-            VkFormat format = VK_FORMAT_UNDEFINED;
-
-            Bool operator==(const StorageImageViewKey& other) const {
-                return mipLevel == other.mipLevel &&
-                       baseArrayLayer == other.baseArrayLayer &&
-                       layerCount == other.layerCount &&
-                       viewType == other.viewType &&
-                       format == other.format;
-            }
-        };
-
-        // Layer range and aspect join the key because a GL texture view (ARB_texture_view) can
-        // differ from its storage on either: the Better Clouds shape samples ONE D24S8 image
-        // through two GL names in one draw, the parent with the stencil aspect and the view with
-        // the depth aspect, and a layer-sliced view of an array texture names a sub-range of the
-        // same image. Without these two fields those views would alias each other in the cache.
-        struct SampledImageViewKey {
-            Uint32 baseMipLevel = 0;
-            Uint32 levelCount = 1;
-            Uint32 baseArrayLayer = 0;
-            Uint32 layerCount = 1;
-            VkImageViewType viewType = VK_IMAGE_VIEW_TYPE_2D;
-            VkFormat format = VK_FORMAT_UNDEFINED;
-            VkImageAspectFlags aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-            // GL_TEXTURE_SWIZZLE_* is per-texture state, so two views over one storage with the
-            // same window but different swizzles are different views. Baked into the key because
-            // a GL texture view's ONLY sampled view lives in this cache: unlike the storage
-            // texture's own sampledView, which SyncTextureViews rebuilds whenever the params
-            // version moves, nothing else would ever notice a swizzle change on a view.
-            Uint32 componentSwizzle = 0;
-
-            Bool operator==(const SampledImageViewKey& other) const {
-                return baseMipLevel == other.baseMipLevel &&
-                       levelCount == other.levelCount &&
-                       baseArrayLayer == other.baseArrayLayer &&
-                       layerCount == other.layerCount &&
-                       viewType == other.viewType &&
-                       format == other.format &&
-                       aspect == other.aspect &&
-                       componentSwizzle == other.componentSwizzle;
-            }
-        };
-
-        struct SampledImageViewKeyHash {
-            SizeT operator()(const SampledImageViewKey& key) const {
-                SizeT hash = std::hash<Uint32>{}(key.baseMipLevel);
-                hash ^= std::hash<Uint32>{}(key.levelCount) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(key.baseArrayLayer) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(key.layerCount) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.viewType)) +
-                        0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.format)) +
-                        0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.aspect)) +
-                        0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(key.componentSwizzle) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-                return hash;
-            }
-        };
-
-        struct StorageImageViewKeyHash {
-            SizeT operator()(const StorageImageViewKey& key) const {
-                SizeT hash = std::hash<Uint32>{}(key.mipLevel);
-                hash ^= std::hash<Uint32>{}(key.baseArrayLayer) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(key.layerCount) + 0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.viewType)) +
-                        0x9e3779b9u + (hash << 6) + (hash >> 2);
-                hash ^= std::hash<Uint32>{}(static_cast<Uint32>(key.format)) +
-                        0x9e3779b9u + (hash << 6) + (hash >> 2);
-                return hash;
-            }
-        };
-
-        VkImage image = VK_NULL_HANDLE;
-        VmaAllocation allocation = nullptr;
-        VkImageView fullView = VK_NULL_HANDLE;
-        VkImageView sampledView = VK_NULL_HANDLE;
-        Vector<VkImageView> perMipViews;
-        Vector<VkImageView> perMipSampledViews;
-        UnorderedMap<AttachmentViewKey, VkImageView, AttachmentViewKeyHash> attachmentViews;
-        UnorderedMap<SampledImageViewKey, VkImageView, SampledImageViewKeyHash> alternateSampledViews;
-        UnorderedMap<StorageImageViewKey, VkImageView, StorageImageViewKeyHash> storageImageViews;
-        VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
-        VkExtent2D extent = {0, 0};
-        Uint32 depth = 1;
-        Uint32 arrayLayers = 1;
-        Uint32 mipLevels = 1;
-        Uint32 sampledBaseMipLevel = 0;
-        Uint32 sampledLevelCount = 1;
-        VkFormat format = VK_FORMAT_UNDEFINED;
-        VkImageAspectFlags aspect = VK_IMAGE_ASPECT_NONE;
-        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;
-        // The same, for the last recorded command that WRITES the image (a render pass it is an
-        // attachment of, a clear, a blit/copy into it, a mip generation, a storage-image binding).
-        // An upload into an image written this recording has to be ordered after that write
-        // (VulkanRenderer::OrderPendingUploadAfterRecording).
-        Uint64 lastRecordingWriteGeneration = 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;
-        // Snapshot of the defined mip-level count at the last sync. Folded into the early-out key
-        // as defense-in-depth: any path that grows the level set (which resizes the sampled view)
-        // busts the skip even if it failed to bump the content version.
-        Uint32 syncedMipLevelCount = 0;
-        // Snapshot of ITextureObject::GetShapeVersion() at the last successful sync. The content
-        // version alone does NOT cover a re-specification: glTexImage2D(..., nullptr) on an
-        // already-defined level changes its size or format and dirties no texel, so it moves the
-        // shape version and nothing else. Without this in the early-out key the image, its views
-        // and therefore imageSize() all keep answering with the texture's PREVIOUS shape.
-        Uint64 syncedShapeVersion = 0;
-        // The handle-keyed arm's (P5f fm) early-out key: the applier record's server-owned
-        // Serial at the last successful sync. 0 also means "this resource has only ever been
-        // synced by the frontend arm" - a wire record's Serial starts at 0 on a create and moves
-        // on every mutation, so the first handle sync of a fresh image always re-checks.
-#if MOBILEGL_BUILD_DISAGGREGATED
-        Uint64 syncedWireSerial = 0;
-#endif
-
-        TextureResource() = default;
-        TextureResource(const TextureResource&) = delete;
-        TextureResource(TextureResource&& that) noexcept {
-            std::swap(this->image, that.image);
-            std::swap(this->allocation, that.allocation);
-            std::swap(this->fullView, that.fullView);
-            std::swap(this->sampledView, that.sampledView);
-            std::swap(this->perMipViews, that.perMipViews);
-            std::swap(this->perMipSampledViews, that.perMipSampledViews);
-            std::swap(this->attachmentViews, that.attachmentViews);
-            std::swap(this->alternateSampledViews, that.alternateSampledViews);
-            std::swap(this->storageImageViews, that.storageImageViews);
-            std::swap(this->layout, that.layout);
-            std::swap(this->extent, that.extent);
-            std::swap(this->depth, that.depth);
-            std::swap(this->arrayLayers, that.arrayLayers);
-            std::swap(this->mipLevels, that.mipLevels);
-            std::swap(this->sampledBaseMipLevel, that.sampledBaseMipLevel);
-            std::swap(this->sampledLevelCount, that.sampledLevelCount);
-            std::swap(this->format, that.format);
-            std::swap(this->aspect, that.aspect);
-            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->lastRecordingWriteGeneration, that.lastRecordingWriteGeneration);
-            std::swap(this->syncedContentVersion, that.syncedContentVersion);
-            std::swap(this->syncedMipLevelCount, that.syncedMipLevelCount);
-            std::swap(this->syncedShapeVersion, that.syncedShapeVersion);
-#if MOBILEGL_BUILD_DISAGGREGATED
-            std::swap(this->syncedWireSerial, that.syncedWireSerial);
-#endif
-        }
-
-        void Reset() {
-            if (fullView != VK_NULL_HANDLE) {
-                vkDestroyImageView(s_device, fullView, nullptr);
-            }
-            if (sampledView != VK_NULL_HANDLE) {
-                vkDestroyImageView(s_device, sampledView, nullptr);
-            }
-            for (const auto attachmentView : perMipViews) {
-                if (attachmentView != VK_NULL_HANDLE) {
-                    vkDestroyImageView(s_device, attachmentView, nullptr);
-                }
-            }
-            for (const auto sampledView : perMipSampledViews) {
-                if (sampledView != VK_NULL_HANDLE) {
-                    vkDestroyImageView(s_device, sampledView, nullptr);
-                }
-            }
-            for (const auto& [_, attachmentView] : attachmentViews) {
-                if (attachmentView != VK_NULL_HANDLE) {
-                    vkDestroyImageView(s_device, attachmentView, nullptr);
-                }
-            }
-            for (const auto& [_, sampledView] : alternateSampledViews) {
-                if (sampledView != VK_NULL_HANDLE) {
-                    vkDestroyImageView(s_device, sampledView, nullptr);
-                }
-            }
-            for (const auto& [_, storageImageView] : storageImageViews) {
-                if (storageImageView != VK_NULL_HANDLE) {
-                    vkDestroyImageView(s_device, storageImageView, nullptr);
-                }
-            }
-            if (image != VK_NULL_HANDLE && allocation != nullptr) {
-                vmaDestroyImage(s_allocator, image, allocation);
-            }
-            fullView = VK_NULL_HANDLE;
-            sampledView = VK_NULL_HANDLE;
-            perMipViews.clear();
-            perMipSampledViews.clear();
-            attachmentViews.clear();
-            alternateSampledViews.clear();
-            storageImageViews.clear();
-            image = VK_NULL_HANDLE;
-            allocation = nullptr;
-            layout = VK_IMAGE_LAYOUT_UNDEFINED;
-            extent = {0, 0};
-            depth = 1;
-            arrayLayers = 1;
-            mipLevels = 1;
-            sampledBaseMipLevel = 0;
-            sampledLevelCount = 1;
-            format = VK_FORMAT_UNDEFINED;
-            aspect = VK_IMAGE_ASPECT_NONE;
-            viewType = VK_IMAGE_VIEW_TYPE_2D;
-            sampleCount = VK_SAMPLE_COUNT_1_BIT;
-            imageCreateFlags = 0;
-            usageFlags = 0;
-            storageUsageResolved = false;
-            syncedTextureParamsVersion = 0;
-            syncedContentVersion = 0;
-            syncedMipLevelCount = 0;
-            syncedShapeVersion = 0;
-#if MOBILEGL_BUILD_DISAGGREGATED
-            syncedWireSerial = 0;
-#endif
-        }
-
-        ~TextureResource() {
-            Reset();
-        }
-
-        static inline VkDevice s_device = VK_NULL_HANDLE;
-        static inline VmaAllocator s_allocator = VK_NULL_HANDLE;
-    };
-
-    struct SampledTextureSnapshot {
-        VkImageView imageView = VK_NULL_HANDLE;
-        VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
-    };
-
-    Bool Initialize(const InitInfo& initInfo);
-    void Shutdown();
-    void BeginFrame(Uint32 frameIndex);
-    // 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();
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // Non-blocking idle proof for wire-object retirement. Independent texture
-    // submissions are not represented by VulkanRenderer's submit counter.
-    Bool WireUploadsAreIdle();
-#endif
-
-    // 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();
-
-    // ---- GL texture views (ARB_texture_view / GL 4.6 core 8.18) ----
-    // The GL texture whose STORAGE backs the given one: itself, or - for a texture created by
-    // glTextureView - the texture it views. Every image-scoped question (which VkImage, its
-    // LAYOUT, its uploads, its extent, its usage) must be asked of this object, because a view
-    // has none of its own; only the VkImageViews differ per GL texture object. Sharing one
-    // TextureResource is not an optimisation, it is the only correct arrangement: layout is a
-    // property of the image, and VulkanRenderer caches raw pointers straight to the resource's
-    // layout field, so a second resource aliasing the same image would desynchronise the moment
-    // either of them transitioned it.
-    static MG_State::GLState::ITextureObject& StorageTextureOf(MG_State::GLState::ITextureObject& texture);
-
-    // The window a GL texture object opens onto its storage image. For a plain texture this is
-    // the resource's own full extent; for a view it is the sub-range, format and aspect
-    // glTextureView gave it. Views built from a non-default window must live in the KEYED caches
-    // (attachmentViews / alternateSampledViews), never in the per-mip vectors, which belong to
-    // the storage texture's own defaults.
-    struct TextureViewWindow {
-        Uint32 baseMipLevel = 0;
-        Uint32 levelCount = 1;
-        Uint32 baseArrayLayer = 0;
-        Uint32 layerCount = 1;
-        VkFormat format = VK_FORMAT_UNDEFINED;
-        VkImageViewType viewType = VK_IMAGE_VIEW_TYPE_2D;
-        VkImageAspectFlags sampledAspect = VK_IMAGE_ASPECT_COLOR_BIT;
-        VkComponentMapping components{VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B,
-                                      VK_COMPONENT_SWIZZLE_A};
-        Bool isTextureView = false;
-    };
-
-    // The four component swizzles packed into one value, for the sampled-view cache key.
-    static Uint32 PackComponentSwizzle(const VkComponentMapping& components) {
-        return (static_cast<Uint32>(components.r) & 0xFFu) | ((static_cast<Uint32>(components.g) & 0xFFu) << 8) |
-               ((static_cast<Uint32>(components.b) & 0xFFu) << 16) |
-               ((static_cast<Uint32>(components.a) & 0xFFu) << 24);
-    }
-    TextureViewWindow ResolveTextureViewWindow(MG_State::GLState::ITextureObject& texture,
-                                               const TextureResource& resource) const;
-    // Records what a GL texture view needs of the image it views, so the next sync of the
-    // STORAGE texture creates (or recreates and copies forward) an image the view can be built
-    // over. See m_viewRequestedImageFlags for why this is lazy rather than unconditional.
-    void NoteTextureViewImageRequirements(MG_State::GLState::ITextureObject& viewTexture,
-                                          MG_State::GLState::ITextureObject& storageTexture);
-    VkImageCreateFlags GetViewRequestedImageFlags(const MG_State::GLState::ITextureObject& storageTexture) const;
-    // Appends every format a GL texture view reinterprets this storage as, for the narrowed
-    // VkImageFormatListCreateInfo the image is created with.
-    void AppendViewRequestedFormats(const MG_State::GLState::ITextureObject& storageTexture,
-                                    Vector<VkFormat>& outFormats) const;
-    // Builds (and caches, keyed by the whole window) one sampled VkImageView over a storage
-    // image. Shared back end of every GL-texture-view sampled path.
-    VkImageView GetOrCreateWindowedSampledView(MG_State::GLState::ITextureObject& texture,
-                                               TextureResource& resource, const TextureViewWindow& window);
-
-    TextureResource* SyncTextureAndGetDescriptor(
-        MG_State::GLState::ITextureObject& texture);
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // P5f (fm): THE HANDLE-KEYED ARM of SyncTextureAndGetDescriptor. Under an active transport
-    // the apply thread may not name the client's ITextureObject (rule E), so the clear / blit /
-    // readback / mipmap verbs resolve their attachment textures from the wire handle the
-    // framebuffer or mip record carried: shape from the applier's resource record
-    // (MGPipeApplier().TextureResources), texels from the server's staged-texture store
-    // (P5c tx), pending-upload bookkeeping consumed from the same record. Returns null - never
-    // a frontend fallback - when the record or the shape does not resolve; the caller declines
-    // loudly, which is the honest answer a missing record deserves.
-    //
-    // The resource lives in m_wireTextureResources keyed by StagedTextureStore::KeyForHandle -
-    // a NAMESPACE THE FRONTEND-KEYED m_textureResources NEVER MEETS, so a recycled {slot, gen}
-    // can never inherit its predecessor's image. Texture views resolve the storage owner from
-    // Desc.ViewOf and the window from ViewCso; buffer-backed textures remain P7's buffer arm.
-    Bool ReadUnbackedWireLevel(MG_Pipe::MGPipeHandle handle, TextureUploadTarget target, Uint32 level,
-                               const IntVec3& extent, VkFormat& format, Vector<Uint8>& bytes);
-    TextureResource* SyncTextureResourceByHandle(MG_Pipe::MGPipeHandle handle, Bool renderbuffer = false,
-                                                 Bool requireStorage = false);
-    // Map a texture/view-relative subresource to its live storage owner. layerCount, when
-    // supplied, receives the number of accessible layers starting at the input layer.
-    // viewFormat is UNDEFINED for an ordinary texture, or the outer view's format.
-    // outsideWindow, when supplied, says WHY a null came back: true only when every record on
-    // the way was live and consistent and the (level, layer) simply is not there - past the
-    // owner's levels or layers, or past a view's own window. A dead record, a missing or stale
-    // view CSO and an unresolvable view format leave it false.
-    MG_Pipe::MGPipeHandle ResolveWireTextureStorage(MG_Pipe::MGPipeHandle handle, Uint32& level,
-        Uint32& layer, VkFormat* viewFormat = nullptr, Uint32* layerCount = nullptr,
-        Bool* outsideWindow = nullptr);
-    // Grows the live image of a handle-keyed resource to `requiredMipLevels`, carrying the
-    // existing levels' content across with an in-command-buffer copy. The caller
-    // (GenerateMipmap's record arm) has flushed every pending submission first, so the old
-    // image is GPU-idle and the copy may be recorded into `commandBuffer` directly; the old
-    // image goes to the deferred-release ring. False when the chain cannot grow (the resource
-    // stays as it was).
-    Bool GrowWireTextureMipChain(MG_Pipe::MGPipeHandle handle, Uint32 requiredMipLevels,
-                                 VkCommandBuffer commandBuffer);
-    // Records that GPU writes superseded the staged CPU snapshot of this level. Layer
-    // ranges select cube faces; array and 3D levels share one staged level shadow.
-    void MarkWireTextureGpuWritten(MG_Pipe::MGPipeHandle handle, Uint32 mipLevel,
-                                    Uint32 baseArrayLayer = 0, Uint32 layerCount = 1);
-#endif
-    VkImageView GetOrCreateViewAtMipLevel(MG_State::GLState::ITextureObject& texture, Uint32 mipLevel);
-    VkImageView GetOrCreateAttachmentViewAtMipLevel(MG_State::GLState::ITextureObject& texture, Uint32 mipLevel,
-                                                    Uint32 baseArrayLayer, Uint32 layerCount,
-                                                    VkImageViewType viewType);
-    VkImageView GetOrCreateSampledViewAtMipLevel(MG_State::GLState::ITextureObject& texture, Uint32 mipLevel);
-    VkImageView GetOrCreateSampledImageView(MG_State::GLState::ITextureObject& texture, VkFormat format);
-    VkImageView GetOrCreateStorageImageView(MG_State::GLState::ITextureObject& texture, Uint32 mipLevel,
-                                            VkFormat format, Bool layered, Int32 layer);
-    void UpdateTrackedImageLayout(MG_State::GLState::ITextureObject* texture, VkImageLayout newLayout);
-    void UpdateTrackedImageLayoutAfterAttachmentWrite(VkCommandBuffer commandBuffer,
-                                                      MG_State::GLState::ITextureObject* texture,
-                                                      Uint32 writtenMipLevel,
-                                                      VkImageLayout newLayout);
-    Bool TransitionTextureForSampling(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
-    Bool TransitionTextureForStorageImage(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture);
-    // Copies the complete sampler-visible mip range into a transient sampled image. The source is
-    // restored to its prior layout, so image-store descriptors continue to name the original image.
-    // The transient ownership is tied to the current frame slot and is safe through its submission.
-    Bool SnapshotTextureForSampling(VkCommandBuffer commandBuffer, MG_State::GLState::ITextureObject& texture,
-                                    SamplerNumericDomain numericDomain,
-                                    VkPipelineStageFlags consumerShaderStageMask,
-                                    SampledTextureSnapshot& outSnapshot);
-
-    // Recording-generation bookkeeping for the pre-pass command stream. The
-    // generation advances every time the frame command buffer (re)begins
-    // 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;
-    }
-    // A write is a use too. See TextureResource::lastRecordingWriteGeneration.
-    void StampResourceRecordingWrite(TextureResource& resource) const {
-        resource.lastRecordingGeneration = m_recordingGeneration;
-        resource.lastRecordingWriteGeneration = m_recordingGeneration;
-    }
-    void StampTextureRecordingWrite(MG_State::GLState::ITextureObject* texture);
-    // Upload-ordering queries (VulkanRenderer::OrderPendingUploadAfterRecording). None of them
-    // syncs, so nothing pending is uploaded by asking. All answer for the STORAGE texture.
-    //
-    // Uploads are recorded into a batch submitted AHEAD of the frame's recording
-    // (FlushPendingUploads), so an upload into an image the open recording already WROTE lands
-    // before that write, which then overwrites the newer texels. (An image the recording only
-    // read keeps the old trade: its earlier reads see the newer texels.)
-    Bool HasLiveImage(MG_State::GLState::ITextureObject& textureOrView) const;
-    // The next sync would record client texels into the image that is live now: same shape (a
-    // shape change mints a new image instead) and content moved since the last sync.
-    Bool HasPendingTexelUpload(MG_State::GLState::ITextureObject& textureOrView) const;
-    Bool WasTextureWrittenThisRecording(MG_State::GLState::ITextureObject& textureOrView) const;
-    // The live resource, or null.
-    TextureResource* FindTextureResource(MG_State::GLState::ITextureObject& textureOrView);
-    // 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 VkFormat ResolveSampledImageViewFormat(VkFormat imageFormat, SamplerNumericDomain numericDomain);
-    static Bool AreSampledImageViewFormatsCompatible(VkFormat imageFormat, VkFormat viewFormat);
-    static Bool AreStorageImageViewFormatsCompatible(VkFormat imageFormat, VkFormat viewFormat);
-
-    // Moves `image` to `newLayout` and writes the new layout back through `trackedLayout`.
-    //
-    // The barrier covers EVERY array layer of the image, and there is deliberately no layer
-    // parameter to say otherwise: layout here is tracked per IMAGE (one `TextureResource::layout`,
-    // or one caller-owned variable), so a barrier narrower than the image would leave the layers it
-    // skipped in the old layout while the tracker claims they moved. Every transfer against a
-    // framebuffer attachment above layer 0 - glReadPixels, glBlitFramebuffer, glCopyTexSubImage,
-    // glCopyImageSubData - then ran its copy on a layer no barrier had transitioned.
-    //
-    // The mip range IS a parameter, because mip levels really are transitioned piecewise (see
-    // UpdateTrackedImageLayoutAfterAttachmentWrite and the mipmap generation loops): those callers
-    // move the complement of the level they wrote so the whole image converges on one layout again.
-    // Nothing does, or can, do that per layer.
-    static Bool TransitionImageLayout(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout& trackedLayout,
-                               VkImageLayout newLayout, VkPipelineStageFlags srcStageMask,
-                               VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask,
-                               VkAccessFlags dstAccessMask, VkImageAspectFlags aspectMask,
-                               Uint32 baseMipLevel = 0, Uint32 levelCount = 1);
-
-    SizeT CollectGarbage();
-
-    // Per-draw sync memo. Within a single SetupDraw the same sampled texture is
-    // resolved ~3x (SetupDraw's layout-probe loop, its post-transition loop, and
-    // again inside ResolveSamplerDescriptor). No GL texture mutation can happen
-    // mid-SetupDraw, and layout is tracked on the TextureResource independently of
-    // SyncTexture, so after the first successful sync of a texture in a draw the
-    // heavy SyncTexture work (mip-completeness/resource/view resync + dirty scan)
-    // is pure redundancy. BeginDrawSyncScope opens a window in which repeat
-    // SyncTextureAndGetDescriptor calls short-circuit to the already-synced
-    // resource; EndDrawSyncScope closes it. Use the RAII DrawSyncScope guard.
-    void BeginDrawSyncScope();
-    void EndDrawSyncScope();
-
-    // RAII guard that opens/closes a per-draw sync memo window (see above).
-    class DrawSyncScope {
-    public:
-        explicit DrawSyncScope(VkTextureManager& manager) : m_manager(manager) { m_manager.BeginDrawSyncScope(); }
-        ~DrawSyncScope() { m_manager.EndDrawSyncScope(); }
-        DrawSyncScope(const DrawSyncScope&) = delete;
-        DrawSyncScope& operator=(const DrawSyncScope&) = delete;
-    private:
-        VkTextureManager& m_manager;
-    };
-
-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);
-    Bool SyncTextureResource(const MG_State::GLState::ITextureObject &texture,
-                             TextureUploadTarget uploadTarget,
-                             const IntVec3 &texelSize, SizeT byteSize, Uint32 mipLevels,
-                             TextureResource &resource);
-    Bool SyncTextureViews(const MG_State::GLState::ITextureObject& texture, TextureResource& resource);
-    VkImageView CreateImageView(VkImage image, VkFormat format, VkImageAspectFlags aspect,
-                                VkImageViewType viewType, Uint32 baseMipLevel, Uint32 levelCount,
-                                Uint32 baseArrayLayer,
-                                Uint32 layerCount,
-                                const VkComponentMapping* components = nullptr,
-                                VkImageUsageFlags viewUsage = 0) const;
-    Bool UploadDirtyMipLevels(MG_State::GLState::TextureObjectMipmap &mipmapTexture,
-                      TextureUploadTarget uploadTarget,
-                      TextureResource &outResource);
-    static Bool CheckMipmapCompleteness(const MG_State::GLState::ITextureObject& texture,
-                                        TextureUploadTarget& outTarget,
-                                        IntVec3& outTexelSize,
-                                        SizeT& outByteSize,
-                                        Uint32& outMipLevelCount);
-    static Uint32 GetUploadMipLevelCount(const MG_State::GLState::TextureObjectMipmap& texture, TextureUploadTarget target);
-    static void ResolveViewMipRange(const MG_State::GLState::ITextureObject& texture, Uint32 mipLevels,
-                                    Uint32& outBaseMipLevel, Uint32& outLevelCount);
-    static VkImageAspectFlags GetAspectMaskForFormat(VkFormat format);
-    void DeferResourceRelease(TextureResource&& resource);
-    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();
-#if MOBILEGL_BUILD_DISAGGREGATED
-    // The two halves of SyncTextureResourceByHandle: shape from the resource record's
-    // descriptor (create / recreate / compatibility), then the pending-upload walk against the
-    // server's staged store. UploadPendingWireLevels mutates the applier's record (consumed
-    // entries are dropped), which is why the record is a non-const reference.
-    Bool SyncWireTextureShape(const MG_Pipe::MGPipeResourceRecord& record, TextureResource& resource,
-                              Bool requireStorage);
-    Bool UploadPendingWireLevels(MG_Pipe::MGPipeHandle handle, MG_Pipe::MGPipeResourceRecord& record,
-                                 TextureResource& resource);
-    // The handle-keyed twin of m_textureResources, keyed by StagedTextureStore::KeyForHandle.
-    // Node-based for the same reason m_renderbufferResources is: callers hold TextureResource*
-    // across map-touching calls.
-    std::unordered_map<Uint64, TextureResource> m_wireTextureResources;
-    // Handles are per-kind; a renderbuffer and texture may have identical slot/gen.
-    std::unordered_map<Uint64, TextureResource> m_wireRenderbufferResources;
-#endif
-
-    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;
-    // Per-draw sync memo: the identity plus the resolved resource pointer. The pointer is stable
-    // across rehash in the node-based m_textureResources and stays valid for the draw (a texture
-    // synced this draw is alive and is not erased mid-draw), so a repeat sync of the same texture
-    // returns the resource without re-hashing the identity into m_textureResources.
-    struct DrawSyncedTexture {
-        TextureIdentity identity;
-        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;
-    // Extra VkImageCreateFlags a GL texture view needs on the storage image it views, keyed by
-    // the STORAGE texture's identity. Requested lazily, exactly like STORAGE usage above and for
-    // the same reason: VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT costs bandwidth compression on tilers
-    // (it is what VK_KHR_image_format_list exists to claw back), so setting it on every
-    // immutable-storage texture would tax every glTexStorage2D render target in a game for a
-    // feature almost none of them use. A SAME-format view - which is the common case, and the
-    // Better Clouds case - needs no flag at all and therefore costs nothing.
-    std::unordered_map<TextureIdentity, VkImageCreateFlags, TextureIdentityHash> m_viewRequestedImageFlags;
-    // Every VkFormat a GL texture view has asked to reinterpret this storage as. The narrowed
-    // VkImageFormatListCreateInfo the image is created with must name them: the list is a promise
-    // that NO other format will ever be viewed, and building a view outside it is
-    // VUID-VkImageViewCreateInfo-pNext-01585. Keyed, like the flags above, by the STORAGE texture.
-    std::unordered_map<TextureIdentity, std::unordered_set<VkFormat>, TextureIdentityHash> m_viewRequestedFormats;
-    // Supported multisample counts per format, so repeat texture syncs do not
-    // re-query vkGetPhysicalDeviceImageFormatProperties.
-    std::unordered_map<VkFormat, VkSampleCountFlags> m_multisampleCountsByFormat;
-    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

@@ -1,179 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VkTimerQueryManager.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 "VkTimerQueryManager.h"
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    Bool VkTimerQueryManager::Initialize(const InitInfo& initInfo) {
-        Shutdown();
-
-        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)",
-                    initInfo.timestampValidBits, initInfo.timestampPeriodNs, initInfo.slotsPerPool);
-            return false;
-        }
-
-        m_device = initInfo.device;
-        m_timestampPeriodNs = initInfo.timestampPeriodNs;
-        m_validBitsMask = initInfo.timestampValidBits >= 64
-                              ? ~0ull
-                              : ((1ull << initInfo.timestampValidBits) - 1ull);
-        m_slotsPerPool = initInfo.slotsPerPool;
-        m_pools.resize(initInfo.frameCount);
-
-        VkQueryPoolCreateInfo poolInfo{};
-        poolInfo.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
-        poolInfo.queryType = VK_QUERY_TYPE_TIMESTAMP;
-        poolInfo.queryCount = m_slotsPerPool;
-        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));
-                Shutdown();
-                return false;
-            }
-        }
-        return true;
-    }
-
-    void VkTimerQueryManager::Shutdown() {
-        if (m_device != VK_NULL_HANDLE) {
-            for (auto& poolState : m_pools) {
-                if (poolState.pool != VK_NULL_HANDLE) {
-                    vkDestroyQueryPool(m_device, poolState.pool, nullptr);
-                }
-            }
-        }
-        // Records the frontend still holds simply stay unharvested; their
-        // results read back as 0.
-        m_pools.clear();
-        m_device = VK_NULL_HANDLE;
-        m_timestampPeriodNs = 0.0f;
-        m_validBitsMask = 0;
-        m_slotsPerPool = 0;
-    }
-
-    void VkTimerQueryManager::OnFrameCommandRecordingBegan(VkCommandBuffer commandBuffer, Uint32 frameIndex,
-                                                           Uint64 frameSerial) {
-        MOBILEGL_ASSERT(frameIndex < m_pools.size(), "VkTimerQueryManager frame index out of range");
-        auto& poolState = m_pools[frameIndex];
-        if (poolState.preparedFrameSerial == frameSerial) {
-            // Recording re-began within the same frame (mid-frame readback
-            // submit or the Present layout transition); the pool was already
-            // harvested and reset for this cycle, and resetting again would
-            // clobber timestamps written earlier in the frame.
-            return;
-        }
-
-        // Harvest what the pool's previous cycle left behind. The frame slot's
-        // fence was waited before re-recording, so every executed query is
-        // already available and the reads return immediately.
-        DrainPoolPending(poolState);
-
-        vkCmdResetQueryPool(commandBuffer, poolState.pool, 0, m_slotsPerPool);
-        poolState.cursor = 0;
-        poolState.exhaustionWarned = false;
-        poolState.preparedFrameSerial = frameSerial;
-    }
-
-    SharedPtr<VkTimerQueryManager::TimestampRecord> VkTimerQueryManager::WriteTimestamp(VkCommandBuffer commandBuffer,
-                                                                                        Uint32 frameIndex,
-                                                                                        Uint64 frameSerial) {
-        MOBILEGL_ASSERT(frameIndex < m_pools.size(), "VkTimerQueryManager frame index out of range");
-        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 "
-                        "this frame fall back to the frontend path",
-                        frameIndex, m_slotsPerPool);
-                poolState.exhaustionWarned = true;
-            }
-            return nullptr;
-        }
-
-        auto record = MakeShared<TimestampRecord>();
-        record->poolIndex = frameIndex;
-        record->slot = poolState.cursor++;
-        record->frameSerial = frameSerial;
-        vkCmdWriteTimestamp(commandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, poolState.pool, record->slot);
-        poolState.pendingRecords.push_back(record);
-        return record;
-    }
-
-    Bool VkTimerQueryManager::TryHarvest(TimestampRecord& record) {
-        if (record.harvested) {
-            return true;
-        }
-        if (m_device == VK_NULL_HANDLE || record.poolIndex >= m_pools.size()) {
-            return false;
-        }
-
-        Uint64 resultWithAvailability[2] = {0, 0};
-        const VkResult result = vkGetQueryPoolResults(
-            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));
-            return false;
-        }
-        if (resultWithAvailability[1] == 0) {
-            return false;
-        }
-        record.rawTicks = resultWithAvailability[0];
-        record.harvested = true;
-        return true;
-    }
-
-    void VkTimerQueryManager::InvalidatePendingRecords() {
-        for (auto& poolState : m_pools) {
-            DrainPoolPending(poolState);
-            // Force a harvest-free reset cycle the next time this pool's frame
-            // begins recording.
-            poolState.preparedFrameSerial = 0;
-        }
-    }
-
-    void VkTimerQueryManager::DrainPoolPending(PoolState& poolState) {
-        for (auto& record : poolState.pendingRecords) {
-            if (record->harvested) {
-                continue;
-            }
-            if (!TryHarvest(*record)) {
-                // The commands carrying this timestamp never executed (they
-                // were dropped, e.g. by a swapchain recreation mid-frame).
-                // Mark the record resolved-as-invalid so waits on it cannot
-                // hang; its result reads back as 0.
-                record->harvested = true;
-                record->valid = false;
-            }
-        }
-        poolState.pendingRecords.clear();
-    }
-
-    Uint64 VkTimerQueryManager::MaskToValidBits(Uint64 ticks) const {
-        return ticks & m_validBitsMask;
-    }
-
-    Uint64 VkTimerQueryManager::ElapsedNs(const TimestampRecord& begin, const TimestampRecord& end) const {
-        if (!begin.valid || !end.valid) {
-            return 0;
-        }
-        const Uint64 deltaTicks = MaskToValidBits(end.rawTicks - begin.rawTicks);
-        return static_cast<Uint64>(static_cast<double>(deltaTicks) * static_cast<double>(m_timestampPeriodNs));
-    }
-
-    Uint64 VkTimerQueryManager::TimestampNs(const TimestampRecord& record) const {
-        if (!record.valid) {
-            return 0;
-        }
-        return static_cast<Uint64>(static_cast<double>(MaskToValidBits(record.rawTicks)) *
-                                   static_cast<double>(m_timestampPeriodNs));
-    }
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/VkTimerQueryManager.h

@@ -1,111 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/VkTimerQueryManager.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 "../VkIncludes.h"
-#include <Includes.h>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-    // GPU timestamp storage backing the GL timer-query frontend (GL_TIME_ELAPSED
-    // spans and GL_TIMESTAMP one-shots): one VkQueryPool of timestamp slots per
-    // frame in flight.
-    //
-    // Per-frame lifecycle: right after a frame slot's command buffer begins
-    // recording (and before any render pass, since vkCmdResetQueryPool must be
-    // recorded outside one), OnFrameCommandRecordingBegan harvests every
-    // not-yet-read slot of the pool about to be reused (the slot's frame fence
-    // was waited before re-recording, so the results are already available),
-    // records a reset of the whole pool, and rewinds the allocation cursor.
-    class VkTimerQueryManager {
-    public:
-        // One vkCmdWriteTimestamp landing spot. Shared (via SharedPtr) between
-        // the frontend-held query object and the owning pool's pending list, so
-        // deleting a query while its result is still in flight never leaves the
-        // pool with a dangling record.
-        struct TimestampRecord {
-            Uint32 poolIndex = 0;
-            Uint32 slot = 0;
-            // VkBufferManager frame serial current when the timestamp was
-            // recorded; result availability is bounded by its completion.
-            Uint64 frameSerial = 0;
-            Bool harvested = false;
-            // Cleared when the recorded commands were dropped before they could
-            // execute (swapchain recreation abandons the in-progress command
-            // buffer); the result then reads back as 0.
-            Bool valid = true;
-            Uint64 rawTicks = 0;
-        };
-
-        struct InitInfo {
-            VkDevice device = VK_NULL_HANDLE;
-            Uint32 frameCount = 0;
-            Uint32 timestampValidBits = 0;
-            Float timestampPeriodNs = 0.0f; // nanoseconds per timestamp tick
-            Uint32 slotsPerPool = 128;
-        };
-
-        Bool Initialize(const InitInfo& initInfo);
-        // The caller guarantees the device is idle (same contract as the other
-        // DirectVulkan managers' Shutdown paths).
-        void Shutdown();
-
-        // The per-frame hook described in the class comment. Re-begins within
-        // the same frame serial (mid-frame readback submits, the Present layout
-        // transition) are skipped so already-written slots survive.
-        void OnFrameCommandRecordingBegan(VkCommandBuffer commandBuffer, Uint32 frameIndex, Uint64 frameSerial);
-
-        // Allocates a slot from the frame's pool and records a bottom-of-pipe
-        // vkCmdWriteTimestamp (valid both inside and outside a render pass).
-        // Returns null on pool exhaustion, with one warning per pool cycle; the
-        // frontend falls back gracefully on a null handle.
-        SharedPtr<TimestampRecord> WriteTimestamp(VkCommandBuffer commandBuffer, Uint32 frameIndex,
-                                                  Uint64 frameSerial);
-
-        // Non-blocking single-slot read (WITH_AVAILABILITY, no WAIT). Returns
-        // true once the record holds its raw ticks. Callers gate this on the
-        // record's frame serial being complete.
-        Bool TryHarvest(TimestampRecord& record);
-
-        // Reads every pending result that is available (the caller guarantees
-        // the device is idle) and marks the rest invalid. Called when recorded
-        // but unsubmitted commands are dropped (swapchain recreation), which
-        // would otherwise leave slots that never become available. Each pool is
-        // reset lazily on its next OnFrameCommandRecordingBegan.
-        void InvalidatePendingRecords();
-
-        // end - begin using unsigned wrap arithmetic masked to the queue's
-        // timestampValidBits, converted to nanoseconds. 0 if either record was
-        // invalidated.
-        Uint64 ElapsedNs(const TimestampRecord& begin, const TimestampRecord& end) const;
-        // Raw GPU timestamp converted to nanoseconds. 0 if invalidated.
-        Uint64 TimestampNs(const TimestampRecord& record) const;
-
-    private:
-        struct PoolState {
-            VkQueryPool pool = VK_NULL_HANDLE;
-            Uint32 cursor = 0;
-            // Frame serial the pool was last harvested + reset for; guards
-            // against double resets when recording re-begins mid-frame.
-            Uint64 preparedFrameSerial = 0;
-            Bool exhaustionWarned = false;
-            Vector<SharedPtr<TimestampRecord>> pendingRecords;
-        };
-
-        Uint64 MaskToValidBits(Uint64 ticks) const;
-        // Harvest (or invalidate, when the result never became available)
-        // every pending record of a pool and clear its pending list.
-        void DrainPoolPending(PoolState& pool);
-
-        VkDevice m_device = VK_NULL_HANDLE;
-        Float m_timestampPeriodNs = 0.0f;
-        Uint64 m_validBitsMask = 0;
-        Uint32 m_slotsPerPool = 0;
-        Vector<PoolState> m_pools;
-    };
-} // namespace MobileGL::MG_Backend::DirectVulkan

MobileGL/MG_Backend/DirectVulkan/Renderer/WireColorBlit.frag

@@ -1,13 +0,0 @@
-#version 450
-layout(set = 0, binding = 0) uniform sampler2D sourceImage;
-layout(location = 0) in vec2 texCoord;
-layout(location = 0) out vec4 outColor;
-
-void main() {
-    // Source framebuffer clipping preserves the original scale, rather than
-    // extending the edge texels into pixels outside the source framebuffer.
-    if (any(lessThan(texCoord, vec2(0.0))) || any(greaterThan(texCoord, vec2(1.0)))) discard;
-    // Explicit LOD is required on Adreno 650: implicit LOD through a rotated
-    // single-mip UBWC render target can read outside its allocation.
-    outColor = textureLod(sourceImage, texCoord, 0.0);
-}

MobileGL/MG_Backend/DirectVulkan/Renderer/WireColorBlit.inc

@@ -1,407 +0,0 @@
-// Included by VulkanRenderer.cpp inside the backend namespace, after WireFramebuffer.inc.
-// The native blit owns no frontend object and never invokes the GL shader compiler.
-#if MOBILEGL_BUILD_DISAGGREGATED
-#include "WireColorBlitSpirv.h"
-
-    struct VulkanRenderer::WireColorBlitResources {
-        struct Target {
-            VkFormat format = VK_FORMAT_UNDEFINED;
-            VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
-            VkRenderPass renderPass = VK_NULL_HANDLE;
-            VkPipeline pipeline = VK_NULL_HANDLE;
-        };
-        VkShaderModule vertex = VK_NULL_HANDLE, fragment = VK_NULL_HANDLE;
-        VkDescriptorSetLayout descriptorLayout = VK_NULL_HANDLE;
-        VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
-        VkSampler nearest = VK_NULL_HANDLE, linear = VK_NULL_HANDLE;
-        Vector<Target> targets;
-    };
-
-    void VulkanRenderer::DestroyWireColorBlitResources() {
-        if (!m_wireColorBlitResources) return;
-        // Shutdown calls this after vkDeviceWaitIdle and after all per-submit
-        // descriptor pools/framebuffers/views have been collected.
-        auto& cache = *m_wireColorBlitResources;
-        for (const auto& target : cache.targets) {
-            vkDestroyPipeline(m_device, target.pipeline, nullptr);
-            vkDestroyRenderPass(m_device, target.renderPass, nullptr);
-        }
-        vkDestroySampler(m_device, cache.nearest, nullptr);
-        vkDestroySampler(m_device, cache.linear, nullptr);
-        vkDestroyPipelineLayout(m_device, cache.pipelineLayout, nullptr);
-        vkDestroyDescriptorSetLayout(m_device, cache.descriptorLayout, nullptr);
-        vkDestroyShaderModule(m_device, cache.vertex, nullptr);
-        vkDestroyShaderModule(m_device, cache.fragment, nullptr);
-        delete m_wireColorBlitResources;
-        m_wireColorBlitResources = nullptr;
-    }
-
-    Bool VulkanRenderer::BlitWireColorToDefault(WireImage source, WireImage destination,
-        GLint sx0, GLint sy0, GLint sx1, GLint sy1,
-        GLint dx0, GLint dy0, GLint dx1, GLint dy1, GLenum filter) {
-        if (!destination.isDefault) return false;
-        return BlitWireColorImage(source, destination, sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, filter, false);
-    }
-
-    // P7 wave 2-B (CONTRACT-P7 §3.2, `default-color-blit-shape`). The shader blit below can only
-    // SAMPLE its source: sampler2D, a float result, and one of two 2D view types. A framebuffer
-    // whose colour attachment is RGBA8UI, or a layer of a 3D texture, is none of those, and on a
-    // rotated Android surface there is no other arm - an axis-aligned vkCmdBlitImage cannot
-    // express a quarter turn. So the source region becomes an owned 2D image first, through
-    // vkCmdCopyImage, which cares about the texel BLOCK SIZE and not about how the block is
-    // interpreted; the scratch then takes the shader blit as an ordinary 2D float source.
-    //
-    // REINTERPRETATION IS THE POINT FOR THE INTEGER CASE, and GL agrees: glBlitFramebuffer
-    // between an integer and a normalized format is INVALID_OPERATION (GL 4.6 core 18.3.1), so
-    // there is no defined result to be wrong about - only a shape that used to end the session
-    // and now produces the source's bits. For a float source of the wrong VIEW TYPE the copy is
-    // a plain slice extraction and the result is exactly right.
-    Bool VulkanRenderer::BlitWireColorToDefaultThroughScratch(WireImage source, WireImage destination,
-        GLint sx0, GLint sy0, GLint sx1, GLint sy1,
-        GLint dx0, GLint dy0, GLint dx1, GLint dy1, GLenum filter) {
-        if (!destination.isDefault || source.isDefault) return false;
-        if (source.samples != VK_SAMPLE_COUNT_1_BIT || destination.samples != VK_SAMPLE_COUNT_1_BIT)
-            return false;
-        if (!source.image || !destination.image || source.image == destination.image) return false;
-        const Int64 width = std::abs(static_cast<Int64>(sx1) - sx0);
-        const Int64 height = std::abs(static_cast<Int64>(sy1) - sy0);
-        if (!width || !height || dx0 == dx1 || dy0 == dy1) return true;
-        if (std::min(sx0, sx1) < 0 || std::min(sy0, sy1) < 0 ||
-            static_cast<Uint64>(std::max(sx0, sx1)) > source.extent.width ||
-            static_cast<Uint64>(std::max(sy0, sy1)) > source.extent.height) return false;
-        // A compressed source cannot be a colour attachment, so it cannot be a framebuffer blit's
-        // source either - but the block arithmetic below would silently produce nonsense for one,
-        // and "cannot happen" is the reason the guards this package retires were written as
-        // asserts. The size-compatibility classes are Vulkan's own (VkFormat texel block size);
-        // the destination format is whatever the swapchain uses and is always sampled-float.
-        if (vkuFormatIsCompressed(source.format)) return false;
-        VkFormat scratchFormat = VK_FORMAT_UNDEFINED;
-        switch (vkuFormatTexelBlockSize(source.format)) {
-        case 1: scratchFormat = VK_FORMAT_R8_UNORM; break;
-        case 2: scratchFormat = VK_FORMAT_R8G8_UNORM; break;
-        case 4: scratchFormat = VK_FORMAT_R8G8B8A8_UNORM; break;
-        case 8: scratchFormat = VK_FORMAT_R16G16B16A16_SFLOAT; break;
-        case 16: scratchFormat = VK_FORMAT_R32G32B32A32_SFLOAT; break;
-        default: return false;
-        }
-        VkFormatProperties scratchProperties{};
-        vkGetPhysicalDeviceFormatProperties(m_physicalDevice.handle, scratchFormat, &scratchProperties);
-        const VkFormatFeatureFlags scratchRequired = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
-            (filter == GL_LINEAR ? VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT : 0);
-        if ((scratchProperties.optimalTilingFeatures & scratchRequired) != scratchRequired) return false;
-
-        auto scratch = MakeUnique<VkTextureManager::TextureResource>();
-        VkImageCreateInfo info{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
-        info.imageType = VK_IMAGE_TYPE_2D;
-        info.format = scratchFormat;
-        info.extent = {static_cast<Uint32>(width), static_cast<Uint32>(height), 1};
-        info.mipLevels = info.arrayLayers = 1;
-        info.samples = VK_SAMPLE_COUNT_1_BIT;
-        info.tiling = VK_IMAGE_TILING_OPTIMAL;
-        info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
-        info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-        VmaAllocationCreateInfo allocation{};
-        allocation.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
-        allocation.requiredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
-        if (vmaCreateImage(m_allocator, &info, &allocation, &scratch->image, &scratch->allocation,
-                           nullptr) != VK_SUCCESS)
-            return false;
-        scratch->format = scratchFormat;
-        scratch->extent = {info.extent.width, info.extent.height};
-        scratch->mipLevels = scratch->arrayLayers = scratch->depth = 1;
-        scratch->aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-        WireImage staged{};
-        staged.image = scratch->image;
-        staged.format = scratchFormat;
-        staged.aspect = VK_IMAGE_ASPECT_COLOR_BIT;
-        staged.extent = scratch->extent;
-        staged.trackedLayout = &scratch->layout;
-
-        m_textureManager->FlushPendingUploads();
-        TransitionWireImage(source, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
-        TransitionWireImage(staged, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
-        VkImageCopy copy{};
-        // A 3D source carries its slice on z and always names layer 0; every other source
-        // carries it on the layer axis, which is the same split ResolveWireImage records.
-        copy.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, source.level, source.is3D ? 0u : source.layer, 1};
-        copy.srcOffset = {std::min(sx0, sx1), std::min(sy0, sy1),
-                          source.is3D ? static_cast<Int32>(source.layer) : 0};
-        copy.dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
-        copy.dstOffset = {0, 0, 0};
-        copy.extent = {static_cast<Uint32>(width), static_cast<Uint32>(height), 1};
-        vkCmdCopyImage(m_frameContext.GetCurrent().commandBuffer, source.image,
-                       VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, staged.image,
-                       VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
-        staged.layout = scratch->layout;
-        // The scratch holds the region at its own origin, so a reversed source rectangle
-        // becomes a reversed rectangle OVER THE SCRATCH - the multisample resolve arm's shape.
-        const GLint rx0 = sx1 > sx0 ? 0 : static_cast<GLint>(width);
-        const GLint rx1 = sx1 > sx0 ? static_cast<GLint>(width) : 0;
-        const GLint ry0 = sy1 > sy0 ? 0 : static_cast<GLint>(height);
-        const GLint ry1 = sy1 > sy0 ? static_cast<GLint>(height) : 0;
-        const Bool blitted = BlitWireColorImage(staged, destination, rx0, ry0, rx1, ry1,
-                                                dx0, dy0, dx1, dy1, filter, false);
-        // Retired whether or not the blit took: the copy above is already recorded against this
-        // image, so the submission that consumes it owns the storage either way.
-        WireRetiredObjects retired{};
-        retired.textures.push_back(Move(scratch));
-        RetireWireObjects(Move(retired));
-        return blitted;
-    }
-
-    Bool VulkanRenderer::BlitWireColorImage(WireImage source, WireImage destination,
-        GLint sx0, GLint sy0, GLint sx1, GLint sy1,
-        GLint dx0, GLint dy0, GLint dx1, GLint dy1, GLenum filter, Bool mipmap) {
-        const Bool sameImage = source.image == destination.image;
-        if (source.isDefault || (sameImage && source.level == destination.level && source.layer == destination.layer) ||
-            source.samples != VK_SAMPLE_COUNT_1_BIT || destination.samples != VK_SAMPLE_COUNT_1_BIT ||
-            source.is3D || destination.is3D || (source.viewType != VK_IMAGE_VIEW_TYPE_2D &&
-                            source.viewType != VK_IMAGE_VIEW_TYPE_2D_ARRAY) ||
-            (destination.viewType != VK_IMAGE_VIEW_TYPE_2D && destination.viewType != VK_IMAGE_VIEW_TYPE_2D_ARRAY) ||
-            !vkuFormatIsSampledFloat(source.format)) return false;
-        if (sx0 == sx1 || sy0 == sy1 || dx0 == dx1 || dy0 == dy1) return true;
-        if (!source.extent.width || !source.extent.height ||
-            !destination.extent.width || !destination.extent.height) return false;
-        const auto transform = destination.isDefault ? m_swapchainObject.GetPreTransform() :
-                                                       VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
-        if (transform != VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR &&
-            transform != VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR &&
-            transform != VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR &&
-            transform != VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) return false;
-        VkFormatProperties sourceProperties{};
-        vkGetPhysicalDeviceFormatProperties(m_physicalDevice.handle, source.format, &sourceProperties);
-        const VkFormatFeatureFlags required = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
-            (filter == GL_LINEAR ? VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT : 0);
-        if ((sourceProperties.optimalTilingFeatures & required) != required) return false;
-        // Mip generation samples and writes the texture's own color space;
-        // GL_FRAMEBUFFER_SRGB only controls framebuffer operations.
-        if (!mipmap) destination.format = ResolveSrgbAttachmentWriteFormat(destination.format,
-            MGB_CTX->IsCapabilityEnabled(CapabilityInput::FramebufferSrgb));
-        VkFormatProperties destinationProperties{};
-        vkGetPhysicalDeviceFormatProperties(m_physicalDevice.handle, destination.format, &destinationProperties);
-        if (!(destinationProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) return false;
-        const VkImageLayout sourceLayout = sameImage ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-        const VkImageLayout destinationLayout = sameImage ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-
-        struct Constants {
-            float srcRect[4];
-            float dstRect[4];
-            Int32 surfaceTransform;
-        };
-        static_assert(sizeof(Constants) == 36);
-        if (!m_wireColorBlitResources) {
-            m_wireColorBlitResources = new WireColorBlitResources;
-            auto& cache = *m_wireColorBlitResources;
-            const auto shader = [&](const Uint32* code, SizeT bytes, VkShaderModule& module) {
-                VkShaderModuleCreateInfo info{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO};
-                info.codeSize = bytes;
-                info.pCode = code;
-                VK_VERIFY(vkCreateShaderModule(m_device, &info, nullptr, &module));
-            };
-            shader(kWireColorBlitVertexSpirv, sizeof(kWireColorBlitVertexSpirv), cache.vertex);
-            shader(kWireColorBlitFragmentSpirv, sizeof(kWireColorBlitFragmentSpirv), cache.fragment);
-            const VkDescriptorSetLayoutBinding binding{0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-                                                       1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr};
-            VkDescriptorSetLayoutCreateInfo layout{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
-            layout.bindingCount = 1;
-            layout.pBindings = &binding;
-            VK_VERIFY(vkCreateDescriptorSetLayout(m_device, &layout, nullptr, &cache.descriptorLayout));
-            const VkPushConstantRange push{VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(Constants)};
-            VkPipelineLayoutCreateInfo pipelineLayout{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
-            pipelineLayout.setLayoutCount = 1;
-            pipelineLayout.pSetLayouts = &cache.descriptorLayout;
-            pipelineLayout.pushConstantRangeCount = 1;
-            pipelineLayout.pPushConstantRanges = &push;
-            VK_VERIFY(vkCreatePipelineLayout(m_device, &pipelineLayout, nullptr, &cache.pipelineLayout));
-            VkSamplerCreateInfo sampler{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
-            sampler.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
-            sampler.addressModeU = sampler.addressModeV = sampler.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
-            sampler.magFilter = sampler.minFilter = VK_FILTER_NEAREST;
-            sampler.maxLod = 0.0f;
-            VK_VERIFY(vkCreateSampler(m_device, &sampler, nullptr, &cache.nearest));
-            sampler.magFilter = sampler.minFilter = VK_FILTER_LINEAR;
-            VK_VERIFY(vkCreateSampler(m_device, &sampler, nullptr, &cache.linear));
-        }
-        auto& cache = *m_wireColorBlitResources;
-        WireColorBlitResources::Target* target = nullptr;
-        for (auto& entry : cache.targets) {
-            if (entry.format == destination.format && entry.layout == destinationLayout) { target = &entry; break; }
-        }
-        if (!target) {
-            cache.targets.emplace_back();
-            target = &cache.targets.back();
-            target->format = destination.format;
-            target->layout = destinationLayout;
-            VkAttachmentDescription attachment{};
-            attachment.format = destination.format;
-            attachment.samples = VK_SAMPLE_COUNT_1_BIT;
-            attachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
-            attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-            attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-            attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-            attachment.initialLayout = attachment.finalLayout = destinationLayout;
-            const VkAttachmentReference color{0, destinationLayout};
-            VkSubpassDescription subpass{};
-            subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
-            subpass.colorAttachmentCount = 1;
-            subpass.pColorAttachments = &color;
-            VkRenderPassCreateInfo pass{VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO};
-            pass.attachmentCount = 1;
-            pass.pAttachments = &attachment;
-            pass.subpassCount = 1;
-            pass.pSubpasses = &subpass;
-            VK_VERIFY(vkCreateRenderPass(m_device, &pass, nullptr, &target->renderPass));
-            VkPipelineShaderStageCreateInfo stages[2]{};
-            for (auto& stage : stages) {
-                stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
-                stage.pName = "main";
-            }
-            stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
-            stages[0].module = cache.vertex;
-            stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
-            stages[1].module = cache.fragment;
-            const VkPipelineVertexInputStateCreateInfo vertex{VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO};
-            VkPipelineInputAssemblyStateCreateInfo assembly{VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO};
-            assembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-            VkPipelineViewportStateCreateInfo viewport{VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO};
-            viewport.viewportCount = viewport.scissorCount = 1;
-            VkPipelineRasterizationStateCreateInfo raster{VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO};
-            raster.polygonMode = VK_POLYGON_MODE_FILL;
-            raster.cullMode = VK_CULL_MODE_NONE;
-            raster.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
-            raster.lineWidth = 1.0f;
-            VkPipelineMultisampleStateCreateInfo samples{VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO};
-            samples.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
-            VkPipelineColorBlendAttachmentState colorMask{};
-            colorMask.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
-                                       VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
-            VkPipelineColorBlendStateCreateInfo blend{VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO};
-            blend.attachmentCount = 1;
-            blend.pAttachments = &colorMask;
-            const VkDynamicState dynamicStates[]{VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
-            VkPipelineDynamicStateCreateInfo dynamic{VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO};
-            dynamic.dynamicStateCount = 2;
-            dynamic.pDynamicStates = dynamicStates;
-            VkGraphicsPipelineCreateInfo pipeline{VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO};
-            pipeline.stageCount = 2;
-            pipeline.pStages = stages;
-            pipeline.pVertexInputState = &vertex;
-            pipeline.pInputAssemblyState = &assembly;
-            pipeline.pViewportState = &viewport;
-            pipeline.pRasterizationState = &raster;
-            pipeline.pMultisampleState = &samples;
-            pipeline.pColorBlendState = &blend;
-            pipeline.pDynamicState = &dynamic;
-            pipeline.layout = cache.pipelineLayout;
-            pipeline.renderPass = target->renderPass;
-            VK_VERIFY(vkCreateGraphicsPipelines(m_device, VK_NULL_HANDLE, 1, &pipeline, nullptr, &target->pipeline));
-        }
-
-        m_textureManager->FlushPendingUploads();
-        // Distinct mip/layer views of the same image are legal shader input and
-        // output. GENERAL keeps the whole-image layout tracker truthful; the
-        // transition also orders the previous mip's attachment write.
-        TransitionWireImage(source, sourceLayout);
-        if (sameImage) destination.layout = source.layout;
-        else TransitionWireImage(destination, destinationLayout);
-        const auto makeView = [&](const WireImage& image) {
-            VkImageViewCreateInfo view{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
-            view.image = image.image;
-            view.viewType = VK_IMAGE_VIEW_TYPE_2D;
-            view.format = image.format;
-            // A layered framebuffer blit reads its first layer, as the native path does.
-            view.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, image.level, 1, image.layer, 1};
-            VkImageView handle = VK_NULL_HANDLE;
-            VK_VERIFY(vkCreateImageView(m_device, &view, nullptr, &handle));
-            return handle;
-        };
-        const VkImageView sourceView = makeView(source), destinationView = makeView(destination);
-        VkFramebufferCreateInfo framebufferInfo{VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO};
-        framebufferInfo.renderPass = target->renderPass;
-        framebufferInfo.attachmentCount = 1;
-        framebufferInfo.pAttachments = &destinationView;
-        framebufferInfo.width = destination.extent.width;
-        framebufferInfo.height = destination.extent.height;
-        framebufferInfo.layers = 1;
-        VkFramebuffer framebuffer = VK_NULL_HANDLE;
-        VK_VERIFY(vkCreateFramebuffer(m_device, &framebufferInfo, nullptr, &framebuffer));
-        // Each in-flight blit owns its descriptor set. Updating a cached set
-        // would rewrite the source view of an older queued blit.
-        VkDescriptorPool descriptorPool = VK_NULL_HANDLE;
-        VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
-        const VkDescriptorPoolSize poolSize{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1};
-        VkDescriptorPoolCreateInfo pool{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
-        pool.maxSets = 1;
-        pool.poolSizeCount = 1;
-        pool.pPoolSizes = &poolSize;
-        VK_VERIFY(vkCreateDescriptorPool(m_device, &pool, nullptr, &descriptorPool));
-        VkDescriptorSetAllocateInfo alloc{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
-        alloc.descriptorPool = descriptorPool;
-        alloc.descriptorSetCount = 1;
-        alloc.pSetLayouts = &cache.descriptorLayout;
-        VK_VERIFY(vkAllocateDescriptorSets(m_device, &alloc, &descriptorSet));
-        // GL_LINEAR filters only a STRETCHED blit; an unscaled one (mirrored or not, on any of the
-        // four transforms) is a copy and samples NEAREST, which is exact where linear filtering
-        // at a quantised coordinate is not (WireColorBlitFilter.h). The format check above still
-        // asks for SAMPLED_IMAGE_FILTER_LINEAR whenever GL said GL_LINEAR, so which blits reach
-        // this pass is unchanged.
-        const VkFilter samplerFilter = WireColorBlitFilterFor({sx0, sy0, sx1, sy1}, {dx0, dy0, dx1, dy1},
-                                                              filter, transform);
-        const VkDescriptorImageInfo sampled{samplerFilter == VK_FILTER_LINEAR ? cache.linear : cache.nearest,
-                                           sourceView, sourceLayout};
-        VkWriteDescriptorSet write{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
-        write.dstSet = descriptorSet;
-        write.dstBinding = 0;
-        write.descriptorCount = 1;
-        write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-        write.pImageInfo = &sampled;
-        vkUpdateDescriptorSets(m_device, 1, &write, 0, nullptr);
-
-        const float sw = static_cast<float>(source.extent.width), sh = static_cast<float>(source.extent.height);
-        const Bool quarterTurn = transform == VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR ||
-                                 transform == VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR;
-        const float dw = static_cast<float>(quarterTurn ? destination.extent.height : destination.extent.width);
-        const float dh = static_cast<float>(quarterTurn ? destination.extent.width : destination.extent.height);
-        // The shared vertex shader flips window Y. Offscreen images keep the
-        // source row order, so undo that flip in the destination rectangle.
-        if (!destination.isDefault) {
-            dy0 = static_cast<GLint>(destination.extent.height) - dy0;
-            dy1 = static_cast<GLint>(destination.extent.height) - dy1;
-        }
-        const Constants constants{{sx0 / sw, sy0 / sh, (static_cast<float>(sx1) - sx0) / sw,
-                                    (static_cast<float>(sy1) - sy0) / sh},
-                                  {dx0 / dw, dy0 / dh, (static_cast<float>(dx1) - dx0) / dw,
-                                    (static_cast<float>(dy1) - dy0) / dh},
-                                  static_cast<Int32>(ToBlitSurfaceTransform(transform))};
-        auto& frame = m_frameContext.GetCurrent();
-        VkRenderPassBeginInfo begin{VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO};
-        begin.renderPass = target->renderPass;
-        begin.framebuffer = framebuffer;
-        begin.renderArea = {{0, 0}, destination.extent};
-        vkCmdBeginRenderPass(frame.commandBuffer, &begin, VK_SUBPASS_CONTENTS_INLINE);
-        vkCmdBindPipeline(frame.commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, target->pipeline);
-        const VkViewport viewport{0.0f, 0.0f, static_cast<float>(destination.extent.width),
-                                  static_cast<float>(destination.extent.height), 0.0f, 1.0f};
-        const VkRect2D scissor{{0, 0}, destination.extent};
-        vkCmdSetViewport(frame.commandBuffer, 0, 1, &viewport);
-        vkCmdSetScissor(frame.commandBuffer, 0, 1, &scissor);
-        vkCmdBindDescriptorSets(frame.commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                cache.pipelineLayout, 0, 1, &descriptorSet, 0, nullptr);
-        vkCmdPushConstants(frame.commandBuffer, cache.pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT,
-                           0, sizeof(constants), &constants);
-        vkCmdDraw(frame.commandBuffer, 6, 1, 0, 0);
-        vkCmdEndRenderPass(frame.commandBuffer);
-        ResetDynamicStateShadow();
-        InvalidatePipelineMemo();
-        // This native pass binds its own set/layout without going through the
-        // application's descriptor binder. Its next fast path must rebind.
-        if (m_uniformManager) m_uniformManager->OnCommandBufferBoundary();
-        WireRetiredObjects retired{};
-        retired.framebuffers.push_back(framebuffer);
-        retired.imageViews = {sourceView, destinationView};
-        retired.descriptorPools.push_back(descriptorPool);
-        RetireWireObjects(Move(retired));
-        if (destination.isDefault) m_swapchainObject.SetImageContentDefined(destination.swapchainImageIndex, true);
-        return true;
-    }
-#endif

MobileGL/MG_Backend/DirectVulkan/Renderer/WireColorBlit.vert

@@ -1,25 +0,0 @@
-#version 450
-// Native Vulkan blit: no GL program, registry entry, or runtime transpilation.
-layout(push_constant) uniform BlitRect {
-    vec4 srcRect;
-    vec4 dstRect;
-    int surfaceTransform;
-} rect;
-layout(location = 0) out vec2 texCoord;
-
-void main() {
-    // A quad, rather than an oversized triangle, also clips partial blits to
-    // their destination rectangle. The Vulkan viewport covers the native image.
-    const vec2 corners[6] = vec2[](
-        vec2(0.0, 0.0), vec2(1.0, 0.0), vec2(0.0, 1.0),
-        vec2(0.0, 1.0), vec2(1.0, 0.0), vec2(1.0, 1.0));
-    vec2 uv = corners[gl_VertexIndex];
-    vec2 p = (rect.dstRect.xy + uv * rect.dstRect.zw) * 2.0 - 1.0;
-    // Same GL-bottom-left to native-image mapping as the monolithic blit.
-    p.y = -p.y;
-    if (rect.surfaceTransform == 1) p = vec2(-p.y, p.x);
-    else if (rect.surfaceTransform == 2) p = -p;
-    else if (rect.surfaceTransform == 3) p = vec2(p.y, -p.x);
-    gl_Position = vec4(p, 0.0, 1.0);
-    texCoord = rect.srcRect.xy + uv * rect.srcRect.zw;
-}

MobileGL/MG_Backend/DirectVulkan/Renderer/WireColorBlitFilter.h

@@ -1,66 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/WireColorBlitFilter.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 "../VkIncludes.h"
-
-// P7 g3-blit (g3det, gate 3): WHICH SAMPLER THE WIRE ARM'S SHADER COLOUR BLIT READS ITS SOURCE
-// THROUGH.
-//
-// GL applies a blit's `filter` only where the image is STRETCHED (GL 4.6 core 18.3.1). A blit whose
-// source and destination rectangles are the same size is a copy, whatever `filter` says, and so is
-// a mirrored one. The wire arm's shader blit (WireColorBlit.inc, BlitWireColorImage) draws a quad
-// and samples `textureLod(sourceImage, texCoord, 0)` at interpolated coordinates, and it used the
-// LINEAR sampler for every GL_LINEAR blit. At 1:1 every fragment centre maps to a texel centre, so
-// in exact arithmetic linear filtering reads the same single texel. Adreno 830 quantises the
-// coordinate to sub-texel precision: a fragment that lands a fraction off the centre blends in a
-// small weight of a neighbour. minecraft-1.21.1-neoforge-create-instancing-in-world ends with a
-// 1:1 GL_LINEAR glBlitFramebuffer into FB 0, and on the wire arm 712 high-contrast pixels moved by
-// 1 LSB toward a neighbour. The monolith's vkCmdBlitImage copied them exactly
-// (~/w7/logs/g3det/VERDICT.md section 3). NEAREST within half a texel of the centre is exact, so an
-// unscaled blit takes NEAREST. Lavapipe samples texel centres exactly, so no host picture can see
-// the difference; this pure half is what the unit test pins
-// (MG_Test/Pipeline/PipelineQuirkTest.cpp, WireColorBlitSamples*).
-//
-// THE SURFACE TRANSFORM DOES NOT TURN A COPY INTO A STRETCH. BlitWireColorImage applies the
-// quarter and half turns in NDC, over a viewport of the native image, and for a quarter turn it
-// takes the logical extent as the native extent swapped. A native pixel then has exactly the pitch
-// of a logical one, and the rotation maps pixel centres onto pixel centres. So the scale test is on
-// GL's own (logical) rectangles for identity and all three rotations. BlitWireColorImage declines
-// any other transform before it chooses a sampler; for one, this answers with the filter's own
-// mapping, as before this package.
-#if MOBILEGL_BUILD_DISAGGREGATED
-namespace MobileGL::MG_Backend::DirectVulkan {
-    // A glBlitFramebuffer rectangle as GL names it: two corners, either order.
-    struct WireBlitRect {
-        GLint x0 = 0, y0 = 0, x1 = 0, y1 = 0;
-    };
-
-    // Same extent on both axes, orientation aside. The extents are taken in 64 bits: GL accepts any
-    // GLint corner, and INT_MAX - INT_MIN does not fit in one.
-    inline Bool WireBlitIsUnscaled(const WireBlitRect& source, const WireBlitRect& destination) {
-        const auto extent = [](GLint a, GLint b) {
-            return std::abs(static_cast<Int64>(b) - static_cast<Int64>(a));
-        };
-        return extent(source.x0, source.x1) == extent(destination.x0, destination.x1) &&
-               extent(source.y0, source.y1) == extent(destination.y0, destination.y1);
-    }
-
-    inline VkFilter WireColorBlitFilterFor(const WireBlitRect& source, const WireBlitRect& destination,
-                                           GLenum filter, VkSurfaceTransformFlagBitsKHR transform) {
-        if (filter != GL_LINEAR) return VK_FILTER_NEAREST;
-        const Bool expressed = transform == VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR ||
-                               transform == VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR ||
-                               transform == VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR ||
-                               transform == VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR;
-        if (expressed && WireBlitIsUnscaled(source, destination)) return VK_FILTER_NEAREST;
-        return VK_FILTER_LINEAR;
-    }
-} // namespace MobileGL::MG_Backend::DirectVulkan
-#endif

MobileGL/MG_Backend/DirectVulkan/Renderer/WireColorBlitSpirv.h

@@ -1,132 +0,0 @@
-// Generated from WireColorBlit.vert / WireColorBlit.frag (Vulkan 1.0 / SPIR-V 1.0) by
-// scripts/bake_internal_shaders.py, which runs MG_Test's BakedInternalShadersTest with the
-// IN-TREE glslang and splices the words it emits into the arrays below. Do not edit the words
-// by hand: MOBILEGL_BAKED_INTERNAL_SHADERS (the same test, run as a gate) recompiles every
-// source in its table and reds on the first word that disagrees.
-//
-// These words were hand-run through glslangValidator before that gate existed, and the gate
-// reproduces them exactly - which is the one thing nobody could have known beforehand.
-#pragma once
-
-static constexpr Uint32 kWireColorBlitVertexSpirv[] = {
-    0x07230203u, 0x00010000u, 0x0008000bu, 0x00000070u, 0x00000000u, 0x00020011u, 0x00000001u, 0x0006000bu,
-    0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u,
-    0x0008000fu, 0x00000000u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00000016u, 0x0000005du, 0x00000066u,
-    0x00030003u, 0x00000002u, 0x000001c2u, 0x00040005u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x00030005u,
-    0x00000009u, 0x00007675u, 0x00060005u, 0x00000016u, 0x565f6c67u, 0x65747265u, 0x646e4978u, 0x00007865u,
-    0x00050005u, 0x00000019u, 0x65646e69u, 0x6c626178u, 0x00000065u, 0x00030005u, 0x0000001cu, 0x00000070u,
-    0x00050005u, 0x0000001eu, 0x74696c42u, 0x74636552u, 0x00000000u, 0x00050006u, 0x0000001eu, 0x00000000u,
-    0x52637273u, 0x00746365u, 0x00050006u, 0x0000001eu, 0x00000001u, 0x52747364u, 0x00746365u, 0x00080006u,
-    0x0000001eu, 0x00000002u, 0x66727573u, 0x54656361u, 0x736e6172u, 0x6d726f66u, 0x00000000u, 0x00040005u,
-    0x00000020u, 0x74636572u, 0x00000000u, 0x00060005u, 0x0000005bu, 0x505f6c67u, 0x65567265u, 0x78657472u,
-    0x00000000u, 0x00060006u, 0x0000005bu, 0x00000000u, 0x505f6c67u, 0x7469736fu, 0x006e6f69u, 0x00070006u,
-    0x0000005bu, 0x00000001u, 0x505f6c67u, 0x746e696fu, 0x657a6953u, 0x00000000u, 0x00070006u, 0x0000005bu,
-    0x00000002u, 0x435f6c67u, 0x4470696cu, 0x61747369u, 0x0065636eu, 0x00070006u, 0x0000005bu, 0x00000003u,
-    0x435f6c67u, 0x446c6c75u, 0x61747369u, 0x0065636eu, 0x00030005u, 0x0000005du, 0x00000000u, 0x00050005u,
-    0x00000066u, 0x43786574u, 0x64726f6fu, 0x00000000u, 0x00040047u, 0x00000016u, 0x0000000bu, 0x0000002au,
-    0x00030047u, 0x0000001eu, 0x00000002u, 0x00050048u, 0x0000001eu, 0x00000000u, 0x00000023u, 0x00000000u,
-    0x00050048u, 0x0000001eu, 0x00000001u, 0x00000023u, 0x00000010u, 0x00050048u, 0x0000001eu, 0x00000002u,
-    0x00000023u, 0x00000020u, 0x00030047u, 0x0000005bu, 0x00000002u, 0x00050048u, 0x0000005bu, 0x00000000u,
-    0x0000000bu, 0x00000000u, 0x00050048u, 0x0000005bu, 0x00000001u, 0x0000000bu, 0x00000001u, 0x00050048u,
-    0x0000005bu, 0x00000002u, 0x0000000bu, 0x00000003u, 0x00050048u, 0x0000005bu, 0x00000003u, 0x0000000bu,
-    0x00000004u, 0x00040047u, 0x00000066u, 0x0000001eu, 0x00000000u, 0x00020013u, 0x00000002u, 0x00030021u,
-    0x00000003u, 0x00000002u, 0x00030016u, 0x00000006u, 0x00000020u, 0x00040017u, 0x00000007u, 0x00000006u,
-    0x00000002u, 0x00040020u, 0x00000008u, 0x00000007u, 0x00000007u, 0x00040015u, 0x0000000au, 0x00000020u,
-    0x00000000u, 0x0004002bu, 0x0000000au, 0x0000000bu, 0x00000006u, 0x0004001cu, 0x0000000cu, 0x00000007u,
-    0x0000000bu, 0x0004002bu, 0x00000006u, 0x0000000du, 0x00000000u, 0x0005002cu, 0x00000007u, 0x0000000eu,
-    0x0000000du, 0x0000000du, 0x0004002bu, 0x00000006u, 0x0000000fu, 0x3f800000u, 0x0005002cu, 0x00000007u,
-    0x00000010u, 0x0000000fu, 0x0000000du, 0x0005002cu, 0x00000007u, 0x00000011u, 0x0000000du, 0x0000000fu,
-    0x0005002cu, 0x00000007u, 0x00000012u, 0x0000000fu, 0x0000000fu, 0x0009002cu, 0x0000000cu, 0x00000013u,
-    0x0000000eu, 0x00000010u, 0x00000011u, 0x00000011u, 0x00000010u, 0x00000012u, 0x00040015u, 0x00000014u,
-    0x00000020u, 0x00000001u, 0x00040020u, 0x00000015u, 0x00000001u, 0x00000014u, 0x0004003bu, 0x00000015u,
-    0x00000016u, 0x00000001u, 0x00040020u, 0x00000018u, 0x00000007u, 0x0000000cu, 0x00040017u, 0x0000001du,
-    0x00000006u, 0x00000004u, 0x0005001eu, 0x0000001eu, 0x0000001du, 0x0000001du, 0x00000014u, 0x00040020u,
-    0x0000001fu, 0x00000009u, 0x0000001eu, 0x0004003bu, 0x0000001fu, 0x00000020u, 0x00000009u, 0x0004002bu,
-    0x00000014u, 0x00000021u, 0x00000001u, 0x00040020u, 0x00000022u, 0x00000009u, 0x0000001du, 0x0004002bu,
-    0x00000006u, 0x0000002cu, 0x40000000u, 0x0004002bu, 0x0000000au, 0x00000030u, 0x00000001u, 0x00040020u,
-    0x00000031u, 0x00000007u, 0x00000006u, 0x0004002bu, 0x00000014u, 0x00000036u, 0x00000002u, 0x00040020u,
-    0x00000037u, 0x00000009u, 0x00000014u, 0x00020014u, 0x0000003au, 0x0004002bu, 0x0000000au, 0x00000041u,
-    0x00000000u, 0x0004002bu, 0x00000014u, 0x00000050u, 0x00000003u, 0x0004001cu, 0x0000005au, 0x00000006u,
-    0x00000030u, 0x0006001eu, 0x0000005bu, 0x0000001du, 0x00000006u, 0x0000005au, 0x0000005au, 0x00040020u,
-    0x0000005cu, 0x00000003u, 0x0000005bu, 0x0004003bu, 0x0000005cu, 0x0000005du, 0x00000003u, 0x0004002bu,
-    0x00000014u, 0x0000005eu, 0x00000000u, 0x00040020u, 0x00000063u, 0x00000003u, 0x0000001du, 0x00040020u,
-    0x00000065u, 0x00000003u, 0x00000007u, 0x0004003bu, 0x00000065u, 0x00000066u, 0x00000003u, 0x00050036u,
-    0x00000002u, 0x00000004u, 0x00000000u, 0x00000003u, 0x000200f8u, 0x00000005u, 0x0004003bu, 0x00000008u,
-    0x00000009u, 0x00000007u, 0x0004003bu, 0x00000018u, 0x00000019u, 0x00000007u, 0x0004003bu, 0x00000008u,
-    0x0000001cu, 0x00000007u, 0x0004003du, 0x00000014u, 0x00000017u, 0x00000016u, 0x0003003eu, 0x00000019u,
-    0x00000013u, 0x00050041u, 0x00000008u, 0x0000001au, 0x00000019u, 0x00000017u, 0x0004003du, 0x00000007u,
-    0x0000001bu, 0x0000001au, 0x0003003eu, 0x00000009u, 0x0000001bu, 0x00050041u, 0x00000022u, 0x00000023u,
-    0x00000020u, 0x00000021u, 0x0004003du, 0x0000001du, 0x00000024u, 0x00000023u, 0x0007004fu, 0x00000007u,
-    0x00000025u, 0x00000024u, 0x00000024u, 0x00000000u, 0x00000001u, 0x0004003du, 0x00000007u, 0x00000026u,
-    0x00000009u, 0x00050041u, 0x00000022u, 0x00000027u, 0x00000020u, 0x00000021u, 0x0004003du, 0x0000001du,
-    0x00000028u, 0x00000027u, 0x0007004fu, 0x00000007u, 0x00000029u, 0x00000028u, 0x00000028u, 0x00000002u,
-    0x00000003u, 0x00050085u, 0x00000007u, 0x0000002au, 0x00000026u, 0x00000029u, 0x00050081u, 0x00000007u,
-    0x0000002bu, 0x00000025u, 0x0000002au, 0x0005008eu, 0x00000007u, 0x0000002du, 0x0000002bu, 0x0000002cu,
-    0x00050050u, 0x00000007u, 0x0000002eu, 0x0000000fu, 0x0000000fu, 0x00050083u, 0x00000007u, 0x0000002fu,
-    0x0000002du, 0x0000002eu, 0x0003003eu, 0x0000001cu, 0x0000002fu, 0x00050041u, 0x00000031u, 0x00000032u,
-    0x0000001cu, 0x00000030u, 0x0004003du, 0x00000006u, 0x00000033u, 0x00000032u, 0x0004007fu, 0x00000006u,
-    0x00000034u, 0x00000033u, 0x00050041u, 0x00000031u, 0x00000035u, 0x0000001cu, 0x00000030u, 0x0003003eu,
-    0x00000035u, 0x00000034u, 0x00050041u, 0x00000037u, 0x00000038u, 0x00000020u, 0x00000036u, 0x0004003du,
-    0x00000014u, 0x00000039u, 0x00000038u, 0x000500aau, 0x0000003au, 0x0000003bu, 0x00000039u, 0x00000021u,
-    0x000300f7u, 0x0000003du, 0x00000000u, 0x000400fau, 0x0000003bu, 0x0000003cu, 0x00000045u, 0x000200f8u,
-    0x0000003cu, 0x00050041u, 0x00000031u, 0x0000003eu, 0x0000001cu, 0x00000030u, 0x0004003du, 0x00000006u,
-    0x0000003fu, 0x0000003eu, 0x0004007fu, 0x00000006u, 0x00000040u, 0x0000003fu, 0x00050041u, 0x00000031u,
-    0x00000042u, 0x0000001cu, 0x00000041u, 0x0004003du, 0x00000006u, 0x00000043u, 0x00000042u, 0x00050050u,
-    0x00000007u, 0x00000044u, 0x00000040u, 0x00000043u, 0x0003003eu, 0x0000001cu, 0x00000044u, 0x000200f9u,
-    0x0000003du, 0x000200f8u, 0x00000045u, 0x00050041u, 0x00000037u, 0x00000046u, 0x00000020u, 0x00000036u,
-    0x0004003du, 0x00000014u, 0x00000047u, 0x00000046u, 0x000500aau, 0x0000003au, 0x00000048u, 0x00000047u,
-    0x00000036u, 0x000300f7u, 0x0000004au, 0x00000000u, 0x000400fau, 0x00000048u, 0x00000049u, 0x0000004du,
-    0x000200f8u, 0x00000049u, 0x0004003du, 0x00000007u, 0x0000004bu, 0x0000001cu, 0x0004007fu, 0x00000007u,
-    0x0000004cu, 0x0000004bu, 0x0003003eu, 0x0000001cu, 0x0000004cu, 0x000200f9u, 0x0000004au, 0x000200f8u,
-    0x0000004du, 0x00050041u, 0x00000037u, 0x0000004eu, 0x00000020u, 0x00000036u, 0x0004003du, 0x00000014u,
-    0x0000004fu, 0x0000004eu, 0x000500aau, 0x0000003au, 0x00000051u, 0x0000004fu, 0x00000050u, 0x000300f7u,
-    0x00000053u, 0x00000000u, 0x000400fau, 0x00000051u, 0x00000052u, 0x00000053u, 0x000200f8u, 0x00000052u,
-    0x00050041u, 0x00000031u, 0x00000054u, 0x0000001cu, 0x00000030u, 0x0004003du, 0x00000006u, 0x00000055u,
-    0x00000054u, 0x00050041u, 0x00000031u, 0x00000056u, 0x0000001cu, 0x00000041u, 0x0004003du, 0x00000006u,
-    0x00000057u, 0x00000056u, 0x0004007fu, 0x00000006u, 0x00000058u, 0x00000057u, 0x00050050u, 0x00000007u,
-    0x00000059u, 0x00000055u, 0x00000058u, 0x0003003eu, 0x0000001cu, 0x00000059u, 0x000200f9u, 0x00000053u,
-    0x000200f8u, 0x00000053u, 0x000200f9u, 0x0000004au, 0x000200f8u, 0x0000004au, 0x000200f9u, 0x0000003du,
-    0x000200f8u, 0x0000003du, 0x0004003du, 0x00000007u, 0x0000005fu, 0x0000001cu, 0x00050051u, 0x00000006u,
-    0x00000060u, 0x0000005fu, 0x00000000u, 0x00050051u, 0x00000006u, 0x00000061u, 0x0000005fu, 0x00000001u,
-    0x00070050u, 0x0000001du, 0x00000062u, 0x00000060u, 0x00000061u, 0x0000000du, 0x0000000fu, 0x00050041u,
-    0x00000063u, 0x00000064u, 0x0000005du, 0x0000005eu, 0x0003003eu, 0x00000064u, 0x00000062u, 0x00050041u,
-    0x00000022u, 0x00000067u, 0x00000020u, 0x0000005eu, 0x0004003du, 0x0000001du, 0x00000068u, 0x00000067u,
-    0x0007004fu, 0x00000007u, 0x00000069u, 0x00000068u, 0x00000068u, 0x00000000u, 0x00000001u, 0x0004003du,
-    0x00000007u, 0x0000006au, 0x00000009u, 0x00050041u, 0x00000022u, 0x0000006bu, 0x00000020u, 0x0000005eu,
-    0x0004003du, 0x0000001du, 0x0000006cu, 0x0000006bu, 0x0007004fu, 0x00000007u, 0x0000006du, 0x0000006cu,
-    0x0000006cu, 0x00000002u, 0x00000003u, 0x00050085u, 0x00000007u, 0x0000006eu, 0x0000006au, 0x0000006du,
-    0x00050081u, 0x00000007u, 0x0000006fu, 0x00000069u, 0x0000006eu, 0x0003003eu, 0x00000066u, 0x0000006fu,
-    0x000100fdu, 0x00010038u,
-};
-
-static constexpr Uint32 kWireColorBlitFragmentSpirv[] = {
-    0x07230203u, 0x00010000u, 0x0008000bu, 0x00000027u, 0x00000000u, 0x00020011u, 0x00000001u, 0x0006000bu,
-    0x00000001u, 0x4c534c47u, 0x6474732eu, 0x3035342eu, 0x00000000u, 0x0003000eu, 0x00000000u, 0x00000001u,
-    0x0007000fu, 0x00000004u, 0x00000004u, 0x6e69616du, 0x00000000u, 0x0000000au, 0x0000001fu, 0x00030010u,
-    0x00000004u, 0x00000007u, 0x00030003u, 0x00000002u, 0x000001c2u, 0x00040005u, 0x00000004u, 0x6e69616du,
-    0x00000000u, 0x00050005u, 0x0000000au, 0x43786574u, 0x64726f6fu, 0x00000000u, 0x00050005u, 0x0000001fu,
-    0x4374756fu, 0x726f6c6fu, 0x00000000u, 0x00050005u, 0x00000023u, 0x72756f73u, 0x6d496563u, 0x00656761u,
-    0x00040047u, 0x0000000au, 0x0000001eu, 0x00000000u, 0x00040047u, 0x0000001fu, 0x0000001eu, 0x00000000u,
-    0x00040047u, 0x00000023u, 0x00000021u, 0x00000000u, 0x00040047u, 0x00000023u, 0x00000022u, 0x00000000u,
-    0x00020013u, 0x00000002u, 0x00030021u, 0x00000003u, 0x00000002u, 0x00020014u, 0x00000006u, 0x00030016u,
-    0x00000007u, 0x00000020u, 0x00040017u, 0x00000008u, 0x00000007u, 0x00000002u, 0x00040020u, 0x00000009u,
-    0x00000001u, 0x00000008u, 0x0004003bu, 0x00000009u, 0x0000000au, 0x00000001u, 0x0004002bu, 0x00000007u,
-    0x0000000cu, 0x00000000u, 0x0005002cu, 0x00000008u, 0x0000000du, 0x0000000cu, 0x0000000cu, 0x00040017u,
-    0x0000000eu, 0x00000006u, 0x00000002u, 0x0004002bu, 0x00000007u, 0x00000015u, 0x3f800000u, 0x0005002cu,
-    0x00000008u, 0x00000016u, 0x00000015u, 0x00000015u, 0x00040017u, 0x0000001du, 0x00000007u, 0x00000004u,
-    0x00040020u, 0x0000001eu, 0x00000003u, 0x0000001du, 0x0004003bu, 0x0000001eu, 0x0000001fu, 0x00000003u,
-    0x00090019u, 0x00000020u, 0x00000007u, 0x00000001u, 0x00000000u, 0x00000000u, 0x00000000u, 0x00000001u,
-    0x00000000u, 0x0003001bu, 0x00000021u, 0x00000020u, 0x00040020u, 0x00000022u, 0x00000000u, 0x00000021u,
-    0x0004003bu, 0x00000022u, 0x00000023u, 0x00000000u, 0x00050036u, 0x00000002u, 0x00000004u, 0x00000000u,
-    0x00000003u, 0x000200f8u, 0x00000005u, 0x0004003du, 0x00000008u, 0x0000000bu, 0x0000000au, 0x000500b8u,
-    0x0000000eu, 0x0000000fu, 0x0000000bu, 0x0000000du, 0x0004009au, 0x00000006u, 0x00000010u, 0x0000000fu,
-    0x000400a8u, 0x00000006u, 0x00000011u, 0x00000010u, 0x000300f7u, 0x00000013u, 0x00000000u, 0x000400fau,
-    0x00000011u, 0x00000012u, 0x00000013u, 0x000200f8u, 0x00000012u, 0x0004003du, 0x00000008u, 0x00000014u,
-    0x0000000au, 0x000500bau, 0x0000000eu, 0x00000017u, 0x00000014u, 0x00000016u, 0x0004009au, 0x00000006u,
-    0x00000018u, 0x00000017u, 0x000200f9u, 0x00000013u, 0x000200f8u, 0x00000013u, 0x000700f5u, 0x00000006u,
-    0x00000019u, 0x00000010u, 0x00000005u, 0x00000018u, 0x00000012u, 0x000300f7u, 0x0000001bu, 0x00000000u,
-    0x000400fau, 0x00000019u, 0x0000001au, 0x0000001bu, 0x000200f8u, 0x0000001au, 0x000100fcu, 0x000200f8u,
-    0x0000001bu, 0x0004003du, 0x00000021u, 0x00000024u, 0x00000023u, 0x0004003du, 0x00000008u, 0x00000025u,
-    0x0000000au, 0x00070058u, 0x0000001du, 0x00000026u, 0x00000024u, 0x00000025u, 0x00000002u, 0x0000000cu,
-    0x0003003eu, 0x0000001fu, 0x00000026u, 0x000100fdu, 0x00010038u,
-};

MobileGL/MG_Backend/DirectVulkan/Renderer/WireDeclineTally.h

@@ -1,172 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/WireDeclineTally.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 <Config.h>
-#if MOBILEGL_BUILD_DISAGGREGATED
-
-#include <Includes.h>
-#include <MG_Util/Debug/Log.h>
-
-#include <atomic>
-
-namespace MobileGL::MG_Backend::DirectVulkan {
-
-// P7 wave 2 package B3: the per-site tally behind CONTRACT-P7 §0 rule I.
-//
-// Shape is PipeApplier.h's ServerVerbSink tallies, and for the same reason (R-16: a probe may
-// not arm against a stub). "The retrace passed" and "the retrace silently dropped nine draws"
-// produce the same exit code and the same log, so the lane has to assert the number that only
-// this path can move.
-//
-// Counters are process-wide and monotone. On the spawn arm they live in the SERVER process,
-// which is where the draw path runs - a client-side reader would always see zero, so the
-// two-process case asserts pixels and reads these from the server's own dump.
-enum class WireDeclineSite : Uint32 {
-#define MGL_WIRE_DECLINE(name) name,
-#include "WireDeclines.def"
-#undef MGL_WIRE_DECLINE
-    Count
-};
-
-inline const char* WireDeclineSiteName(WireDeclineSite site) {
-    switch (site) {
-#define MGL_WIRE_DECLINE(name)                                                                                         \
-    case WireDeclineSite::name:                                                                                        \
-        return #name;
-#include "WireDeclines.def"
-#undef MGL_WIRE_DECLINE
-    case WireDeclineSite::Count:
-        break;
-    }
-    return "Unnamed";
-}
-
-class WireDeclineTally {
-public:
-    static constexpr SizeT kSiteCount = static_cast<SizeT>(WireDeclineSite::Count);
-
-    static void Count(WireDeclineSite site) {
-        Slots()[static_cast<SizeT>(site)].fetch_add(1, std::memory_order_relaxed);
-        Total().fetch_add(1, std::memory_order_relaxed);
-    }
-
-    static Uint64 Get(WireDeclineSite site) {
-        return Slots()[static_cast<SizeT>(site)].load(std::memory_order_relaxed);
-    }
-
-    static Uint64 TotalDeclines() { return Total().load(std::memory_order_relaxed); }
-
-    // The memory half (package M1's thread): a refused upload does not consume its
-    // PendingUpload entry, so the entry and the level shadow behind it stay alive. These are
-    // GAUGES, not counters - the last observed live depth, sampled where the refusal happens -
-    // so a monotone climb across frames is the signature that a refusal is also a leak.
-    static void SetPendingGauge(Uint64 entries, Uint64 bytes) {
-        PendingEntries().store(entries, std::memory_order_relaxed);
-        PendingBytes().store(bytes, std::memory_order_relaxed);
-        Uint64 peak = PeakPendingBytes().load(std::memory_order_relaxed);
-        while (bytes > peak && !PeakPendingBytes().compare_exchange_weak(peak, bytes, std::memory_order_relaxed)) {
-        }
-    }
-    // The frame-serial floor's own counter. An "unsound serial complete" is an advance of
-    // VkBufferManager's completed-frame-serial floor to a serial that ANOTHER submission still
-    // in flight also carries - i.e. the renderer telling the buffer manager "frame N-1 is done"
-    // while the submission holding frame N-1's buffer copies is still executing. It is what
-    // lets a streamed glBufferSubData take the unordered host path and tear one draw's vertex
-    // range. With a provable floor it is unreachable, so this counter is the red-once's reading:
-    // non-zero on the wire arms before the fix, zero after, zero on monolith either way.
-    static void CountUnsoundSerialComplete() {
-        UnsoundSerial().fetch_add(1, std::memory_order_relaxed);
-    }
-    static Uint64 UnsoundSerialCompleteEvents() { return UnsoundSerial().load(std::memory_order_relaxed); }
-
-    static Uint64 PendingUploadEntries() { return PendingEntries().load(std::memory_order_relaxed); }
-    static Uint64 PendingUploadBytes() { return PendingBytes().load(std::memory_order_relaxed); }
-    static Uint64 PeakPendingUploadBytes() { return PeakPendingBytes().load(std::memory_order_relaxed); }
-
-    static void Reset() {
-        for (SizeT i = 0; i < kSiteCount; ++i) Slots()[i].store(0, std::memory_order_relaxed);
-        Total().store(0, std::memory_order_relaxed);
-        UnsoundSerial().store(0, std::memory_order_relaxed);
-        PendingEntries().store(0, std::memory_order_relaxed);
-        PendingBytes().store(0, std::memory_order_relaxed);
-        PeakPendingBytes().store(0, std::memory_order_relaxed);
-    }
-
-    // One line per site that moved, plus the pending gauges. Called at session teardown and
-    // from the forced-condition harness; silent when nothing declined, so a green lane stays
-    // quiet and a lane that dropped a draw cannot.
-    static void Dump(const char* tag) {
-        // The floor counter prints unconditionally: "zero unsound advances" is the reading the
-        // red-once needs, and an absent line cannot be told from a lane that never ran.
-        MGLOG_I("MGWIRE-FLOOR[%s] unsoundSerialComplete=%llu", tag,
-                static_cast<unsigned long long>(UnsoundSerialCompleteEvents()));
-        if (TotalDeclines() == 0 && PeakPendingUploadBytes() == 0) return;
-        MGLOG_I("MGWIRE-DECLINES[%s] total=%llu pendingEntries=%llu pendingBytes=%llu peakPendingBytes=%llu", tag,
-                static_cast<unsigned long long>(TotalDeclines()),
-                static_cast<unsigned long long>(PendingUploadEntries()),
-                static_cast<unsigned long long>(PendingUploadBytes()),
-                static_cast<unsigned long long>(PeakPendingUploadBytes()));
-        for (SizeT i = 0; i < kSiteCount; ++i) {
-            const Uint64 value = Slots()[i].load(std::memory_order_relaxed);
-            if (!value) continue;
-            MGLOG_I("MGWIRE-DECLINES[%s]   %s=%llu", tag, WireDeclineSiteName(static_cast<WireDeclineSite>(i)),
-                    static_cast<unsigned long long>(value));
-        }
-    }
-
-private:
-    static std::atomic<Uint64>* Slots() {
-        static std::atomic<Uint64> slots[kSiteCount]{};
-        return slots;
-    }
-    static std::atomic<Uint64>& Total() {
-        static std::atomic<Uint64> total{0};
-        return total;
-    }
-    static std::atomic<Uint64>& PendingEntries() {
-        static std::atomic<Uint64> value{0};
-        return value;
-    }
-    static std::atomic<Uint64>& PendingBytes() {
-        static std::atomic<Uint64> value{0};
-        return value;
-    }
-    static std::atomic<Uint64>& PeakPendingBytes() {
-        static std::atomic<Uint64> value{0};
-        return value;
-    }
-    static std::atomic<Uint64>& UnsoundSerial() {
-        static std::atomic<Uint64> value{0};
-        return value;
-    }
-};
-
-// Every decline goes through this: the tally moves ALWAYS, the log line is once per site.
-// `MGL_WIRE_DECLINE_AT(Site, "why", ...); return false;` is the statement pair that replaces
-// a bare `return false;` (the few sites that call WireDeclineTally::Count directly stand
-// under an MGLOG_W/E of their own; scripts/ci/wire_declines_audit.py holds them to that).
-//
-// A DECLINE IS NOT ALWAYS A SKIPPED DRAW, so the line does not say "draw". The Tex*, Shape* and
-// Upload* rows are counted per texture SYNC: SyncTextureResourceByHandle is reached from the
-// draw/dispatch texture preparation, but also from the descriptor resolver, framebuffer
-// attachments, CopyTexSubImage, mipmap generation and CopyImageSubData - each of which Fatals
-// right after a failed sync - and from texture readback, which falls back to the unbacked
-// shadow. A draw that samples three unsyncable textures counts three; a failed attachment
-// sync counts once and is then a Fatal, not a skipped draw.
-#define MGL_WIRE_DECLINE_AT(site, fmt, ...)                                                                            \
-    do {                                                                                                               \
-        ::MobileGL::MG_Backend::DirectVulkan::WireDeclineTally::Count(                                                  \
-            ::MobileGL::MG_Backend::DirectVulkan::WireDeclineSite::site);                                              \
-        MGLOG_E_ONCE("Magma wire decline [" #site "]: " fmt, ##__VA_ARGS__);                                           \
-    } while (0)
-
-} // namespace MobileGL::MG_Backend::DirectVulkan
-
-#endif // MOBILEGL_BUILD_DISAGGREGATED

MobileGL/MG_Backend/DirectVulkan/Renderer/WireDeclines.def

@@ -1,128 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectVulkan/Renderer/WireDeclines.def
-// 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
-
-// P7 wave 2 package B3. THE NAMES OF EVERY WAY THE MAGMA WIRE ARM CAN DECLINE.
-//
-// A DECLINE IS NOT ALWAYS A SKIPPED DRAW. The SetupWireDraw / DispatchWireCompute rows are one
-// per refused draw or dispatch; the Tex* / Shape* / Upload* rows are counted per texture SYNC,
-// which the draw path reaches once per sampled texture and the descriptor resolver, framebuffer
-// attachments, CopyTexSubImage, mipmap generation, CopyImageSubData and texture readback reach
-// on their own (WireDeclineTally.h, above MGL_WIRE_DECLINE_AT).
-//
-// CONTRACT-P7 §0 rule I says a refusal on the wire arm is either a named decline or a named
-// Fatal. Before B3 the draw path had a third shape the rule does not admit: a bare
-// `return false` with no log, no counter and no census entry - roughly twenty of them in
-// SetupWireDraw alone, plus the texture-sync chain behind PrepareWireTextureResources. A draw
-// that took one of those exits left NO trace anywhere, which is precisely why the OpenRA
-// device divergence survived four device windows with client and server logs that were
-// LINE-IDENTICAL between a passing and a failing run.
-//
-// Each row below is one such exit. The name is what the decline logs and what the tally
-// counts, so "which exit did this frame take" is answerable from a counter dump instead of
-// from a bisect. Rows are append-only: the integration lane asserts specific counters moved.
-//
-// EVERY ROW HAS A SITE AND EVERY SITE HAS A LINE. A row with no site is a name that can never
-// be counted - it reads as "this cannot happen here" when it only means "nobody wired it up" -
-// and a site with no line puts the reader back on a bisect. Sites reached through a macro
-// (MGL_WIRE_DECLINE_AT) get both at once; the few that use WireDeclineTally::Count directly do
-// so ONLY because the statement above them already carries the same reason as an _ONCE log.
-// scripts/ci/wire_declines_audit.py holds both halves.
-//
-// MGL_WIRE_DECLINE(Name)
-
-// ---- SetupWireDraw, in statement order -------------------------------------------------
-MGL_WIRE_DECLINE(ProgramLinkOrSpirv)
-MGL_WIRE_DECLINE(PointSizeCapability)
-MGL_WIRE_DECLINE(TextureResourcesUnprepared)
-MGL_WIRE_DECLINE(VertexFormatUnsupported)
-MGL_WIRE_DECLINE(VertexAttributeWindow)
-MGL_WIRE_DECLINE(VertexStreamCountZero)
-MGL_WIRE_DECLINE(VertexStreamRead)
-MGL_WIRE_DECLINE(VertexStreamConverter)
-MGL_WIRE_DECLINE(VertexTransientUpload)
-MGL_WIRE_DECLINE(IndexViewMissing)
-MGL_WIRE_DECLINE(IndexTypeWidth)
-MGL_WIRE_DECLINE(IndexWindow)
-MGL_WIRE_DECLINE(IndexStreamRead)
-MGL_WIRE_DECLINE(IndexTransientUpload)
-MGL_WIRE_DECLINE(IndexSliceInvalid)
-MGL_WIRE_DECLINE(UniformBufferBinding)
-MGL_WIRE_DECLINE(NoAttachments)
-MGL_WIRE_DECLINE(PipelineUnavailable)
-MGL_WIRE_DECLINE(CurrentAttributePayload)
-MGL_WIRE_DECLINE(CurrentAttributeUpload)
-MGL_WIRE_DECLINE(BeginRenderPass)
-
-// ---- DispatchWireCompute (and DispatchWireComputeIndirect, P8-SV) -------------------------
-MGL_WIRE_DECLINE(ComputeProgramLinkOrSpirv)
-MGL_WIRE_DECLINE(ComputeTextureResourcesUnprepared)
-MGL_WIRE_DECLINE(ComputePipelineUnavailable)
-MGL_WIRE_DECLINE(ComputeUniformBufferBinding)
-
-// ---- UniformManager::PrepareWireTextureResources ----------------------------------------
-MGL_WIRE_DECLINE(DescriptorDeclined)
-MGL_WIRE_DECLINE(SamplerLocationAlias)
-MGL_WIRE_DECLINE(SamplerUnitRange)
-
-// ---- VkTextureManager::SyncTextureResourceByHandle --------------------------------------
-MGL_WIRE_DECLINE(TexResolveStorage)
-MGL_WIRE_DECLINE(TexViewFormat)
-MGL_WIRE_DECLINE(TexNoApplierRecord)
-MGL_WIRE_DECLINE(TexRecordDeadOrStale)
-MGL_WIRE_DECLINE(TexShapeSync)
-MGL_WIRE_DECLINE(TexUploadPendingLevels)
-MGL_WIRE_DECLINE(TexStorageUsage)
-
-// ---- VkTextureManager::UploadPendingWireLevels ------------------------------------------
-// The five `incomplete`/false exits the investigation named, plus the two that leave an
-// entry pending WITHOUT failing (a `continue`) - those are the ones that can starve a draw
-// of its texels while still reporting success, so they are counted separately.
-MGL_WIRE_DECLINE(UploadLevelBeyondChain)
-MGL_WIRE_DECLINE(UploadLevelExtentMismatch)
-MGL_WIRE_DECLINE(UploadEmptyLevel)
-MGL_WIRE_DECLINE(UploadConversion)
-MGL_WIRE_DECLINE(UploadTexelArithmetic)
-MGL_WIRE_DECLINE(UploadRegionOutOfBounds)
-MGL_WIRE_DECLINE(UploadIncomplete)
-MGL_WIRE_DECLINE(UploadFlushFailed)
-
-// ---- VkTextureManager::SyncWireTextureShape ---------------------------------------------
-MGL_WIRE_DECLINE(ShapeBufferBacked)
-MGL_WIRE_DECLINE(ShapeViewOfStorage)
-MGL_WIRE_DECLINE(ShapeNoLevels)
-MGL_WIRE_DECLINE(ShapeNoVulkanShape)
-MGL_WIRE_DECLINE(ShapeNoVkFormat)
-MGL_WIRE_DECLINE(ShapeSampleCount)
-MGL_WIRE_DECLINE(ShapePreserveFlushFailed)
-MGL_WIRE_DECLINE(ShapeImageFlagsUnsupported)
-MGL_WIRE_DECLINE(ShapeCreateImageFailed)
-// Appended by the B3 review round: the preserve-copy arm of a reallocation was the one exit in
-// SyncWireTextureShape still leaving no trace at all.
-MGL_WIRE_DECLINE(ShapePreserveCopyFailed)
-
-// ---- VulkanRenderer::GenerateWireMipmap (P8-F) -----------------------------------------
-// `mipmap-shader-format-or-shape` was a Fatal on this arm and a decline on the monolith arm; it
-// is the monolith's decline now. Counted once per refused glGenerateMipmap, whose chain is left
-// as it was.
-MGL_WIRE_DECLINE(MipmapShaderFormatOrShape)
-
-// ---- VulkanRenderer::DrawWireIndirectNative (P8-D), in statement order -----------------------
-MGL_WIRE_DECLINE(IndirectBufferUnbound)
-MGL_WIRE_DECLINE(IndirectCommandRange)
-MGL_WIRE_DECLINE(IndirectCountRange)
-MGL_WIRE_DECLINE(IndirectIndexStore)
-
-// ---- P8-SV -------------------------------------------------------------------------------
-// VulkanRenderer::GenerateWireMipmap: a combined depth/stencil (or stencil-only) chain, which no
-// arm generates (CONTRACT-P7 §3.2). It logged but was never counted, so MGWIRE-DECLINES could
-// not see it. Counted once per refused glGenerateMipmap, whose chain is left as it was.
-MGL_WIRE_DECLINE(MipmapDepthStencilAspect)
-// VulkanRenderer::DispatchWireComputeIndirect, in statement order: the dispatch-indirect store
-// is missing, or the three group-count words lie outside it or are misaligned.
-MGL_WIRE_DECLINE(DispatchIndirectBufferUnbound)
-MGL_WIRE_DECLINE(DispatchIndirectRange)

MobileGL/MG_Backend/DirectVulkan/Renderer/WireDepthMipmap.frag

@@ -1,28 +0,0 @@
-#version 450
-// The monolith arm's kDepthMipmapFragmentShaderSource (VulkanRenderer.cpp), ported to the
-// baked pipeline: the same 2x2 box of texelFetches, the same clamp, the same average, the
-// same gl_FragDepth. It is a PORT and not a rewrite on purpose - CONTRACT-P7 §3.2 retires a
-// refusal by making the wire arm observably the monolith's, so the two arms have to agree
-// texel for texel, including where they read.
-//
-// uSrcTexelSize arrives on the push constant rather than in a uniform block: the wire arm
-// owns no GL program, so there is no default-block uniform to write and no global UBO to
-// bind. That is the whole of OQ-13's narrow half for this program.
-layout(push_constant) uniform DepthMipmapRect {
-    vec4 srcRect;
-    vec4 dstRect;
-    int surfaceTransform;
-    ivec2 srcTexelSize;
-} rect;
-layout(set = 0, binding = 0) uniform sampler2D sourceImage;
-layout(location = 0) in vec2 texCoord;
-
-void main() {
-    ivec2 srcBase = ivec2(texCoord * vec2(rect.srcTexelSize));
-    ivec2 srcMax = rect.srcTexelSize - ivec2(1);
-    float depth0 = texelFetch(sourceImage, clamp(srcBase, ivec2(0), srcMax), 0).r;
-    float depth1 = texelFetch(sourceImage, clamp(srcBase + ivec2(1, 0), ivec2(0), srcMax), 0).r;
-    float depth2 = texelFetch(sourceImage, clamp(srcBase + ivec2(0, 1), ivec2(0), srcMax), 0).r;
-    float depth3 = texelFetch(sourceImage, clamp(srcBase + ivec2(1, 1), ivec2(0), srcMax), 0).r;
-    gl_FragDepth = 0.25 * (depth0 + depth1 + depth2 + depth3);
-}