[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'

.claude/skills/anland-mobilegl-plasma/.gitattributes

@@ -1,3 +0,0 @@
-# Everything here is executed by bash/sh on Linux, Android or WSL: keep LF even on a Windows checkout
-# (core.autocrlf=true would otherwise hand sh a script full of $'\r').
-* text=auto eol=lf

.claude/skills/anland-mobilegl-plasma/SKILL.md

@@ -1,183 +0,0 @@
----
-name: anland-mobilegl-plasma
-description: Bring up, rebuild, deploy, switch backends on, test and debug the "MobileGL + anland + KDE Plasma" stack - a rooted Android tablet whose anland APK embeds the MobileGL server, plus a Droidspaces Arch Linux ARM container running KWin/plasmashell/Chrome through the MobileGL client library and GBM backend - driven from this Windows machine (Git Bash, WSL archlinux, adb). Use it after a phone reboot, when changing server (NDK) or client (container glibc) MobileGL code or anland's KWin backend/patch, when switching Espryt/Magma, when validating zero-copy dma-buf presentation, and when chasing crashes, black windows, noise or software-rendering fallbacks in the Plasma session.
----
-
-# MobileGL on anland KDE Plasma
-
-**Setting this up on a new machine or phone from source: `reproduce.md` next to this file.**
-Human-readable runbook (Chinese, same content): `docs/Disaggregated/notes/anland/runbook-plasma.md`.
-Background: `docs/Disaggregated/notes/anland/handoff-legacy-mobilegl-unified.md` (state, commits, known
-issues) and `plan-ahb-dmabuf.md` (zero-copy design).  All scripts are in `scripts/` next to this file;
-parameters are documented at the top of each script and in `scripts/env.sh`.
-
-**The phone may be shared with another session.** Before anything that restarts the app, the daemon,
-the container session or replaces a library, run the read-only `scripts/device/status.sh` and make sure
-nobody else is mid-test.  Use your own `ct.sh` channel names (others use c, c2, c3, xd, xr, gbm).
-
-## Architecture (10 lines)
-
-1. Phone: Lenovo TB321FU (Y700, Adreno 750, Android 15, kernel 6.1), rooted with **KernelSU** (`/data/adb/ksu`, `ksud`; `su -c` works). USB serial `HA27Q3LQ`, or wireless adb `ip:port`.
-2. anland APK `com.anland.consumer.mobilegl` (debuggable build of anland branch `legacy-mobilegl-unified`): UI process + private service process `:mobilegl` (`MobileGLWorker`), which loads the **server** `libMobileGL.so` (NDK, from MobileGL `feat/disaggregated`) and listens on abstract socket `@anland-mobilegl` from the first attached window on. One process serves every client (KWin, plasmashell, ksplash, Chrome...), one backend per process. `MobileGLWorker` is a **foreground service** (notification "Linux desktop is running" / action "Stop desktop"), so the server and the session outlive a hidden, locked or swiped-away window.
-3. Backend = the app setting "Renderer backend" (Settings > Connection > MobileGL desktop; file `/data/data/<pkg>/files/mobilegl-backend`, default DirectGLES; also `am start ... --es mobilegl_backend X`). Espryt = DirectGLES, Magma = DirectVulkan. The server reads it when its process starts; the app publishes it as `/data/local/tmp/anland-mobilegl/backend` and the session copies that into the container's `/etc/mobilegl/backend` (what every client reports; mismatch = "Hello.backendType disagrees with pinned backend"). `debug.mobilegl.backend`, if someone sets it, still overrides the setting until the next reboot.
-4. Experiment display daemon `/data/adb/modules/anland-daemon/display_daemon /data/local/tmp/anland-mobilegl/display.sock` (display/input broker), started by the app (below). The module only starts the original one on `/data/local/tmp/display_daemon.sock` at boot; leave that alone.
-5. Container `arch-kde-mgl` (Droidspaces 6.4.5, Arch Linux ARM aarch64 glibc, host net, `rootfs.img` mounted at `/mnt/Droidspaces/arch-kde-mgl` on the Android side). Bind mounts: `/data/local/tmp/anland-mobilegl` -> `/run/anland-mobilegl`, `/data/local/tmp/display_daemon.sock` -> `/run/display.sock`.
-6. `desktop-session.service` (User=swung0x48, **enabled**: the container boots straight into it, as the original image does) has drop-in `/etc/systemd/system/desktop-session.service.d/mobilegl.conf` (anland `producers/kde/Arch_v5/desktop-session-mobilegl.conf`, installed + enabled by `sync-build-kwin.sh`): `ExecStartPre=mobilegl-startup.sh wait` (until `@anland-mobilegl` listens in `/proc/net/unix` and the daemon socket exists), `ExecStartPre=+... sync-backend`, `Restart=always`, then `ExecStart=/opt/mobilegl/bin/mobilegl-startup.sh plasma`, which deletes the sticky software-renderer key, sets `MOBILEGL_IPC_PROBE_TIMEOUT_MS=0` session-wide (MobileGL never declines, so glvnd never falls through to another GL stack), writes a user drop-in for `plasma-kwin_wayland.service` (kwin_wayland_wrapper -> `/opt/mobilegl/kwin/bin/kwin_wayland` + `/opt/mobilegl/kwin/lib/libkwin.so.6.7.4`, `ANLAND_MOBILEGL=1`, `MOBILEGL_IPC_SURFACE=server`) and runs `startplasma-wayland`.
-7. KWin 6.7.4 with anland's `anland` backend renders straight into the anland Android Surface through the server. While the window is not on screen (consumer disconnected) the backend powers its output down (DPMS Off + RenderLoop inhibited: no compositing, no frame callbacks) and back up when the window returns. Every other GL process is `MOBILEGL_IPC_SURFACE=offscreen` and presents through KWin.
-8. Client = `/opt/mobilegl/lib/libMobileGL.so` (glibc aarch64), the container's **system-wide** GL vendor (section below): glvnd EGL vendor `/usr/share/glvnd/egl_vendor.d/10_mobilegl.json` (sorts before the distribution's `50_*.json`, which serves whenever MobileGL declines), GLX vendor `/usr/lib/libGLX_mobilegl.so.0`, settings from `/etc/mobilegl/client.conf` (`MOBILEGL_TRANSPORT=spawn MOBILEGL_IPC_DATA=shm MOBILEGL_IPC_CONTROL=unix:@anland-mobilegl`) + `/etc/mobilegl/backend`. No per-process environment is needed.
-9. Zero-copy windows: client `wl_egl_window` frames are server-allocated AHardwareBuffer "shared images" exported as dma-buf fds over `zwp_linux_dmabuf_v1`; KWin imports them with EGL and the server recognises its own buffer by inode. KWin gets a DRM device via `GBM_BACKEND=mobilegl` -> `/usr/lib/gbm/mobilegl_gbm.so` (node is only an identity, never ioctl'd). Without linux-dmabuf the client falls back to wl_shm readback.
-10. X11 (`docs/Disaggregated/notes/anland/plan-x11-gpu.md`): Xwayland draws with **glamor on MobileGL** (an offscreen session; `GBM_BACKEND=mobilegl` on KWin's render node; window pixmaps are shared images handed to KWin as linux-dmabuf buffers; its `glFlush` publishes them through the server, `/tmp/mgl-xwayland.client.log`); `ANLAND_XWAYLAND_GLAMOR=0` in KWin's drop-in brings back the software `-shm` Xwayland. GLX windows present their frames as shared images through **DRI3 + Present** (log `presented through DRI3+Present shared images`), falling back to readback + MIT-SHM / `xcb_put_image` when the X server has no DRI3 (`MOBILEGL_GLX_PRESENT=readback` forces it per app). Chrome runs ANGLE-GLES over MobileGL EGL with the GPU in its own process (`mobilegl-startup.sh chrome`; `MOBILEGL_CHROME_GPU=in-process` opts out), presenting GBM dma-bufs over linux-dmabuf; after a device loss Chrome restarts that process and repaints.
-
-## First-time prerequisites (Windows host)
-
-- Git Bash, `adb` (SDK platform-tools), CMake >= 3.22 and Ninja on PATH (seen: CMake 3.27.6, Ninja 1.13.2), Python 3 + Pillow (only `rec.sh`).
-- Android NDK **27.2.12479018** at `%LOCALAPPDATA%/Android/Sdk/ndk/27.2.12479018` (override `ANDROID_NDK`).
-- WSL distro **archlinux** with clang, lld, llvm, cmake, ninja. **lld's major version must equal clang/llvm-libs'** (lld 23 on llvm 22 broke `ld.lld`; working set: all 22.1.6). Then export the sysroot once: `bash scripts/xsysroot/refresh-sysroot.sh` (-> `~/sysroots/arch-kde-mgl` + `~/sysroots/aarch64-arch.cmake`; re-run after container package upgrades, then `xbuild.sh --reconfigure`).
-- MobileGL worktree (never build in the shared main checkout): `GIT_LFS_SKIP_SMUDGE=1 git worktree add ...`, `git submodule update --init --recursive`, and copy `3rdparty/glslang/External/spirv-tools` from the main checkout (the submodule leaves it empty).
-- anland worktree on `legacy-mobilegl-unified` (KWin patch/backend, startup script, `mobilegl-tools/`).
-- Phone side that already exists and is NOT recreated by this skill: the APK (build: anland `consumers/anland_v5/android_consumer/MOBILEGL.md`, gradle `:app:assemblePlainDebug` with `MOBILEGL_DIST`, `-PmobileglApplicationId=com.anland.consumer.mobilegl -PanlandDefaultSocket=/data/local/tmp/anland-mobilegl/display.sock`, from Git Bash with `MSYS_NO_PATHCONV=1`; signed with this machine's `~/.android/debug.keystore`, so `adb install -r` works; reinstalling with another key changes the UID and needs the KernelSU grant again - `mobilegl-tools/ksu_grant.c`), the anland KernelSU modules (`anland-daemon`, `anland-awl`), the container with KWin's configured build tree `/root/mobilegl-build/kwin-6.7.4/build` and pristine `/root/gbm-dev/kwin-a/src`.
-- Install the helpers once (container must be running): `bash scripts/push-tools.sh` (device/*.sh -> `/data/local/tmp/anl`, `mgrun` -> container `/usr/local/bin`, `kwprep.sh` -> container `/root`).
-
-Run host scripts from Git Bash as `bash scripts/<x>.sh`.  Raw adb with device paths needs `MSYS_NO_PATHCONV=1` and the whole root command in one quoted string: `adb shell 'su -c "..."'`.  A device script can also be run without pushing: `MSYS_NO_PATHCONV=1 adb shell 'su -c sh' < scripts/device/status.sh`.
-
-## Starting, idling, stopping - no manual steps
-
-Nothing starts at phone boot (container `run_at_boot=0`). **Opening the app** (launcher icon = `am start -n com.anland.consumer.mobilegl/com.anland.consumer.MainActivity`, no extras; the APK's default socket is the experiment's, `-PanlandDefaultSocket`) calls `MobileGLDesktop.ensureStarted()` - the single trigger - which starts the foreground service and runs the APK's `assets/mobilegl-desktop.sh up` as root (`su`): display daemon if absent (the script leaves the app's cgroup first, so it survives the app) -> backend published -> container started if stopped -> `systemctl start --no-block desktop-session`. The window waits for the daemon socket; the server listens once the Surface is attached; the session's `wait` step then lets Plasma start. A reopen with everything up only reattaches the window. Log: `/data/local/tmp/anland-mobilegl/desktop.log`, logcat `AnlandMobileGL` ("MobileGL desktop up done in N ms").
-
-Hidden window, screen off, lock screen or swiped-away task: server and session stay (foreground service); KWin turns the workspace's DPMS off (logs "viewer gone: output powered down"; windows get xdg_toplevel `suspended`, no frame callbacks) and back on ("viewer back"). Client swaps are paced by frame callbacks (`MG_Impl/EGLImpl/FrameThrottle.h`): interval >= 1 waits like any Wayland EGL; interval 0 (Chrome) drops to ~1 fps once a callback goes unanswered for 200 ms.
-
-Measured 2026-10-03 (Espryt, Chrome on webglsamples aquarium; % of one core, phone = all of Android): open-to-desktop cold 7.5-12.5 s (daemon 0.5, server 1.0, container 1.5, kwin ~5, plasmashell ~6-7), after a phone reboot 8.5 s, reopen of a running desktop 0.2 s; visible phone 249% / kwin 13 / chrome 99 / server 57 / GPU 22%, hidden 54 / 0 / 6 / 2 / 0%, locked 38 / 0 / 8 / 3 / 0%. Stop desktop 1.7 s. Wireless adb does not come back by itself after a reboot (re-enable it on the phone). **Stop desktop** (notification action, or `am startservice -n <pkg>/com.anland.consumer.MobileGLWorker -a com.anland.consumer.mobilegl.STOP`) runs `mobilegl-desktop.sh down` (session + container stopped, daemon stays), closes the windows, ends `:mobilegl`.
-
-```sh
-adb connect <ip>:<port>                        # only for wireless debugging
-export MSYS_NO_PATHCONV=1
-adb shell 'su -c "sh /data/local/tmp/anl/bringup.sh"'     # after a reboot: wake, dismiss keyguard, open the app, print the timeline
-bash scripts/desktop-verify.sh push cold reopen idle      # timed cold start, swipe-away + reopen, CPU/GPU visible/hidden/locked
-adb shell 'su -c "sh /data/local/tmp/anl/status.sh"'
-```
-
-`droidspaces` has no `status` command; `droidspaces show` lists running containers. `device/run-plasma.sh` is a developer restart (session + logind user, then the app), needed after a rebuild because KWin does not reconnect to a new server process. `device/desktop-reset.sh` takes everything down to the post-reboot state. The old manual sequence (setprop, start container, `restart-daemon.sh`, `run-plasma.sh`) is gone; `restart-daemon.sh` remains for daemon debugging only.
-
-## Build and deploy loops
-
-**Server (Android, NDK) -> APK lib**
-```sh
-bash scripts/build-android.sh          # -> <worktree>/build-android/libMobileGL.so (RelWithDebInfo, unstripped)
-bash scripts/cyc.sh s1                 # clear sticky SW-renderer key, push, swap into APK, restart session, screenshot $ANL_DIR/s1.png, print fatals
-```
-`device/swap.sh` overwrites `/data/app/.../lib/arm64/libMobileGL.so` keeping owner/mode/SELinux context (original saved as `/data/local/tmp/anland-mobilegl/libMobileGL.so.orig`); no re-signing. To swap without the session restart: push to `/data/local/tmp/anland-mobilegl/libMobileGL.new.so`, `su -c "sh /data/local/tmp/anl/swap.sh"`, then `run-plasma.sh` anyway (KWin does not reconnect to a new server process).
-
-**Client + GBM backend (container glibc) via WSL cross-build**
-```sh
-bash scripts/xbuild.sh [--reconfigure]  # WSL ~/mgl-xbuild-a64; ~150 s full, seconds incremental
-bash scripts/xdeploy.sh                 # rename-into-place install of libMobileGL.so + mobilegl_gbm.so, aliases, vendor JSONs, client.conf, GLX/GBM env drop-ins
-```
-Running clients keep the old inode; restart the client, or `run-plasma.sh` for KWin/plasmashell.  Build server and client from the **same commit** (both stamp `git rev-parse HEAD`), else the logs WARN "compatible wire with different build".  Fallback in-container build (slow): `scripts/sync-src.sh` + anland `mobilegl-tools/anland-build-client.sh`.
-
-**KWin (anland backend / kwin.patch) - built inside the container**
-```sh
-bash scripts/kwin-stage.sh build        # stage CR-stripped patch+backend+startup script, kwprep.sh, background sync-build-kwin.sh
-printf 'tail -5 /root/kwin-build.log\n' | bash scripts/ct.sh kw     # wait for "== ALL DONE =="
-adb shell 'su -c "sh /data/local/tmp/anl/run-plasma.sh"'
-```
-`sync-build-kwin.sh` (anland `producers/kde/Arch_v5/`) copies only the backend sources, then `ninja -j4`, installs `kwin_wayland`, `libkwin.so.6.7.4`, the patched screencast plugin and `/opt/mobilegl/bin/mobilegl-startup.sh` by atomic rename.  `kwprep.sh` is what applies changed `kwin.patch` hunks to core KWin files.  Repo-root `libdisplay_producer/` is not synced by either.  `kwin-stage.sh` is assembled from those two scripts and was not run as one unit yet.
-
-**Unit tests (no device)** - in WSL (the MSVC build of this branch is broken):
-```sh
-MSYS2_ARG_CONV_EXCL='*' wsl -d archlinux -- bash /mnt/c/<worktree>/.claude/skills/anland-mobilegl-plasma/scripts/wsl-test.sh MultiSessionTest TwinOwnershipTest
-MSYS2_ARG_CONV_EXCL='*' wsl -d archlinux -- bash -lc 'cd ~/mgl-anl-bld && ctest -R "MultiSession|TwinOwnership" -E DirectVulkan --output-on-failure'
-```
-`wsl-all.sh` builds and runs every unit test.  Never run DirectVulkan integration tests; never two ctest runs at once.
-
-## Switching backends
-
-In the app: Settings > Connection > MobileGL desktop > Renderer backend, then Stop desktop and open the app. Or `adb shell 'su -c "sh /data/local/tmp/anl/switch.sh DirectGLES"'`, which does the same (saves the setting through the launch extra, STOPs the service, reopens; clears a stale `debug.mobilegl.backend`). No setprop, no file to edit in the container: the session copies the published backend into `/etc/mobilegl/backend` on its next start. `cyc.sh` keeps whatever is set.
-
-## System-wide vendor and fallback
-
-Installed by `xdeploy.sh` (and anland's `anland-build-client.sh`), so any process in the container gets MobileGL through the stock libglvnd/libgbm:
-
-| File | Does |
-|---|---|
-| `/usr/share/glvnd/egl_vendor.d/10_mobilegl.json` | EGL vendor, asked before the system's `50_*.json` |
-| `/opt/mobilegl/share/glvnd/egl_vendor.d/50_mobilegl.json` | same JSON, for per-process forcing with `__EGL_VENDOR_LIBRARY_FILENAMES` |
-| `/etc/mobilegl/client.conf` | `KEY=value` defaults for every client (transport, data, endpoint); rewritten on deploy |
-| `/etc/mobilegl/backend` | the backend (the session's `sync-backend` step copies the app's choice in); wins over a `MOBILEGL_BACKEND_TYPE` line in client.conf |
-| `/etc/environment.d/10-mobilegl.conf` | `__GLX_VENDOR_LIBRARY_NAME=mobilegl`, `GBM_BACKEND=mobilegl` for the systemd user manager (all Plasma services and what they start, terminals included) |
-| `/etc/profile.d/mobilegl.sh` | the same two for login shells (`bash -l`, `su -l`, ssh, `droidspaces run bash -l`) |
-
-Precedence is environment > `/etc/mobilegl/backend` (backend only) > client.conf > built-in; `MOBILEGL_CONFIG_FILE` / `MOBILEGL_BACKEND_FILE` name other files (empty = off); a server process never reads them.
-
-**Fallback.** Before bringing anything up the client probes the configured endpoint (one non-blocking connect, `MOBILEGL_IPC_PROBE_TIMEOUT_MS`, default 250, 0 = off; a refused abstract socket answers in ~0.2 ms). With no server: the EGL vendor returns `EGL_NO_DISPLAY` and no devices (glvnd moves on to the other vendor), the GLX vendor fails `__glx_Main` (libGLX falls back to the vendor Xwayland names), and `mobilegl_gbm` fails `create_device` (libgbm falls back to the device's own backend). Client queries (`eglQueryString(EGL_NO_DISPLAY)`, `eglGetProcAddress`) never bring a session up. MobileGL also steps aside for a GBM device another backend created and for `LIBGL_ALWAYS_SOFTWARE=1` - that is how a software Xwayland (`ANLAND_XWAYLAND_GLAMOR=0`, KWin's patch sets it then) keeps the software stack. MobileGL never opens an X connection to a display its own process serves (`MG_Util/X11/DisplayGuard.h`; `MOBILEGL_X11_DIAL=0` forbids all), which is what made a glamor Xwayland deadlock on itself before. Show it without stopping the real server:
-```sh
-sed 's|^MOBILEGL_IPC_CONTROL=.*|MOBILEGL_IPC_CONTROL=unix:@nobody|' /etc/mobilegl/client.conf > /tmp/down.conf
-sudo -u swung0x48 env -i HOME=/home/swung0x48 PATH=/usr/bin XDG_RUNTIME_DIR=/run/user/1000 WAYLAND_DISPLAY=wayland-0 \
-  MOBILEGL_CONFIG_FILE=/tmp/down.conf eglinfo -B -p wayland     # vendor = the other one, ~0.1 s
-```
-
-## Test clients and how to verify
-
-X11 on the GPU has its own driver, `scripts/x11-verify.sh` (preflight, measure before/after with glxgears at `vblank_mode=0` on both GLX paths (presentation throughput only: glxgears is fixed-function GL, which MobileGL does not implement, so its window is black by design), deploy-client/-kwin/-server, check, apps, stop); `scripts/device/x11-measure.sh` refuses to load the phone below 40% battery.
-
-Inside the container as root (`printf '...' | bash scripts/ct.sh <chan>`), `mgrun offscreen <cmd>` runs a client as swung0x48 in the live session through a login shell, with nothing but the surface mode and the log path set (log `/tmp/mgl-run.client.log`, override base with `MGLOG=/tmp/x.log`); a plain `env -i ... bash -l -c '<cmd>'` as swung0x48 gets MobileGL the same way:
-```sh
-mgrun offscreen eglinfo -B ; mgrun offscreen glxinfo -B
-timeout 25 mgrun offscreen glmark2-es2-wayland -s 1280x720 --run-forever > /tmp/gm.out 2>&1 &
-sleep 8; grep -a "presented through" /tmp/mgl-run.client.log
-```
-Chrome: `bash scripts/chrome-launch.sh <tag> [flags]` (log `/tmp/mgl-chrome-<tag>.client.log`, screenshot `ch-<tag>.png`; `CHROME_GPU=in-process` puts the GPU back in the browser, which cannot recover from a device loss).
-Video: Chrome decodes in hardware. The GPU process's render node has a VA-API driver in the container (`/usr/lib/dri/msm_drm_drv_video.so`, DroidSpaces' V4L2 driver): Chrome allocates its frames with `vaCreateSurfaces` and exports them (`vaExportSurfaceHandle`, one fd, R8 + GR88 layers) - the driver's own buffers, never GBM ones - and imports each as an NV12 (P010 for 10-bit) EGLImage bound to `GL_TEXTURE_EXTERNAL_OES`. MobileGL takes such a FOREIGN YUV dma-buf through its labelled CPU-copy fallback: the server maps it and copies it into a YUV AHardwareBuffer of its own (`AHardwareBuffer_lockPlanes`) at the reader's first use in each frame (any present, publishing flush or native fence), then converts that into the texture's RGBA level on the GPU (Espryt: `GL_EXT_YUV_target` with the import's colour hints, `MOBILEGL_YUV_DRIVER_CONVERSION=1` for the driver's external sampler; Magma: `VkSamplerYcbcrConversion` on the AHB's external format). A server-allocated NV12/P010 buffer (GBM `gbm_bo_create(NV12)`) needs no copy. `MOBILEGL_CHROME_VIDEO_DECODE=software` in `mobilegl-startup.sh chrome` brings back `--disable-accelerated-video-decode`. Check a video with `scripts/probes/cdpmedia.py <port> <s>` in the container (CDP `Media.enable`: `kVideoDecoderName = VaapiVideoDecoder`, `kIsPlatformVideoDecoder = true`; `CDP_NAVIGATE=<url>` / `CDP_EXPR=<js>`), which needs Chrome started with `--remote-debugging-port` and a non-default `--user-data-dir` (a fresh profile also needs `--password-store=basic`, else page loads wait forever on KWallet), and grep Chrome's log for `exit_code` (a GPU-process restart). `scripts/probes/yuvprobe.c` pixel-checks foreign NV12/P010 imports, their per-frame refresh and a GBM NV12 buffer (`mgrun offscreen mgl-yuvprobe`, exit 0 = pass). KWin's own NV12 path (it splits a YUV buffer into R8 + GR88 imports) is not served: MobileGL imports no single-channel dma-bufs, so KWin advertises no YUV format over linux-dmabuf. A vendor-agnostic replacement driver (MobileVA: VA-API on Android MediaCodec, decoding into server YUV images with no CPU copy, the current driver kept as an A/B fallback) is planned, not built: `docs/MobileVA/plan.md`.
-Device loss: `setprop debug.mobilegl.inject_device_lost_pid <pid>` (as root) loses the server session of the client whose pid - as it sees itself in the container - is `<pid>`, once per value, on any backend and whether or not it presents; `debug.mobilegl.inject_device_lost_at N` instead loses whichever session makes the N-th device check (Espryt presents and read-backs only). `bash scripts/chrome-recover.sh <in-process|process> [rounds]` checks that Chrome repaints after such a loss without a restart (battery-guarded, stops below 40%). `bash scripts/kwin-recover.sh [rounds]` loses KWin's own session (default twice) and checks that KWin restarts compositing on a fresh session - same KWin, plasmashell and client processes, the screen still animating (glmark2 on Wayland, glxgears on X11, `CHROME=1` adds Chrome) - which needs the anland backend + kwin.patch reset handling deployed (`kwin-stage.sh build`).
-Probes: `scripts/probes/texfmt.c` (texture formats keep alpha?), `dmahash.c` (hash a process's dma-bufs), `yuvprobe.c` (YUV dma-buf sampling, `gcc -O1 /root/yuvprobe.c -o /usr/local/bin/mgl-yuvprobe -lEGL -lGLESv2 -lgbm -lm`), `cdpmedia.py` (which decoder a Chrome page uses); build in the container, e.g. `gcc -O1 /root/texfmt.c -o /usr/local/bin/mgl-texfmt -lEGL`, run with `mgrun offscreen`.
-GPU hangs: a shader that never ends stops the WHOLE GPU (every process, MobileGL or not) until the kernel resets it - ~2 s, or ~10 s ("Preemption Fault" in dmesg) when a higher-priority context waits; nothing in user space shortens one stall. What the server does is end the guilty session so it cannot hang the GPU again (Magma: event-bracketed submissions + `mgl-gpu-watch`, budget `MOBILEGL_GPU_HANG_BUDGET_MS` / `debug.mobilegl.gpu_hang_budget_ms`, default 2000; Espryt: the driver's GUILTY reset status, which it reports after the ~2 s reset only). Repro: `scripts/probes/hangclient.c` (Wayland + GL 3.3 core; `-H 60 -N 1 -E 60` hangs every 60 frames, `-H -1` is a frame-gap observer; build with wayland-scanner's xdg-shell files, `-lwayland-client -lwayland-egl -lEGL -lOpenGL -lm`), and `gpuprobe.c` (NDK, plain adb shell; `gpuprobe 30 high` is a high-priority GLES context outside MobileGL - it both measures the device-wide stall and forces the 10 s preemption path).
-
-A result counts only if ALL hold:
-- client log says `presented through linux-dmabuf shared images` (not `wl_shm`; `could not be presented through a linux-dmabuf shared image` = fell back);
-- `bash scripts/shot.sh g 2 1` gives two different hashes while the client animates (a "fast" score can mean frames are not shown);
-- `adb logcat -b crash -d` and `adb logcat -d | grep -E "Fatal signal|Abort message|E MobileGL"` are clean (a frozen window is usually a dead server);
-- for plasmashell verdicts, the sticky software renderer is off (below) and `/tmp/mgl-plasmashell.client.log` is freshly written.
-Reference (glmark2-es2-wayland 1280x720, zero-copy vs wl_shm): Espryt 187 vs 49, Magma 158 vs 34.  Rerun any surprising pass.
-
-## Logs
-
-| What | Where |
-|---|---|
-| KWin client side | container `/tmp/mobilegl-compositor.client.log` |
-| plasmashell / ksplash | `/tmp/mgl-plasmashell.client.log`, `/tmp/mgl-ksplash.client.log` (user drop-ins `~/.config/systemd/user/plasma-{plasmashell,ksplash}.service.d/mobilegl-log.conf`) |
-| mgrun / Chrome | `/tmp/mgl-run.client.log`, `/tmp/mgl-chrome-<tag>.client.log` (+ `/tmp/chrome-<tag>-out.log`) |
-| Server | `adb logcat -s MobileGL`; file `/data/data/com.anland.consumer.mobilegl/files/mobilegl-server.server.log` |
-| Native crashes | `adb logcat -b crash -d`; container `coredumpctl list` |
-| Session / KWin stderr | container `journalctl -u desktop-session --no-pager`, `journalctl --no-pager --since -2min \| grep kwin_wayland` |
-| Display daemon | `/data/local/tmp/anland-mobilegl/display-daemon.log` |
-| Desktop start/stop (app's su script) | `/data/local/tmp/anland-mobilegl/desktop.log`, `container-start.log`; logcat `-s AnlandMobileGL` |
-| Session wait / backend sync | container `journalctl -u desktop-session --no-pager` ("waiting for the MobileGL server ...") |
-
-`MOBILEGL_LOG_FILE_PATH=/tmp/x.log` produces `/tmp/x.client.log` (and `.server.log` for forwarded lines); files are truncated on open, so one base per process.  Client builds log at INFO.  Symbolize server frames with `$ANDROID_NDK/toolchains/llvm/prebuilt/windows-x86_64/bin/llvm-addr2line.exe -Cfe build-android/libMobileGL.so <offset>`.
-
-## Pitfalls
-
-- **pkill -f self-match**: a `ct.sh`/`droidspaces run bash -lc "<script>"` process carries the script in its argv; `pkill -f chrome` kills the runner. Use `pkill -x`.
-- **Root-owned /tmp files**: a log created by a root-run client cannot be reopened by swung0x48 later (no log appears). `rm -f` it as root first.
-- **Sticky Plasma software renderer**: after any server crash Plasma writes `[QtQuickRendererSettings] SceneGraphBackend=software` into `~swung0x48/.config/kdeglobals`; plasmashell then renders on the CPU and screenshots still look fine (tray icon "正在使用的软件渲染器"). `mobilegl-startup.sh plasma` deletes it at every session start; within a running session that hit a crash, restart the session (`run-plasma.sh`) before any verdict.
-- **Lock screen**: autolock is off (`kscreenlockerrc [Daemon] Autolock=false`); a real lock can only be left by typing the password (logind lock/unlock is not supported for this session type - `device/unlock.sh` is unverified). Test the greeter with `/usr/lib/kscreenlocker_greet --testing` and kill it.
-- **CRLF**: `core.autocrlf=true` here; anland's backend sources and `sync-build-kwin.sh` are CRLF in the Windows checkout. Strip CR before anything runs on Linux/Android (`tr -d '\r'`; `ct.sh`, `push-tools.sh`, `kwin-stage.sh` do). This skill has a `.gitattributes` forcing LF.
-- **Display daemon**: the app starts it; the session's `wait` step keeps KWin from starting without it (a KWin that cannot reach it logs "failed to connect to display daemon at /run/anland-mobilegl/display.sock" and exits in ~3 s). Anything started from the app's `su` must leave the app's cgroup (`echo $$ > /sys/fs/cgroup/cgroup.procs`) or a force-stop kills it.
-- **Device power/connection**: low battery or the screen turning off (30 s default) can kill the SurfaceView - `svc power stayon true`; wireless adb `ip:port` changes per pairing - never pin `-s HA27Q3LQ`, use `ANDROID_SERIAL` if several devices are attached.
-- **Container vs phone paths**: container `/tmp` is a different place from the phone's `/data/local/tmp`; move files via `/mnt/Droidspaces/arch-kde-mgl/root` (container `/root`) or `/data/local/tmp/anland-mobilegl` (= container `/run/anland-mobilegl`).
-- **Never overwrite a mapped .so in place** (container or APK while running): copy to a new inode and `mv -f`; the APK swap force-stops the app first.
-- **Input**: plain `adb shell input` is blocked - use `su -c input`; anland grabs the touchscreen, so if `input tap` does nothing use `input mouse tap x y`. Never `debuggerd -b` a container process (signal 35 kills glibc processes).
-- **linux-dmabuf**: the client must use `create` + roundtrip, never `create_immed` (KWin answers a failed immediate import with a protocol error that kills the client).
-- **Cross-session bugs**: noise / another window's pixels after some client starts or exits = process-global state in the multi-session server (handles are per client, FBO/VAO per context). Repro with `kscreenlocker_greet --testing`.
-- `/etc/environment` leaks the baseline session's driver variables through pam_env (and, via `/usr/lib/environment.d/99-environment.conf`, into the user manager); `mobilegl-startup.sh` unsets them - keep that when editing it.
-- **Shared log path**: Xwayland inherits KWin's `MOBILEGL_LOG_FILE_PATH`; any line a process logs opens (truncates) that file. MobileGL stays silent in processes it does not serve, but give any extra client its own `MOBILEGL_LOG_FILE_PATH`.
-- **Stale per-process overrides**: an `__EGL_VENDOR_LIBRARY_FILENAMES` / `MOBILEGL_*` left in a unit drop-in or the user manager's environment (`systemctl --user show-environment`) still wins over the system files; `run-plasma.sh` (terminate-user) clears the manager's.
-- `handoff` mentions a `kwin_wayland` logging shim and `/tmp/mgl-kwin-<pid>.log`: stale - `/opt/mobilegl/kwin/bin/kwin_wayland` is now the real binary and logs to `/tmp/mobilegl-compositor.client.log`.
-
-## House rules
-
-- Work in a git worktree, never in the shared main checkout or its build dirs; worktrees need `GIT_LFS_SKIP_SMUDGE=1`.
-- Commit with `git commit --no-verify`, one short sentence, **no** `Co-Authored-By` trailer.
-- Never run the DirectVulkan integration tests (`ctest -E DirectVulkan`).
-- No external project names ("Mesa", "Zink", ...) in source code or comments; describe the technique.
-- Vendor-agnostic only on the zero-copy path: AHB, EGL_ANDROID_*, VK_ANDROID AHB import, sync_file, dma-buf, libgbm ABI - no kgsl/gralloc layouts/QCOM modifiers.
-- Identity caches key on monotonic lifetime ids, never GL names or pointers.

.claude/skills/anland-mobilegl-plasma/reproduce.md

@@ -1,183 +0,0 @@
-# Reproducing the MobileGL + anland + KDE Plasma setup from source
-
-This is the from-scratch path for a NEW development machine and/or a NEW phone.  `SKILL.md` covers the
-day-to-day loop once everything below exists.  Paths and names that are specific to the original
-machine are listed in step 9: set them in `scripts/env.sh` (or the environment) before running anything.
-
-## 0. What you need
-
-**Phone.**
-- arm64 Android 11+ with **root**. KernelSU is what this was built on; the scripts only need `su -c`.
-- A Vulkan 1.1 driver with `VK_ANDROID_external_memory_android_hardware_buffer` for Magma, and/or GLES 3.2 + EGL_ANDROID_native_fence_sync for Espryt. Nothing vendor-specific is used: no kgsl and no vendor ioctls, only AHardwareBuffer, sync_file and the vendor's public GLES/Vulkan.
-- About 20 GB free for the container image.
-
-**Development host.**
-- The scripts are written for **Windows + Git Bash** with WSL (`archlinux` distro) for the unit tests and the cross build.
-- A Linux host works too: drop the `cygpath`/`MSYS_NO_PATHCONV` handling in `env.sh`, and run the WSL parts natively.
-- Tools:
-  - `adb`, CMake >= 3.22, Ninja, Python 3 (+ Pillow for screenshots/recording).
-  - Android NDK **27.2.12479018**.
-  - JDK 17 and Android SDK platform 36 (for the APK).
-  - In the Linux environment: clang/lld/llvm of ONE major version (a mismatched lld breaks `ld.lld`), cmake, ninja.
-
-## 1. Sources
-
-```sh
-# MobileGL: branch feat/disaggregated (everything here is on it)
-git clone https://github.com/MobileGL-Dev/MobileGL.git && cd MobileGL
-git checkout feat/disaggregated
-GIT_LFS_SKIP_SMUDGE=1 git submodule update --init --recursive
-#   3rdparty/glslang is the MobileGL-Dev fork (main); its External/spirv-tools must be populated
-#   (glslang's own update_glslang_sources.py, or copy it from another checkout).
-# Keep builds out of a shared checkout: work in a worktree (GIT_LFS_SKIP_SMUDGE=1 git worktree add ...).
-
-# anland: branch legacy-mobilegl-unified (KWin backend + patch, startup script, APK, daemon module)
-git clone https://github.com/MobileGL-Dev/anland.git && cd anland   # the fork that carries this branch
-git checkout legacy-mobilegl-unified
-```
-
-Build the server (APK) and the client (container) from the **same MobileGL commit**: both stamp
-`git rev-parse HEAD`, and a mismatch logs "compatible wire with different build".
-
-## 2. Phone base: root, Droidspaces, display daemon
-
-1. **Root** with KernelSU (or another `su` provider).
-2. **Droidspaces:** install the module and its app. Containers live under `/data/local/Droidspaces/Containers/<name>/`, and the CLI is `/data/local/Droidspaces/bin/droidspaces`.
-3. **anland display daemon** (KernelSU/Magisk module `anland-daemon`):
-   - Build it from the anland repo with `build_daemon_android.sh`, then package it with `build_magisk_module.sh`, which uses `magisk_module/`. Flash it and reboot.
-   - The module's `service.sh` starts the original daemon on `/data/local/tmp/display_daemon.sock`.
-   - The MobileGL session uses a SECOND instance of the same binary on `/data/local/tmp/anland-mobilegl/display.sock`: see `scripts/device/restart-daemon.sh`, which also chmods the directory and socket.
-
-## 3. The container
-
-Use an **Arch Linux ARM (aarch64, glibc) KDE Plasma Wayland rootfs** that has a systemd `desktop-session.service` running the desktop as a normal user with `PAMName=login`. A ready-made one is the Arch KDE "Wayland" image from Droidspaces RootFS Desktop Builder (see anland `doc/UserManual/anland_guide.md`, "Use prebuilt packages or a RootFS"). Or install `plasma-desktop`, `plasma-workspace`, `libglvnd`, `xorg-xwayland`, `base-devel`, `cmake` and `ninja` on plain Arch Linux ARM and write the service yourself.
-
-Import it into Droidspaces as `arch-kde-mgl`. The default name is in `env.sh`. Reference `container.config` keys:
-```
-enable_gpu_mode=1
-net_mode=host
-bind_mounts=/data/local/tmp/display_daemon.sock:/run/display.sock,/data/local/tmp/anland-mobilegl:/run/anland-mobilegl
-run_at_boot=0
-```
-- **Host networking:** it is required. The MobileGL server listens on the ABSTRACT socket `@anland-mobilegl`, which crosses into the container only when the network namespace is shared.
-- **The anland-mobilegl directory:** create `/data/local/tmp/anland-mobilegl` on the phone before the first start, mode 777.
-- **Desktop user:** the default is `swung0x48` (`MGL_DESKTOP_USER`). Create your own and point `desktop-session.service` at it.
-- **Starting it:** `droidspaces -C .../container.config start`. Android root sees the rootfs at `/mnt/Droidspaces/<name>`, which `CT_ROOT` in `env.sh` relies on.
-- **Container tools:** install them with `bash scripts/push-tools.sh` once the container runs.
-
-## 4. MobileGL server and the anland APK
-
-```sh
-bash scripts/build-android.sh          # -> <worktree>/build-android/libMobileGL.so
-```
-The script runs, with the NDK toolchain:
-```
--DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-30 -DCMAKE_BUILD_TYPE=RelWithDebInfo
--DMOBILEGL_PIPE_PUSH=ON -DMOBILEGL_BUILD_DISAGGREGATED=ON -DMOBILEGL_BUILD_DISAGGREGATED_INPROC=ON
--DMOBILEGL_BUILD_TEST=OFF -DMOBILEGL_BUILD_BENCHMARK=OFF
-```
-
-APK, from anland `consumers/anland_v5/android_consumer` (details in its `MOBILEGL.md`):
-```sh
-mkdir -p dist/arm64-v8a && cp <worktree>/build-android/libMobileGL.so dist/arm64-v8a/
-MOBILEGL_DIST=$PWD/dist ./gradlew :app:assemblePlainDebug \
-  -PanlandNdkVersion=27.2.12479018 -PmobileglApplicationId=com.anland.consumer.mobilegl \
-  -PanlandDefaultSocket=/data/local/tmp/anland-mobilegl/display.sock
-adb install -r app/build/outputs/apk/plain/debug/app-plain-debug.apk
-```
-- **Grant root:** the app needs root for its helper; approve it in KernelSU.
-- **Reinstall with another signing key:** that changes the UID, so grant root again (anland `mobilegl-tools/ksu_grant.c` does it from a shell). Don't uninstall to fix a signature clash: that wipes the app data.
-- **Later server-only changes:** swap just the library into the installed APK (`scripts/cyc.sh` / `device/swap.sh`) instead of rebuilding the APK.
-
-## 5. MobileGL client in the container
-
-Pick one of these two:
-- **Cross build** (fast, from WSL or Linux):
-  1. `bash scripts/xsysroot/refresh-sysroot.sh` exports the container's headers and libraries to `~/sysroots/arch-kde-mgl` and installs `~/sysroots/aarch64-arch.cmake`. Re-run it after container package upgrades.
-  2. `bash scripts/xbuild.sh`, then `bash scripts/xdeploy.sh`.
-- **Native build in the container** (slow, no WSL): `scripts/sync-src.sh` copies the worktree to `/root/mobilegl-unified-src`, then run anland `producers/kde/Arch_v5/mobilegl-tools/anland-build-client.sh` inside (g++, `-DMOBILEGL_BUILD_DISAGGREGATED=ON`, Release).
-
-Either route installs the same files, renamed into place so running clients keep their old mapping:
-
-| File | What it is |
-|---|---|
-| `/opt/mobilegl/lib/libMobileGL.so` (+ `libEGL`/`libGL` aliases) | the client library |
-| `/usr/share/glvnd/egl_vendor.d/10_mobilegl.json` | system-wide EGL vendor; sorts before the distribution's `50_*.json`, which serves whenever MobileGL declines (no server reachable) |
-| `/opt/mobilegl/share/glvnd/egl_vendor.d/50_mobilegl.json` | per-process forcing |
-| `/usr/lib/libGLX_mobilegl.so.0` | GLX vendor |
-| `/usr/lib/gbm/mobilegl_gbm.so` | GBM backend (zero-copy window buffers) |
-| `/etc/mobilegl/client.conf` | `MOBILEGL_TRANSPORT=spawn`, `MOBILEGL_IPC_DATA=shm`, `MOBILEGL_IPC_CONTROL=unix:@anland-mobilegl` |
-| `/etc/mobilegl/backend` | `DirectVulkan` (Magma) or `DirectGLES` (Espryt) |
-| `/etc/environment.d/10-mobilegl.conf`, `/etc/profile.d/mobilegl.sh` | `__GLX_VENDOR_LIBRARY_NAME=mobilegl`, `GBM_BACKEND=mobilegl` |
-
-## 6. KWin 6.7.4 with the anland backend, and Xwayland
-
-The MobileGL session runs a rebuilt KWin from `/opt/mobilegl/kwin`, so the packaged one stays untouched.
-
-1. **Source tree:** in the container, unpack KWin 6.7.4 to `/root/mobilegl-build/kwin-6.7.4`, apply anland `producers/kde/Arch_v5/kwin.patch`, and overlay `producers/kde/anland_backend_Arch_v5/src/backends/anland` into `src/backends/anland`. Also take the current `common/` and `libdisplay_producer/`, as `mobilegl.md` there says.
-2. **Configure:**
-   ```sh
-   cmake -S kwin-6.7.4 -B kwin-6.7.4/build -G Ninja -DCMAKE_BUILD_TYPE=Release \
-     -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_INSTALL_LIBDIR=lib -DBUILD_TESTING=OFF
-   ```
-3. **Build and install:** run `producers/kde/Arch_v5/sync-build-kwin.sh` (`ninja -j4`). It installs `kwin_wayland` + `libkwin.so.6.7.4` into `/opt/mobilegl/kwin/{bin,lib}`, the patched screencast plugin in place (the original is kept beside it), and `/opt/mobilegl/bin/mobilegl-startup.sh`.
-   - From the dev host, `bash scripts/kwin-stage.sh build` does steps 1–3 incrementally: `kwprep.sh` applies changed patch hunks.
-4. **Xwayland:** the anland-patched Xwayland 24.1.13 comes from `producers/kde/Arch_v5/build.sh` (makepkg, as a normal user; it builds the anland KWin and Xwayland packages). A prebuilt anland rootfs already has it.
-5. **Session hook:** add `/etc/systemd/system/desktop-session.service.d/mobilegl.conf`:
-   ```ini
-   [Service]
-   ExecStart=
-   ExecStart=/opt/mobilegl/bin/mobilegl-startup.sh plasma
-   Environment=ANLAND_SOCKET=/run/anland-mobilegl/display.sock
-   Environment=QT_LOGGING_RULES=kwin_*.info=true
-   ```
-   `mobilegl-startup.sh plasma` writes the user drop-in for `plasma-kwin_wayland.service` (the `/opt/mobilegl/kwin` binary, `ANLAND_MOBILEGL=1`, `MOBILEGL_IPC_SURFACE=server`, `GBM_BACKEND=mobilegl`) and runs `startplasma-wayland`.
-
-## 7. Bring it up
-
-Nothing has to be started by hand, and the order no longer matters: **open the app** (its launcher
-icon, or `am start -n com.anland.consumer.mobilegl/com.anland.consumer.MainActivity` with no extras).
-That is the single trigger. The app starts its foreground service and runs its bundled
-`mobilegl-desktop.sh up` as root, which:
-1. starts the display daemon if it is not running;
-2. publishes the backend (the app setting "Renderer backend", default DirectGLES) to
-   `/data/local/tmp/anland-mobilegl/backend`;
-3. starts the container if it is stopped;
-4. starts `desktop-session`, which waits for the server and the daemon socket, copies the backend into
-   `/etc/mobilegl/backend` and runs Plasma.
-
-Cold start to a desktop takes about 8-12 s. `scripts/device/bringup.sh` wakes the phone, dismisses the
-keyguard, opens the app and prints the timeline. To change the backend, use the app setting and then
-Stop desktop and reopen, or run `scripts/device/switch.sh DirectGLES|DirectVulkan`. Do not use
-`setprop debug.mobilegl.backend`: it overrides the setting until the next reboot. **Stop desktop**
-(the notification action) stops the session and the container.
-
-**After a phone reboot:** wireless adb does not come back by itself. Re-enable it on the phone
-(Developer options > Wireless debugging), then `adb connect <ip>:<port>`; the port changes. After
-that, open the app as above. See SKILL.md "Starting, idling, stopping".
-
-## 8. Verify
-
-- **Plasma:** it appears in the app. The tray must NOT show the "software renderer" icon; if it does, delete `SceneGraphBackend=software` from the user's `kdeglobals` and restart.
-- **Plain shell:** in a plain container shell as the desktop user, `eglinfo -B` names MobileGL, and `glxinfo -B` from a login shell does too.
-- **Wayland client:** `timeout 25 mgrun offscreen glmark2-es2-wayland -s 1280x720`. The log must say `presented through linux-dmabuf shared images`.
-- **Chrome:** `bash scripts/chrome-launch.sh t1` gives windows with correct icons.
-- **Resize and lock:** BACK toggles the extra-keys bar (resize); lock/unlock resumes the desktop. `rtest.sh` in the scratch dir checks both.
-- **Unit tests:** `bash scripts/wsl-all.sh` in WSL. NEVER run the DirectVulkan integration tests.
-
-## 9. Machine-specific values to change
-
-| Value | Original | Where |
-|---|---|---|
-| MobileGL worktree | this skill's worktree | `MGL_WORKTREE` (auto) |
-| scratch dir | `%LOCALAPPDATA%/Temp/anl` | `ANL_DIR` |
-| NDK | `<SDK>/ndk/27.2.12479018` | `ANDROID_NDK` |
-| anland worktree | `%USERPROFILE%/AndroidStudioProjects/anland/.claude/worktrees/mgl-unified` | `ANLAND_WORKTREE` (`kwin-stage.sh`) |
-| APK id | `com.anland.consumer.mobilegl` | `MGL_PKG` |
-| container | `arch-kde-mgl` | `MGL_CONTAINER` |
-| desktop user | `swung0x48` | `MGL_DESKTOP_USER` + `desktop-session.service` |
-| WSL distro | `archlinux` | `WSL_DISTRO` (`xbuild.sh`, `wsl-*.sh`) |
-| cross build dir | WSL `~/mgl-xbuild-a64` | `MGL_XBUILD_DIR` |
-| phone | Lenovo TB321FU, Adreno 750 | nothing: no serial is pinned; with several devices set `ANDROID_SERIAL` |
-
-**Thermals:** a phone vendor's thermal daemon may throttle charging while the screen is on during long sessions. That is not part of this setup.

.claude/skills/anland-mobilegl-plasma/scripts/build-android.sh

@@ -1,25 +0,0 @@
-#!/usr/bin/env bash
-# build-android.sh - build the Android SERVER libMobileGL.so (NDK, arm64-v8a) that the anland APK embeds.
-# Output: $MGL_WORKTREE/build-android/libMobileGL.so (RelWithDebInfo, unstripped, ~320 MB; keep it for
-# llvm-addr2line, it is what cyc.sh pushes).  Stamp = worktree HEAD, so the container client
-# (xbuild.sh, same stamp) and the server agree on the build ("compatible wire with different build"
-# WARN otherwise).  Env: MGL_WORKTREE, ANDROID_NDK, BUILD_DIR (default build-android), JOBS (12).
-# Log level is compiled to INFO.  android-30 = the APK's minSdk: thread_local is then the platform's
-# own TLS rather than the emulated one (which cost 7-12% of an apply thread on the API 26 build).
-set -euo pipefail
-. "$(dirname "$0")/env.sh"
-W=$MGL_WORKTREE
-B=$W/${BUILD_DIR:-build-android}
-STAMP=$(git -C "$W" rev-parse HEAD)
-if [ ! -f "$B/build.ninja" ]; then
-cmake -S "$W" -B "$B" -G Ninja -DCMAKE_TOOLCHAIN_FILE="$ANDROID_NDK/build/cmake/android.toolchain.cmake" \
-  -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-30 -DCMAKE_BUILD_TYPE=RelWithDebInfo \
-  -DMOBILEGL_PIPE_PUSH=ON -DMOBILEGL_BUILD_DISAGGREGATED=ON -DMOBILEGL_BUILD_DISAGGREGATED_INPROC=ON \
-  -DMOBILEGL_BUILD_TEST=OFF -DMOBILEGL_BUILD_BENCHMARK=OFF \
-  -DCMAKE_CXX_FLAGS=-DMOBILEGL_LOG_ACTIVE_LEVEL=MOBILEGL_LOG_LEVEL_INFO \
-  -DMOBILEGL_BUILD_STAMP="$STAMP"
-else
-cmake "$B" -DMOBILEGL_BUILD_STAMP="$STAMP" >/dev/null
-fi
-cmake --build "$B" --target MobileGL -j"${JOBS:-12}"
-ls -la "$B/libMobileGL.so"

.claude/skills/anland-mobilegl-plasma/scripts/chrome-launch.sh

@@ -1,25 +0,0 @@
-#!/usr/bin/env bash
-# chrome-launch.sh <tag> [extra chrome flags...] - (re)start Chrome inside the running Plasma session
-# through mobilegl-startup.sh's `chrome` mode (ANGLE GLES over MobileGL EGL), client log
-# /tmp/mgl-chrome-<tag>.client.log, then print its "presented through" line and save a screenshot
-# to $ANL_DIR/ch-<tag>.png.  Kills the running chrome first (pkill -x, never -f).  MobileGL is the
-# container's system-wide vendor (10_mobilegl.json + /etc/mobilegl/client.conf), so only the log is set here.
-# Env: WAIT (s before checking, default 20), CHANNEL (ct.sh channel, default chrome),
-#      CHROME_GPU (process, the default: the GPU in its own process, which presents
-#      through GBM dma-bufs and is restarted by Chrome after a device loss; in-process opts out -
-#      needs the anland startup script that knows MOBILEGL_CHROME_GPU; in process mode the GPU process and the browser
-#      write the one client log, the GPU process last); CHROME_GPU_SANDBOX=on keeps its GPU sandbox.
-set -euo pipefail
-here=$(cd "$(dirname "$0")" && pwd)
-. "$here/env.sh"
-TAG=${1:?usage: chrome-launch.sh <tag> [chrome flags...]}; shift
-bash "$here/ct.sh" "${CHANNEL:-chrome}" <<IN
-pkill -x chrome; sleep 2
-U=\$(id -u $MGL_DESKTOP_USER)
-rm -f /tmp/mgl-chrome-$TAG.client.log /tmp/chrome-$TAG-out.log
-sudo -u $MGL_DESKTOP_USER env XDG_RUNTIME_DIR=/run/user/\$U WAYLAND_DISPLAY=wayland-0 DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/\$U/bus MOBILEGL_LOG_FILE_PATH=/tmp/mgl-chrome-$TAG.log MOBILEGL_CHROME_GPU=${CHROME_GPU:-process} MOBILEGL_CHROME_GPU_SANDBOX=${CHROME_GPU_SANDBOX:-off} bash -c 'nohup /opt/mobilegl/bin/mobilegl-startup.sh chrome --restore-last-session $* > /tmp/chrome-$TAG-out.log 2>&1 &'
-sleep ${WAIT:-20}
-grep -ah 'presented through' /tmp/mgl-chrome-$TAG.client.log | head -3
-IN
-adb_ shell "su -c 'screencap -p $DEV_SHARE/ch-$TAG.png'"
-adb_ pull "$DEV_SHARE/ch-$TAG.png" "$ANL_DIR/ch-$TAG.png" >/dev/null && echo "screenshot: $ANL_DIR/ch-$TAG.png"

.claude/skills/anland-mobilegl-plasma/scripts/chrome-recover.sh

@@ -1,146 +0,0 @@
-#!/usr/bin/env bash
-# chrome-recover.sh <in-process|process> [rounds] - does Chrome repaint after a GPU device loss,
-# without a restart?  Starts Chrome (chrome-launch.sh, CHROME_GPU=<mode>) on an animated WebGL page,
-# then per round: screenshots (the page must animate), loses the session of Chrome's GPU client with
-# the server's pid-targeted debug knob (debug.mobilegl.inject_device_lost_pid; the pid as Chrome sees
-# itself in the container), waits, and screenshots again.  A round PASSES when the server latched
-# that pid's session, the browser process is the same one (no restart), a GPU client is drawing on a
-# NEW server session, and the screen still animates.  Stops early below MIN_BATTERY percent.
-#
-#   in-process  the GPU in the browser process (the startup script's default today): the target is
-#               the browser itself; recovery needs ANGLE to make a new native context.
-#   process     the GPU in its own process (MOBILEGL_CHROME_GPU=process): the target is the GPU
-#               process; Chrome restarts it after the loss, so the next round's target is a new pid.
-#
-# Deploy first (same MobileGL commit on both sides; see SKILL.md):
-#   bash scripts/build-android.sh && bash scripts/cyc.sh pre      # server -> APK, restarts the session
-#   bash scripts/xbuild.sh && bash scripts/xdeploy.sh             # client -> container
-#   STARTUP=<anland worktree>/producers/kde/Arch_v5/mobilegl-startup.sh bash scripts/chrome-recover.sh deploy-startup
-# Env: ROUNDS (default 2), SETTLE (s after the loss, default 8), MIN_BATTERY (default 40),
-#      CHANNEL (ct.sh channel, default crec), TAG (log tag, default crec-<mode>).
-set -euo pipefail
-here=$(cd "$(dirname "$0")" && pwd)
-. "$here/env.sh"
-MODE=${1:?usage: chrome-recover.sh <in-process|process|deploy-startup> [rounds]}
-ROUNDS=${2:-${ROUNDS:-2}}
-SETTLE=${SETTLE:-8}
-MIN_BATTERY=${MIN_BATTERY:-40}
-CH=${CHANNEL:-crec}
-TAG=${TAG:-crec-$MODE}
-PAGE=/tmp/mgl-spin.html
-
-ct() { bash "$here/ct.sh" "$CH"; }
-
-battery() { adb_ shell dumpsys battery | tr -d '\r' | awk '/ level:/ {print $2}'; }
-check_battery() {
-    local level; level=$(battery)
-    echo "battery: $level%"
-    if [ -n "$level" ] && [ "$level" -lt "$MIN_BATTERY" ]; then
-        echo "STOP: battery below $MIN_BATTERY%"; cleanup; exit 3
-    fi
-}
-cleanup() { adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid 0'" || true; }
-
-if [ "$MODE" = deploy-startup ]; then
-    # The anland startup script that knows MOBILEGL_CHROME_GPU, installed by rename (a running
-    # session keeps its open copy).
-    src=${STARTUP:?STARTUP=<path to the anland mobilegl-startup.sh>}
-    tr -d '\r' < "$src" > "$ANL_DIR/mobilegl-startup.sh"
-    adb_ push "$ANL_DIR/mobilegl-startup.sh" "$DEV_SHARE/mobilegl-startup.sh.new" >/dev/null
-    ct <<'IN'
-install -m 755 /run/anland-mobilegl/mobilegl-startup.sh.new /opt/mobilegl/bin/mobilegl-startup.sh.new
-mv -f /opt/mobilegl/bin/mobilegl-startup.sh.new /opt/mobilegl/bin/mobilegl-startup.sh
-grep -c MOBILEGL_CHROME_GPU /opt/mobilegl/bin/mobilegl-startup.sh
-IN
-    exit 0
-fi
-case "$MODE" in in-process|process) ;; *) echo "mode must be in-process or process" >&2; exit 2;; esac
-trap cleanup EXIT
-
-check_battery
-adb_ shell "su -c 'sh $DEV_TOOLS/status.sh'" || true
-cleanup
-
-# The page: WebGL clears that change colour every frame plus a moving block, so a frame that
-# reaches the screen changes the screenshot.
-ct <<IN
-cat > $PAGE <<'HTML'
-<!doctype html><html><body style="margin:0;background:#000">
-<canvas id=c width=640 height=360 style="width:100vw;height:100vh"></canvas>
-<script>
-const gl = document.getElementById('c').getContext('webgl');
-let t = 0, lost = 0;
-document.getElementById('c').addEventListener('webglcontextlost', e => { e.preventDefault(); lost++; });
-function frame() {
-  t++;
-  if (gl && !gl.isContextLost()) {
-    gl.clearColor((t % 60) / 60, ((t + 20) % 60) / 60, ((t + 40) % 60) / 60, 1);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.enable(gl.SCISSOR_TEST); gl.scissor((t * 7) % 600, 100, 40, 160);
-    gl.clearColor(1, 1, 1, 1); gl.clear(gl.COLOR_BUFFER_BIT); gl.disable(gl.SCISSOR_TEST);
-  }
-  document.title = 'spin ' + t + ' lost ' + lost;
-  requestAnimationFrame(frame);
-}
-frame();
-</script></body></html>
-HTML
-chmod 644 $PAGE
-IN
-
-WAIT=${WAIT:-20} CHROME_GPU=$MODE CHANNEL=$CH bash "$here/chrome-launch.sh" "$TAG" --new-window "file://$PAGE"
-
-# The target pid inside the container: the browser (in-process) or the GPU process.
-target_pid() {
-    ct <<'IN' | tr -d '\r' | tail -1
-for p in $(pgrep -x chrome); do
-  args=$(tr '\0' ' ' < /proc/$p/cmdline)
-  case "$args" in
-    *--type=gpu-process*) echo "gpu $p" ;;
-    *--type=*) ;;
-    *) echo "browser $p" ;;
-  esac
-done | sort > /tmp/mgl-crec-pids
-cat /tmp/mgl-crec-pids >&2
-echo "$(awk '/^browser/ {print $2; exit}' /tmp/mgl-crec-pids) $(awk '/^gpu/ {print $2; exit}' /tmp/mgl-crec-pids)"
-IN
-}
-
-pass=0
-for round in $(seq 1 "$ROUNDS"); do
-    echo "=== round $round/$ROUNDS ($MODE)"
-    check_battery
-    read -r browser gpu < <(target_pid)
-    if [ "$MODE" = process ]; then target=$gpu; else target=$browser; fi
-    echo "browser=$browser gpu=${gpu:-none} target=$target"
-    if [ -z "$target" ]; then echo "FAIL: no target process"; break; fi
-    bash "$here/shot.sh" "$TAG-r$round-pre" 2 1
-    adb_ logcat -c
-    adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid $target'"
-    sleep "$SETTLE"
-    adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid 0'"
-    bash "$here/shot.sh" "$TAG-r$round-post" 3 1 | tee "$ANL_DIR/$TAG-r$round-post.md5"
-    latched=$(adb_ logcat -d | grep -c "injected:pid=$target" || true)
-    started=$(adb_ logcat -d | grep -c "session #[0-9]* started" || true)
-    adb_ logcat -d | grep -E "inject_device_lost_pid|SessionLatch|session #[0-9]+ (started|pid)" | cut -c1-220 | head -12 || true
-    read -r browser2 gpu2 < <(target_pid)
-    echo "after: browser=$browser2 gpu=${gpu2:-none}"
-    ct <<IN || true
-echo "--- client log ($TAG):"; grep -aE "DEVICE LOST|RECOVERED|GL_UNKNOWN_CONTEXT_RESET|failed to make|session #" /tmp/mgl-chrome-$TAG.client.log | tail -8
-echo "--- chrome stderr:"; grep -aiE "context lost|GPU process|make.*current|lost" /tmp/chrome-$TAG-out.log | tail -8
-IN
-    adb_ logcat -b crash -d | tail -5
-    hashes=$(awk '{print $1}' "$ANL_DIR/$TAG-r$round-post.md5" | sort -u | wc -l)
-    verdict=PASS
-    [ "$latched" -ge 1 ] || { echo "  - the server never latched pid $target"; verdict=FAIL; }
-    [ "$browser2" = "$browser" ] || { echo "  - the browser process changed ($browser -> $browser2): Chrome restarted"; verdict=FAIL; }
-    [ "$started" -ge 1 ] || { echo "  - no new server session started after the loss"; verdict=FAIL; }
-    if [ "$MODE" = process ]; then
-        [ -n "$gpu2" ] && [ "$gpu2" != "$gpu" ] || { echo "  - no new GPU process"; verdict=FAIL; }
-    fi
-    [ "$hashes" -ge 2 ] || { echo "  - the screen does not change after the loss (frozen)"; verdict=FAIL; }
-    echo "round $round: $verdict"
-    [ "$verdict" = PASS ] && pass=$((pass + 1))
-    [ "$verdict" = PASS ] || break
-done
-echo "=== $pass/$ROUNDS rounds passed ($MODE); screenshots in $ANL_DIR/$TAG-r*-*.png"

.claude/skills/anland-mobilegl-plasma/scripts/container/kwprep.sh

@@ -1,29 +0,0 @@
-#!/bin/bash
-# kwprep.sh - (container, as root) bring the live KWin tree /root/mobilegl-build/kwin-6.7.4 in line with
-# anland's kwin.patch + anland backend sources, touching ONLY files whose content changed (keeps the
-# ninja build incremental).  It re-applies the whole patch to a pristine copy of KWin's src/
-# (/root/gbm-dev/kwin-a/src) in /root/kp and copies every patched file that differs into the live tree,
-# then copies changed backend files.  Build + install afterwards with anland's sync-build-kwin.sh.
-#
-# Input: /root/kwsync.tgz, a tar made in the anland worktree's producers/kde directory:
-#   tar czf kwsync.tgz Arch_v5/kwin.patch Arch_v5/mobilegl-startup.sh anland_backend_Arch_v5/src/backends/anland/
-# and pushed to the container's /root (e.g. via /mnt/Droidspaces/arch-kde-mgl/root/ on the Android side).
-# The pristine tree /root/gbm-dev/kwin-a/src was set up by hand earlier (unverified that it is exactly
-# upstream 6.7.4); patch hunks that fail are reported by `patch`.
-set -e
-rm -rf /root/kwsync && mkdir -p /root/kwsync && tar xzf /root/kwsync.tgz -C /root/kwsync
-P=/root/kwsync/Arch_v5/kwin.patch
-rm -rf /root/kp && mkdir -p /root/kp && cp -a /root/gbm-dev/kwin-a/src /root/kp/
-cd /root/kp && patch -p1 -s < $P
-LIVE=/root/mobilegl-build/kwin-6.7.4
-FILES=$(grep -E '^\+\+\+ b/' $P | sed 's|^+++ b/||' | awk '{print $1}' | sort -u)
-for f in $FILES; do
-  if [ -f "/root/kp/$f" ] && ! cmp -s "/root/kp/$f" "$LIVE/$f"; then cp "/root/kp/$f" "$LIVE/$f"; echo "updated $f"; fi
-done
-for f in /root/kwsync/anland_backend_Arch_v5/src/backends/anland/*; do
-  # libdisplay_producer is a symlink in git; a Windows checkout turns it into a small text file. The live
-  # tree has the real directory (repo-root libdisplay_producer/), which neither script syncs.
-  [ -f "$f" ] && [ "$(basename $f)" != libdisplay_producer ] || continue
-  b=$(basename $f); if ! cmp -s "$f" "$LIVE/src/backends/anland/$b"; then cp "$f" "$LIVE/src/backends/anland/$b"; echo "updated anland/$b"; fi
-done
-echo PREP_DONE

.claude/skills/anland-mobilegl-plasma/scripts/container/mgrun

@@ -1,21 +0,0 @@
-#!/bin/bash
-# mgrun <surface: offscreen|server> <command...> - (container, as root) run one MobileGL client as the
-# desktop user inside the running Plasma session.  Installed as /usr/local/bin/mgrun (push-tools.sh).
-#   mgrun offscreen glmark2-es2-wayland -s 1280x720     # Wayland client, presents through KWin
-#   mgrun offscreen eglinfo -B ; mgrun offscreen glxinfo -B   # glxinfo goes through Xwayland + GLX vendor
-# "server" is only for a client that owns the Android Surface itself (KWin does); everything else is
-# offscreen.  MobileGL is the container's system-wide vendor, so nothing selects it here: EGL comes from
-# /usr/share/glvnd/egl_vendor.d/10_mobilegl.json, transport/endpoint from /etc/mobilegl/client.conf,
-# the backend from /etc/mobilegl/backend (must match the server), and the GLX vendor name / GBM backend
-# from /etc/profile.d/mobilegl.sh (sourced by the login shell below).  Client log:
-# ${MGLOG:-/tmp/mgl-run.log} -> the library writes /tmp/mgl-run.client.log (truncated per run; give
-# concurrent clients different MGLOG values).  Env: MGLOG, DESKTOP_USER (swung0x48).
-S=$1; shift
-DU=${DESKTOP_USER:-swung0x48}
-U=$(id -u "$DU")
-cd /tmp
-exec sudo -u "$DU" env XDG_RUNTIME_DIR=/run/user/$U WAYLAND_DISPLAY=wayland-0 DISPLAY=:0 \
-  XAUTHORITY=$(ls /run/user/$U/xauth_* 2>/dev/null | head -1) \
-  DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/$U/bus QT_QPA_PLATFORM=wayland \
-  MOBILEGL_IPC_SURFACE=$S MOBILEGL_LOG_FILE_PATH=${MGLOG:-/tmp/mgl-run.log} \
-  bash -lc 'exec "$@"' mgrun "$@"

.claude/skills/anland-mobilegl-plasma/scripts/ct.sh

@@ -1,26 +0,0 @@
-#!/usr/bin/env bash
-# ct.sh <channel> [script-file] - run a bash script as ROOT inside the container (login shell),
-# reading the script from the file or from stdin.  Generic form of the old c.sh/c2.sh/c3.sh.
-#
-#   printf '%s\n' 'ls -la /tmp/*.log' | bash ct.sh mychan
-#   bash ct.sh mychan ./something.cmd
-#
-# How: the script is written to $ANL_DIR/<channel>.cmd, pushed to $DEV_TOOLS/<channel>.cmd together with
-# a one-line <channel>.sh that does `droidspaces --name=<container> run bash -lc "$(cat <channel>.cmd)"`,
-# and that runs under `su`.  Quoting through adb + su + droidspaces is thereby avoided entirely.
-#
-# Pick a channel name of your own: other sessions on the same phone use c, c2, c3, xd, xr, gbm...;
-# writing to their channel files races with them.  CR characters are stripped (Windows checkouts).
-# Inside, run user-side commands with `sudo -u <desktop user> env XDG_RUNTIME_DIR=/run/user/<uid> ...`.
-# Never `pkill -f <word>` in a channel script: the `bash -lc "<script>"` process carries the whole
-# script on its command line and kills itself.  Use `pkill -x <name>`.
-set -euo pipefail
-. "$(dirname "$0")/env.sh"
-ch=${1:?usage: ct.sh <channel> [script-file]}
-src=${2:--}
-if [ "$src" = - ]; then tr -d '\r' > "$ANL_DIR/$ch.cmd"; else tr -d '\r' < "$src" > "$ANL_DIR/$ch.cmd"; fi
-printf '%s\n' "$DS_BIN --name=$MGL_CONTAINER run bash -lc \"\$(cat $DEV_TOOLS/$ch.cmd)\"" > "$ANL_DIR/$ch.sh"
-adb_ shell "mkdir -p $DEV_TOOLS"
-adb_ push "$ANL_DIR/$ch.cmd" "$DEV_TOOLS/$ch.cmd" >/dev/null
-adb_ push "$ANL_DIR/$ch.sh" "$DEV_TOOLS/$ch.sh" >/dev/null
-adb_ shell "su -c 'sh $DEV_TOOLS/$ch.sh'"

.claude/skills/anland-mobilegl-plasma/scripts/cyc.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-# cyc.sh <shot-name> - one server iteration: clear Plasma's sticky software-renderer key, push the
-# NDK-built server lib, swap it into the installed APK (device/swap.sh), restart app + Plasma session
-# (device/run-plasma.sh, ~90 s), screenshot to $ANL_DIR/<shot-name>.png, print fatal logcat lines.
-# Env: SERVER_LIB (default $MGL_WORKTREE/build-android/libMobileGL.so), WAIT (s after the session
-# restart, default 15), N (logcat lines, default 20), CHANNEL (ct.sh channel, default cyc).
-# Needs device/swap.sh + device/run-plasma.sh in $DEV_TOOLS (push-tools.sh).  RESTARTS THE SESSION.
-set -euo pipefail
-here=$(cd "$(dirname "$0")" && pwd)
-. "$here/env.sh"
-shot=${1:?usage: cyc.sh <shot-name>}
-LIB=${SERVER_LIB:-$MGL_WORKTREE/build-android/libMobileGL.so}
-printf '%s\n' "sudo -u $MGL_DESKTOP_USER kwriteconfig6 --file kdeglobals --group QtQuickRendererSettings --key SceneGraphBackend --delete; rm -f /tmp/mgl-plasmashell.client.log" \
-    | bash "$here/ct.sh" "${CHANNEL:-cyc}"
-adb_ push "$LIB" "$DEV_SHARE/libMobileGL.new.so" >/dev/null
-adb_ logcat -c
-adb_ shell "su -c 'sh $DEV_TOOLS/swap.sh >/dev/null && sh $DEV_TOOLS/run-plasma.sh >/dev/null 2>&1; sleep ${WAIT:-15}; screencap -p $DEV_SHARE/$shot.png'"
-adb_ pull "$DEV_SHARE/$shot.png" "$ANL_DIR/$shot.png" >/dev/null && echo "screenshot: $ANL_DIR/$shot.png"
-adb_ logcat -d | grep -E "Fatal signal|FATAL|Abort message|Magma wire buffer|E MobileGL" | cut -c1-260 | head -"${N:-20}" || true

.claude/skills/anland-mobilegl-plasma/scripts/desktop-verify.sh

@@ -1,94 +0,0 @@
-#!/usr/bin/env bash
-# desktop-verify.sh <phase>... - check that the MobileGL desktop starts, idles and stops by itself
-# (anland app: foreground service + mobilegl-desktop.sh; container: desktop-session.service).
-# Phases run in the order given; screenshots go to $ANL_DIR/dv-<phase>.png.
-#
-#   push     install device/*.sh into $DEV_TOOLS (push-tools.sh's device half)
-#   reset    everything down: app force-stopped (its service with it), container stopped,
-#            experiment display daemon killed - the state after a phone reboot
-#   cold     reset, then open the app like its icon does and time each piece (desktop-timeline.sh)
-#   open     open the app without resetting (after a reboot: the reboot was the reset)
-#   chrome   (re)start Chrome in the session on an animated WebGL page (kills a running Chrome)
-#   idle     CPU/GPU for visible, hidden (HOME), locked (screen off), visible again (measure.sh)
-#   reopen   swipe the app away (remove its task), check KWin survives, open it again, time it
-#   stop     Stop desktop from the notification (the service's STOP action) and check it all ends
-#   rtest    lock/unlock + window resize regression ($ANL_DIR/rtest.sh)
-# Env: SECS (idle window, default 20), URL (chrome page).
-set -euo pipefail
-here=$(cd "$(dirname "$0")" && pwd)
-. "$here/env.sh"
-SECS=${SECS:-20}
-URL=${URL:-https://webglsamples.org/aquarium/aquarium.html}
-SOCK=$DEV_SHARE/display.sock
-su_() { adb_ shell "su -c '$*'"; }
-shot() {
-    su_ "screencap -p $DEV_SHARE/dv-$1.png"
-    adb_ pull "$DEV_SHARE/dv-$1.png" "$ANL_DIR/dv-$1.png" > /dev/null && echo "screenshot $ANL_DIR/dv-$1.png"
-}
-kwin_log() {   # the anland backend's lines since <time>
-    printf '%s\n' "journalctl --no-pager --since '$1' 2>/dev/null | grep -a -E 'viewer (gone|back)|consumer (reconnected|disconnected)|failed to connect' | tail -${2:-8}" |
-        bash "$here/ct.sh" dv 2>/dev/null | grep -v pushed || true
-}
-task_id() {
-    su_ "am stack list" | tr -d '\r' | grep -m1 "$MGL_PKG/" | sed -n 's/.*taskId=\([0-9]*\).*/\1/p'
-}
-wake() {
-    su_ "input keyevent KEYCODE_WAKEUP"; sleep 1; su_ "wm dismiss-keyguard"; sleep 2
-}
-
-for phase in "$@"; do
-    echo "=== $phase"
-    case $phase in
-    push)
-        for f in "$here"/device/*.sh; do
-            tr -d '\r' < "$f" > "$ANL_DIR/push.tmp"
-            adb_ push "$ANL_DIR/push.tmp" "$DEV_TOOLS/$(basename "$f")" > /dev/null
-        done
-        rm -f "$ANL_DIR/push.tmp"; echo "device scripts in $DEV_TOOLS" ;;
-    reset)
-        su_ "sh $DEV_TOOLS/desktop-reset.sh" ;;
-    cold)
-        bash "$0" reset
-        wake
-        su_ "sh $DEV_TOOLS/desktop-timeline.sh 240"
-        sleep 3; shot cold ;;
-    open)
-        wake
-        su_ "sh $DEV_TOOLS/desktop-timeline.sh 300"
-        sleep 3; shot open ;;
-    chrome)
-        WAIT=15 bash "$here/chrome-launch.sh" dv "$URL" ;;
-    idle)
-        su_ "sh $DEV_TOOLS/measure.sh visible $SECS"
-        t=$(date -u '+%Y-%m-%d %H:%M:%S UTC')
-        su_ "input keyevent KEYCODE_HOME"; sleep 4
-        su_ "sh $DEV_TOOLS/measure.sh hidden $SECS"
-        su_ "am start -n $MGL_PKG/com.anland.consumer.MainActivity >/dev/null"; sleep 5
-        su_ "input keyevent KEYCODE_SLEEP"; sleep 4
-        su_ "sh $DEV_TOOLS/measure.sh locked $SECS"
-        wake
-        su_ "am start -n $MGL_PKG/com.anland.consumer.MainActivity >/dev/null"; sleep 5
-        su_ "sh $DEV_TOOLS/measure.sh visible2 $SECS"
-        shot idle
-        kwin_log "$t" 12 ;;
-    reopen)
-        t=$(date -u '+%Y-%m-%d %H:%M:%S UTC')
-        id=$(task_id); echo "removing task $id"
-        [ -n "$id" ] && su_ "am stack remove $id"
-        sleep 8
-        su_ "echo server: \$(pidof $MGL_PKG:mobilegl) ui: \$(pidof $MGL_PKG) kwin: \$(pidof kwin_wayland) plasmashell: \$(pidof plasmashell)"
-        su_ "sh $DEV_TOOLS/measure.sh closed 10"
-        su_ "sh $DEV_TOOLS/desktop-timeline.sh 120"
-        sleep 3; shot reopen
-        kwin_log "$t" ;;
-    stop)
-        su_ "am startservice -n $MGL_PKG/com.anland.consumer.MobileGLWorker -a com.anland.consumer.mobilegl.STOP" || true
-        sleep 25
-        su_ "echo server: \$(pidof $MGL_PKG:mobilegl) ui: \$(pidof $MGL_PKG); $DS_BIN show"
-        su_ "tail -3 $DEV_SHARE/desktop.log" ;;
-    rtest)
-        bash "$ANL_DIR/rtest.sh" dv ;;
-    *)
-        echo "unknown phase $phase" >&2; exit 2 ;;
-    esac
-done

.claude/skills/anland-mobilegl-plasma/scripts/device/bringup.sh

@@ -1,7 +0,0 @@
-# bringup.sh - (Android root shell) bring the MobileGL desktop up after a phone reboot. There is
-# nothing left to do by hand: opening the anland app (its launcher icon, or this am start) starts
-# the display daemon, the MobileGL server, the container and its Plasma session. Prints the timeline.
-# Run: su -c "sh /data/local/tmp/anl/bringup.sh"      Env: as desktop-timeline.sh.
-input keyevent KEYCODE_WAKEUP
-wm dismiss-keyguard
-sh "$(dirname "$0")/desktop-timeline.sh" 300

.claude/skills/anland-mobilegl-plasma/scripts/device/desktop-reset.sh

@@ -1,17 +0,0 @@
-# desktop-reset.sh - (Android root shell) take the MobileGL desktop fully down, as after a phone
-# reboot: the app force-stopped (its foreground service and server with it), the container
-# stopped, the experiment display daemon killed. Leaves the original anland daemon alone.
-# Run: su -c "sh /data/local/tmp/anl/desktop-reset.sh"      Env: PKG, CONTAINER, SOCK, DS.
-P=${PKG:-com.anland.consumer.mobilegl}
-C=${CONTAINER:-arch-kde-mgl}
-SOCK=${SOCK:-/data/local/tmp/anland-mobilegl/display.sock}
-D=${DS:-/data/local/Droidspaces/bin/droidspaces}
-am force-stop $P
-$D --name=$C stop > /dev/null 2>&1
-for p in $(pidof display_daemon); do
-    tr '\0' ' ' < /proc/$p/cmdline | grep -qF " $SOCK " && kill $p
-done
-rm -f $SOCK
-sleep 2
-echo "app: $(pidof $P) server: $(pidof $P:mobilegl) daemon: $(ls $SOCK 2>/dev/null)"
-$D show

.claude/skills/anland-mobilegl-plasma/scripts/device/desktop-timeline.sh

@@ -1,30 +0,0 @@
-# desktop-timeline.sh [timeout-s] - (Android root shell) open the anland app the way its launcher
-# icon does (am start, no extras) and print when each piece of the MobileGL desktop comes up,
-# in seconds after the open: display daemon socket, the app's MobileGL server listening, the
-# container, kwin_wayland, plasmashell, and the splash (ksplashqml) gone = desktop on screen.
-# Pieces that already run show 0.0. Read-only apart from the am start.
-# Run: su -c "sh /data/local/tmp/anl/desktop-timeline.sh 180"      Env: PKG, CONTAINER, SOCK, DS.
-T=${1:-180}
-P=${PKG:-com.anland.consumer.mobilegl}
-C=${CONTAINER:-arch-kde-mgl}
-SOCK=${SOCK:-/data/local/tmp/anland-mobilegl/display.sock}
-D=${DS:-/data/local/Droidspaces/bin/droidspaces}
-now() { awk '{print $1}' /proc/uptime; }
-since() { awk -v a="$1" -v b="$(now)" 'BEGIN{printf "%.1f", b - a}'; }
-listening() { grep -q '00010000 0001 01 [0-9]* @anland-mobilegl$' /proc/net/unix; }
-t0=$(now)
-am start -n $P/com.anland.consumer.MainActivity > /dev/null
-for k in daemon server container kwin shell splash_seen shown; do eval "t_$k="; done
-while :; do
-    [ -z "$t_daemon" ] && [ -S "$SOCK" ] && t_daemon=$(since $t0) && echo "daemon socket     +${t_daemon}s"
-    [ -z "$t_server" ] && listening && t_server=$(since $t0) && echo "server listening  +${t_server}s"
-    [ -z "$t_container" ] && [ -n "$($D --name=$C pid 2>/dev/null | tr -dc 0-9)" ] && t_container=$(since $t0) && echo "container up      +${t_container}s"
-    [ -z "$t_kwin" ] && pidof kwin_wayland > /dev/null && t_kwin=$(since $t0) && echo "kwin_wayland      +${t_kwin}s"
-    [ -z "$t_shell" ] && pidof plasmashell > /dev/null && t_shell=$(since $t0) && echo "plasmashell       +${t_shell}s"
-    [ -z "$t_splash_seen" ] && pidof ksplashqml > /dev/null && t_splash_seen=1
-    if [ -n "$t_shell" ] && [ -z "$t_shown" ] && ! pidof ksplashqml > /dev/null; then
-        t_shown=$(since $t0); echo "splash gone       +${t_shown}s (desktop on screen)"; break
-    fi
-    [ "$(since $t0 | cut -d. -f1)" -ge "$T" ] && { echo "TIMEOUT after ${T}s"; break; }
-    sleep 0.3
-done

.claude/skills/anland-mobilegl-plasma/scripts/device/measure.sh

@@ -1,47 +0,0 @@
-# measure.sh <label> [seconds] - (Android root shell) CPU and GPU load of the MobileGL desktop over a
-# window: % of ONE core (so 800 = all 8 cores) for the whole phone, KWin (+Xwayland), plasmashell,
-# Chrome (all its processes), the app's :mobilegl server and its UI process, plus the mean of the
-# kgsl gpu_busy_percentage samples (1/s). The container's processes are visible from Android's
-# /proc (Droidspaces only gives them their own pid namespace).
-# Run: su -c "sh /data/local/tmp/anl/measure.sh visible 20"      Env: PKG.
-L=${1:-sample}
-N=${2:-20}
-P=${PKG:-com.anland.consumer.mobilegl}
-GPU=/sys/class/kgsl/kgsl-3d0/gpu_busy_percentage
-
-pids_named() {   # exact process names (comm or argv0 basename)
-    for n in "$@"; do pidof "$n"; done
-}
-pids_matching() {   # argv contains the word
-    for d in /proc/[0-9]*; do
-        { tr '\0' ' ' < $d/cmdline; } 2>/dev/null | grep -q "$1" && echo ${d#/proc/}
-    done
-}
-ticks() {   # utime+stime of the pids, in clock ticks
-    t=0
-    for p in "$@"; do
-        [ -r /proc/$p/stat ] || continue
-        v=$(sed 's/^.*) //' /proc/$p/stat | awk '{print $12 + $13}')
-        t=$((t + v))
-    done
-    echo $t
-}
-total() { awk '/^cpu /{print $2+$3+$4+$6+$7+$8}' /proc/stat; }
-
-KW="$(pids_named kwin_wayland Xwayland)"
-SH="$(pids_named plasmashell)"
-CH="$(pids_matching /opt/google/chrome/)"
-SV="$(pidof $P:mobilegl)"
-UI="$(pidof $P)"
-
-a0=$(total); k0=$(ticks $KW); s0=$(ticks $SH); c0=$(ticks $CH); v0=$(ticks $SV); u0=$(ticks $UI)
-g=0; i=0
-while [ $i -lt $N ]; do
-    sleep 1
-    b=$(cat $GPU 2>/dev/null | tr -dc '0-9'); g=$((g + ${b:-0})); i=$((i + 1))
-done
-a1=$(total); k1=$(ticks $KW); s1=$(ticks $SH); c1=$(ticks $CH); v1=$(ticks $SV); u1=$(ticks $UI)
-# CLK_TCK is 100: ticks per second == percent of one core.
-pct() { echo $(( ($2 - $1) / N )); }
-printf '%-10s %3ss  phone %4s%%  kwin %3s%%  plasmashell %3s%%  chrome %3s%%  server %3s%%  app-ui %3s%%  gpu %3s%%\n' \
-    "$L" "$N" "$(pct $a0 $a1)" "$(pct $k0 $k1)" "$(pct $s0 $s1)" "$(pct $c0 $c1)" "$(pct $v0 $v1)" "$(pct $u0 $u1)" "$((g / N))"

.claude/skills/anland-mobilegl-plasma/scripts/device/restart-daemon.sh

@@ -1,20 +0,0 @@
-# restart-daemon.sh - (Android root shell) (re)start the EXPERIMENT's anland display daemon on $SOCK.
-# It is not started at boot (the anland-daemon module's service.sh only starts the original daemon on
-# /data/local/tmp/display_daemon.sock, which must be left alone).  Without it KWin logs
-# "failed to connect to display daemon at /run/anland-mobilegl/display.sock" and the session dies in ~3 s.
-# The container sees $SOCK as /run/anland-mobilegl/display.sock (bind mount in container.config);
-# uid 1000 in the container must connect, hence 777 dir / 666 socket.
-# Env: SOCK, DAEMON (/data/adb/modules/anland-daemon/display_daemon).
-SOCK=${SOCK:-/data/local/tmp/anland-mobilegl/display.sock}
-DAEMON=${DAEMON:-/data/adb/modules/anland-daemon/display_daemon}
-DIR=$(dirname $SOCK)
-for p in $(ps -A -o PID,ARGS | grep "display_daemon $SOCK" | grep -v grep | awk '{print $1}'); do kill $p; done
-sleep 1
-rm -f $SOCK
-mkdir -p $DIR
-nohup $DAEMON $SOCK > $DIR/display-daemon.log 2>&1 &
-sleep 1
-chmod 777 $DIR
-chmod 666 $SOCK
-echo "daemon restarted:"
-ps -A -o PID,ARGS | grep "display_daemon $SOCK" | grep -v grep

.claude/skills/anland-mobilegl-plasma/scripts/device/run-plasma.sh

@@ -1,27 +0,0 @@
-# run-plasma.sh - (Android root shell) DEVELOPER restart of the whole MobileGL desktop, e.g. after a
-# server, client or KWin rebuild: ends the Plasma session (and the user's logind session, which takes
-# a while to wind down), then restarts the anland app; opening it brings up the server, starts
-# desktop-session.service again and the session waits for the server. Normal use needs none of this:
-# opening the app is enough. ~60 s. Prints the unit status, plasma user units and recent coredumps.
-# Run: su -c "sh /data/local/tmp/anl/run-plasma.sh"
-# Env: PKG, CONTAINER, DESKTOP_USER (swung0x48), DS (droidspaces binary).
-D=${DS:-/data/local/Droidspaces/bin/droidspaces}
-P=${PKG:-com.anland.consumer.mobilegl}
-C=${CONTAINER:-arch-kde-mgl}
-U=${DESKTOP_USER:-swung0x48}
-$D --name=$C run bash -lc "
-systemctl stop desktop-session.service 2>/dev/null
-loginctl terminate-user $U 2>/dev/null; sleep 30
-systemctl reset-failed desktop-session.service
-rm -f /tmp/mobilegl-compositor.log
-date +%s > /tmp/plasma-start
-"
-am force-stop $P
-am start -n $P/com.anland.consumer.MainActivity > /dev/null
-sleep 30
-$D --name=$C run bash -lc "
-systemctl --no-pager status desktop-session.service | head -8
-UID_=\$(id -u $U)
-sudo -u $U XDG_RUNTIME_DIR=/run/user/\$UID_ systemctl --user --no-pager list-units --all 'plasma*' 2>&1 | head -30
-coredumpctl --no-pager list --since '-2min' 2>&1 | tail -5
-"

.claude/skills/anland-mobilegl-plasma/scripts/device/status.sh

@@ -1,13 +0,0 @@
-# status.sh - (Android root shell) READ-ONLY health check of the whole stack.
-# Run: su -c "sh /data/local/tmp/anl/status.sh"      Env: PKG, CONTAINER, DS, SOCK.
-D=${DS:-/data/local/Droidspaces/bin/droidspaces}
-P=${PKG:-com.anland.consumer.mobilegl}
-C=${CONTAINER:-arch-kde-mgl}
-SOCK=${SOCK:-/data/local/tmp/anland-mobilegl/display.sock}
-echo "battery: $(dumpsys battery | grep ' level:' | tr -d ' ')  $(dumpsys power | grep -o 'mStayOn=[a-z]*')"
-echo "backend: app setting=$(cat /data/data/$P/files/mobilegl-backend 2>/dev/null || echo 'DirectGLES (default)')  published=$(cat ${SOCK%/*}/backend 2>/dev/null)  container /etc/mobilegl/backend=$(cat /mnt/Droidspaces/$C/etc/mobilegl/backend 2>/dev/null)  prop override=$(getprop debug.mobilegl.backend)"
-echo "desktop service log: $(tail -1 ${SOCK%/*}/desktop.log 2>/dev/null)"
-echo "app pid: $(pidof $P)  server (:mobilegl) pid: $(pidof $P:mobilegl)"
-ps -A -o PID,ARGS | grep "display_daemon $SOCK" | grep -v grep || echo "experiment display daemon NOT running"
-$D show
-$D --name=$C run bash -lc 'echo "desktop-session: $(systemctl is-active desktop-session.service)"; pgrep -a -x kwin_wayland; pgrep -a -x plasmashell; grep -A1 QtQuickRendererSettings /home/*/.config/kdeglobals 2>/dev/null || echo "kdeglobals: no sticky software renderer"'

.claude/skills/anland-mobilegl-plasma/scripts/device/swap.sh

@@ -1,17 +0,0 @@
-# swap.sh - (Android root shell) replace the server libMobileGL.so inside the INSTALLED anland APK with
-# $SHARE/libMobileGL.new.so, keeping owner, mode and SELinux context; force-stops the app.  The first
-# run backs the APK's original lib up to $SHARE/libMobileGL.so.orig.  No re-signing/reinstall (that
-# would change the app UID and lose its root grant).  Run: su -c "sh /data/local/tmp/anl/swap.sh"
-# Env: PKG (com.anland.consumer.mobilegl), SHARE (/data/local/tmp/anland-mobilegl).
-set -e
-P=${PKG:-com.anland.consumer.mobilegl}
-SHARE=${SHARE:-/data/local/tmp/anland-mobilegl}
-D=$(dirname $(pm path $P | sed 's/package://'))/lib/arm64
-ls -laZ $D
-[ -f $SHARE/libMobileGL.so.orig ] || cp $D/libMobileGL.so $SHARE/libMobileGL.so.orig
-am force-stop $P
-CTX=$(ls -Z $D/libMobileGL.so | awk '{print $1}')
-OWN=$(stat -c %u:%g $D/libMobileGL.so)
-cp $SHARE/libMobileGL.new.so $D/libMobileGL.so
-chown $OWN $D/libMobileGL.so; chmod 755 $D/libMobileGL.so; chcon $CTX $D/libMobileGL.so
-ls -laZ $D/libMobileGL.so

.claude/skills/anland-mobilegl-plasma/scripts/device/switch.sh

@@ -1,17 +0,0 @@
-# switch.sh <DirectGLES|DirectVulkan> - (Android root shell) change the MobileGL backend the anland
-# app's server runs (Espryt = DirectGLES, Magma = DirectVulkan). The choice is the app's setting
-# (Settings > Connection > MobileGL desktop, saved in the app's files/mobilegl-backend); this does
-# what a user does there: save it, Stop desktop, open the app again. The new server publishes the
-# backend and the container's session copies it to /etc/mobilegl/backend before it starts, so
-# server and clients agree. ~30-60 s. No setprop: debug.mobilegl.backend, if set, still overrides
-# the setting until the next reboot - this clears it.
-# Env: PKG, SOCK.
-B=${1:?usage: switch.sh DirectGLES|DirectVulkan}
-P=${PKG:-com.anland.consumer.mobilegl}
-[ -n "$(getprop debug.mobilegl.backend)" ] && setprop debug.mobilegl.backend ""
-if pidof $P:mobilegl > /dev/null; then
-    am startservice -n $P/com.anland.consumer.MobileGLWorker -a com.anland.consumer.mobilegl.STOP > /dev/null
-    i=0; while pidof $P:mobilegl > /dev/null && [ $i -lt 60 ]; do sleep 1; i=$((i + 1)); done
-fi
-am start -n $P/com.anland.consumer.MainActivity --es mobilegl_backend $B > /dev/null
-echo "backend $B saved; the desktop is starting (watch: sh $(dirname $0)/status.sh)"

.claude/skills/anland-mobilegl-plasma/scripts/device/unlock.sh

@@ -1,8 +0,0 @@
-# unlock.sh - (Android root shell) ask logind to unlock the desktop user's session.  UNVERIFIED that this
-# helps here: the handoff notes this logind session type does not support lock-session (a real lock
-# screen then needs the password).  Prevention: [Daemon] Autolock=false in ~/.config/kscreenlockerrc.
-# Env: DS, CONTAINER, DESKTOP_USER.
-D=${DS:-/data/local/Droidspaces/bin/droidspaces}
-C=${CONTAINER:-arch-kde-mgl}
-U=${DESKTOP_USER:-swung0x48}
-$D --name=$C run bash -lc "S=\$(loginctl list-sessions --no-legend | awk '\$3==\"$U\"{print \$1}' | head -1); loginctl unlock-session \$S; echo unlocked \$S"

.claude/skills/anland-mobilegl-plasma/scripts/device/x11-measure.sh

@@ -1,47 +0,0 @@
-# x11-measure.sh <label> <app-process-name> [seconds] - (Android root shell) CPU of the X11 path while
-# an X11 app runs: % of ONE core (800 = all 8 cores) for the whole phone, the app, Xwayland,
-# kwin_wayland, the app's :mobilegl server; mean kgsl gpu_busy_percentage; and the number of dma-buf
-# descriptors Xwayland and KWin hold (window pixmaps / client buffers as dma-bufs). Refuses to run
-# below 40% battery: the phone drains faster under load than USB charges it.
-# Run: su -c "sh /data/local/tmp/anl/x11-measure.sh glamor glxgears 10"      Env: PKG, MIN_BATTERY.
-L=${1:-sample}
-APP=${2:-glxgears}
-N=${3:-10}
-P=${PKG:-com.anland.consumer.mobilegl}
-GPU=/sys/class/kgsl/kgsl-3d0/gpu_busy_percentage
-level=$(dumpsys battery | sed -n 's/^ *level: *//p')
-if [ "${level:-0}" -lt "${MIN_BATTERY:-40}" ]; then
-    echo "battery ${level}% < ${MIN_BATTERY:-40}%: not loading the phone; charge first" >&2
-    exit 3
-fi
-ticks() {
-    t=0
-    for p in "$@"; do
-        [ -r /proc/$p/stat ] || continue
-        v=$(sed 's/^.*) //' /proc/$p/stat | awk '{print $12 + $13}')
-        t=$((t + v))
-    done
-    echo $t
-}
-total() { awk '/^cpu /{print $2+$3+$4+$6+$7+$8}' /proc/stat; }
-dmabufs() {   # dma-buf descriptors held by the pids (Android kernels link them to /dmabuf:...)
-    n=0
-    for p in "$@"; do n=$((n + $(ls -l /proc/$p/fd 2>/dev/null | grep -c dmabuf))); done
-    echo $n
-}
-AP="$(pidof $APP)"
-XW="$(pidof Xwayland)"
-KW="$(pidof kwin_wayland)"
-SV="$(pidof $P:mobilegl)"
-[ -n "$AP" ] || { echo "no running process named $APP" >&2; exit 2; }
-a0=$(total); p0=$(ticks $AP); x0=$(ticks $XW); k0=$(ticks $KW); v0=$(ticks $SV)
-g=0; i=0
-while [ $i -lt $N ]; do
-    sleep 1
-    b=$(cat $GPU 2>/dev/null | tr -dc '0-9'); g=$((g + ${b:-0})); i=$((i + 1))
-done
-a1=$(total); p1=$(ticks $AP); x1=$(ticks $XW); k1=$(ticks $KW); v1=$(ticks $SV)
-pct() { echo $(( ($2 - $1) / N )); }
-printf '%-12s %3ss  phone %4s%%  %s %3s%%  Xwayland %3s%%  kwin %3s%%  server %3s%%  gpu %3s%%  dmabufs Xwayland %s kwin %s  battery %s%%\n' \
-    "$L" "$N" "$(pct $a0 $a1)" "$APP" "$(pct $p0 $p1)" "$(pct $x0 $x1)" "$(pct $k0 $k1)" "$(pct $v0 $v1)" "$((g / N))" \
-    "$(dmabufs $XW)" "$(dmabufs $KW)" "$level"

.claude/skills/anland-mobilegl-plasma/scripts/env.sh

@@ -1,41 +0,0 @@
-# env.sh - shared parameters for the host-side (Git Bash) scripts of the anland-mobilegl-plasma skill.
-# Sourced, never run. Every value can be overridden from the environment before calling a script.
-#
-#   MGL_WORKTREE    MobileGL worktree (Windows form C:/...). Default: the worktree this skill lives in.
-#   ANL_DIR         Local scratch dir: channel files, screenshots, xdist/. Default: %LOCALAPPDATA%/Temp/anl
-#   ANDROID_NDK     NDK used for the Android server lib. Default: <SDK>/ndk/27.2.12479018
-#   MGL_PKG         Anland APK that embeds the server. Default: com.anland.consumer.mobilegl
-#   MGL_CONTAINER   Droidspaces container. Default: arch-kde-mgl
-#   MGL_DESKTOP_USER  Desktop user inside the container. Default: swung0x48
-#   DS_BIN          droidspaces binary on the phone. Default: /data/local/Droidspaces/bin/droidspaces
-#   DEV_TOOLS       Phone dir for device/*.sh and channel files. Default: /data/local/tmp/anl
-#   DEV_SHARE       Phone dir bind-mounted into the container as /run/anland-mobilegl (screenshots,
-#                   server lib staging, display daemon socket). Default: /data/local/tmp/anland-mobilegl
-#   ANDROID_SERIAL  Honoured by adb itself; leave unset when only one device is attached
-#                   (USB serial or a wireless "ip:port").
-
-_skill_scripts=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
-if [ -z "${MGL_WORKTREE:-}" ]; then
-    MGL_WORKTREE=$(cd "$_skill_scripts/../../../.." && pwd -W 2>/dev/null || pwd)
-fi
-: "${ANL_DIR:=$(cygpath -m "${LOCALAPPDATA:-C:/Users/$USERNAME/AppData/Local}" 2>/dev/null || echo /tmp)/Temp/anl}"
-: "${ANDROID_NDK:=$(cygpath -m "${LOCALAPPDATA:-C:/Users/$USERNAME/AppData/Local}" 2>/dev/null)/Android/Sdk/ndk/27.2.12479018}"
-: "${MGL_PKG:=com.anland.consumer.mobilegl}"
-: "${MGL_CONTAINER:=arch-kde-mgl}"
-: "${MGL_DESKTOP_USER:=swung0x48}"
-: "${DS_BIN:=/data/local/Droidspaces/bin/droidspaces}"
-: "${DEV_TOOLS:=/data/local/tmp/anl}"
-: "${DEV_SHARE:=/data/local/tmp/anland-mobilegl}"
-# The container rootfs as Android root sees it (the container's /tmp is NOT visible here).
-CT_ROOT=/mnt/Droidspaces/$MGL_CONTAINER
-export MGL_WORKTREE ANL_DIR ANDROID_NDK MGL_PKG MGL_CONTAINER MGL_DESKTOP_USER DS_BIN DEV_TOOLS DEV_SHARE CT_ROOT
-
-# Git Bash would rewrite /data/... arguments into C:/Program Files/Git/data/...; keep them literal.
-# Consequence: pass LOCAL paths to Windows tools (adb, cmake, git) in C:/ form, never /c/.
-export MSYS_NO_PATHCONV=1
-adb_() { MSYS2_ARG_CONV_EXCL='*' adb "$@"; }
-
-# C:/x/y -> /mnt/c/x/y (for WSL).
-win2wsl() { local p=$1 d; d=$(printf '%s' "${p:0:1}" | tr 'A-Z' 'a-z'); printf '/mnt/%s%s' "$d" "${p:2}"; }
-
-mkdir -p "$ANL_DIR"

.claude/skills/anland-mobilegl-plasma/scripts/kwin-recover.sh

@@ -1,146 +0,0 @@
-#!/usr/bin/env bash
-# kwin-recover.sh [rounds] - does the desktop keep working when KWin's OWN MobileGL session is lost?
-# Starts animated clients (glmark2-es2-wayland: Wayland, zero-copy shared images; glxgears: X11 through
-# Xwayland's GLX; with CHROME=1 also Chrome on an animated WebGL page), then per round loses the server
-# session of KWin with the pid-targeted debug knob (debug.mobilegl.inject_device_lost_pid, KWin's pid as
-# it sees itself in the container), waits, and checks.  A round PASSES when:
-#   - the server latched KWin's session (the server log file: "injected:pid=<kwin>"; logcat is too small);
-#   - KWin, plasmashell and every test client are the SAME processes (nothing restarted);
-#   - KWin restarted compositing on a fresh session (its journal: "compositing restarted on a fresh
-#     MobileGL session"; its client log: one more "RECOVERED");
-#   - the screen still animates (shot.sh hashes differ) and the clients keep presenting;
-#   - no native crash (logcat -b crash).
-# Between rounds the knob is reset to 0 while the clients run, which re-arms it for the same pid.
-# Stops early below MIN_BATTERY percent (the phone drains faster under load than USB charges it).
-#
-# Deploy first (same MobileGL commit on both sides; see SKILL.md):
-#   bash scripts/build-android.sh && bash scripts/cyc.sh pre      # server -> APK, restarts the session
-#   bash scripts/xbuild.sh && bash scripts/xdeploy.sh             # client -> container
-#   ANLAND_WORKTREE=<anland worktree> bash scripts/kwin-stage.sh build   # kwin.patch + anland backend
-#   (wait for "== ALL DONE ==" in /root/kwin-build.log), then: adb shell 'su -c "sh /data/local/tmp/anl/run-plasma.sh"'
-# Env: ROUNDS (default 2), SETTLE (s after the loss, default 10), REARM (s with the knob at 0 between
-#      rounds, default 4), MIN_BATTERY (default 40), CHROME (1: add Chrome), CHANNEL (ct.sh channel,
-#      default krec), TAG (screenshot/log tag, default krec).
-set -euo pipefail
-here=$(cd "$(dirname "$0")" && pwd)
-. "$here/env.sh"
-ROUNDS=${1:-${ROUNDS:-2}}
-SETTLE=${SETTLE:-10}
-REARM=${REARM:-4}
-MIN_BATTERY=${MIN_BATTERY:-40}
-CH=${CHANNEL:-krec}
-TAG=${TAG:-krec}
-COMPOSITOR_LOG=/tmp/mobilegl-compositor.client.log
-SERVER_LOG=/data/data/$MGL_PKG/files/mobilegl-server.server.log
-
-ct() { bash "$here/ct.sh" "$CH"; }
-
-battery() { adb_ shell dumpsys battery | tr -d '\r' | awk '/ level:/ {print $2}'; }
-stop_clients() {
-    ct <<'IN' || true
-pkill -x glmark2-es2-way 2>/dev/null; pkill -x glmark2-es2-wayland 2>/dev/null; pkill -x glxgears 2>/dev/null
-true
-IN
-}
-cleanup() {
-    adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid 0'" || true
-    stop_clients
-}
-check_battery() {
-    local level; level=$(battery)
-    echo "battery: $level%"
-    if [ -n "$level" ] && [ "$level" -lt "$MIN_BATTERY" ]; then
-        echo "STOP: battery below $MIN_BATTERY%"; exit 3
-    fi
-}
-trap cleanup EXIT
-
-check_battery
-adb_ shell "su -c 'sh $DEV_TOOLS/status.sh'" || true
-adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid 0'"
-
-# The clients, each with its own log (mgrun's MGLOG), in the background for the whole run.
-ct <<'IN'
-rm -f /tmp/mgl-krec-gm.client.log /tmp/mgl-krec-gx.client.log /tmp/krec-gm.out /tmp/krec-gx.out
-MGLOG=/tmp/mgl-krec-gm.log nohup timeout 900 mgrun offscreen glmark2-es2-wayland -s 960x540 --run-forever \
-  > /tmp/krec-gm.out 2>&1 < /dev/null &
-MGLOG=/tmp/mgl-krec-gx.log nohup timeout 900 mgrun offscreen glxgears -info > /tmp/krec-gx.out 2>&1 < /dev/null &
-sleep 8
-echo "glmark2: $(pgrep -x glmark2-es2-way || pgrep -x glmark2-es2-wayland)  glxgears: $(pgrep -x glxgears)"
-grep -aE "presented through|could not be presented" /tmp/mgl-krec-gm.client.log | head -2
-grep -aE "presented through|readback" /tmp/mgl-krec-gx.client.log | head -2
-IN
-if [ "${CHROME:-0}" = 1 ]; then
-    ct <<'IN'
-cat > /tmp/mgl-krec-spin.html <<'HTML'
-<!doctype html><html><body style="margin:0;background:#000">
-<canvas id=c width=640 height=360 style="width:100vw;height:100vh"></canvas>
-<script>
-const gl = document.getElementById('c').getContext('webgl'); let t = 0;
-function frame() { t++; if (gl && !gl.isContextLost()) { gl.clearColor((t % 60) / 60, 0.2, 0.6, 1); gl.clear(gl.COLOR_BUFFER_BIT); }
-  requestAnimationFrame(frame); }
-frame();
-</script></body></html>
-HTML
-chmod 644 /tmp/mgl-krec-spin.html
-IN
-    WAIT=${WAIT:-20} CHANNEL=$CH bash "$here/chrome-launch.sh" "$TAG" --new-window "file:///tmp/mgl-krec-spin.html"
-fi
-
-# KWin, plasmashell and the clients, as pids inside the container; how often KWin recovered so far.
-snapshot() {
-    ct <<IN | tr -d '\r' | tail -1
-k=\$(pgrep -x kwin_wayland | head -1); p=\$(pgrep -x plasmashell | head -1)
-g=\$(pgrep -x glmark2-es2-way || pgrep -x glmark2-es2-wayland); x=\$(pgrep -x glxgears | head -1)
-c=\$(pgrep -x chrome | head -1)
-r=\$(grep -ac "RECOVERED" $COMPOSITOR_LOG 2>/dev/null || true)
-f=\$(grep -ac "FPS" /tmp/krec-gm.out 2>/dev/null || true)
-echo "\${k:-none} \${p:-none} \${g:-none} \${x:-none} \${c:-none} \${r:-0} \${f:-0}"
-IN
-}
-
-pass=0
-for round in $(seq 1 "$ROUNDS"); do
-    echo "=== round $round/$ROUNDS"
-    check_battery
-    read -r kwin plasma gm gx chrome recovered fps < <(snapshot)
-    echo "kwin=$kwin plasmashell=$plasma glmark2=$gm glxgears=$gx chrome=$chrome recoveries=$recovered fps-lines=$fps"
-    if [ "$kwin" = none ]; then echo "FAIL: KWin is not running"; break; fi
-    bash "$here/shot.sh" "$TAG-r$round-pre" 2 1
-    srvlines=$(adb_ shell "su -c 'wc -l < $SERVER_LOG'" | tr -dc '0-9')
-    adb_ logcat -b crash -c || true
-    adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid $kwin'"
-    sleep "$SETTLE"
-    adb_ shell "su -c 'setprop debug.mobilegl.inject_device_lost_pid 0'"
-    bash "$here/shot.sh" "$TAG-r$round-post" 3 1 | tee "$ANL_DIR/$TAG-r$round-post.md5"
-    read -r kwin2 plasma2 gm2 gx2 chrome2 recovered2 fps2 < <(snapshot)
-    echo "after: kwin=$kwin2 plasmashell=$plasma2 glmark2=$gm2 glxgears=$gx2 chrome=$chrome2 recoveries=$recovered2 fps-lines=$fps2"
-    adb_ shell "su -c 'tail -n +$((srvlines + 1)) $SERVER_LOG'" > "$ANL_DIR/$TAG-r$round-server.log"
-    latched=$(grep -c "injected:pid=$kwin" "$ANL_DIR/$TAG-r$round-server.log" || true)
-    grep -aE "inject_device_lost_pid|SessionLatch|session #[0-9]+ (started|pid)|owner=server|lease" \
-        "$ANL_DIR/$TAG-r$round-server.log" | cut -c1-220 | head -14 || true
-    ct <<IN || true
-echo "--- KWin's MobileGL client log:"; grep -aE "DEVICE LOST|RECOVERED|GL_UNKNOWN_CONTEXT_RESET|re-created on the fresh|Refuse" $COMPOSITOR_LOG | tail -6
-echo "--- KWin journal:"; journalctl --no-pager --since -40s 2>/dev/null | grep -aE "kwin_wayland" | grep -aiE "reset|restarted|MobileGL swap|context|fatal|abort" | tail -10
-echo "--- clients:"; grep -aE "DEVICE LOST|lost|Fatal" /tmp/mgl-krec-gm.client.log /tmp/mgl-krec-gx.client.log | tail -4
-IN
-    crashes=$(adb_ logcat -b crash -d | grep -c "Fatal signal\|Abort message" || true)
-    hashes=$(awk '{print $1}' "$ANL_DIR/$TAG-r$round-post.md5" | sort -u | wc -l)
-    verdict=PASS
-    [ "$latched" -ge 1 ] || { echo "  - the server never latched KWin's session (pid $kwin)"; verdict=FAIL; }
-    [ "$kwin2" = "$kwin" ] || { echo "  - KWin is a different process ($kwin -> $kwin2): it restarted"; verdict=FAIL; }
-    [ "$plasma2" = "$plasma" ] || { echo "  - plasmashell restarted ($plasma -> $plasma2)"; verdict=FAIL; }
-    [ "$gm2" = "$gm" ] && [ "$gx2" = "$gx" ] || { echo "  - a test client restarted or died"; verdict=FAIL; }
-    [ "${CHROME:-0}" != 1 ] || [ "$chrome2" = "$chrome" ] || { echo "  - Chrome restarted"; verdict=FAIL; }
-    [ "$recovered2" -gt "$recovered" ] || { echo "  - KWin's client log shows no new RECOVERED session"; verdict=FAIL; }
-    [ "$fps2" -gt "$fps" ] || { echo "  - glmark2 stopped reporting frames"; verdict=FAIL; }
-    [ "$hashes" -ge 2 ] || { echo "  - the screen does not change after the loss (frozen)"; verdict=FAIL; }
-    [ "$crashes" -eq 0 ] || { echo "  - native crash(es):"; adb_ logcat -b crash -d | tail -8; verdict=FAIL; }
-    echo "round $round: $verdict"
-    [ "$verdict" = PASS ] && pass=$((pass + 1))
-    [ "$verdict" = PASS ] || break
-    # Re-arm the knob for the same pid: a session must observe 0 before the next value counts.
-    sleep "$REARM"
-done
-echo "=== $pass/$ROUNDS rounds passed; screenshots in $ANL_DIR/$TAG-r*-*.png"
-[ "$pass" = "$ROUNDS" ]

.claude/skills/anland-mobilegl-plasma/scripts/kwin-stage.sh

@@ -1,46 +0,0 @@
-#!/usr/bin/env bash
-# kwin-stage.sh [build] - stage anland's KWin changes (kwin.patch, anland backend sources,
-# mobilegl-startup.sh, sync-build-kwin.sh) for the in-container KWin rebuild; with "build", also run
-# kwprep.sh (apply changed patch hunks / backend files to the live tree) and start sync-build-kwin.sh
-# (ninja -j4 + atomic install into /opt/mobilegl/kwin, screencast plugin, startup script) in the
-# background, log /root/kwin-build.log.  KWin is NOT restarted: run device/run-plasma.sh afterwards.
-# Poll:  printf 'tail -5 /root/kwin-build.log\n' | bash ct.sh kw
-#
-# Two staging places, because the two container scripts read different ones:
-#   /root/kwsync.tgz                            <- kwprep.sh (installed by push-tools.sh)
-#   $DEV_SHARE/kwin-sync = /run/anland-mobilegl/kwin-sync  <- sync-build-kwin.sh (as kwin-sync/sync-build.sh)
-# All files are CR-stripped: the Windows checkout of anland has CRLF backend sources and a CRLF
-# sync-build-kwin.sh (bash then fails on $'\r').
-# Assembled from kwprep.sh + sync-build-kwin.sh; not exercised as one unit yet.
-# Env: ANLAND_WORKTREE (anland checkout on branch legacy-mobilegl-unified, Windows form),
-#      CHANNEL (ct.sh channel, default kw).
-set -euo pipefail
-here=$(cd "$(dirname "$0")" && pwd)
-. "$here/env.sh"
-: "${ANLAND_WORKTREE:=$(cygpath -m "$USERPROFILE" 2>/dev/null)/AndroidStudioProjects/anland/.claude/worktrees/mgl-unified}"
-K=$ANLAND_WORKTREE/producers/kde
-st=$ANL_DIR/kwstage
-rm -rf "$st"; mkdir -p "$st/kwsync/Arch_v5" "$st/kwsync/anland_backend_Arch_v5/src/backends/anland" "$st/kwin-sync/anland" "$st/kwin-sync/misc"
-lf() { tr -d '\r' < "$1" > "$2"; }
-for f in "$K"/anland_backend_Arch_v5/src/backends/anland/*; do
-    b=$(basename "$f"); [ "$b" = libdisplay_producer ] && continue
-    lf "$f" "$st/kwsync/anland_backend_Arch_v5/src/backends/anland/$b"
-    lf "$f" "$st/kwin-sync/anland/$b"
-done
-for f in kwin.patch mobilegl-startup.sh desktop-session-mobilegl.conf; do
-    lf "$K/Arch_v5/$f" "$st/kwsync/Arch_v5/$f"
-    lf "$K/Arch_v5/$f" "$st/kwin-sync/misc/$f"
-done
-lf "$K/Arch_v5/sync-build-kwin.sh" "$st/kwin-sync/sync-build.sh"
-(cd "$st/kwsync" && tar --force-local -czf ../kwsync.tgz Arch_v5 anland_backend_Arch_v5)
-tar --force-local -C "$st" -czf "$st/kwin-sync.tgz" kwin-sync
-adb_ push "$st/kwsync.tgz" "$DEV_TOOLS/kwsync.tgz" >/dev/null
-adb_ push "$st/kwin-sync.tgz" "$DEV_TOOLS/kwin-sync.tgz" >/dev/null
-adb_ shell "su -c 'cp $DEV_TOOLS/kwsync.tgz $CT_ROOT/root/kwsync.tgz && tar xzf $DEV_TOOLS/kwin-sync.tgz -C $DEV_SHARE && chmod -R a+rX $DEV_SHARE/kwin-sync && rm -f $DEV_TOOLS/kwsync.tgz $DEV_TOOLS/kwin-sync.tgz && echo staged'"
-if [ "${1:-}" = build ]; then
-    bash "$here/ct.sh" "${CHANNEL:-kw}" <<'IN'
-bash /root/kwprep.sh || exit 1
-nohup bash /run/anland-mobilegl/kwin-sync/sync-build.sh > /root/kwin-build.log 2>&1 < /dev/null &
-echo "kwin build started (pid $!), log /root/kwin-build.log; it ends with '== ALL DONE =='"
-IN
-fi

.claude/skills/anland-mobilegl-plasma/scripts/probes/cdpmedia.py

@@ -1,94 +0,0 @@
-#!/usr/bin/env python3
-# cdpmedia.py [port] [seconds] - ask a Chrome started with --remote-debugging-port=<port> (and a
-# non-default --user-data-dir) which video decoder its first page's players use, and evaluate
-# `window.__mglStats` / the element `#t` text of the page. Standard library only (no websocket
-# module in the container): a minimal RFC 6455 client.
-#   python3 cdpmedia.py 9333 6
-# Prints kVideoDecoderName / kIsPlatformVideoDecoder / kVideoTracks properties and media errors as
-# they arrive, then the page's stats text.
-import base64, json, os, socket, struct, sys, time, urllib.request
-
-port = int(sys.argv[1]) if len(sys.argv) > 1 else 9333
-seconds = float(sys.argv[2]) if len(sys.argv) > 2 else 6.0
-targets = json.load(urllib.request.urlopen(f"http://127.0.0.1:{port}/json"))
-page = next(t for t in targets if t.get("type") == "page")
-url = page["webSocketDebuggerUrl"]
-path = url.split(f"127.0.0.1:{port}", 1)[1]
-sock = socket.create_connection(("127.0.0.1", port))
-key = base64.b64encode(os.urandom(16)).decode()
-sock.sendall((f"GET {path} HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n"
-              f"Sec-WebSocket-Key: {key}\r\nSec-WebSocket-Version: 13\r\n\r\n").encode())
-response = b""
-while b"\r\n\r\n" not in response:
-    response += sock.recv(4096)
-buffer = response.split(b"\r\n\r\n", 1)[1]
-
-
-def send(message):
-    data = json.dumps(message).encode()
-    header = bytes([0x81])
-    mask = os.urandom(4)
-    if len(data) < 126:
-        header += bytes([0x80 | len(data)])
-    elif len(data) < 65536:
-        header += bytes([0x80 | 126]) + struct.pack(">H", len(data))
-    else:
-        header += bytes([0x80 | 127]) + struct.pack(">Q", len(data))
-    sock.sendall(header + mask + bytes(b ^ mask[i % 4] for i, b in enumerate(data)))
-
-
-def recv_exact(n):
-    global buffer
-    while len(buffer) < n:
-        chunk = sock.recv(65536)
-        if not chunk:
-            raise EOFError
-        buffer += chunk
-    out, buffer = buffer[:n], buffer[n:]
-    return out
-
-
-def recv():
-    first, second = recv_exact(2)
-    length = second & 0x7F
-    if length == 126:
-        length = struct.unpack(">H", recv_exact(2))[0]
-    elif length == 127:
-        length = struct.unpack(">Q", recv_exact(8))[0]
-    payload = recv_exact(length)
-    return json.loads(payload) if first & 0x0F == 1 else None
-
-
-send({"id": 1, "method": "Media.enable"})
-# Players created before the domain was enabled report nothing: reload so the page makes new ones.
-if os.environ.get("CDP_NAVIGATE"):
-    send({"id": 3, "method": "Page.navigate", "params": {"url": os.environ["CDP_NAVIGATE"]}})
-elif os.environ.get("CDP_RELOAD", "1") == "1":
-    send({"id": 3, "method": "Page.reload"})
-deadline = time.time() + seconds
-sock.settimeout(0.5)
-seen = set()
-while time.time() < deadline:
-    try:
-        message = recv()
-    except socket.timeout:
-        continue
-    if not message or "method" not in message:
-        continue
-    if message["method"] == "Media.playerPropertiesChanged":
-        for prop in message["params"]["properties"]:
-            if prop["name"] in ("kVideoDecoderName", "kIsPlatformVideoDecoder", "kVideoTracks", "kResolution"):
-                line = f"{prop['name']} = {prop['value']}"
-                if line not in seen:
-                    seen.add(line)
-                    print(line)
-    elif message["method"] in ("Media.playerErrorsRaised",):
-        print("media error:", json.dumps(message["params"])[:300])
-send({"id": 2, "method": "Runtime.evaluate",
-      "params": {"expression": os.environ.get("CDP_EXPR", "(document.getElementById('t')||{}).textContent"), "returnByValue": True}})
-sock.settimeout(3)
-while True:
-    message = recv()
-    if message and message.get("id") == 2:
-        print("page:", message.get("result", {}).get("result", {}).get("value"))
-        break

.claude/skills/anland-mobilegl-plasma/scripts/probes/dmahash.c

@@ -1,34 +0,0 @@
-// dmahash <pid> : for each dma-buf fd of <pid> at least 1 MB, print inode, size and a sampled checksum.
-#include <dirent.h>
-#include <fcntl.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-int main(int argc, char** argv) {
-    char dir[64];
-    snprintf(dir, sizeof dir, "/proc/%s/fd", argv[1]);
-    DIR* d = opendir(dir);
-    if (!d) { perror("opendir"); return 1; }
-    struct dirent* e;
-    while ((e = readdir(d))) {
-        char p[128], l[128] = {0};
-        snprintf(p, sizeof p, "%s/%s", dir, e->d_name);
-        if (readlink(p, l, sizeof l - 1) <= 0 || strncmp(l, "/dmabuf", 7) != 0) continue;
-        int fd = open(p, O_RDONLY);
-        if (fd < 0) continue;
-        struct stat st; fstat(fd, &st);
-        if (st.st_size < (1 << 20)) { close(fd); continue; }
-        const uint8_t* m = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
-        if (m == MAP_FAILED) { printf("fd %s ino %lu mmap failed\n", e->d_name, (unsigned long)st.st_ino); close(fd); continue; }
-        uint64_t h = 1469598103934665603ull; unsigned nz = 0;
-        for (off_t i = 0; i < st.st_size; i += 64) { h = (h ^ m[i]) * 1099511628211ull; nz += m[i] != 0; }
-        printf("fd %s ino %lu size %ld hash %016llx nz %u\n", e->d_name, (unsigned long)st.st_ino, (long)st.st_size,
-               (unsigned long long)h, nz);
-        munmap((void*)m, st.st_size); close(fd);
-    }
-    return 0;
-}

.claude/skills/anland-mobilegl-plasma/scripts/probes/gpuprobe.c

@@ -1,55 +0,0 @@
-// gpuprobe - a plain Android process (outside MobileGL) that measures whether the GPU keeps executing
-// other contexts' work: a pbuffer GLES context clears + draws and glFinish()es every ~10 ms, printing any
-// round trip over 50 ms with a CLOCK_REALTIME timestamp.  Usage: gpuprobe <seconds> [priority: low|med|high]
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <GLES3/gl3.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <unistd.h>
-
-#ifndef EGL_CONTEXT_PRIORITY_LEVEL_IMG
-#define EGL_CONTEXT_PRIORITY_LEVEL_IMG 0x3100
-#define EGL_CONTEXT_PRIORITY_HIGH_IMG 0x3101
-#define EGL_CONTEXT_PRIORITY_MEDIUM_IMG 0x3102
-#define EGL_CONTEXT_PRIORITY_LOW_IMG 0x3103
-#endif
-
-static double now_ms(void) { struct timespec ts; clock_gettime(CLOCK_REALTIME, &ts); return ts.tv_sec * 1e3 + ts.tv_nsec / 1e6; }
-
-int main(int argc, char** argv) {
-    int seconds = argc > 1 ? atoi(argv[1]) : 20;
-    EGLint prio = EGL_CONTEXT_PRIORITY_MEDIUM_IMG;
-    if (argc > 2 && !strcmp(argv[2], "high")) prio = EGL_CONTEXT_PRIORITY_HIGH_IMG;
-    if (argc > 2 && !strcmp(argv[2], "low")) prio = EGL_CONTEXT_PRIORITY_LOW_IMG;
-    setvbuf(stdout, NULL, _IOLBF, 0);
-    EGLDisplay d = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-    eglInitialize(d, NULL, NULL);
-    const EGLint ca[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, EGL_RED_SIZE, 8, EGL_NONE};
-    EGLConfig c; EGLint n;
-    eglChooseConfig(d, ca, &c, 1, &n);
-    const EGLint pa[] = {EGL_WIDTH, 256, EGL_HEIGHT, 256, EGL_NONE};
-    EGLSurface s = eglCreatePbufferSurface(d, c, pa);
-    const EGLint xa[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_CONTEXT_PRIORITY_LEVEL_IMG, prio, EGL_NONE};
-    EGLContext x = eglCreateContext(d, c, EGL_NO_CONTEXT, xa);
-    if (x == EGL_NO_CONTEXT) { printf("no ctx 0x%x\n", eglGetError()); return 1; }
-    eglMakeCurrent(d, s, s, x);
-    EGLint got = 0; eglQueryContext(d, x, EGL_CONTEXT_PRIORITY_LEVEL_IMG, &got);
-    const double t0 = now_ms(); double maxRt = 0; long iters = 0, slow = 0;
-    printf("[probe] start %.0f prio=0x%x\n", t0, got);
-    while (now_ms() - t0 < seconds * 1000.0) {
-        const double a = now_ms();
-        glClearColor((iters & 1) ? 1.f : 0.f, 0.f, 0.f, 1.f);
-        glClear(GL_COLOR_BUFFER_BIT);
-        glFinish();
-        const double rt = now_ms() - a;
-        if (rt > maxRt) maxRt = rt;
-        if (rt > 50) { ++slow; printf("[probe] glFinish %.0f ms ending at %.0f\n", rt, now_ms()); }
-        ++iters;
-        usleep(10000);
-    }
-    printf("[probe] END iters=%ld max=%.0f ms slow=%ld\n", iters, maxRt, slow);
-    return 0;
-}

.claude/skills/anland-mobilegl-plasma/scripts/probes/hangclient.c

@@ -1,150 +0,0 @@
-// hangclient - a Wayland xdg-toplevel, EGL + desktop GL 3.3 core client that animates and, on request,
-// submits fragment work that never ends (the driver has to reset it).  Prints per-frame gaps so the same
-// binary measures "other app" frame pacing (frame callbacks come from the compositor) when run with -H -1.
-//
-//   hangclient -T tag [-H hang_at_frame] [-N hang_repeat] [-I iters] [-S seconds] [-W w] [-X h] [-F]
-//     -H n   frame at which the hanging draw is submitted (-1: never; default -1)
-//     -N k   how many consecutive hanging frames (default 1)
-//     -E e   re-arm a hang every e frames after the first (0: once)
-//     -I i   loop count of the hanging shader (default 2^31-1)
-//     -S s   run time in seconds (default 30)
-//     -F     glFinish after every frame (puts the wait inside the client's own session)
-#define GL_GLEXT_PROTOTYPES 1
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <GL/glcorearb.h>
-#include <wayland-client.h>
-#include <wayland-egl.h>
-#include "xdg-shell-client-protocol.h"
-#include <math.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <unistd.h>
-
-static struct wl_compositor* g_comp;
-static struct xdg_wm_base* g_wm;
-static int g_configured, g_closed;
-static int g_w = 480, g_h = 360;
-
-static void reg_global(void* d, struct wl_registry* r, uint32_t name, const char* iface, uint32_t ver) {
-    (void)d;
-    if (!strcmp(iface, "wl_compositor")) g_comp = wl_registry_bind(r, name, &wl_compositor_interface, 4);
-    else if (!strcmp(iface, "xdg_wm_base")) g_wm = wl_registry_bind(r, name, &xdg_wm_base_interface, 1);
-}
-static void reg_remove(void* d, struct wl_registry* r, uint32_t n) { (void)d; (void)r; (void)n; }
-static const struct wl_registry_listener reg_l = {reg_global, reg_remove};
-static void wm_ping(void* d, struct xdg_wm_base* wm, uint32_t s) { (void)d; xdg_wm_base_pong(wm, s); }
-static const struct xdg_wm_base_listener wm_l = {wm_ping};
-static void xs_conf(void* d, struct xdg_surface* s, uint32_t serial) { (void)d; xdg_surface_ack_configure(s, serial); g_configured = 1; }
-static const struct xdg_surface_listener xs_l = {xs_conf};
-static void tl_conf(void* d, struct xdg_toplevel* t, int32_t w, int32_t h, struct wl_array* st) { (void)d; (void)t; (void)st; (void)w; (void)h; }
-static void tl_close(void* d, struct xdg_toplevel* t) { (void)d; (void)t; g_closed = 1; }
-static const struct xdg_toplevel_listener tl_l = {tl_conf, tl_close};
-
-static double now_ms(void) { struct timespec ts; clock_gettime(CLOCK_REALTIME, &ts); return ts.tv_sec * 1e3 + ts.tv_nsec / 1e6; }
-
-static GLuint sh(GLenum type, const char* src) {
-    GLuint s = glCreateShader(type);
-    glShaderSource(s, 1, &src, NULL);
-    glCompileShader(s);
-    GLint ok = 0; glGetShaderiv(s, GL_COMPILE_STATUS, &ok);
-    if (!ok) { char log[2048]; glGetShaderInfoLog(s, sizeof log, NULL, log); fprintf(stderr, "shader: %s\n", log); exit(2); }
-    return s;
-}
-
-int main(int argc, char** argv) {
-    const char* tag = "hc"; int hangAt = -1, hangN = 1, every = 0, seconds = 30, finish = 0; long iters = 2147483647L;
-    for (int i = 1; i < argc; ++i) {
-        if (!strcmp(argv[i], "-T") && i + 1 < argc) tag = argv[++i];
-        else if (!strcmp(argv[i], "-H") && i + 1 < argc) hangAt = atoi(argv[++i]);
-        else if (!strcmp(argv[i], "-N") && i + 1 < argc) hangN = atoi(argv[++i]);
-        else if (!strcmp(argv[i], "-E") && i + 1 < argc) every = atoi(argv[++i]);
-        else if (!strcmp(argv[i], "-I") && i + 1 < argc) iters = atol(argv[++i]);
-        else if (!strcmp(argv[i], "-S") && i + 1 < argc) seconds = atoi(argv[++i]);
-        else if (!strcmp(argv[i], "-W") && i + 1 < argc) g_w = atoi(argv[++i]);
-        else if (!strcmp(argv[i], "-X") && i + 1 < argc) g_h = atoi(argv[++i]);
-        else if (!strcmp(argv[i], "-F")) finish = 1;
-    }
-    setvbuf(stdout, NULL, _IOLBF, 0);
-    struct wl_display* dpy = wl_display_connect(NULL);
-    if (!dpy) { fprintf(stderr, "no wayland\n"); return 1; }
-    struct wl_registry* reg = wl_display_get_registry(dpy);
-    wl_registry_add_listener(reg, &reg_l, NULL);
-    wl_display_roundtrip(dpy);
-    if (!g_comp || !g_wm) { fprintf(stderr, "no compositor/xdg_wm_base\n"); return 1; }
-    xdg_wm_base_add_listener(g_wm, &wm_l, NULL);
-    struct wl_surface* surf = wl_compositor_create_surface(g_comp);
-    struct xdg_surface* xs = xdg_wm_base_get_xdg_surface(g_wm, surf);
-    xdg_surface_add_listener(xs, &xs_l, NULL);
-    struct xdg_toplevel* tl = xdg_surface_get_toplevel(xs);
-    xdg_toplevel_add_listener(tl, &tl_l, NULL);
-    xdg_toplevel_set_title(tl, tag);
-    wl_surface_commit(surf);
-    while (!g_configured) wl_display_dispatch(dpy);
-
-    EGLDisplay ed = eglGetPlatformDisplay(EGL_PLATFORM_WAYLAND_KHR, dpy, NULL);
-    if (!eglInitialize(ed, NULL, NULL)) { fprintf(stderr, "eglInitialize\n"); return 1; }
-    eglBindAPI(EGL_OPENGL_API);
-    const EGLint ca[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT, EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_NONE};
-    EGLConfig cfg; EGLint n = 0;
-    if (!eglChooseConfig(ed, ca, &cfg, 1, &n) || n < 1) { fprintf(stderr, "no config\n"); return 1; }
-    const EGLint xa[] = {EGL_CONTEXT_MAJOR_VERSION, 3, EGL_CONTEXT_MINOR_VERSION, 3, EGL_CONTEXT_OPENGL_PROFILE_MASK, EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT, EGL_NONE};
-    EGLContext ctx = eglCreateContext(ed, cfg, EGL_NO_CONTEXT, xa);
-    if (ctx == EGL_NO_CONTEXT) { fprintf(stderr, "no context 0x%x\n", eglGetError()); return 1; }
-    struct wl_egl_window* ew = wl_egl_window_create(surf, g_w, g_h);
-    EGLSurface es = eglCreatePlatformWindowSurface(ed, cfg, ew, NULL);
-    eglMakeCurrent(ed, es, es, ctx);
-    eglSwapInterval(ed, 1);
-
-    const char* vs = "#version 330 core\nlayout(location=0) in vec2 p; uniform float t; out vec2 uv;\n"
-                     "void main(){ uv=p*0.5+0.5; gl_Position=vec4(p*0.4+vec2(0.5*sin(t),0.0),0.0,1.0);}";
-    const char* fs = "#version 330 core\nin vec2 uv; uniform int iters; uniform float t; out vec4 c;\n"
-                     "void main(){ float a=uv.x; for(int i=0;i<iters;++i){ a=fract(a*1.0001+0.37+uv.y); }\n"
-                     " c=vec4(uv, 0.5+0.5*sin(t)+a*1e-6, 1.0);}";
-    GLuint prog = glCreateProgram();
-    glAttachShader(prog, sh(GL_VERTEX_SHADER, vs));
-    glAttachShader(prog, sh(GL_FRAGMENT_SHADER, fs));
-    glLinkProgram(prog);
-    GLint ok = 0; glGetProgramiv(prog, GL_LINK_STATUS, &ok);
-    if (!ok) { fprintf(stderr, "link failed\n"); return 2; }
-    GLint uIt = glGetUniformLocation(prog, "iters"), uT = glGetUniformLocation(prog, "t");
-    GLuint vao, vbo; glGenVertexArrays(1, &vao); glBindVertexArray(vao);
-    const float q[] = {-1, -1, 1, -1, -1, 1, 1, 1};
-    glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof q, q, GL_STATIC_DRAW);
-    glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
-
-    const double t0 = now_ms(); double last = t0, maxGap = 0; long frames = 0, gaps100 = 0;
-    printf("[%s] start %.0f renderer=%s hangAt=%d N=%d every=%d iters=%ld\n", tag, t0, glGetString(GL_RENDERER), hangAt, hangN, every, iters);
-    while (!g_closed && now_ms() - t0 < seconds * 1000.0) {
-        wl_display_dispatch_pending(dpy);
-        const double t = (now_ms() - t0) / 1000.0;
-        int hang = 0;
-        if (hangAt >= 0 && frames >= hangAt) {
-            long rel = frames - hangAt;
-            if (every > 0) rel %= every;
-            hang = rel < hangN;
-        }
-        glViewport(0, 0, g_w, g_h);
-        glClearColor(0.5f + 0.5f * (float)sin(t * 3.0), 0.2f, 0.4f, 1.0f);
-        glClear(GL_COLOR_BUFFER_BIT);
-        glUseProgram(prog);
-        glUniform1i(uIt, hang ? (int)iters : 0);
-        glUniform1f(uT, (float)t);
-        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-        if (hang) printf("[%s] HANG submitted frame %ld at %.0f\n", tag, frames, now_ms());
-        if (finish) glFinish();
-        if (!eglSwapBuffers(ed, es)) printf("[%s] swap failed 0x%x at %.0f\n", tag, eglGetError(), now_ms());
-        const GLenum rs = glGetError();
-        if (rs != GL_NO_ERROR) printf("[%s] glGetError 0x%x at %.0f\n", tag, rs, now_ms());
-        const double nowv = now_ms(), gap = nowv - last;
-        last = nowv; ++frames;
-        if (gap > maxGap) maxGap = gap;
-        if (gap > 100.0) { ++gaps100; printf("[%s] GAP %.0f ms ending at %.0f (frame %ld)\n", tag, gap, nowv, frames); }
-        if (frames % 120 == 0) printf("[%s] frame %ld t=%.1fs fps=%.1f\n", tag, frames, (nowv - t0) / 1e3, frames * 1e3 / (nowv - t0));
-    }
-    const double total = now_ms() - t0;
-    printf("[%s] END frames=%ld fps=%.1f maxGap=%.0f ms gaps>100ms=%ld\n", tag, frames, frames * 1e3 / total, maxGap, gaps100);
-    return 0;
-}

.claude/skills/anland-mobilegl-plasma/scripts/probes/texfmt.c

@@ -1,95 +0,0 @@
-/* texfmt: does a texture keep its alpha? One opaque red texel and one transparent texel per
- * format, sampled across a 64x64 ES3 pbuffer cleared white with SRC_ALPHA blending. Expect the
- * left half red and the right half WHITE; a black right half means the alpha was lost. */
-#include <EGL/egl.h>
-#include <GLES3/gl3.h>
-#include <GLES2/gl2ext.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#define P(T, n) T n = (T)eglGetProcAddress(#n)
-static const char* vs = "#version 300 es\nlayout(location=0) in vec2 p; out vec2 uv; void main(){uv=p*0.5+0.5; gl_Position=vec4(p,0,1);}";
-static const char* fs = "#version 300 es\nprecision mediump float; uniform sampler2D t; uniform int mode; in vec2 uv; out vec4 o;"
-                        "void main(){vec4 c=texture(t,uv); o = mode==1 ? vec4(1.0,0.0,0.0,c.a) : (mode==2 ? vec4(c.r,0.0,0.0,c.r) : c);}";
-int main(void) {
-    EGLDisplay d = eglGetDisplay(EGL_DEFAULT_DISPLAY); eglInitialize(d, 0, 0); eglBindAPI(EGL_OPENGL_ES_API);
-    EGLint ca[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8, EGL_NONE};
-    EGLConfig c; EGLint n; eglChooseConfig(d, ca, &c, 1, &n);
-    EGLint xa[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
-    EGLContext x = eglCreateContext(d, c, EGL_NO_CONTEXT, xa);
-    EGLint pa[] = {EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE};
-    EGLSurface s = eglCreatePbufferSurface(d, c, pa); eglMakeCurrent(d, s, s, x);
-    P(PFNGLCREATESHADERPROC, glCreateShader); P(PFNGLSHADERSOURCEPROC, glShaderSource); P(PFNGLCOMPILESHADERPROC, glCompileShader);
-    P(PFNGLCREATEPROGRAMPROC, glCreateProgram); P(PFNGLATTACHSHADERPROC, glAttachShader); P(PFNGLLINKPROGRAMPROC, glLinkProgram);
-    P(PFNGLUSEPROGRAMPROC, glUseProgram); P(PFNGLGETUNIFORMLOCATIONPROC, glGetUniformLocation); P(PFNGLUNIFORM1IPROC, glUniform1i);
-    P(PFNGLGENBUFFERSPROC, glGenBuffers); P(PFNGLBINDBUFFERPROC, glBindBuffer); P(PFNGLBUFFERDATAPROC, glBufferData);
-    P(PFNGLVERTEXATTRIBPOINTERPROC, glVertexAttribPointer); P(PFNGLENABLEVERTEXATTRIBARRAYPROC, glEnableVertexAttribArray);
-    P(PFNGLDRAWARRAYSPROC, glDrawArrays); P(PFNGLCLEARCOLORPROC, glClearColor); P(PFNGLCLEARPROC, glClear);
-    P(PFNGLREADPIXELSPROC, glReadPixels); P(PFNGLVIEWPORTPROC, glViewport); P(PFNGLGENTEXTURESPROC, glGenTextures);
-    P(PFNGLBINDTEXTUREPROC, glBindTexture); P(PFNGLTEXIMAGE2DPROC, glTexImage2D); P(PFNGLTEXPARAMETERIPROC, glTexParameteri);
-    P(PFNGLENABLEPROC, glEnable); P(PFNGLBLENDFUNCPROC, glBlendFunc); P(PFNGLGETERRORPROC, glGetError);
-    P(PFNGLTEXSTORAGE2DPROC, glTexStorage2D); P(PFNGLTEXSUBIMAGE2DPROC, glTexSubImage2D); P(PFNGLGETSTRINGPROC, glGetString);
-    printf("GL_VERSION %s\n", glGetString(GL_VERSION));
-    printf("BGRA ext: %s\n", strstr((const char*)glGetString(GL_EXTENSIONS), "GL_EXT_texture_format_BGRA8888") ? "yes" : "no");
-    GLuint v = glCreateShader(GL_VERTEX_SHADER), f = glCreateShader(GL_FRAGMENT_SHADER);
-    glShaderSource(v, 1, &vs, 0); glCompileShader(v); glShaderSource(f, 1, &fs, 0); glCompileShader(f);
-    GLuint pr = glCreateProgram(); glAttachShader(pr, v); glAttachShader(pr, f); glLinkProgram(pr); glUseProgram(pr);
-    float q[] = {-1,-1, 1,-1, -1,1, 1,1};
-    GLuint vbo; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo);
-    glBufferData(GL_ARRAY_BUFFER, sizeof q, q, GL_STATIC_DRAW); glVertexAttribPointer(0, 2, GL_FLOAT, 0, 0, 0); glEnableVertexAttribArray(0);
-    GLint lm = glGetUniformLocation(pr, "mode");
-    glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-    struct { const char* name; GLint ifmt; GLenum fmt; int bpp; int mode; int storage; GLenum sized; unsigned char px[8]; } cases[] = {
-        {"RGBA/TexImage", GL_RGBA, GL_RGBA, 4, 0, 0, 0, {255,0,0,255, 0,0,0,0}},
-        {"BGRA_EXT/TexImage", GL_BGRA_EXT, GL_BGRA_EXT, 4, 0, 0, 0, {0,0,255,255, 0,0,0,0}},
-        {"BGRA8_EXT/TexStorage+Sub", 0, GL_BGRA_EXT, 4, 0, 1, GL_BGRA8_EXT, {0,0,255,255, 0,0,0,0}},
-        {"RGBA8/TexStorage+Sub", 0, GL_RGBA, 4, 0, 1, GL_RGBA8, {255,0,0,255, 0,0,0,0}},
-        {"ALPHA", GL_ALPHA, GL_ALPHA, 1, 1, 0, 0, {255, 0}},
-        {"LUMINANCE_ALPHA", GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, 2, 1, 0, 0, {255,255, 0,0}},
-        {"R8/TexStorage+Sub", 0, GL_RED, 1, 2, 1, GL_R8, {255, 0}},
-    };
-    for (unsigned i = 0; i < sizeof cases / sizeof cases[0]; ++i) {
-        GLuint t; glGenTextures(1, &t); glBindTexture(GL_TEXTURE_2D, t);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        while (glGetError()) {}
-        if (cases[i].storage) {
-            glTexStorage2D(GL_TEXTURE_2D, 1, cases[i].sized, 2, 1);
-            glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 1, cases[i].fmt, GL_UNSIGNED_BYTE, cases[i].px);
-        } else {
-            glTexImage2D(GL_TEXTURE_2D, 0, cases[i].ifmt, 2, 1, 0, cases[i].fmt, GL_UNSIGNED_BYTE, cases[i].px);
-        }
-        GLenum err = glGetError();
-        glUniform1i(lm, cases[i].mode);
-        glViewport(0, 0, 64, 64); glClearColor(1, 1, 1, 1); glClear(GL_COLOR_BUFFER_BIT);
-        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-        unsigned char l[4], r[4];
-        glReadPixels(16, 32, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, l); glReadPixels(48, 32, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, r);
-        const int ok = l[0] > 200 && l[1] < 60 && l[2] < 60 && r[0] > 200 && r[1] > 200 && r[2] > 200;
-        printf("%-26s err=0x%04x left=%3d,%3d,%3d right=%3d,%3d,%3d %s\n", cases[i].name, err, l[0], l[1], l[2], r[0], r[1], r[2], ok ? "ok" : "BAD");
-    }
-    /* ANGLE's emulation of ALPHA8 / LUMINANCE_ALPHA8 on a desktop-GL driver: R8 / RG8 + swizzle. */
-    P(PFNGLTEXPARAMETERIPROC, glTexParameteri2);
-    struct { const char* name; GLenum sized, fmt; int bpp; GLint sw[4]; unsigned char px[4]; unsigned char wantL[3], wantR[3]; } sz[] = {
-        {"R8 swizzled as ALPHA8", GL_R8, GL_RED, 1, {GL_ZERO, GL_ZERO, GL_ZERO, GL_RED}, {255, 0}, {0,0,0}, {255,255,255}},
-        {"RG8 swizzled as LUM_ALPHA", GL_RG8, GL_RG, 2, {GL_RED, GL_RED, GL_RED, GL_GREEN}, {255,255, 0,0}, {255,255,255}, {255,255,255}},
-        {"RG8 as LUM_ALPHA (lum 0)", GL_RG8, GL_RG, 2, {GL_RED, GL_RED, GL_RED, GL_GREEN}, {0,255, 0,0}, {0,0,0}, {255,255,255}},
-    };
-    glUniform1i(lm, 0);
-    for (unsigned i = 0; i < sizeof sz / sizeof sz[0]; ++i) {
-        GLuint t; glGenTextures(1, &t); glBindTexture(GL_TEXTURE_2D, t);
-        glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        glTexStorage2D(GL_TEXTURE_2D, 1, sz[i].sized, 2, 1);
-        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 2, 1, sz[i].fmt, GL_UNSIGNED_BYTE, sz[i].px);
-        glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, sz[i].sw[0]); glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, sz[i].sw[1]);
-        glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, sz[i].sw[2]); glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, sz[i].sw[3]);
-        GLenum err = glGetError();
-        glClearColor(1, 1, 1, 1); glClear(GL_COLOR_BUFFER_BIT); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-        unsigned char l[4], r[4];
-        glReadPixels(16, 32, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, l); glReadPixels(48, 32, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, r);
-        int ok = 1;
-        for (int k = 0; k < 3; ++k) ok = ok && abs(l[k] - sz[i].wantL[k]) < 40 && abs(r[k] - sz[i].wantR[k]) < 40;
-        printf("%-26s err=0x%04x left=%3d,%3d,%3d right=%3d,%3d,%3d %s\n", sz[i].name, err, l[0], l[1], l[2], r[0], r[1], r[2], ok ? "ok" : "BAD");
-    }
-    return 0;
-}

