[Misc] (All): Sync with dev-es.

.clang-format

@@ -1,27 +0,0 @@
-BasedOnStyle: Microsoft
-IndentWidth: 4
-UseTab: Never
-AccessModifierOffset: -4
-PointerAlignment: Left
-BreakBeforeBraces: Custom
-BraceWrapping:
-  AfterFunction: false
-  AfterClass: false
-  AfterControlStatement: Never
-  AfterEnum: false
-  AfterNamespace: false
-  AfterStruct: false
-  AfterUnion: false
-  BeforeElse: false
-  SplitEmptyFunction: false
-  SplitEmptyRecord: false
-
-AllowShortBlocksOnASingleLine: Empty
-AllowShortIfStatementsOnASingleLine: WithoutElse
-AlwaysBreakTemplateDeclarations: Yes
-NamespaceIndentation: All
-AllowShortFunctionsOnASingleLine: Inline
-SortIncludes: false
-FixNamespaceComments: true
-ShortNamespaceLines: 0
-CompactNamespaces: false

.clang-tidy

@@ -1,142 +0,0 @@
-#Generated from CLion Inspection settings
----
-Checks: '-*,
-bugprone-argument-comment,
-bugprone-assert-side-effect,
-bugprone-bad-signal-to-kill-thread,
-bugprone-branch-clone,
-bugprone-copy-constructor-init,
-bugprone-dangling-handle,
-bugprone-dynamic-static-initializers,
-bugprone-fold-init-type,
-bugprone-forward-declaration-namespace,
-bugprone-forwarding-reference-overload,
-bugprone-inaccurate-erase,
-bugprone-incorrect-roundings,
-bugprone-integer-division,
-bugprone-macro-parentheses,
-bugprone-macro-repeated-side-effects,
-bugprone-misplaced-operator-in-strlen-in-alloc,
-bugprone-misplaced-pointer-arithmetic-in-alloc,
-bugprone-misplaced-widening-cast,
-bugprone-move-forwarding-reference,
-bugprone-multiple-statement-macro,
-bugprone-no-escape,
-bugprone-parent-virtual-call,
-bugprone-posix-return,
-bugprone-reserved-identifier,
-bugprone-sizeof-container,
-bugprone-sizeof-expression,
-bugprone-spuriously-wake-up-functions,
-bugprone-string-constructor,
-bugprone-string-integer-assignment,
-bugprone-string-literal-with-embedded-nul,
-bugprone-suspicious-enum-usage,
-bugprone-suspicious-include,
-bugprone-suspicious-memset-usage,
-bugprone-suspicious-missing-comma,
-bugprone-suspicious-semicolon,
-bugprone-suspicious-string-compare,
-bugprone-suspicious-memory-comparison,
-bugprone-suspicious-realloc-usage,
-bugprone-swapped-arguments,
-bugprone-terminating-continue,
-bugprone-throw-keyword-missing,
-bugprone-too-small-loop-variable,
-bugprone-undefined-memory-manipulation,
-bugprone-undelegated-constructor,
-bugprone-unhandled-self-assignment,
-bugprone-unused-raii,
-bugprone-unused-return-value,
-bugprone-use-after-move,
-bugprone-virtual-near-miss,
-cert-dcl21-cpp,
-cert-dcl58-cpp,
-cert-err34-c,
-cert-err52-cpp,
-cert-err60-cpp,
-cert-flp30-c,
-cert-msc50-cpp,
-cert-msc51-cpp,
-cert-str34-c,
-cppcoreguidelines-interfaces-global-init,
-cppcoreguidelines-narrowing-conversions,
-cppcoreguidelines-pro-type-member-init,
-cppcoreguidelines-slicing,
-google-default-arguments,
-google-runtime-operator,
-hicpp-exception-baseclass,
-hicpp-multiway-paths-covered,
-misc-misplaced-const,
-misc-new-delete-overloads,
-misc-non-copyable-objects,
-misc-throw-by-value-catch-by-reference,
-misc-unconventional-assign-operator,
-misc-uniqueptr-reset-release,
-modernize-avoid-bind,
-modernize-concat-nested-namespaces,
-modernize-deprecated-headers,
-modernize-deprecated-ios-base-aliases,
-modernize-loop-convert,
-modernize-make-shared,
-modernize-make-unique,
-modernize-pass-by-value,
-modernize-raw-string-literal,
-modernize-redundant-void-arg,
-modernize-replace-auto-ptr,
-modernize-replace-disallow-copy-and-assign-macro,
-modernize-replace-random-shuffle,
-modernize-return-braced-init-list,
-modernize-shrink-to-fit,
-modernize-unary-static-assert,
-modernize-use-auto,
-modernize-use-bool-literals,
-modernize-use-emplace,
-modernize-use-equals-default,
-modernize-use-equals-delete,
-modernize-use-noexcept,
-modernize-use-nullptr,
-modernize-use-override,
-modernize-use-transparent-functors,
-modernize-use-uncaught-exceptions,
-mpi-buffer-deref,
-mpi-type-mismatch,
-openmp-use-default-none,
-performance-faster-string-find,
-performance-for-range-copy,
-performance-implicit-conversion-in-loop,
-performance-inefficient-algorithm,
-performance-inefficient-string-concatenation,
-performance-inefficient-vector-operation,
-performance-move-const-arg,
-performance-move-constructor-init,
-performance-no-automatic-move,
-performance-noexcept-move-constructor,
-performance-trivially-destructible,
-performance-type-promotion-in-math-fn,
-performance-unnecessary-copy-initialization,
-performance-unnecessary-value-param,
-portability-simd-intrinsics,
-readability-avoid-const-params-in-decls,
-readability-const-return-type,
-readability-container-size-empty,
-readability-convert-member-functions-to-static,
-readability-delete-null-pointer,
-readability-deleted-default,
-readability-inconsistent-declaration-parameter-name,
-readability-make-member-function-const,
-readability-misleading-indentation,
-readability-misplaced-array-index,
-readability-non-const-parameter,
-readability-redundant-control-flow,
-readability-redundant-declaration,
-readability-redundant-function-ptr-dereference,
-readability-redundant-smartptr-get,
-readability-redundant-string-cstr,
-readability-redundant-string-init,
-readability-simplify-subscript-expr,
-readability-static-accessed-through-instance,
-readability-static-definition-in-anonymous-namespace,
-readability-string-compare,
-readability-uniqueptr-delete-release,
-readability-use-anyofallof'

.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,75 +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
-
-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
-if grep -Fq 'android.intent.action.MAIN' <<<"$trace_manifest"; then
-  echo '::error::Trace APK must not expose a launcher activity' >&2
-  exit 1
-fi
-
-echo 'Validated unified MobileGL plugin APK and isolated trace APK.'

.github/workflows/apk.yml

@@ -1,660 +0,0 @@
-name: MobileGL APK
-
-on:
-  push:
-    branches:
-      - dev
-      - Feat/Backend-Direct-GLES
-      - Feat/Backend-Direct-Vulkan
-  workflow_dispatch:
-
-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
-
-    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: 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
-
-      - 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 --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 --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
-    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: |
-          echo "android=$(python3 tools/trace_replay/trace_cases.py --ci --format github-apk-matrix)" >> "$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
-
-      - 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.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:
-      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
-
-      - 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=()
-          # 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}"
-          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-${{ 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()
-
-    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 retrace results
-        uses: actions/download-artifact@v8
-        with:
-          pattern: MobileGL-android-retrace-result-*
-          path: retrace-artifacts
-
-      - name: Render retrace summary
-        run: |
-          node tools/trace_replay/render_retrace_summary.mjs \
-            --input retrace-artifacts \
-            --output-dir android-retrace-summary \
-            --title "MobileGL Android retrace overview" \
-            --group-label "Android Emulator" \
-            --html mobilegl-android-retrace-overview.html
-
-      - name: Upload Android retrace summary
-        uses: actions/upload-artifact@v7
-        with:
-          path: android-retrace-summary/mobilegl-android-retrace-overview.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: |
-          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 < <(
-            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'
-          )
-
-          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 < <(
-            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'
-          )
-
-          echo "Deleted ${deleted} intermediate Android artifact(s); retained ${retained} failed-retrace fixture(s)."

.github/workflows/test.yml

@@ -1,780 +0,0 @@
-name: Test
-
-on:
-  push:
-    branches:
-      - dev
-      - Feat/Backend-Direct-GLES
-      - Feat/Backend-Direct-Vulkan
-  workflow_dispatch:
-
-jobs:
-  build-linux:
-    runs-on: ubuntu-latest
-    permissions:
-      actions: write
-      contents: read
-    env:
-      BUILD_DIR: build-linux
-      CCACHE_BASEDIR: ${{ github.workspace }}
-      CCACHE_COMPRESS: "true"
-      CCACHE_DIR: ${{ github.workspace }}/.ccache
-      CCACHE_MAXSIZE: 4G
-      CCACHE_NOHASHDIR: "true"
-
-    steps:
-      - name: Set Swap Space
-        uses: pierotofy/set-swap-space@v1.0
-        with:
-          swap-size-gb: 32
-
-      - name: Checkout repo
-        uses: actions/checkout@v6
-        with:
-          submodules: recursive
-
-      - name: Get CMake
-        uses: lukka/get-cmake@v4.3.3
-
-      - name: Restore ccache
-        uses: actions/cache/restore@v5
-        with:
-          path: .ccache
-          key: ${{ runner.os }}-test-${{ github.job }}-ccache-v1
-          restore-keys: |
-            ${{ runner.os }}-test-${{ github.job }}-ccache-
-
-      - name: Prepare Vulkan SDK
-        uses: humbletim/setup-vulkan-sdk@v1.2.1
-        with:
-          vulkan-query-version: 1.4.304.1
-          vulkan-components: Vulkan-Headers, Vulkan-Loader
-          vulkan-use-cache: true
-
-      - name: Update glslang external sources
-        working-directory: 3rdparty/glslang
-        run: python update_glslang_sources.py
-
-      - name: Install build dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y ccache clang-20 clang++-20 lld-20 libc++-20-dev libc++abi-20-dev libvulkan-dev libegl1-mesa-dev libgles2-mesa-dev libgl1-mesa-dri mesa-vulkan-drivers ninja-build
-
-      - name: Show installed toolchain
-        run: |
-          ccache --version
-          clang-20 --version
-          clang++-20 --version
-          ld.lld-20 --version || ld.lld --version || true
-          dpkg -l 'libc++*' 'libegl*' 'libgles*' 'mesa*' 'vulkan*' || true
-
-      - name: Configure CMake
-        run: |
-          if [ "${{ secrets.ACTIONS_STEP_DEBUG }}" = "true" ]; then
-            BUILD_TYPE=Debug
-          else
-            BUILD_TYPE=Release
-          fi
-
-          cmake -S . -B "${BUILD_DIR}" -G Ninja \
-            -DCMAKE_C_COMPILER=clang-20 \
-            -DCMAKE_CXX_COMPILER=clang++-20 \
-            -DCMAKE_C_COMPILER_LAUNCHER=ccache \
-            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-            -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
-            -DMOBILEGL_LOG_ACTIVE_LEVEL=MOBILEGL_LOG_LEVEL_INFO \
-            -DMOBILEGL_BUILD_TEST=ON \
-            -DMOBILEGL_BUILD_BENCHMARK=ON \
-            -DMOBILEGL_BUILD_INTEGRATION_TEST=ON \
-            -DMOBILEGL_ITEST_VK_ICD=/usr/share/vulkan/icd.d/lvp_icd.json \
-            -DMOBILEGL_BUILD_TRACE_REPLAY=OFF \
-            -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON \
-            -DBENCHMARK_ENABLE_TESTING=OFF \
-            -DCMAKE_POLICY_VERSION_MINIMUM=3.5
-
-      - name: Build
-        run: cmake --build "${BUILD_DIR}" --parallel "$(nproc)"
-
-      - 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 one of their own.
-      - name: Release superseded ccache entry
-        if: github.ref_name == github.event.repository.default_branch
-        env:
-          GH_TOKEN: ${{ github.token }}
-          CACHE_KEY: ${{ runner.os }}-test-${{ github.job }}-ccache-v1
-        run: gh cache delete "${CACHE_KEY}" || true
-
-      - name: Save ccache
-        if: github.ref_name == github.event.repository.default_branch
-        continue-on-error: true
-        uses: actions/cache/save@v5
-        with:
-          path: .ccache
-          key: ${{ runner.os }}-test-${{ github.job }}-ccache-v1
-
-      - name: Package Linux runtime
-        run: |
-          mkdir -p ci-artifacts
-          mapfile -t SHARED_LIBS < <(find "${BUILD_DIR}" -type f \( -name '*.so' -o -name '*.so.*' \) -print | sort)
-          tar \
-            --exclude='*/CMakeFiles' \
-            --exclude='*.o' \
-            --exclude='*.a' \
-            --exclude='*.ninja*' \
-            --exclude='build.ninja' \
-            --exclude='cmake_install.cmake' \
-            -czf ci-artifacts/mobilegl-linux-runtime.tgz \
-            "${BUILD_DIR}/CTestTestfile.cmake" \
-            "${BUILD_DIR}/MobileGL/MG_Test" \
-            "${BUILD_DIR}/MobileGL/MG_Benchmark" \
-            "${BUILD_DIR}/MobileGL/MG_IntegrationTest" \
-            "${SHARED_LIBS[@]}"
-
-      - name: Upload Linux runtime
-        uses: actions/upload-artifact@v7
-        with:
-          name: mobilegl-linux-runtime
-          path: ci-artifacts/mobilegl-linux-runtime.tgz
-          if-no-files-found: error
-
-  test:
-    runs-on: ubuntu-latest
-    needs: build-linux
-
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v6
-
-      - name: Get CMake
-        uses: lukka/get-cmake@v4.3.3
-
-      - name: Install runtime dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libvulkan1 libegl1 libgles2 libgl1-mesa-dri mesa-vulkan-drivers
-
-      - name: Download Linux runtime
-        uses: actions/download-artifact@v8
-        with:
-          name: mobilegl-linux-runtime
-          path: .
-
-      - name: Unpack Linux runtime
-        run: tar -xzf mobilegl-linux-runtime.tgz
-
-      - name: Normalize CTest command paths
-        run: |
-          python - <<'PY'
-          from pathlib import Path
-          import re
-
-          for path in Path('build-linux').rglob('CTestTestfile.cmake'):
-              text = path.read_text()
-              text = re.sub(r'"[^"]*/cmake-[^"]*/bin/cmake"', '"cmake"', text)
-              path.write_text(text)
-          PY
-
-      - name: Test
-        working-directory: build-linux
-        run: |
-          ulimit -c unlimited
-          sudo sysctl -w kernel.core_pattern='/tmp/core.%e.%p'
-          if [ "${{ secrets.ACTIONS_STEP_DEBUG }}" = "true" ]; then
-            ctest -V -L unit --no-tests=error
-          else
-            ctest --output-on-failure -L unit --no-tests=error
-          fi
-
-      - name: Upload core dumps
-        if: failure()
-        uses: actions/upload-artifact@v7
-        with:
-          name: unit-core-dumps
-          path: /tmp/core.*
-          if-no-files-found: ignore
-
-  integration:
-    runs-on: ubuntu-latest
-    needs: build-linux
-
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v6
-
-      - name: Get CMake
-        uses: lukka/get-cmake@v4.3.3
-
-      - name: Install runtime dependencies
-        # Same set as the benchmark job, for the same reason: the scenarios bring
-        # up real headless EGL (llvmpipe) and Vulkan (lavapipe) contexts, and
-        # libegl-mesa0 - the EGL vendor library behind glvnd's libegl1 dispatch -
-        # only arrives as a Recommends.
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libvulkan1 libegl1 libegl-mesa0 libgles2 libgl1-mesa-dri mesa-vulkan-drivers
-
-      - name: Download Linux runtime
-        uses: actions/download-artifact@v8
-        with:
-          name: mobilegl-linux-runtime
-          path: .
-
-      - name: Unpack Linux runtime
-        run: tar -xzf mobilegl-linux-runtime.tgz
-
-      - name: Normalize CTest command paths
-        run: |
-          python - <<'PY'
-          from pathlib import Path
-          import re
-
-          for path in Path('build-linux').rglob('CTestTestfile.cmake'):
-              text = path.read_text()
-              text = re.sub(r'"[^"]*/cmake-[^"]*/bin/cmake"', '"cmake"', text)
-              path.write_text(text)
-          PY
-
-      - name: Integration scenarios
-        working-directory: build-linux
-        # REQUIRE_GPU makes a driverless runner FAIL instead of skipping every
-        # scenario - an all-skip run is otherwise indistinguishable from a pass,
-        # which is how a five-month-old draw-dropping bug survived unseen until
-        # this lane existed.
-        #
-        # The lavapipe ICD pin lives in the build-linux configure
-        # (-DMOBILEGL_ITEST_VK_ICD), NOT here: the configure bakes it into each
-        # test's ctest ENVIRONMENT property, and a property entry OVERRIDES the
-        # job environment - a VK_ICD_FILENAMES exported here would be silently
-        # ignored while looking like it works. This lane runs on lavapipe
-        # deterministically, not on whichever of the eight Mesa ICDs a GPU-less
-        # runner enumerates first.
-        #
-        # Cores are armed so that any crash - the harness pre-flight child's
-        # included - leaves /tmp/core.*, which the failure-only step below ships
-        # as an artifact. Analyzing a downloaded core against the runtime
-        # artifact's binary in an ubuntu-24.04 userspace reproduces the exact
-        # crash stack without burning a CI round on an in-workflow debugger.
-        env:
-          MOBILEGL_ITEST_REQUIRE_GPU: "1"
-          MOBILEGL_MAGMA_FIX_ITERATIONRP_SUBGROUP_SCRATCH: "1"
-          MOBILEGL_MAGMA_DERIVE_NUM_SUBGROUPS: "1"
-          MOBILEGL_MAGMA_ITERATIONRP_FIX_BARRIER: "1"
-        run: |
-          ulimit -c unlimited
-          sudo sysctl -w kernel.core_pattern='/tmp/core.%e.%p'
-          # Second, filtered pass: with the range-invalidating map flush disabled,
-          # the buffer scenarios run on the upload ring's staged-copy tier - which
-          # the default pass never reaches (the map tier absorbs every flush on
-          # Mesa), so without this the Mali fallback tier would have zero CI
-          # coverage. The flag is NOT baked into the ctest ENVIRONMENT properties,
-          # so an inline env reaches the test processes (unlike the ICD pin above).
-          if [ "${{ secrets.ACTIONS_STEP_DEBUG }}" = "true" ]; then
-            ctest -V -L integration-gpu --no-tests=error
-            MOBILEGL_ESPRYT_DISABLE_INVALIDATE_FLUSH=1 ctest -V -L integration-gpu \
-              -R 'Buffer|Readback|Atomic|Ssbo|Arena' --no-tests=error
-          else
-            ctest --output-on-failure -L integration-gpu --no-tests=error
-            MOBILEGL_ESPRYT_DISABLE_INVALIDATE_FLUSH=1 ctest --output-on-failure -L integration-gpu \
-              -R 'Buffer|Readback|Atomic|Ssbo|Arena' --no-tests=error
-          fi
-
-      - name: Upload core dumps
-        if: failure()
-        uses: actions/upload-artifact@v7
-        with:
-          name: integration-core-dumps
-          path: /tmp/core.*
-          if-no-files-found: ignore
-
-  benchmark:
-    runs-on: ubuntu-latest
-    needs: build-linux
-
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v6
-
-      - name: Get CMake
-        uses: lukka/get-cmake@v4.3.3
-
-      - name: Install runtime dependencies
-        # libegl-mesa0 is the EGL vendor library itself: DriverBench brings up a
-        # real GL context, and libegl1 is only glvnd's dispatch. It normally
-        # arrives as a Recommends of libegl1, which is too quiet a dependency for
-        # the one job that needs a working driver.
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libvulkan1 libegl1 libegl-mesa0 libgles2 libgl1-mesa-dri mesa-vulkan-drivers
-
-      - name: Download Linux runtime
-        uses: actions/download-artifact@v8
-        with:
-          name: mobilegl-linux-runtime
-          path: .
-
-      - name: Unpack Linux runtime
-        run: tar -xzf mobilegl-linux-runtime.tgz
-
-      - name: Normalize CTest command paths
-        run: |
-          python - <<'PY'
-          from pathlib import Path
-          import re
-
-          for path in Path('build-linux').rglob('CTestTestfile.cmake'):
-              text = path.read_text()
-              text = re.sub(r'"[^"]*/cmake-[^"]*/bin/cmake"', '"cmake"', text)
-              path.write_text(text)
-          PY
-
-      - name: Benchmark
-        working-directory: build-linux
-        run: |
-          ulimit -c unlimited
-          sudo sysctl -w kernel.core_pattern='/tmp/core.%e.%p'
-          ctest -V -C Release -L benchmark --no-tests=error
-
-      - name: Upload core dumps
-        if: failure()
-        uses: actions/upload-artifact@v7
-        with:
-          name: benchmark-core-dumps
-          path: /tmp/core.*
-          if-no-files-found: ignore
-
-  build-retrace:
-    runs-on: ubuntu-latest
-    needs:
-      - build-linux
-      - test
-      - benchmark
-      - integration
-    permissions:
-      actions: write
-      contents: read
-    env:
-      BUILD_DIR: build-retrace
-      CCACHE_BASEDIR: ${{ github.workspace }}
-      CCACHE_COMPRESS: "true"
-      CCACHE_DIR: ${{ github.workspace }}/.ccache
-      CCACHE_MAXSIZE: 4G
-      CCACHE_NOHASHDIR: "true"
-      MOBILEGL_LIBRARY: ${{ github.workspace }}/build-linux/libMobileGL.so
-
-    steps:
-      - name: Set Swap Space
-        uses: pierotofy/set-swap-space@v1.0
-        with:
-          swap-size-gb: 32
-
-      - name: Checkout repo
-        uses: actions/checkout@v6
-        with:
-          submodules: recursive
-
-      - name: Get CMake
-        uses: lukka/get-cmake@v4.3.3
-
-      - name: Restore ccache
-        uses: actions/cache/restore@v5
-        with:
-          path: .ccache
-          key: ${{ runner.os }}-test-${{ github.job }}-ccache-v1
-          restore-keys: |
-            ${{ runner.os }}-test-${{ github.job }}-ccache-
-
-      - name: Prepare Vulkan SDK
-        uses: humbletim/setup-vulkan-sdk@v1.2.1
-        with:
-          vulkan-query-version: 1.4.304.1
-          vulkan-components: Vulkan-Headers, Vulkan-Loader
-          vulkan-use-cache: true
-
-      - name: Update glslang external sources
-        working-directory: 3rdparty/glslang
-        run: python update_glslang_sources.py
-
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y ccache clang-20 clang++-20 lld-20 libc++-20-dev libc++abi-20-dev libvulkan-dev libegl1-mesa-dev libgles2-mesa-dev libgl1-mesa-dri mesa-vulkan-drivers ninja-build
-
-      - name: Show installed toolchain
-        run: |
-          ccache --version
-          clang-20 --version
-          clang++-20 --version
-          ld.lld-20 --version || ld.lld --version || true
-          dpkg -l 'libc++*' 'libegl*' 'libgles*' 'mesa*' 'vulkan*' || true
-
-      - name: Download Linux runtime
-        uses: actions/download-artifact@v8
-        with:
-          name: mobilegl-linux-runtime
-          path: .
-
-      - name: Unpack Linux runtime
-        run: |
-          tar -xzf mobilegl-linux-runtime.tgz
-          test -f "${MOBILEGL_LIBRARY}"
-
-      - name: Configure CMake
-        run: |
-          if [ "${{ secrets.ACTIONS_STEP_DEBUG }}" = "true" ]; then
-            BUILD_TYPE=Debug
-          else
-            BUILD_TYPE=Release
-          fi
-
-          cmake -S . -B "${BUILD_DIR}" -G Ninja \
-            -DCMAKE_C_COMPILER=clang-20 \
-            -DCMAKE_CXX_COMPILER=clang++-20 \
-            -DCMAKE_C_COMPILER_LAUNCHER=ccache \
-            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-            -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" \
-            -DMOBILEGL_LOG_ACTIVE_LEVEL=MOBILEGL_LOG_LEVEL_INFO \
-            -DMOBILEGL_BUILD_TEST=OFF \
-            -DMOBILEGL_BUILD_BENCHMARK=OFF \
-            -DMOBILEGL_BUILD_TRACE_REPLAY=ON \
-            -DMOBILEGL_TRACE_REPLAY_MOBILEGL_LIBRARY="${MOBILEGL_LIBRARY}" \
-            -DCMAKE_POLICY_VERSION_MINIMUM=3.5
-
-      - name: Build trace replay
-        run: cmake --build "${BUILD_DIR}" --target mobilegl_trace_replay --parallel "$(nproc)"
-
-      - name: Show ccache stats
-        if: always()
-        run: ccache --show-stats
-
-      - name: Release superseded ccache entry
-        if: github.ref_name == github.event.repository.default_branch
-        env:
-          GH_TOKEN: ${{ github.token }}
-          CACHE_KEY: ${{ runner.os }}-test-${{ github.job }}-ccache-v1
-        run: gh cache delete "${CACHE_KEY}" || true
-
-      - name: Save ccache
-        if: github.ref_name == github.event.repository.default_branch
-        continue-on-error: true
-        uses: actions/cache/save@v5
-        with:
-          path: .ccache
-          key: ${{ runner.os }}-test-${{ github.job }}-ccache-v1
-
-      - name: Normalize CTest command paths
-        run: |
-          python - <<'PY'
-          from pathlib import Path
-          import re
-
-          for path in Path('build-retrace').rglob('CTestTestfile.cmake'):
-              text = path.read_text()
-              text = re.sub(r'"[^"]*/cmake-[^"]*/bin/cmake"', '"cmake"', text)
-              path.write_text(text)
-          PY
-
-      - name: Package trace replay
-        run: |
-          mkdir -p ci-artifacts
-          tar -czf ci-artifacts/mobilegl-trace-replay.tgz \
-            build-retrace/tools/trace_replay/mobilegl_trace_replay \
-            build-retrace/tools/trace_replay/CTestTestfile.cmake
-
-      - name: Upload trace replay
-        uses: actions/upload-artifact@v7
-        with:
-          name: mobilegl-trace-replay
-          path: ci-artifacts/mobilegl-trace-replay.tgz
-          if-no-files-found: error
-
-  trace-cases:
-    name: trace case matrix
-    runs-on: ubuntu-latest
-    needs:
-      - test
-      - benchmark
-      - integration
-    outputs:
-      matrix: ${{ steps.trace-cases.outputs.matrix }}
-      names: ${{ steps.trace-cases.outputs.names }}
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v6
-
-      - name: Load trace cases
-        id: trace-cases
-        run: |
-          echo "matrix=$(python3 tools/trace_replay/trace_cases.py --ci --format github-test-matrix)" >> "$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: trace-fixture-${{ matrix.case }}
-          path: trace-fixtures/**
-          if-no-files-found: error
-
-  retrace:
-    name: retrace (${{ matrix.backend }}, ${{ matrix.case }})
-    runs-on: ubuntu-latest
-    needs:
-      - build-linux
-      - build-retrace
-      - trace-cases
-      - trace-fixtures
-    if: ${{ always() && needs.build-linux.result == 'success' && needs.build-retrace.result == 'success' && needs.trace-cases.result == 'success' }}
-    strategy:
-      fail-fast: false
-      max-parallel: 4
-      matrix: ${{ fromJSON(needs.trace-cases.outputs.matrix) }}
-
-    steps:
-      - name: Set Swap Space
-        uses: pierotofy/set-swap-space@v1.0
-        with:
-          swap-size-gb: 16
-
-      - name: Checkout repo
-        uses: actions/checkout@v6
-
-      - name: Download trace fixture
-        uses: actions/download-artifact@v8
-        with:
-          name: trace-fixture-${{ matrix.case }}
-          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: Get CMake
-        uses: lukka/get-cmake@v4.3.3
-
-      - name: Install runtime dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libvulkan1 libegl1-mesa-dev libgles2-mesa-dev libgl1-mesa-dri mesa-vulkan-drivers
-          test -e /usr/lib/x86_64-linux-gnu/libEGL.so
-          test -e /usr/lib/x86_64-linux-gnu/libGLESv2.so
-
-      - name: Download Linux runtime
-        uses: actions/download-artifact@v8
-        with:
-          name: mobilegl-linux-runtime
-          path: .
-
-      - name: Download trace replay
-        uses: actions/download-artifact@v8
-        with:
-          name: mobilegl-trace-replay
-          path: .
-
-      - name: Unpack retrace runtime
-        run: |
-          tar -xzf mobilegl-linux-runtime.tgz
-          tar -xzf mobilegl-trace-replay.tgz
-          test -f build-linux/libMobileGL.so
-          test -f build-retrace/tools/trace_replay/mobilegl_trace_replay
-
-      - name: Retrace and validate
-        working-directory: build-retrace/tools/trace_replay
-        run: |
-          ulimit -c unlimited
-          sudo sysctl -w kernel.core_pattern='/tmp/core.%e.%p'
-          if [ '${{ matrix.backend }}' = 'DirectVulkan' ]; then
-            export MOBILEGL_MAGMA_R11G11B10F_FALLBACK=1
-          fi
-          if [ '${{ matrix.backend }}' = 'DirectVulkan' ] \
-             && [ '${{ matrix.case }}' = 'minecraft-1.21.4-fabric-iris-iterationrp-in-world' ]; then
-            export MOBILEGL_MAGMA_FIX_ITERATIONRP_SUBGROUP_SCRATCH=1
-            export MOBILEGL_MAGMA_DERIVE_NUM_SUBGROUPS=1
-            export MOBILEGL_MAGMA_ITERATIONRP_FIX_BARRIER=1
-          fi
-          # The blended depth-write quirk auto-enables only on Qualcomm, which no CI
-          # runner has, so force it on for the OIT case it exists to fix. ForceOn
-          # bypasses only the vendor gate, so this exercises the real strip on
-          # lavapipe. The Android AVD lane deliberately leaves it off, keeping the
-          # unstripped path covered for the same trace.
-          if [ '${{ matrix.backend }}' = 'DirectVulkan' ] \
-             && [ '${{ matrix.case }}' = 'improved-transparency-minecraft-26.3' ]; then
-            export MOBILEGL_MAGMA_DISABLE_BLENDED_DEPTH_WRITE=1
-          fi
-          ctest -V --no-tests=error -R '^MobileGLTraceReplay\.${{ matrix.case }}\.${{ matrix.backend }}$'
-
-      - name: Upload core dumps
-        if: failure()
-        uses: actions/upload-artifact@v7
-        with:
-          name: retrace-core-dumps-${{ matrix.backend }}-${{ matrix.case }}
-          path: /tmp/core.*
-          if-no-files-found: ignore
-
-      - name: Upload actual image
-        if: always()
-        uses: actions/upload-artifact@v7
-        with:
-          name: retrace-result-${{ matrix.backend }}-${{ matrix.case }}
-          path: |
-            build-retrace/tools/trace_replay/${{ matrix.case }}/actual-images/**
-            build-retrace/tools/trace_replay/${{ matrix.case }}/${{ matrix.backend }}/output/**
-          if-no-files-found: warn
-
-  retrace-summary:
-    name: retrace summary
-    runs-on: ubuntu-latest
-    needs: retrace
-    if: ${{ always() && needs.retrace.result != 'skipped' }}
-
-    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 retrace results
-        uses: actions/download-artifact@v8
-        with:
-          pattern: retrace-result-*
-          path: retrace-artifacts
-
-      - name: Render retrace summary
-        run: |
-          node tools/trace_replay/render_retrace_summary.mjs \
-            --input retrace-artifacts \
-            --output-dir retrace-summary \
-            --title "MobileGL Linux retrace overview" \
-            --group-label "Linux" \
-            --html mobilegl-linux-retrace-overview.html
-
-      - name: Upload retrace summary
-        uses: actions/upload-artifact@v7
-        with:
-          path: retrace-summary/mobilegl-linux-retrace-overview.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 Linux retrace artifacts
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          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 < <(
-            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'
-          )
-
-          if ((${#failed_cases[@]})); then
-            echo "Retaining fixtures for failed retrace case(s):"
-            printf '  %s\n' "${!failed_cases[@]}"
-          else
-            echo "All retrace jobs succeeded; no fixtures need to be retained."
-          fi
-
-          deleted=0
-          retained=0
-          while IFS=$'\t' read -r artifact_id artifact_name; do
-            if [[ "${artifact_name}" == trace-fixture-* ]]; then
-              case_name="${artifact_name#trace-fixture-}"
-              if [[ -v "failed_cases[${case_name}]" ]]; then
-                echo "Retaining ${artifact_name} (${artifact_id}) for failed retrace."
-                ((retained += 1))
-                continue
-              fi
-            fi
-
-            echo "Deleting ${artifact_name} (${artifact_id})"
-            gh api --method DELETE "repos/${GITHUB_REPOSITORY}/actions/artifacts/${artifact_id}"
-            ((deleted += 1))
-          done < <(
-            gh api --paginate "repos/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}/artifacts?per_page=100" \
-              --jq '.artifacts[] | select(.name | startswith("trace-fixture-") or startswith("retrace-result-")) | [.id, .name] | @tsv'
-          )
-
-          echo "Deleted ${deleted} intermediate Linux artifact(s); retained ${retained} failed-retrace fixture(s)."

.gitignore

@@ -1,30 +0,0 @@
-################################################################################
-# 此 .gitignore 文件已由 Microsoft(R) Visual Studio 自动创建。
-################################################################################
-
-/build
-.cxx
-/.vs
-/out/build
-CMakeSettings.json
-MobileGL/MG_Test/out
-MobileGL/MG_Test/.vs
-MobileGLCodeManager.*
-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

.gitmodules

@@ -1,36 +0,0 @@
-[submodule "3rdparty/DiligentCore"]
-	path = 3rdparty/DiligentCore
-	url = https://github.com/DiligentGraphics/DiligentCore.git
-[submodule "3rdparty/glslang"]
-	path = 3rdparty/glslang
-	url = https://github.com/MobileGL-Dev/glslang.git
-[submodule "3rdparty/SPIRV-Cross"]
-	path = 3rdparty/SPIRV-Cross
-	url = https://github.com/KhronosGroup/SPIRV-Cross.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

CMakeLists.txt

@@ -2,700 +2,120 @@ cmake_minimum_required(VERSION 3.22.1)
 
 project("MobileGL")
 
-option(MOBILEGL_BUILD_TEST        "Build MobileGL tests"                             ON )
-option(MOBILEGL_BUILD_BENCHMARK   "Build MobileGL benchmarks"                        ON )
-# Headless end-to-end GPU scenarios (MobileGL/MG_IntegrationTest). They need a
-# real GPU/ICD to do anything, so they are off by default for CI; every scenario
-# skips cleanly where there is none. Registered under the `integration-gpu`
-# ctest label so a run can select or exclude them.
-option(MOBILEGL_BUILD_INTEGRATION_TEST "Build MobileGL headless GPU integration tests" OFF)
-option(MOBILEGL_FORCE_RELEASE_OPT "Enable Release optimization flags in Debug build" ON )
-option(MOBILEGL_ENABLE_TRACY      "Enable tracy for profiling"                       OFF)
-option(MOBILEGL_BUILD_TRACE_REPLAY "Build desktop apitrace replay runner"            OFF)
-option(MOBILEGL_TRACE_ANGLE_VARIANTS "Enable signed trace-APK ANGLE variant loading" OFF)
-option(MOBILEGL_IOS               "Build MobileGL for iOS instead of macOS when APPLE is set" OFF)
-set(MOBILEGL_LOG_ACTIVE_LEVEL "MOBILEGL_LOG_LEVEL_INFO" CACHE STRING "MobileGL active log level macro")
-set(MOBILEGL_VULKAN_LIBRARY "" CACHE FILEPATH "Vulkan loader/MoltenVK library to link for iOS builds")
-
-if (ANDROID)
-    set(MOBILEGL_BUILD_TEST       OFF CACHE BOOL "Build MobileGL tests"      FORCE)
-    set(MOBILEGL_BUILD_BENCHMARK  OFF CACHE BOOL "Build MobileGL benchmarks" FORCE)
-
-    # ------- Android API level policy: minimum 26, decided here and only here -------
-    # MobileGL ships against API 26: the codebase must not use any API introduced
-    # after 26. That usage constraint is enforced where it is real - the shipping
-    # gradle build compiles at minSdk 26, where a newer API is simply undeclared
-    # and fails to compile. Configuring at a HIGHER level is therefore allowed
-    # (nothing in the tree may rely on it), but a LOWER level would change the
-    # libc contract underneath the shipped library and is refused.
-    #
-    # This has to live at configure time because the level cannot be corrected
-    # from a source header. A `#define __ANDROID_API__ 26` in a common header
-    # only rewrites the macro for the bionic headers that happen to be included
-    # after it; any libc++ header pulled in earlier has already latched its
-    # feature macros at the real configure-time level. libc++ and bionic then
-    # disagree about which symbols exist - libc++ calls e.g.
-    # pthread_cond_clockwait while bionic, re-read at the lowered level, has
-    # hidden its declaration. MobileGL/Defines.h carried exactly that pin from
-    # the first commit until it was removed; this guard is what replaces it.
-    #
-    # Read the level back from the compiler target triple first. Its trailing
-    # number (aarch64-none-linux-android26) is precisely what clang turns into
-    # __ANDROID_API__, so it cannot disagree with the compile itself, and it is
-    # already past every NDK normalisation step - codename aliases, "latest",
-    # and per-ABI minimum pull-ups. ANDROID_PLATFORM_LEVEL is the fallback for
-    # generators/languages where the triple variable is not populated.
-    #
-    # Note CMAKE_SYSTEM_VERSION is deliberately NOT consulted: it holds the API
-    # level only under the NDK's newer toolchain path, and is a meaningless 1
-    # when ANDROID_USE_LEGACY_TOOLCHAIN_FILE is on (which is what AGP has been
-    # defaulting to). Reading it would fail every legacy-mode build.
-    set(MOBILEGL_ANDROID_API_LEVEL 26)
-
-    set(_mobilegl_android_api "")
-    foreach (_mobilegl_api_triple "${CMAKE_CXX_COMPILER_TARGET}"
-                                  "${CMAKE_C_COMPILER_TARGET}")
-        if (NOT _mobilegl_android_api AND
-            _mobilegl_api_triple MATCHES "-android([0-9]+)$")
-            set(_mobilegl_android_api "${CMAKE_MATCH_1}")
-        endif()
-    endforeach()
-
-    foreach (_mobilegl_api_var ANDROID_PLATFORM_LEVEL ANDROID_NATIVE_API_LEVEL
-                               ANDROID_PLATFORM)
-        if (NOT _mobilegl_android_api AND ${_mobilegl_api_var})
-            string(REGEX REPLACE "^android-" ""
-                   _mobilegl_android_api "${${_mobilegl_api_var}}")
-        endif()
-    endforeach()
-
-    if (NOT _mobilegl_android_api MATCHES "^[0-9]+$")
-        message(FATAL_ERROR
-            "MobileGL: could not determine the Android API level (got "
-            "\"${_mobilegl_android_api}\"). Configure with the NDK toolchain "
-            "file and -DANDROID_PLATFORM=android-${MOBILEGL_ANDROID_API_LEVEL}.")
-    elseif (_mobilegl_android_api LESS MOBILEGL_ANDROID_API_LEVEL)
-        message(FATAL_ERROR
-            "MobileGL requires at least Android API ${MOBILEGL_ANDROID_API_LEVEL}, "
-            "but this build resolved to API ${_mobilegl_android_api}.\n"
-            "Configure with -DANDROID_PLATFORM=android-${MOBILEGL_ANDROID_API_LEVEL} "
-            "(gradle builds get this from minSdk ${MOBILEGL_ANDROID_API_LEVEL}, so "
-            "check that minSdk instead of adding an override).")
-    elseif (_mobilegl_android_api GREATER MOBILEGL_ANDROID_API_LEVEL)
-        message(STATUS
-            "MobileGL: configuring at Android API ${_mobilegl_android_api} "
-            "(> shipping minimum ${MOBILEGL_ANDROID_API_LEVEL}). Allowed, but the "
-            "tree must not use post-${MOBILEGL_ANDROID_API_LEVEL} APIs - the "
-            "minSdk-${MOBILEGL_ANDROID_API_LEVEL} gradle build is the enforcing "
-            "compile.")
-    endif()
-
-    message(STATUS "MobileGL: Android API level ${_mobilegl_android_api}")
-
-    unset(_mobilegl_android_api)
-    unset(_mobilegl_api_var)
-    unset(_mobilegl_api_triple)
-endif()
-
-option(MOBILEGL_ENABLE_LTO "Build with ThinLTO/IPO" OFF)
-
-if ((NOT CMAKE_BUILD_TYPE STREQUAL "Debug" OR MOBILEGL_FORCE_RELEASE_OPT) AND MOBILEGL_ENABLE_LTO)
-    # Check if ThinLTO or LTO is suppported
-    include(CheckIPOSupported)
-    include(CheckCCompilerFlag)
-    include(CheckCXXCompilerFlag)
-
-    check_ipo_supported(RESULT LTOSupported OUTPUT LTOError)
-
-    check_c_compiler_flag("-flto" HAS_LTO_C)
-    check_cxx_compiler_flag("-flto" HAS_LTO_CXX)
-
-    if (LTOSupported OR (HAS_LTO_C AND HAS_LTO_CXX))
-        # Check ThinLTO
-        check_c_compiler_flag("-flto=thin" HAS_THINLTO_C)
-        check_cxx_compiler_flag("-flto=thin" HAS_THINLTO_CXX)
-        if (HAS_THINLTO_C AND HAS_THINLTO_CXX)
-            message(STATUS "ThinLTO supported, using -flto=thin")
-
-            add_compile_options(-flto=thin)
-            add_link_options(-flto=thin)
-        else()
-            # ThinLTO is not supported
-            message(STATUS "ThinLTO not available, fallback to CMAKE IPO")
-            set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
-        endif()
-    else()
-        message(STATUS "IPO not supported: ${LTOError}")
-    endif()
-
-    if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang" AND NOT MATCHES "AppleClang")
-        add_compile_options(-O3 -ffunction-sections -fdata-sections)
-        add_link_options(-Wl,--gc-sections)
-    elseif (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-#        add_compile_options(/O2)
-    else ()
-        add_compile_options(-O2)
-    endif()
-endif()
-
-if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-    add_compile_options(/Zc:preprocessor)
-    add_compile_options(/Zc:__cplusplus)
-endif()
-
 enable_language(CXX)
 
-set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD 20)
 
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w -fvisibility=hidden -funwind-tables -g -D_THREAD_SAFE -fPIC -stdlib=libc++")
 
-set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w -g -std=gnu99 -funwind-tables -O3 -fvisibility=hidden")
 
-if (MSVC)
-    set(CMAKE_CXX_FLAGS "/EHsc ${CMAKE_CXX_FLAGS}")
-endif()
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++")
 
-# Generate MGGitHash.h
-execute_process(
-    COMMAND git rev-parse HEAD
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-    OUTPUT_VARIABLE GIT_COMMIT_HASH_FULL
-    OUTPUT_STRIP_TRAILING_WHITESPACE
+set(CMAKE_ANDROID_STL_TYPE c++_static)
+
+#set(CMAKE_BUILD_TYPE Release)
+
+set(PROFILING OFF)
+
+find_library(GLSLANG_LIB glslang PATHS ${CMAKE_SOURCE_DIR}/libraries/arm64-v8a/)
+
+add_library(${CMAKE_PROJECT_NAME} SHARED 
+        MG/Init.cpp
+
+        # MG_GL/Implementations/GL
+        MG/MG_GL/Implementations/GL/GLFuncsDefinitions/GLFuncsDefinitions.cpp
+        
+        MG/MG_GL/Implementations/GL/Getter/GL_Getter.cpp
+        MG/MG_GL/Implementations/GL/Getter/BackendInfo.cpp
+
+        MG/MG_GL/Implementations/GL/Framebuffer/GL_Framebuffer.cpp
+
+        MG/MG_GL/Implementations/GL/Common/GL_Common.cpp
+
+        MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.cpp
+
+        MG/MG_GL/Implementations/GL/Drawing/GL_Drawing.cpp
+
+        MG/MG_GL/Implementations/GL/Program/GL_Program.cpp
+
+        MG/MG_GL/Implementations/GL/Texture/GL_Texture.cpp
+
+        MG/MG_GL/Implementations/GL/VertexArray/GL_VertexArray.cpp
+
+        # MG_GL/Implementations/GLX
+        MG/MG_GL/Implementations/GLX/LookUp/LookUp.cpp
+        
+        # MG_GL/Implementations/EGL
+        MG/MG_GL/Implementations/EGL/VK/EGL_EMU.cpp
+
+        MG/MG_GL/Implementations/EGL/GLES/EGL_WRAP.cpp
+        
+        # MG_GL/State
+        MG/MG_GL/State/Core/GLState.cpp
+        
+        MG/MG_GL/State/Common/CommonState.cpp
+
+        MG/MG_GL/State/Texture/TextureState.cpp
+        
+        MG/MG_GL/State/VertexArray/VertexArrayState.cpp
+        
+        MG/MG_GL/State/Buffer/BufferState.cpp
+
+        MG/MG_GL/State/Program/ShaderObject.cpp
+        MG/MG_GL/State/Program/ProgramState.cpp
+        
+        MG/MG_GL/State/Framebuffer/FramebufferState.cpp
+
+        # MG_GL/BackendLoader
+        MG/MG_GL/BackendLoader/GLES/Loader.cpp
+        
+        # MG_UTIL/Debug
+        MG/MG_UTIL/Debug/Debug.cpp
+        
+        # MG_UTIL/Program
+        MG/MG_UTIL/Program/DebugTool.cpp
+        MG/MG_UTIL/Program/GLSLTool.cpp
+        
+        # MG_RHI/GLES
+        MG/MG_RHI/GLES/Test/TestDrawing.cpp
 )
 
-string(SUBSTRING "${GIT_COMMIT_HASH_FULL}" 0 7 GIT_COMMIT_HASH_SHORT)
-
-configure_file(
-    ${CMAKE_SOURCE_DIR}/MobileGL/MG_Util/Miscellany/MGGitHash.h.in
-    ${CMAKE_BINARY_DIR}/generated/MGGitHash.h
-    @ONLY
-)
-
-include_directories(${CMAKE_BINARY_DIR}/generated)
-
-set(ENABLE_RTTI                ON  CACHE BOOL "Enables RTTI (will be took by glslang)" FORCE)
-
-set(ENABLE_GLSLANG_BINARIES    OFF CACHE BOOL "Enable glslangValidator/spirv-remap" FORCE)
-set(ENABLE_SPVREMAPPER         OFF CACHE BOOL "Enable SPVRemapper" FORCE)
-set(ENABLE_OPT                 ON  CACHE BOOL "Enable SPIRV-Tools opt usage in glslang" FORCE)
-set(BUILD_EXTERNAL             ON  CACHE BOOL "Build external deps in External/" FORCE)
-set(ENABLE_GLSLANG_INSTALL     OFF CACHE BOOL "Install glslang targets" FORCE)
-set(SPIRV_SKIP_EXECUTABLES     ON  CACHE BOOL "Skip building SPIRV-Tools executables" FORCE)
-
-set(SPIRV_CROSS_C_API          ON  CACHE BOOL "Enable C API" FORCE)
-set(SPIRV_CROSS_ENABLE_GLSL    ON  CACHE BOOL "Enable GLSL backend" FORCE)
-set(SPIRV_CROSS_ENABLE_HLSL    OFF CACHE BOOL "Disable HLSL backend" FORCE)
-set(SPIRV_CROSS_ENABLE_MSL     OFF CACHE BOOL "Disable MSL backend" FORCE)
-set(SPIRV_CROSS_ENABLE_CPP     OFF CACHE BOOL "Disable C++ API target" FORCE)
-set(SPIRV_CROSS_CLI            OFF CACHE BOOL "Disable CLI binary" FORCE)
-set(SPIRV_CROSS_STATIC         ON  CACHE BOOL "Prefer static libs" FORCE)
-
-set(SPIRV_REFLECT_EXECUTABLE     OFF CACHE BOOL "Build spirv-reflect executable" FORCE)
-set(SPIRV_REFLECT_STATIC_LIB     ON  CACHE BOOL "Build a SPIRV-Reflect static library" FORCE)
-set(SPIRV_REFLECT_BUILD_TESTS    OFF CACHE BOOL "Build the SPIRV-Reflect test suite" FORCE)
-set(SPIRV_REFLECT_ENABLE_ASSERTS OFF CACHE BOOL  "Enable asserts for debugging" FORCE)
-set(SPIRV_REFLECT_ENABLE_ASAN    OFF CACHE BOOL "Use address sanitization" FORCE)
-set(SPIRV_REFLECT_INSTALL        OFF CACHE BOOL "Whether to install" FORCE)
-
-# add_subdirectory(3rdparty/DiligentCore)
-add_subdirectory(3rdparty/glslang)
-add_subdirectory(3rdparty/SPIRV-Cross)
-add_subdirectory(3rdparty/VulkanMemoryAllocator)
-add_subdirectory(3rdparty/Vulkan-Headers)
-add_subdirectory(3rdparty/Vulkan-Utility-Libraries)
-add_subdirectory(3rdparty/SPIRV-Reflect)
-
-set(XXHASH_BUILD_XXHSUM OFF)
-option(BUILD_SHARED_LIBS OFF)
-add_subdirectory(3rdparty/xxHash/build/cmake xxhash_build EXCLUDE_FROM_ALL)
-
-set(TRACY_ENABLE ${MOBILEGL_ENABLE_TRACY} CACHE BOOL "Enable Tracy, this is an internal variable" FORCE)
-
-if (TRACY_ENABLE)
-    set(TRACY_ON_DEMAND            ON  CACHE BOOL "Enable profiling only connected" FORCE)
-    set(TRACY_NO_EXIT              OFF CACHE BOOL "Don't exit Tracy until connected" FORCE)
-    set(TRACY_DELAYED_INIT         ON  CACHE BOOL "Don't init Tracy on library load" FORCE)
-    set(TRACY_MANUAL_LIFETIME      ON  CACHE BOOL "Manually control Tracy lifetime" FORCE)
-    set(TRACY_NO_CRASH_HANDLER     ON  CACHE BOOL "Disable crash handling" FORCE)
-
-    add_subdirectory(3rdparty/tracy)
-endif ()
-
-set(SOURCE_FILES
-    MobileGL/Init.cpp
-    MobileGL/GlobalObjects.cpp
-    MobileGL/ConfigLoader.cpp
-
-    MobileGL/MG_Util/Debug/Log.cpp
-
-    MobileGL/MG_Util/Async/JobNode.cpp
-    MobileGL/MG_Util/Async/ShaderCompilePool.cpp
-
-    MobileGL/MG_Util/Math/VectorTypes.cpp
-    MobileGL/MG_Util/Metrics/TextureMetrics.cpp
-
-    MobileGL/MG_Util/Metrics/BufferMetrics.cpp
-
-    MobileGL/MG_Util/Converters/GLToStr/GLEnumConverter.cpp
-    MobileGL/MG_Util/Converters/EGLToStr/EGLEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToStr/DataTypeConverter.cpp
-    MobileGL/MG_Util/Converters/MGToStr/RenderStateEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToStr/GLExtensionConverter.cpp
-    MobileGL/MG_Util/Converters/MGToStr/BufferEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToStr/FramebufferEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToStr/TextureEnumConverter.cpp
-    MobileGL/MG_Util/Converters/GLToGlslang/ProgramEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToGL/ErrorCodeConverter.cpp
-    MobileGL/MG_Util/Converters/MGToGL/BufferEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToGL/FramebufferEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToGL/TextureEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToGL/DataTypeConverter.cpp
-    MobileGL/MG_Util/Converters/MGToGL/RenderStateEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToGL/ProgramEnumConverter.cpp
-    MobileGL/MG_Util/Converters/GLToMG/BufferEnumConverter.cpp
-    MobileGL/MG_Util/Converters/GLToMG/FramebufferEnumConverter.cpp
-    MobileGL/MG_Util/Converters/GLToMG/TextureEnumConverter.cpp
-    MobileGL/MG_Util/Converters/GLToMG/DataTypeConverter.cpp
-    MobileGL/MG_Util/Converters/GLToMG/RenderStateEnumConverter.cpp
-    MobileGL/MG_Util/Converters/GLToMG/ProgramEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToMG/TextureEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToVk/RenderStateEnumConverter.cpp
-    MobileGL/MG_Util/Converters/MGToVk/TextureEnumConverter.cpp
-
-    MobileGL/MG_Util/Classifiers/TextureEnumClassifier.cpp
-
-    MobileGL/MG_Util/ShaderTranspiler/CompileEnv.cpp
-    MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpvcSession.cpp
-    MobileGL/MG_Util/ShaderTranspiler/ShaderSourceProcessor.cpp
-    MobileGL/MG_Util/ShaderTranspiler/TranslationCache.cpp
-    MobileGL/MG_Util/ShaderTranspiler/glslang/TMglGlslIoResolver.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FlattenInterfaceStructPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EliminateFloatEqualsZeroPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RenameSamplerFunctionParameterPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RenameBuiltinShadowingFunctionsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecomposeWorkgroupVec3Pass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DecoratePositionInvariantPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemoteFloat64Pass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FlattenFloat64StorageBlockPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerDrawParametersPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LowerViewportIndexPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/PackDoubleVertexInputsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FlattenXfbInterfaceBlocksPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/UniquifyIoBlockNamesPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripIoBlockLocationsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/SplitArrayVertexInputsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/RebaseInstanceIndexPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/ZeroBaseVertexPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DeriveNumSubgroupsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FixIterationRPBarrierPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FixIterationRPSubgroupScratchPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EmulateSubgroupsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/NormalizeRectCoordinatesPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/Lower1DArrayImagesPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/Lower1DSampledImagesPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/BakeImageFormatsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/WidenImageFormatsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/ClampMultisampleFetchPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/PrivateToEntryLocalPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripUniformLocationsPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripUboMemberRelaxedPrecisionPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/StripNoPerspectivePass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/EmulateNoPerspectivePass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LegalizeFragmentOutputIndexPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/LegalizeResourceArrayIndexPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/FlattenAtomicCounterBlockPass.cpp
-    MobileGL/MG_Util/ShaderTranspiler/SpirvPasses/DemotePointSizePass.cpp
-
-    MobileGL/MG_Util/BackendLoaders/OpenGL/Loader.cpp
-    MobileGL/MG_Util/BackendLoaders/Vulkan/Loader.cpp
-
-    MobileGL/MG_Util/SelfTest/DriverBugProbes.cpp
-    MobileGL/MG_Util/SelfTest/PersistentBufferOrderingProbe.cpp
-    MobileGL/MG_Util/SelfTest/DriverPost.cpp
-    MobileGL/MG_Util/SelfTest/DriverPostIterationRPWitness.cpp
-    MobileGL/MG_Util/SelfTest/PrimitivesGeneratedNoXfbProbe.cpp
-
-    MobileGL/MG_Util/Texture/PixelStoreProcessor.cpp
-    MobileGL/MG_Util/Texture/TextureFormatProcessor.cpp
-
-    MobileGL/MG_Impl/GLXImpl/Exporting/Definitions.cpp
-    MobileGL/MG_Impl/GLXImpl/GLXImpl.cpp
-    MobileGL/MG_Impl/GLXImpl/LookUp/LookUp.cpp
-
-    MobileGL/MG_Impl/EGLImpl/Exporting/Definitions.cpp
-    MobileGL/MG_Impl/EGLImpl/EGLImpl.cpp
-    
-    # @INSERTION_POINT:SOURCE_FILE_GLIMPL@ #
-    MobileGL/MG_Impl/GLImpl/Sampler/Validators.cpp
-    MobileGL/MG_Impl/GLImpl/Sampler/GL_Sampler.cpp
-    MobileGL/MG_Impl/GLImpl/Drawing/GL_Drawing.cpp
-    MobileGL/MG_Impl/GLImpl/RenderState/GL_RenderState.cpp
-    MobileGL/MG_Impl/GLImpl/Framebuffer/Validators.cpp
-    MobileGL/MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.cpp
-    MobileGL/MG_Impl/GLImpl/Program/GL_Program.cpp
-    MobileGL/MG_Impl/GLImpl/Program/ProgramInterface.cpp
-    MobileGL/MG_Impl/GLImpl/Program/GL_ProgramPipeline.cpp
-    MobileGL/MG_Impl/GLImpl/Texture/GL_Texture.cpp
-    MobileGL/MG_Impl/GLImpl/Debug/GL_Debug.cpp
-    MobileGL/MG_Impl/GLImpl/Texture/Validators.cpp
-    MobileGL/MG_Impl/GLImpl/Texture/ProxyTexture.cpp
-    MobileGL/MG_Impl/GLImpl/VertexArray/GL_VertexArray.cpp
-    MobileGL/MG_Impl/GLImpl/VertexArray/Validators.cpp
-    MobileGL/MG_Impl/GLImpl/Buffer/GL_Buffer.cpp
-    MobileGL/MG_Impl/GLImpl/Buffer/Validators.cpp
-    MobileGL/MG_Impl/GLImpl/Exporting/Definitions.cpp
-    MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.cpp
-    MobileGL/MG_Impl/GLImpl/Sync/GL_Sync.cpp
-    MobileGL/MG_Impl/GLImpl/Query/GL_Query.cpp
-
-    MobileGL/MG_Impl/Init.cpp
-    MobileGL/MG_Impl/GetProcAddress.cpp
-
-    MobileGL/MG_Backend/Init.cpp
-    MobileGL/MG_Backend/BackendObject.cpp
-
-    MobileGL/MG_Backend/DirectGLES/DirectGLES.cpp
-    MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp
-    MobileGL/MG_Backend/DirectGLES/Utils.cpp
-    MobileGL/MG_Backend/DirectGLES/Managers.cpp
-    MobileGL/MG_Backend/DirectGLES/MultiDraw.cpp
-
-    MobileGL/MG_Backend/DirectVulkan/DirectVulkan.cpp
-    MobileGL/MG_Backend/DirectVulkan/BackendObject_DirectVulkan.cpp
-    MobileGL/MG_Backend/DirectVulkan/VmaImpl.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/VulkanRenderer.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/SwapchainObject.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/FrameContext.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/PipelineFactory.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/ProgramFactory.cpp
-        MobileGL/MG_Backend/DirectVulkan/Renderer/UniformManager.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/BufferArena.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferManager.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateBuilder.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/VertexInputStateFactory.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/VkBufferObject.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/VkTextureManager.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/VkTimerQueryManager.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/VkSamplerManager.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/VkClearManager.cpp
-    MobileGL/MG_Backend/DirectVulkan/Renderer/VkRenderPassManager.cpp
-
-    MobileGL/MG_State/GLState/Core.cpp
-    MobileGL/MG_State/EGLState/Core.cpp
-    MobileGL/MG_State/GLState/ErrorState/Error.cpp
-    MobileGL/MG_State/GLState/BufferState/BufferState.cpp
-    MobileGL/MG_State/GLState/BufferState/BufferObject.cpp
-    MobileGL/MG_State/GLState/VertexArrayState/VertexArrayState.cpp
-    MobileGL/MG_State/GLState/VertexArrayState/VertexArrayObject.cpp
-    MobileGL/MG_State/GLState/TextureState/MipmapStorage.cpp
-    MobileGL/MG_State/GLState/TextureState/TextureObject.cpp
-    MobileGL/MG_State/GLState/TextureState/TextureObject1D.cpp
-    MobileGL/MG_State/GLState/TextureState/TextureObject2D.cpp
-    MobileGL/MG_State/GLState/TextureState/TextureObject2DCube.cpp
-    MobileGL/MG_State/GLState/TextureState/TextureObject3D.cpp
-    MobileGL/MG_State/GLState/TextureState/TextureObjectBuffer.cpp
-    MobileGL/MG_State/GLState/TextureState/TextureObjectView.cpp
-    MobileGL/MG_State/GLState/TextureState/TextureUnit.cpp
-    MobileGL/MG_State/GLState/TextureState/TextureState.cpp
-    MobileGL/MG_State/GLState/ProgramState/ProgramObject.cpp
-    MobileGL/MG_State/GLState/ProgramState/ProgramLinkTask.cpp
-    MobileGL/MG_State/GLState/ProgramState/ProgramTranslationCache.cpp
-    MobileGL/MG_State/GLState/ProgramState/ProgramSpirvTask.cpp
-    MobileGL/MG_State/GLState/ProgramState/ShaderCompileTask.cpp
-    MobileGL/MG_State/GLState/ProgramState/ShaderObject.cpp
-    MobileGL/MG_State/GLState/ProgramState/ShaderPreprocessCache.cpp
-    MobileGL/MG_State/GLState/ProgramState/ShaderCompileAdoptionMap.cpp
-    MobileGL/MG_State/GLState/ProgramState/ProgramState.cpp
-    MobileGL/MG_State/GLState/RenderState/RenderState.cpp
-    MobileGL/MG_State/GLState/FramebufferState/FramebufferObject.cpp
-    MobileGL/MG_State/GLState/FramebufferState/FramebufferState.cpp
-    MobileGL/MG_State/GLState/SamplerState/SamplerObject.cpp
-    MobileGL/MG_State/GLState/SamplerState/SamplerState.cpp
-    MobileGL/MG_State/GLState/RenderbufferState/RenderbufferObject.cpp
-    MobileGL/MG_State/GLState/RenderbufferState/RenderbufferState.cpp
-)
-
-if (APPLE AND NOT MOBILEGL_IOS)
-    list(APPEND SOURCE_FILES
-        MobileGL/MG_Impl/CGLImpl/CGLImpl.cpp
-        MobileGL/MG_Impl/CGLImpl/Exporting/Definitions.cpp
-        MobileGL/MG_Impl/DyldInterpose/DyldInterpose.cpp
-        MobileGL/MG_Impl/NSOpenGLImpl/NSOpenGLImpl.cpp
-    )
-endif()
-
-if (ANDROID)
-    list(APPEND SOURCE_FILES
-        MobileGL/MG_Util/SelfTest/DriverPostJni.cpp
-        MobileGL/MG_Util/SelfTest/DriverBenchJni.cpp
-    )
-endif()
-
-if (WIN32)
-    list(APPEND SOURCE_FILES
-        MobileGL/MG_Impl/WGLImpl/WGLImpl.cpp
-        MobileGL/MG_Impl/WGLImpl/Exporting/Definitions.cpp
-    )
-endif()
-
-# The shader-compile pool runs standalone Asio on real threads. This host's glibc (>= 2.34)
-# merged pthread into libc, so it links without asking, but the NDK and musl are not
-# guaranteed to be as forgiving - ask for it explicitly rather than rely on the accident.
-find_package(Threads REQUIRED)
-
-set(MOBILEGL_LINK_LIBRARIES
-        glslang::glslang
-        spirv-cross-c
-        SPIRV-Tools-opt
-        SPIRV-Tools
-        xxHash::xxhash
-        GPUOpen::VulkanMemoryAllocator
-        Vulkan::UtilityHeaders
-        spirv-reflect-static
-        Threads::Threads
-)
-
-set(MOBILEGL_COMPILE_DEF
-        -DVMA_STATIC_VULKAN_FUNCTIONS=0
-        -DVMA_DYNAMIC_VULKAN_FUNCTIONS=1
-        -DVMA_VULKAN_VERSION=1001000
-        # Header-only Asio, no Boost, no deprecated interfaces. Set on the definition list
-        # rather than per-target so the shared library and the _s static target agree.
-        -DASIO_STANDALONE
-        -DASIO_NO_DEPRECATED
-)
-
-message(STATUS "MOBILEGL_COMPILE_DEF=${MOBILEGL_COMPILE_DEF}")
-
-set(MOBILEGL_INCLUDE_DIR
-        ${CMAKE_SOURCE_DIR}/include
-        ${CMAKE_SOURCE_DIR}/MobileGL
-        ${spirv-tools_SOURCE_DIR}
-        ${spirv-tools_SOURCE_DIR}/include
-        ${spirv-tools_BINARY_DIR}
-        ${SPIRV-Headers_SOURCE_DIR}/include
-        # Header-only submodule: no add_subdirectory, no link target. Only
-        # MG_Util/Async/ShaderCompilePool.cpp includes it, and it stays behind that file's
-        # pimpl so no consumer target needs this path.
-        ${CMAKE_SOURCE_DIR}/3rdparty/asio/include
-)
-
-add_library(${CMAKE_PROJECT_NAME} SHARED
-    ${SOURCE_FILES}
-)
-
-if (WIN32)
-    # The wgl* entry points are exported via .def (see the comment in wgl.def);
-    # only the shared library links it.
-    target_sources(${CMAKE_PROJECT_NAME} PRIVATE
-        MobileGL/MG_Impl/WGLImpl/Exporting/wgl.def
-    )
-endif()
-
-if (CMAKE_BUILD_TYPE STREQUAL "Debug")
-    set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES
-        C_VISIBILITY_PRESET default
-        CXX_VISIBILITY_PRESET default
-        VISIBILITY_INLINES_HIDDEN OFF
-    )
-else()
-    set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES
-        C_VISIBILITY_PRESET hidden
-        CXX_VISIBILITY_PRESET hidden
-        VISIBILITY_INLINES_HIDDEN ON
-    )
-endif()
-
-target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC
-    ${MOBILEGL_INCLUDE_DIR}
-)
+target_include_directories(${CMAKE_PROJECT_NAME} PRIVATE ./includes)
 
 target_link_libraries(${CMAKE_PROJECT_NAME}
-    PUBLIC
-    ${MOBILEGL_LINK_LIBRARIES}
-)
-
-target_compile_definitions(${CMAKE_PROJECT_NAME}
-        PUBLIC
-        ${MOBILEGL_COMPILE_DEF}
-        MOBILEGL_LOG_ACTIVE_LEVEL=${MOBILEGL_LOG_ACTIVE_LEVEL}
-        $<$<BOOL:${MOBILEGL_TRACE_ANGLE_VARIANTS}>:MOBILEGL_TRACE_ANGLE_VARIANTS=1>
-)
-
-if(UNIX AND NOT APPLE AND NOT ANDROID)
-    foreach(MOBILEGL_LOADER_ALIAS
-            libEGL.so libEGL.so.1)
-        add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
-            COMMAND ${CMAKE_COMMAND} -E create_symlink
-                    "$<TARGET_FILE_NAME:${CMAKE_PROJECT_NAME}>"
-                    "$<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>/${MOBILEGL_LOADER_ALIAS}"
-            COMMENT "Creating ${MOBILEGL_LOADER_ALIAS} alias for Linux GL/EGL loaders"
-        )
-    endforeach()
-endif()
-
-if(WIN32)
-    # Drop-in for the classic GL loader path: a copy named opengl32.dll placed
-    # next to a host executable is what LoadLibrary("opengl32.dll") and gdi32's
-    # pixel-format forwarding will resolve.
-    add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                "$<TARGET_FILE:${CMAKE_PROJECT_NAME}>"
-                "$<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>/opengl32.dll"
-        COMMENT "Creating opengl32.dll drop-in copy"
-    )
-endif()
-
-if(NOT ANDROID)
-    add_library(${CMAKE_PROJECT_NAME}_s STATIC 
-        ${SOURCE_FILES}
-    )
-
-    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
-        set_target_properties(${CMAKE_PROJECT_NAME}_s PROPERTIES
-            C_VISIBILITY_PRESET default
-            CXX_VISIBILITY_PRESET default
-            VISIBILITY_INLINES_HIDDEN OFF
-        )
-    else()
-        set_target_properties(${CMAKE_PROJECT_NAME}_s PROPERTIES
-            C_VISIBILITY_PRESET hidden
-            CXX_VISIBILITY_PRESET hidden
-            VISIBILITY_INLINES_HIDDEN ON
-        )
-    endif()
-
-    target_include_directories(${CMAKE_PROJECT_NAME}_s PUBLIC
-        ${MOBILEGL_INCLUDE_DIR}
-    )
-
-    target_link_libraries(${CMAKE_PROJECT_NAME}_s
-        PUBLIC
-        ${MOBILEGL_LINK_LIBRARIES}
-    )
-
-    target_compile_definitions(${CMAKE_PROJECT_NAME}_s
-            PUBLIC
-            ${MOBILEGL_COMPILE_DEF}
-            MOBILEGL_LOG_ACTIVE_LEVEL=${MOBILEGL_LOG_ACTIVE_LEVEL}
-    )
-endif()
-
-if (TRACY_ENABLE)
-    target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC Tracy::TracyClient)
-    target_link_libraries(${CMAKE_PROJECT_NAME}_s PUBLIC Tracy::TracyClient)
-    target_compile_definitions(${CMAKE_PROJECT_NAME} PUBLIC -DTRACY_ENABLE)
-    target_compile_definitions(${CMAKE_PROJECT_NAME}_s PUBLIC -DTRACY_ENABLE)
-endif ()
-
-if (ANDROID)
-    target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libglslang.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libspirv-cross-c-shared.so
+        #${CMAKE_SOURCE_DIR}/library/arm64-v8a/libshaderconv.so
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libGenericCodeGen.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libglslang-default-resource-limits.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libMachineIndependent.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libOSDependent.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libSPIRV-Tools-diff.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libSPIRV-Tools-link.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libSPIRV-Tools-lint.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libSPIRV-Tools-opt.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libSPIRV-Tools-reduce.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libSPIRV-Tools.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libSPIRV.a
+        ${CMAKE_SOURCE_DIR}/library/arm64-v8a/libSPVRemapper.a
         android
         log
+        EGL
         vulkan
-    )
-endif()
+)
 
-if (APPLE AND NOT MOBILEGL_IOS)
-    # MobileGL statically embeds glslang, SPIRV-Tools, and SPIRV-Cross. When
-    # this dylib is injected with DYLD_INSERT_LIBRARIES, exporting those C++
-    # symbols interposes incompatible copies embedded by host libraries such
-    # as shaderc. Keep only the public GL/EGL/CGL loader surface globally
-    # visible; GetProcAddress can still return pointers to hidden internals.
-    set(MOBILEGL_MACOS_EXPORTED_SYMBOLS
-        "${CMAKE_CURRENT_SOURCE_DIR}/MobileGL/MG_Impl/DyldInterpose/ExportedSymbols.txt")
-    target_link_options(${CMAKE_PROJECT_NAME} PRIVATE
-        "LINKER:-exported_symbols_list,${MOBILEGL_MACOS_EXPORTED_SYMBOLS}")
-    set_property(TARGET ${CMAKE_PROJECT_NAME} APPEND PROPERTY
-        LINK_DEPENDS "${MOBILEGL_MACOS_EXPORTED_SYMBOLS}")
+target_include_directories(MobileGL PUBLIC
+        ${CMAKE_SOURCE_DIR}/include
+        )
 
-    target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC
-        "-framework Cocoa"
-        "-framework CoreVideo"
-        "-framework QuartzCore"
-        "-framework Foundation"
-        "-framework OpenGL"
-        objc)
-    if(TARGET ${CMAKE_PROJECT_NAME}_s)
-        target_link_libraries(${CMAKE_PROJECT_NAME}_s PUBLIC
-            "-framework Cocoa"
-            "-framework CoreVideo"
-            "-framework QuartzCore"
-            "-framework Foundation"
-            "-framework OpenGL"
-            objc)
-    endif()
-endif()
 
-if (APPLE AND MOBILEGL_IOS)
-    target_compile_definitions(${CMAKE_PROJECT_NAME} PUBLIC MOBILEGL_IOS=1 _LIBCPP_DISABLE_AVAILABILITY)
-    target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC
-        "-framework CoreGraphics"
-        "-framework Foundation"
-        "-framework QuartzCore"
-        objc)
-    if (MOBILEGL_VULKAN_LIBRARY)
-        target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC "${MOBILEGL_VULKAN_LIBRARY}")
-    endif()
-
-    if(TARGET ${CMAKE_PROJECT_NAME}_s)
-        target_compile_definitions(${CMAKE_PROJECT_NAME}_s PUBLIC MOBILEGL_IOS=1 _LIBCPP_DISABLE_AVAILABILITY)
-        target_link_libraries(${CMAKE_PROJECT_NAME}_s PUBLIC
-            "-framework CoreGraphics"
-            "-framework Foundation"
-            "-framework QuartzCore"
-            objc)
-        if (MOBILEGL_VULKAN_LIBRARY)
-            target_link_libraries(${CMAKE_PROJECT_NAME}_s PUBLIC "${MOBILEGL_VULKAN_LIBRARY}")
-        endif()
-    endif()
-endif()
-
-if (NOT ANDROID AND NOT MOBILEGL_IOS)
-    find_package(Vulkan)
-    if (Vulkan_FOUND)
-        target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC Vulkan::Vulkan Vulkan::Headers)
-        target_link_libraries(${CMAKE_PROJECT_NAME}_s PUBLIC Vulkan::Vulkan Vulkan::Headers)
-        target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC ${Vulkan_INCLUDE_DIR})
-        target_include_directories(${CMAKE_PROJECT_NAME}_s PUBLIC ${Vulkan_INCLUDE_DIR})
-    endif ()
-endif ()
-
-if (NOT ANDROID)
-    # Enable testing in the top-level scope so a CTestTestfile.cmake is emitted
-    # at the build-tree root. This lets `ctest` be invoked from the top-level
-    # build directory (IDE "run all tests", CI) and discover every test in the
-    # subdirectories below, instead of having to descend into each
-    # MG_Test/MG_Benchmark subdirectory. Tests are tagged with CTest labels
-    # (unit / benchmark / integration), so e.g. `ctest -L unit` selects just
-    # the unit suite.
-    enable_testing()
-
-    if (MOBILEGL_BUILD_TEST)
-        add_subdirectory(MobileGL/MG_Test)
-    endif()
-
-    # After MG_Test so googletest is already available when the unit tests are
-    # built; the module fetches its own copy when they are not.
-    if (MOBILEGL_BUILD_INTEGRATION_TEST)
-        add_subdirectory(MobileGL/MG_IntegrationTest)
-    endif()
-
-    if (MOBILEGL_BUILD_BENCHMARK)
-        add_subdirectory(MobileGL/MG_Benchmark)
-    endif()
-
-    if (MOBILEGL_BUILD_TRACE_REPLAY)
-        add_subdirectory(tools/trace_replay)
-    endif()
-endif()
-
-# The integration binary is also useful as a standalone adb-shell executable.
-# Android cannot use the desktop-only MobileGL_s target, so its CMake module
-# links libMobileGL.so and creates an AImageReader-backed window instead.
-if (ANDROID AND MOBILEGL_BUILD_INTEGRATION_TEST)
-    add_subdirectory(MobileGL/MG_IntegrationTest)
+if (PROFILING)
+        find_package(Threads)
+        include_directories(${CMAKE_SOURCE_DIR}/3rdparty/perfetto/sdk)
+        add_library(perfetto STATIC ${CMAKE_SOURCE_DIR}/3rdparty/perfetto/sdk/perfetto.cc)
+        target_link_libraries(MobileGL perfetto ${CMAKE_THREAD_LIBS_INIT})
+        target_compile_definitions(MobileGL PUBLIC PROFILING=1)
 endif()

COPYING

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

COPYING.LESSER

@@ -1,165 +0,0 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.

LICENSE

@@ -1,4 +1,458 @@
-Copyright (c) 2025-2026 MobileGL-Dev
+Copyright (c) 2025 MobileGL-Dev
 
-This project is licensed under the GNU Lesser General Public License v3.0.
-See COPYING and COPYING.LESSER for the full text of the LGPLv3 license.
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.

MG/Constants.h

@@ -0,0 +1,185 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_CONSTANTS_H
+#define MOBILEGL_CONSTANTS_H
+
+#include <array>
+#include <unordered_map>
+#include <unordered_set>
+#include <GL/gl.h>
+#include <ankerl/unordered_dense.h>
+
+#ifdef __ANDROID__
+#define __ANDROID_API__ 26
+#endif
+
+#ifdef _WIN32
+#define MG_EXPORT extern "C" __declspec(dllexport)
+#else
+#define MG_EXPORT extern "C" __attribute__((visibility("default")))
+#endif
+
+namespace ankerl {
+    template <typename K, typename V>
+    using unordered_map = ankerl::unordered_dense::map<K, V>;
+    
+    template <typename T>
+    using unordered_set = ankerl::unordered_dense::set<T>;
+}
+
+namespace MG_Constants {
+    namespace Common {
+        inline const int LOG_LEVEL_DEBUG = 0x0010;
+        inline const int LOG_LEVEL_WARN = 0x0011;
+        inline const int LOG_LEVEL_ERROR = 0x0012;
+        inline const int LOG_LEVEL_INFO = 0x0013;
+        inline const int LOG_LEVEL_FATAL = 0x0014;
+    }
+    
+    namespace Blend {
+        static const ankerl::unordered_set<GLenum> VALID_FACTORS = {
+                GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR,
+                GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
+                GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR,
+                GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA, GL_SRC_ALPHA_SATURATE
+        }; // OpenGL 3
+    }
+    
+    namespace Depth {
+        static const ankerl::unordered_set<GLenum> VALID_FUNCS = {
+                GL_NEVER, GL_LESS, GL_EQUAL, GL_LEQUAL, GL_GREATER, GL_NOTEQUAL, GL_GEQUAL, GL_ALWAYS
+        }; // OpenGL 3
+    }
+    
+    namespace CommonState {
+        static const ankerl::unordered_set<GLenum> VALID_CAPS = {
+                GL_BLEND, GL_DEPTH_TEST, GL_STENCIL_TEST, GL_SCISSOR_TEST, GL_CULL_FACE,
+                GL_POLYGON_OFFSET_FILL, GL_SAMPLE_ALPHA_TO_COVERAGE, GL_SAMPLE_COVERAGE
+        }; // OpenGL 3
+    }
+    
+    namespace Framebuffer {
+        static const ankerl::unordered_set<GLenum> VALID_ATTACHMENTS = {
+                GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT,
+                GL_STENCIL_ATTACHMENT, GL_DEPTH_STENCIL_ATTACHMENT
+        }; // OpenGL 3
+        
+        static const ankerl::unordered_set<GLenum> VALID_TARGETS = {
+                GL_FRAMEBUFFER, GL_DRAW_FRAMEBUFFER, GL_READ_FRAMEBUFFER
+        }; // OpenGL 3
+        
+        static const ankerl::unordered_set<GLenum> VALID_ACCESS = {
+                GL_READ_ONLY, GL_WRITE_ONLY, GL_READ_WRITE
+        }; // OpenGL 3
+    }
+    
+    namespace Buffer {
+        static const ankerl::unordered_set<GLenum> VALID_PARAM_NAMES = {
+                GL_BUFFER_ACCESS, GL_BUFFER_MAPPED, GL_BUFFER_SIZE, GL_BUFFER_USAGE
+        }; // OpenGL 3
+        
+        static const ankerl::unordered_set<GLenum> VALID_TARGETS = { 
+                GL_ARRAY_BUFFER, GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, GL_ELEMENT_ARRAY_BUFFER,
+                GL_PIXEL_PACK_BUFFER, GL_PIXEL_UNPACK_BUFFER, GL_TEXTURE_BUFFER,
+                GL_TRANSFORM_FEEDBACK_BUFFER,  GL_UNIFORM_BUFFER
+        }; // OpenGL 3
+        
+        static const ankerl::unordered_set<GLenum> VALID_ACCESS = {
+                GL_READ_ONLY, GL_WRITE_ONLY, GL_READ_WRITE
+        }; // OpenGL 3
+    }
+
+    namespace PixelStore {
+        static const ankerl::unordered_map<GLenum, GLint> DEFAULT_VALUES_MAP = {
+                {GL_PACK_SWAP_BYTES,   GL_FALSE},
+                {GL_PACK_LSB_FIRST,    GL_FALSE},
+                {GL_PACK_ROW_LENGTH,   0},
+                {GL_PACK_IMAGE_HEIGHT, 0},
+                {GL_PACK_SKIP_ROWS,    0},
+                {GL_PACK_SKIP_PIXELS,  0},
+                {GL_PACK_SKIP_IMAGES,  0},
+                {GL_PACK_ALIGNMENT,    4},
+                {GL_UNPACK_SWAP_BYTES, GL_FALSE},
+                {GL_UNPACK_LSB_FIRST,  GL_FALSE},
+                {GL_UNPACK_ROW_LENGTH, 0},
+                {GL_UNPACK_IMAGE_HEIGHT, 0},
+                {GL_UNPACK_SKIP_ROWS,  0},
+                {GL_UNPACK_SKIP_PIXELS,0},
+                {GL_UNPACK_SKIP_IMAGES,0},
+                {GL_UNPACK_ALIGNMENT,  4}
+        }; // OpenGL 3
+        
+        static const ankerl::unordered_set<GLenum> VALID_PARAM_NAMES = {
+                GL_PACK_SWAP_BYTES, GL_PACK_LSB_FIRST, GL_PACK_ROW_LENGTH, GL_PACK_IMAGE_HEIGHT,
+                GL_PACK_SKIP_ROWS, GL_PACK_SKIP_PIXELS, GL_PACK_SKIP_IMAGES, GL_PACK_ALIGNMENT,
+                GL_UNPACK_SWAP_BYTES, GL_UNPACK_LSB_FIRST, GL_UNPACK_ROW_LENGTH,
+                GL_UNPACK_IMAGE_HEIGHT,
+                GL_UNPACK_SKIP_ROWS, GL_UNPACK_SKIP_PIXELS, GL_UNPACK_SKIP_IMAGES,
+                GL_UNPACK_ALIGNMENT
+        }; // OpenGL 3
+    }
+    
+    namespace Texture {
+        inline const GLuint MAX_TEXTURE_UNITS = 80;
+        const GLsizei MAX_TEXTURE_SIZE = 32768;
+        const GLsizei MAX_ARRAY_LAYERS = 256;
+        inline const ankerl::unordered_set<GLenum> VALID_TARGETS = {
+                GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_1D_ARRAY, GL_PROXY_TEXTURE_1D_ARRAY,
+                GL_TEXTURE_RECTANGLE, GL_PROXY_TEXTURE_RECTANGLE, GL_TEXTURE_CUBE_MAP_POSITIVE_X,
+                GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 
+                GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GL_PROXY_TEXTURE_CUBE_MAP
+        }; // OpenGL 3
+
+        inline const ankerl::unordered_set<GLenum> VALID_FORMATS = {
+                GL_RED, GL_RG, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL
+        }; // OpenGL 3
+
+        inline const ankerl::unordered_set<GLenum> VALID_INTERNAL_FORMATS = {
+                GL_RED, GL_RG, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL,
+                GL_RGBA32F, GL_RGBA32I, GL_RGBA32UI, GL_RGBA16, GL_RGBA16F, GL_RGBA16I, 
+                GL_RGBA16UI, GL_RGBA8, GL_RGBA8UI, GL_SRGB8_ALPHA8, GL_RGB10_A2, GL_RGB10_A2UI, 
+                GL_R11F_G11F_B10F, GL_RG32F, GL_RG32I, GL_RG32UI, GL_RG16, GL_RG16F, GL_RGB16I,
+                GL_RGB16UI, GL_RG8, GL_RG8I, GL_RG8UI, GL_R32F, GL_R32I, GL_R32UI, GL_R16F, 
+                GL_R16I, GL_R16UI, GL_R8, GL_R8I, GL_R8UI, GL_RGBA16_SNORM, GL_RGBA8_SNORM, 
+                GL_RGB32F, GL_RGB32I, GL_RGB32UI, GL_RGB16_SNORM, GL_RGB16F, GL_RGB16I, GL_RGB16UI,
+                GL_RGB16, GL_RGB8_SNORM, GL_RGB8, GL_RGB8I, GL_RGB8UI, GL_SRGB8, GL_RGB9_E5, 
+                GL_RG16_SNORM, GL_RG8_SNORM, GL_COMPRESSED_RG_RGTC2, GL_COMPRESSED_SIGNED_RG_RGTC2,
+                GL_R16_SNORM, GL_R8_SNORM, GL_COMPRESSED_RED_RGTC1, GL_COMPRESSED_SIGNED_RED_RGTC1,
+                GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT16,
+                GL_DEPTH32F_STENCIL8, GL_DEPTH24_STENCIL8
+        }; // OpenGL 3
+
+        inline const ankerl::unordered_set<GLenum> VALID_TYPES = {
+                GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, 
+                GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, 
+                GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV,
+                GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8,
+                GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, GL_UNSIGNED_INT_2_10_10_10_REV
+        }; // OpenGL 3
+
+        inline const ankerl::unordered_set<GLenum> VALID_TEXTURE_PARAM_NAMES = {
+                GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_COMPARE_FUNC, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_MIN_FILTER, 
+                GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_SWIZZLE_R, GL_TEXTURE_SWIZZLE_G,
+                GL_TEXTURE_SWIZZLE_B, GL_TEXTURE_SWIZZLE_A, GL_TEXTURE_SWIZZLE_RGBA, GL_TEXTURE_WRAP_S,
+                GL_TEXTURE_WRAP_T, GL_TEXTURE_WRAP_R, GL_TEXTURE_LOD_BIAS, GL_TEXTURE_MIN_LOD, GL_TEXTURE_MAX_LOD, GL_TEXTURE_BORDER_COLOR
+        }; // OpenGL 3
+        
+        inline const ankerl::unordered_set<GLenum> VALID_QUERY_LEVEL_PROPERTY_PARAM_NAMES = {
+                GL_TEXTURE_WIDTH, GL_TEXTURE_HEIGHT, GL_TEXTURE_DEPTH, GL_TEXTURE_INTERNAL_FORMAT,
+                GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE,
+                GL_TEXTURE_DEPTH_SIZE, GL_TEXTURE_COMPRESSED, GL_TEXTURE_COMPRESSED_IMAGE_SIZE
+        }; // OpenGL 3
+    }
+
+    namespace Backend {
+#define BACKEND_VULKAN 0x0015
+#define BACKEND_METAL 0x0016
+#define BACKEND_GLES 0x0017
+    }
+    
+    inline const char* RenderName = "MobileGL";
+}
+
+#endif //MOBILEGL_CONSTANTS_H

MG/Global.h

@@ -0,0 +1,40 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_GLOBAL_H
+#define MOBILEGL_GLOBAL_H
+
+#include "Includes.h"
+
+namespace MG_Global {
+    namespace MG {
+        inline const int VersionMajor = 1;
+        inline const int VersionMinor = 0;
+        inline const int VersionRevision = 0;
+        inline const int VersionPatch = 0;
+        inline const std::string VersionSuffix = "-ShittilyDraw";
+    }
+    
+    namespace Backend {
+// BACKEND_TYPE is defined in Includes.h
+    }
+    
+    namespace GL {
+        inline const int GLVersionMajor = 3;
+        inline const int GLVersionMinor = 2;
+        inline const int GLVersionRevision = 0;
+    }
+    
+    namespace Common {
+        inline constexpr int LogLevel = MG_Constants::Common::LOG_LEVEL_INFO;
+        
+#ifdef __ANDROID__
+        inline const char* LOG_FILE_PATH = "/sdcard/MG/latest.log";
+#else
+        inline const char* LOG_FILE_PATH = nullptr;
+#endif
+    }
+}
+
+#endif //MOBILEGL_GLOBAL_H

MG/Includes.h

@@ -0,0 +1,136 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#include "Constants.h"
+#define BACKEND_TYPE BACKEND_GLES
+#include "Global.h"
+#ifndef MOBILEGL_GLES_LOADER_H
+#include "MG_GL/BackendLoader/GLES/Loader.h"
+#endif
+#ifndef MOBILEGL_GL_FRAMEBUFFER_H
+#include "MG_GL/Implementations/GL/Framebuffer/GL_Framebuffer.h"
+#endif
+#ifndef MOBILEGL_GL_GETTER_H
+#include "MG_GL/Implementations/GL/Getter/GL_Getter.h"
+#endif
+#ifndef MOBILEGL_BACKENDINFO_H
+#include "MG_GL/Implementations/GL/Getter/BackendInfo.h"
+#endif
+#ifndef MOBILEGL_GL_BUFFER_H
+#include "MG_GL/Implementations/GL/Buffer/GL_Buffer.h"
+#endif
+#ifndef MOBILEGL_GL_DRAWING_H
+#include "MG_GL/Implementations/GL/Drawing/GL_Drawing.h"
+#endif
+#ifndef MOBILEGL_GL_PROGRAM_H
+#include "MG_GL/Implementations/GL/Program/GL_Program.h"
+#endif
+#ifndef MOBILEGL_GL_TEXTURE_H
+#include "MG_GL/Implementations/GL/Texture/GL_Texture.h"
+#endif
+#ifndef MOBILEGL_GL_VERTEXARRAY_H
+#include "MG_GL/Implementations/GL/VertexArray/GL_VertexArray.h"
+#endif
+#ifndef MOBILEGL_GLSTATE_H
+#include "MG_GL/State/Core/GLState.h"
+#endif
+#ifndef MOBILEGL_COMMONSTATE_H
+#include "MG_GL/State/Common/CommonState.h"
+#endif
+#ifndef MOBILEGL_TEXTURESTATE_H
+#include "MG_GL/State/Texture/TextureState.h"
+#endif
+#ifndef MOBILEGL_VERTEXARRAYSTATE_H
+#include "MG_GL/State/VertexArray/VertexArrayState.h"
+#endif
+#ifndef MOBILEGL_BUFFERSTATE_H
+#include "MG_GL/State/Buffer/BufferState.h"
+#endif
+#ifndef MOBILEGL_SHADEROBJECT_H
+#include "MG_GL/State/Program/ShaderObject.h"
+#endif
+#ifndef MOBILEGL_PROGRAMSTATE_H
+#include "MG_GL/State/Program/ProgramState.h"
+#endif
+#ifndef MOBILEGL_FRAMEBUFFERSTATE_H
+#include "MG_GL/State/Framebuffer/FramebufferState.h"
+#endif
+#ifndef MOBILEGL_LOOKUP_H
+#include "MG_GL/Implementations/GLX/LookUp/LookUp.h"
+#endif
+#ifndef MOBILEGL_DEBUG_H
+#include "MG_UTIL/Debug/Debug.h"
+#endif
+#ifndef MOBILEGL_GLSLTOOL_H
+#include "MG_UTIL/Program/GLSLTool.h"
+#endif
+#ifndef MOBILEGL_PROGRAM_DEBUGTOOL_H
+#include "MG_UTIL/Program/DebugTool.h"
+#endif
+#ifndef MOBILEGL_GL_COMMON_H
+#include "MG_GL/Implementations/GL/Common/GL_Common.h"
+#endif
+#ifndef MOBILEGL_EGL_VK_EMU_H
+#include "MG_GL/Implementations/EGL/VK/EGL_EMU.h"
+#endif
+#ifndef MOBILEGL_EGL_GLES_EGL_WRAP_H
+#include "MG_GL/Implementations/EGL/GLES/EGL_WRAP.h"
+#endif
+#ifndef MOBILEGL_TESTDRAWING_H
+#include "MG_RHI/GLES/Test/TestDrawing.h"
+#endif
+
+#include <cstring>
+#include <iostream>
+#include <cstdio>
+#include <ctime>
+#include <chrono>
+#include <thread>
+#include <string>
+#include <map>
+#include <vector>
+#include <stdexcept>
+#include <atomic>
+#include <regex>
+#include <strstream>
+#include <algorithm>
+#include <array>
+#include <random>
+#include <optional>
+#include <unordered_map>
+#include <queue>
+#include <format>
+#include <glslang/Public/ShaderLang.h>
+#include <glslang/Include/Types.h>
+#include <glslang/Public/ShaderLang.h>
+#include <spirv_cross/spirv_cross_c.h>
+#include <glslang/SPIRV/GlslangToSpv.h>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/glm.hpp>
+#include <ankerl/unordered_dense.h>
+#include <GLES3/gl32.h>
+
+#include "MG_Include/UncertainBool.hpp"
+
+#ifndef _WIN32
+#include <dlfcn.h>
+#include <unistd.h>
+#include <vulkan/vulkan.h>
+#endif
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#include <pthread.h>
+#include <vulkan/vulkan_android.h>
+#include <android/native_window.h>
+#elif _WIN32
+#include <windows.h>
+#include <processthreadsapi.h>
+#else
+#include <pthread.h>
+#endif
+
+#include <EGL/egl.h>
+#include <GL/gl.h>
+#include <GL/glext.h>

MG/Init.cpp

@@ -0,0 +1,17 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#include "Includes.h"
+
+__attribute__((constructor)) void MG_Initialize() {
+    MG_Util::Debug::LogInit();
+    MG_Util::Debug::LogI("MobileGL Initializing...");
+    MG_State::Init();
+    MG_GL::BackendLoader::Init();
+}
+
+__attribute__((destructor)) void MG_Destroy() {
+    MG_Util::Debug::LogI("MobileGL Exiting...");
+    MG_State::Destroy();
+}

MG/MG_GL/Implementations/EGL/GLES/EGL_WRAP.cpp

@@ -0,0 +1,179 @@
+//
+// Created by BZLZHH on 2025/4/26.
+//
+
+#include "EGL_WRAP.h"
+
+#if BACKEND_TYPE == BACKEND_GLES
+
+MG_EXPORT EGLint eglGetError(void) {
+    LOAD_EGL(eglGetError)
+    return egl_eglGetError();
+}
+
+MG_EXPORT EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id) {
+    LOAD_EGL(eglGetDisplay)
+    return egl_eglGetDisplay(display_id);
+}
+
+MG_EXPORT EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) {
+    LOAD_EGL(eglInitialize)
+    return egl_eglInitialize(dpy, major, minor);
+}
+
+MG_EXPORT EGLBoolean eglTerminate(EGLDisplay dpy) {
+    LOAD_EGL(eglTerminate)
+    return egl_eglTerminate(dpy);
+}
+
+MG_EXPORT const char *eglQueryString(EGLDisplay dpy, EGLint name) {
+    LOAD_EGL(eglQueryString)
+    return egl_eglQueryString(dpy, name);
+}
+
+MG_EXPORT EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config) {
+    LOAD_EGL(eglGetConfigs)
+    return egl_eglGetConfigs(dpy, configs, config_size, num_config);
+}
+
+MG_EXPORT EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config) {
+    LOAD_EGL(eglChooseConfig)
+    return egl_eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
+}
+
+MG_EXPORT EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value) {
+    LOAD_EGL(eglGetConfigAttrib)
+    return egl_eglGetConfigAttrib(dpy, config, attribute, value);
+}
+
+MG_EXPORT EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list) {
+    LOAD_EGL(eglCreateWindowSurface)
+    return egl_eglCreateWindowSurface(dpy, config, win, attrib_list);
+}
+
+MG_EXPORT EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list) {
+    LOAD_EGL(eglCreatePbufferSurface)
+    return egl_eglCreatePbufferSurface(dpy, config, attrib_list);
+}
+
+MG_EXPORT EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list) {
+    LOAD_EGL(eglCreatePixmapSurface)
+    return egl_eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
+}
+
+MG_EXPORT EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface) {
+    LOAD_EGL(eglDestroySurface)
+    return egl_eglDestroySurface(dpy, surface);
+}
+
+MG_EXPORT EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value) {
+    LOAD_EGL(eglQuerySurface)
+    return egl_eglQuerySurface(dpy, surface, attribute, value);
+}
+
+MG_EXPORT EGLBoolean eglBindAPI(EGLenum api) {
+    LOAD_EGL(eglBindAPI)
+    return egl_eglBindAPI(api);
+}
+
+MG_EXPORT EGLenum eglQueryAPI(void) {
+    LOAD_EGL(eglQueryAPI)
+    return egl_eglQueryAPI();
+}
+
+MG_EXPORT EGLBoolean eglWaitClient(void) {
+    LOAD_EGL(eglWaitClient)
+    return egl_eglWaitClient();
+}
+
+MG_EXPORT EGLBoolean eglReleaseThread(void) {
+    LOAD_EGL(eglReleaseThread)
+    return egl_eglReleaseThread();
+}
+
+MG_EXPORT EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list) {
+    LOAD_EGL(eglCreatePbufferFromClientBuffer)
+    return egl_eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
+}
+
+MG_EXPORT EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) {
+    LOAD_EGL(eglSurfaceAttrib)
+    return egl_eglSurfaceAttrib(dpy, surface, attribute, value);
+}
+
+MG_EXPORT EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
+    LOAD_EGL(eglBindTexImage)
+    return egl_eglBindTexImage(dpy, surface, buffer);
+}
+
+MG_EXPORT EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
+    LOAD_EGL(eglReleaseTexImage)
+    return egl_eglReleaseTexImage(dpy, surface, buffer);
+}
+
+MG_EXPORT EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) {
+    LOAD_EGL(eglSwapInterval)
+    return egl_eglSwapInterval(dpy, interval);
+}
+
+MG_EXPORT EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list) {
+    LOAD_EGL(eglCreateContext)
+    return egl_eglCreateContext(dpy, config, share_context, attrib_list);
+}
+
+MG_EXPORT EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) {
+    LOAD_EGL(eglDestroyContext)
+    return egl_eglDestroyContext(dpy, ctx);
+}
+
+MG_EXPORT EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
+    LOAD_EGL(eglMakeCurrent)
+    return egl_eglMakeCurrent(dpy, draw, read, ctx);
+}
+
+MG_EXPORT EGLContext eglGetCurrentContext(void) {
+    LOAD_EGL(eglGetCurrentContext)
+    return egl_eglGetCurrentContext();
+}
+
+MG_EXPORT EGLSurface eglGetCurrentSurface(EGLint readdraw) {
+    LOAD_EGL(eglGetCurrentSurface)
+    return egl_eglGetCurrentSurface(readdraw);
+}
+
+MG_EXPORT EGLDisplay eglGetCurrentDisplay(void) {
+    LOAD_EGL(eglGetCurrentDisplay)
+    return egl_eglGetCurrentDisplay();
+}
+
+MG_EXPORT EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value) {
+    LOAD_EGL(eglQueryContext)
+    return egl_eglQueryContext(dpy, ctx, attribute, value);
+}
+
+MG_EXPORT EGLBoolean eglWaitGL(void) {
+    LOAD_EGL(eglWaitGL)
+    return egl_eglWaitGL();
+}
+
+MG_EXPORT EGLBoolean eglWaitNative(EGLint engine) {
+    LOAD_EGL(eglWaitNative)
+    return egl_eglWaitNative(engine);
+}
+
+MG_EXPORT EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) {
+    LOAD_EGL(eglSwapBuffers)
+    return egl_eglSwapBuffers(dpy, surface);
+}
+
+MG_EXPORT EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) {
+    LOAD_EGL(eglCopyBuffers)
+    return egl_eglCopyBuffers(dpy, surface, target);
+}
+
+MG_EXPORT EGLDisplay eglGetPlatformDisplay(EGLenum platform, void *native_display, const EGLAttrib *attrib_list) {
+    LOAD_EGL(eglGetPlatformDisplay)
+    return egl_eglGetPlatformDisplay(platform, native_display, (const EGLint *)attrib_list);
+}
+
+#endif

MG/MG_GL/Implementations/EGL/GLES/EGL_WRAP.h

@@ -0,0 +1,14 @@
+//
+// Created by BZLZHH on 2025/4/26.
+//
+
+#ifndef MOBILEGL_EGL_GLES_EGL_WRAP_H
+#define MOBILEGL_EGL_GLES_EGL_WRAP_H
+
+#include "../../../../Includes.h"
+
+#if BACKEND_TYPE == BACKEND_GLES
+
+#endif
+
+#endif //MOBILEGL_EGL_GLES_EGL_WRAP_H

MG/MG_GL/Implementations/EGL/VK/EGL_EMU.cpp

@@ -0,0 +1,551 @@
+//
+// Created by BZLZHH on 2025/3/30.
+//
+
+#include "EGL_EMU.h"
+
+#if BACKEND_TYPE == BACKEND_VULKAN
+
+std::atomic<uintptr_t> g_nextContextId{1};
+std::atomic<uintptr_t> g_nextSurfaceId{1};
+EGLenum g_currentAPI = EGL_OPENGL_ES_API;
+
+std::mutex g_globalMutex;
+ankerl::unordered_map<EGLDisplay, VulkanDisplay> g_displays;
+ankerl::unordered_map<EGLSurface, VulkanSurface> g_surfaces;
+ankerl::unordered_map<EGLContext, VulkanContext> g_contexts;
+EGLint g_lastError = EGL_SUCCESS;
+
+thread_local EGLContext tls_currentContext = EGL_NO_CONTEXT;
+thread_local EGLSurface tls_drawSurface = EGL_NO_SURFACE;
+thread_local EGLSurface tls_readSurface = EGL_NO_SURFACE;
+
+static VkResult CreateRenderPass(VulkanDisplay& display, VulkanContext& ctx) {
+    VkAttachmentDescription colorAttachment{};
+    colorAttachment.format = VK_FORMAT_B8G8R8A8_SRGB;
+    colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
+    colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+    colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+    colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+    colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+    colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+    colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+
+    VkAttachmentReference colorRef{0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
+
+    VkSubpassDescription subpass{};
+    subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+    subpass.colorAttachmentCount = 1;
+    subpass.pColorAttachments = &colorRef;
+
+    VkRenderPassCreateInfo rpInfo{};
+    rpInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    rpInfo.subpassCount = 1;
+    rpInfo.pSubpasses = &subpass;
+    rpInfo.attachmentCount = 1;
+    rpInfo.pAttachments = &colorAttachment;
+
+    return vkCreateRenderPass(display.device, &rpInfo, nullptr, &ctx.renderPass);
+}
+
+EGLDisplay eglGetDisplay(NativeDisplayType display) {
+    std::lock_guard<std::mutex> lock(g_globalMutex);
+    static uintptr_t nextDisplayId = 1;
+    EGLDisplay newDisplay = (EGLDisplay)nextDisplayId++;
+    g_displays[newDisplay].initialized = false;
+    return newDisplay;
+}
+
+EGLBoolean eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
+    VulkanDisplay& vkDpy = g_displays[dpy];
+    if (vkDpy.initialized) return EGL_TRUE;
+
+    VkInstanceCreateInfo instInfo{};
+    instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+    const char* extensions[] = {
+            VK_KHR_SURFACE_EXTENSION_NAME,
+            VK_KHR_ANDROID_SURFACE_EXTENSION_NAME
+    };
+    instInfo.enabledExtensionCount = 2;
+    instInfo.ppEnabledExtensionNames = extensions;
+
+    if (vkCreateInstance(&instInfo, nullptr, &vkDpy.instance) != VK_SUCCESS) {
+        g_lastError = EGL_NOT_INITIALIZED;
+        return EGL_FALSE;
+    }
+
+    uint32_t devCount = 0;
+    vkEnumeratePhysicalDevices(vkDpy.instance, &devCount, nullptr);
+    std::vector<VkPhysicalDevice> devices(devCount);
+    vkEnumeratePhysicalDevices(vkDpy.instance, &devCount, devices.data());
+    vkDpy.physicalDevice = devices[0];
+
+
+    uint32_t queueFamilyCount = 0;
+    vkGetPhysicalDeviceQueueFamilyProperties(vkDpy.physicalDevice, &queueFamilyCount, nullptr);
+    std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
+    vkGetPhysicalDeviceQueueFamilyProperties(vkDpy.physicalDevice, &queueFamilyCount, queueFamilies.data());
+
+    // 寻找支持图形和呈现的队列家族
+    bool foundQueue = false;
+    for (uint32_t i = 0; i < queueFamilyCount; ++i) {
+        VkBool32 presentSupport = VK_FALSE;
+        vkGetPhysicalDeviceSurfaceSupportKHR(vkDpy.physicalDevice, i, VK_NULL_HANDLE, &presentSupport);
+
+        if ((queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) && presentSupport) {
+            vkDpy.graphicsQueueFamily = i;
+            foundQueue = true;
+            break;
+        }
+    }
+
+    if (!foundQueue) {
+        g_lastError = EGL_NOT_INITIALIZED;
+        return EGL_FALSE;
+    }
+
+    // 创建逻辑设备时请求队列
+    float queuePriority = 1.0f;
+    VkDeviceQueueCreateInfo queueInfo{};
+    queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+    queueInfo.queueFamilyIndex = vkDpy.graphicsQueueFamily;
+    queueInfo.queueCount = 1;
+    queueInfo.pQueuePriorities = &queuePriority;
+
+    const char* devExtensions[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
+    VkDeviceCreateInfo devInfo{};
+    devInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+    devInfo.pQueueCreateInfos = &queueInfo;
+    devInfo.queueCreateInfoCount = 1;
+    devInfo.ppEnabledExtensionNames = devExtensions;
+    devInfo.enabledExtensionCount = 1;
+
+    if (vkCreateDevice(vkDpy.physicalDevice, &devInfo, nullptr, &vkDpy.device) != VK_SUCCESS) {
+        g_lastError = EGL_NOT_INITIALIZED;
+        return EGL_FALSE;
+    }
+
+    vkDpy.vkCreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)vkGetDeviceProcAddr(vkDpy.device, "vkCreateSwapchainKHR");
+    vkDpy.vkDestroySwapchainKHR = (PFN_vkDestroySwapchainKHR)vkGetDeviceProcAddr(vkDpy.device, "vkDestroySwapchainKHR");
+    vkDpy.vkGetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)vkGetDeviceProcAddr(vkDpy.device, "vkGetSwapchainImagesKHR");
+    vkDpy.vkAcquireNextImageKHR = (PFN_vkAcquireNextImageKHR)vkGetDeviceProcAddr(vkDpy.device, "vkAcquireNextImageKHR");
+    vkDpy.vkQueuePresentKHR = (PFN_vkQueuePresentKHR)vkGetDeviceProcAddr(vkDpy.device, "vkQueuePresentKHR");
+    vkGetDeviceQueue(vkDpy.device, vkDpy.graphicsQueueFamily, 0, &vkDpy.graphicsQueue);
+    vkDpy.presentQueue = vkDpy.graphicsQueue;
+    vkDpy.initialized = true;
+    if (major) *major = 1;
+    if (minor) *minor = 5;
+    return EGL_TRUE;
+}
+
+EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config) {
+    VulkanDisplay& vkDpy = g_displays[dpy];
+    EGLInternalConfig defaultConfig{ VK_FORMAT_B8G8R8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, 1 };
+    vkDpy.configs = {defaultConfig};
+
+    EGLint returnCount = 1;
+    if (configs && config_size > 0) {
+        configs[0] = (EGLConfig)0;
+    }
+
+    if (num_config) *num_config = returnCount;
+    return EGL_TRUE;
+}
+
+EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint* attrib_list) {
+    VulkanDisplay& disp = g_displays[dpy];
+    static uintptr_t nextSurfId = 1;
+
+    ANativeWindow* nativeWindow = static_cast<ANativeWindow*>(window);
+    if (!nativeWindow || ANativeWindow_getWidth(nativeWindow) <= 0 || ANativeWindow_getHeight(nativeWindow) <= 0) {
+        g_lastError = EGL_BAD_NATIVE_WINDOW;
+        return EGL_NO_SURFACE;
+    }
+
+    auto vkCreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR)vkGetInstanceProcAddr(
+            disp.instance, "vkCreateAndroidSurfaceKHR");
+    if (!vkCreateAndroidSurfaceKHR) {
+        g_lastError = EGL_BAD_ALLOC;
+        return EGL_NO_SURFACE;
+    }
+
+    VulkanSurface surface{};
+    surface.type = VulkanSurface::WINDOW;
+
+    VkAndroidSurfaceCreateInfoKHR createInfo{};
+    createInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
+    createInfo.window = nativeWindow;
+    VkResult result = vkCreateAndroidSurfaceKHR(disp.instance, &createInfo, nullptr, &surface.surface);
+    if (result != VK_SUCCESS) {
+        g_lastError = (result == VK_ERROR_NATIVE_WINDOW_IN_USE_KHR) ?
+                      EGL_BAD_NATIVE_WINDOW : EGL_BAD_ALLOC;
+        return EGL_NO_SURFACE;
+    }
+
+    VkBool32 supported = VK_FALSE;
+    vkGetPhysicalDeviceSurfaceSupportKHR(disp.physicalDevice,
+                                         disp.graphicsQueueFamily,
+                                         surface.surface,
+                                         &supported);
+    if (!supported) {
+        vkDestroySurfaceKHR(disp.instance, surface.surface, nullptr);
+        g_lastError = EGL_BAD_MATCH;
+        return EGL_NO_SURFACE;
+    }
+
+    VkSurfaceCapabilitiesKHR caps;
+    vkGetPhysicalDeviceSurfaceCapabilitiesKHR(disp.physicalDevice, surface.surface, &caps);
+
+    const VkExtent2D swapchainExtent = {
+            (std::max)(caps.minImageExtent.width,  (uint32_t)ANativeWindow_getWidth(nativeWindow)),
+            (std::max)(caps.minImageExtent.height, (uint32_t)ANativeWindow_getHeight(nativeWindow))
+    };
+
+    VkSwapchainCreateInfoKHR swapInfo{};
+    swapInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+    swapInfo.surface = surface.surface;
+    swapInfo.minImageCount = 3;
+    swapInfo.imageFormat = VK_FORMAT_R8G8B8A8_SRGB;
+    swapInfo.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+    swapInfo.imageExtent = swapchainExtent;
+    swapInfo.imageArrayLayers = 1;
+    swapInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    swapInfo.preTransform = caps.currentTransform;
+    swapInfo.compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
+    swapInfo.presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
+
+    if (disp.vkCreateSwapchainKHR(disp.device, &swapInfo, nullptr, &surface.swapchain) != VK_SUCCESS) {
+        vkDestroySurfaceKHR(disp.instance, surface.surface, nullptr);
+        g_lastError = EGL_BAD_ALLOC;
+        return EGL_NO_SURFACE;
+    }
+
+    uint32_t imageCount = 0;
+    disp.vkGetSwapchainImagesKHR(disp.device, surface.swapchain, &imageCount, nullptr);
+    surface.images.resize(imageCount);
+    disp.vkGetSwapchainImagesKHR(disp.device, surface.swapchain, &imageCount, surface.images.data());
+
+    surface.imageViews.resize(imageCount);
+    for (uint32_t i = 0; i < imageCount; ++i) {
+        VkImageViewCreateInfo viewInfo{};
+        viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+        viewInfo.image = surface.images[i];
+        viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+        viewInfo.format = swapInfo.imageFormat;
+        viewInfo.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
+
+        if (vkCreateImageView(disp.device, &viewInfo, nullptr, &surface.imageViews[i]) != VK_SUCCESS) {
+            // Handle error
+        }
+    }
+
+    ANativeWindow_acquire(nativeWindow);
+    ANativeWindow_setBuffersGeometry(nativeWindow,
+                                     swapchainExtent.width,
+                                     swapchainExtent.height,
+                                     AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM);
+    EGLSurface surfId = (EGLSurface)nextSurfId++;
+    g_surfaces[surfId] = std::move(surface);
+    return surfId;
+}
+
+EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx, const EGLint* attrib_list) {
+    static uintptr_t nextCtxId = 1;
+    VulkanDisplay &disp = g_displays[dpy];
+
+    VulkanContext ctx{};
+    VkCommandPoolCreateInfo poolInfo{};
+    poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+    poolInfo.queueFamilyIndex = 0;
+    if (vkCreateCommandPool(disp.device, &poolInfo, nullptr, &ctx.cmdPool) != VK_SUCCESS) {
+        g_lastError = EGL_BAD_ALLOC;
+        return EGL_NO_CONTEXT;
+    }
+
+    ctx.frameFences.resize(2);
+    ctx.acquireSemaphores.resize(2);
+    ctx.presentSemaphores.resize(2);
+    for (uint32_t i = 0; i < 2; ++i) {
+        VkFenceCreateInfo fenceInfo{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, nullptr,
+                                    VK_FENCE_CREATE_SIGNALED_BIT};
+        vkCreateFence(disp.device, &fenceInfo, nullptr, &ctx.frameFences[i]);
+
+        VkSemaphoreCreateInfo semInfo{VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO};
+        vkCreateSemaphore(disp.device, &semInfo, nullptr, &ctx.acquireSemaphores[i]);
+        vkCreateSemaphore(disp.device, &semInfo, nullptr, &ctx.presentSemaphores[i]);
+    }
+
+    if (CreateRenderPass(disp, ctx) != VK_SUCCESS) {
+        g_lastError = EGL_BAD_CONFIG;
+        return EGL_NO_CONTEXT;
+    }
+
+    EGLContext ctxId = (EGLContext)nextCtxId++;
+    g_contexts[ctxId] = std::move(ctx);
+    return ctxId;
+}
+
+EGLint eglGetError() {
+    return EGL_SUCCESS;
+}
+
+EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
+    std::lock_guard<std::mutex> lock(g_globalMutex);
+
+    if (dpy == EGL_NO_DISPLAY || (ctx != EGL_NO_CONTEXT && !g_contexts.count(ctx)) ||
+        (draw != EGL_NO_SURFACE && !g_surfaces.count(draw)) ||
+        (read != EGL_NO_SURFACE && !g_surfaces.count(read))) {
+        g_lastError = EGL_BAD_PARAMETER;
+        return EGL_FALSE;
+    }
+
+    if (tls_currentContext != EGL_NO_CONTEXT) {
+        VulkanContext& oldCtx = g_contexts[tls_currentContext];
+        if (oldCtx.currentCmdBuffer) {
+            vkEndCommandBuffer(oldCtx.currentCmdBuffer);
+            oldCtx.currentCmdBuffer = VK_NULL_HANDLE;
+        }
+    }
+
+    if (ctx != EGL_NO_CONTEXT) {
+        VulkanContext& newCtx = g_contexts[ctx];
+        VulkanDisplay& disp = g_displays[dpy];
+
+        VkCommandBufferAllocateInfo allocInfo{};
+        allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+        allocInfo.commandPool = newCtx.cmdPool;
+        allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+        allocInfo.commandBufferCount = 1;
+
+        if (vkAllocateCommandBuffers(disp.device, &allocInfo, &newCtx.currentCmdBuffer) != VK_SUCCESS) {
+            g_lastError = EGL_BAD_ALLOC;
+            return EGL_FALSE;
+        }
+
+        VkCommandBufferBeginInfo beginInfo{};
+        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+        vkBeginCommandBuffer(newCtx.currentCmdBuffer, &beginInfo);
+    }
+
+    tls_currentContext = ctx;
+    tls_drawSurface = draw;
+    tls_readSurface = read;
+    return EGL_TRUE;
+}
+
+EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) {
+    std::lock_guard<std::mutex> lock(g_globalMutex);
+
+    if (!g_contexts.count(ctx)) {
+        g_lastError = EGL_BAD_CONTEXT;
+        return EGL_FALSE;
+    }
+
+    VulkanContext& vkCtx = g_contexts[ctx];
+    VulkanDisplay& disp = g_displays[dpy];
+
+    vkDeviceWaitIdle(disp.device);
+
+    vkDestroyCommandPool(disp.device, vkCtx.cmdPool, nullptr);
+    vkDestroyRenderPass(disp.device, vkCtx.renderPass, nullptr);
+
+    for (auto& fence : vkCtx.frameFences)
+        vkDestroyFence(disp.device, fence, nullptr);
+    for (auto& sem : vkCtx.acquireSemaphores)
+        vkDestroySemaphore(disp.device, sem, nullptr);
+    for (auto& sem : vkCtx.presentSemaphores)
+        vkDestroySemaphore(disp.device, sem, nullptr);
+
+    g_contexts.erase(ctx);
+    if (tls_currentContext == ctx)
+        tls_currentContext = EGL_NO_CONTEXT;
+
+    return EGL_TRUE;
+}
+
+EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface) {
+    std::lock_guard<std::mutex> lock(g_globalMutex);
+
+    if (!g_surfaces.count(surface)) {
+        g_lastError = EGL_BAD_SURFACE;
+        return EGL_FALSE;
+    }
+
+    VulkanSurface& surf = g_surfaces[surface];
+    VulkanDisplay& disp = g_displays[dpy];
+
+    vkDeviceWaitIdle(disp.device);
+
+    if (surf.type == VulkanSurface::WINDOW) {
+        disp.vkDestroySwapchainKHR(disp.device, surf.swapchain, nullptr);
+        vkDestroySurfaceKHR(disp.instance, surf.surface, nullptr);
+        for (auto& view : surf.imageViews)
+            vkDestroyImageView(disp.device, view, nullptr);
+    } else {
+        vkDestroyImageView(disp.device, surf.pbufferImageView, nullptr);
+        vkDestroyImage(disp.device, surf.pbufferImage, nullptr);
+    }
+
+    g_surfaces.erase(surface);
+    return EGL_TRUE;
+}
+
+EGLBoolean eglTerminate(EGLDisplay dpy) {
+    std::lock_guard<std::mutex> lock(g_globalMutex);
+
+    if (!g_displays.count(dpy)) {
+        g_lastError = EGL_BAD_DISPLAY;
+        return EGL_FALSE;
+    }
+
+    VulkanDisplay& disp = g_displays[dpy];
+
+    for (auto& [ctxId, ctx] : g_contexts)
+        eglDestroyContext(dpy, ctxId);
+    for (auto& [surfId, surf] : g_surfaces)
+        eglDestroySurface(dpy, surfId);
+
+    vkDestroyDevice(disp.device, nullptr);
+    vkDestroyInstance(disp.instance, nullptr);
+
+    g_displays.erase(dpy);
+    return EGL_TRUE;
+}
+
+EGLBoolean eglReleaseThread(void) {
+    tls_currentContext = EGL_NO_CONTEXT;
+    tls_drawSurface = EGL_NO_SURFACE;
+    tls_readSurface = EGL_NO_SURFACE;
+    return EGL_TRUE;
+}
+
+EGLContext eglGetCurrentContext(void) {
+    return tls_currentContext;
+}
+
+EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value) {
+    VulkanDisplay& disp = g_displays[dpy];
+    if (!disp.configs.empty() && config == (EGLConfig)0) {
+        switch (attribute) {
+            case EGL_BUFFER_SIZE:  *value = 32; break;
+            case EGL_RED_SIZE:      *value = 8;  break;
+            case EGL_GREEN_SIZE:    *value = 8;  break;
+            case EGL_BLUE_SIZE:     *value = 8;  break;
+            case EGL_ALPHA_SIZE:    *value = 8;  break;
+            case EGL_CONFIG_ID:     *value = 1;  break;
+            default: return EGL_FALSE;
+        }
+        return EGL_TRUE;
+    }
+    return EGL_FALSE;
+}
+
+EGLBoolean eglBindAPI(EGLenum api) {
+    if (api == EGL_OPENGL_ES_API) {
+        g_currentAPI = api;
+        return EGL_TRUE;
+    }
+    return EGL_FALSE;
+}
+
+EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list) {
+    VulkanDisplay& disp = g_displays[dpy];
+    VulkanSurface surface{};
+    surface.type = VulkanSurface::PBUFFER;
+
+    VkImageCreateInfo imgInfo{};
+    imgInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+    imgInfo.imageType = VK_IMAGE_TYPE_2D;
+    imgInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
+    imgInfo.extent = {512, 512, 1};
+    imgInfo.mipLevels = 1;
+    imgInfo.arrayLayers = 1;
+    imgInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+    imgInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+    imgInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    imgInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+
+    if (vkCreateImage(disp.device, &imgInfo, nullptr, &surface.pbufferImage) != VK_SUCCESS) {
+        g_lastError = EGL_BAD_ALLOC;
+        return EGL_NO_SURFACE;
+    }
+
+    VkImageViewCreateInfo viewInfo{};
+    viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+    viewInfo.image = surface.pbufferImage;
+    viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+    viewInfo.format = imgInfo.format;
+    viewInfo.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
+
+    if (vkCreateImageView(disp.device, &viewInfo, nullptr, &surface.pbufferImageView) != VK_SUCCESS) {
+        vkDestroyImage(disp.device, surface.pbufferImage, nullptr);
+        g_lastError = EGL_BAD_ALLOC;
+        return EGL_NO_SURFACE;
+    }
+
+    EGLSurface surfId = (EGLSurface)g_nextSurfaceId++;
+    g_surfaces[surfId] = surface;
+    return surfId;
+}
+
+EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw) {
+    VulkanSurface& surf = g_surfaces[draw];
+    VulkanDisplay& disp = g_displays[dpy];
+    VulkanContext& ctx = g_contexts[tls_currentContext];
+    
+    if (!disp.presentQueue) {
+        g_lastError = EGL_BAD_DISPLAY;
+        return EGL_FALSE;
+    }
+    
+    if (surf.type != VulkanSurface::WINDOW) {
+        g_lastError = EGL_BAD_SURFACE;
+        return EGL_FALSE;
+    }
+
+    vkEndCommandBuffer(ctx.currentCmdBuffer);
+
+    VkSubmitInfo submitInfo{};
+    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submitInfo.commandBufferCount = 1;
+    submitInfo.pCommandBuffers = &ctx.currentCmdBuffer;
+
+    vkQueueSubmit(disp.graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
+
+    VkPresentInfoKHR presentInfo{};
+    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+    presentInfo.swapchainCount = 1;
+    presentInfo.pSwapchains = &surf.swapchain;
+    presentInfo.pImageIndices = &ctx.frameIndex;
+
+    VkResult result = disp.vkQueuePresentKHR(disp.presentQueue, &presentInfo);
+    if (result != VK_SUCCESS) {
+        g_lastError = EGL_BAD_ALLOC;
+        return EGL_FALSE;
+    }
+
+    ctx.frameIndex = (ctx.frameIndex + 1) % surf.images.size();
+    return EGL_TRUE;
+}
+
+EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) {
+    // TODO
+    return EGL_TRUE;
+}
+
+EGLSurface eglGetCurrentSurface(EGLint readdraw) {
+    return (readdraw == EGL_READ) ? tls_readSurface : tls_drawSurface;
+}
+
+EGLBoolean eglQuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint *value) {
+    VulkanSurface& surf = g_surfaces[surface];
+    switch (attribute) {
+        case EGL_WIDTH:  *value = surf.extent.width;  break;
+        case EGL_HEIGHT: *value = surf.extent.height; break;
+        case EGL_CONFIG_ID: *value = 1; break;
+        default: return EGL_FALSE;
+    }
+    return EGL_TRUE;
+}
+
+#endif

MG/MG_GL/Implementations/EGL/VK/EGL_EMU.h

@@ -0,0 +1,103 @@
+//
+// Created by BZLZHH on 2025/3/30.
+//
+
+#ifndef MOBILEGL_EGL_VK_EMU_H
+#define MOBILEGL_EGL_VK_EMU_H
+
+#include "../../../../Includes.h"
+
+#if BACKEND_TYPE == BACKEND_VULKAN
+
+struct EGLInternalConfig {
+    VkFormat format;
+    VkColorSpaceKHR colorSpace;
+    uint32_t samples;
+};
+
+struct VulkanDisplay {
+    VkInstance instance;
+    VkPhysicalDevice physicalDevice;
+    VkDevice device;
+    uint32_t graphicsQueueFamily;
+    VkQueue graphicsQueue;
+    std::vector<EGLInternalConfig> configs;
+    bool initialized = false;
+    PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR;
+    PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR;
+    PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR;
+    PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR;
+    PFN_vkQueuePresentKHR vkQueuePresentKHR;
+    VkRenderPass defaultRenderPass;
+    VkQueue presentQueue = VK_NULL_HANDLE;
+};
+
+struct VulkanSurface {
+    enum Type { WINDOW, PBUFFER } type;
+    VkSurfaceKHR surface;
+    VkSwapchainKHR swapchain;
+    std::vector<VkImage> images;
+    std::vector<VkImageView> imageViews;
+    VkExtent2D extent;
+    VkFormat format;
+    VkImage pbImage;
+    VkImageView pbImageView;
+    VkDeviceMemory pbMemory;
+    VkFramebuffer framebuffer;
+    VkImage pbufferImage;
+    VkImageView pbufferImageView;
+};
+
+struct VulkanContext {
+    VkCommandPool cmdPool;
+    std::vector<VkCommandBuffer> cmdBuffers;
+    uint32_t currentFrame = 0;
+    VkRenderPass renderPass;
+    VkPipelineLayout pipelineLayout;
+    VkPipeline graphicsPipeline;
+    std::vector<VkFence> frameFences;
+    std::vector<VkSemaphore> acquireSemaphores;
+    std::vector<VkSemaphore> presentSemaphores;
+    VulkanSurface* boundSurface = nullptr;
+    VkCommandBuffer currentCmdBuffer;
+    uint32_t frameIndex;
+    VkClearColorValue clearColor;
+};
+
+extern std::atomic<uintptr_t> g_nextContextId;
+extern std::atomic<uintptr_t> g_nextSurfaceId;
+extern EGLenum g_currentAPI;
+
+extern std::mutex g_globalMutex;
+extern ankerl::unordered_map<EGLDisplay, VulkanDisplay> g_displays;
+extern ankerl::unordered_map<EGLSurface, VulkanSurface> g_surfaces;
+extern ankerl::unordered_map<EGLContext, VulkanContext> g_contexts;
+extern EGLint g_lastError;
+
+extern thread_local EGLContext tls_currentContext;
+extern thread_local EGLSurface tls_drawSurface;
+extern thread_local EGLSurface tls_readSurface;
+
+MG_EXPORT EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint* attrib_list);
+MG_EXPORT EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config);
+MG_EXPORT EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx, const EGLint* attrib_list);
+MG_EXPORT EGLBoolean eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor);
+MG_EXPORT EGLDisplay eglGetDisplay(NativeDisplayType display);
+MG_EXPORT EGLint eglGetError();
+MG_EXPORT EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
+MG_EXPORT EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx);
+MG_EXPORT EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface);
+MG_EXPORT EGLBoolean eglTerminate(EGLDisplay dpy);
+MG_EXPORT EGLBoolean eglReleaseThread(void);
+MG_EXPORT EGLContext eglGetCurrentContext(void);
+MG_EXPORT EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
+MG_EXPORT EGLBoolean eglBindAPI(EGLenum api);
+MG_EXPORT EGLSurface eglGetCurrentSurface(EGLint readdraw);
+MG_EXPORT EGLBoolean eglQuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint *value);
+MG_EXPORT EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval);
+MG_EXPORT EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw);
+MG_EXPORT EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
+
+#endif
+
+#endif //MOBILEGL_EGL_VK_EMU_H

MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.cpp

@@ -0,0 +1,188 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#include "GL_Buffer.h"
+
+namespace MG_GL::GL {
+    void* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
+                         GLbitfield access) {
+        MG_Util::Debug::LogD("glMapBufferRange, target: %s, offset: %lld, length: %lld, access: 0x%X",
+                             MG_Util::Debug::GLEnumToString(target),
+                             static_cast<long long>(offset),
+                             static_cast<long long>(length),
+                             access);
+        void* mappedPointer = nullptr;
+        GLenum result = MG_State::AcquireBufferMemoryRange(target, offset, length, access, &mappedPointer);
+
+        if (result == GL_NO_ERROR) {
+            MG_Util::Debug::LogD("Mapped pointer: %p", mappedPointer);
+            return mappedPointer;
+        }
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error mapping buffer range: %s", MG_Util::Debug::GLEnumToString(result));
+        return nullptr;
+    }
+
+    void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) {
+        MG_Util::Debug::LogD("glFlushMappedBufferRange, target: %s, offset: %lld, length: %lld",
+                             MG_Util::Debug::GLEnumToString(target),
+                             static_cast<long long>(offset),
+                             static_cast<long long>(length));
+        GLenum result = MG_State::SyncBufferMemory(target, offset, length);
+        if (result == GL_NO_ERROR) {
+            return;
+        }
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error flushing mapped buffer range: %s",
+                             MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
+                           GLintptr readOffset, GLintptr writeOffset,
+                           GLsizeiptr size) {
+        MG_Util::Debug::LogD("glCopyBufferSubData, readTarget: %s, writeTarget: %s, "
+                             "readOffset: %lld, writeOffset: %lld, size: %lld",
+                             MG_Util::Debug::GLEnumToString(readTarget),
+                             MG_Util::Debug::GLEnumToString(writeTarget),
+                             static_cast<long long>(readOffset),
+                             static_cast<long long>(writeOffset),
+                             static_cast<long long>(size));
+        GLenum result = MG_State::CopyBufferRange(readTarget, writeTarget, readOffset, writeOffset, size);
+        if (result == GL_NO_ERROR) {
+            return;
+        }
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error copying buffer subdata: %s",
+                             MG_Util::Debug::GLEnumToString(result));
+    }
+    
+    void* MapBuffer(GLenum target, GLenum access) {
+        MG_Util::Debug::LogD("glMapBuffer(target=0x%x, access=0x%x)", target, access);
+        void* mappedPtr = nullptr;
+        GLenum err = MG_State::AcquireBufferMemory(target, access, &mappedPtr);
+        if (err != GL_NO_ERROR) {
+            MG_State::SetError(err);
+            MG_Util::Debug::LogE("glMapBuffer failed: %s", MG_Util::Debug::GLEnumToString(err));
+            return nullptr;
+        }
+        MG_Util::Debug::LogD("glMapBuffer returns %p", mappedPtr);
+        return mappedPtr;
+    }
+    
+    GLboolean UnmapBuffer(GLenum target) {
+        MG_Util::Debug::LogD("glUnmapBuffer(target=0x%x)", target);
+        GLenum err = MG_State::ReleaseBufferMemory(target);
+        if (err != GL_NO_ERROR) {
+            MG_State::SetError(err);
+            MG_Util::Debug::LogE("glUnmapBuffer failed: %s", MG_Util::Debug::GLEnumToString(err));
+            return GL_FALSE;
+        }
+        MG_Util::Debug::LogD("glUnmapBuffer succeeded");
+        return GL_TRUE;
+    }
+
+    void BindBuffer(GLenum target, GLuint buffer) {
+        MG_Util::Debug::LogD("glBindBuffer, target: %s, buffer: %d", MG_Util::Debug::GLEnumToString(target), buffer);
+        if (buffer != 0 &&
+            MG_State::ValidateGeneratedName(buffer) &&
+            !MG_State::ValidateAllocatedBufferHandle(buffer)) {
+            MG_Util::Debug::LogD("Actually creating buffer: %u", buffer);
+            GLenum result = MG_State::CreateBuffer(buffer);
+            if (result != GL_NO_ERROR) {
+                MG_State::SetError(result);
+                MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+                return;
+            }
+        }
+
+        if (buffer != 0 && !MG_State::ValidateAllocatedBufferHandle(buffer)) {
+            MG_State::SetError(GL_INVALID_VALUE);
+            MG_Util::Debug::LogE("Invalid buffer handle: %u", buffer);
+            return;
+        }
+        GLenum result = MG_State::BindBuffer(target, buffer);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
+        MG_Util::Debug::LogD("glBufferData, target: %s, size: %zd, data: %p, usage: %s",
+                             MG_Util::Debug::GLEnumToString(target), size, data, MG_Util::Debug::GLEnumToString(usage));
+        GLenum result = MG_State::CommitBufferStorage(target, size, data, usage);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
+        MG_Util::Debug::LogD("glGetBufferParameteriv, target: %d, pname: %d, params: %p",
+                             target, pname, params);
+        GLenum result = MG_State::QueryBufferPropertyIntVector(target, pname, params);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("GetBufferParameteriv not implemented");
+    }
+    
+    void GenBuffers(GLsizei n, GLuint* buffers) {
+        MG_Util::Debug::LogD("glGenBuffers, n: %d, buffers: %p", n, buffers);
+
+        if (n < 0) {
+            MG_State::SetError(GL_INVALID_VALUE);
+            MG_Util::Debug::LogE("Invalid buffer count: %d", n);
+            return;
+        }
+
+        GLenum result = MG_State::GenBufferNames(n, buffers);
+        if (result == GL_NO_ERROR) {
+            MG_Util::Debug::LogD("Generated buffer names:");
+            for (GLsizei i = 0; i < n; ++i) {
+                MG_Util::Debug::LogD("  Buffer[%d] = %u", i, buffers[i]);
+            }
+            return;
+        }
+
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    GLboolean IsBuffer(GLuint buffer) {
+        MG_Util::Debug::LogD("glIsBuffer, buffer: %u", buffer);
+
+        if (buffer == 0) {
+            return GL_FALSE;
+        }
+
+        bool isValid = MG_State::ValidateAllocatedBufferHandle(buffer);
+        // Should we report gl error here or in MG_State? 
+        MG_Util::Debug::LogD("Buffer %u is %s", buffer, isValid ? "valid" : "invalid");
+        return isValid ? GL_TRUE : GL_FALSE;
+    }
+
+    void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
+        MG_Util::Debug::LogD("glBufferSubData, target: %s, offset: %lld, size: %lld, data: %p",
+                             MG_Util::Debug::GLEnumToString(target),
+                             static_cast<long long>(offset),
+                             static_cast<long long>(size),
+                             data);
+        GLenum result = MG_State::CommitBufferStorageRegion(target, offset, size, data);
+        if (result != GL_NO_ERROR) {
+            MG_State::SetError(result);
+            MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+        }
+    }
+    void DeleteBuffers(GLsizei n, const GLuint *buffers) {
+        MG_Util::Debug::LogD("glDeleteBuffers, n: %d, buffers: %p", n, buffers);
+
+        GLenum result = MG_State::DeleteBuffers(n, buffers);
+        if (result == GL_NO_ERROR)
+            return;
+
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+}

MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.h

@@ -0,0 +1,25 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_GL_BUFFER_H
+#define MOBILEGL_GL_BUFFER_H
+
+#include "../../../../Includes.h"
+
+namespace MG_GL::GL {
+    void* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+    void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length);
+    void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+    void* MapBuffer(GLenum target, GLenum access);
+    GLboolean UnmapBuffer(GLenum target);
+    void BindBuffer(GLenum target, GLuint buffer);
+    void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
+    void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
+    void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params);
+    void GenBuffers(GLsizei n, GLuint* buffers);
+    void DeleteBuffers(GLsizei n, const GLuint *buffers);
+    GLboolean IsBuffer(GLuint buffer);
+}
+
+#endif //MOBILEGL_GL_BUFFER_H

MG/MG_GL/Implementations/GL/Common/GL_Common.cpp

@@ -0,0 +1,103 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#include "GL_Common.h"
+
+namespace MG_GL::GL {
+    void Enable(GLenum cap) {
+        MG_Util::Debug::LogD("glEnable, cap: %s", MG_Util::Debug::GLEnumToString(cap));
+        GLenum result = MG_State::glEnable(cap);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error enabling capability: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void Disable(GLenum cap) {
+        MG_Util::Debug::LogD("glDisable, cap: %s", MG_Util::Debug::GLEnumToString(cap));
+        GLenum result = MG_State::glDisable(cap);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error disabling capability: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void BlendFunc(GLenum sfactor, GLenum dfactor) {
+        MG_Util::Debug::LogD("glBlendFunc, sfactor: %s, dfactor: %s",
+                             MG_Util::Debug::GLEnumToString(sfactor),
+                             MG_Util::Debug::GLEnumToString(dfactor));
+        GLenum result = MG_State::glBlendFunc(sfactor, dfactor);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error setting blend func: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
+        MG_Util::Debug::LogD("glBlendFuncSeparate, srcRGB: %s, dstRGB: %s, srcAlpha: %s, dstAlpha: %s",
+                             MG_Util::Debug::GLEnumToString(srcRGB),
+                             MG_Util::Debug::GLEnumToString(dstRGB),
+                             MG_Util::Debug::GLEnumToString(srcAlpha),
+                             MG_Util::Debug::GLEnumToString(dstAlpha));
+        GLenum result = MG_State::glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error setting separate blend func: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
+        MG_Util::Debug::LogD("glClearColor, rgba: [%.2f, %.2f, %.2f, %.2f]", red, green, blue, alpha);
+        GLenum result = MG_State::glClearColor(red, green, blue, alpha);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error setting clear color: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void ClearDepth(GLdouble depth) {
+        MG_Util::Debug::LogD("glClearDepth, depth: %.3f", depth);
+        GLenum result = MG_State::glClearDepth(depth);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error setting clear depth: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
+        MG_Util::Debug::LogD("glColorMask, rgba: [%d, %d, %d, %d]", red, green, blue, alpha);
+        GLenum result = MG_State::glColorMask(red, green, blue, alpha);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error setting color mask: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void DepthFunc(GLenum func) {
+        MG_Util::Debug::LogD("glDepthFunc, func: %s", MG_Util::Debug::GLEnumToString(func));
+        GLenum result = MG_State::glDepthFunc(func);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error setting depth func: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void DepthMask(GLboolean flag) {
+        MG_Util::Debug::LogD("glDepthMask, flag: %d", flag);
+        GLenum result = MG_State::glDepthMask(flag);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error setting depth mask: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
+        MG_Util::Debug::LogD("glViewport, x: %d, y: %d, width: %d, height: %d",
+                             x, y, width, height);
+        GLenum result = MG_State::glViewport(x, y, width, height);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error setting viewport: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void PixelStorei(GLenum pname, GLint param) {
+        MG_Util::Debug::LogD("glPixelStorei, pname: %d, param: %d", pname, param);
+        GLenum result = MG_State::SetPixelStoreInt(pname,param);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }   
+}

MG/MG_GL/Implementations/GL/Common/GL_Common.h

@@ -0,0 +1,25 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_GL_COMMON_H
+#define MOBILEGL_GL_COMMON_H
+
+#include "../../../../Includes.h"
+
+namespace MG_GL::GL {
+    void ClearDepth(GLdouble depth);
+    void ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+    void Clear(GLbitfield mask);
+    void PixelStorei(GLenum pname, GLint param);
+    void Enable(GLenum cap);
+    void Disable(GLenum cap);
+    void BlendFunc(GLenum sfactor, GLenum dfactor);
+    void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+    void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+    void DepthFunc(GLenum func);
+    void DepthMask(GLboolean flag);
+    void Viewport(GLint x, GLint y, GLsizei width, GLsizei height);
+}
+
+#endif //MOBILEGL_GL_COMMON_H

MG/MG_GL/Implementations/GL/Drawing/GL_Drawing.h

@@ -0,0 +1,17 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_GL_DRAWING_H
+#define MOBILEGL_GL_DRAWING_H
+#include "../../../../Includes.h"
+namespace MG_GL::GL {
+    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 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 DrawBuffer(GLenum buf);
+}
+
+#endif //MOBILEGL_GL_DRAWING_H

MG/MG_GL/Implementations/GL/Framebuffer/GL_Framebuffer.cpp

@@ -0,0 +1,68 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#include "GL_Framebuffer.h"
+
+namespace MG_GL::GL {
+    void GenFramebuffers(GLsizei n, GLuint* framebuffers) {
+        MG_Util::Debug::LogD("glGenFramebuffers, n: %d, framebuffers: %p", n, framebuffers);
+        GLenum result = MG_State::CreateFramebuffers(n, framebuffers);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Framebuffer generation failed: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
+        MG_Util::Debug::LogD("glDeleteFramebuffers, n: %d, framebuffers: %p", n, framebuffers);
+        for (GLsizei i = 0; i < n; ++i) {
+            GLenum result = MG_State::DeleteFramebuffer(framebuffers[i]);
+            if (result != GL_NO_ERROR) {
+                MG_State::SetError(result);
+                MG_Util::Debug::LogE("Failed to delete framebuffer %u: %s",
+                                     framebuffers[i], MG_Util::Debug::GLEnumToString(result));
+            }
+        }
+    }
+
+    void BindFramebuffer(GLenum target, GLuint framebuffer) {
+        MG_Util::Debug::LogD("glBindFramebuffer, target: %s, fb: %u",
+                             MG_Util::Debug::GLEnumToString(target), framebuffer);
+        GLenum result = MG_State::BindFramebuffer(target, framebuffer);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Framebuffer bind error: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget,
+                              GLuint texture, GLint level) {
+        MG_Util::Debug::LogD("glFramebufferTexture2D, target: %s, attach: %s, textarget: %s, tex: %u, level: %d",
+                             MG_Util::Debug::GLEnumToString(target),
+                             MG_Util::Debug::GLEnumToString(attachment),
+                             MG_Util::Debug::GLEnumToString(textarget),
+                             texture, level);
+
+        GLenum result = MG_State::AttachTexture2DToFramebuffer(
+                target, attachment, textarget, texture, level
+        );
+
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Texture attachment failed: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    GLenum CheckFramebufferStatus(GLenum target) {
+        MG_Util::Debug::LogD("glCheckFramebufferStatus, target: %s",
+                             MG_Util::Debug::GLEnumToString(target));
+        GLenum result = MG_State::ValidateFramebufferCompleteness(target);
+        if (result >= GL_FRAMEBUFFER_COMPLETE) {
+            MG_Util::Debug::LogD("Framebuffer status: %s",
+                                 MG_Util::Debug::GLEnumToString(result));
+            return result;
+        }
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Framebuffer incomplete: %s",
+                             MG_Util::Debug::GLEnumToString(result));
+        return result;
+    }
+}

MG/MG_GL/Implementations/GL/Framebuffer/GL_Framebuffer.h

@@ -0,0 +1,19 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_GL_FRAMEBUFFER_H
+#define MOBILEGL_GL_FRAMEBUFFER_H
+
+#include "../../../../Includes.h"
+
+namespace MG_GL::GL {
+    void GenFramebuffers(GLsizei n, GLuint* framebuffers);
+    void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers);
+    void BindFramebuffer(GLenum target, GLuint framebuffer);
+    void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+    GLenum CheckFramebufferStatus(GLenum target);
+    void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+}
+
+#endif //MOBILEGL_GL_FRAMEBUFFER_H

MG/MG_GL/Implementations/GL/GLFuncsDefinitions/GLFuncsDefinitions.h

@@ -0,0 +1,10 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_GL_FUNCS_DEFINITIONS_H
+#define MOBILEGL_GL_FUNCS_DEFINITIONS_H
+
+#include "../../../../Includes.h"
+
+#endif //MOBILEGL_GL_FUNCS_DEFINITIONS_H

MG/MG_GL/Implementations/GL/Getter/BackendInfo.cpp

@@ -0,0 +1,93 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#include "BackendInfo.h"
+
+namespace MG_GL::Getter {
+    const std::string GetBackendName() {
+#if BACKEND_TYPE == BACKEND_VULKAN
+        return "Vulkan";
+#elif BACKEND_TYPE == BACKEND_METAL
+        return "Metal";
+#elif BACKEND_TYPE == BACKEND_GLES
+        return "OpenGL ES";
+#else
+        return "<Unknown Backend>";
+#endif
+    }
+
+    const std::string GetMGName() {
+#if BACKEND_TYPE == BACKEND_VULKAN
+        return "MobileGluvk";
+#elif BACKEND_TYPE == BACKEND_METAL
+        return "MobileGlumtl";
+#elif BACKEND_TYPE == BACKEND_GLES
+        return "MobileGlues";
+#else
+        return "<Unknown MobileGL Version>";
+#endif
+    }
+
+    void LogMGInfo() {
+        std::string MGName = MG_GL::Getter::GetMGName() + " (MobileGL Core)";
+
+        std::string MGVersion = std::to_string(MG_Global::MG::VersionMajor) + "."
+                                +  std::to_string(MG_Global::MG::VersionMinor) + "."
+                                +  std::to_string(MG_Global::MG::VersionRevision);
+        if (MG_Global::MG::VersionPatch != 0)
+            MGVersion += "." + std::to_string(MG_Global::MG::VersionPatch);
+        MGVersion += MG_Global::MG::VersionSuffix;
+
+        std::string GLVersion = std::to_string(MG_Global::GL::GLVersionMajor) + "."
+                                +  std::to_string(MG_Global::GL::GLVersionMinor) + "."
+                                +  std::to_string(MG_Global::GL::GLVersionRevision);
+
+        std::string backendName = MG_GL::Getter::GetBackendName();
+        
+        std::string backendVersion;
+#if BACKEND_TYPE == BACKEND_VULKAN
+        VkApplicationInfo appInfo = {};
+        appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+        appInfo.pApplicationName = "Vulkan Version Query";
+        appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
+        appInfo.pEngineName = "No Engine";
+        appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
+        appInfo.apiVersion = VK_API_VERSION_1_0;
+        VkInstanceCreateInfo createInfo = {};
+        createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+        createInfo.pApplicationInfo = &appInfo;
+        VkInstance instance;
+        if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
+            throw std::runtime_error("Failed to create Vulkan instance!");
+        }
+        uint32_t deviceCount = 0;
+        vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
+        if (deviceCount == 0) {
+            throw std::runtime_error("No Vulkan devices found!");
+        }
+        VkPhysicalDevice physicalDevice;
+        vkEnumeratePhysicalDevices(instance, &deviceCount, &physicalDevice);
+        VkPhysicalDeviceProperties deviceProperties;
+        vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
+        uint32_t major = VK_VERSION_MAJOR(deviceProperties.apiVersion);
+        uint32_t minor = VK_VERSION_MINOR(deviceProperties.apiVersion);
+        uint32_t patch = VK_VERSION_PATCH(deviceProperties.apiVersion);
+        vkDestroyInstance(instance, nullptr);
+        
+        backendVersion = "Vulkan " + std::to_string(major) + "." + 
+                std::to_string(minor)+"." + std::to_string(patch);
+#elif BACKEND_TYPE == BACKEND_GLES
+        backendVersion = std::string((const char*)::GLES::glGetString(GL_VERSION));
+#else
+        backendVersion = "<Unknown Backend>";
+#endif
+
+        MG_Util::Debug::LogI("MobileGL Renderer Info:");
+        MG_Util::Debug::LogI("----%s:", MGName.c_str());
+        MG_Util::Debug::LogI("--------MobileGL Version: %s", MGVersion.c_str());
+        MG_Util::Debug::LogI("--------Target OpenGL Implementation Version: %s", GLVersion.c_str());
+        MG_Util::Debug::LogI("--------Backend: %s", backendName.c_str());
+        MG_Util::Debug::LogI("--------Backend Version: %s", backendVersion.c_str());
+    }
+}

MG/MG_GL/Implementations/GL/Getter/BackendInfo.h

@@ -0,0 +1,16 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_BACKENDINFO_H
+#define MOBILEGL_BACKENDINFO_H
+
+#include "../../../../Includes.h"
+
+namespace MG_GL::Getter {
+    const std::string GetBackendName();
+    const std::string GetMGName();
+    void LogMGInfo();
+}
+
+#endif //MOBILEGL_BACKENDINFO_H

MG/MG_GL/Implementations/GL/Getter/GL_Getter.cpp

@@ -0,0 +1,320 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#include "GL_Getter.h"
+
+namespace MG_GL::GL {
+    static std::string rendererString;
+    static bool loggedMGInfo;
+    const GLubyte* GetString(GLenum name) {
+        if (!loggedMGInfo) {
+            loggedMGInfo = true;
+            MG_GL::Getter::LogMGInfo();
+        }
+        MG_Util::Debug::LogD("glGetString, name: %s", MG_Util::Debug::GLEnumToString(name));
+        switch (name) {
+            case GL_VENDOR: 
+                return (const GLubyte *)"MobileGL-Dev";
+            case GL_VERSION: {
+                static std::string versionStr;
+                if (versionStr.empty()) {
+                    versionStr = std::to_string(MG_Global::GL::GLVersionMajor) + "."
+                            +  std::to_string(MG_Global::GL::GLVersionMinor) + "."
+                            +  std::to_string(MG_Global::GL::GLVersionRevision) 
+                            + " "+ MG_GL::Getter::GetMGName() +
+                            ", MobileGL Core, " + MG_GL::Getter::GetBackendName() + " Backend, Version "
+                            + std::to_string(MG_Global::MG::VersionMajor) + "."
+                            + std::to_string(MG_Global::MG::VersionMinor) + "."
+                            + std::to_string(MG_Global::MG::VersionRevision);
+                    if (MG_Global::MG::VersionPatch != 0)
+                        versionStr += "." + std::to_string(MG_Global::MG::VersionPatch);
+                    versionStr += MG_Global::MG::VersionSuffix;
+                }
+                return (const GLubyte *)versionStr.c_str();
+            }
+
+            case GL_RENDERER:
+            {
+                /*
+                if (rendererString == std::string("")) {
+                    const char* gpuName = getGpuName();
+                    const char* glesName = getGLESName();
+                    rendererString = std::string(gpuName) + " | " + std::string(glesName);
+                }
+                return (const GLubyte *)rendererString.c_str();
+                 */
+                return (const GLubyte *)(MG_GL::Getter::GetMGName() + " (MobileGL Core) Renderer").c_str();
+            }
+            case GL_SHADING_LANGUAGE_VERSION:
+                return (const GLubyte *) "4.50 MobileGL with glslang";
+            case GL_EXTENSIONS:
+                return (const GLubyte *) "OpenGL11 "
+                                         "OpenGL12 "
+                                         "OpenGL13 "
+                                         "OpenGL14 "
+                                         "OpenGL15 "
+                                         "OpenGL20 "
+                                         "OpenGL21 "
+                                         "OpenGL30 ";
+            default:
+                return (const GLubyte *) "Unknown enum";
+        }
+    }
+
+    const GLubyte* GetStringi(GLenum name, GLuint index) {
+        MG_Util::Debug::LogD("glGetStringi, name: %s, index: %d", MG_Util::Debug::GLEnumToString(name), index);
+        if (name != GL_EXTENSIONS)
+            return (const GLubyte*)"";
+        typedef struct {
+            GLenum name;
+            const char** parts;
+            GLuint count;
+        } StringCache;
+        static StringCache caches[] = {
+                {GL_EXTENSIONS, nullptr, 0},
+        };
+        static int initialized = 0;
+        if (!initialized) {
+            for (auto & cache : caches) {
+                GLenum target = cache.name;
+                const GLubyte* str = nullptr;
+                const char* delimiter = " ";
+                str = GetString(GL_EXTENSIONS);
+                
+                char* copy = strdup((const char*)str);
+                char* token = strtok(copy, delimiter);
+                while (token) {
+                    cache.parts = (const char**)realloc(cache.parts, (cache.count + 1) * sizeof(char*));
+                    cache.parts[cache.count++] = strdup(token);
+                    token = strtok(nullptr, delimiter);
+                }
+                free(copy);
+            }
+            initialized = 1;
+        }
+
+        for (auto & cache : caches) {
+            if (cache.name == name) {
+                if (index >= cache.count) {
+                    return nullptr;
+                }
+                return (const GLubyte*)cache.parts[index];
+            }
+        }
+
+        return nullptr;
+    }
+
+    GLenum GetError() {
+        GLenum error = MG_State::GetError();
+        MG_Util::Debug::LogD("glGetError -> %s", MG_Util::Debug::GLEnumToString(error));
+        return error;
+    }
+
+    void GetIntegerv(GLenum pname, GLint *params) {
+        MG_Util::Debug::LogD("glGetIntegerv, pname: %s", MG_Util::Debug::GLEnumToString(pname));
+        if (!params) {
+            MG_State::SetError(GL_INVALID_VALUE);
+            return;
+        }
+
+        switch (pname) {
+            // General
+            case GL_CONTEXT_PROFILE_MASK:
+                params[0] = GL_CONTEXT_CORE_PROFILE_BIT;
+                break;
+            case GL_NUM_EXTENSIONS:
+                static GLint num_extensions = -1;
+                if (num_extensions == -1) {
+                    const GLubyte* ext_str = MG_GL::GL::GetString(GL_EXTENSIONS);
+                    char *copy = strdup((const char *) ext_str);
+                    char *token = strtok(copy, " ");
+                    num_extensions = 0;
+                    while (token) {
+                        num_extensions++;
+                        token = strtok(nullptr, " ");
+                    }
+                    free(copy);
+                }
+                params[0] = num_extensions;
+                break;
+            case GL_MAJOR_VERSION:
+                params[0] = MG_Global::GL::GLVersionMajor;
+                break;
+            case GL_MINOR_VERSION:
+                params[0] = MG_Global::GL::GLVersionMinor;
+                break;
+            
+            // Viewport and scissor
+            case GL_VIEWPORT:
+                memcpy(params, MG_State_T::commonState->viewport, 4 * sizeof(GLint));
+                break;
+            case GL_SCISSOR_BOX:
+                // TODO: memcpy(params, MG_State_T::commonState->scissorBox, 4 * sizeof(GLint));
+                break;
+            case GL_MAX_VIEWPORT_DIMS: {
+                static const GLint maxDims[2] = {16384, 16384};
+                memcpy(params, maxDims, sizeof(maxDims));
+                break;
+            }
+
+            // Buffer bindings
+            case GL_ARRAY_BUFFER_BINDING:
+                params[0] = static_cast<GLint>(MG_State_T::bufferState->GetCurrentBinding(GL_ARRAY_BUFFER));
+                break;
+
+            case GL_ELEMENT_ARRAY_BUFFER_BINDING:
+                params[0] = static_cast<GLint>(MG_State_T::vertexArrayState->GetBoundElementBuffer());
+                break;
+            case GL_DRAW_FRAMEBUFFER_BINDING:
+                params[0] = static_cast<GLint>(MG_State_T::framebufferState->currentBindings_[GL_DRAW_FRAMEBUFFER]);
+                break;
+            case GL_READ_FRAMEBUFFER_BINDING:
+                params[0] = static_cast<GLint>(MG_State_T::framebufferState->currentBindings_[GL_READ_FRAMEBUFFER]);
+                break;
+            case GL_RENDERBUFFER_BINDING:
+                // TODO: params[0] = static_cast<GLint>(MG_State_T::framebufferState->currentRenderbuffer_);
+                break;
+
+            // Program state
+            case GL_CURRENT_PROGRAM:
+                params[0] = static_cast<GLint>(MG_State_T::programState->currentProgram_);
+                break;
+            case GL_MAX_VERTEX_ATTRIBS:
+                // TODO: Check the real value
+                params[0] = 64;
+                break;
+                
+            // Texture state
+            case GL_TEXTURE_BINDING_2D: {
+                GLuint unit = MG_State_T::textureState->activeTextureUnit_;
+                auto& textures = MG_State_T::textureState->textureUnits_[unit].boundTextures;
+                params[0] = textures.count(GL_TEXTURE_2D) ? static_cast<GLint>(textures[GL_TEXTURE_2D]) : 0;
+                break;
+            }
+            case GL_ACTIVE_TEXTURE:
+                params[0] = GL_TEXTURE0 + MG_State_T::textureState->activeTextureUnit_;
+                break;
+            case GL_MAX_TEXTURE_SIZE:
+                params[0] = 8192;
+                break;
+
+            // Blend state
+            case GL_BLEND_SRC_RGB:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->blendSrcRGB);
+                break;
+            case GL_BLEND_DST_RGB:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->blendDstRGB);
+                break;
+            case GL_BLEND_SRC_ALPHA:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->blendSrcAlpha);
+                break;
+            case GL_BLEND_DST_ALPHA:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->blendDstAlpha);
+                break;
+                
+            // Depth and stencil
+            case GL_DEPTH_FUNC:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->depthFunc);
+                break;
+            case GL_DEPTH_WRITEMASK:
+                params[0] = static_cast<GLint>(MG_State_T::commonState->depthMask);
+                break;
+            case GL_STENCIL_REF:
+                // TODO: params[0] = MG_State_T::commonState->stencilRef;
+                break;
+
+            // Capability enables
+            case GL_BLEND:
+                params[0] = MG_State_T::commonState->capabilities[GL_BLEND] ? GL_TRUE : GL_FALSE;
+                break;
+            case GL_DEPTH_TEST:
+                params[0] = MG_State_T::commonState->capabilities[GL_DEPTH_TEST] ? GL_TRUE : GL_FALSE;
+                break;
+            case GL_SCISSOR_TEST:
+                params[0] = MG_State_T::commonState->capabilities[GL_SCISSOR_TEST] ? GL_TRUE : GL_FALSE;
+                break;
+
+            // Pixel operations
+            case GL_PACK_ALIGNMENT:
+                params[0] = MG_State_T::commonState->QueryPixelStoreInt(GL_PACK_ALIGNMENT);
+                break;
+            case GL_UNPACK_ALIGNMENT:
+                params[0] = MG_State_T::commonState->QueryPixelStoreInt(GL_UNPACK_ALIGNMENT);
+                break;
+
+            // Hardware limits, TODO: Check the real values
+            case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
+                params[0] = 32;
+                break;
+            case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
+                params[0] = 32;
+                break;
+            case GL_MAX_TEXTURE_IMAGE_UNITS:
+                params[0] = 32;
+                break;
+            case GL_MAX_RENDERBUFFER_SIZE:
+                params[0] = 65537;
+                break;
+            case GL_MAX_DRAW_BUFFERS:
+                params[0] = 32;
+                break;
+            case GL_MAX_COLOR_ATTACHMENTS:
+                params[0] = 32;
+                break;
+
+            // Color state
+            case GL_COLOR_CLEAR_VALUE: {
+                const auto& c = MG_State_T::commonState->clearColor;
+                params[0] = static_cast<GLint>(c[0] * 0x7FFF);
+                params[1] = static_cast<GLint>(c[1] * 0x7FFF);
+                params[2] = static_cast<GLint>(c[2] * 0x7FFF);
+                params[3] = static_cast<GLint>(c[3] * 0x7FFF);
+                break;
+            }
+            case GL_COLOR_WRITEMASK:
+                params[0] = MG_State_T::commonState->colorMask[0];
+                params[1] = MG_State_T::commonState->colorMask[1];
+                params[2] = MG_State_T::commonState->colorMask[2];
+                params[3] = MG_State_T::commonState->colorMask[3];
+                break;
+
+            // Stencil operations
+            case GL_STENCIL_CLEAR_VALUE:
+                // TODO: params[0] = MG_State_T::commonState->stencilClearValue;
+                break;
+            case GL_STENCIL_BITS:
+                // TODO: Check the real value
+                params[0] = 8;
+                break;
+
+           // Implementation limits
+            case GL_SUBPIXEL_BITS:
+                // TODO: Check the real value
+                params[0] = 4;
+                break;
+            case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
+                // TODO: params[0] = static_cast<GLint>(MG_State_T::textureState->compressedFormats_.size());
+                break;
+            case GL_COMPRESSED_TEXTURE_FORMATS:
+                // TODO: Implement GL_COMPRESSED_TEXTURE_FORMATS
+                break;
+
+           // Polygon state
+            case GL_POLYGON_OFFSET_FACTOR:
+                // TODO: params[0] = static_cast<GLint>(MG_State_T::commonState->polygonOffsetFactor);
+                break;
+            case GL_POLYGON_OFFSET_UNITS:
+                // TODO: params[0] = static_cast<GLint>(MG_State_T::commonState->polygonOffsetUnits);
+                break;
+
+            // Others...
+            default:
+                MG_Util::Debug::LogE("glGetIntegerv: Invalid enum %s (0x%X)", MG_Util::Debug::GLEnumToString(pname), pname);
+                MG_State::SetError(GL_INVALID_ENUM);
+                break;
+        }
+    }
+
+}

MG/MG_GL/Implementations/GL/Getter/GL_Getter.h

@@ -0,0 +1,17 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_GL_GETTER_H
+#define MOBILEGL_GL_GETTER_H
+
+#include "../../../../Includes.h"
+
+namespace MG_GL::GL {
+    const GLubyte* GetString(GLenum name);
+    const GLubyte* GetStringi(GLenum name, GLuint index);
+    GLenum GetError();
+    void GetIntegerv(GLenum pname, GLint *params);
+}
+
+#endif //MOBILEGL_GL_GETTER_H

MG/MG_GL/Implementations/GL/Program/GL_Program.cpp

@@ -0,0 +1,298 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#include "GL_Program.h"
+
+namespace MG_GL::GL {
+    GLuint CreateShader(GLenum type) {
+        MG_Util::Debug::LogD("glCreateShader, type: %s", MG_Util::Debug::GLEnumToString(type));
+        GLuint shader;
+        GLenum result = MG_State::CreateShader(type, &shader);
+        if (result == GL_NO_ERROR) {
+            MG_Util::Debug::LogD("Created shader ID: %u", shader);
+            return shader;
+        }
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error creating shader: %s", MG_Util::Debug::GLEnumToString(result));
+        return 0;
+    }
+
+    GLuint CreateProgram() {
+        MG_Util::Debug::LogD("glCreateProgram");
+        GLuint program;
+        GLenum result = MG_State::CreateProgram(&program);
+        if (result == GL_NO_ERROR) {
+            MG_Util::Debug::LogD("Created program ID: %u", program);
+            return program;
+        }
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error creating program: %s", MG_Util::Debug::GLEnumToString(result));
+        return 0;
+    }
+    
+    void DeleteShader(GLuint shader) {
+        MG_Util::Debug::LogD("glDeleteShader, shader: %u", shader);
+        GLenum result = MG_State::DeleteShader(shader);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error deleting shader: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+    
+    void DeleteProgram(GLuint program) {
+        MG_Util::Debug::LogD("glDeleteProgram, program: %u", program);
+        GLenum result = MG_State::DeleteProgram(program);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error deleting program: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+    
+    void AttachShader(GLuint program, GLuint shader) {
+        MG_Util::Debug::LogD("glAttachShader, program: %u, shader: %u", program, shader);
+        GLenum result = MG_State::LinkShaderToProgram(program, shader);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error attaching shader: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+    
+    void ShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, const GLint* length) {
+        MG_Util::Debug::LogD("glShaderSource, shader: %u, count: %d", shader, count);
+        GLenum result = MG_State::UploadShaderSource(shader, count, (const GLchar **)string, length);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error setting shader source: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+    
+    void CompileShader(GLuint shader) {
+        MG_Util::Debug::LogD("glCompileShader, shader: %u", shader);
+        GLenum result = MG_State::BuildShaderStage(shader);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error compiling shader: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+    
+    void LinkProgram(GLuint program) {
+        MG_Util::Debug::LogD("glLinkProgram, program: %u", program);
+        GLenum result = MG_State::FinalizeProgramPipeline(program);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error linking program: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+    
+    void UseProgram(GLuint program) {
+        MG_Util::Debug::LogD("glUseProgram, program: %u", program);
+        GLenum result = MG_State::ActivateRenderProgram(program);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error using program: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+    
+    void BindAttribLocation(GLuint program, GLuint index, const GLchar* name) {
+        MG_Util::Debug::LogD("glBindAttribLocation, program: %u, index: %u, name: %s", program, index, name);
+        GLenum result = MG_State::DefineProgramAttributeBinding(program, index, name);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error binding attribute: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+    
+    GLint GetAttribLocation(GLuint program, const GLchar* name) {
+        MG_Util::Debug::LogD("glGetAttribLocation, program: %u, name: %s", program, name);
+        GLint location = MG_State::QueryProgramAttributeBinding(program, name);
+        if (location != -1) return location;
+        MG_State::SetError(GL_INVALID_OPERATION);
+        MG_Util::Debug::LogE("Attribute not found: %s", name);
+        return -1;
+    }
+    
+    GLint GetUniformLocation(GLuint program, const GLchar* name) {
+        MG_Util::Debug::LogD("glGetUniformLocation, program: %u, name: %s", program, name);
+        GLint location = MG_State::QueryProgramUniformLocation(program, name);
+        if (location != -1) return location;
+        MG_State::SetError(GL_INVALID_OPERATION);
+        MG_Util::Debug::LogE("Uniform not found: %s", name);
+        return -1;
+    }
+    
+    void GetProgramiv(GLuint program, GLenum pname, GLint* params) {
+        MG_Util::Debug::LogD("glGetProgramiv, program: %u, pname: %s",
+                             program, MG_Util::Debug::GLEnumToString(pname));
+        GLenum result = MG_State::QueryProgramStateIntVector(program, pname, params);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error getting program param: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+    
+    void GetShaderiv(GLuint shader, GLenum pname, GLint* params) {
+        MG_Util::Debug::LogD("glGetShaderiv, shader: %u, pname: %s",
+                             shader, MG_Util::Debug::GLEnumToString(pname));
+        GLenum result = MG_State::QueryShaderStateIntVector(shader, pname, params);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error getting shader param: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void Uniform1f(GLint location, GLfloat v0) {
+        MG_Util::Debug::LogD("glUniform1f, location: %d, v0: %f", location, v0);
+        MG_State::UpdateProgramUniformFloat1(location, v0);
+    }
+
+    void Uniform2f(GLint location, GLfloat v0, GLfloat v1) {
+        MG_Util::Debug::LogD("glUniform2f, location: %d, v0: %f, v1: %f", location, v0, v1);
+        MG_State::UpdateProgramUniformFloat2(location, v0, v1);
+    }
+
+    void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
+        MG_Util::Debug::LogD("glUniform3f, location: %d, v0: %f, v1: %f, v2: %f", location, v0, v1, v2);
+        MG_State::UpdateProgramUniformFloat3(location, v0, v1, v2);
+    }
+
+    void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
+        MG_Util::Debug::LogD("glUniform4f, location: %d, v0: %f, v1: %f, v2: %f, v3: %f", location, v0, v1, v2, v3);
+        MG_State::UpdateProgramUniformFloat4(location, v0, v1, v2, v3);
+    }
+
+    void Uniform1fv(GLint location, GLsizei count, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniform1fv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformFloatVector1(location, count, value);
+    }
+
+    void Uniform2fv(GLint location, GLsizei count, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniform2fv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformFloatVector2(location, count, value);
+    }
+
+    void Uniform3fv(GLint location, GLsizei count, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniform3fv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformFloatVector3(location, count, value);
+    }
+
+    void Uniform4fv(GLint location, GLsizei count, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniform4fv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformFloatVector4(location, count, value);
+    }
+
+    void Uniform1i(GLint location, GLint v0) {
+        MG_Util::Debug::LogD("glUniform1i, location: %d, v0: %d", location, v0);
+        MG_State::UpdateProgramUniformInt1(location, v0);
+    }
+
+    void Uniform2i(GLint location, GLint v0, GLint v1) {
+        MG_Util::Debug::LogD("glUniform2i, location: %d, v0: %d, v1: %d", location, v0, v1);
+        MG_State::UpdateProgramUniformInt2(location, v0, v1);
+    }
+
+    void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2) {
+        MG_Util::Debug::LogD("glUniform3i, location: %d, v0: %d, v1: %d, v2: %d", location, v0, v1, v2);
+        MG_State::UpdateProgramUniformInt3(location, v0, v1, v2);
+    }
+
+    void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
+        MG_Util::Debug::LogD("glUniform4i, location: %d, v0: %d, v1: %d, v2: %d, v3: %d", location, v0, v1, v2, v3);
+        MG_State::UpdateProgramUniformInt4(location, v0, v1, v2, v3);
+    }
+
+    void Uniform1iv(GLint location, GLsizei count, const GLint* value) {
+        MG_Util::Debug::LogD("glUniform1iv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformIntVector1(location, count, value);
+    }
+
+    void Uniform2iv(GLint location, GLsizei count, const GLint* value) {
+        MG_Util::Debug::LogD("glUniform2iv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformIntVector2(location, count, value);
+    }
+
+    void Uniform3iv(GLint location, GLsizei count, const GLint* value) {
+        MG_Util::Debug::LogD("glUniform3iv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformIntVector3(location, count, value);
+    }
+
+    void Uniform4iv(GLint location, GLsizei count, const GLint* value) {
+        MG_Util::Debug::LogD("glUniform4iv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformIntVector4(location, count, value);
+    }
+
+    void Uniform1ui(GLint location, GLuint v0) {
+        MG_Util::Debug::LogD("glUniform1ui, location: %d, v0: %u", location, v0);
+        MG_State::UpdateProgramUniformUInt1(location, v0);
+    }
+
+    void Uniform2ui(GLint location, GLuint v0, GLuint v1) {
+        MG_Util::Debug::LogD("glUniform2ui, location: %d, v0: %u, v1: %u", location, v0, v1);
+        MG_State::UpdateProgramUniformUInt2(location, v0, v1);
+    }
+
+    void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) {
+        MG_Util::Debug::LogD("glUniform3ui, location: %d, v0: %u, v1: %u, v2: %u", location, v0, v1, v2);
+        MG_State::UpdateProgramUniformUInt3(location, v0, v1, v2);
+    }
+
+    void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
+        MG_Util::Debug::LogD("glUniform4ui, location: %d, v0: %u, v1: %u, v2: %u, v3: %u", location, v0, v1, v2, v3);
+        MG_State::UpdateProgramUniformUInt4(location, v0, v1, v2, v3);
+    }
+
+    void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) {
+        MG_Util::Debug::LogD("glUniform1uiv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformUIntVector1(location, count, value);
+    }
+
+    void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) {
+        MG_Util::Debug::LogD("glUniform2uiv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformUIntVector2(location, count, value);
+    }
+
+    void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) {
+        MG_Util::Debug::LogD("glUniform3uiv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformUIntVector3(location, count, value);
+    }
+
+    void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) {
+        MG_Util::Debug::LogD("glUniform4uiv, location: %d, count: %d", location, count);
+        MG_State::UpdateProgramUniformUIntVector4(location, count, value);
+    }
+
+    void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniformMatrix2fv, location: %d, count: %d, transpose: %d", location, count, transpose);
+        MG_State::UpdateProgramUniformMatrix2x2Vector(location, count, transpose, value);
+    }
+
+    void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniformMatrix3fv, location: %d, count: %d, transpose: %d", location, count, transpose);
+        MG_State::UpdateProgramUniformMatrix3x3Vector(location, count, transpose, value);
+    }
+
+    void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniformMatrix4fv, location: %d, count: %d, transpose: %d", location, count, transpose);
+        MG_State::UpdateProgramUniformMatrix4x4Vector(location, count, transpose, value);
+    }
+
+    void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniformMatrix2x3fv, location: %d, count: %d, transpose: %d", location, count, transpose);
+        MG_State::UpdateProgramUniformMatrix2x3Vector(location, count, transpose, value);
+    }
+
+    void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniformMatrix2x4fv, location: %d, count: %d, transpose: %d", location, count, transpose);
+        MG_State::UpdateProgramUniformMatrix2x4Vector(location, count, transpose, value);
+    }
+
+    void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniformMatrix3x2fv, location: %d, count: %d, transpose: %d", location, count, transpose);
+        MG_State::UpdateProgramUniformMatrix3x2Vector(location, count, transpose, value);
+    }
+
+    void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniformMatrix3x4fv, location: %d, count: %d, transpose: %d", location, count, transpose);
+        MG_State::UpdateProgramUniformMatrix3x4Vector(location, count, transpose, value);
+    }
+
+    void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniformMatrix4x2fv, location: %d, count: %d, transpose: %d", location, count, transpose);
+        MG_State::UpdateProgramUniformMatrix4x2Vector(location, count, transpose, value);
+    }
+
+    void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
+        MG_Util::Debug::LogD("glUniformMatrix4x3fv, location: %d, count: %d, transpose: %d", location, count, transpose);
+        MG_State::UpdateProgramUniformMatrix4x3Vector(location, count, transpose, value);
+    }
+}

MG/MG_GL/Implementations/GL/Program/GL_Program.h

@@ -0,0 +1,60 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_GL_PROGRAM_H
+#define MOBILEGL_GL_PROGRAM_H
+
+#include "../../../../Includes.h"
+
+namespace MG_GL::GL {
+    GLuint CreateShader(GLenum type);
+    GLuint CreateProgram();
+    void DeleteShader(GLuint shader);
+    void DeleteProgram(GLuint program);
+    void AttachShader(GLuint program, GLuint shader);
+    void ShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, const GLint* length);
+    void CompileShader(GLuint shader);
+    void LinkProgram(GLuint program);
+    void UseProgram(GLuint program);
+    void BindAttribLocation(GLuint program, GLuint index, const GLchar* name);
+    GLint GetAttribLocation(GLuint program, const GLchar* name);
+    GLint GetUniformLocation(GLuint program, const GLchar* name);
+    void GetProgramiv(GLuint program, GLenum pname, GLint* params);
+    void GetShaderiv(GLuint shader, GLenum pname, GLint* params);
+    void Uniform1f(GLint location, GLfloat v0);
+    void Uniform2f(GLint location, GLfloat v0, GLfloat v1);
+    void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+    void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+    void Uniform1fv(GLint location, GLsizei count, const GLfloat* value);
+    void Uniform2fv(GLint location, GLsizei count, const GLfloat* value);
+    void Uniform3fv(GLint location, GLsizei count, const GLfloat* value);
+    void Uniform4fv(GLint location, GLsizei count, const GLfloat* value);
+    void Uniform1i(GLint location, GLint v0);
+    void Uniform2i(GLint location, GLint v0, GLint v1);
+    void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2);
+    void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+    void Uniform1iv(GLint location, GLsizei count, const GLint* value);
+    void Uniform2iv(GLint location, GLsizei count, const GLint* value);
+    void Uniform3iv(GLint location, GLsizei count, const GLint* value);
+    void Uniform4iv(GLint location, GLsizei count, const GLint* value);
+    void Uniform1ui(GLint location, GLuint v0);
+    void Uniform2ui(GLint location, GLuint v0, GLuint v1);
+    void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
+    void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+    void Uniform1uiv(GLint location, GLsizei count, const GLuint* value);
+    void Uniform2uiv(GLint location, GLsizei count, const GLuint* value);
+    void Uniform3uiv(GLint location, GLsizei count, const GLuint* value);
+    void Uniform4uiv(GLint location, GLsizei count, const GLuint* value);
+    void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+}
+
+#endif //MOBILEGL_GL_PROGRAM_H

MG/MG_GL/Implementations/GL/Texture/GL_Texture.cpp

@@ -0,0 +1,93 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#include "GL_Texture.h"
+
+namespace MG_GL::GL {
+    void ActiveTexture(GLenum texture) {
+        MG_Util::Debug::LogD("glActiveTexture, texture: %d", texture);
+        GLenum result = MG_State::BindTextureUnit(texture);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void BindTexture(GLenum target, GLuint texture) {
+        MG_Util::Debug::LogD("glBindTexture, target: %d, texture: %d", target, texture);
+        GLenum result = MG_State::BindTexture(target, texture);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void DeleteTextures(GLsizei n, const GLuint* textures) {
+        MG_Util::Debug::LogD("glDeleteTextures, n: %d, textures: %p", n, textures);
+        GLenum result = MG_State::DeleteTextures(n, textures);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void GenTextures(GLsizei n, GLuint* textures) {
+        MG_Util::Debug::LogD("glGenTextures, n: %d, textures: %p", n, textures);
+        GLenum result = MG_State::CreateTextures(n, textures);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void TexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, 
+                    GLenum format, GLenum type, const void* data) {
+        MG_Util::Debug::LogD("glTexImage2D, target: %d, level: %d, internalFormat: %d, width: %d, height: %d, format: %d, type: %d, data: %p",
+                             target, level, internalFormat, width, height, format, type, data);
+        GLenum result = MG_State::UploadTexture2D(target, level, internalFormat, width, height, border, format, type, data);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void TexParameterf(GLenum target, GLenum pname, GLfloat param) {
+        MG_Util::Debug::LogD("glTexParameterf, target: %d, pname: %d, param: %f", target, pname, param);
+        GLenum result = MG_State::SetTexturePropertyFloat(target, pname, param);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void TexParameteri(GLenum target, GLenum pname, GLint param) {
+        MG_Util::Debug::LogD("glTexParameteri, target: %d, pname: %d, param: %d", target, pname, param);
+        GLenum result = MG_State::SetTexturePropertyInt(target, pname, param);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
+                       GLsizei height, GLenum format, GLenum type, const void* pixels) {
+        MG_Util::Debug::LogD("glTexSubImage2D, target: %d, level: %d, xoffset: %d, yoffset: %d, width: %d, height: %d, format: %d, type: %d, pixels: %p",
+                             target, level, xoffset, yoffset, width, height, format, type, pixels);
+        GLenum result = MG_State::UpdateTextureRegion2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint* params) {
+        MG_Util::Debug::LogD("glGetTexLevelParameteriv, target: %d, level: %d, pname: %d, params: %p",
+                             target, level, pname, params);
+        GLenum result = MG_State::QueryTextureLevelPropertyIntVector(target, level, pname, params);
+        if (result == GL_NO_ERROR)
+            return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+}

MG/MG_GL/Implementations/GL/Texture/GL_Texture.h

@@ -0,0 +1,22 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_GL_TEXTURE_H
+#define MOBILEGL_GL_TEXTURE_H
+
+#include "../../../../Includes.h"
+
+namespace MG_GL::GL {
+    void ActiveTexture(GLenum texture);
+    void BindTexture(GLenum target, GLuint texture);
+    void DeleteTextures(GLsizei n, const GLuint* textures);
+    void GenTextures(GLsizei n, GLuint* textures);
+    void TexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* data);
+    void TexParameterf(GLenum target, GLenum pname, GLfloat param);
+    void TexParameteri(GLenum target, GLenum pname, GLint param);
+    void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels);
+    void GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint* params);
+}
+
+#endif //MOBILEGL_GL_TEXTURE_H

MG/MG_GL/Implementations/GL/VertexArray/GL_VertexArray.cpp

@@ -0,0 +1,53 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#include "GL_VertexArray.h"
+
+namespace MG_GL::GL {
+    void GenVertexArrays(GLsizei n, GLuint* arrays) {
+        MG_Util::Debug::LogD("glGenVertexArrays, n: %d, arrays: %p", n, arrays);
+        GLenum result = MG_State::GenVertexArraysNames(n, arrays);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void BindVertexArray(GLuint array) {
+        MG_Util::Debug::LogD("glBindVertexArray, array: %u", array);
+        GLenum result = MG_State::BindVertexArray(array);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void EnableVertexAttribArray(GLuint index) {
+        MG_Util::Debug::LogD("glEnableVertexAttribArray, index: %u", index);
+        GLenum result = MG_State::EnableVertexAttribArray(index);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void VertexAttribPointer(GLuint index, GLint size, GLenum type,
+                             GLboolean normalized, GLsizei stride, const void* pointer) {
+        MG_Util::Debug::LogD("glVertexAttribPointer, index: %u, size: %d, type: %s, norm: %d, stride: %d, ptr: %p",
+                             index, size, MG_Util::Debug::GLEnumToString(type), normalized, stride, pointer);
+
+        GLenum result = MG_State::SetVertexAttributeLayout(index, size, type, normalized, stride, pointer);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+
+    void VertexAttribIPointer(GLuint index, GLint size, GLenum type,
+                              GLsizei stride, const void* pointer) {
+        MG_Util::Debug::LogD("glVertexAttribIPointer, index: %u, size: %d, type: %s, stride: %d, ptr: %p",
+                             index, size, MG_Util::Debug::GLEnumToString(type), stride, pointer);
+
+        GLenum result = MG_State::SetVertexAttributeLayoutInt(index, size, type, stride, pointer);
+        if (result == GL_NO_ERROR) return;
+        MG_State::SetError(result);
+        MG_Util::Debug::LogE("Error from MG State: %s", MG_Util::Debug::GLEnumToString(result));
+    }
+}

MG/MG_GL/Implementations/GL/VertexArray/GL_VertexArray.h

@@ -0,0 +1,18 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_GL_VERTEXARRAY_H
+#define MOBILEGL_GL_VERTEXARRAY_H
+
+#include "../../../../Includes.h"
+
+namespace MG_GL::GL {
+    void GenVertexArrays(GLsizei n, GLuint* arrays);
+    void BindVertexArray(GLuint array);
+    void EnableVertexAttribArray(GLuint index);
+    void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer);
+    void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer);
+}
+
+#endif //MOBILEGL_GL_VERTEXARRAY_H

MG/MG_GL/Implementations/GLX/LookUp/LookUp.cpp

@@ -0,0 +1,24 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#include "LookUp.h"
+
+#include "../../../../Includes.h"
+
+namespace MG_GL::GLX {
+    void* GetProcAddress(const char *name) {
+        void* proc = dlsym(RTLD_DEFAULT, (const char*)name);
+
+        if (!proc) {
+            MG_Util::Debug::LogW("Failed to get function: %s", (const char*)name);
+            return nullptr;
+        }
+
+        return proc;
+    }
+
+    void* GetProcAddressARB(const char *name) {
+        return GetProcAddress(name);
+    }
+}

MG/MG_GL/Implementations/GLX/LookUp/LookUp.h

@@ -0,0 +1,12 @@
+//
+// Created by BZLZHH on 2025/3/15.
+//
+
+#ifndef MOBILEGL_LOOKUP_H
+#define MOBILEGL_LOOKUP_H
+
+namespace MG_GL::GLX {
+    void* GetProcAddress(const char *name);
+    void* GetProcAddressARB(const char *name);
+}
+#endif //MOBILEGL_LOOKUP_H

MG/MG_GL/State/Buffer/BufferState.cpp

@@ -0,0 +1,328 @@
+//
+// Created by BZLZHH on 2025/5/1.
+//
+
+// TODO: Add more gl error check for buffer state manager.
+
+#include "BufferState.h"
+
+GLenum BufferState::GenName(GLuint *buffer) {
+    MG_Util::Debug::LogD("MG_State: Buffer: GenName");
+    if (!buffer)
+        return GL_INVALID_VALUE;
+
+    GLuint id = 0;
+    if (freeId_.empty()) {
+        id = lastId_++;
+    } else {
+        id = freeId_.back();
+        freeId_.pop_back();
+    }
+
+    *buffer = id;
+    MG_Util::Debug::LogD("MG_State: Buffer: Gen new name %d", id);
+
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::GenNameN(GLsizei n, GLuint* buffers) {
+    MG_Util::Debug::LogD("MG_State: Buffer: GenNameN called with n=%d", n);
+    if (n < 0) return GL_INVALID_VALUE;
+
+    for (GLsizei i = 0; i < n; ++i) {
+        GLenum result = GenName(&buffers[i]);
+        if (result != GL_NO_ERROR) {
+            MG_Util::Debug::LogE("MG_State: Buffer: GenNameN failed with error 0x%x", result);
+            return result;
+        }
+    }
+    MG_Util::Debug::LogD("MG_State: Buffer: GenNameN created buffers successfully");
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::Create(GLuint buffer) {
+    MG_Util::Debug::LogD("MG_State: Buffer: Create called");
+    if (!buffer)
+        return GL_INVALID_VALUE;
+
+    if (ValidateAllocatedHandle(buffer))
+        return GL_INVALID_VALUE;
+
+    BufferObject& obj = buffers_[buffer];
+    MG_Util::Debug::LogD("MG_State: Buffer: Create created buffer %d", buffer);
+    obj.generated = true;
+    obj.dirty = true;
+
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::Bind(GLenum target, GLuint buffer) {
+    // We don't handle unallocated buffer names here, just plain bind
+    if (!IsValidTarget_(target)) return GL_INVALID_ENUM;
+    MG_Util::Debug::LogD("MG_State: Buffer: Bind called with target=%s, buffer=%u", MG_Util::Debug::GLEnumToString(target), buffer);
+    currentBindings_[target] = buffer;
+    MG_Util::Debug::LogD("MG_State: Buffer: Bind succeed bind buffer %u to target 0x%x", buffer, target);
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::CommitStorage(GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
+    MG_Util::Debug::LogD("MG_State: Buffer: CommitStorage called on target 0x%x",target);
+    auto it = currentBindings_.find(target);
+    if (it == currentBindings_.end() || it->second == 0)
+        return GL_INVALID_OPERATION;
+
+    BufferObject& obj = buffers_[it->second];
+    MG_Util::Debug::LogD("MG_State: Buffer: CommitStorage get buffer object %u at target 0x%x",it->second,target);
+    obj.usage = usage;
+    obj.data.resize(size);
+    if (data) {
+        memcpy(obj.data.data(), data, size);
+        obj.dataValid = true;
+    }
+    obj.dirty = true;
+    MG_Util::Debug::LogD("MG_State: Buffer: CommitStorage buffer at target 0x%x committed storage, size = %zu, usage=0x%x", target, size, usage);
+
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::CommitStorageRegion(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
+    MG_Util::Debug::LogD("MG_State: Buffer: BufferSubData called on target 0x%x, offset=%ld, size=%ld", target, offset, size);
+    if (!IsValidTarget_(target)) return GL_INVALID_ENUM;
+    if (offset < 0 || size < 0) return GL_INVALID_VALUE;
+
+    auto it = currentBindings_.find(target);
+    if (it == currentBindings_.end() || it->second == 0)
+        return GL_INVALID_OPERATION;
+
+    BufferObject& obj = buffers_[it->second];
+    MG_Util::Debug::LogD("MG_State: Buffer: BufferSubData get buffer object %u at target 0x%x", it->second, target);
+
+    if (static_cast<size_t>(offset + size) > obj.data.size()) return GL_INVALID_VALUE;
+
+    if (data) {
+        memcpy(obj.data.data() + offset, data, size);
+        obj.dirty = true;
+    }
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer) {
+    MG_Util::Debug::LogD("MG_State: Buffer: AcquireBufferMemoryRange called with target=0x%x, offset=%ld, length=%ld, access=0x%x", target, offset, length, access);
+    if (!IsValidTarget_(target)) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: invalid target 0x%x", target);
+        return GL_INVALID_ENUM;
+    }
+    if (offset < 0 || length <= 0) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: invalid offset %ld or length %ld", offset, length);
+        return GL_INVALID_VALUE;
+    }
+
+    auto it = currentBindings_.find(target);
+    if (it == currentBindings_.end() || it->second == 0) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: no buffer bound to target 0x%x", target);
+        return GL_INVALID_OPERATION;
+    }
+
+    BufferObject& obj = buffers_[it->second];
+    MG_Util::Debug::LogD("MG_State: Buffer: AcquireBufferMemoryRange operating on buffer %u", it->second);
+    if (obj.isMapped) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: buffer %u is already mapped", it->second);
+        return GL_INVALID_OPERATION;
+    }
+
+    const GLbitfield validFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT ;
+    if ((access & ~validFlags) != 0) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: invalid access flags 0x%x", access);
+        return GL_INVALID_VALUE;
+    }
+
+    if (static_cast<size_t>(offset + length) > obj.data.size()) {
+        MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: requested range [%ld, %ld) exceeds buffer size %zu", offset, offset + length, obj.data.size());
+        return GL_INVALID_VALUE;
+    }
+
+    obj.isMapped = true;
+    obj.mapOffset = offset;
+    obj.mapLength = length;
+    obj.mapAccessFlags = access;
+    obj.dirty = true;
+    *mappedPointer = obj.data.data() + offset;
+    MG_Util::Debug::LogD("MG_State: Buffer: AcquireBufferMemoryRange succeeded for buffer %u. Mapped pointer: %p", it->second, *mappedPointer);
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length) {
+    if (!IsValidTarget_(target)) return GL_INVALID_ENUM;
+    if (offset < 0 || length <= 0) return GL_INVALID_VALUE;
+
+    auto it = currentBindings_.find(target);
+    if (it == currentBindings_.end() || it->second == 0)
+        return GL_INVALID_OPERATION;
+
+    BufferObject& obj = buffers_[it->second];
+    if (!obj.isMapped || !(obj.mapAccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT))
+        return GL_INVALID_OPERATION;
+
+    if (offset < obj.mapOffset || offset + length > obj.mapOffset + obj.mapLength)
+        return GL_INVALID_VALUE;
+
+    // TODO: Add support for flush range.
+    // Now only mark it as dirty.
+    obj.dirty = true;
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
+    if (!IsValidTarget_(readTarget) || !IsValidTarget_(writeTarget))
+        return GL_INVALID_ENUM;
+    if (readOffset < 0 || writeOffset < 0 || size < 0)
+        return GL_INVALID_VALUE;
+
+    GLuint readBuffer = currentBindings_[readTarget];
+    GLuint writeBuffer = currentBindings_[writeTarget];
+    if (readBuffer == 0 || writeBuffer == 0 || readBuffer == writeBuffer)
+        return GL_INVALID_OPERATION;
+
+    BufferObject& src = buffers_[readBuffer];
+    BufferObject& dst = buffers_[writeBuffer];
+
+    if (static_cast<size_t>(readOffset + size) > src.data.size() ||
+        static_cast<size_t>(writeOffset + size) > dst.data.size())
+        return GL_INVALID_VALUE;
+
+    memcpy(dst.data.data() + writeOffset, src.data.data() + readOffset, size);
+    dst.dirty = true;
+    return GL_NO_ERROR;
+}
+
+GLenum BufferState::AcquireBufferMemory(GLenum target, GLenum access, void** mappedPointer) {
+    GLbitfield flags = 0;
+    switch (access) {
+        case GL_READ_ONLY:  flags = GL_MAP_READ_BIT; break;
+        case GL_WRITE_ONLY: flags = GL_MAP_WRITE_BIT; break;
+        case GL_READ_WRITE: flags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT; break;
+        default:
+            flags = access;
+    }
+    return AcquireBufferMemoryRange(target, 0, buffers_[currentBindings_[target]].data.size(), flags, mappedPointer);
+}
+
+GLenum BufferState::ReleaseBufferMemory(GLenum target) {
+    if (!IsValidTarget_(target))
+        return GL_INVALID_ENUM;
+
+    auto it = currentBindings_.find(target);
+    if (it == currentBindings_.end() || it->second == 0)
+        return GL_INVALID_OPERATION;
+
+    BufferObject& obj = buffers_[it->second];
+    if (!obj.isMapped)
+        return GL_INVALID_OPERATION;
+
+    if ((obj.mapAccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT) == 0) {
+        obj.dirty = true;
+    }
+
+    obj.isMapped = false;
+    obj.mapOffset = 0;
+    obj.mapLength = 0;
+    obj.mapAccessFlags = 0;
+    obj.accessMode = GL_READ_WRITE;
+
+    return GL_NO_ERROR;
+}
+
+bool BufferState::ValidateAllocatedHandle(GLuint buffer) {
+    bool isValid = buffers_.find(buffer) != buffers_.end();
+    MG_Util::Debug::LogD("MG_State: Buffer: ValidateAllocatedHandle called on buffer %u returns %d", buffer, isValid);
+    return isValid;
+}
+
+bool BufferState::ValidateGeneratedName(GLuint buffer) {
+    bool inFreeList = std::find(freeId_.begin(), freeId_.end(), buffer) != freeId_.end();
+    bool lessThanLast = buffer < lastId_; // lastId_ is not generated yet
+    MG_Util::Debug::LogD("MG_State: Buffer: ValidateGeneratedName called on buffer %u returns %d", buffer, lessThanLast && !inFreeList);
+    return lessThanLast && !inFreeList;
+}
+
+void BufferState::Delete(GLuint buffer) {
+    buffers_.erase(buffer);
+    if (ValidateGeneratedName(buffer))
+        // TODO: Prevent the object that uses a freeId from conflicting with legacy object in the backend.
+        //freeId_.emplace_back(buffer);
+    for (auto& [target, id] : currentBindings_) {
+        if (id == buffer) id = 0;
+    }
+    MG_Util::Debug::LogD("MG_State: Buffer: Delete buffer %u", buffer);
+}
+
+GLenum BufferState::DeleteN(GLsizei n, const GLuint* buffers) {
+    MG_Util::Debug::LogD("MG_State: Buffer: DeleteN called with n=%d", n);
+    if (n < 0) return GL_INVALID_VALUE;
+
+    for (GLsizei i = 0; i < n; ++i) {
+        Delete(buffers[i]);
+    }
+    MG_Util::Debug::LogD("MG_State: Buffer: DeleteN deleted buffers successfully");
+    return GL_NO_ERROR;
+}
+
+bool BufferState::IsValidTarget_(GLenum target) {
+    MG_Util::Debug::LogD("MG_State: Buffer: IsValidTarget_ called with target=0x%x,result=%d", target, !(MG_Constants::Buffer::VALID_TARGETS.find(target) == MG_Constants::Buffer::VALID_TARGETS.end()));
+    return !(MG_Constants::Buffer::VALID_TARGETS.find(target) == MG_Constants::Buffer::VALID_TARGETS.end());
+}
+
+GLenum BufferState::QueryPropertyIntVector(GLenum target, GLenum pname, GLint* params) const {
+    MG_Util::Debug::LogD("MG_State: Buffer: QueryPropertyIntVector called at target 0x%x,param name = 0x%x",target,pname);
+    static const std::set<GLenum> validTargets = {
+            GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER,
+            GL_PIXEL_PACK_BUFFER, GL_PIXEL_UNPACK_BUFFER
+    };
+    if (validTargets.find(target) == validTargets.end()) {
+        return GL_INVALID_ENUM;
+    }
+    
+    if (MG_Constants::Buffer::VALID_PARAM_NAMES.find(pname) == MG_Constants::Buffer::VALID_PARAM_NAMES.end()) {
+        return GL_INVALID_ENUM;
+    }
+    
+    auto bindingIt = currentBindings_.find(target);
+    if (bindingIt == currentBindings_.end() || bindingIt->second == 0) {
+        return GL_INVALID_OPERATION;
+    }
+    GLuint bufferId = bindingIt->second;
+    auto bufferIt = buffers_.find(bufferId);
+    if (bufferIt == buffers_.end()) {
+        return GL_INVALID_OPERATION;
+    }
+    
+    const BufferObject& buffer = bufferIt->second;
+    
+    switch (pname) {
+        case GL_BUFFER_ACCESS:
+            *params = static_cast<GLint>(buffer.accessMode);
+            break;
+        case GL_BUFFER_MAPPED:
+            *params = buffer.isMapped ? GL_TRUE : GL_FALSE;
+            break;
+        case GL_BUFFER_SIZE:
+            *params = static_cast<GLint>(buffer.data.size());
+            break;
+        case GL_BUFFER_USAGE:
+            *params = static_cast<GLint>(buffer.usage);
+            break;
+        MG_Util::Debug::LogD("MG_State: Buffer: QueryPropertyIntVector Query info about buffer %u succeed", target);
+        default:
+            return GL_INVALID_ENUM;
+    }
+    return GL_NO_ERROR;
+}
+
+
+GLuint BufferState::GetCurrentBinding(GLenum target) const {
+    auto it = currentBindings_.find(target);
+    if (it != currentBindings_.end()) {
+        return it->second;
+    }
+    return 0;
+}

MG/MG_GL/State/Buffer/BufferState.h

@@ -0,0 +1,58 @@
+//
+// Created by BZLZHH on 2025/5/1.
+//
+
+#ifndef MOBILEGL_BUFFERSTATE_H
+#define MOBILEGL_BUFFERSTATE_H
+#define MOBILEGL_GLSTATE_H
+
+#include "../../../Includes.h"
+
+class BufferState {
+    template <typename K, typename V>
+    using unordered_map = ankerl::unordered_dense::map<K, V>;
+
+public:
+    struct BufferObject {
+        GLenum usage = GL_STATIC_DRAW;
+        std::vector<GLubyte> data;
+        bool dataValid = false;
+        bool dirty = false; // TODO: encapsulate this with an public API to RHI
+        bool isMapped = false;
+        bool generated = false;
+        GLenum accessMode = GL_READ_WRITE;
+        GLintptr mapOffset = 0;
+        GLsizeiptr mapLength = 0;
+        GLbitfield mapAccessFlags = 0;
+    };
+
+    // Return: the validity of the operation, according to OpenGL 3 standard
+    GLenum GenName(GLuint* buffer);
+    GLenum GenNameN(GLsizei n, GLuint* buffers);
+    GLenum Create(GLuint buffer);
+    GLenum Bind(GLenum target, GLuint buffer);
+    GLenum CommitStorage(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
+    GLenum CommitStorageRegion(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
+    GLenum AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer);
+    GLenum SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length);
+    GLenum CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+    GLenum AcquireBufferMemory(GLenum target, GLenum access, void** mappedPointer);
+    GLenum ReleaseBufferMemory(GLenum target);
+    GLenum QueryPropertyIntVector(GLenum target, GLenum pname, GLint* params) const;
+    GLenum DeleteN(GLsizei n, const GLuint* buffers);
+    
+    bool ValidateAllocatedHandle(GLuint buffer);
+    bool ValidateGeneratedName(GLuint buffer);
+    void Delete(GLuint buffer);
+    GLuint GetCurrentBinding(GLenum target) const;
+
+    unordered_map<GLenum, GLuint> currentBindings_;
+    unordered_map<GLuint, BufferObject> buffers_;
+private:
+    std::vector<GLuint> freeId_;
+    GLuint lastId_ = 1;
+
+    static bool IsValidTarget_(GLenum target);
+};
+
+#endif //MOBILEGL_BUFFERSTATE_H

MG/MG_GL/State/Common/CommonState.cpp

@@ -0,0 +1,158 @@
+//
+// Created by BZLZHH on 2025/4/30.
+//
+
+#include "CommonState.h"
+
+CommonState::CommonState() {
+    pixelStoreParams[GL_PACK_ALIGNMENT] = 4;
+    pixelStoreParams[GL_UNPACK_ALIGNMENT] = 4;
+}
+
+GLenum CommonState::SetPixelStoreInt(GLenum pname, GLint param) {
+    if (MG_Constants::PixelStore::VALID_PARAM_NAMES.find(pname) == MG_Constants::PixelStore::VALID_PARAM_NAMES.end()) {
+        return GL_INVALID_ENUM;
+    }
+
+    switch (pname) {
+        case GL_PACK_SWAP_BYTES:
+        case GL_PACK_LSB_FIRST:
+        case GL_UNPACK_SWAP_BYTES:
+        case GL_UNPACK_LSB_FIRST:
+            break;
+        case GL_PACK_ROW_LENGTH:
+        case GL_PACK_IMAGE_HEIGHT:
+        case GL_PACK_SKIP_ROWS:
+        case GL_PACK_SKIP_PIXELS:
+        case GL_PACK_SKIP_IMAGES:
+        case GL_UNPACK_ROW_LENGTH:
+        case GL_UNPACK_IMAGE_HEIGHT:
+        case GL_UNPACK_SKIP_ROWS:
+        case GL_UNPACK_SKIP_PIXELS:
+        case GL_UNPACK_SKIP_IMAGES:
+            if (param < 0) {
+                return GL_INVALID_VALUE;
+            }
+            break;
+
+        case GL_PACK_ALIGNMENT:
+        case GL_UNPACK_ALIGNMENT:
+            if (param != 1 && param != 2 && param != 4 && param != 8) {
+                return GL_INVALID_VALUE;
+            }
+            break;
+
+        default:
+            return GL_INVALID_ENUM;
+    }
+
+    pixelStoreParams[pname] = param;
+    return GL_NO_ERROR;
+}
+
+GLint CommonState::QueryPixelStoreInt(GLenum pname) {
+    auto it = pixelStoreParams.find(pname);
+    if (it != pixelStoreParams.end()) {
+        return it->second;
+    }
+
+    auto defaultIt = MG_Constants::PixelStore::DEFAULT_VALUES_MAP.find(pname);
+    return (defaultIt != MG_Constants::PixelStore::DEFAULT_VALUES_MAP.end()) ? defaultIt->second : 0;
+}
+
+GLenum CommonState::Enable(GLenum cap) {
+    if (MG_Constants::CommonState::VALID_CAPS.find(cap) == MG_Constants::CommonState::VALID_CAPS.end()) {
+        return GL_INVALID_ENUM;
+    }
+    capabilities[cap] = true;
+    return GL_NO_ERROR;
+}
+
+GLenum CommonState::Disable(GLenum cap) {
+    if (MG_Constants::CommonState::VALID_CAPS.find(cap) == MG_Constants::CommonState::VALID_CAPS.end()) {
+        return GL_INVALID_ENUM;
+    }
+    capabilities[cap] = false;
+    return GL_NO_ERROR;
+}
+
+GLenum CommonState::BlendFunc(GLenum sfactor, GLenum dfactor) {
+    if (MG_Constants::Blend::VALID_FACTORS.find(sfactor) == MG_Constants::Blend::VALID_FACTORS.end() ||
+        MG_Constants::Blend::VALID_FACTORS.find(dfactor) == MG_Constants::Blend::VALID_FACTORS.end()) {
+        return GL_INVALID_ENUM;
+    }
+
+    blendSrcRGB = blendSrcAlpha = sfactor;
+    blendDstRGB = blendDstAlpha = dfactor;
+    return GL_NO_ERROR;
+}
+
+GLenum CommonState::BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB,
+                                      GLenum srcAlpha, GLenum dstAlpha) {
+    if (MG_Constants::Blend::VALID_FACTORS.find(srcRGB) == MG_Constants::Blend::VALID_FACTORS.end() ||
+        MG_Constants::Blend::VALID_FACTORS.find(dstRGB) == MG_Constants::Blend::VALID_FACTORS.end() ||
+        MG_Constants::Blend::VALID_FACTORS.find(srcAlpha) == MG_Constants::Blend::VALID_FACTORS.end() ||
+        MG_Constants::Blend::VALID_FACTORS.find(dstAlpha) == MG_Constants::Blend::VALID_FACTORS.end()) {
+        return GL_INVALID_ENUM;
+    }
+    blendSrcRGB = srcRGB;
+    blendDstRGB = dstRGB;
+    blendSrcAlpha = srcAlpha;
+    blendDstAlpha = dstAlpha;
+    return GL_NO_ERROR;
+}
+
+GLenum CommonState::Clear(GLbitfield mask) {
+    const GLbitfield validBits = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
+    if ((mask & ~validBits) != 0) {
+        return GL_INVALID_VALUE;
+    }
+    clearMask = mask;
+    return GL_NO_ERROR;
+}
+
+GLenum CommonState::ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
+    clearColor[0] = red;
+    clearColor[1] = green;
+    clearColor[2] = blue;
+    clearColor[3] = alpha;
+    return GL_NO_ERROR;
+}
+
+GLenum CommonState::ClearDepth(GLfloat depth) {
+    clearDepth = depth;
+    return GL_NO_ERROR;
+}
+
+GLenum CommonState::ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
+    colorMask[0] = red;
+    colorMask[1] = green;
+    colorMask[2] = blue;
+    colorMask[3] = alpha;
+    return GL_NO_ERROR;
+}
+
+GLenum CommonState::DepthFunc(GLenum func) {
+    if (MG_Constants::Depth::VALID_FUNCS.find(func) == MG_Constants::Depth::VALID_FUNCS.end()) {
+        return GL_INVALID_ENUM;
+    }
+    depthFunc = func;
+    return GL_NO_ERROR;
+}
+
+GLenum CommonState::DepthMask(GLboolean flag) {
+    depthMask = flag;
+    return GL_NO_ERROR;
+}
+
+GLenum CommonState::Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
+    if (width < 0 || height < 0) {
+        return GL_INVALID_VALUE;
+    }
+
+    viewport[0] = x;
+    viewport[1] = y;
+    viewport[2] = width;
+    viewport[3] = height;
+    return GL_NO_ERROR;
+}

MG/MG_GL/State/Common/CommonState.h

@@ -0,0 +1,65 @@
+//
+// Created by BZLZHH on 2025/4/30.
+//
+
+#ifndef MOBILEGL_COMMONSTATE_H
+#define MOBILEGL_COMMONSTATE_H
+#define MOBILEGL_GLSTATE_H
+
+#include "../../../Includes.h"
+
+class CommonState {
+    template <typename K, typename V>
+    using unordered_map = ankerl::unordered_dense::map<K, V>;
+public:
+    // Viewport
+    GLint viewport[4] = {0, 0, 0, 0};
+    
+    // Color mask
+    GLboolean colorMask[4] = {GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE};
+    
+    // Pixel storage parameters
+    unordered_map<GLenum, GLint> pixelStoreParams;
+
+    // Blend state
+    GLenum blendSrcRGB = GL_ONE;
+    GLenum blendDstRGB = GL_ZERO;
+    GLenum blendSrcAlpha = GL_ONE;
+    GLenum blendDstAlpha = GL_ZERO;
+    
+    // Clear state
+    GLfloat clearColor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+    GLfloat clearDepth = 1.0f;
+    GLenum clearMask;
+
+    // Depth state
+    GLenum depthFunc = GL_LESS;
+    GLboolean depthMask = GL_TRUE;
+
+    // Capability enables
+    unordered_map<GLenum, bool> capabilities;
+    
+    CommonState();
+    
+    // Return: the validity of the operation, according to OpenGL 3 standard
+    GLenum SetPixelStoreInt(GLenum pname, GLint param);
+
+    GLenum Enable(GLenum cap);
+    GLenum Disable(GLenum cap);
+    GLenum BlendFunc(GLenum sfactor, GLenum dfactor);
+    GLenum BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB,
+                             GLenum srcAlpha, GLenum dstAlpha);
+    GLenum Clear(GLbitfield mask);
+    GLenum ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+    GLenum ClearDepth(GLfloat depth);
+    GLenum ColorMask(GLboolean red, GLboolean green,
+                     GLboolean blue, GLboolean alpha);
+    GLenum DepthFunc(GLenum func);
+    GLenum DepthMask(GLboolean flag);
+    GLenum Viewport(GLint x, GLint y, GLsizei width, GLsizei height);
+    
+    GLint QueryPixelStoreInt(GLenum pname);
+
+};
+
+#endif //MOBILEGL_COMMONSTATE_H

MG/MG_GL/State/Core/GLState.cpp

@@ -0,0 +1,407 @@
+//
+// Created by BZLZHH on 2025/4/4.
+//
+
+#include "GLState.h"
+
+std::queue<GLenum> MG_State_T::glErrorQueue;
+TextureState* MG_State_T::textureState = nullptr;
+CommonState* MG_State_T::commonState = nullptr;
+BufferState* MG_State_T::bufferState = nullptr;
+VertexArrayState* MG_State_T::vertexArrayState = nullptr;
+ProgramState* MG_State_T::programState = nullptr;
+FramebufferState* MG_State_T::framebufferState = nullptr;
+
+namespace MG_State {
+    void Init() {
+        MG_State_T::textureState = new TextureState();
+        MG_State_T::commonState = new CommonState();
+        MG_State_T::bufferState = new BufferState();
+        MG_State_T::vertexArrayState = new VertexArrayState();
+        MG_State_T::programState = new ProgramState();
+        MG_State_T::framebufferState = new FramebufferState();
+    }
+    
+    void Destroy() {
+        delete MG_State_T::textureState;
+        delete MG_State_T::commonState;
+        delete MG_State_T::bufferState;
+        delete MG_State_T::vertexArrayState;
+        delete MG_State_T::programState;
+        delete MG_State_T::framebufferState;
+    }
+    
+    void SetError(GLenum error) {
+        if (error == GL_NO_ERROR) {
+            return;
+        }
+        MG_State_T::glErrorQueue.push(error);
+    }
+
+    GLenum GetError() {
+        if (MG_State_T::glErrorQueue.empty()) {
+            return GL_NO_ERROR;
+        }
+        GLenum error = MG_State_T::glErrorQueue.front();
+        MG_State_T::glErrorQueue.pop();
+        return error;
+    }
+
+// TODO: Take these functions apart into multiple files.
+
+    // Texture
+    GLenum BindTextureUnit(GLenum textureUnit) {
+        return MG_State_T::textureState->BindUnit(textureUnit);
+    }
+    
+    GLenum CreateTexture(GLuint* texture) {
+        return MG_State_T::textureState->Create(texture);
+    }
+    
+    GLenum CreateTextures(GLsizei n, GLuint* textures) {
+        return MG_State_T::textureState->CreateN(n, textures);
+    }
+    
+    GLenum BindTexture(GLenum target, GLuint texture) {
+        return MG_State_T::textureState->Bind(target, texture);
+    }
+    
+    GLenum UploadTexture2D(GLenum target, GLint level, GLint internalFormat,
+                           GLsizei width, GLsizei height, GLint border, GLenum format,
+                           GLenum type, const void* data) {
+        return MG_State_T::textureState->Upload2D(target, level, internalFormat, width, height, border, format, type, data);
+    }
+
+    GLenum UpdateTextureRegion2D(GLenum target, GLint level, GLint xoffset,
+                                 GLint yoffset, GLsizei width, GLsizei height, GLenum format,
+                                 GLenum type, const GLvoid* data) {
+        return MG_State_T::textureState->UpdateRegion2D(target, level, xoffset, yoffset, width, height, format, type, data);
+    }
+    
+    GLenum SetTexturePropertyInt(GLenum target, GLenum pname, GLint param) {
+        return MG_State_T::textureState->SetTexturePropertyInt(target, pname, param);
+    }
+    
+    GLenum SetTexturePropertyFloat(GLenum target, GLenum pname, GLfloat param) {
+        return MG_State_T::textureState->SetTexturePropertyFloat(target, pname, param);
+    }
+    
+    GLenum DeleteTexture(GLuint texture) {
+        return MG_State_T::textureState->Delete(texture);
+    }
+    
+    GLenum DeleteTextures(GLsizei n, const GLuint* textures) { 
+        return MG_State_T::textureState->DeleteN(n, textures);
+    }
+    
+    GLenum QueryTextureLevelPropertyIntVector(GLenum target, GLint level, GLenum pname, GLint* params) {
+        return MG_State_T::textureState->QueryLevelPropertyIntVector(target, level, pname, params);
+    }
+    
+    // Common
+    GLenum SetPixelStoreInt(GLenum pname, GLint param) {
+        return MG_State_T::commonState->SetPixelStoreInt(pname, param);
+    }
+
+    GLint QueryPixelStoreInt(GLenum pname) {
+        return MG_State_T::commonState->QueryPixelStoreInt(pname);
+    }
+    
+    GLenum glEnable(GLenum cap) {
+        return MG_State_T::commonState->Enable(cap);
+    }
+
+    GLenum glDisable(GLenum cap) {
+        return MG_State_T::commonState->Disable(cap);
+    }
+
+    GLenum glBlendFunc(GLenum sfactor, GLenum dfactor) {
+        return MG_State_T::commonState->BlendFunc(sfactor, dfactor);
+    }
+
+    GLenum glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
+        return MG_State_T::commonState->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+    }
+
+    GLenum glClear(GLbitfield mask) {
+        return MG_State_T::commonState->Clear(mask);
+    }
+
+    GLenum glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
+        return MG_State_T::commonState->ClearColor(red, green, blue, alpha);
+    }
+
+    GLenum glClearDepth(GLdouble depth) {
+        return MG_State_T::commonState->ClearDepth(static_cast<GLfloat>(depth));
+    }
+
+    GLenum glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
+        return MG_State_T::commonState->ColorMask(red, green, blue, alpha);
+    }
+
+    GLenum glDepthFunc(GLenum func) {
+        return MG_State_T::commonState->DepthFunc(func);
+    }
+
+    GLenum glDepthMask(GLboolean flag) {
+        return MG_State_T::commonState->DepthMask(flag);
+    }
+
+    GLenum glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
+        return MG_State_T::commonState->Viewport(x, y, width, height);
+    }
+
+    // Buffer
+    GLenum AcquireBufferMemory(GLenum target, GLenum access, void** mappedPtr) {
+        return MG_State_T::bufferState->AcquireBufferMemory(target, access, mappedPtr);
+    }
+    
+    GLenum AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer) {
+        return MG_State_T::bufferState->AcquireBufferMemoryRange(target, offset, length, access, mappedPointer);
+    }
+
+    GLenum SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length) {
+        return MG_State_T::bufferState->SyncBufferMemory(target, offset, length);
+    }
+
+    GLenum CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
+        return MG_State_T::bufferState->CopyBufferRange(readTarget, writeTarget, readOffset,
+                                                        writeOffset, size);
+    }
+
+    GLenum ReleaseBufferMemory(GLenum target) {
+        return MG_State_T::bufferState->ReleaseBufferMemory(target);
+    }
+
+    GLenum CreateBuffer(GLuint buffer) {
+        return MG_State_T::bufferState->Create(buffer);
+    }
+
+    GLenum GenBufferNames(GLsizei n, GLuint* buffers) {
+        return MG_State_T::bufferState->GenNameN(n, buffers);
+    }
+
+    GLenum BindBuffer(GLenum target, GLuint buffer) {
+        if (target == GL_ELEMENT_ARRAY_BUFFER) {
+            auto* vao = MG_State_T::vertexArrayState->GetCurrentVAO();
+            if (!vao) return GL_INVALID_OPERATION;
+            vao->elementBuffer = (GLuint)buffer;
+            vao->eboDirty = true;
+        }
+        return MG_State_T::bufferState->Bind(target, buffer);
+    }
+
+    GLenum CommitBufferStorage(GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
+        return MG_State_T::bufferState->CommitStorage(target, size, data, usage);
+    }
+
+    GLenum CommitBufferStorageRegion(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
+        return MG_State_T::bufferState->CommitStorageRegion(target, offset, size, data);
+    }
+
+    bool ValidateAllocatedBufferHandle(GLuint buffer) {
+        return MG_State_T::bufferState->ValidateAllocatedHandle(buffer);
+    }
+
+    bool ValidateGeneratedName(GLuint buffer) {
+        return MG_State_T::bufferState->ValidateGeneratedName(buffer);
+    }
+
+    void DeleteBuffer(GLuint buffer) {
+        return MG_State_T::bufferState->Delete(buffer);
+    }
+
+    GLenum DeleteBuffers(GLsizei n, const GLuint* buffers) {
+        return MG_State_T::bufferState->DeleteN(n, buffers);
+    }
+
+    GLenum QueryBufferPropertyIntVector(GLenum target, GLenum pname, GLint* params) {
+        return MG_State_T::bufferState->QueryPropertyIntVector(target, pname, params);
+    }
+    
+    // VertexArray
+    GLenum BindVertexArray(GLuint array) {
+        return MG_State_T::vertexArrayState->Bind(array);
+    }
+
+    GLenum CreateVertexArray(GLuint* array) {
+        return MG_State_T::vertexArrayState->Create(array);
+    }
+
+    GLenum CreateVertexArrays(GLsizei n, GLuint* arrays) {
+        return MG_State_T::vertexArrayState->CreateN(n, arrays);
+    }
+
+    GLenum GenVertexArraysNames(GLsizei n, GLuint* arrays) {
+        return MG_State_T::vertexArrayState->GenNameN(n, arrays);
+    }
+
+    GLenum EnableVertexAttribArray(GLuint index) {
+        return MG_State_T::vertexArrayState->EnableAttrib(index);
+    }
+
+    GLenum DisableVertexAttribArray(GLuint index) {
+        return MG_State_T::vertexArrayState->DisableAttrib(index);
+    }
+
+    GLenum SetVertexAttributeLayout(GLuint index, GLint size, GLenum type,
+                               GLboolean normalized, GLsizei stride,
+                               const void* pointer) {
+        GLuint currentBuffer = MG_State_T::bufferState->GetCurrentBinding(GL_ARRAY_BUFFER);
+        return MG_State_T::vertexArrayState->SetAttribPointer(
+                index, size, type, normalized, stride, pointer, false, currentBuffer
+        );
+    }
+
+    GLenum SetVertexAttributeLayoutInt(GLuint index, GLint size, GLenum type,
+                                GLsizei stride, const void* pointer) {
+        GLuint currentBuffer = MG_State_T::bufferState->GetCurrentBinding(GL_ARRAY_BUFFER);
+        return MG_State_T::vertexArrayState->SetAttribPointer(
+                index, size, type, GL_FALSE, stride, pointer, true, currentBuffer
+        );
+    }
+    
+    // Program
+    GLenum CreateShader(GLenum type, GLuint* shader) {
+        return MG_State_T::programState->CreateShader(type, shader);
+    }
+
+    GLenum CreateProgram(GLuint* program) {
+        return MG_State_T::programState->CreateProgram(program);
+    }
+
+    GLenum DeleteShader(GLuint shader) {
+        return MG_State_T::programState->DeleteShader(shader);
+    }
+
+    GLenum DeleteProgram(GLuint program) {
+        return MG_State_T::programState->DeleteProgram(program);
+    }
+
+    GLenum LinkShaderToProgram(GLuint program, GLuint shader) {
+        return MG_State_T::programState->LinkShaderToProgram(program, shader);
+    }
+
+    GLenum UploadShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length) {
+        return MG_State_T::programState->UploadShaderSource(shader, count, string, length);
+    }
+
+    GLenum BuildShaderStage(GLuint shader) {
+        return MG_State_T::programState->BuildShaderStage(shader);
+    }
+
+    GLenum FinalizeProgramPipeline(GLuint program) {
+        return MG_State_T::programState->FinalizeProgramPipeline(program);
+    }
+
+    GLenum ActivateRenderProgram(GLuint program) {
+        return MG_State_T::programState->ActivateRenderProgram(program);
+    }
+
+    GLenum DefineProgramAttributeBinding(GLuint program, GLuint index, const GLchar* name) {
+        return MG_State_T::programState->DefineProgramAttributeBinding(program, index, name);
+    }
+
+    GLint QueryProgramAttributeBinding(GLuint program, const GLchar* name) {
+        return MG_State_T::programState->QueryProgramAttributeBinding(program, name);
+    }
+
+    GLint QueryProgramUniformLocation(GLuint program, const GLchar* name) {
+        return MG_State_T::programState->QueryProgramUniformLocation(program, name);
+    }
+
+    GLenum QueryProgramStateIntVector(GLuint program, GLenum pname, GLint* params) {
+        return MG_State_T::programState->QueryProgramStateIntVector(program, pname, params);
+    }
+
+    GLenum QueryShaderStateIntVector(GLuint shader, GLenum pname, GLint* params) {
+        return MG_State_T::programState->QueryShaderStateIntVector(shader, pname, params);
+    }
+
+#define IMPLEMENT_UNIFORM_FUNCTIONS(type, suffix, vecType)                               \
+void UpdateProgramUniform##suffix##1(GLint location, type v0) {                   \
+    MG_State_T::programState->UpdateUniform##suffix##1(location, v0); \
+}                                                                                        \
+void UpdateProgramUniform##suffix##2(GLint location, type v0, type v1) {          \
+    MG_State_T::programState->UpdateUniform##suffix##2(location, v0, v1); \
+}                                                                                        \
+void UpdateProgramUniform##suffix##3(GLint location, type v0, type v1, type v2) { \
+    MG_State_T::programState->UpdateUniform##suffix##3(location, v0, v1, v2); \
+}                                                                                        \
+void UpdateProgramUniform##suffix##4(GLint location, type v0, type v1, type v2, type v3) { \
+    MG_State_T::programState->UpdateUniform##suffix##4(location, v0, v1, v2, v3); \
+    } \
+void UpdateProgramUniform##suffix##Vector1(GLint location, GLsizei count, const type* value) { \
+    MG_State_T::programState->UpdateUniform##suffix##Vector1(location, count,value); \
+    } \
+void UpdateProgramUniform##suffix##Vector2(GLint location, GLsizei count, const type* value) { \
+    MG_State_T::programState->UpdateUniform##suffix##Vector2(location, count, value); \
+    } \
+void UpdateProgramUniform##suffix##Vector3(GLint location, GLsizei count, const type* value) { \
+    MG_State_T::programState->UpdateUniform##suffix##Vector3(location, count, value); \
+    } \
+void UpdateProgramUniform##suffix##Vector4(GLint location, GLsizei count, const type* value) { \
+    MG_State_T::programState->UpdateUniform##suffix##Vector4(location, count, value); \
+    }
+
+    IMPLEMENT_UNIFORM_FUNCTIONS(GLfloat, Float, GL_FLOAT_VEC4)
+    IMPLEMENT_UNIFORM_FUNCTIONS(GLint, Int, GL_INT_VEC4)
+    IMPLEMENT_UNIFORM_FUNCTIONS(GLuint, UInt, GL_UNSIGNED_INT_VEC4)
+    IMPLEMENT_UNIFORM_FUNCTIONS(GLboolean, Bool, GL_BOOL_VEC4)
+#undef IMPLEMENT_UNIFORM_FUNCTIONS
+
+#define IMPLEMENT_MATRIX_FUNCTIONS(suffix, matrixType) \
+void UpdateProgramUniformMatrix##suffix##Vector(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { \
+    MG_State_T::programState->UpdateUniformMatrix##suffix##Vector(location, count, transpose, value); \
+}
+
+    IMPLEMENT_MATRIX_FUNCTIONS(2x2, GL_FLOAT_MAT2)
+    IMPLEMENT_MATRIX_FUNCTIONS(3x3, GL_FLOAT_MAT3)
+    IMPLEMENT_MATRIX_FUNCTIONS(4x4, GL_FLOAT_MAT4)
+    IMPLEMENT_MATRIX_FUNCTIONS(2x3, GL_FLOAT_MAT2x3)
+    IMPLEMENT_MATRIX_FUNCTIONS(2x4, GL_FLOAT_MAT2x4)
+    IMPLEMENT_MATRIX_FUNCTIONS(3x2, GL_FLOAT_MAT3x2)
+    IMPLEMENT_MATRIX_FUNCTIONS(3x4, GL_FLOAT_MAT3x4)
+    IMPLEMENT_MATRIX_FUNCTIONS(4x2, GL_FLOAT_MAT4x2)
+    IMPLEMENT_MATRIX_FUNCTIONS(4x3, GL_FLOAT_MAT4x3)
+#undef IMPLEMENT_MATRIX_FUNCTIONS
+    
+    GLuint GetCurrentProgram() {
+        return MG_State_T::programState->GetCurrentProgram();
+    }
+    
+    bool SetProgramStatus(GLuint program, GLboolean status) {
+        return MG_State_T::programState->SetProgramStatus(program, status);
+    }
+    
+    bool SetShaderStatus(GLuint shader, GLboolean status) {
+        return MG_State_T::programState->SetShaderStatus(shader, status);
+    }
+    
+    // Framebuffer
+    GLenum MG_State::CreateFramebuffer(GLuint* framebuffer) {
+        return MG_State_T::framebufferState->Create(framebuffer);
+    }
+    
+    GLenum MG_State::CreateFramebuffers(GLsizei n, GLuint* framebuffers) {
+        return MG_State_T::framebufferState->CreateN(n, framebuffers);
+    }
+    
+    GLenum MG_State::DeleteFramebuffer(GLuint framebuffer) {
+        return MG_State_T::framebufferState->Delete(framebuffer);
+    }
+    
+    GLenum MG_State::BindFramebuffer(GLenum target, GLuint framebuffer) {
+        return MG_State_T::framebufferState->Bind(target, framebuffer);
+    }
+    
+    GLenum MG_State::AttachTexture2DToFramebuffer(GLenum target, GLenum attachment, GLenum textarget,
+                                                  GLuint texture, GLint level) {
+        return MG_State_T::framebufferState->AttachTexture2D(target, attachment, textarget,
+                                                             texture, level);
+    }
+    
+    GLenum MG_State::ValidateFramebufferCompleteness(GLenum target) {
+        return MG_State_T::framebufferState->ValidateCompleteness(target);
+    }
+}

MG/MG_GL/State/Core/GLState.h

@@ -0,0 +1,151 @@
+//
+// Created by BZLZHH on 2025/4/4.
+//
+
+#ifndef MOBILEGL_GLSTATE_H
+#define MOBILEGL_GLSTATE_H
+
+#include "../../../Includes.h"
+
+struct MG_State_T {
+    static std::queue<GLenum> glErrorQueue;
+    static TextureState* textureState;
+    static CommonState* commonState;
+    static BufferState* bufferState;
+    static VertexArrayState* vertexArrayState;
+    static ProgramState* programState;
+    static FramebufferState* framebufferState;
+};
+
+namespace MG_State {
+    void Init();
+    void Destroy();
+    void SetError(GLenum error);
+    GLenum GetError();
+    
+    //Texture
+    GLenum BindTextureUnit(GLenum textureUnit);
+    GLenum CreateTexture(GLuint* texture);
+    GLenum CreateTextures(GLsizei n, GLuint* textures);
+    GLenum BindTexture(GLenum target, GLuint texture);
+    GLenum UploadTexture2D(GLenum target, GLint level, GLint internalFormat,
+                           GLsizei width, GLsizei height, GLint border, GLenum format,
+                           GLenum type, const void* data);
+    GLenum UpdateTextureRegion2D(GLenum target, GLint level, GLint xoffset,
+                                 GLint yoffset, GLsizei width, GLsizei height, GLenum format,
+                                 GLenum type, const GLvoid* data);
+    GLenum SetTexturePropertyInt(GLenum target, GLenum pname, GLint param);
+    GLenum SetTexturePropertyFloat(GLenum target, GLenum pname, GLfloat param);
+    GLenum DeleteTexture(GLuint texture);
+    GLenum DeleteTextures(GLsizei n, const GLuint* textures);
+    GLenum QueryTextureLevelPropertyIntVector(GLenum target, GLint level, GLenum pname, GLint* params);
+    
+    // Common
+    GLenum SetPixelStoreInt(GLenum pname, GLint param);
+    GLint QueryPixelStoreInt(GLenum pname);
+    GLenum glEnable(GLenum cap);
+    GLenum glDisable(GLenum cap);
+    GLenum glBlendFunc(GLenum sfactor, GLenum dfactor);
+    GLenum glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+    GLenum glClear(GLbitfield mask);
+    GLenum glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+    GLenum glClearDepth(GLdouble depth);
+    GLenum glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+    GLenum glDepthFunc(GLenum func);
+    GLenum glDepthMask(GLboolean flag);
+    GLenum glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
+    
+    // Buffer
+    GLenum AcquireBufferMemory(GLenum target, GLenum access, void** mappedPtr);
+    GLenum AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer);
+    GLenum SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length);
+    GLenum CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+    GLenum ReleaseBufferMemory(GLenum target);
+    GLenum CreateBuffer(GLuint buffer);
+    GLenum GenBufferNames(GLsizei n, GLuint* buffers);
+    GLenum BindBuffer(GLenum target, GLuint buffer);
+    GLenum CommitBufferStorage(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
+    GLenum CommitBufferStorageRegion(GLenum target, GLintptr offset, GLsizeiptr size, const void* data);
+    bool ValidateAllocatedBufferHandle(GLuint buffer);
+    bool ValidateGeneratedName(GLuint buffer);
+    void DeleteBuffer(GLuint buffer);
+    GLenum DeleteBuffers(GLsizei n, const GLuint* buffers);
+    GLenum QueryBufferPropertyIntVector(GLenum target, GLenum pname, GLint* params);
+    
+    // VertexArray
+    GLenum CreateVertexArray(GLuint* array);
+    GLenum CreateVertexArrays(GLsizei n, GLuint* arrays);
+    GLenum GenVertexArraysNames(GLsizei n, GLuint* arrays);
+    GLenum BindVertexArray(GLuint array);
+    GLenum EnableVertexAttribArray(GLuint index);
+    GLenum DisableVertexAttribArray(GLuint index);
+    GLenum SetVertexAttributeLayout(GLuint index, GLint size, GLenum type,
+                                    GLboolean normalized, GLsizei stride,
+                                    const void* pointer);
+    GLenum SetVertexAttributeLayoutInt(GLuint index, GLint size, GLenum type,
+                                       GLsizei stride, const void* pointer);
+    
+    // Program
+    GLenum CreateShader(GLenum type, GLuint* shader);
+    GLenum CreateProgram(GLuint* program);
+    GLenum DeleteShader(GLuint shader);
+    GLenum DeleteProgram(GLuint program);
+    GLenum LinkShaderToProgram(GLuint program, GLuint shader);
+    GLenum UploadShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length);
+    GLenum BuildShaderStage(GLuint shader);
+    GLenum FinalizeProgramPipeline(GLuint program);
+    GLenum ActivateRenderProgram(GLuint program);
+    GLenum DefineProgramAttributeBinding(GLuint program, GLuint index, const GLchar* name);
+    GLint QueryProgramAttributeBinding(GLuint program, const GLchar* name);
+    GLint QueryProgramUniformLocation(GLuint program, const GLchar* name);
+    GLenum QueryProgramStateIntVector(GLuint program, GLenum pname, GLint* params);
+    GLenum QueryShaderStateIntVector(GLuint shader, GLenum pname, GLint* params);
+    template<typename T>
+    GLenum SetUniform(GLuint program, GLint location, GLsizei count, const T* value, GLenum type);
+
+    template<typename T>
+    GLenum SetUniformMatrix(GLuint program, GLint location, GLsizei count, GLboolean transpose, const T* value, GLenum matrixType);
+
+#define DECLARE_UNIFORM_FUNCTIONS(type, suffix, vecType) \
+    void UpdateProgramUniform##suffix##1(GLint location, type v0); \
+    void UpdateProgramUniform##suffix##2(GLint location, type v0, type v1); \
+    void UpdateProgramUniform##suffix##3(GLint location, type v0, type v1, type v2); \
+    void UpdateProgramUniform##suffix##4(GLint location, type v0, type v1, type v2, type v3); \
+    void UpdateProgramUniform##suffix##Vector1(GLint location, GLsizei count, const type* value); \
+    void UpdateProgramUniform##suffix##Vector2(GLint location, GLsizei count, const type* value); \
+    void UpdateProgramUniform##suffix##Vector3(GLint location, GLsizei count, const type* value); \
+    void UpdateProgramUniform##suffix##Vector4(GLint location, GLsizei count, const type* value);
+    DECLARE_UNIFORM_FUNCTIONS(GLfloat, Float, GL_FLOAT)
+    DECLARE_UNIFORM_FUNCTIONS(GLint, Int, GL_INT)
+    DECLARE_UNIFORM_FUNCTIONS(GLuint, UInt, GL_UNSIGNED_INT)
+    DECLARE_UNIFORM_FUNCTIONS(GLboolean, Bool, GL_BOOL)
+#undef DECLARE_UNIFORM_FUNCTIONS
+#define DECLARE_MATRIX_FUNCTIONS(suffix, matrixType) \
+    void UpdateProgramUniformMatrix##suffix##Vector(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    DECLARE_MATRIX_FUNCTIONS(2x2, GL_FLOAT_MAT2)
+    DECLARE_MATRIX_FUNCTIONS(3x3, GL_FLOAT_MAT3)
+    DECLARE_MATRIX_FUNCTIONS(4x4, GL_FLOAT_MAT4)
+    DECLARE_MATRIX_FUNCTIONS(2x3, GL_FLOAT_MAT2x3)
+    DECLARE_MATRIX_FUNCTIONS(2x4, GL_FLOAT_MAT2x4)
+    DECLARE_MATRIX_FUNCTIONS(3x2, GL_FLOAT_MAT3x2)
+    DECLARE_MATRIX_FUNCTIONS(3x4, GL_FLOAT_MAT3x4)
+    DECLARE_MATRIX_FUNCTIONS(4x2, GL_FLOAT_MAT4x2)
+    DECLARE_MATRIX_FUNCTIONS(4x3, GL_FLOAT_MAT4x3)
+#undef DECLARE_MATRIX_FUNCTIONS
+    
+    GLuint GetCurrentProgram();
+    bool SetProgramStatus(GLuint program, GLboolean status);
+    bool SetShaderStatus(GLuint shader, GLboolean status);
+    
+    // Framebuffer
+    GLenum CreateFramebuffer(GLuint* framebuffer);
+    GLenum CreateFramebuffers(GLsizei n, GLuint* framebuffers);
+    GLenum DeleteFramebuffer(GLuint framebuffer);
+    GLenum BindFramebuffer(GLenum target, GLuint framebuffer);
+    GLenum AttachTexture2DToFramebuffer(GLenum target, GLenum attachment, GLenum textarget,
+                                        GLuint texture, GLint level);
+    GLenum ValidateFramebufferCompleteness(GLenum target);
+}
+
+
+#endif //MOBILEGL_GLSTATE_H

MG/MG_GL/State/Framebuffer/FramebufferState.cpp

@@ -0,0 +1,165 @@
+//
+// Created by BZLZHH on 2025/5/3.
+//
+
+// TODO: Add more gl error check for framebuffer state manager.
+// TODO: Check if the state machine really meets up to OpenGL 3 standard.
+
+#include "FramebufferState.h"
+
+// Re-Include Includes.h, cuz of the absence of GLState.h
+#undef MOBILEGL_GLSTATE_H
+#include "../../../Includes.h"
+
+GLenum FramebufferState::Create(GLuint* framebuffer) {
+    if (!framebuffer) return GL_INVALID_VALUE;
+    GLuint id = freeIds_.empty() ? ++lastId_ : *freeIds_.begin();
+    if (!freeIds_.empty()) freeIds_.erase(freeIds_.begin());
+    *framebuffer = id;
+    framebuffers_[id].generated = true;
+    return GL_NO_ERROR;
+}
+
+GLenum FramebufferState::CreateN(GLsizei n, GLuint* framebuffers) {
+    if (n < 0) return GL_INVALID_VALUE;
+    for (GLsizei i = 0; i < n; ++i) {
+        if (GLenum err = Create(&framebuffers[i])) return err;
+    }
+    return GL_NO_ERROR;
+}
+
+GLenum FramebufferState::Delete(GLuint framebuffer) {
+    if (framebuffer == 0) return GL_INVALID_VALUE;
+    
+    if (framebuffers_.erase(framebuffer)) {
+        // TODO: Prevent the object that uses a freeId from conflicting with legacy object in the backend.
+        //freeIds_.insert(framebuffer);
+        for (auto& [target, id] : currentBindings_) {
+            if (id == framebuffer) id = 0;
+        }
+    }
+    return GL_NO_ERROR;
+}
+
+GLenum FramebufferState::Bind(GLenum target, GLuint framebuffer) {
+    if (MG_Constants::Framebuffer::VALID_TARGETS.find(target) == MG_Constants::Framebuffer::VALID_TARGETS.end()) 
+        return GL_INVALID_ENUM;
+    if (framebuffer != 0 && !ValidateHandle(framebuffer))
+        return GL_INVALID_OPERATION;
+    if (target == GL_FRAMEBUFFER) {
+        currentBindings_[GL_READ_FRAMEBUFFER] = framebuffer;
+        currentBindings_[GL_DRAW_FRAMEBUFFER] = framebuffer;
+    } else {
+        currentBindings_[target] = framebuffer;
+    }
+    return GL_NO_ERROR;
+}
+
+GLenum FramebufferState::AttachTexture2D(GLenum target, GLenum attachment,
+                                         GLenum textarget, GLuint texture, GLint level) {
+    if (MG_Constants::Framebuffer::VALID_ATTACHMENTS.find(attachment) == MG_Constants::Framebuffer::VALID_ATTACHMENTS.end() ||
+        MG_Constants::Texture::VALID_TARGETS.find(textarget) == MG_Constants::Texture::VALID_TARGETS.end())
+        return GL_INVALID_ENUM;
+    if (target == GL_FRAMEBUFFER) target = GL_DRAW_FRAMEBUFFER;
+    FramebufferObject* fbo = GetCurrentFBO(target);
+    if (!fbo) return GL_INVALID_OPERATION;
+    if (texture != 0 && !MG_State_T::textureState->IsTexture(texture))
+        return GL_INVALID_VALUE;
+    FramebufferAttachment att;
+    att.type = GL_TEXTURE_2D;
+    att.handle = texture;
+    att.mipLevel = level;
+    fbo->attachments[attachment] = att;
+    
+    if (texture != 0) {
+        GLint params = 0;
+        MG_State_T::textureState->QueryLevelPropertyIntVector(
+            textarget, level, GL_TEXTURE_WIDTH, &params);
+        fbo->width = params;
+        MG_State_T::textureState->QueryLevelPropertyIntVector(
+            textarget, level, GL_TEXTURE_HEIGHT, &params);
+        fbo->height = params;
+    }
+    UpdateCompleteness(*fbo);
+    return GL_NO_ERROR;
+}
+
+GLenum FramebufferState::ValidateCompleteness(GLenum target) {
+    if (target == GL_FRAMEBUFFER) target = GL_DRAW_FRAMEBUFFER;
+    FramebufferObject* fbo = GetCurrentFBO(target);
+    if (!fbo) return GL_INVALID_OPERATION;
+    return fbo->status;
+}
+
+void FramebufferState::UpdateCompleteness(FramebufferObject& fbo) {
+    if (fbo.attachments.empty()) {
+        fbo.status = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
+        return;
+    }
+    bool hasColor = false;
+    bool hasDepth = false;
+    bool hasStencil = false;
+    GLsizei width = 0, height = 0;
+    for (const auto& [attach, att] : fbo.attachments) {
+        GLsizei attWidth = 0, attHeight = 0;
+        if (att.handle != 0) {
+            GLint params = 0;
+            MG_State_T::textureState->QueryLevelPropertyIntVector(
+                GL_TEXTURE_2D, att.mipLevel, GL_TEXTURE_WIDTH, &params);
+            attWidth = params;
+            MG_State_T::textureState->QueryLevelPropertyIntVector(
+                GL_TEXTURE_2D, att.mipLevel, GL_TEXTURE_HEIGHT, &params);
+            attHeight = params;
+        }
+        if (width == 0) {
+            width = attWidth;
+            height = attHeight;
+        } else if (attWidth != width || attHeight != height) {
+            fbo.status = GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS;
+            return;
+        }
+        
+        if (attach == GL_DEPTH_ATTACHMENT) hasDepth = true;
+        if (attach == GL_STENCIL_ATTACHMENT) hasStencil = true;
+        if (attach >= GL_COLOR_ATTACHMENT0 && 
+            attach <= GL_COLOR_ATTACHMENT31) hasColor = true;
+    }
+    
+    if (!ValidateAttachmentCombination(fbo)) {
+        fbo.status = GL_FRAMEBUFFER_UNSUPPORTED;
+        return;
+    }
+    fbo.status = GL_FRAMEBUFFER_COMPLETE;
+}
+
+bool FramebufferState::ValidateAttachmentCombination(const FramebufferObject& fbo) {
+    bool depthStencilConflict = false;
+    for (const auto& [attach, att] : fbo.attachments) {
+        if (attach == GL_DEPTH_STENCIL_ATTACHMENT) {
+            GLint internalFormat = 0;
+            MG_State_T::textureState->QueryLevelPropertyIntVector(
+                GL_TEXTURE_2D, att.mipLevel, GL_TEXTURE_INTERNAL_FORMAT, &internalFormat);
+            if (internalFormat != GL_DEPTH24_STENCIL8 && 
+                internalFormat != GL_DEPTH32F_STENCIL8) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+FramebufferObject* FramebufferState::GetCurrentFBO(GLenum target) {
+    auto it = currentBindings_.find(target);
+    if (it == currentBindings_.end()) return nullptr;
+    
+    GLuint id = it->second;
+    if (id == 0) return nullptr;
+    
+    auto fboIt = framebuffers_.find(id);
+    return (fboIt != framebuffers_.end()) ? &fboIt->second : nullptr;
+}
+
+bool FramebufferState::ValidateHandle(GLuint framebuffer) {
+    return framebuffers_.count(framebuffer) && 
+           framebuffers_[framebuffer].generated;
+}

MG/MG_GL/State/Framebuffer/FramebufferState.h

@@ -0,0 +1,49 @@
+//
+// Created by BZLZHH on 2025/5/3.
+//
+
+#ifndef MOBILEGL_FRAMEBUFFERSTATE_H
+#define MOBILEGL_FRAMEBUFFERSTATE_H
+#define MOBILEGL_GLSTATE_H
+
+#include "../../../Includes.h"
+
+struct FramebufferAttachment {
+    GLenum type = GL_NONE;
+    GLuint handle = 0;
+    GLint mipLevel = 0;
+    GLint zoffset = 0;
+};
+
+struct FramebufferObject {
+    bool generated = false;
+    ankerl::unordered_map<GLenum, FramebufferAttachment> attachments;
+    GLenum status = GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
+    GLsizei width = 0;
+    GLsizei height = 0;
+};
+
+class FramebufferState {
+public:
+    // Return: the validity of the operation
+    GLenum Create(GLuint* framebuffer);
+    GLenum CreateN(GLsizei n, GLuint* framebuffers);
+    GLenum Delete(GLuint framebuffer);
+    GLenum Bind(GLenum target, GLuint framebuffer);
+    GLenum AttachTexture2D(GLenum target, GLenum attachment,
+                           GLenum textarget, GLuint texture, GLint level);
+    GLenum ValidateCompleteness(GLenum target);
+    FramebufferObject* GetCurrentFBO(GLenum target);
+    
+    ankerl::unordered_map<GLenum, GLuint> currentBindings_; // READ/DRAW
+    
+private:
+    ankerl::unordered_map<GLuint, FramebufferObject> framebuffers_;
+    std::set<GLuint> freeIds_;
+    GLuint lastId_ = 0;
+    bool ValidateHandle(GLuint framebuffer);
+    static void UpdateCompleteness(FramebufferObject& fbo);
+    static bool ValidateAttachmentCombination(const FramebufferObject& fbo);
+};
+
+#endif //MOBILEGL_FRAMEBUFFERSTATE_H

MG/MG_GL/State/Program/ProgramState.cpp

@@ -0,0 +1,577 @@
+//
+// Created by BZLZHH on 2025/5/1.
+
+// TODO: Add more gl error check for buffer state manager.
+// TODO: Check if the state machine really meets up to OpenGL 3 standard.
+
+#include "ProgramState.h"
+
+// Re-Include Includes.h, cuz of the absence of Program/DebugTool.h and Program/GLSLTool.cpp.
+#undef MOBILEGL_GLSLTOOL_H
+#undef MOBILEGL_PROGRAM_DEBUGTOOL_H
+#include "../../../Includes.h"
+
+ProgramState::ProgramState() {
+    glslang::InitializeProcess();
+}
+
+ProgramState::~ProgramState() {
+    glslang::FinalizeProcess();
+}
+
+GLenum ProgramState::CreateProgram(GLuint* program) {
+    MG_Util::Debug::LogD("MG_State: Program: CreateProgram called, program ptr=%p", program);
+    if (!program) {
+        MG_Util::Debug::LogE("MG_State: Program: CreateProgram error: program pointer is null");
+        return GL_INVALID_VALUE;
+    }
+
+    GLuint id = freeProgramIds_.empty() ? ++lastProgramId_ : *freeProgramIds_.begin();
+    if (!freeProgramIds_.empty())
+        freeProgramIds_.erase(freeProgramIds_.begin());
+
+    ProgramObject obj;
+    obj.linked = {UncertainBool::Unknown, UncertainBool::False};
+    obj.linkStatus = GL_FALSE;
+    obj.markedForDeletion = false;
+    programs_[id] = obj;
+    *program = id;
+    MG_Util::Debug::LogD("MG_State: Program: CreateProgram success, new id=%u", id);
+    return GL_NO_ERROR;
+}
+
+GLenum ProgramState::DeleteProgram(GLuint program) {
+    MG_Util::Debug::LogD("MG_State: Program: DeleteProgram called, id=%u", program);
+    if (!ValidateProgram_(program)) {
+        MG_Util::Debug::LogE("MG_State: Program: DeleteProgram error: invalid program id %u", program);
+        return GL_INVALID_VALUE;
+    }
+
+    programs_.erase(program);
+    //freeProgramIds_.insert(program);
+    if (currentProgram_ == program)
+        currentProgram_ = 0;
+    MG_Util::Debug::LogD("MG_State: Program: DeleteProgram success, id=%u", program);
+    return GL_NO_ERROR;
+}
+
+GLenum ProgramState::LinkShaderToProgram(GLuint program, GLuint shader) {
+    MG_Util::Debug::LogD("MG_State: Program: LinkShaderToProgram called, program=%u, shader=%u",
+                         program, shader);
+    if (!ValidateProgram_(program) || !ValidateShader_(shader)) {
+        MG_Util::Debug::LogE("MG_State: Program: LinkShaderToProgram error: invalid ids program=%u shader=%u",
+                             program, shader);
+        return GL_INVALID_VALUE;
+    }
+
+    auto& prog = programs_[program];
+    if (std::find(prog.attachedShaders.begin(),
+                  prog.attachedShaders.end(), shader) != prog.attachedShaders.end()) {
+        MG_Util::Debug::LogW("MG_State: Program: LinkShaderToProgram warning: shader %u already attached to program %u",
+                             shader, program);
+        return GL_INVALID_OPERATION;
+    }
+
+    prog.attachedShaders.push_back(shader);
+    MG_Util::Debug::LogD("MG_State: Program: LinkShaderToProgram success: shader %u attached to program %u",
+                         shader, program);
+    return GL_NO_ERROR;
+}
+
+GLenum ProgramState::FinalizeProgramPipeline(GLuint program) {
+    MG_Util::Debug::LogD("MG_State: Program: FinalizeProgramPipeline called, id=%u", program);
+    if (!ValidateProgram_(program)) {
+        MG_Util::Debug::LogE("MG_State: Program: FinalizeProgramPipeline error: invalid program id %u", program);
+        return GL_INVALID_VALUE;
+    }
+    auto& prog = programs_[program];
+
+    for (GLuint shader : prog.attachedShaders) {
+        if (!shaders_[shader].compiled.toBool()) {
+            MG_Util::Debug::LogE("MG_State: Program: FinalizeProgramPipeline error: shader %u not compiled", shader);
+            return GL_INVALID_OPERATION;
+        }
+    }
+
+    prog.infoLog.clear();
+    
+    for (GLuint shaderId : prog.attachedShaders) {
+        auto& shader = shaders_[shaderId];
+        if (!shader.compiled.toBool() || shader.compiledSpirv.empty()) {
+            prog.infoLog = "Program linking failed: \n" +
+                           MG_Util::Program::GetShaderTypeName(shader.type) + " is not compiled.";
+            prog.linked = UncertainBool::False;
+            prog.linkStatus = GL_FALSE;
+            MG_Util::Debug::LogE("MG_State: Program: FinalizeProgramPipeline error: %s", prog.infoLog.c_str());
+            return GL_INVALID_OPERATION;
+        }
+    }
+
+    std::vector<std::vector<unsigned>> allSpirv = 
+            MG_Util::Program::CompileMultipleShadersToSPIRV(*this, prog, prog.infoLog);
+    
+    MG_Util::Program::ReflectSPIRVUniforms(allSpirv, prog, prog.infoLog);
+    if (!prog.infoLog.empty()) {
+        prog.linked = UncertainBool::False;
+        prog.linkStatus = GL_FALSE;
+        prog.infoLog = "Program linking failed: " + prog.infoLog;
+        MG_Util::Debug::LogE("MG_State: Program: FinalizeProgramPipeline error: %s", prog.infoLog.c_str());
+        return GL_INVALID_OPERATION;
+    }
+
+    for (auto& [name, index] : prog.attribBindings) {
+        prog.attribLocations[name] = index;
+    }
+
+    prog.linked = {UncertainBool::Unknown, UncertainBool::True};
+    prog.linkStatus = GL_TRUE;
+
+    CleanupShaders_();
+
+    MG_Util::Program::DumpUniforms(*this, program);
+    MG_Util::Debug::LogD("MG_State: Program: FinalizeProgramPipeline success, id=%u", program);
+    return GL_NO_ERROR;
+}
+
+GLenum ProgramState::ActivateRenderProgram(GLuint program) {
+    MG_Util::Debug::LogD("MG_State: Program: ActivateRenderProgram called, id=%u", program);
+    if (program != 0 && !ValidateProgram_(program)) {
+        MG_Util::Debug::LogE("MG_State: Program: ActivateRenderProgram error: invalid program id %u", program);
+        return GL_INVALID_VALUE;
+    }
+
+    MG_Util::Program::DumpCurrentUniforms(*this);
+    currentProgram_ = program;
+    MG_Util::Program::DumpCurrentUniforms(*this);
+    MG_Util::Debug::LogD("MG_State: Program: ActivateRenderProgram success, current program=%u", currentProgram_);
+    return GL_NO_ERROR;
+}
+
+GLenum ProgramState::DefineProgramAttributeBinding(GLuint program, GLuint index, const GLchar* name) {
+    MG_Util::Debug::LogD("MG_State: Program: DefineProgramAttributeBinding called, program=%u, index=%u, name=%s",
+                         program, index, name);
+    if (!ValidateProgram_(program)) {
+        MG_Util::Debug::LogE("MG_State: Program: DefineProgramAttributeBinding error: invalid program id %u", program);
+        return GL_INVALID_VALUE;
+    }
+    if (index >= GL_MAX_VERTEX_ATTRIBS) {
+        MG_Util::Debug::LogE("MG_State: Program: DefineProgramAttributeBinding error: index %u out of range", index);
+        return GL_INVALID_VALUE;
+    }
+
+    programs_[program].attribBindings[name] = index;
+    MG_Util::Debug::LogD("MG_State: Program: DefineProgramAttributeBinding success: %s -> %u", name, index);
+    return GL_NO_ERROR;
+}
+
+GLint ProgramState::QueryProgramAttributeBinding(GLuint program, const GLchar* name) {
+    MG_Util::Debug::LogD("MG_State: Program: QueryProgramAttributeBinding called, program=%u, name=%s",
+                         program, name);
+    if (!ValidateProgram_(program)) {
+        MG_Util::Debug::LogE("MG_State: Program: QueryProgramAttributeBinding error: invalid program id %u", program);
+        return -1;
+    }
+
+    auto& prog = programs_[program];
+    auto it = prog.attribLocations.find(name);
+    if (it != prog.attribLocations.end()) {
+        GLint loc = it->second;
+        MG_Util::Debug::LogD("MG_State: Program: QueryProgramAttributeBinding success: %s -> %d", name, loc);
+        return loc;
+    }
+    MG_Util::Debug::LogW("MG_State: Program: QueryProgramAttributeBinding warning: name '%s' not found", name);
+    return -1;
+}
+
+GLenum ProgramState::QueryProgramStateIntVector(GLuint program, GLenum pname, GLint* params) {
+    MG_Util::Debug::LogD("MG_State: Program: QueryProgramStateIntVector called, program=%u, pname=0x%X",
+                         program, pname);
+    if (!ValidateProgram_(program)) {
+        MG_Util::Debug::LogE("MG_State: Program: QueryProgramStateIntVector error: invalid program id %u", program);
+        return GL_INVALID_VALUE;
+    }
+    auto& prog = programs_[program];
+
+    switch (pname) {
+        case GL_LINK_STATUS:     *params = prog.linkStatus; break;
+        case GL_DELETE_STATUS:   *params = prog.markedForDeletion; break;
+        case GL_ATTACHED_SHADERS:*params = (GLint)prog.attachedShaders.size(); break;
+        default:
+            MG_Util::Debug::LogE("MG_State: Program: QueryProgramStateIntVector error: invalid pname 0x%X", pname);
+            return GL_INVALID_ENUM;
+    }
+    MG_Util::Debug::LogD("MG_State: Program: QueryProgramStateIntVector success: value=%d", *params);
+    return GL_NO_ERROR;
+}
+
+GLenum ProgramState::QueryShaderStateIntVector(GLuint shader, GLenum pname, GLint* params) {
+    MG_Util::Debug::LogD("MG_State: Program: QueryShaderStateIntVector called, shader=%u, pname=0x%X",
+                         shader, pname);
+    if (!ValidateShader_(shader)) {
+        MG_Util::Debug::LogE("MG_State: Program: QueryShaderStateIntVector error: invalid shader id %u", shader);
+        return GL_INVALID_VALUE;
+    }
+    auto& obj = shaders_[shader];
+
+    switch (pname) {
+        case GL_COMPILE_STATUS: *params = obj.compileStatus; break;
+        case GL_DELETE_STATUS:  *params = obj.markedForDeletion; break;
+        case GL_SHADER_TYPE:    *params = obj.type; break;
+        default:
+            MG_Util::Debug::LogE("MG_State: Program: QueryShaderStateIntVector error: invalid pname 0x%X", pname);
+            return GL_INVALID_ENUM;
+    }
+    MG_Util::Debug::LogD("MG_State: Program: QueryShaderStateIntVector success: value=%d", *params);
+    return GL_NO_ERROR;
+}
+
+template<typename T>
+GLenum ProgramState::SetUniform(GLuint program, GLint location, GLsizei count, const T* value, GLenum type) {
+    MG_Util::Debug::LogD("MG_State: Program: SetUniform called, program=%u, location=%d, count=%d, type=0x%X",
+                         program, location, count, type);
+    if (!ValidateProgram_(program)) {
+        MG_Util::Debug::LogE("MG_State: Program: SetUniform error: invalid program id %u", program);
+        return GL_INVALID_VALUE;
+    }
+    if (location < -1) {
+        MG_Util::Debug::LogE("MG_State: Program: SetUniform error: invalid location %d", location);
+        return GL_INVALID_VALUE;
+    }
+    if (count < 0) {
+        MG_Util::Debug::LogE("MG_State: Program: SetUniform error: invalid count %d", count);
+        return GL_INVALID_VALUE;
+    }
+    if (location == -1) {
+        MG_Util::Debug::LogW("MG_State: Program: SetUniform warning: location -1, no-op");
+        return GL_NO_ERROR;
+    }
+
+    ProgramObject& prog = programs_[program];
+    std::string uniformName;
+    for (const auto& pair : prog.uniformLocations) {
+        if (pair.second == location) {
+            uniformName = pair.first;
+            break;
+        }
+    }
+    if (uniformName.empty()) {
+        MG_Util::Debug::LogE("MG_State: Program: SetUniform error: no uniform at location %d in program %u",
+                             location, program);
+        return GL_INVALID_OPERATION;
+    }
+
+    UniformValue& uniform = prog.uniformValues[uniformName];
+    
+    uniform.setData(type, count, value);
+    MG_Util::Debug::LogD("MG_State: Program: SetUniform success: %s set", uniformName.c_str());
+    return GL_NO_ERROR;
+}
+
+template<typename T>
+GLenum ProgramState::SetUniformMatrix(GLuint program, GLint location, GLsizei count, GLboolean transpose, const T* value, GLenum matrixType) {
+    MG_Util::Debug::LogD("MG_State: Program: SetUniformMatrix called, program=%u, location=%d, count=%d, matrixType=0x%X",
+                         program, location, count, matrixType);
+    (void)transpose;
+    if (!ValidateProgram_(program)) {
+        MG_Util::Debug::LogE("MG_State: Program: SetUniformMatrix error: invalid program id %u", program);
+        return GL_INVALID_VALUE;
+    }
+    if (location < -1) {
+        MG_Util::Debug::LogE("MG_State: Program: SetUniformMatrix error: invalid location %d", location);
+        return GL_INVALID_VALUE;
+    }
+    if (count < 0) {
+        MG_Util::Debug::LogE("MG_State: Program: SetUniformMatrix error: invalid count %d", count);
+        return GL_INVALID_VALUE;
+    }
+    if (location == -1) {
+        MG_Util::Debug::LogW("MG_State: Program: SetUniformMatrix warning: location -1, no-op");
+        return GL_NO_ERROR;
+    }
+
+    ProgramObject& prog = programs_[program];
+    std::string uniformName;
+    for (const auto& pair : prog.uniformLocations) {
+        if (pair.second == location) {
+            uniformName = pair.first;
+            break;
+        }
+    }
+    if (uniformName.empty()) {
+        MG_Util::Debug::LogE("MG_State: Program: SetUniformMatrix error: no uniform at location %d in program %u",
+                             location, program);
+        return GL_INVALID_OPERATION;
+    }
+
+    UniformValue& uniform = prog.uniformValues[uniformName];
+    uniform.setData(matrixType, count, value);
+    MG_Util::Debug::LogD("MG_State: Program: SetUniformMatrix success: %s set", uniformName.c_str());
+    return GL_NO_ERROR;
+}
+
+#define IMPLEMENT_UNIFORM_FUNCTIONS(type, suffix, vecType)                               \
+void ProgramState::UpdateUniform##suffix##1(GLint location, type v0) {                   \
+    MG_Util::Debug::LogD("MG_State: Program: UpdateUniform" #suffix "1 called, location=%d", location); \
+    SetUniform<type>(currentProgram_, location, 1, &v0, vecType);                        \
+}                                                                                        \
+void ProgramState::UpdateUniform##suffix##2(GLint location, type v0, type v1) {          \
+    type values[2] = {v0, v1};                                                           \
+    MG_Util::Debug::LogD("MG_State: Program: UpdateUniform" #suffix "2 called, location=%d", location); \
+    SetUniform<type>(currentProgram_, location, 1, values, vecType);                     \
+}                                                                                        \
+void ProgramState::UpdateUniform##suffix##3(GLint location, type v0, type v1, type v2) { \
+    type values[3] = {v0, v1, v2};                                                       \
+    MG_Util::Debug::LogD("MG_State: Program: UpdateUniform" #suffix "3 called, location=%d", location); \
+    SetUniform<type>(currentProgram_, location, 1, values, vecType);                     \
+}                                                                                        \
+void ProgramState::UpdateUniform##suffix##4(GLint location, type v0, type v1, type v2, type v3) { \
+    type values[4] = {v0, v1, v2, v3};                                                   \
+    MG_Util::Debug::LogD("MG_State: Program: UpdateUniform" #suffix "4 called, location=%d", location); \
+    SetUniform<type>(currentProgram_, location, 1, values, vecType);                     \
+    } \
+void ProgramState::UpdateUniform##suffix##Vector1(GLint location, GLsizei count, const type* value) { \
+    MG_Util::Debug::LogD("MG_State: Program: UpdateUniform" #suffix "Vector1 called, location=%d, count=%d", location, count); \
+    SetUniform<type>(currentProgram_, location, count, value, vecType);                  \
+    } \
+void ProgramState::UpdateUniform##suffix##Vector2(GLint location, GLsizei count, const type* value) { \
+    MG_Util::Debug::LogD("MG_State: Program: UpdateUniform" #suffix "Vector2 called, location=%d, count=%d", location, count); \
+    SetUniform<type>(currentProgram_, location, count, value, vecType);              \
+    } \
+void ProgramState::UpdateUniform##suffix##Vector3(GLint location, GLsizei count, const type* value) { \
+    MG_Util::Debug::LogD("MG_State: Program: UpdateUniform" #suffix "Vector3 called, location=%d, count=%d", location, count); \
+    SetUniform<type>(currentProgram_, location, count, value, vecType);              \
+    } \
+void ProgramState::UpdateUniform##suffix##Vector4(GLint location, GLsizei count, const type* value) { \
+    MG_Util::Debug::LogD("MG_State: Program: UpdateUniform" #suffix "Vector4 called, location=%d, count=%d", location, count); \
+    SetUniform<type>(currentProgram_, location, count, value, vecType);              \
+    }
+
+IMPLEMENT_UNIFORM_FUNCTIONS(GLfloat, Float, GL_FLOAT_VEC4)
+IMPLEMENT_UNIFORM_FUNCTIONS(GLint, Int, GL_INT_VEC4)
+IMPLEMENT_UNIFORM_FUNCTIONS(GLuint, UInt, GL_UNSIGNED_INT_VEC4)
+IMPLEMENT_UNIFORM_FUNCTIONS(GLboolean, Bool, GL_BOOL_VEC4)
+#undef IMPLEMENT_UNIFORM_FUNCTIONS
+
+#define IMPLEMENT_MATRIX_FUNCTIONS(suffix, matrixType) \
+void ProgramState::UpdateUniformMatrix##suffix##Vector(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { \
+    MG_Util::Debug::LogD("MG_State: Program: UpdateUniformMatrix" #suffix "Vector called, location=%d, count=%d", location, count); \
+    SetUniformMatrix<GLfloat>(currentProgram_, location, count, transpose, value, matrixType); \
+}
+
+IMPLEMENT_MATRIX_FUNCTIONS(2x2, GL_FLOAT_MAT2)
+IMPLEMENT_MATRIX_FUNCTIONS(3x3, GL_FLOAT_MAT3)
+IMPLEMENT_MATRIX_FUNCTIONS(4x4, GL_FLOAT_MAT4)
+IMPLEMENT_MATRIX_FUNCTIONS(2x3, GL_FLOAT_MAT2x3)
+IMPLEMENT_MATRIX_FUNCTIONS(2x4, GL_FLOAT_MAT2x4)
+IMPLEMENT_MATRIX_FUNCTIONS(3x2, GL_FLOAT_MAT3x2)
+IMPLEMENT_MATRIX_FUNCTIONS(3x4, GL_FLOAT_MAT3x4)
+IMPLEMENT_MATRIX_FUNCTIONS(4x2, GL_FLOAT_MAT4x2)
+IMPLEMENT_MATRIX_FUNCTIONS(4x3, GL_FLOAT_MAT4x3)
+#undef IMPLEMENT_MATRIX_FUNCTIONS
+
+GLint ProgramState::QueryProgramUniformLocation(GLuint program, const GLchar* name) {
+    MG_Util::Debug::LogD("MG_State: Program: QueryProgramUniformLocation called, program=%u, name=%s", program, name);
+    if (!ValidateProgram_(program)) {
+        MG_Util::Debug::LogE("MG_State: Program: QueryProgramUniformLocation error: invalid program id %u", program);
+        return -1;
+    }
+    auto& prog = programs_[program];
+    auto it = prog.uniformLocations.find(name);
+    if (it != prog.uniformLocations.end()) {
+        GLint loc = it->second;
+        MG_Util::Debug::LogD("MG_State: Program: QueryProgramUniformLocation success: %s -> %d", name, loc);
+        return loc;
+    }
+    MG_Util::Debug::LogW("MG_State: Program: QueryProgramUniformLocation warning: name '%s' not found", name);
+    return -1;
+}
+
+bool ProgramState::SetProgramStatus(GLuint program, GLboolean status) {
+    MG_Util::Debug::LogD("MG_State: Program: SetProgramStatus called, program=%u, status=%d", program, status);
+    if (!ValidateProgram_(program)) {
+        MG_Util::Debug::LogE("MG_State: Program: SetProgramStatus error: invalid program id %u", program);
+        return false;
+    }
+    auto& prog = programs_[program];
+    if (prog.linked.getValue() != UncertainBool::Unknown) {
+        MG_Util::Debug::LogW("MG_State: Program: SetProgramStatus warning: link state already known");
+        return false;
+    }
+    prog.linked = (status == GL_TRUE) ? UncertainBool::True : UncertainBool::False;
+    prog.linkStatus = status;
+    MG_Util::Debug::LogD("MG_State: Program: SetProgramStatus success, status=%d", status);
+    return true;
+}
+
+GLuint ProgramState::GetCurrentProgram() const {
+    MG_Util::Debug::LogD("MG_State: Program: GetCurrentProgram called, returning %u", currentProgram_);
+    return currentProgram_;
+}
+
+ShaderObject ProgramState::GetShaderObject(GLuint shader) const {
+    MG_Util::Debug::LogD("MG_State: Program: GetShaderObject called, shader=%u", shader);
+    auto it = shaders_.find(shader);
+    if (it == shaders_.end()) {
+        MG_Util::Debug::LogW("MG_State: Program: GetShaderObject warning: invalid shader id %u", shader);
+        return ShaderObject();
+    }
+    MG_Util::Debug::LogD("MG_State: Program: GetShaderObject success, returning object");
+    return it->second;
+}
+
+ProgramObject ProgramState::GetProgramObject(GLuint program) const {
+    MG_Util::Debug::LogD("MG_State: Program: GetProgramObject called, program=%u", program);
+    auto it = programs_.find(program);
+    if (it == programs_.end()) {
+        MG_Util::Debug::LogW("MG_State: Program: GetProgramObject warning: invalid program id %u", program);
+        return ProgramObject();
+    }
+    MG_Util::Debug::LogD("MG_State: Program: GetProgramObject success, returning object");
+    return it->second;
+}
+
+bool ProgramState::ValidateProgram_(GLuint program) {
+    bool ok = programs_.count(program) && !programs_[program].markedForDeletion;
+    MG_Util::Debug::LogD("MG_State: Program: ValidateProgram_ called, program=%u, result=%d", program, ok);
+    return ok;
+}
+
+void ProgramState::CleanupShaders_() {
+    MG_Util::Debug::LogD("MG_State: Program: CleanupShaders_ start");
+    auto it = shaders_.begin();
+    while (it != shaders_.end()) {
+        if (it->second.markedForDeletion) {
+            bool inUse = false;
+            for (auto& [progId, program] : programs_) {
+                if (std::find(program.attachedShaders.begin(),
+                              program.attachedShaders.end(), it->first) != program.attachedShaders.end()) {
+                    inUse = true;
+                    break;
+                }
+            }
+            if (!inUse) {
+                MG_Util::Debug::LogD("MG_State: Program: CleanupShaders_ deleting shader %u", it->first);
+                freeShaderIds_.insert(it->first);
+                it = shaders_.erase(it);
+                continue;
+            }
+        }
+        ++it;
+    }
+    MG_Util::Debug::LogD("MG_State: Program: CleanupShaders_ end");
+}
+
+// UniformValue
+template<typename T>
+void UniformValue::setData(GLenum uniformType, GLsizei count_, const T* values) {
+    MG_Util::Debug::LogD("MG_State: Program: UniformValue::setData called, type=0x%X, count=%d", uniformType, count_);
+    //type = uniformType;
+    count = count_;
+
+    floatData.clear();
+    intData.clear();
+    uintData.clear();
+    boolData.clear();
+
+    switch (type) {
+        case GL_FLOAT:                           numElements = count_ * 1; break;
+        case GL_FLOAT_VEC2:                      numElements = count_ * 2; break;
+        case GL_FLOAT_VEC3:                      numElements = count_ * 3; break;
+        case GL_FLOAT_VEC4:                      numElements = count_ * 4; break;
+        case GL_INT:                             numElements = count_ * 1; break;
+        case GL_INT_VEC2:                        numElements = count_ * 2; break;
+        case GL_INT_VEC3:                        numElements = count_ * 3; break;
+        case GL_INT_VEC4:                        numElements = count_ * 4; break;
+        case GL_UNSIGNED_INT:                    numElements = count_ * 1; break;
+        case GL_UNSIGNED_INT_VEC2:               numElements = count_ * 2; break;
+        case GL_UNSIGNED_INT_VEC3:               numElements = count_ * 3; break;
+        case GL_UNSIGNED_INT_VEC4:               numElements = count_ * 4; break;
+        case GL_BOOL:                            numElements = count_ * 1; break;
+        case GL_BOOL_VEC2:                       numElements = count_ * 2; break;
+        case GL_BOOL_VEC3:                       numElements = count_ * 3; break;
+        case GL_BOOL_VEC4:                       numElements = count_ * 4; break;
+        case GL_FLOAT_MAT2:                      numElements = count_ * 4; break; // 2x2
+        case GL_FLOAT_MAT3:                      numElements = count_ * 9; break; // 3x3
+        case GL_FLOAT_MAT4:                      numElements = count_ * 16; break; // 4x4
+        case GL_FLOAT_MAT2x3:                    numElements = count_ * 6; break; // 2x3
+        case GL_FLOAT_MAT2x4:                    numElements = count_ * 8; break; // 2x4
+        case GL_FLOAT_MAT3x2:                    numElements = count_ * 6; break; // 3x2
+        case GL_FLOAT_MAT3x4:                    numElements = count_ * 12; break; // 3x4
+        case GL_FLOAT_MAT4x2:                    numElements = count_ * 8; break; // 4x2
+        case GL_FLOAT_MAT4x3:                    numElements = count_ * 12; break; // 4x3
+        case GL_SAMPLER_1D:
+        case GL_SAMPLER_2D:
+        case GL_SAMPLER_3D:
+        case GL_SAMPLER_CUBE:
+        case GL_SAMPLER_1D_SHADOW:
+        case GL_SAMPLER_2D_SHADOW:
+        case GL_SAMPLER_CUBE_SHADOW:
+        case GL_SAMPLER_1D_ARRAY:
+        case GL_SAMPLER_2D_ARRAY:
+        case GL_SAMPLER_1D_ARRAY_SHADOW:
+        case GL_SAMPLER_2D_ARRAY_SHADOW:
+        case GL_SAMPLER_BUFFER:
+        case GL_SAMPLER_2D_MULTISAMPLE:
+        case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:    numElements = count_ * 1; break;
+        default:
+            MG_Util::Debug::LogW("MG_State: Program: UniformValue::setData warning: unsupported type 0x%X for numElements", uniformType);
+            numElements = 1;
+            return;
+    }
+
+    for (GLsizei i = 0; i < numElements; ++i) {
+        switch (uniformType) {
+            case GL_FLOAT:
+            case GL_FLOAT_VEC2:
+            case GL_FLOAT_VEC3:
+            case GL_FLOAT_VEC4:
+            case GL_FLOAT_MAT2:
+            case GL_FLOAT_MAT3:
+            case GL_FLOAT_MAT4:
+            case GL_FLOAT_MAT2x3:
+            case GL_FLOAT_MAT2x4:
+            case GL_FLOAT_MAT3x2:
+            case GL_FLOAT_MAT3x4:
+            case GL_FLOAT_MAT4x2:
+            case GL_FLOAT_MAT4x3:
+                floatData.push_back(static_cast<GLfloat>(values[i]));
+                break;
+            case GL_INT:
+            case GL_INT_VEC2:
+            case GL_INT_VEC3:
+            case GL_INT_VEC4:
+            case GL_SAMPLER_1D:
+            case GL_SAMPLER_2D:
+            case GL_SAMPLER_3D:
+            case GL_SAMPLER_CUBE:
+            case GL_SAMPLER_1D_SHADOW:
+            case GL_SAMPLER_2D_SHADOW:
+            case GL_SAMPLER_CUBE_SHADOW:
+            case GL_SAMPLER_1D_ARRAY:
+            case GL_SAMPLER_2D_ARRAY:
+            case GL_SAMPLER_1D_ARRAY_SHADOW:
+            case GL_SAMPLER_2D_ARRAY_SHADOW:
+            case GL_SAMPLER_BUFFER:
+            case GL_SAMPLER_2D_MULTISAMPLE:
+            case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
+                intData.push_back(static_cast<GLint>(values[i]));
+                break;
+            case GL_UNSIGNED_INT:
+            case GL_UNSIGNED_INT_VEC2:
+            case GL_UNSIGNED_INT_VEC3:
+            case GL_UNSIGNED_INT_VEC4:
+                uintData.push_back(static_cast<GLuint>(values[i]));
+                break;
+            case GL_BOOL:
+            case GL_BOOL_VEC2:
+            case GL_BOOL_VEC3:
+            case GL_BOOL_VEC4:
+                boolData.push_back(values[i] ? GL_TRUE : GL_FALSE);
+                break;
+            default:
+                MG_Util::Debug::LogW("MG_State: Program: UniformValue::setData warning: unsupported type 0x%X", uniformType);
+                break;
+        }
+    }
+    MG_Util::Debug::LogD("MG_State: Program: UniformValue::setData end");
+}

MG/MG_GL/State/Program/ProgramState.h

@@ -0,0 +1,126 @@
+//
+// Created by BZLZHH on 2025/5/1.
+//
+
+#ifndef MOBILEGL_PROGRAMSTATE_H
+#define MOBILEGL_PROGRAMSTATE_H
+#define MOBILEGL_GLSTATE_H
+#define MOBILEGL_PROGRAM_DEBUGTOOL_H
+#define MOBILEGL_GLSLTOOL_H
+
+#include "../../../Includes.h"
+
+struct ShaderObject {
+    GLenum type;
+    std::string source;
+    std::vector<unsigned int> compiledSpirv;
+    UncertainBool compiled;
+    GLint compileStatus;
+    std::string infoLog;
+    bool markedForDeletion;
+};
+
+struct UniformValue {
+    GLenum type;
+    std::vector<GLfloat> floatData;
+    std::vector<GLint> intData;
+    std::vector<GLuint> uintData;
+    std::vector<GLboolean> boolData;
+    GLsizei count;
+    GLsizei numElements;
+
+    UniformValue() : type(0), count(0) {}
+
+    template<typename T>
+    void setData(GLenum uniformType, GLsizei count_, const T* values);
+};
+
+struct ProgramObject {
+    std::vector<GLuint> attachedShaders;
+    UncertainBool linked;
+    bool dirty;
+    GLint linkStatus;
+    std::string infoLog;
+    ankerl::unordered_map<std::string, GLint> attribBindings;
+    ankerl::unordered_map<std::string, GLint> attribLocations;
+    ankerl::unordered_map<std::string, GLint> uniformLocations;
+    ankerl::unordered_map<std::string, UniformValue> uniformValues;
+    bool markedForDeletion;
+};
+
+class ProgramState {
+public:
+    ankerl::unordered_map<GLuint, ShaderObject> shaders_;
+    ankerl::unordered_map<GLuint, ProgramObject> programs_;
+    std::set<GLuint> freeShaderIds_;
+    std::set<GLuint> freeProgramIds_;
+    GLuint lastShaderId_ = 0;
+    GLuint lastProgramId_ = 0;
+    GLuint currentProgram_ = 0;
+
+    ProgramState();
+    ~ProgramState();
+    
+    // Return: the validity of the operation, according to OpenGL 3 standard
+    GLenum CreateShader(GLenum type, GLuint* shader);
+    GLenum CreateProgram(GLuint* program);
+    GLenum DeleteShader(GLuint shader);
+    GLenum DeleteProgram(GLuint program);
+    GLenum LinkShaderToProgram(GLuint program, GLuint shader);
+    GLenum UploadShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length);
+    GLenum BuildShaderStage(GLuint shader);
+    GLenum FinalizeProgramPipeline(GLuint program);
+    GLenum ActivateRenderProgram(GLuint program);
+    GLenum DefineProgramAttributeBinding(GLuint program, GLuint index, const GLchar* name);
+    GLint QueryProgramAttributeBinding(GLuint program, const GLchar* name);
+    GLint QueryProgramUniformLocation(GLuint program, const GLchar* name);
+    GLenum QueryProgramStateIntVector(GLuint program, GLenum pname, GLint* params);
+    GLenum QueryShaderStateIntVector(GLuint shader, GLenum pname, GLint* params);
+
+    template<typename T>
+    GLenum SetUniform(GLuint program, GLint location, GLsizei count, const T* value, GLenum type);
+
+    template<typename T>
+    GLenum SetUniformMatrix(GLuint program, GLint location, GLsizei count, GLboolean transpose, const T* value, GLenum matrixType);
+    
+#define DECLARE_UNIFORM_FUNCTIONS(type, suffix, vecType) \
+    void UpdateUniform##suffix##1(GLint location, type v0); \
+    void UpdateUniform##suffix##2(GLint location, type v0, type v1); \
+    void UpdateUniform##suffix##3(GLint location, type v0, type v1, type v2); \
+    void UpdateUniform##suffix##4(GLint location, type v0, type v1, type v2, type v3); \
+    void UpdateUniform##suffix##Vector1(GLint location, GLsizei count, const type* value); \
+    void UpdateUniform##suffix##Vector2(GLint location, GLsizei count, const type* value); \
+    void UpdateUniform##suffix##Vector3(GLint location, GLsizei count, const type* value); \
+    void UpdateUniform##suffix##Vector4(GLint location, GLsizei count, const type* value);
+    DECLARE_UNIFORM_FUNCTIONS(GLfloat, Float, GL_FLOAT)
+    DECLARE_UNIFORM_FUNCTIONS(GLint, Int, GL_INT)
+    DECLARE_UNIFORM_FUNCTIONS(GLuint, UInt, GL_UNSIGNED_INT)
+    DECLARE_UNIFORM_FUNCTIONS(GLboolean, Bool, GL_BOOL)
+#undef DECLARE_UNIFORM_FUNCTIONS
+#define DECLARE_MATRIX_FUNCTIONS(suffix, matrixType) \
+    void UpdateUniformMatrix##suffix##Vector(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
+    DECLARE_MATRIX_FUNCTIONS(2x2, GL_FLOAT_MAT2)
+    DECLARE_MATRIX_FUNCTIONS(3x3, GL_FLOAT_MAT3)
+    DECLARE_MATRIX_FUNCTIONS(4x4, GL_FLOAT_MAT4)
+    DECLARE_MATRIX_FUNCTIONS(2x3, GL_FLOAT_MAT2x3)
+    DECLARE_MATRIX_FUNCTIONS(2x4, GL_FLOAT_MAT2x4)
+    DECLARE_MATRIX_FUNCTIONS(3x2, GL_FLOAT_MAT3x2)
+    DECLARE_MATRIX_FUNCTIONS(3x4, GL_FLOAT_MAT3x4)
+    DECLARE_MATRIX_FUNCTIONS(4x2, GL_FLOAT_MAT4x2)
+    DECLARE_MATRIX_FUNCTIONS(4x3, GL_FLOAT_MAT4x3)
+#undef DECLARE_MATRIX_FUNCTIONS
+    
+    ProgramObject GetProgramObject(GLuint program) const;
+    ShaderObject GetShaderObject(GLuint program) const;
+    GLuint GetCurrentProgram() const;
+    bool SetProgramStatus(GLuint program, GLboolean status);
+    bool SetShaderStatus(GLuint shader, GLboolean status);
+
+private:
+    bool ValidateShader_(GLuint shader);
+    bool ValidateProgram_(GLuint program);
+    void CleanupShaders_();
+    GLint GetUniformLocation_(GLuint program, GLint location, const GLchar* name);
+};
+
+#endif // MOBILEGL_PROGRAMSTATE_H

MG/MG_GL/State/Program/ShaderObject.cpp

@@ -0,0 +1,139 @@
+//
+// Created by BZLZHH on 2025/5/3.
+//
+
+#include "ShaderObject.h"
+
+// Re-Include Includes.h, cuz of the absence of Program/DebugTool.h and Program/GLSLTool.cpp.
+#undef MOBILEGL_GLSLTOOL_H
+#undef MOBILEGL_PROGRAM_DEBUGTOOL_H
+#include "../../../Includes.h"
+
+GLenum ProgramState::CreateShader(GLenum type, GLuint* shader) {
+    MG_Util::Debug::LogD("MG_State: Program: CreateShader called, type=0x%X, shader ptr=%p", type, shader);
+    if (!shader) {
+        MG_Util::Debug::LogE("MG_State: Program: CreateShader error: shader pointer is null");
+        return GL_INVALID_VALUE;
+    }
+    if (type != GL_VERTEX_SHADER && type != GL_FRAGMENT_SHADER) {
+        MG_Util::Debug::LogE("MG_State: Program: CreateShader error: invalid shader type 0x%X", type);
+        return GL_INVALID_ENUM;
+    }
+
+    GLuint id = freeShaderIds_.empty() ? ++lastShaderId_ : *freeShaderIds_.begin();
+    if (!freeShaderIds_.empty())
+        freeShaderIds_.erase(freeShaderIds_.begin());
+
+    ShaderObject obj;
+    obj.type = type;
+    obj.compiled = {UncertainBool::Unknown, UncertainBool::False};
+    obj.compiledSpirv = {};
+    obj.markedForDeletion = false;
+    obj.compileStatus = GL_FALSE;
+    shaders_[id] = obj;
+    *shader = id;
+    MG_Util::Debug::LogD("MG_State: Program: CreateShader success, new shader id=%u", id);
+    return GL_NO_ERROR;
+}
+
+GLenum ProgramState::DeleteShader(GLuint shader) {
+    MG_Util::Debug::LogD("MG_State: Program: DeleteShader called, shader id=%u", shader);
+    if (!ValidateShader_(shader)) {
+        MG_Util::Debug::LogE("MG_State: Program: DeleteShader error: invalid shader id %u", shader);
+        return GL_INVALID_VALUE;
+    }
+    if (shaders_[shader].markedForDeletion) {
+        MG_Util::Debug::LogW("MG_State: Program: DeleteShader warning: shader %u already marked for deletion", shader);
+        return GL_NO_ERROR;
+    }
+
+    bool inUse = false;
+    for (auto& [progId, program] : programs_) {
+        if (std::find(program.attachedShaders.begin(),
+                      program.attachedShaders.end(), shader) != program.attachedShaders.end()) {
+            inUse = true;
+            break;
+        }
+    }
+    if (inUse) {
+        shaders_[shader].markedForDeletion = true;
+        MG_Util::Debug::LogD("MG_State: Program: DeleteShader info: shader %u marked for deferred deletion (in use)", shader);
+    } else {
+        shaders_.erase(shader);
+        // TODO: Prevent the object that uses a freeId from conflicting with legacy object in the backend.
+        //freeShaderIds_.insert(shader);
+        MG_Util::Debug::LogD("MG_State: Program: DeleteShader success: shader %u deleted immediately", shader);
+    }
+    return GL_NO_ERROR;
+}
+
+GLenum ProgramState::UploadShaderSource(GLuint shader, GLsizei count,
+                                        const GLchar** string, const GLint* length) {
+    MG_Util::Debug::LogD("MG_State: Program: UploadShaderSource called, shader id=%u, count=%d", shader, count);
+    if (!ValidateShader_(shader)) {
+        MG_Util::Debug::LogE("MG_State: Program: UploadShaderSource error: invalid shader id %u", shader);
+        return GL_INVALID_VALUE;
+    }
+    if (count < 0) {
+        MG_Util::Debug::LogE("MG_State: Program: UploadShaderSource error: negative count %d", count);
+        return GL_INVALID_VALUE;
+    }
+
+    std::string source;
+    for (GLsizei i = 0; i < count; ++i) {
+        const GLchar* str = string[i];
+        GLint len = (length && length[i] >= 0) ? length[i] : strlen(str);
+        source.append(str, len);
+    }
+    shaders_[shader].source = std::move(source);
+    MG_Util::Debug::LogD("MG_State: Program: UploadShaderSource success: source uploaded (length=%zu)", shaders_[shader].source.size());
+    return GL_NO_ERROR;
+}
+
+GLenum ProgramState::BuildShaderStage(GLuint shader) {
+    MG_Util::Debug::LogD("MG_State: Program: BuildShaderStage called, shader id=%u", shader);
+    if (!ValidateShader_(shader)) {
+        MG_Util::Debug::LogE("MG_State: Program: BuildShaderStage error: invalid shader id %u", shader);
+        return GL_INVALID_VALUE;
+    }
+    auto& obj = shaders_[shader];
+
+    std::string compilationLog;
+    auto spirv = MG_Util::Program::CompileGLSLToSPIRV(obj.type, obj.source, compilationLog);
+    if (spirv.empty()) {
+        obj.infoLog = "Shader compilation failed: " + compilationLog;
+        obj.compiled = UncertainBool::False;
+        obj.compileStatus = GL_FALSE;
+        MG_Util::Debug::LogE("MG_State: Program: BuildShaderStage error: %s", compilationLog.c_str());
+        return GL_INVALID_OPERATION;
+    }
+    obj.compiledSpirv = spirv;
+    obj.compiled = {UncertainBool::Unknown, UncertainBool::True};
+    obj.compileStatus = GL_TRUE;
+    obj.infoLog.clear();
+    MG_Util::Debug::LogD("MG_State: Program: BuildShaderStage success: shader %u compiled to SPIR-V (size=%zu bytes)", shader, spirv.size() * sizeof(unsigned));
+    return GL_NO_ERROR;
+}
+
+bool ProgramState::SetShaderStatus(GLuint shader, GLboolean status) {
+    MG_Util::Debug::LogD("MG_State: Program: SetShaderStatus called, shader id=%u, status=%d", shader, status);
+    if (!ValidateShader_(shader)) {
+        MG_Util::Debug::LogE("MG_State: Program: SetShaderStatus error: invalid shader id %u", shader);
+        return false;
+    }
+    auto& obj = shaders_[shader];
+    if (obj.compiled.getValue() != UncertainBool::Unknown) {
+        MG_Util::Debug::LogW("MG_State: Program: SetShaderStatus warning: shader %u status already set", shader);
+        return false;
+    }
+    obj.compiled = (status == GL_TRUE) ? UncertainBool::True : UncertainBool::False;
+    obj.compileStatus = status;
+    MG_Util::Debug::LogD("MG_State: Program: SetShaderStatus success: shader %u status=%d", shader, status);
+    return true;
+}
+
+bool ProgramState::ValidateShader_(GLuint shader) {
+    bool valid = shaders_.count(shader) && !shaders_[shader].markedForDeletion;
+    MG_Util::Debug::LogD("MG_State: Program: ValidateShader_ called, shader id=%u, result=%d", shader, valid);
+    return valid;
+}

MG/MG_GL/State/Program/ShaderObject.h

@@ -0,0 +1,12 @@
+//
+// Created by BZLZHH on 2025/5/3.
+//
+
+#ifndef MOBILEGL_SHADEROBJECT_H
+#define MOBILEGL_SHADEROBJECT_H
+
+#define MOBILEGL_GLSTATE_H
+
+#include "../../../Includes.h"
+
+#endif //MOBILEGL_SHADEROBJECT_H

MG/MG_GL/State/Texture/TextureState.h

@@ -0,0 +1,117 @@
+//
+// Created by BZLZHH on 2025/4/4.
+//
+
+#ifndef MOBILEGL_TEXTURESTATE_H
+#define MOBILEGL_TEXTURESTATE_H
+#define MOBILEGL_GLSTATE_H
+
+#include "../../../Includes.h"
+
+struct ComponentSizes {
+    GLint red = 0;  
+    GLint green = 0;
+    GLint blue = 0; 
+    GLint alpha = 0;
+    GLint depth = 0;
+    GLint stencil = 0;
+    bool isCompressed = false;
+};
+
+struct TextureParams {
+    template <typename K, typename V>
+    using unordered_map = ankerl::unordered_dense::map<K, V>;
+    unordered_map<GLenum, GLfloat> texPropertiesFloat;
+    unordered_map<GLenum, GLint> texPropertiesInt;
+    struct MipmapLevel {
+        GLsizei width = 0;
+        GLsizei height = 0;
+        GLenum format = GL_RGBA;
+        GLenum internalFormat = GL_RGBA;
+        GLenum type = GL_UNSIGNED_BYTE;
+        std::vector<GLubyte> pixelData;
+        bool hasData = false;
+        bool dirty = false; // TODO: encapsulate this with an public API to RHI
+    };
+    unordered_map<GLint, MipmapLevel> mipmapData;
+};
+
+class TextureObject {
+public:
+    bool generated = false;
+    GLenum target = GL_NONE;
+    TextureParams params;
+    const void* data = nullptr;
+    bool IsImmutable() const;
+    uint64_t createTimestamp{};
+};
+
+class TextureUnitState {
+    template <typename K, typename V>
+    using unordered_map = ankerl::unordered_dense::map<K, V>;
+private:
+    GLenum activeTarget = GL_TEXTURE_2D;
+    
+public:
+    unordered_map<GLenum, GLuint> boundTextures;
+    void Bind(GLenum target, GLuint texture);
+    GLuint GetBoundTexture(GLenum target);
+};
+
+class TextureState {
+    template <typename K, typename V>
+    using unordered_map = ankerl::unordered_dense::map<K, V>;
+private:
+
+    GLuint lastUsedID_ = 1;
+//    ankerl::unordered_set<GLuint> freeIDs_;
+    std::vector<GLuint> freeID_;
+
+    unordered_map<GLenum, TextureObject> proxyTextures_;
+    
+    static GLint GetUnpackParam_(GLenum pname);
+public:
+    TextureState();
+    
+    bool IsTextureGenerated(GLuint texture);
+    bool IsTexture(GLuint texture);
+    unordered_map<GLuint, TextureObject> textures;
+
+    // Return: the validity of the operation, according to OpenGL 3 standard
+    GLenum BindUnit(GLenum textureUnit);
+    GLenum Create(GLuint* texture);
+    GLenum CreateN(GLsizei n, GLuint* textures);
+    GLenum Bind(GLenum target, GLuint texture);
+    GLenum Upload2D(GLenum target, GLint level, GLint internalFormat,
+                    GLsizei width, GLsizei height, GLint border, GLenum format,
+                    GLenum type, const void* data);
+    GLenum UpdateRegion2D(GLenum target, GLint level, GLint xoffset,
+                          GLint yoffset, GLsizei width, GLsizei height, GLenum format,
+                          GLenum type, const GLvoid* data);
+    GLenum SetTexturePropertyInt(GLenum target, GLenum pname, GLint param);
+    GLenum SetTexturePropertyFloat(GLenum target, GLenum pname, GLfloat param);
+    GLenum Delete(GLuint texture);
+    GLenum DeleteN(GLsizei n, const GLuint* textures);
+    GLenum QueryLevelPropertyIntVector(GLenum target, GLint level, GLenum pname, GLint* params);
+
+    std::vector<TextureUnitState> textureUnits_;
+    GLuint activeTextureUnit_ = 0;
+private:
+    size_t CalculatePixelDataSize_(GLenum format, GLenum type, GLsizei width, GLsizei height);
+    void InvalidateTextureInAllUnits_(GLuint texture);
+    static ComponentSizes GetComponentSize_s_(GLenum internalFormat);
+    size_t CalculateBytesPerPixel_(GLenum format, GLenum type);
+    static size_t GetComponentSize_(GLenum type);
+    void SwapBytesForTexture_(GLenum format, GLenum type, const GLubyte* src, GLubyte* dst, GLsizei width);
+    static void ReverseBitOrder_(const GLubyte* src, GLubyte* dst, size_t size);
+    static GLubyte ReverseBits_(GLubyte b);
+    void SwapPixelBytes_(GLenum format, GLenum type, const GLubyte* src, GLubyte* dst);
+    GLenum CheckUploadingTexture2DValidity_(GLenum target, GLint level, GLint internalFormat,
+                                            GLsizei width, GLsizei height, GLint border, GLenum format,
+                                            GLenum type, const void* data);
+    GLenum CheckUpdatingTextureRegion2DValidity_(GLenum target, GLint level, GLint xoffset,
+                                                 GLint yoffset, GLsizei width, GLsizei height, GLenum format,
+                                                 GLenum type, const GLvoid* data);
+};
+
+#endif //MOBILEGL_TEXTURESTATE_H

MG/MG_GL/State/VertexArray/VertexArrayState.cpp

@@ -0,0 +1,162 @@
+//
+// Created by BZLZHH on 2025/5/1.
+//
+
+// TODO: Add more gl error check for vertex array state manager.
+
+#include "VertexArrayState.h"
+
+VertexArrayState::VertexArrayState() {
+    vaos_[0];
+}
+
+GLenum VertexArrayState::GenName(GLuint *array) {
+    MG_Util::Debug::LogD("MG_State: VAO: GenName");
+    if (!array)
+        return GL_INVALID_VALUE;
+    GLuint id;
+    if (freeIds_.empty()) {
+        id = ++lastId_;
+    } else {
+        id = *freeIds_.begin();
+        freeIds_.erase(freeIds_.begin());
+    }
+    *array = id;
+    MG_Util::Debug::LogD("MG_State: VAO: Generated new name %d", id);
+    return GL_NO_ERROR;
+}
+
+GLenum VertexArrayState::GenNameN(GLsizei n, GLuint* arrays) {
+    MG_Util::Debug::LogD("MG_State: VAO: GenNameN called with n=%d", n);
+    if (n < 0)
+        return GL_INVALID_VALUE;
+    for (GLsizei i = 0; i < n; ++i) {
+        GLenum result = GenName(&arrays[i]);
+        if (result != GL_NO_ERROR) {
+            MG_Util::Debug::LogE("MG_State: VAO: GenNameN failed at index %d with error 0x%x", i, result);
+            return result;
+        }
+    }
+    MG_Util::Debug::LogD("MG_State: VAO: GenNameN created %d names", n);
+    return GL_NO_ERROR;
+}
+
+GLenum VertexArrayState::Create(GLuint* array) {
+    if (array == nullptr) return GL_INVALID_VALUE;
+
+    GLuint id = freeIds_.empty() ? ++lastId_ : *freeIds_.begin();
+    if (!freeIds_.empty()) {
+        freeIds_.erase(freeIds_.begin());
+    }
+
+    *array = id;
+    vaos_[id].generated = true;
+    return GL_NO_ERROR;
+}
+
+GLenum VertexArrayState::CreateN(GLsizei n, GLuint* arrays) {
+    if (n < 0) {
+        return GL_INVALID_VALUE; 
+    }
+
+    if (n > 0 && arrays == nullptr) {
+        return GL_INVALID_VALUE;
+    }
+
+    for (GLsizei i = 0; i < n; ++i) {
+        if (GLenum error = Create(&arrays[i]); error != GL_NO_ERROR) {
+            return error;
+        }
+    }
+    return GL_NO_ERROR;
+}
+
+GLenum VertexArrayState::Bind(GLuint array) {
+    MG_Util::Debug::LogD("MG_State: VAO: Bind called for %u", array);
+    if (array != 0) {
+        if (!ValidateGeneratedName(array)) {
+            MG_Util::Debug::LogE("MG_State: VAO: Bind invalid name %u", array);
+            return GL_INVALID_OPERATION;
+        }
+        auto& vao = vaos_[array];
+        if (!vao.generated) {
+            MG_Util::Debug::LogD("MG_State: VAO: Creating VAO %u during bind", array);
+            vao.generated = true;
+        }
+    }
+    currentVao_ = array;
+    MG_Util::Debug::LogD("MG_State: VAO: Bound to %u", array);
+    return GL_NO_ERROR;
+}
+
+bool VertexArrayState::ValidateGeneratedName(GLuint array) {
+    if (array == 0)
+        return true;
+    bool inFreeList = freeIds_.count(array) > 0;
+    bool valid = (array <= lastId_) && !inFreeList;
+    MG_Util::Debug::LogD("MG_State: VAO: ValidateGeneratedName %u: %d", array, valid);
+    return valid;
+}
+
+bool VertexArrayState::ValidateAllocatedHandle(GLuint array) {
+    bool exists = vaos_.count(array) && vaos_[array].generated;
+    MG_Util::Debug::LogD("MG_State: VAO: ValidateAllocatedHandle %u: %d", array, exists);
+    return exists;
+}
+
+GLenum VertexArrayState::EnableAttrib(GLuint index) {
+    if (!ValidateAllocatedHandle(currentVao_))
+        return GL_INVALID_OPERATION;
+    if (index >= GL_MAX_VERTEX_ATTRIBS) return GL_INVALID_VALUE;
+    GetCurrentVAO()->attribs[index].enabled = true;
+    MG_Util::Debug::LogD("Attrib vaos_[%u].attribs[%u].enabled = %d", currentVao_, index, vaos_[currentVao_].attribs[index].enabled);
+
+    GetCurrentVAO()->attribDirty = true;
+    return GL_NO_ERROR;
+}
+
+GLenum VertexArrayState::DisableAttrib(GLuint index) {
+    if (!ValidateAllocatedHandle(currentVao_))
+        return GL_INVALID_OPERATION;
+    if (index >= GL_MAX_VERTEX_ATTRIBS) return GL_INVALID_VALUE;
+    GetCurrentVAO()->attribs[index].enabled = false;
+    MG_Util::Debug::LogD("Attrib vaos_[%u].attribs[%u].enabled = %d", currentVao_, index, vaos_[currentVao_].attribs[index].enabled);
+
+    GetCurrentVAO()->attribDirty = true;
+    return GL_NO_ERROR;
+}
+
+GLenum VertexArrayState::SetAttribPointer(GLuint index, GLint size, GLenum type,
+                                          GLboolean normalized, GLsizei stride,
+                                          const void* pointer, bool isInteger,
+                                          GLuint currentArrayBuffer) {
+    if (!ValidateAllocatedHandle(currentVao_))
+        return GL_INVALID_OPERATION;
+    if (index >= GL_MAX_VERTEX_ATTRIBS) return GL_INVALID_VALUE;
+
+    VertexAttribState state;
+    state.size = size;
+    state.type = type;
+    state.normalized = normalized;
+    state.stride = stride;
+    state.pointer = pointer;
+    state.buffer = currentArrayBuffer;
+    state.isInteger = isInteger;
+    if (vaos_[currentVao_].attribs.count(index) && vaos_[currentVao_].attribs[index].enabled)
+        state.enabled = true;
+
+    vaos_[currentVao_].attribs[index] = state;
+
+    GetCurrentVAO()->attribDirty = true;
+    return GL_NO_ERROR;
+}
+
+GLuint VertexArrayState::GetBoundElementBuffer() {
+    auto it = vaos_.find(currentVao_);
+    return (it != vaos_.end()) ? it->second.elementBuffer : 0;
+}
+
+VertexArrayObject* VertexArrayState::GetCurrentVAO() {
+    auto it = vaos_.find(currentVao_);
+    return (it != vaos_.end()) ? &it->second : &vaos_.at(0);
+}

MG/MG_GL/State/VertexArray/VertexArrayState.h

@@ -0,0 +1,59 @@
+//
+// Created by BZLZHH on 2025/5/1.
+//
+
+#ifndef MOBILEGL_VERTEXARRAYSTATE_H
+#define MOBILEGL_VERTEXARRAYSTATE_H
+#define MOBILEGL_GLSTATE_H
+
+#include "../../../Includes.h"
+
+struct VertexAttribState {
+    bool enabled;
+    GLint size = 4;
+    GLenum type = GL_FLOAT;
+    GLboolean normalized = GL_FALSE;
+    GLsizei stride = 0;
+    const GLvoid* pointer = nullptr;
+    GLuint buffer = 0;
+    bool isInteger = false;
+};
+
+struct VertexArrayObject {
+    bool generated = false;
+    bool attribDirty = false;
+    bool eboDirty = false;
+    GLuint elementBuffer = 0;
+    ankerl::unordered_map<GLuint, VertexAttribState> attribs;
+};
+
+class VertexArrayState {
+public:
+    VertexArrayState();
+    
+    // Return: the validity of the operation, according to OpenGL 3 standard
+    GLenum GenName(GLuint* array);
+    GLenum GenNameN(GLsizei n, GLuint* arrays);
+    GLenum Create(GLuint* array);
+    GLenum CreateN(GLsizei n, GLuint* arrays);
+    GLenum Bind(GLuint array);
+    GLenum EnableAttrib(GLuint index);
+    GLenum DisableAttrib(GLuint index);
+    GLenum SetAttribPointer(GLuint index, GLint size, GLenum type,
+                            GLboolean normalized, GLsizei stride,
+                            const void* pointer, bool isInteger,
+                            GLuint currentArrayBuffer);
+    
+    GLuint GetBoundElementBuffer();
+    VertexArrayObject* GetCurrentVAO();
+    bool ValidateGeneratedName(GLuint array);
+    bool ValidateAllocatedHandle(GLuint array);
+
+    GLuint currentVao_ = 0;
+    ankerl::unordered_map<GLuint, VertexArrayObject> vaos_;
+private:
+    std::set<GLuint> freeIds_;
+    GLuint lastId_ = 0;
+};
+
+#endif //MOBILEGL_VERTEXARRAYSTATE_H

MG/MG_Include/UncertainBool.hpp

@@ -0,0 +1,127 @@
+//
+// Created by BZLZHH on 2025/5/3.
+//
+
+#pragma once
+#include <initializer_list>
+#include <stdexcept>
+#include <utility>
+
+class UncertainBool {
+public:
+    enum Value { False = 0, True = 1, Unknown = 2 };
+
+    UncertainBool() : value_(False), default_(false) {}
+
+    explicit UncertainBool(bool b) : value_(b ? True : False), default_(false) {}
+
+    UncertainBool(Value val, bool def) : value_(val), default_(def) {
+        validateValue();
+    }
+    
+    UncertainBool(bool val, bool def) : value_(val ? True : False), default_(def) {
+        validateValue();
+    }
+    
+    UncertainBool& operator=(Value val) {
+        value_ = val;
+        validateValue();
+        return *this;
+    }
+    
+    UncertainBool& operator=(bool b) {
+        value_ = b ? True : False;
+        return *this;
+    }
+    
+    UncertainBool& operator=(std::initializer_list<std::pair<bool, bool>> init) {
+        if (init.size() != 1) throw std::invalid_argument("Invalid initializer");
+        value_ = init.begin()->first ? True : False;
+        default_ = init.begin()->second;
+        return *this;
+    }
+    
+    explicit operator bool() const {
+        return toBool();
+    }
+    
+    bool toBool() const {
+        if (value_ == True)       return true;
+        else if (value_ == False) return false;
+        else                      return default_;
+    }
+
+    UncertainBool operator!() const {
+        return {static_cast<bool>(*this) ? False : True, false};
+    }
+
+    bool operator==(const UncertainBool& rhs) const {
+        return static_cast<bool>(*this) == static_cast<bool>(rhs);
+    }
+    bool operator!=(const UncertainBool& rhs) const { return !(*this == rhs); }
+
+    friend UncertainBool operator&&(const UncertainBool& lhs, const UncertainBool& rhs) {
+        bool actualDefault = lhs.default_ && rhs.default_;
+        if(lhs.value_ == False || rhs.value_ == False) return {False,actualDefault};
+        else if(lhs.value_ == True && rhs.value_ == True) return {True,actualDefault};
+        else return {Unknown, actualDefault};
+    }
+
+    friend UncertainBool operator||(const UncertainBool& lhs, const UncertainBool& rhs) {
+        bool actualDefault = lhs.default_ || rhs.default_;
+        if(lhs.value_ == True || rhs.value_ == True) return {True,actualDefault};
+        else if(lhs.value_ == False && rhs.value_ == False) return {False,actualDefault};
+        else return {Unknown, actualDefault};
+    }
+    
+    friend UncertainBool operator&&(bool lhs,const UncertainBool& rhs){
+        return UncertainBool(lhs, lhs) && rhs;
+    }
+
+    friend UncertainBool operator||(bool lhs,const UncertainBool& rhs){
+        return UncertainBool(lhs, lhs) || rhs;
+    }
+
+    UncertainBool& operator&=(const UncertainBool& rhs) {
+        *this = *this && rhs;
+        return *this;
+    }
+
+    UncertainBool& operator|=(const UncertainBool& rhs) {
+        *this = *this || rhs;
+        return *this;
+    }
+
+    UncertainBool& operator=(std::initializer_list<std::pair<Value, bool>> init) {
+        if (init.size() != 1) throw std::invalid_argument("Invalid initializer");
+        value_ = init.begin()->first;
+        default_ = init.begin()->second;
+        validateValue();
+        return *this;
+    }
+
+    Value getValue() const { return value_; }
+    bool getDefault() const { return default_; }
+
+private:
+    Value value_;
+    bool default_;
+
+    void validateValue() {
+        if (value_ != False && value_ != True && value_ != Unknown) {
+            throw std::invalid_argument("Invalid value");
+        }
+    }
+};
+
+inline UncertainBool operator!(const UncertainBool& lhs) {
+    return lhs.operator!();
+}
+
+inline bool operator==(bool lhs, const UncertainBool& rhs) {
+    return static_cast<bool>(rhs) == lhs;
+}
+
+inline bool operator!=(bool lhs, const UncertainBool& rhs) {
+    return !(lhs == rhs);
+}

MG/MG_RHI/GLES/Test/TestDrawing.cpp

@@ -0,0 +1,234 @@
+//
+// Created by BZLZHH on 2025/4/26.
+//
+
+#include "TestDrawing.h"
+
+namespace MG_RHI::GLES::Test {
+    constexpr int DISPLAY_COLUMNS = 8;
+    constexpr int DISPLAY_ROWS    = 10;
+    constexpr int MAX_DISPLAY_TEXTURES = DISPLAY_COLUMNS * DISPLAY_ROWS;
+
+    bool IsTextureComplete(const TextureObject& tex) {
+        return !tex.params.mipmapData.empty();
+    }
+
+    bool CheckShaderCompileStatus(GLuint shader, const char* type) {
+        GLint success;
+        ::GLES::glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+        if (!success) {
+            GLchar infoLog[512];
+            ::GLES::glGetShaderInfoLog(shader, 512, NULL, infoLog);
+            MG_Util::Debug::LogE("Shader compilation error (%s): %s", type, infoLog);
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckProgramLinkStatus(GLuint program) {
+        GLint success;
+        ::GLES::glGetProgramiv(program, GL_LINK_STATUS, &success);
+        if (!success) {
+            GLchar infoLog[512];
+            ::GLES::glGetProgramInfoLog(program, 512, NULL, infoLog);
+            MG_Util::Debug::LogE("Program link error: %s", infoLog);
+            return false;
+        }
+        return true;
+    }
+
+    // TODO: Use the textures state from MG_RHI(another state?) rather than directly from MG_State
+    void DrawAllTextures() {
+        ::GLES::glClearColor(1,1,1,1);
+        ::GLES::glClear(GL_COLOR_BUFFER_BIT);
+        
+        struct ScreenResources {
+            GLuint program = 0;
+            GLuint quadVAO = 0;
+            GLuint quadVBO = 0;
+            GLint uTexLoc = -1;
+            GLint uMVPLoc = -1;
+            ankerl::unordered_map<GLuint, GLuint> textureCache;
+            ankerl::unordered_map<GLuint, bool> textureDirty;
+        };
+
+        static ScreenResources sRes;
+        static glm::ivec2 lastScreenSize{0, 0};
+
+        GLint viewport[4];
+        ::GLES::glGetIntegerv(GL_VIEWPORT, viewport);
+
+        const glm::ivec2 screenSize(viewport[2], viewport[3]);
+
+        if (screenSize != lastScreenSize) {
+            if (sRes.quadVAO) {
+                ::GLES::glDeleteVertexArrays(1, &sRes.quadVAO);
+                ::GLES::glDeleteBuffers(1, &sRes.quadVBO);
+                sRes.quadVAO = sRes.quadVBO = 0;
+            }
+            lastScreenSize = screenSize;
+        }
+
+        if (!sRes.program) {
+            const char* vsSrc = R"(#version 320 es
+            layout(location=0) in vec2 aPos;
+            layout(location=1) in vec2 aTexUV;
+            out vec2 vUV;
+            uniform mat4 uMVP;
+            void main() {
+                gl_Position = uMVP * vec4(aPos, 0.0, 1.0);
+                vUV = aTexUV;
+            })";
+
+            const char* fsSrc = R"(#version 320 es
+            precision mediump float;
+            in vec2 vUV;
+            uniform sampler2D uTex;
+            out vec4 FragColor;
+            void main() {
+                FragColor = texture(uTex, vUV);
+            })";
+
+            GLuint vs = ::GLES::glCreateShader(GL_VERTEX_SHADER);
+            ::GLES::glShaderSource(vs, 1, &vsSrc, NULL);
+            ::GLES::glCompileShader(vs);
+            if (!CheckShaderCompileStatus(vs, "vertex")) return;
+
+            GLuint fs = ::GLES::glCreateShader(GL_FRAGMENT_SHADER);
+            ::GLES::glShaderSource(fs, 1, &fsSrc, NULL);
+            ::GLES::glCompileShader(fs);
+            if (!CheckShaderCompileStatus(fs, "fragment")) return;
+
+            sRes.program = ::GLES::glCreateProgram();
+            ::GLES::glAttachShader(sRes.program, vs);
+            ::GLES::glAttachShader(sRes.program, fs);
+            ::GLES::glLinkProgram(sRes.program);
+            if (!CheckProgramLinkStatus(sRes.program)) return;
+
+            sRes.uTexLoc = ::GLES::glGetUniformLocation(sRes.program, "uTex");
+            sRes.uMVPLoc = ::GLES::glGetUniformLocation(sRes.program, "uMVP");
+
+            ::GLES::glDeleteShader(vs);
+            ::GLES::glDeleteShader(fs);
+        }
+
+        if (!sRes.quadVAO) {
+            const float margin = 0.01f;
+            const float gridWidth = (2.0f - 2*margin) / DISPLAY_COLUMNS;
+            const float gridHeight = (2.0f - 2*margin) / DISPLAY_ROWS;
+
+            std::vector<float> vertices;
+            vertices.reserve(MAX_DISPLAY_TEXTURES * 16);
+
+            for (int col = 0; col < DISPLAY_COLUMNS; ++col) {
+                for (int row = 0; row < DISPLAY_ROWS; ++row) {
+                    const float xStart = -1.0f + margin + col * gridWidth;
+                    const float yStart = -1.0f + margin + row * gridHeight;
+                    const float xEnd = xStart + gridWidth - margin;
+                    const float yEnd = yStart + gridHeight - margin;
+
+                    vertices.insert(vertices.end(), {
+                            xStart, yStart, 0.0f, 0.0f,
+                            xEnd,   yStart, 1.0f, 0.0f,
+                            xEnd,   yEnd,   1.0f, 1.0f,
+                            xStart, yEnd,   0.0f, 1.0f
+                    });
+                }
+            }
+
+            ::GLES::glGenVertexArrays(1, &sRes.quadVAO);
+            ::GLES::glGenBuffers(1, &sRes.quadVBO);
+            ::GLES::glBindVertexArray(sRes.quadVAO);
+            ::GLES::glBindBuffer(GL_ARRAY_BUFFER, sRes.quadVBO);
+            ::GLES::glBufferData(GL_ARRAY_BUFFER,
+                                 vertices.size() * sizeof(float),
+                                 vertices.data(),
+                                 GL_STATIC_DRAW
+            );
+
+            ::GLES::glEnableVertexAttribArray(0);
+            ::GLES::glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE,
+                                          4 * sizeof(float), (void*)0
+            );
+            ::GLES::glEnableVertexAttribArray(1);
+            ::GLES::glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,
+                                          4 * sizeof(float), (void*)(2 * sizeof(float))
+            );
+            ::GLES::glBindVertexArray(0);
+        }
+
+        std::vector<std::pair<GLuint, TextureObject*>> sortedTextures;
+        for (auto&& [stateID, texObj] : MG_State_T::textureState->textures) {
+            if (!texObj.generated || texObj.target != GL_TEXTURE_2D) continue;
+            if (texObj.params.mipmapData.empty()) continue;
+            sortedTextures.emplace_back(stateID, &texObj);
+        }
+        std::sort(sortedTextures.begin(), sortedTextures.end(),
+                  [](auto& a, auto& b) {
+                      return a.second->createTimestamp > b.second->createTimestamp;
+                  }
+        );
+        sortedTextures.resize(std::min<size_t>(sortedTextures.size(), MAX_DISPLAY_TEXTURES));
+
+        for (auto&& [stateID, texObj] : sortedTextures) {
+            auto& dirtyFlag = sRes.textureDirty[stateID];
+            bool needCreate = !sRes.textureCache.count(stateID);
+
+            if (needCreate) {
+                GLuint glTexID;
+                ::GLES::glGenTextures(1, &glTexID);
+                sRes.textureCache[stateID] = glTexID;
+                dirtyFlag = true;
+            }
+
+            if (dirtyFlag || needCreate) {
+                const auto& mip0 = texObj->params.mipmapData.begin()->second;
+                if (mip0.hasData) {
+                    GLuint glTexID = sRes.textureCache[stateID];
+                    ::GLES::glBindTexture(GL_TEXTURE_2D, glTexID);
+                    ::GLES::glTexImage2D(GL_TEXTURE_2D, 0, mip0.internalFormat,
+                                         mip0.width, mip0.height, 0,
+                                         mip0.format, mip0.type, mip0.pixelData.data()
+                    );
+                    ::GLES::glTexParameteri(GL_TEXTURE_2D,
+                                            GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+                    ::GLES::glTexParameteri(GL_TEXTURE_2D,
+                                            GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+                    ::GLES::glTexParameteri(GL_TEXTURE_2D,
+                                            GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+                    ::GLES::glTexParameteri(GL_TEXTURE_2D,
+                                            GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+                    if (texObj->params.mipmapData.size() > 1) {
+                        ::GLES::glGenerateMipmap(GL_TEXTURE_2D);
+                    }
+                    dirtyFlag = false;
+                }
+            }
+        }
+
+        GLboolean origDepthTest = ::GLES::glIsEnabled(GL_DEPTH_TEST);
+        GLint origProgram, origViewport[4];
+        ::GLES::glGetIntegerv(GL_VIEWPORT, origViewport);
+        ::GLES::glGetIntegerv(GL_CURRENT_PROGRAM, &origProgram);
+
+        ::GLES::glDisable(GL_DEPTH_TEST);
+        ::GLES::glUseProgram(sRes.program);
+        ::GLES::glUniformMatrix4fv(sRes.uMVPLoc, 1, GL_FALSE,
+                                   &glm::mat4(1.0f)[0][0]
+        );
+        ::GLES::glUniform1i(sRes.uTexLoc, 0);
+        ::GLES::glBindVertexArray(sRes.quadVAO);
+
+        for (size_t i = 0; i < sortedTextures.size(); ++i) {
+            const GLuint glTexID = sRes.textureCache[sortedTextures[i].first];
+            ::GLES::glActiveTexture(GL_TEXTURE0);
+            ::GLES::glBindTexture(GL_TEXTURE_2D, glTexID);
+            ::GLES::glDrawArrays(GL_TRIANGLE_FAN, static_cast<GLint>(i*4), 4);
+        }
+
+        if (origDepthTest) ::GLES::glEnable(GL_DEPTH_TEST);
+        ::GLES::glUseProgram(origProgram);
+        ::GLES::glViewport(origViewport[0], origViewport[1],
+                           origViewport[2], origViewport[3]);
+    }
+}

MG/MG_RHI/GLES/Test/TestDrawing.h

@@ -0,0 +1,14 @@
+//
+// Created by BZLZHH on 2025/4/26.
+//
+
+#ifndef MOBILEGL_TESTDRAWING_H
+#define MOBILEGL_TESTDRAWING_H
+
+#include "../../../Includes.h"
+
+namespace MG_RHI::GLES::Test {
+    void DrawAllTextures();
+}
+
+#endif //MOBILEGL_TESTDRAWING_H

MG/MG_UTIL/Debug/Debug.h

@@ -0,0 +1,31 @@
+//
+// Created by BZLZHH on 2025/1/26.
+//
+
+#ifndef MOBILEGL_DEBUG_H
+#define MOBILEGL_DEBUG_H
+
+#include "../../Includes.h"
+
+#define FORCE_SYNC_WITH_LOG_FILE 0
+
+namespace MG_Util {
+    namespace Debug {
+        const char* GetOSName();
+        
+        void LogD (const char* format, ...);
+        void LogW (const char* format, ...);
+        void LogE (const char* format, ...);
+        void LogI (const char* format, ...);
+        void LogF (const char* format, ...);
+        void LogClear();
+        void LogInit();
+        void LogWrite(const char* format, va_list args);
+        
+        const char* GLEnumToString(::GLenum value);
+    }
+}
+
+#define MOBILEGL_DEBUG_H
+
+#endif //MOBILEGL_DEBUG_H

MG/MG_UTIL/Program/DebugTool.cpp

@@ -0,0 +1,150 @@
+//
+// Created by BZLZHH on 2025/5/3.
+//
+
+#include "DebugTool.h"
+
+namespace MG_Util::Program {
+    std::string GLTypeToString(GLenum type) {
+        switch(type) {
+            case GL_FLOAT: return "float";
+            case GL_FLOAT_VEC2: return "vec2";
+            case GL_FLOAT_VEC3: return "vec3";
+            case GL_FLOAT_VEC4: return "vec4";
+            case GL_INT: return "int";
+            case GL_INT_VEC2: return "ivec2";
+            case GL_INT_VEC3: return "ivec3";
+            case GL_INT_VEC4: return "ivec4";
+            case GL_UNSIGNED_INT: return "uint";
+            case GL_UNSIGNED_INT_VEC2: return "uvec2";
+            case GL_UNSIGNED_INT_VEC3: return "uvec3";
+            case GL_UNSIGNED_INT_VEC4: return "uvec4";
+            case GL_BOOL: return "bool";
+            case GL_BOOL_VEC2: return "bvec2";
+            case GL_BOOL_VEC3: return "bvec3";
+            case GL_BOOL_VEC4: return "bvec4";
+            case GL_FLOAT_MAT2: return "mat2";
+            case GL_FLOAT_MAT3: return "mat3";
+            case GL_FLOAT_MAT4: return "mat4";
+            case GL_FLOAT_MAT2x3: return "mat2x3";
+            case GL_FLOAT_MAT2x4: return "mat2x4";
+            case GL_FLOAT_MAT3x2: return "mat3x2";
+            case GL_FLOAT_MAT3x4: return "mat3x4";
+            case GL_FLOAT_MAT4x2: return "mat4x2";
+            case GL_FLOAT_MAT4x3: return "mat4x3";
+            case GL_SAMPLER_1D: return "sampler1D";
+            case GL_SAMPLER_2D: return "sampler2D";
+            case GL_SAMPLER_3D: return "sampler3D";
+            case GL_SAMPLER_CUBE: return "samplerCube";
+            case GL_SAMPLER_1D_SHADOW: return "sampler1DShadow";
+            case GL_SAMPLER_2D_SHADOW: return "sampler2DShadow";
+            case GL_SAMPLER_CUBE_SHADOW: return "samplerCubeShadow";
+            case GL_SAMPLER_1D_ARRAY: return "sampler1DArray";
+            case GL_SAMPLER_2D_ARRAY: return "sampler2DArray";
+            case GL_SAMPLER_1D_ARRAY_SHADOW: return "sampler1DArrayShadow";
+            case GL_SAMPLER_2D_ARRAY_SHADOW: return "sampler2DArrayShadow";
+            case GL_SAMPLER_BUFFER: return "samplerBuffer";
+            case GL_SAMPLER_2D_MULTISAMPLE: return "sampler2DMS";
+            case GL_SAMPLER_2D_MULTISAMPLE_ARRAY: return "sampler2DMSArray";
+            default: return "UnknownType(0x" + std::to_string(type) + ")";
+        }
+    }
+    
+    std::string FormatUniformValue(const UniformValue& value) {
+        std::ostringstream ss;
+        ss << "[";
+
+        const size_t elemCount = std::min<size_t>(value.count, 16);
+
+        switch(value.type) {
+            case GL_FLOAT:
+            case GL_FLOAT_VEC2:
+            case GL_FLOAT_VEC3:
+            case GL_FLOAT_VEC4:
+            case GL_FLOAT_MAT2:
+            case GL_FLOAT_MAT3:
+            case GL_FLOAT_MAT4:
+            case GL_FLOAT_MAT2x3:
+            case GL_FLOAT_MAT2x4:
+            case GL_FLOAT_MAT3x2:
+            case GL_FLOAT_MAT3x4:
+            case GL_FLOAT_MAT4x2:
+            case GL_FLOAT_MAT4x3:
+                for(size_t i=0; i<elemCount; ++i) {
+                    if (i > 0) ss << ", ";
+                    ss << (i < value.floatData.size() ? value.floatData[i] : 0.0f);
+                }
+                break;
+
+            case GL_INT:
+            case GL_INT_VEC2:
+            case GL_INT_VEC3:
+            case GL_INT_VEC4:
+                for(size_t i=0; i<elemCount; ++i) {
+                    if (i > 0) ss << ", ";
+                    ss << (i < value.intData.size() ? value.intData[i] : 0);
+                }
+                break;
+
+            case GL_UNSIGNED_INT:
+            case GL_UNSIGNED_INT_VEC2:
+            case GL_UNSIGNED_INT_VEC3:
+            case GL_UNSIGNED_INT_VEC4:
+                for(size_t i=0; i<elemCount; ++i) {
+                    if (i > 0) ss << ", ";
+                    ss << (i < value.uintData.size() ? value.uintData[i] : 0);
+                }
+                break;
+
+            case GL_BOOL:
+            case GL_BOOL_VEC2:
+            case GL_BOOL_VEC3:
+            case GL_BOOL_VEC4:
+                for(size_t i=0; i<elemCount; ++i) {
+                    if (i > 0) ss << ", ";
+                    ss << (i < value.boolData.size() ? (value.boolData[i] ? "true" : "false") : "false");
+                }
+                break;
+
+            default:
+                ss << "N/A";
+        }
+
+        if (value.count > elemCount) ss << ", ...";
+        ss << "]";
+        return ss.str();
+    }
+    
+    void DumpUniforms(const ProgramState& state, GLuint program) {
+        if (MG_Global::Common::LogLevel > MG_Constants::Common::LOG_LEVEL_DEBUG)
+            return;
+        
+        auto prog = (ProgramObject)state.GetProgramObject(program);
+        if (!prog.linked.toBool()) {
+            MG_Util::Debug::LogE("Program %u not linked", program);
+            return;
+        }
+        MG_Util::Debug::LogD("=== Dumping uniforms for program %u ===", program);
+        for(const auto& [name, loc] : prog.uniformLocations) {
+            const auto& value = prog.uniformValues.at(name);
+            MG_Util::Debug::LogD("Uniform: %-24s Location: %-4d Type: %-16s Count: %-3d Value: %s",
+                                 name.c_str(),
+                                 loc,
+                                 GLTypeToString(value.type).c_str(),
+                                 value.count,
+                                 FormatUniformValue(value).c_str());
+        }
+    }
+    
+    void DumpCurrentUniforms(const ProgramState& state) {
+        if (MG_Global::Common::LogLevel > MG_Constants::Common::LOG_LEVEL_DEBUG)
+            return;
+        
+        GLuint current = state.GetCurrentProgram();
+        if (current == 0) {
+            MG_Util::Debug::LogE("No active program");
+            return;
+        }
+        DumpUniforms(state, current);
+    }
+}

MG/MG_UTIL/Program/DebugTool.h

@@ -0,0 +1,16 @@
+//
+// Created by BZLZHH on 2025/5/3.
+//
+
+#ifndef MOBILEGL_PROGRAM_DEBUGTOOL_H
+#define MOBILEGL_PROGRAM_DEBUGTOOL_H
+#include "../../Includes.h"
+
+namespace MG_Util::Program {
+    std::string GLTypeToString(GLenum type);
+    std::string FormatUniformValue(const UniformValue& value);
+    void DumpUniforms(const ProgramState& state, GLuint program);
+    void DumpCurrentUniforms(const ProgramState& state);
+}
+
+#endif //MOBILEGL_PROGRAM_DEBUGTOOL_H

MG/MG_UTIL/Program/GLSLTool.cpp

@@ -0,0 +1,438 @@
+//
+// Created by BZLZHH on 2025/5/3.
+//
+
+#include "GLSLTool.h"
+
+namespace MG_Util::Program {
+    std::string CompileGLSLToTShader(GLenum shaderType, const std::string& source, glslang::TShader *&shader) {
+        std::string infoLog;
+        using namespace glslang;
+        
+        int glslVersion = QueryGLSLVersion(source);
+        EShLanguage language = GetEShLanguageByShaderType(shaderType);
+        if (language == EShLanguage::EShLangCount) {
+            infoLog += "Error: [Preprocess] Unsupported shader type: " +
+                      std::to_string(shaderType);
+            TShader tmpShader(EShLanguage::EShLangVertex);
+            return infoLog;
+        }
+
+        shader = new TShader(language);
+        const char *src = source.c_str();
+        shader->setStrings(&src, 1);
+        shader->setEnvInput(EShSourceGlsl, language, EShClientVulkan, glslVersion);
+        shader->setEnvClient(EShClientOpenGL, EShTargetOpenGL_450);
+        shader->setEnvTarget(EShTargetSpv, EShTargetSpv_1_6);
+        shader->setAutoMapLocations(true);
+        shader->setAutoMapBindings(true);
+
+        // Is InitResources() really correct?
+        TBuiltInResource resources = InitResources();
+
+        if (!shader->parse(&resources, glslVersion, true, EShMsgDefault)) {
+            infoLog += "Error: [glslang] Cannot compile the " + GetShaderTypeName(shaderType) + ":\n"
+                      + std::to_string(shader->getInfoLog());
+            return infoLog;
+        }
+        
+        return {};
+    }
+
+    std::vector<std::vector<unsigned>> CompileMultipleShadersToSPIRV(const ProgramState& state, ProgramObject& prog, std::string& infoLog) {
+        using namespace glslang;
+
+        std::vector<EShLanguage> usedShaderTypes;
+        TProgram program;
+        for (GLuint shaderId : prog.attachedShaders) {
+            auto shaderObject = state.GetShaderObject(shaderId);
+            EShLanguage shLanguage = GetEShLanguageByShaderType(shaderObject.type);
+            TShader* shader = nullptr;
+            std::string infoLogOfShader = CompileGLSLToTShader(shaderObject.type, shaderObject.source, shader);
+            if (!infoLogOfShader.empty()) {
+                infoLog = "Error: [glslang] Cannot compile " + GetShaderTypeName(shaderObject.type) +
+                        " :\n" + infoLogOfShader;
+                return {};
+            }
+            program.addShader(shader);
+            usedShaderTypes.push_back(shLanguage);
+        }
+        if (!program.link(EShMsgDefault)) {
+            infoLog = "Error: [glslang] Cannot link the program:\n" + std::to_string(program.getInfoLog());
+            return {};
+        }
+
+        SpvOptions spvOptions;
+        spvOptions.disableOptimizer = false;
+
+        std::vector<std::vector<unsigned>> allSpirv;
+        for(auto type : usedShaderTypes) {
+            std::vector<unsigned> spirv;
+            GlslangToSpv(*program.getIntermediate(type), spirv, &spvOptions);
+            allSpirv.push_back(spirv);
+        }
+
+        return allSpirv;
+    }
+    
+    std::vector<unsigned> CompileGLSLToSPIRV(GLenum shaderType, const std::string &source, std::string &infoLog) {
+        using namespace glslang;
+
+        TShader* shader = nullptr;
+        std::string infoLogOfShader = CompileGLSLToTShader(shaderType, source, shader);
+        if (!infoLogOfShader.empty()) {
+            infoLog = "Error: [glslang] Cannot compile " + GetShaderTypeName(shaderType) + ":\n" + infoLogOfShader;
+            return {};
+        }
+        TProgram program;
+        program.addShader(shader);
+        if (!program.link(EShMsgDefault)) {
+            infoLog = "Error: [glslang] Cannot link the program of the single shader:\n" + std::to_string(program.getInfoLog());
+            return {};
+        }
+        std::vector<unsigned> spirv;
+        
+        SpvOptions spvOptions;
+        spvOptions.disableOptimizer = false;
+        EShLanguage language = GetEShLanguageByShaderType(shaderType);
+        GlslangToSpv(*program.getIntermediate(language), spirv, &spvOptions);
+
+        return spirv;
+    }
+
+    void ReflectSPIRVUniforms(const std::vector<std::vector<unsigned>>& allSpirv, ProgramObject& prog, std::string& infoLog) {
+        spvc_context context = nullptr;
+
+        if (spvc_context_create(&context) != SPVC_SUCCESS) {
+            infoLog = "Failed to create SPIRV-Cross context";
+            return;
+        }
+
+        ankerl::unordered_set<GLint> used_locations;
+        GLint auto_location = 0;
+        for (auto spirv: allSpirv) {
+            spvc_parsed_ir ir = nullptr;
+            spvc_compiler compiler = nullptr;
+            spvc_resources resources = nullptr;
+            
+            spvc_result result = spvc_context_parse_spirv(context, spirv.data(), spirv.size(), &ir);
+            if (result != SPVC_SUCCESS) {
+                infoLog = "SPIR-V parsing failed";
+                spvc_context_destroy(context);
+                return;
+            }
+
+            result = spvc_context_create_compiler(context, SPVC_BACKEND_GLSL, ir,
+                                                  SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, &compiler);
+            if (result != SPVC_SUCCESS) {
+                infoLog = "Failed to create SPIRV-Cross compiler";
+                spvc_context_destroy(context);
+                return;
+            }
+
+            result = spvc_compiler_create_shader_resources(compiler, &resources);
+            if (result != SPVC_SUCCESS) {
+                infoLog = "Failed to get shader resources";
+                spvc_context_destroy(context);
+                return;
+            }
+
+            const spvc_reflected_resource *uniform_buffers = nullptr;
+            const spvc_reflected_resource *uniform_vars = nullptr;
+            const spvc_reflected_resource *sampled_images = nullptr;
+            size_t uniform_buffer_count = 0;
+            size_t uniform_var_count = 0;
+            size_t sampled_image_count = 0;
+
+            spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_UNIFORM_BUFFER,
+                                                      &uniform_buffers, &uniform_buffer_count);
+            spvc_resources_get_resource_list_for_type(resources,
+                                                      SPVC_RESOURCE_TYPE_GL_PLAIN_UNIFORM,
+                                                      &uniform_vars, &uniform_var_count);
+            spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_SAMPLED_IMAGE,
+                                                      &sampled_images, &sampled_image_count);
+
+            std::vector<const spvc_reflected_resource *> all_resources;
+            for (size_t i = 0; i < uniform_buffer_count; ++i)
+                all_resources.push_back(&uniform_buffers[i]);
+            for (size_t i = 0; i < uniform_var_count; ++i)
+                all_resources.push_back(&uniform_vars[i]);
+            for (size_t i = 0; i < sampled_image_count; ++i)
+                all_resources.push_back(&sampled_images[i]);
+
+            for (const auto res_ptr: all_resources) {
+                const spvc_reflected_resource &res = *res_ptr;
+                const char *name = res.name;
+                if (name[0] == '_') continue;
+
+                unsigned spirv_location = spvc_compiler_get_decoration(compiler, res.id,
+                                                                       SpvDecorationLocation);
+                GLint final_location;
+
+                if (spirv_location > 0) {
+                    if (used_locations.find(spirv_location) != used_locations.end()) {
+                        infoLog += "\nLocation conflict for uniform: " + std::string(name);
+                        continue;
+                    }
+                    final_location = spirv_location;
+                } else {
+                    while (used_locations.find(auto_location) != used_locations.end()) {
+                        auto_location++;
+                    }
+                    final_location = auto_location;
+                }
+
+                used_locations.insert(final_location);
+
+                spvc_type_id type_id = res.type_id;
+                spvc_type type = spvc_compiler_get_type_handle(compiler, type_id);
+                spvc_basetype base_type = spvc_type_get_basetype(type);
+                GLenum gl_type = GL_NONE;
+
+                if (base_type == SPVC_BASETYPE_SAMPLED_IMAGE) {
+                    SpvDim dim = spvc_type_get_image_dimension(type);
+                    bool is_array = spvc_type_get_image_arrayed(type);
+                    bool is_shadow = spvc_type_get_image_is_depth(type);
+                    bool is_ms = spvc_type_get_image_multisampled(type);
+
+                    switch (dim) {
+                        case SpvDim1D:
+                            gl_type = is_array ? GL_SAMPLER_1D_ARRAY : GL_SAMPLER_1D;
+                            if (is_shadow)
+                                gl_type = is_array ? GL_SAMPLER_1D_ARRAY_SHADOW
+                                                   : GL_SAMPLER_1D_SHADOW;
+                            break;
+                        case SpvDim2D:
+                            if (is_ms) {
+                                gl_type = is_array ? GL_SAMPLER_2D_MULTISAMPLE_ARRAY
+                                                   : GL_SAMPLER_2D_MULTISAMPLE;
+                            } else {
+                                gl_type = is_array ? GL_SAMPLER_2D_ARRAY : GL_SAMPLER_2D;
+                                if (is_shadow)
+                                    gl_type = is_array ? GL_SAMPLER_2D_ARRAY_SHADOW
+                                                       : GL_SAMPLER_2D_SHADOW;
+                            }
+                            break;
+                        case SpvDim3D:
+                            gl_type = GL_SAMPLER_3D;
+                            break;
+                        case SpvDimCube:
+                            gl_type = is_array ? GL_SAMPLER_CUBE_MAP_ARRAY : GL_SAMPLER_CUBE;
+                            if (is_shadow)
+                                gl_type = is_array ? GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW
+                                                   : GL_SAMPLER_CUBE_SHADOW;
+                            break;
+                        case SpvDimRect:
+                            gl_type = is_shadow ? GL_SAMPLER_2D_RECT_SHADOW : GL_SAMPLER_2D_RECT;
+                            break;
+                        case SpvDimBuffer:
+                            gl_type = GL_SAMPLER_BUFFER;
+                            break;
+                        default:
+                            gl_type = GL_SAMPLER_2D;
+                    }
+
+                    spvc_basetype sampled_base = spvc_type_get_basetype(type);
+                    if (sampled_base == SPVC_BASETYPE_INT32) {
+                        switch (gl_type) {
+                            case GL_SAMPLER_1D:
+                                gl_type = GL_INT_SAMPLER_1D;
+                                break;
+                            case GL_SAMPLER_2D:
+                                gl_type = GL_INT_SAMPLER_2D;
+                                break;
+                            case GL_SAMPLER_3D:
+                                gl_type = GL_INT_SAMPLER_3D;
+                                break;
+                            case GL_SAMPLER_CUBE:
+                                gl_type = GL_INT_SAMPLER_CUBE;
+                                break;
+                            case GL_SAMPLER_1D_ARRAY:
+                                gl_type = GL_INT_SAMPLER_1D_ARRAY;
+                                break;
+                            case GL_SAMPLER_2D_ARRAY:
+                                gl_type = GL_INT_SAMPLER_2D_ARRAY;
+                                break;
+                            case GL_SAMPLER_CUBE_MAP_ARRAY:
+                                gl_type = GL_INT_SAMPLER_CUBE_MAP_ARRAY;
+                                break;
+                            case GL_SAMPLER_2D_RECT:
+                                gl_type = GL_INT_SAMPLER_2D_RECT;
+                                break;
+                            case GL_SAMPLER_BUFFER:
+                                gl_type = GL_INT_SAMPLER_BUFFER;
+                                break;
+                            case GL_SAMPLER_2D_MULTISAMPLE:
+                                gl_type = GL_INT_SAMPLER_2D_MULTISAMPLE;
+                                break;
+                            case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
+                                gl_type = GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
+                                break;
+                        }
+                    } else if (sampled_base == SPVC_BASETYPE_UINT32) {
+                        switch (gl_type) {
+                            case GL_SAMPLER_1D:
+                                gl_type = GL_UNSIGNED_INT_SAMPLER_1D;
+                                break;
+                            case GL_SAMPLER_2D:
+                                gl_type = GL_UNSIGNED_INT_SAMPLER_2D;
+                                break;
+                            case GL_SAMPLER_3D:
+                                gl_type = GL_UNSIGNED_INT_SAMPLER_3D;
+                                break;
+                            case GL_SAMPLER_CUBE:
+                                gl_type = GL_UNSIGNED_INT_SAMPLER_CUBE;
+                                break;
+                            case GL_SAMPLER_1D_ARRAY:
+                                gl_type = GL_UNSIGNED_INT_SAMPLER_1D_ARRAY;
+                                break;
+                            case GL_SAMPLER_2D_ARRAY:
+                                gl_type = GL_UNSIGNED_INT_SAMPLER_2D_ARRAY;
+                                break;
+                            case GL_SAMPLER_CUBE_MAP_ARRAY:
+                                gl_type = GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY;
+                                break;
+                            case GL_SAMPLER_2D_RECT:
+                                gl_type = GL_UNSIGNED_INT_SAMPLER_2D_RECT;
+                                break;
+                            case GL_SAMPLER_BUFFER:
+                                gl_type = GL_UNSIGNED_INT_SAMPLER_BUFFER;
+                                break;
+                            case GL_SAMPLER_2D_MULTISAMPLE:
+                                gl_type = GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE;
+                                break;
+                            case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
+                                gl_type = GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
+                                break;
+                        }
+                    }
+                } else {
+                    unsigned vec_size = spvc_type_get_vector_size(type);
+                    unsigned columns = spvc_type_get_columns(type);
+
+                    switch (base_type) {
+                        case SPVC_BASETYPE_FP32:
+                            if (columns > 1) {
+                                if (vec_size == 2 && columns == 2) gl_type = GL_FLOAT_MAT2;
+                                else if (vec_size == 3 && columns == 3) gl_type = GL_FLOAT_MAT3;
+                                else if (vec_size == 4 && columns == 4) gl_type = GL_FLOAT_MAT4;
+                                else if (vec_size == 3 && columns == 2) gl_type = GL_FLOAT_MAT2x3;
+                                else if (vec_size == 4 && columns == 2) gl_type = GL_FLOAT_MAT2x4;
+                                else if (vec_size == 2 && columns == 3) gl_type = GL_FLOAT_MAT3x2;
+                                else if (vec_size == 4 && columns == 3) gl_type = GL_FLOAT_MAT3x4;
+                                else if (vec_size == 2 && columns == 4) gl_type = GL_FLOAT_MAT4x2;
+                                else if (vec_size == 3 && columns == 4) gl_type = GL_FLOAT_MAT4x3;
+                            } else {
+                                switch (vec_size) {
+                                    case 1:
+                                        gl_type = GL_FLOAT;
+                                        break;
+                                    case 2:
+                                        gl_type = GL_FLOAT_VEC2;
+                                        break;
+                                    case 3:
+                                        gl_type = GL_FLOAT_VEC3;
+                                        break;
+                                    case 4:
+                                        gl_type = GL_FLOAT_VEC4;
+                                        break;
+                                }
+                            }
+                            break;
+                        case SPVC_BASETYPE_INT32:
+                            switch (vec_size) {
+                                case 1:
+                                    gl_type = GL_INT;
+                                    break;
+                                case 2:
+                                    gl_type = GL_INT_VEC2;
+                                    break;
+                                case 3:
+                                    gl_type = GL_INT_VEC3;
+                                    break;
+                                case 4:
+                                    gl_type = GL_INT_VEC4;
+                                    break;
+                            }
+                            break;
+                        case SPVC_BASETYPE_UINT32:
+                            switch (vec_size) {
+                                case 1:
+                                    gl_type = GL_UNSIGNED_INT;
+                                    break;
+                                case 2:
+                                    gl_type = GL_UNSIGNED_INT_VEC2;
+                                    break;
+                                case 3:
+                                    gl_type = GL_UNSIGNED_INT_VEC3;
+                                    break;
+                                case 4:
+                                    gl_type = GL_UNSIGNED_INT_VEC4;
+                                    break;
+                            }
+                            break;
+                        case SPVC_BASETYPE_BOOLEAN:
+                            switch (vec_size) {
+                                case 1:
+                                    gl_type = GL_BOOL;
+                                    break;
+                                case 2:
+                                    gl_type = GL_BOOL_VEC2;
+                                    break;
+                                case 3:
+                                    gl_type = GL_BOOL_VEC3;
+                                    break;
+                                case 4:
+                                    gl_type = GL_BOOL_VEC4;
+                                    break;
+                            }
+                            break;
+                        default:
+                            continue;
+                    }
+                }
+
+                prog.uniformLocations[name] = final_location;
+                UniformValue uniformValue;
+                uniformValue.type = gl_type;
+                prog.uniformValues[name] = uniformValue;
+            }
+        }
+        spvc_context_destroy(context);
+    }
+
+    std::string CompileSPIRVToGLSL(std::vector<unsigned int> spirv, uint glslVersion, bool isES) {
+        spvc_context context = nullptr;
+        spvc_parsed_ir ir = nullptr;
+        spvc_compiler compiler_glsl = nullptr;
+        spvc_compiler_options options = nullptr;
+        spvc_resources resources = nullptr;
+        const spvc_reflected_resource *list = nullptr;
+        const char *result = nullptr;
+        size_t count;
+
+        const SpvId *p_spirv = spirv.data();
+        size_t word_count = spirv.size();
+
+        spvc_context_create(&context);
+        spvc_context_parse_spirv(context, p_spirv, word_count, &ir);
+        spvc_context_create_compiler(context, SPVC_BACKEND_GLSL, ir, SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, &compiler_glsl);
+        spvc_compiler_create_shader_resources(compiler_glsl, &resources);
+        spvc_resources_get_resource_list_for_type(resources, SPVC_RESOURCE_TYPE_UNIFORM_BUFFER, &list, &count);
+        spvc_compiler_create_compiler_options(compiler_glsl, &options);
+        spvc_compiler_options_set_uint(options, SPVC_COMPILER_OPTION_GLSL_VERSION, glslVersion);
+        spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_ES, isES ? SPVC_TRUE : SPVC_FALSE);
+        spvc_compiler_install_compiler_options(compiler_glsl, options);
+        spvc_compiler_compile(compiler_glsl, &result);
+
+        if (!result) {
+            return{};
+        }
+
+        std::string essl = result;
+
+        spvc_context_destroy(context);
+
+        return essl;
+    }
+}

MG/MG_UTIL/Program/GLSLTool.h

@@ -0,0 +1,183 @@
+//
+// Created by BZLZHH on 2025/5/3.
+//
+
+#ifndef MOBILEGL_GLSLTOOL_H
+#define MOBILEGL_GLSLTOOL_H
+
+#include "../../Includes.h"
+
+namespace MG_Util::Program {
+    inline static TBuiltInResource InitResources()
+    {
+        TBuiltInResource Resources{};
+        Resources.maxLights                                 = 32;
+        Resources.maxClipPlanes                             = 6;
+        Resources.maxTextureUnits                           = 32;
+        Resources.maxTextureCoords                          = 32;
+        Resources.maxVertexAttribs                          = 64;
+        Resources.maxVertexUniformComponents                = 4096;
+        Resources.maxVaryingFloats                          = 64;
+        Resources.maxVertexTextureImageUnits                = 32;
+        Resources.maxCombinedTextureImageUnits              = 80;
+        Resources.maxTextureImageUnits                      = 32;
+        Resources.maxFragmentUniformComponents              = 4096;
+        Resources.maxDrawBuffers                            = 32;
+        Resources.maxVertexUniformVectors                   = 128;
+        Resources.maxVaryingVectors                         = 8;
+        Resources.maxFragmentUniformVectors                 = 16;
+        Resources.maxVertexOutputVectors                    = 16;
+        Resources.maxFragmentInputVectors                   = 15;
+        Resources.minProgramTexelOffset                     = -8;
+        Resources.maxProgramTexelOffset                     = 7;
+        Resources.maxClipDistances                          = 8;
+        Resources.maxComputeWorkGroupCountX                 = 65535;
+        Resources.maxComputeWorkGroupCountY                 = 65535;
+        Resources.maxComputeWorkGroupCountZ                 = 65535;
+        Resources.maxComputeWorkGroupSizeX                  = 1024;
+        Resources.maxComputeWorkGroupSizeY                  = 1024;
+        Resources.maxComputeWorkGroupSizeZ                  = 64;
+        Resources.maxComputeUniformComponents               = 1024;
+        Resources.maxComputeTextureImageUnits               = 16;
+        Resources.maxComputeImageUniforms                   = 8;
+        Resources.maxComputeAtomicCounters                  = 8;
+        Resources.maxComputeAtomicCounterBuffers            = 1;
+        Resources.maxVaryingComponents                      = 60;
+        Resources.maxVertexOutputComponents                 = 64;
+        Resources.maxGeometryInputComponents                = 64;
+        Resources.maxGeometryOutputComponents               = 128;
+        Resources.maxFragmentInputComponents                = 128;
+        Resources.maxImageUnits                             = 8;
+        Resources.maxCombinedImageUnitsAndFragmentOutputs   = 8;
+        Resources.maxCombinedShaderOutputResources          = 8;
+        Resources.maxImageSamples                           = 0;
+        Resources.maxVertexImageUniforms                    = 0;
+        Resources.maxTessControlImageUniforms               = 0;
+        Resources.maxTessEvaluationImageUniforms            = 0;
+        Resources.maxGeometryImageUniforms                  = 0;
+        Resources.maxFragmentImageUniforms                  = 8;
+        Resources.maxCombinedImageUniforms                  = 8;
+        Resources.maxGeometryTextureImageUnits              = 16;
+        Resources.maxGeometryOutputVertices                 = 256;
+        Resources.maxGeometryTotalOutputComponents          = 1024;
+        Resources.maxGeometryUniformComponents              = 1024;
+        Resources.maxGeometryVaryingComponents              = 64;
+        Resources.maxTessControlInputComponents             = 128;
+        Resources.maxTessControlOutputComponents            = 128;
+        Resources.maxTessControlTextureImageUnits           = 16;
+        Resources.maxTessControlUniformComponents           = 1024;
+        Resources.maxTessControlTotalOutputComponents       = 4096;
+        Resources.maxTessEvaluationInputComponents          = 128;
+        Resources.maxTessEvaluationOutputComponents         = 128;
+        Resources.maxTessEvaluationTextureImageUnits        = 16;
+        Resources.maxTessEvaluationUniformComponents        = 1024;
+        Resources.maxTessPatchComponents                    = 120;
+        Resources.maxPatchVertices                          = 32;
+        Resources.maxTessGenLevel                           = 64;
+        Resources.maxViewports                              = 16;
+        Resources.maxVertexAtomicCounters                   = 0;
+        Resources.maxTessControlAtomicCounters              = 0;
+        Resources.maxTessEvaluationAtomicCounters           = 0;
+        Resources.maxGeometryAtomicCounters                 = 0;
+        Resources.maxFragmentAtomicCounters                 = 8;
+        Resources.maxCombinedAtomicCounters                 = 8;
+        Resources.maxAtomicCounterBindings                  = 1;
+        Resources.maxVertexAtomicCounterBuffers             = 0;
+        Resources.maxTessControlAtomicCounterBuffers        = 0;
+        Resources.maxTessEvaluationAtomicCounterBuffers     = 0;
+        Resources.maxGeometryAtomicCounterBuffers           = 0;
+        Resources.maxFragmentAtomicCounterBuffers           = 1;
+        Resources.maxCombinedAtomicCounterBuffers           = 1;
+        Resources.maxAtomicCounterBufferSize                = 16384;
+        Resources.maxTransformFeedbackBuffers               = 4;
+        Resources.maxTransformFeedbackInterleavedComponents = 64;
+        Resources.maxCullDistances                          = 8;
+        Resources.maxCombinedClipAndCullDistances           = 8;
+        Resources.maxSamples                                = 4;
+        Resources.maxMeshOutputVerticesNV                   = 256;
+        Resources.maxMeshOutputPrimitivesNV                 = 512;
+        Resources.maxMeshWorkGroupSizeX_NV                  = 32;
+        Resources.maxMeshWorkGroupSizeY_NV                  = 1;
+        Resources.maxMeshWorkGroupSizeZ_NV                  = 1;
+        Resources.maxTaskWorkGroupSizeX_NV                  = 32;
+        Resources.maxTaskWorkGroupSizeY_NV                  = 1;
+        Resources.maxTaskWorkGroupSizeZ_NV                  = 1;
+        Resources.maxMeshViewCountNV                        = 4;
+        
+        Resources.limits.nonInductiveForLoops                 = true;
+        Resources.limits.whileLoops                           = true;
+        Resources.limits.doWhileLoops                         = true;
+        Resources.limits.generalUniformIndexing               = true;
+        Resources.limits.generalAttributeMatrixVectorIndexing = true;
+        Resources.limits.generalVaryingIndexing               = true;
+        Resources.limits.generalSamplerIndexing               = true;
+        Resources.limits.generalVariableIndexing              = true;
+        Resources.limits.generalConstantMatrixVectorIndexing  = true;
+
+        return Resources;
+    }
+
+    inline int QueryGLSLVersion(const std::string& code) {
+        static std::regex version_pattern(R"(#version\s+(\d{3}))");
+        std::smatch match;
+        if (std::regex_search(code, match, version_pattern)) {
+            return std::stoi(match[1].str());
+        }
+
+        return -1;
+    }
+
+    inline GLsizei GetMatrixElementCount(GLenum matrixType) {
+        switch(matrixType) {
+            case GL_FLOAT_MAT2: return 4;
+            case GL_FLOAT_MAT3: return 9;
+            case GL_FLOAT_MAT4: return 16;
+            case GL_FLOAT_MAT2x3: return 6;
+            case GL_FLOAT_MAT2x4: return 8;
+            case GL_FLOAT_MAT3x2: return 6;
+            case GL_FLOAT_MAT3x4: return 12;
+            case GL_FLOAT_MAT4x2: return 8;
+            case GL_FLOAT_MAT4x3: return 12;
+            default: return 0;
+        }
+    }
+
+    inline std::string GetShaderTypeName(GLenum shaderType) {
+        switch(shaderType) {
+            case GL_VERTEX_SHADER:          return "Vertex Shader";
+            case GL_FRAGMENT_SHADER:        return "Fragment Shader";
+            case GL_GEOMETRY_SHADER:        return "Geometry Shader";
+            case GL_TESS_CONTROL_SHADER:    return "Tessellation Control Shader";
+            case GL_TESS_EVALUATION_SHADER: return "Tessellation Evaluation Shader";
+            case GL_COMPUTE_SHADER:         return "Compute Shader";
+            default:                        return "Unknown Shader Type (" + std::to_string(shaderType) + ")";
+        }
+    }
+    
+    inline EShLanguage GetEShLanguageByShaderType(GLenum shaderType) {
+        switch (shaderType) {
+            case GL_VERTEX_SHADER:
+                return EShLanguage::EShLangVertex;
+            case GL_FRAGMENT_SHADER:
+                return EShLanguage::EShLangFragment;
+            case GL_COMPUTE_SHADER:
+                return EShLanguage::EShLangCompute;
+            case GL_TESS_CONTROL_SHADER:
+                return EShLanguage::EShLangTessControl;
+            case GL_TESS_EVALUATION_SHADER:
+                return EShLanguage::EShLangTessEvaluation;
+            case GL_GEOMETRY_SHADER:
+                return EShLanguage::EShLangGeometry;
+            default:
+                return EShLanguage::EShLangCount;
+        }
+    }
+    
+    std::vector<unsigned> CompileGLSLToSPIRV(GLenum shaderType, const std::string& source, std::string& infoLog);
+    std::string CompileGLSLToTShader(GLenum shaderType, const std::string& source, glslang::TShader *&shader);
+    std::vector<std::vector<unsigned>> CompileMultipleShadersToSPIRV(const ProgramState& state, ProgramObject& prog, std::string& infoLog);
+    void ReflectSPIRVUniforms(const std::vector<std::vector<unsigned>>& allSpirv, ProgramObject& prog, std::string& infoLog);
+    std::string CompileSPIRVToGLSL(std::vector<unsigned int> spirv, uint glslVersion, bool isES);
+}
+
+#endif //MOBILEGL_GLSLTOOL_H

MobileGL/Config.h

@@ -1,321 +0,0 @@
-// MobileGL - MobileGL/Config.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/BackendObjects.h>
-
-namespace MobileGL::MG_Config {
-    inline const String ProjectName = "MobileGL";
-    inline const String CoreName = "MobileGL Core";
-    inline const String CoreVendor = "MobileGL-Dev (BZLZHH, Swung0x48, Tungsten)";
-    inline const Version CoreVersion = {26, 8, 0, "-dev", VersionType::Development};
-    inline const 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_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 is a plain memcpy into GPU-visible memory; every driver-mediated
-        // route for the same write stalls the thread or ghost-copies the whole arena on
-        // this class of Mali driver, and the arena stops costing its size again in RAM.
-        Bool DisableLargeBufferAdoption = false;
-        // MOBILEGL_ESPRYT_FORCE_DS_READBACK_EMULATION: make DirectGLES skip the native ES
-        // depth/stencil reads and always go through the shader-sampling emulation. Core GL
-        // ES has no depth or stencil readback, but some drivers accept it anyway (Mesa does,
-        // Adreno does not), which means the emulation is dead code on exactly the stack the
-        // headless suite runs on. This forces it live so the scenarios and the CTS can
-        // exercise the path, and gives the device an A/B lever over the same choice.
-        Bool EsprytForceDepthStencilReadbackEmulation = false;
-        // 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;
-    };
-    extern FeaturesTable Features;
-} // namespace MobileGL::MG_Config

MobileGL/ConfigLoader.cpp

@@ -1,238 +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"
-
-#include <cerrno>
-#include <cstdlib>
-
-#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;
-} // 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);
-    }
-
-    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.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");
-    }
-
-    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
-    }
-
-    void Init() {
-        MGLOG_D("Loading configuration from environment variables...");
-        InitializeAcceptedEnvVariables();
-
-        InitBackendType();
-        InitFeatures();
-
-        // Destroy the map since we won't need it anymore
-        acceptedEnvVariablesMap.reset();
-    }
-} // namespace MobileGL::MG_ConfigLoader

MobileGL/Defines.h

@@ -1,115 +0,0 @@
-// MobileGL - MobileGL/Defines.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
-
-// ============== 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 _WIN32
-#ifndef NOMINMAX
-#define NOMINMAX 1 // prevent Windows.h from defining min and max macros
-#endif
-#endif
-
-// ================== MobileGL definitions and macros =================== //
-#ifdef _WIN32
-#define MOBILEGL_EXPORT extern "C" __declspec(dllexport)
-#else
-#define MOBILEGL_EXPORT extern "C" __attribute__((visibility("default")))
-#endif
-
-#define MOBILEGL_API MOBILEGL_EXPORT
-
-#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
-#define MOBILEGL_LOG_ENABLE_ANDROID 1
-#define MOBILEGL_ENABLE_SCOPE_MARKER 0
-
-// Require C++23
-// Clang/Android NDK still doesn't have support for that :(
-#if __cplusplus >= 202302L && !__ANDROID__
-#define MOBILEGL_LOG_ENABLE_STACKTRACE 0
-#endif
-
-#ifdef __ANDROID__
-#define MOBILEGL_LOG_FILE_PATH "/sdcard/MG/latest.log"
-#else
-#define MOBILEGL_LOG_FILE_PATH ""
-#endif
-
-#if defined _MSC_VER or defined __MINGW32__ or defined __MINGW64__
-#define TRAP assert(false)
-#elif __clang__
-#define TRAP __builtin_debugtrap()
-#else
-#include <signal.h>
-#define TRAP raise(SIGTRAP)
-#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)) {                                                                                            \
-                MGLOG_F("Assertion failed" __VA_OPT__(": ") __VA_ARGS__);                                                  \
-                MGLOG_F("  at %s:%d (%s)", __FILE__, __LINE__, __func__);                                                  \
-                TRAP;                                                                                                      \
-            }                                                                                                              \
-        } while (0)
-#else
-    #define MOBILEGL_ASSERT(condition, ...)
-#endif

MobileGL/GlobalObjects.cpp

@@ -1,26 +0,0 @@
-// MobileGL - MobileGL/GlobalObjects.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"
-
-namespace MobileGL {
-    namespace MG_Config {
-        BackendType ActiveBackendType;
-    } // 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>();
-        GlobalBackendFunctionsTable gBackendFunctionsTable;
-    } // namespace MG_Backend
-} // namespace MobileGL

MobileGL/Includes.h

@@ -1,149 +0,0 @@
-// MobileGL - MobileGL/Includes.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 significant project headers
-#include "Defines.h"
-#include "MG_Util/PlatformStubs.h"
-
-// Include necessary standard headers
-#include <bit>
-#include <map>
-#include <array>
-#include <ctime>
-#include <mutex>
-#include <queue>
-#include <regex>
-#include <atomic>
-#include <bitset>
-#include <cctype>
-#include <chrono>
-#include <cstdio>
-#include <format>
-#include <memory>
-#include <random>
-#include <string>
-#include <thread>
-#include <vector>
-#include <cassert>
-#include <climits>
-#include <cstdlib>
-#include <cstdarg>
-#include <cstring>
-#include <numeric>
-#include <expected>
-#include <iostream>
-#include <optional>
-#include <algorithm>
-#include <stdexcept>
-#include <functional>
-#include <string_view>
-#include <unordered_map>
-#if __cplusplus >= 202302L && MOBILEGL_LOG_ENABLE_STACKTRACE
-#include <stacktrace>
-#endif
-
-// Include ska::flat_hash_map
-#include <ska/flat_hash_map.hpp>
-
-// Include xxHash
-#include <xxhash.h>
-
-// Include spirv_cross
-#include <spirv_cross/spirv_cross_c.h>
-
-// Include OpenGL and EGL headers
-#ifdef GLAPI
-#undef GLAPI
-#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
-
-#include <GL/glext.h>
-
-#define GL_GLES_PROTOTYPES 0
-#include <GLES3/gl32.h>
-#undef GL_GLES_PROTOTYPES
-
-// Include glslang headers
-#include <glslang/Include/Types.h>
-#include <glslang/Public/ShaderLang.h>
-#include <glslang/SPIRV/GlslangToSpv.h>
-#include <glslang/Include/intermediate.h>
-#include <glslang/MachineIndependent/localintermediate.h>
-
-// Include headers for platform-specific functionality
-#ifdef __linux__
-#include <dlfcn.h>
-#include <pthread.h>
-#endif
-
-#ifdef _WIN32
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN 1
-#endif
-#include <windows.h>
-#include <processthreadsapi.h>
-#endif
-
-#ifdef __ANDROID__
-#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>
-#define TRACY_ZONECOLOR_ENTRY 0xFF0000
-#define TRACY_ZONECOLOR_FRONTEND 0x00FF00
-#define TRACY_ZONECOLOR_BACKEND 0x00FF00
-#endif
-
-// Post-includes for significant project headers
-#include "MG_Util/Debug/Log.h"
-#include "MG_Util/Types.h"

MobileGL/Init.cpp

@@ -1,163 +0,0 @@
-// MobileGL - MobileGL/Init.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 "Init.h"
-#include "Config.h"
-#include <MG_Backend/BackendObjects.h>
-#include <MG_Backend/DirectVulkan/DirectVulkan.h>
-#include <MG_State/GLState/Core.h>
-#include <MG_State/EGLState/Core.h>
-#include <MG_Impl/GLImpl/Texture/ProxyTexture.h>
-#include <MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h>
-#include <MG_Impl/GLImpl/Sync/GL_Sync.h>
-#include <MG_Impl/GLImpl/Query/GL_Query.h>
-#include <MG_Util/Async/ShaderCompilePool.h>
-#include <MG_Util/ShaderTranspiler/ShaderCompiler.h>
-#include <MG_State/GLState/ProgramState/ProgramTranslationCache.h>
-#include <MG_Util/ShaderTranspiler/TranslationCache.h>
-
-#include <atomic>
-#include <mutex>
-
-namespace MobileGL {
-    namespace {
-        std::atomic<Bool> g_isInitialized = false;
-        thread_local Bool tl_initializing = false;
-
-        std::mutex& InitMutex() {
-            static std::mutex mutex;
-            return mutex;
-        }
-
-        void DestroyImpl(Bool logLifecycle) {
-            if (!g_isInitialized) {
-                return;
-            }
-
-            if (logLifecycle) {
-                MGLOG_I("MobileGL closing...");
-            }
-            // First, before anything else is torn down. In-flight compile/link jobs own
-            // their own inputs and are safe against everything below EXCEPT glslang's
-            // process globals and the TShader/TProgram objects hanging off pGLContext,
-            // both of which this function is about to destroy. This is the one
-            // cancellation path in the whole design that waits.
-            MG_Util::Async::ShaderCompilePool::Get().StopAndDrain();
-            // GL syncs die with their contexts, and every context is gone by the
-            // time full teardown runs: drain the live-sync registry while the
-            // backend function table can still release the backend handles (and
-            // before a re-initialized library could pair them with the wrong
-            // backend's DeleteSync).
-            MG_Impl::GLImpl::DestroyAllSyncObjects();
-            // 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 (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;
-        }
-
-        MG_Util::Debug::InitFile();
-        MGLOG_I("Initializing MobileGL...");
-        MG_ConfigLoader::Init();
-        MGLOG_I("Config loaded");
-        MG_State::Init();
-        MGLOG_D("MG_State initialized");
-        MG_Backend::Init();
-        MGLOG_D("MG_Backend initialized");
-        MG_Impl::Init();
-        MGLOG_D("MG_Impl initialized");
-        glslang::InitializeProcess();
-        // On the GL thread, before any worker can exist. glslang builds its built-in symbol
-        // tables lazily under a process-wide lock held for the whole build, so without this
-        // the first concurrent compiles of a shaderpack all serialize behind the very first
-        // parse and asynchronous compilation looks like it is doing nothing.
-        //
-        // Gated on the flag, because the problem it solves only exists when there are
-        // workers: with compilation synchronous, nothing ever contends for that lock and the
-        // three throwaway parses buy nothing - they just add to every eglInitialize. Read the
-        // flag here rather than inside PrewarmBuiltins so ShaderCompiler keeps no dependency
-        // on the async subsystem (ProgramUtilTest compiles that file without it).
-        if (MG_Util::Async::AsyncShaderCompileEnabled()) {
-            MG_Util::ShaderTranspiler::ShaderCompiler::PrewarmBuiltins();
-        }
-        MGLOG_D("glslang initialized");
-        g_isInitialized = true;
-        MGLOG_I("MobileGL initialized");
-    }
-
-    void EnsureInitialized() {
-        if (g_isInitialized.load(std::memory_order_acquire)) {
-            return;
-        }
-        // Re-entrant call while this thread is already inside Initialize()
-        // (e.g. an init step routing back through a public entry point).
-        if (tl_initializing) {
-            return;
-        }
-        const std::lock_guard<std::mutex> lock(InitMutex());
-        if (g_isInitialized.load(std::memory_order_acquire)) {
-            return;
-        }
-        tl_initializing = true;
-        Initialize();
-        tl_initializing = false;
-    }
-
-    void Destroy() {
-        DestroyImpl(true);
-    }
-
-    // MobileGL's lifecycle is owned entirely by the host-API layers
-    // (EGL/WGL/CGL): initialization happens lazily on the first entry point
-    // via EnsureInitialized(), and full teardown happens deterministically
-    // when the last EGL display is terminated with nothing current (EGLImpl
-    // calls Destroy()). There is intentionally no backend-initializing static
-    // constructor, no static destructor, and no DllMain: the global singletons
-    // use leak-at-exit storage (see GlobalObjects.cpp), so a process that exits
-    // without eglTerminate simply leaks them to the OS instead of running
-    // backend destructors during static teardown. macOS has a lightweight
-    // dyld constructor that installs NSOpenGL dispatch hooks only; full backend
-    // initialization still enters here from the first hooked CGL context.
-} // namespace MobileGL

MobileGL/Init.h

@@ -1,38 +0,0 @@
-// MobileGL - MobileGL/Init.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 {
-    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

MobileGL/MG_Backend/BackendObject.cpp

@@ -1,495 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/BackendObject.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 "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;
-        }
-
-        if (m_eglDisplayInitialized && m_eglDisplay != dpy) {
-            MGLOG_E("InitializeEGLDisplay failed: backend already bound to a different EGLDisplay");
-            return false;
-        }
-
-        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;
-    }
-
-    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 {
-            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;
-        }
-        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;
-        }
-
-        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);
-        }
-    }
-
-    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

@@ -1,619 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/BackendObject.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_State/GLState/TextureState/TextureEnum.h"
-
-namespace MobileGL {
-    namespace MG_State::GLState {
-        class FramebufferObject;
-        class ITextureObject;
-        class RenderbufferObject;
-    }
-
-    enum class BackendType {
-        DirectGLES,
-        DirectVulkan,
-        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;
-
-            Bool IsRenderbuffer() const { return Renderbuffer != nullptr; }
-            Bool Exists() const { 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,
-                                                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 (*DrawArraysInstancedBaseInstance)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount,
-                                                    GLuint baseinstance);
-            void (*DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-            void (*DrawElementsIndirect)(GLenum mode, GLenum type, const void* indirect);
-            void (*DrawArraysIndirect)(GLenum mode, const void* indirect);
-            void (*Clear)(GLbitfield mask);
-            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 (*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);
-            void (*GetIntegeri_v)(GLenum target, GLuint index, GLint* data);
-            void (*GetInteger64i_v)(GLenum target, GLuint index, GLint64* data);
-            void (*GetProgramiv)(GLuint program, GLenum pname, GLint* params);
-            // The GL program interface (glGetProgramInterfaceiv / glGetProgramResource*) is NOT
-            // a backend query: it describes the program the application wrote, in the
-            // application's namespace, which neither backend program is in. It is answered
-            // entirely by MG_Impl/GLImpl/Program/ProgramInterface from the frontend reflection.
-            // Takes the block's GL NAME, not glShaderStorageBlockBinding's index. The index
-            // the application passes is the frontend interface-query enumeration's, and no
-            // backend shares that index space: DirectVulkan enumerates SPIR-V descriptor
-            // bindings and DirectGLES asks a real driver about SPIRV-Cross-generated ESSL.
-            // The name is the one coordinate all three agree on, so the frontend resolves the
-            // index against its own enumeration and each backend maps the name to its own.
-            void (*ShaderStorageBlockBinding)(GLuint program, const GLchar* storageBlockName,
-                                              GLuint storageBlockBinding);
-            // 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 {
-            SizeT UniformBufferOffsetAlignment = 256;
-            // GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, which is a SEPARATE limit from the
-            // uniform one and is routinely larger: Adreno 830 reports 32 for uniform buffers and
-            // 64 for storage buffers. Answering the storage query with the uniform value let an
-            // application bind a storage range at an offset the driver cannot address, which it
-            // accepted without error and then wrote somewhere else entirely.
-            SizeT ShaderStorageBufferOffsetAlignment = 256;
-            // GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT. 1.0 means the backend cannot filter anisotropically,
-            // which is also why the extension is not advertised in that case.
-            Float MaxTextureMaxAnisotropy = 1.0f;
-            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;
-            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.
-            GLenum LayerProvokingVertex = GL_UNDEFINED_VERTEX;
-            GLenum 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;
-            SizeT MaxShaderStorageBlockSize = 128 * 1024 * 1024;
-            Uint32 SubgroupSize = 0;
-            Uint32 SubgroupSupportedStages = 0;
-            Uint32 SubgroupSupportedFeatures = 0;
-            Bool SubgroupQuadOperationsInAllStages = false;
-            GpuVendorKind GpuVendor = GpuVendorKind::Unknown;
-        };
-
-        enum class WindowBackend {
-            Android,
-            X11,
-            MetalLayer,
-            Win32, // Handle is an HWND
-            // TODO: Wayland, etc.
-            WindowBackendCount,
-            Unknown = -1
-        };
-
-        struct WindowHandle {
-            WindowBackend Backend = WindowBackend::Unknown;
-            void* Handle = nullptr;
-            Uint32 Width = 0;
-            Uint32 Height = 0;
-        };
-
-        class BackendObject {
-        public:
-            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);
-            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();
-
-            void SetWindowHandle(const WindowHandle& handle);
-
-            virtual const RendererInfo& GetRendererInfo() const = 0;
-            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
-            };
-
-            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

@@ -1,18 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/BackendObjects.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 "DirectGLES/BackendObject_DirectGLES.h"
-#include "DirectVulkan/BackendObject_DirectVulkan.h"
-
-namespace MobileGL::MG_Backend {
-    extern UniquePtr<BackendObject>& pActiveBackendObject;
-    extern GlobalBackendFunctionsTable gBackendFunctionsTable;
-} // namespace MobileGL::MG_Backend

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.h

@@ -1,92 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.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/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;
-
-        const RendererInfo& GetRendererInfo() const override;
-        String GetBackendAPIVersionString() const override;
-        const GlobalBackendFunctionsTable& GetBackendFunctions() const override;
-        const DynamicBackendParameters& GetDynamicParameters() const override;
-        BackendType GetBackendType() const override;
-
-        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;
-        void OnEGLSurfaceReleased(EGLSurface surface) override;
-
-        Bool m_initialized = false;
-        MG_External::EGLFunctionsTable m_EGLFunctions;
-        MG_External::GLESFunctionsTable m_GLESFunctions;
-        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/DirectGLES.h

@@ -1,234 +0,0 @@
-// MobileGL - MobileGL/MG_Backend/DirectGLES/DirectGLES.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 <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>
-
-#define CallAndCheck(operation)                                                                                        \
-    MGLOG_D("Call GLES func: %s", #operation);                                                                         \
-    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();
-    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 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 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);
-    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 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 GetInteger64i_v(GLenum target, GLuint index, GLint64* data);
-    void GetProgramiv(GLuint program, GLenum pname, GLint* params);
-    void ShaderStorageBlockBinding(GLuint program, const GLchar* storageBlockName, GLuint storageBlockBinding);
-    Bool InitWindowSurface(NativeWindowType window);
-    Bool InitPbufferSurface(EGLint width, EGLint height);
-    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);
-    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
-
-    extern MG_External::EGLFunctionsTable g_EGLFuncs;
-    extern MG_External::GLESFunctionsTable g_GLESFuncs;
-    extern MG_External::GLESCapabilities g_GLESCapabilities;
-} // namespace MobileGL::MG_Backend::DirectGLES

MobileGL/MG_Backend/DirectGLES/MultiDraw.cpp

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