.claude/skills/anland-mobilegl-plasma/scripts/probes/yuvprobe.c

@@ -1,410 +0,0 @@
-// yuvprobe.c - pixel check of YUV dma-buf sampling through MobileGL (GL_OES_EGL_image_external).
-//
-//   gcc -O1 yuvprobe.c -o /usr/local/bin/mgl-yuvprobe -lEGL -lGLESv2 -lgbm
-//   mgrun offscreen mgl-yuvprobe            # exit 0 = every check passed
-//
-// What it does, in an ES 3.0 context on a pbuffer:
-//   1. FOREIGN NV12 (and P010): a dma-buf from /dev/dma_heap/system - a buffer the MobileGL server
-//      did not allocate, as a video decoder's would be - with padded pitches and a gap before the
-//      chroma plane, filled with four vertical bars (red, green, blue, white) in BT.709 narrow
-//      range. Imported with eglCreateImage(EGL_LINUX_DMA_BUF_EXT) and its colour hints, bound to
-//      GL_TEXTURE_EXTERNAL_OES, drawn through a samplerExternalOES shader into an RGBA8 FBO and read
-//      back: each bar must come out its colour. The buffer is then rewritten with the bars in
-//      reverse order and, after a native fence (what ends a frame for an offscreen producer), drawn
-//      again: the new order must show (the server refreshes a foreign buffer at each frame).
-//   2. GBM NV12: gbm_bo_create(NV12) through the mobilegl GBM backend (a server-allocated YUV
-//      buffer, zero-copy), its planes printed, imported and sampled once (content undefined; the
-//      check is that every call succeeds).
-// Also prints the dma-buf formats/modifiers EGL lists for NV12/P010.
-#define _GNU_SOURCE
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <GLES3/gl3.h>
-#include <GLES2/gl2ext.h>
-#include <fcntl.h>
-#include <gbm.h>
-#include <linux/dma-buf.h>
-#include <linux/dma-heap.h>
-#include <math.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <unistd.h>
-
-#ifndef DRM_FORMAT_NV12
-#define DRM_FORMAT_NV12 0x3231564E
-#endif
-#ifndef DRM_FORMAT_P010
-#define DRM_FORMAT_P010 0x30313050
-#endif
-
-static int g_failures = 0;
-#define CHECK(cond, ...)                                                                                              \
-    do {                                                                                                               \
-        if (!(cond)) {                                                                                                 \
-            printf("FAIL: " __VA_ARGS__);                                                                              \
-            printf("\n");                                                                                              \
-            ++g_failures;                                                                                              \
-        }                                                                                                              \
-    } while (0)
-
-static PFNEGLCREATEIMAGEKHRPROC pCreateImage;
-static PFNEGLDESTROYIMAGEKHRPROC pDestroyImage;
-static PFNGLEGLIMAGETARGETTEXTURE2DOESPROC pTargetTexture;
-static PFNEGLQUERYDMABUFFORMATSEXTPROC pQueryFormats;
-static PFNEGLQUERYDMABUFMODIFIERSEXTPROC pQueryModifiers;
-static PFNEGLCREATESYNCKHRPROC pCreateSync;
-static PFNEGLDESTROYSYNCKHRPROC pDestroySync;
-static EGLDisplay g_display;
-
-enum { W = 256, H = 128, BARS = 4 };
-static const unsigned char kBars[BARS][3] = {{255, 0, 0}, {0, 255, 0}, {0, 0, 255}, {255, 255, 255}};
-
-// RGB -> BT.709 narrow-range codes at `bits` (8 or 10).
-static void Encode709(const unsigned char rgb[3], int bits, int out[3]) {
-    const double kr = 0.2126, kb = 0.0722, kg = 1.0 - kr - kb;
-    const double r = rgb[0] / 255.0, g = rgb[1] / 255.0, b = rgb[2] / 255.0;
-    const double y = kr * r + kg * g + kb * b;
-    const double cb = (b - y) / (2.0 * (1.0 - kb)), cr = (r - y) / (2.0 * (1.0 - kr));
-    const double scale = (double)(1 << (bits - 8));
-    out[0] = (int)lround((16.0 + 219.0 * y) * scale);
-    out[1] = (int)lround((128.0 + 224.0 * cb) * scale);
-    out[2] = (int)lround((128.0 + 224.0 * cr) * scale);
-}
-
-// Writes the bars (`reverse`d or not) into a semi-planar buffer: 1 byte samples, or P010's 16-bit
-// samples with the 10 significant bits high.
-static void FillBars(uint8_t* base, uint32_t pitchY, uint32_t offsetC, uint32_t pitchC, int bytes, int reverse) {
-    const int bits = bytes == 1 ? 8 : 10;
-    for (int y = 0; y < H; ++y) {
-        for (int x = 0; x < W; ++x) {
-            int bar = x * BARS / W;
-            if (reverse) bar = BARS - 1 - bar;
-            int code[3];
-            Encode709(kBars[bar], bits, code);
-            uint8_t* py = base + (size_t)y * pitchY + (size_t)x * bytes;
-            if (bytes == 1) py[0] = (uint8_t)code[0];
-            else *(uint16_t*)py = (uint16_t)(code[0] << 6);
-            if ((x & 1) == 0 && (y & 1) == 0) {
-                uint8_t* pc = base + offsetC + (size_t)(y / 2) * pitchC + (size_t)(x / 2) * 2 * bytes;
-                if (bytes == 1) {
-                    pc[0] = (uint8_t)code[1];
-                    pc[1] = (uint8_t)code[2];
-                } else {
-                    ((uint16_t*)pc)[0] = (uint16_t)(code[1] << 6);
-                    ((uint16_t*)pc)[1] = (uint16_t)(code[2] << 6);
-                }
-            }
-        }
-    }
-}
-
-static GLuint Compile(GLenum type, const char* source) {
-    GLuint shader = glCreateShader(type);
-    glShaderSource(shader, 1, &source, NULL);
-    glCompileShader(shader);
-    GLint ok = 0;
-    glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
-    if (!ok) {
-        char log[2048];
-        glGetShaderInfoLog(shader, sizeof(log), NULL, log);
-        printf("shader: %s\n", log);
-    }
-    return shader;
-}
-
-static GLuint g_program, g_fbo, g_rgba;
-
-static void SetUpDraw(void) {
-    const char* vs = "#version 300 es\n"
-                     "out vec2 uv;\n"
-                     "void main() {\n"
-                     "  vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));\n"
-                     "  gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);\n"
-                     "  uv = p;\n"
-                     "}\n";
-    const char* fs = "#version 300 es\n"
-                     "#extension GL_OES_EGL_image_external_essl3 : require\n"
-                     "precision mediump float;\n"
-                     "uniform samplerExternalOES tex;\n"
-                     "in vec2 uv;\n"
-                     "out vec4 color;\n"
-                     "void main() { color = texture(tex, uv); }\n";
-    g_program = glCreateProgram();
-    glAttachShader(g_program, Compile(GL_VERTEX_SHADER, vs));
-    glAttachShader(g_program, Compile(GL_FRAGMENT_SHADER, fs));
-    glLinkProgram(g_program);
-    GLint linked = 0;
-    glGetProgramiv(g_program, GL_LINK_STATUS, &linked);
-    CHECK(linked, "the samplerExternalOES program did not link");
-    GLint type = 0, size = 0;
-    char name[64];
-    glGetActiveUniform(g_program, 0, sizeof(name), NULL, &size, (GLenum*)&type, name);
-    printf("uniform 0: %s type 0x%04x\n", name, type);
-    CHECK(type == GL_SAMPLER_EXTERNAL_OES, "the sampler reports type 0x%04x, not GL_SAMPLER_EXTERNAL_OES", type);
-    glGenTextures(1, &g_rgba);
-    glBindTexture(GL_TEXTURE_2D, g_rgba);
-    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, W, H);
-    glGenFramebuffers(1, &g_fbo);
-    glBindFramebuffer(GL_FRAMEBUFFER, g_fbo);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, g_rgba, 0);
-    CHECK(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE, "the readback FBO is incomplete");
-    GLuint vao;
-    glGenVertexArrays(1, &vao);
-    glBindVertexArray(vao);
-}
-
-// Draws the external texture `texture` and checks each bar's center (row `y` of the image).
-static void DrawAndCheck(GLuint texture, const char* what, int reverse, int tolerance) {
-    glBindFramebuffer(GL_FRAMEBUFFER, g_fbo);
-    glViewport(0, 0, W, H);
-    glUseProgram(g_program);
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
-    glUniform1i(glGetUniformLocation(g_program, "tex"), 0);
-    glDrawArrays(GL_TRIANGLES, 0, 3);
-    static unsigned char pixels[W * H * 4];
-    glReadPixels(0, 0, W, H, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
-    GLenum error = glGetError();
-    CHECK(error == GL_NO_ERROR, "%s: GL error 0x%04x", what, error);
-    if (tolerance < 0) {
-        printf("%s: center pixel %d %d %d %d (content undefined)\n", what, pixels[(H / 2 * W + W / 2) * 4],
-               pixels[(H / 2 * W + W / 2) * 4 + 1], pixels[(H / 2 * W + W / 2) * 4 + 2],
-               pixels[(H / 2 * W + W / 2) * 4 + 3]);
-        return;
-    }
-    // Rows: GL row 0 is the image's first row (the uv mapping above), and the bars are vertical,
-    // so any row does; take two to catch a broken chroma row pitch.
-    const int rows[2] = {H / 4, (3 * H) / 4};
-    for (int r = 0; r < 2; ++r) {
-        for (int bar = 0; bar < BARS; ++bar) {
-            const int x = bar * (W / BARS) + W / (2 * BARS);
-            const unsigned char* p = &pixels[(rows[r] * W + x) * 4];
-            const unsigned char* want = kBars[reverse ? BARS - 1 - bar : bar];
-            int worst = 0;
-            for (int c = 0; c < 3; ++c) {
-                int d = abs((int)p[c] - (int)want[c]);
-                if (d > worst) worst = d;
-            }
-            printf("%s: row %d bar %d -> %3d %3d %3d %3d (want %3d %3d %3d)%s\n", what, rows[r], bar, p[0], p[1], p[2],
-                   p[3], want[0], want[1], want[2], worst > tolerance ? "  <-- off" : "");
-            CHECK(worst <= tolerance, "%s: bar %d is off by %d", what, bar, worst);
-        }
-    }
-}
-
-static int AllocateDmaHeap(size_t size) {
-    int heap = open("/dev/dma_heap/system", O_RDWR | O_CLOEXEC);
-    if (heap < 0) {
-        perror("open /dev/dma_heap/system");
-        return -1;
-    }
-    struct dma_heap_allocation_data data = {.len = size, .fd_flags = O_RDWR | O_CLOEXEC};
-    if (ioctl(heap, DMA_HEAP_IOCTL_ALLOC, &data) != 0) {
-        perror("DMA_HEAP_IOCTL_ALLOC");
-        close(heap);
-        return -1;
-    }
-    close(heap);
-    return (int)data.fd;
-}
-
-static void Sync(int fd, int start) {
-    struct dma_buf_sync sync = {.flags = DMA_BUF_SYNC_WRITE | (start ? DMA_BUF_SYNC_START : DMA_BUF_SYNC_END)};
-    ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync);
-}
-
-static EGLImageKHR Import(int fd, uint32_t fourcc, uint32_t pitchY, uint32_t offsetC, uint32_t pitchC, int modifier) {
-    EGLint attribs[64];
-    int n = 0;
-#define A(k, v) (attribs[n++] = (k), attribs[n++] = (EGLint)(v))
-    A(EGL_WIDTH, W);
-    A(EGL_HEIGHT, H);
-    A(EGL_LINUX_DRM_FOURCC_EXT, fourcc);
-    A(EGL_DMA_BUF_PLANE0_FD_EXT, fd);
-    A(EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0);
-    A(EGL_DMA_BUF_PLANE0_PITCH_EXT, pitchY);
-    A(EGL_DMA_BUF_PLANE1_FD_EXT, fd);
-    A(EGL_DMA_BUF_PLANE1_OFFSET_EXT, offsetC);
-    A(EGL_DMA_BUF_PLANE1_PITCH_EXT, pitchC);
-    if (modifier) {
-        A(EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT, 0);
-        A(EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT, 0);
-        A(EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT, 0);
-        A(EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT, 0);
-    }
-    A(EGL_YUV_COLOR_SPACE_HINT_EXT, EGL_ITU_REC709_EXT);
-    A(EGL_SAMPLE_RANGE_HINT_EXT, EGL_YUV_NARROW_RANGE_EXT);
-    attribs[n] = EGL_NONE;
-#undef A
-    EGLImageKHR image = pCreateImage(g_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, attribs);
-    if (image == EGL_NO_IMAGE_KHR) printf("eglCreateImage failed: 0x%04x\n", eglGetError());
-    return image;
-}
-
-static GLuint ExternalTexture(EGLImageKHR image) {
-    GLuint texture;
-    glGenTextures(1, &texture);
-    glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
-    pTargetTexture(GL_TEXTURE_EXTERNAL_OES, image);
-    GLenum error = glGetError();
-    CHECK(error == GL_NO_ERROR, "glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES) -> 0x%04x", error);
-    GLint bound = 0;
-    glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &bound);
-    CHECK((GLuint)bound == texture, "GL_TEXTURE_BINDING_EXTERNAL_OES reads %d", bound);
-    return texture;
-}
-
-// A frame boundary as an offscreen producer makes one: a native fence.
-static void EndFrame(void) {
-    EGLint attribs[] = {EGL_NONE};
-    EGLSyncKHR sync = pCreateSync(g_display, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
-    CHECK(sync != EGL_NO_SYNC_KHR, "eglCreateSync(native fence) failed");
-    if (sync != EGL_NO_SYNC_KHR) pDestroySync(g_display, sync);
-}
-
-static void ForeignTest(uint32_t fourcc, int bytes, int tolerance) {
-    const char* what = fourcc == DRM_FORMAT_NV12 ? "foreign NV12" : "foreign P010";
-    // Padded pitches and a gap before the chroma plane, as decoders lay buffers out.
-    const uint32_t pitchY = W * bytes + 64, pitchC = W * bytes + 128;
-    const uint32_t offsetC = pitchY * (H + 16);
-    const size_t size = offsetC + (size_t)pitchC * (H / 2) + 4096;
-    int fd = AllocateDmaHeap(size);
-    if (fd < 0) {
-        CHECK(0, "%s: no dma-buf to test with", what);
-        return;
-    }
-    uint8_t* map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
-    CHECK(map != MAP_FAILED, "%s: mmap failed", what);
-    if (map == MAP_FAILED) return;
-    Sync(fd, 1);
-    FillBars(map, pitchY, offsetC, pitchC, bytes, 0);
-    Sync(fd, 0);
-    EGLImageKHR image = Import(fd, fourcc, pitchY, offsetC, pitchC, fourcc == DRM_FORMAT_NV12);
-    CHECK(image != EGL_NO_IMAGE_KHR, "%s: import refused", what);
-    if (image == EGL_NO_IMAGE_KHR) return;
-    GLuint texture = ExternalTexture(image);
-    DrawAndCheck(texture, what, 0, tolerance);
-    EndFrame();
-    // New content, same buffer: shows after the frame boundary.
-    Sync(fd, 1);
-    FillBars(map, pitchY, offsetC, pitchC, bytes, 1);
-    Sync(fd, 0);
-    EndFrame();
-    DrawAndCheck(texture, what, 1, tolerance);
-    glDeleteTextures(1, &texture);
-    pDestroyImage(g_display, image);
-    munmap(map, size);
-    close(fd);
-}
-
-static void GbmTest(void) {
-    int node = open("/dev/dri/renderD128", O_RDWR | O_CLOEXEC);
-    if (node < 0) node = open("/dev/null", O_RDWR | O_CLOEXEC);
-    struct gbm_device* gbm = gbm_create_device(node);
-    if (gbm == NULL) {
-        CHECK(0, "gbm_create_device failed");
-        return;
-    }
-    printf("gbm backend: %s\n", gbm_device_get_backend_name(gbm));
-    const int supported = gbm_device_is_format_supported(gbm, DRM_FORMAT_NV12, 0);
-    printf("gbm NV12 supported: %d, P010: %d\n", supported,
-           gbm_device_is_format_supported(gbm, DRM_FORMAT_P010, 0));
-    CHECK(supported == 1, "gbm does not support NV12");
-    struct gbm_bo* bo = gbm_bo_create(gbm, W, H, DRM_FORMAT_NV12, 0);
-    CHECK(bo != NULL, "gbm_bo_create(NV12) failed");
-    if (bo != NULL) {
-        const int planes = gbm_bo_get_plane_count(bo);
-        printf("gbm NV12 bo: planes %d, stride %u/%u, offset %u/%u, modifier 0x%llx\n", planes,
-               gbm_bo_get_stride_for_plane(bo, 0), gbm_bo_get_stride_for_plane(bo, 1), gbm_bo_get_offset(bo, 0),
-               gbm_bo_get_offset(bo, 1), (unsigned long long)gbm_bo_get_modifier(bo));
-        CHECK(planes == 2, "the NV12 bo has %d planes", planes);
-        int fd = gbm_bo_get_fd(bo);
-        EGLImageKHR image =
-            Import(fd, DRM_FORMAT_NV12, gbm_bo_get_stride_for_plane(bo, 0), gbm_bo_get_offset(bo, 1),
-                   gbm_bo_get_stride_for_plane(bo, 1), 0);
-        CHECK(image != EGL_NO_IMAGE_KHR, "the server's own NV12 buffer was not imported");
-        if (image != EGL_NO_IMAGE_KHR) {
-            GLuint texture = ExternalTexture(image);
-            DrawAndCheck(texture, "gbm NV12", 0, -1);
-            glDeleteTextures(1, &texture);
-            pDestroyImage(g_display, image);
-        }
-        close(fd);
-        gbm_bo_destroy(bo);
-    }
-    gbm_device_destroy(gbm);
-    close(node);
-}
-
-int main(void) {
-    setvbuf(stdout, NULL, _IONBF, 0);
-    g_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-    EGLint major, minor;
-    if (!eglInitialize(g_display, &major, &minor)) {
-        printf("FAIL: eglInitialize\n");
-        return 2;
-    }
-    const char* eglExtensions = eglQueryString(g_display, EGL_EXTENSIONS);
-    printf("EGL %d.%d dma_buf_import: %s\n", major, minor,
-           strstr(eglExtensions, "EGL_EXT_image_dma_buf_import") ? "yes" : "no");
-    eglBindAPI(EGL_OPENGL_ES_API);
-    const EGLint configAttribs[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT,
-                                    EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_NONE};
-    EGLConfig config;
-    EGLint count = 0;
-    eglChooseConfig(g_display, configAttribs, &config, 1, &count);
-    if (count < 1) {
-        printf("FAIL: no config\n");
-        return 2;
-    }
-    const EGLint pbufferAttribs[] = {EGL_WIDTH, 16, EGL_HEIGHT, 16, EGL_NONE};
-    EGLSurface surface = eglCreatePbufferSurface(g_display, config, pbufferAttribs);
-    const EGLint contextAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 3, EGL_NONE};
-    EGLContext context = eglCreateContext(g_display, config, EGL_NO_CONTEXT, contextAttribs);
-    if (context == EGL_NO_CONTEXT || !eglMakeCurrent(g_display, surface, surface, context)) {
-        printf("FAIL: no ES 3 context\n");
-        return 2;
-    }
-    pCreateImage = (PFNEGLCREATEIMAGEKHRPROC)eglGetProcAddress("eglCreateImageKHR");
-    pDestroyImage = (PFNEGLDESTROYIMAGEKHRPROC)eglGetProcAddress("eglDestroyImageKHR");
-    pTargetTexture = (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)eglGetProcAddress("glEGLImageTargetTexture2DOES");
-    pQueryFormats = (PFNEGLQUERYDMABUFFORMATSEXTPROC)eglGetProcAddress("eglQueryDmaBufFormatsEXT");
-    pQueryModifiers = (PFNEGLQUERYDMABUFMODIFIERSEXTPROC)eglGetProcAddress("eglQueryDmaBufModifiersEXT");
-    pCreateSync = (PFNEGLCREATESYNCKHRPROC)eglGetProcAddress("eglCreateSyncKHR");
-    pDestroySync = (PFNEGLDESTROYSYNCKHRPROC)eglGetProcAddress("eglDestroySyncKHR");
-    printf("GL_RENDERER: %s\n", glGetString(GL_RENDERER));
-    const char* glExtensions = (const char*)glGetString(GL_EXTENSIONS);
-    const int external = strstr(glExtensions, "GL_OES_EGL_image_external_essl3") != NULL;
-    printf("GL_OES_EGL_image_external_essl3: %s\n", external ? "yes" : "no");
-    CHECK(external, "GL_OES_EGL_image_external_essl3 is not advertised");
-
-    EGLint formats[32], formatCount = 0;
-    pQueryFormats(g_display, 32, formats, &formatCount);
-    int nv12 = 0;
-    for (int i = 0; i < formatCount; ++i) {
-        printf("dma-buf format %.4s", (const char*)&formats[i]);
-        EGLuint64KHR modifiers[4];
-        EGLBoolean externalOnly[4];
-        EGLint modifierCount = 0;
-        pQueryModifiers(g_display, formats[i], 4, modifiers, externalOnly, &modifierCount);
-        for (int m = 0; m < modifierCount; ++m)
-            printf(" [modifier 0x%llx%s]", (unsigned long long)modifiers[m], externalOnly[m] ? " external-only" : "");
-        printf("\n");
-        nv12 |= formats[i] == (EGLint)DRM_FORMAT_NV12;
-    }
-    CHECK(nv12, "NV12 is not a listed dma-buf format");
-
-    SetUpDraw();
-    ForeignTest(DRM_FORMAT_NV12, 1, 12);
-    ForeignTest(DRM_FORMAT_P010, 2, 16);
-    GbmTest();
-
-    printf("%s (%d failure(s))\n", g_failures ? "FAILED" : "PASSED", g_failures);
-    eglMakeCurrent(g_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-    eglTerminate(g_display);
-    return g_failures ? 1 : 0;
-}

.claude/skills/anland-mobilegl-plasma/scripts/push-tools.sh

@@ -1,22 +0,0 @@
-#!/usr/bin/env bash
-# push-tools.sh - install this skill's device- and container-side helpers on the phone.
-#   device/*.sh      -> $DEV_TOOLS            (run as root: adb shell 'su -c "sh $DEV_TOOLS/<x>.sh"')
-#   container/mgrun  -> <container>/usr/local/bin/mgrun
-#   container/kwprep.sh -> <container>/root/kwprep.sh
-# Needs the container running (its rootfs is mounted at $CT_ROOT only then).
-# Overwrites same-named files other sessions may be using in $DEV_TOOLS; check first on a shared phone.
-set -euo pipefail
-here=$(cd "$(dirname "$0")" && pwd)
-. "$here/env.sh"
-adb_ shell "mkdir -p $DEV_TOOLS"
-for f in "$here"/device/*.sh; do
-    tr -d '\r' < "$f" > "$ANL_DIR/push.tmp"
-    adb_ push "$ANL_DIR/push.tmp" "$DEV_TOOLS/$(basename "$f")" >/dev/null
-    echo "pushed $DEV_TOOLS/$(basename "$f")"
-done
-for f in mgrun kwprep.sh; do
-    tr -d '\r' < "$here/container/$f" > "$ANL_DIR/push.tmp"
-    adb_ push "$ANL_DIR/push.tmp" "$DEV_TOOLS/$f" >/dev/null
-done
-rm -f "$ANL_DIR/push.tmp"
-adb_ shell "su -c 'cp $DEV_TOOLS/mgrun $CT_ROOT/usr/local/bin/mgrun && chmod 755 $CT_ROOT/usr/local/bin/mgrun && cp $DEV_TOOLS/kwprep.sh $CT_ROOT/root/kwprep.sh && echo installed mgrun kwprep.sh'"

.claude/skills/anland-mobilegl-plasma/scripts/rec.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-# rec.sh <name> - record 3 s of the screen while opening Kickoff, extract frames inside the container
-# with ffmpeg, pull them to $ANL_DIR/af_<name>/ and build a 3x4 contact sheet $ANL_DIR/grid_<name>.png
-# (needs Python + Pillow on Windows).  Use it to catch flicker/black frames a single screenshot misses.
-# Env: TAP="x y" Kickoff button position (default "69 1349" = bottom-left on the 2560x1600 tablet;
-# device specific).  Note: anland grabs the touchscreen (EVIOCGRAB); if `input tap` does nothing, use
-# `input mouse tap x y`.  Env CHANNEL (default rec).
-set -euo pipefail
-here=$(cd "$(dirname "$0")" && pwd)
-. "$here/env.sh"
-N=${1:?usage: rec.sh <name>}; TAP=${TAP:-69 1349}
-adb_ shell "su -c 'input keyevent 111; sleep 1.5; (screenrecord --time-limit 3 --bit-rate 20000000 $DEV_SHARE/$N.mp4 &); sleep 0.7; input tap $TAP; sleep 3; cp $DEV_SHARE/$N.mp4 $CT_ROOT/root/$N.mp4'"
-bash "$here/ct.sh" "${CHANNEL:-rec}" <<IN
-rm -rf /root/af_$N; mkdir -p /root/af_$N; ffmpeg -loglevel quiet -i /root/$N.mp4 -vf scale=1000:-1 -fps_mode passthrough /root/af_$N/f%03d.png; ls /root/af_$N | wc -l
-IN
-adb_ shell "su -c 'rm -rf $DEV_SHARE/af_$N; cp -r $CT_ROOT/root/af_$N $DEV_SHARE/ && chmod -R 777 $DEV_SHARE/af_$N'"
-rm -rf "$ANL_DIR/af_$N"; adb_ pull "$DEV_SHARE/af_$N" "$ANL_DIR/" >/dev/null
-python - "$ANL_DIR/af_$N" "$ANL_DIR/grid_$N.png" <<'P'
-import sys, os
-from PIL import Image
-d, out = sys.argv[1], sys.argv[2]
-fs = sorted(os.listdir(d)); n = len(fs)
-pick = [fs[min(n-1, int(i * n / 12))] for i in range(12)]
-ims = [Image.open(os.path.join(d, f)) for f in pick]
-w, h = ims[0].size; tw, th = w // 2, h // 2
-g = Image.new('RGB', (tw * 3, th * 4))
-for i, im in enumerate(ims): g.paste(im.resize((tw, th)), ((i % 3) * tw, (i // 3) * th))
-g.save(out); print(n, pick)
-P

.claude/skills/anland-mobilegl-plasma/scripts/shot.sh

@@ -1,15 +0,0 @@
-#!/usr/bin/env bash
-# shot.sh <name> [count] [interval-s] - take <count> (default 2) phone screenshots <interval> s apart
-# (default 1), pull them to $ANL_DIR/<name>-<i>.png and print their md5.  Identical hashes while an
-# animated client (glmark2, a video) runs mean the frames are NOT reaching the screen.
-set -euo pipefail
-. "$(dirname "$0")/env.sh"
-name=${1:?usage: shot.sh <name> [count] [interval]}; n=${2:-2}; dt=${3:-1}
-cmd=""; i=1
-while [ "$i" -le "$n" ]; do cmd="$cmd screencap -p $DEV_SHARE/$name-$i.png; sleep $dt;"; i=$((i+1)); done
-adb_ shell "su -c '$cmd'"
-i=1
-while [ "$i" -le "$n" ]; do
-    adb_ pull "$DEV_SHARE/$name-$i.png" "$ANL_DIR/$name-$i.png" >/dev/null
-    md5sum "$ANL_DIR/$name-$i.png"; i=$((i+1))
-done

.claude/skills/anland-mobilegl-plasma/scripts/sync-src.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-# sync-src.sh - FALLBACK path only (the WSL cross build, xbuild.sh, replaced it).  Pushes the files the
-# worktree changed since the container's source stamp into the container's MobileGL source tree
-# (/root/mobilegl-unified-src), keeping mtimes so the in-container ninja build stays incremental;
-# then build/install inside the container with anland's anland-build-client.sh
-# (producers/kde/Arch_v5/mobilegl-tools/, gcc, -j4, slow on the phone).
-# A full re-sync of the tree is anland's anland-sync-source.sh (MOBILEGL_REPO=<worktree>).
-set -euo pipefail
-. "$(dirname "$0")/env.sh"
-SRC=$CT_ROOT/root/mobilegl-unified-src
-STAMP=$(adb_ shell "su -c 'cat $SRC/.anland-build-stamp'" | tr -d '\r\n')
-cd "$MGL_WORKTREE"
-FILES=$( (git diff --name-only --diff-filter=d "$STAMP"; git ls-files --others --exclude-standard) \
-    | grep -v -E '^(3rdparty/|build-android|\.anland-build-stamp|\.claude/)' | sort -u)
-echo "$(echo "$FILES" | wc -l) files since $STAMP"
-tar --force-local -czf "$ANL_DIR/src-delta.tgz" $FILES
-adb_ push "$ANL_DIR/src-delta.tgz" /data/local/tmp/src-delta.tgz >/dev/null
-HEAD=$(git rev-parse HEAD)
-adb_ shell "su -c 'tar xzf /data/local/tmp/src-delta.tgz -C $SRC && echo $HEAD > $SRC/.anland-build-stamp && echo synced'"

.claude/skills/anland-mobilegl-plasma/scripts/wsl-all.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-# wsl-all.sh - run INSIDE WSL archlinux after wsl-test.sh configured $B: build every *Test target except
-# DirectVulkan*/Benchmark* and run the unit label.  NEVER run the DirectVulkan integration tests
-# (they need a live device + manual intervention); never run two ctest suites at once.
-B=${B:-$HOME/mgl-anl-bld}
-cd $B
-T=$(ninja -t targets all 2>/dev/null | grep -oE "^[A-Za-z]+Test:" | tr -d : | sort -u | grep -v -E "^(DirectVulkan|Benchmark)" | tr "\n" " ")
-ninja -j14 MobileGLServer $T 2>&1 | grep -E "error:|FAILED" | head -10
-ctest -L unit -j10 --timeout 300 -E "DirectVulkan" 2>&1 | tail -25

.claude/skills/anland-mobilegl-plasma/scripts/wsl-test.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-# wsl-test.sh <targets...> - run INSIDE WSL archlinux: configure (once) and build MobileGL unit-test
-# targets for the host (clang, disaggregated + in-process server ON).  From Git Bash:
-#   MSYS2_ARG_CONV_EXCL='*' wsl -d archlinux -- bash /mnt/c/<worktree>/.claude/skills/anland-mobilegl-plasma/scripts/wsl-test.sh MultiSessionTest
-# then ctest in $B (see wsl-all.sh).  Env: W (worktree, WSL path; default: derived from this file),
-# B (build dir, default ~/mgl-anl-bld).  The Windows MSVC build of feat/disaggregated is broken; use this.
-set -e
-W=${W:-$(cd "$(dirname "$0")/../../../.." && pwd)}
-B=${B:-$HOME/mgl-anl-bld}
-if [ ! -f $B/build.ninja ]; then
-cmake -S $W -B $B -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DMOBILEGL_BUILD_TEST=ON -DMOBILEGL_BUILD_DISAGGREGATED=ON -DMOBILEGL_BUILD_DISAGGREGATED_INPROC=ON -DMOBILEGL_BUILD_STAMP=wsl
-fi
-cmake --build $B --target "$@" -j16

.claude/skills/anland-mobilegl-plasma/scripts/x11-verify.sh

@@ -1,135 +0,0 @@
-#!/usr/bin/env bash
-# x11-verify.sh <step> [...] - device verification of X11 on the GPU (docs/Disaggregated/notes/anland/
-# plan-x11-gpu.md): Xwayland drawing with glamor on MobileGL, and GLX windows presented through
-# DRI3 + Present from shared images. Steps, in the order a full run takes them:
-#
-#   preflight             read-only: battery, stack status, Xwayland package, render node, xcb libs,
-#                         test apps, Xwayland's extensions and its GLX vendor
-#   measure <label> [s]   glxgears 1280x720 (GEARS_ARGS; vblank_mode=0) for s seconds (10): its fps, then CPU/GPU/dma-buf
-#                         counts (device/x11-measure.sh); also with MOBILEGL_GLX_PRESENT=readback
-#   deploy-client         xbuild.sh + xdeploy.sh of this worktree's client (MGL_XBUILD_DIR)
-#   deploy-kwin           kwin-stage.sh build from ANLAND_WORKTREE; waits for "== ALL DONE =="
-#   deploy-server         build-android.sh + cyc.sh x11-server (swaps the APK lib, RESTARTS the session)
-#   check                 the evidence: Xwayland took glamor (journal), its MobileGL log, GLX's path
-#                         line, dma-buf counts in Xwayland/KWin, the server's import lines
-#   apps                  X11 clients on screen: konsole and kate on Qt's xcb platform (glamor-drawn
-#                         core X), glxgears (GLX), xterm/xeyes when installed; two screenshots
-#   stop                  kill the test apps
-#
-# Typical run: preflight; measure before; deploy-client; deploy-kwin; deploy-server; check; measure
-# after; apps; stop. Battery: every load step refuses below MIN_BATTERY (40) %.
-# Env: CHANNEL (ct.sh channel, default x11), ANLAND_WORKTREE (anland x11-gpu worktree, Windows
-# form), MGL_XBUILD_DIR (default /home/swung/mgl-xbuild-x11), MIN_BATTERY.
-set -euo pipefail
-here=$(cd "$(dirname "$0")" && pwd)
-. "$here/env.sh"
-CH=${CHANNEL:-x11}
-: "${MGL_XBUILD_DIR:=/home/swung/mgl-xbuild-x11}"
-: "${ANLAND_WORKTREE:=$(cygpath -m "$USERPROFILE" 2>/dev/null)/AndroidStudioProjects/anland/.claude/worktrees/x11-gpu}"
-export MGL_XBUILD_DIR ANLAND_WORKTREE
-
-battery_ok() {
-    local level
-    level=$(adb_ shell "dumpsys battery" | sed -n 's/^ *level: *//p' | tr -d '\r')
-    echo "battery: ${level}%"
-    if [ "${level:-0}" -lt "${MIN_BATTERY:-40}" ]; then
-        echo "below ${MIN_BATTERY:-40}%: stopping GPU-heavy work; charge the phone first" >&2
-        return 1
-    fi
-}
-
-push_measure() {
-    tr -d '\r' < "$here/device/x11-measure.sh" > "$ANL_DIR/x11-measure.sh"
-    adb_ push "$ANL_DIR/x11-measure.sh" "$DEV_TOOLS/x11-measure.sh" >/dev/null
-}
-
-step=${1:?usage: x11-verify.sh <preflight|measure|deploy-client|deploy-kwin|deploy-server|check|apps|stop>}
-shift
-case "$step" in
-preflight)
-    battery_ok || true
-    adb_ shell "su -c 'sh $DEV_TOOLS/status.sh'" || true
-    bash "$here/ct.sh" "$CH" <<'IN'
-echo "== packages"; pacman -Q xorg-xwayland libxcb mesa-utils xorg-xdpyinfo qt6-base 2>&1 | sed 's/^/  /'
-echo "== render nodes"; ls -l /dev/dri/ 2>&1 | sed 's/^/  /'
-U=swung0x48; for n in /dev/dri/renderD*; do sudo -u $U test -r "$n" -a -w "$n" && echo "  $U can open $n"; done
-echo "== KWin's thin node"; tr '\0' '\n' < /proc/$(pgrep -x kwin_wayland)/environ 2>/dev/null | grep -E "MOBILEGL_GBM_NODE|ANLAND_XWAYLAND_GLAMOR|GBM_BACKEND" | sed 's/^/  /'
-echo "== xcb libraries"; for l in libxcb-dri3.so.0 libxcb-present.so.0 libxcb-xfixes.so.0 libxcb-shm.so.0; do ls /usr/lib/$l >/dev/null 2>&1 && echo "  $l ok" || echo "  $l MISSING"; done
-echo "== Xwayland"; pgrep -a -x Xwayland | sed 's/^/  /'
-mgrun offscreen xdpyinfo 2>/dev/null | grep -E "^ +(DRI3|Present|MIT-SHM|XFIXES|GLX)$" | sed 's/^/  ext/'
-mgrun offscreen glxinfo -B 2>&1 | grep -E "vendor|renderer|direct rendering" | sed 's/^/  /'
-IN
-    ;;
-measure)
-    label=${1:?usage: x11-verify.sh measure <label> [seconds]}
-    secs=${2:-10}
-    battery_ok
-    push_measure
-    for mode in auto readback; do
-        printf '%s\n' \
-            "pkill -x glxgears; rm -f /tmp/mgl-x11-gears.client.log /tmp/x11-gears.out" \
-            "MGLOG=/tmp/mgl-x11-gears.log timeout $((secs + 8)) mgrun offscreen env vblank_mode=${VBLANK_MODE:-0} MOBILEGL_GLX_PRESENT=$mode glxgears ${GEARS_ARGS:--geometry 1280x720} > /tmp/x11-gears.out 2>&1 &" \
-            "sleep 3" | bash "$here/ct.sh" "$CH" >/dev/null
-        adb_ shell "su -c 'sh $DEV_TOOLS/x11-measure.sh $label-$mode glxgears $secs'" || true
-        sleep 6
-        printf '%s\n' "grep -a 'frames in' /tmp/x11-gears.out | tail -3; grep -a 'presented through' /tmp/mgl-x11-gears.client.log | head -1; pkill -x glxgears; true" \
-            | bash "$here/ct.sh" "$CH"
-    done
-    ;;
-deploy-client)
-    bash "$here/xbuild.sh"
-    CHANNEL=$CH bash "$here/xdeploy.sh"
-    ;;
-deploy-kwin)
-    CHANNEL=$CH bash "$here/kwin-stage.sh" build
-    for _ in $(seq 1 120); do
-        out=$(printf 'tail -3 /root/kwin-build.log\n' | bash "$here/ct.sh" "$CH" 2>/dev/null || true)
-        echo "$out" | tail -1
-        echo "$out" | grep -q "== ALL DONE ==" && exit 0
-        echo "$out" | grep -qiE "error|failed" && { echo "KWin build failed" >&2; exit 1; }
-        sleep 30
-    done
-    echo "KWin build did not finish in an hour" >&2; exit 1
-    ;;
-deploy-server)
-    battery_ok
-    bash "$here/build-android.sh"
-    CHANNEL=$CH bash "$here/cyc.sh" x11-server
-    ;;
-check)
-    bash "$here/ct.sh" "$CH" <<'IN'
-echo "== Xwayland's command line (no -shm with glamor)"; pgrep -a -x Xwayland | sed 's/^/  /'
-echo "== Xwayland's glamor (journal)"
-journalctl --no-pager --since -30min 2>/dev/null | grep -aiE "glamor|Xwayland.*(EGL|gbm|dri3|falling back)" | tail -10 | sed 's/^/  /'
-echo "== Xwayland's MobileGL client log"; grep -aE "presented|shared image|declin|Fatal|ERROR" /tmp/mgl-xwayland.client.log /tmp/mgl-xwayland.client 2>/dev/null | tail -8 | sed 's/^/  /' || echo "  (none)"
-X=$(pgrep -x Xwayland); K=$(pgrep -x kwin_wayland)
-echo "== dma-bufs held: Xwayland $(ls -l /proc/$X/fd 2>/dev/null | grep -c dmabuf), kwin $(ls -l /proc/$K/fd 2>/dev/null | grep -c dmabuf)"
-echo "== Xwayland's GLX vendor and extensions"
-mgrun offscreen xdpyinfo 2>/dev/null | grep -E "^ +(DRI3|Present|MIT-SHM)$" | sed 's/^/  ext/'
-echo "== a GLX window's path"
-rm -f /tmp/mgl-x11-check.client.log
-MGLOG=/tmp/mgl-x11-check.log timeout 6 mgrun offscreen glxgears >/dev/null 2>&1
-grep -a "presented through\|leaves DRI3" /tmp/mgl-x11-check.client.log | sed 's/^/  /'
-IN
-    adb_ logcat -d | grep -aE "MobileGL.*(shared image|dma-buf import|refused)" | tail -8 || true
-    adb_ logcat -b crash -d | tail -5 || true
-    ;;
-apps)
-    battery_ok
-    printf '%s\n' \
-        "pkill -x xterm; pkill -x xeyes; pkill -x glxgears; pkill -x konsole; pkill -x kate" \
-        "MGLOG=/tmp/mgl-x11-konsole.log mgrun offscreen env QT_QPA_PLATFORM=xcb konsole >/dev/null 2>&1 &" \
-        "MGLOG=/tmp/mgl-x11-kate.log mgrun offscreen env QT_QPA_PLATFORM=xcb kate >/dev/null 2>&1 &" \
-        "command -v xterm >/dev/null && MGLOG=/tmp/mgl-x11-xterm.log mgrun offscreen xterm >/dev/null 2>&1 &" \
-        "command -v xeyes >/dev/null && MGLOG=/tmp/mgl-x11-xeyes.log mgrun offscreen xeyes >/dev/null 2>&1 &" \
-        "MGLOG=/tmp/mgl-x11-gears.log mgrun offscreen glxgears >/dev/null 2>&1 &" \
-        "sleep 6; pgrep -a -x konsole; pgrep -a -x kate; pgrep -a -x xterm; pgrep -a -x xeyes; pgrep -a -x glxgears; true" | bash "$here/ct.sh" "$CH"
-    bash "$here/shot.sh" x11-apps 2 1
-    ;;
-stop)
-    printf '%s\n' "pkill -x xterm; pkill -x xeyes; pkill -x glxgears; pkill -x konsole; pkill -x kate; true" | bash "$here/ct.sh" "$CH"
-    ;;
-*)
-    echo "unknown step $step" >&2; exit 2
-    ;;
-esac

.claude/skills/anland-mobilegl-plasma/scripts/xbuild.sh

@@ -1,42 +0,0 @@
-#!/usr/bin/env bash
-# xbuild.sh [--reconfigure] [extra ninja targets...] - cross-build the container CLIENT: libMobileGL.so
-# (glibc aarch64, glvnd EGL/GLX vendor) + mobilegl_gbm.so (GBM backend), in WSL archlinux with
-# clang + lld against a sysroot exported from the container (xsysroot/refresh-sysroot.sh).
-# Full build ~150 s, incremental seconds.  Deploy with xdeploy.sh.
-# Env: MGL_WORKTREE (source, Windows form), MGL_XBUILD_DIR (WSL build dir, default ~/mgl-xbuild-a64),
-#      MGL_JOBS (16), WSL_DISTRO (archlinux).
-# Prereq in WSL: clang, lld, llvm (lld major MUST equal clang/llvm-libs major - lld 23 on llvm 22
-# broke ld.lld), cmake, ninja; ~/sysroots/aarch64-arch.cmake + ~/sysroots/arch-kde-mgl.
-set -euo pipefail
-. "$(dirname "$0")/env.sh"
-STAMP=$(git -C "$MGL_WORKTREE" rev-parse HEAD)
-RECONF=0
-if [ "${1:-}" = "--reconfigure" ]; then RECONF=1; shift; fi
-EXTRA="$*"
-SRC_WSL=$(win2wsl "$MGL_WORKTREE")
-wsl -d "${WSL_DISTRO:-archlinux}" -- env SRC="$SRC_WSL" STAMP="$STAMP" RECONF="$RECONF" EXTRA="$EXTRA" \
-    OUT="${MGL_XBUILD_DIR:-}" JOBS="${MGL_JOBS:-16}" bash -s <<'IN' 2>&1 | tr -d '\0' | grep -av '^wsl:'
-set -euo pipefail
-OUT=${OUT:-$HOME/mgl-xbuild-a64}
-TC=$HOME/sysroots/aarch64-arch.cmake
-[ -f "$TC" ] || { echo "missing toolchain $TC (run xsysroot/refresh-sysroot.sh)"; exit 1; }
-ld.lld --version >/dev/null || { echo "ld.lld is not runnable in WSL (lld/llvm version mismatch?)"; exit 1; }
-t0=$(date +%s)
-if [ "$RECONF" = 1 ] || [ ! -f "$OUT/build.ninja" ]; then
-    rm -rf "$OUT/CMakeCache.txt" "$OUT/CMakeFiles"
-    cmake -S "$SRC" -B "$OUT" -G Ninja --toolchain "$TC" -DMOBILEGL_BUILD_STAMP="$STAMP" \
-        -DCMAKE_BUILD_TYPE=Release -DMOBILEGL_BUILD_TEST=OFF -DMOBILEGL_BUILD_BENCHMARK=OFF \
-        -DMOBILEGL_BUILD_DISAGGREGATED=ON -DMOBILEGL_ENABLE_LTO=OFF
-elif ! grep -qx "MOBILEGL_BUILD_STAMP:STRING=$STAMP" "$OUT/CMakeCache.txt"; then
-    cmake -S "$SRC" -B "$OUT" -DMOBILEGL_BUILD_STAMP="$STAMP" >/dev/null
-fi
-t1=$(date +%s)
-cmake --build "$OUT" --target MobileGL mobilegl_gbm $EXTRA -j"$JOBS"
-t2=$(date +%s)
-echo "stamp:     $STAMP"
-echo "configure: $((t1-t0))s   build: $((t2-t1))s"
-for f in "$OUT/libMobileGL.so" "$OUT/MobileGL/MG_Gbm/mobilegl_gbm.so"; do
-    ls -la "$f"; echo "  windows: $(wslpath -w "$f")"
-done
-IN
-exit "${PIPESTATUS[0]}"

.claude/skills/anland-mobilegl-plasma/scripts/xdeploy.sh

@@ -1,65 +0,0 @@
-#!/usr/bin/env bash
-# xdeploy.sh - install the WSL cross-built libMobileGL.so + mobilegl_gbm.so into the container, exactly
-# like anland's anland-build-client.sh: copy to a NEW inode and rename into place (overwriting a mapped
-# .so in place crashes every running client, KWin included), refresh the libEGL/libGL aliases, the
-# glvnd GLX vendor link, the EGL vendor JSON (system-wide 10_mobilegl.json + the /opt copy), the client
-# config /etc/mobilegl/client.conf and the GLX/GBM selection drop-ins.  Does not restart anything: already-running clients
-# keep the old inode; restart the client (or the session) to pick up the new library.
-# Env: MGL_XBUILD_DIR (WSL build dir), CHANNEL (ct.sh channel, default xd), WSL_DISTRO.
-set -euo pipefail
-here=$(cd "$(dirname "$0")" && pwd)
-. "$here/env.sh"
-mkdir -p "$ANL_DIR/xdist"
-# 1. Copy the build outputs out of WSL.
-wsl -d "${WSL_DISTRO:-archlinux}" -- env OUT="${MGL_XBUILD_DIR:-}" D="$(win2wsl "$ANL_DIR")/xdist" bash -s <<'IN' 2>&1 | tr -d '\0' | grep -av '^wsl:'
-set -e; OUT=${OUT:-$HOME/mgl-xbuild-a64}
-cp -f "$OUT/libMobileGL.so" "$D/libMobileGL.so"; cp -f "$OUT/MobileGL/MG_Gbm/mobilegl_gbm.so" "$D/mobilegl_gbm.so"
-sha256sum "$D/libMobileGL.so" "$D/mobilegl_gbm.so"
-IN
-# 2. Push to the phone and stage them in the container's /root/xdeploy (the container's /tmp and the
-#    phone's /data/local/tmp are different places; the rootfs is reachable at $CT_ROOT).
-adb_ shell "mkdir -p $DEV_TOOLS/xdist"
-adb_ push "$ANL_DIR/xdist/libMobileGL.so" "$DEV_TOOLS/xdist/libMobileGL.so"
-adb_ push "$ANL_DIR/xdist/mobilegl_gbm.so" "$DEV_TOOLS/xdist/mobilegl_gbm.so"
-adb_ shell "su -c 'mkdir -p $CT_ROOT/root/xdeploy && cp $DEV_TOOLS/xdist/libMobileGL.so $DEV_TOOLS/xdist/mobilegl_gbm.so $CT_ROOT/root/xdeploy/ && rm -f $DEV_TOOLS/xdist/*.so'"
-# 3. Install inside the container.
-bash "$here/ct.sh" "${CHANNEL:-xd}" <<'IN'
-set -euo pipefail
-in=/root/xdeploy
-mkdir -p /opt/mobilegl/lib /opt/mobilegl/share/glvnd/egl_vendor.d
-cp "$in/libMobileGL.so" /opt/mobilegl/lib/libMobileGL.so.new
-mv -f /opt/mobilegl/lib/libMobileGL.so.new /opt/mobilegl/lib/libMobileGL.so
-for lib in libEGL.so libEGL.so.1 libGL.so libGL.so.1; do ln -sf libMobileGL.so "/opt/mobilegl/lib/$lib"; done
-ln -sf /opt/mobilegl/lib/libMobileGL.so /usr/lib/libGLX_mobilegl.so.0
-vendor='{"file_format_version":"1.0.0","ICD":{"library_path":"/opt/mobilegl/lib/libMobileGL.so"}}'
-# Per-process forcing (__EGL_VENDOR_LIBRARY_FILENAMES=<this file>) keeps working off the /opt copy.
-printf '%s\n' "$vendor" >/opt/mobilegl/share/glvnd/egl_vendor.d/50_mobilegl.json
-# System-wide vendor: 10_ sorts ahead of the system's 50_mesa.json, so stock libglvnd asks MobileGL
-# first and moves on to the other vendor whenever MobileGL declines (no server reachable).
-mkdir -p /usr/share/glvnd/egl_vendor.d
-printf '%s\n' "$vendor" >/usr/share/glvnd/egl_vendor.d/10_mobilegl.json.new
-mv -f /usr/share/glvnd/egl_vendor.d/10_mobilegl.json.new /usr/share/glvnd/egl_vendor.d/10_mobilegl.json
-# Client settings every process reads when its environment does not say otherwise (the backend
-# comes from /etc/mobilegl/backend, which switch.sh rewrites).
-mkdir -p /etc/mobilegl
-cat >/etc/mobilegl/client.conf <<'CONF'
-# MobileGL client configuration, read by every process that loads libMobileGL.so.
-# KEY=value lines; a MOBILEGL_* variable in a process's environment overrides the line here.
-# The backend is /etc/mobilegl/backend. Written by xdeploy.sh / anland-build-client.sh.
-MOBILEGL_TRANSPORT=spawn
-MOBILEGL_IPC_DATA=shm
-MOBILEGL_IPC_CONTROL=unix:@anland-mobilegl
-CONF
-# What glvnd's libGLX and libgbm cannot infer: environment.d reaches the systemd user manager (every
-# Plasma service and what it launches, terminals included), profile.d reaches login shells.
-mkdir -p /etc/environment.d /etc/profile.d
-printf '%s\n' '__GLX_VENDOR_LIBRARY_NAME=mobilegl' 'GBM_BACKEND=mobilegl' >/etc/environment.d/10-mobilegl.conf
-printf '%s\n' 'export __GLX_VENDOR_LIBRARY_NAME=mobilegl' 'export GBM_BACKEND=mobilegl' >/etc/profile.d/mobilegl.sh
-mkdir -p /usr/lib/gbm
-cp "$in/mobilegl_gbm.so" /usr/lib/gbm/mobilegl_gbm.so.new
-mv -f /usr/lib/gbm/mobilegl_gbm.so.new /usr/lib/gbm/mobilegl_gbm.so
-rm -f "$in/libMobileGL.so" "$in/mobilegl_gbm.so"
-sha256sum /opt/mobilegl/lib/libMobileGL.so /usr/lib/gbm/mobilegl_gbm.so
-ls /usr/share/glvnd/egl_vendor.d/ /etc/mobilegl/ /etc/environment.d/
-echo DEPLOYED
-IN

.claude/skills/anland-mobilegl-plasma/scripts/xsysroot/aarch64-arch.cmake

@@ -1,47 +0,0 @@
-# Cross toolchain: WSL clang -> aarch64 Arch Linux ARM (glibc) container "arch-kde-mgl".
-# Sysroot exported from the container by refresh-sysroot.sh (default $HOME/sysroots/arch-kde-mgl).
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR aarch64)
-
-set(_triple aarch64-unknown-linux-gnu)
-if (DEFINED ENV{MGL_SYSROOT})
-    set(_sysroot "$ENV{MGL_SYSROOT}")
-else()
-    set(_sysroot "$ENV{HOME}/sysroots/arch-kde-mgl")
-endif()
-# The container's GCC install dir (crtbegin/crtend, libgcc, libstdc++ via /usr/include/c++/<ver>).
-file(GLOB _gcc_dirs LIST_DIRECTORIES true "${_sysroot}/usr/lib/gcc/${_triple}/*")
-list(SORT _gcc_dirs COMPARE NATURAL ORDER DESCENDING)
-list(GET _gcc_dirs 0 _gcc_install_dir)
-
-set(CMAKE_SYSROOT "${_sysroot}")
-set(CMAKE_C_COMPILER clang)
-set(CMAKE_CXX_COMPILER clang++)
-set(CMAKE_ASM_COMPILER clang)
-set(CMAKE_C_COMPILER_TARGET ${_triple})
-set(CMAKE_CXX_COMPILER_TARGET ${_triple})
-set(CMAKE_ASM_COMPILER_TARGET ${_triple})
-set(CMAKE_AR llvm-ar)
-set(CMAKE_RANLIB llvm-ranlib)
-set(CMAKE_NM llvm-nm)
-set(CMAKE_OBJCOPY llvm-objcopy)
-set(CMAKE_STRIP llvm-strip)
-
-set(_xflags "--gcc-install-dir=${_gcc_install_dir}")
-set(CMAKE_C_FLAGS_INIT "${_xflags}")
-set(CMAKE_CXX_FLAGS_INIT "${_xflags}")
-set(CMAKE_ASM_FLAGS_INIT "${_xflags}")
-set(CMAKE_EXE_LINKER_FLAGS_INIT "-fuse-ld=lld")
-set(CMAKE_SHARED_LINKER_FLAGS_INIT "-fuse-ld=lld")
-set(CMAKE_MODULE_LINKER_FLAGS_INIT "-fuse-ld=lld")
-set(CMAKE_LINKER_TYPE LLD)
-
-set(CMAKE_FIND_ROOT_PATH "${_sysroot}")
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
-
-set(ENV{PKG_CONFIG_SYSROOT_DIR} "${_sysroot}")
-set(ENV{PKG_CONFIG_LIBDIR} "${_sysroot}/usr/lib/pkgconfig:${_sysroot}/usr/share/pkgconfig")
-set(ENV{PKG_CONFIG_PATH} "")

.claude/skills/anland-mobilegl-plasma/scripts/xsysroot/refresh-sysroot.sh

@@ -1,26 +0,0 @@
-#!/usr/bin/env bash
-# xsysroot/refresh-sysroot.sh - (re)export the cross sysroot from the container into WSL
-# ~/sysroots/arch-kde-mgl and install the toolchain file as ~/sysroots/aarch64-arch.cmake.
-# Read-only on the container side (it only tars headers/libs into /root and moves the tarball out).
-# Run once on a new machine, and again after the container upgrades glibc/gcc/vulkan/libdrm/gbm;
-# then `bash xbuild.sh --reconfigure`.  Env: CHANNEL (default xr), WSL_DISTRO.
-set -euo pipefail
-here=$(cd "$(dirname "$0")" && pwd)
-. "$here/../env.sh"
-cp -f "$here/aarch64-arch.cmake" "$ANL_DIR/aarch64-arch.cmake"
-bash "$here/../ct.sh" "${CHANNEL:-xr}" <<'IN'
-set -e; cd /
-L=$(ls -d usr/lib/*crt*.o usr/lib/lib{c,m,mvec,pthread,dl,rt,util,resolv,anl,stdc++,stdc++fs,stdc++exp,supc++,gcc_s,atomic,vulkan,drm,drm_*,gbm,z}.* usr/lib/lib{c,m}_nonshared* usr/lib/ld-linux* usr/lib/pkgconfig usr/share/pkgconfig usr/share/cmake/VulkanHeaders usr/lib/cmake/Vulkan* 2>/dev/null)
-tar czf /root/xsysroot.tar.gz --exclude='usr/lib/gcc/*/*/cc1' --exclude='usr/lib/gcc/*/*/cc1plus' --exclude='usr/lib/gcc/*/*/lto1' --exclude='usr/lib/gcc/*/*/lto-wrapper' --exclude='usr/lib/gcc/*/*/collect2' --exclude='usr/lib/gcc/*/*/plugin' --exclude='usr/lib/gcc/*/*/install-tools' --exclude='usr/lib/gcc/*/*/liblto_plugin.so' lib usr/include usr/lib/gcc $L
-echo SYSROOT_TAR_DONE
-IN
-adb_ shell "su -c 'mv $CT_ROOT/root/xsysroot.tar.gz $DEV_TOOLS/xsysroot.tar.gz && chmod 644 $DEV_TOOLS/xsysroot.tar.gz'"
-adb_ pull "$DEV_TOOLS/xsysroot.tar.gz" "$ANL_DIR/xsysroot.tar.gz"
-adb_ shell "su -c 'rm -f $DEV_TOOLS/xsysroot.tar.gz'"
-wsl -d "${WSL_DISTRO:-archlinux}" -- env A="$(win2wsl "$ANL_DIR")" bash -s <<'IN' 2>&1 | tr -d '\0' | grep -av '^wsl:'
-set -e; S=$HOME/sysroots/arch-kde-mgl; rm -rf "$S.new"; mkdir -p "$S.new"
-tar xzf "$A/xsysroot.tar.gz" -C "$S.new"
-rm -rf "$S"; mv "$S.new" "$S"; cp -f "$A/aarch64-arch.cmake" "$HOME/sysroots/aarch64-arch.cmake"
-du -sh "$S"; ls "$S/usr/lib/gcc/aarch64-unknown-linux-gnu/"
-IN
-rm -f "$ANL_DIR/xsysroot.tar.gz"

.gitattributes

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

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

@@ -1,199 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=trace-fixture-lib.sh
-. "${script_dir}/trace-fixture-lib.sh"
-
-if [ "$#" -lt 1 ] || [ "$#" -gt 2 ]; then
-  echo "usage: $0 <trace-case> [fixture-dir]" >&2
-  exit 2
-fi
-
-case_name="$1"
-fixture_dir="${2:-tools/trace_replay/fixtures}"
-python_bin="${PYTHON:-python3}"
-# Fixture mirrors, tried in order before falling back to Git LFS. Override the
-# whole list with MOBILEGL_TRACE_FIXTURE_MIRROR_BASES (whitespace separated);
-# MOBILEGL_TRACE_FIXTURE_MIRROR_BASE still works and is tried first.
-default_mirror_bases=(
-  "https://git.hit.moe/swung0x48/MobileGL/media/branch/dev/tools/trace_replay/fixtures"
-  "https://repo.miawa.cn/mgl/tools/trace_replay/fixtures"
-)
-if [ -n "${MOBILEGL_TRACE_FIXTURE_MIRROR_BASES:-}" ]; then
-  read -r -a mirror_bases <<< "${MOBILEGL_TRACE_FIXTURE_MIRROR_BASES}"
-else
-  mirror_bases=("${default_mirror_bases[@]}")
-fi
-if [ -n "${MOBILEGL_TRACE_FIXTURE_MIRROR_BASE:-}" ]; then
-  mirror_bases=("${MOBILEGL_TRACE_FIXTURE_MIRROR_BASE}" "${mirror_bases[@]}")
-fi
-# Optional bearer token for mirrors that require authentication (private Gitea).
-mirror_token="${MOBILEGL_TRACE_FIXTURE_MIRROR_TOKEN:-}"
-download_attempts="${MOBILEGL_TRACE_FIXTURE_DOWNLOAD_ATTEMPTS:-5}"
-retry_delay="${MOBILEGL_TRACE_FIXTURE_RETRY_DELAY:-2}"
-
-if ! command -v "${python_bin}" >/dev/null 2>&1 && command -v python >/dev/null 2>&1; then
-  python_bin=python
-fi
-
-if ! [[ "${download_attempts}" =~ ^[1-9][0-9]*$ ]]; then
-  echo "MOBILEGL_TRACE_FIXTURE_DOWNLOAD_ATTEMPTS must be a positive integer: ${download_attempts}" >&2
-  exit 2
-fi
-if ! [[ "${retry_delay}" =~ ^[0-9]+$ ]]; then
-  echo "MOBILEGL_TRACE_FIXTURE_RETRY_DELAY must be a non-negative integer: ${retry_delay}" >&2
-  exit 2
-fi
-
-fixture_list="$("${python_bin}" tools/trace_replay/trace_cases.py \
-  --format fixture-files \
-  --case "${case_name}" \
-  --fixture-root "${fixture_dir}")"
-# Strip CR so the script also works when python emits CRLF (Git Bash on Windows).
-mapfile -t files < <(printf '%s\n' "${fixture_list}" | tr -d '\r')
-
-include="$(IFS=,; echo "${files[*]}")"
-if [ "${case_name}" = "OpenRA" ]; then
-  echo "Fixture files for ${case_name} are stored in Git: ${include}"
-  for file in "${files[@]}"; do
-    test -s "${file}"
-    if head -n 1 "${file}" | grep -q "version https://git-lfs.github.com/spec/v1"; then
-      echo "fixture should not be stored as an LFS pointer: ${file}" >&2
-      exit 1
-    fi
-  done
-  exit 0
-fi
-
-fetch_file_from_mirror() {
-  local file="$1"
-  local url="$2"
-  local metadata
-  local expected_oid
-  local expected_size
-  local tmp_file="${file}.tmp"
-  local attempt
-  local partial_size
-  local curl_status
-  local curl_auth
-
-  metadata="$(get_lfs_metadata "${file}")" || return 1
-  read -r expected_oid expected_size <<< "${metadata}"
-
-  if [ -f "${tmp_file}" ]; then
-    partial_size="$(wc -c < "${tmp_file}" | tr -d '[:space:]')"
-    if [ "${partial_size}" -gt "${expected_size}" ]; then
-      echo "Discarding oversized partial fixture ${tmp_file}: ${partial_size} > ${expected_size}" >&2
-      rm -f "${tmp_file}"
-    elif [ "${partial_size}" = "${expected_size}" ]; then
-      if verify_fixture_file "${tmp_file}" "${file}" "${expected_oid}" "${expected_size}"; then
-        mv "${tmp_file}" "${file}"
-        return 0
-      fi
-      rm -f "${tmp_file}"
-    fi
-  fi
-
-  for ((attempt = 1; attempt <= download_attempts; attempt++)); do
-    partial_size=0
-    if [ -f "${tmp_file}" ]; then
-      partial_size="$(wc -c < "${tmp_file}" | tr -d '[:space:]')"
-    fi
-
-    if [ "${partial_size}" -gt 0 ]; then
-      echo "Resuming mirror download for ${file} at byte ${partial_size} (attempt ${attempt}/${download_attempts})"
-    else
-      echo "Starting mirror download for ${file} (attempt ${attempt}/${download_attempts})"
-    fi
-
-    curl_auth=()
-    if [ -n "${mirror_token}" ]; then
-      curl_auth=(--header "Authorization: token ${mirror_token}")
-    fi
-    if curl -L --fail --show-error --continue-at - "${curl_auth[@]}" --output "${tmp_file}" "${url}"; then
-      if verify_fixture_file "${tmp_file}" "${file}" "${expected_oid}" "${expected_size}"; then
-        mv "${tmp_file}" "${file}"
-        return 0
-      fi
-      echo "Mirror download failed integrity verification; retrying from the beginning: ${file}" >&2
-      rm -f "${tmp_file}"
-    else
-      curl_status=$?
-      partial_size=0
-      if [ -f "${tmp_file}" ]; then
-        partial_size="$(wc -c < "${tmp_file}" | tr -d '[:space:]')"
-      fi
-
-      if [ "${partial_size}" = "${expected_size}" ]; then
-        if verify_fixture_file "${tmp_file}" "${file}" "${expected_oid}" "${expected_size}"; then
-          mv "${tmp_file}" "${file}"
-          return 0
-        fi
-        rm -f "${tmp_file}"
-        partial_size=0
-      elif [ "${partial_size}" -gt "${expected_size}" ]; then
-        echo "Discarding oversized partial fixture ${tmp_file}: ${partial_size} > ${expected_size}" >&2
-        rm -f "${tmp_file}"
-        partial_size=0
-      elif [ "${curl_status}" -eq 33 ]; then
-        echo "Mirror refused the resume request; retrying from the beginning: ${file}" >&2
-        rm -f "${tmp_file}"
-        partial_size=0
-      fi
-
-      echo "Mirror download attempt ${attempt}/${download_attempts} failed with curl exit ${curl_status}; retained ${partial_size} bytes for resume: ${file}" >&2
-    fi
-
-    if [ "${attempt}" -lt "${download_attempts}" ]; then
-      sleep "${retry_delay}"
-    fi
-  done
-
-  rm -f "${tmp_file}"
-  return 1
-}
-
-# Files no mirror could serve, even after retrying every mirror. Only these fall
-# back to Git LFS, so a mirror that served the rest of the case still spares
-# GitHub the bandwidth for those files.
-mirror_failures=()
-
-fetch_from_mirror() {
-  mkdir -p "${fixture_dir}"
-  for file in "${files[@]}"; do
-    local name
-    local url
-    local base
-    local fetched=0
-    name="$(basename "${file}")"
-    for base in "${mirror_bases[@]}"; do
-      url="${base%/}/${name}"
-      echo "Fetching trace fixture from mirror: ${url}"
-      if fetch_file_from_mirror "${file}" "${url}"; then
-        fetched=1
-        break
-      fi
-      echo "Mirror did not serve ${name}; trying the next mirror" >&2
-    done
-    if [ "${fetched}" -ne 1 ]; then
-      mirror_failures+=("${file}")
-    fi
-  done
-  [ "${#mirror_failures[@]}" -eq 0 ]
-}
-
-if fetch_from_mirror; then
-  echo "Fetched trace fixture files for ${case_name} from mirror: ${include}"
-else
-  fallback_include="$(IFS=,; echo "${mirror_failures[*]}")"
-  echo "All mirrors failed for ${#mirror_failures[@]} of ${#files[@]} file(s) of ${case_name}; falling back to Git LFS: ${fallback_include}"
-  git lfs install --local
-  git lfs pull --include="${fallback_include}" --exclude=""
-fi
-
-for file in "${files[@]}"; do
-  metadata="$(get_lfs_metadata "${file}")"
-  read -r expected_oid expected_size <<< "${metadata}"
-  verify_fixture_file "${file}" "${file}" "${expected_oid}" "${expected_size}"
-done

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

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

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

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

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

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

.github/workflows/apk.yml

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

.github/workflows/wsl-gpu-smoke.yml

@@ -1,31 +0,0 @@
-name: Arch WSL GPU smoke
-
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - ci/arch-wsl-gpu-runner
-    paths:
-      - .github/workflows/wsl-gpu-smoke.yml
-      - docs/ci/arch-wsl-gpu-runner.md
-
-permissions: {}
-
-concurrency:
-  group: arch-wsl-gpu-smoke
-  cancel-in-progress: false
-
-jobs:
-  gpu-smoke:
-    runs-on: [self-hosted, Linux, X64, arch, wsl, gpu, gles, vulkan]
-    timeout-minutes: 5
-    steps:
-      - name: Report runner identity
-        shell: bash
-        run: |
-          printf 'Runner: %s\n' "$RUNNER_NAME"
-          uname -n
-          uname -a
-      - name: Verify hardware GLES and Vulkan
-        shell: bash
-        run: /usr/local/libexec/mobilegl-runner/gpu-smoke

.gitignore

@@ -1,31 +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
-/.trace-work/

.gitmodules

@@ -1,39 +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
-[submodule "3rdparty/flatbuffers"]
-	path = 3rdparty/flatbuffers
-	url = https://github.com/google/flatbuffers.git

3rdparty/glvnd/README.md

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

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

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

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

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

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));
+    }
+}