Merge origin/main into game debug logging

This commit is contained in:
xXJsonDeruloXx committed 2026-10-22 10:24:09 -04:00
commit f67ff86470
495 files changed
+35293 -2510

No files matched your search

+2 -2
View File
@@ -328,8 +328,8 @@ Neither stabilization nor prediction refreshes camera timestamps or creates gest
Each session writes `events.jsonl` beside its other artifacts: the lifecycle (`session.created`,
`compositor.started`, `guest.exited`, ...) plus `agent.ready` (the guest agent is up),
`focus.changed` (the focused app, focusable apps or base-layer order changed) and
`agent.launch_requested`.
`focus.changed` (the focused app, focusable apps or base-layer order changed),
`keyboard.changed` (Steam's on-screen keyboard opened or closed) and `agent.launch_requested`.
## UI test tags
+24 -13
View File
@@ -465,20 +465,31 @@ results, app recovery behavior, and the unverified powered-adapter design.
### Not done yet
- **Controllers**: the driver adds two Vive-profile hands driven by the session's game pad. It reads
- **Controllers**: the driver adds two hands driven by the session's game pad. It reads
the absolute-state snapshot the app already publishes in fake input ring 0
(`FAKE_EVDEV_MEMFD_PATHS`), so the app needs no new plumbing. They rest low in front of each side and
point where the head looks. Each stick moves its hand sideways (40 cm), up (50 cm) and down (30 cm)
and turns it as if from an elbow 45 cm behind, so pointers and aim follow it too; the hand eases
back when the stick is let go. The d-pad's up and down move both hands in and out; while a hand's
trigger or grip is held they move only that hand (a slingshot or bow pulled back), and it eases back
on release. Clicking the left stick hands the sticks to the game as trackpads (walking, turning,
teleport) and back. Mapping, right hand: A/R3 = trackpad click, RT = trigger, RB = grip, Start = menu, guide =
system. Left hand: X, LT, LB, Select. Both hands activate in SteamVR and their laser shows on the
dashboard; guide, Start and A presses show up in the ring the driver reads. They are drawn as Index
controllers and switch off while another driver's controller is connected. A Joy-Con hand replaces
the pad hand on its side, and bare camera hands replace both while no controller is connected
(above).
(`FAKE_EVDEV_MEMFD_PATHS`), so the app needs no new plumbing. **Play SteamVR → Settings → Controllers**
chooses what they are; the app writes the choice to `/run/droiddeck/droiddeck-vr-controllers`
(`emulate=index|touch|vive|off`, `sticks=game|hands`). The same choice is in the session menu's glasses page
and on the phone while the picture is on the glasses. The driver checks the file every second and switches
while SteamVR runs: SteamVR fixes a device's input profile when it activates, so each type gets its own pair
of devices, added the first time it is chosen, and the pair it replaces is disconnected:
- **Valve Index** (default) and **Meta Quest 3** (Touch Plus) are thumbstick controllers with the
stock input profiles, so games use their own Index or Touch bindings. Triggers are triggers, bumpers
grip, A/B and X/Y are each hand's face buttons, stick clicks are thumbstick clicks and Guide is system.
Quest's left menu button is Start or Select.
- **HTC Vive wands** keep the older layout: the sticks are trackpads, A/X or a stick click presses them,
Start and Select are menu.
- **Regular game pad** adds no hands, for games that play with a game pad.
The hands rest low in front of each side and point where the head looks. By default the sticks move you
in the game; pressing both sticks in together switches them to moving the hands and back. Each stick then
moves its hand sideways (40 cm), up (50 cm) and down (30 cm) and turns it as if from an elbow 45 cm
behind, so pointers and aim follow it too; the hand eases back when the stick is let go. The d-pad's up
and down move both hands in and out; while a hand's trigger or grip is held they move only that hand
(a slingshot or bow pulled back), and it eases back on release. Both hands activate in SteamVR and their
laser shows on the dashboard. They switch off while another driver's controller is connected. A Joy-Con
hand replaces the pad hand on its side, and bare camera hands replace both while no controller is
connected (above).
- **Layers**: only the first layer of each frame is drawn. SteamVR's compositor composites the
dashboard into it, so this has not mattered yet.
- **Timing**: no reprojection. The presenter blits the frame submitted last once `vrcompositor`'s GPU
+13
View File
@@ -0,0 +1,13 @@
# Uninstall desktop mode
Choose **Uninstall** beside **Open desktop**, then confirm. The same action is available under
**Desktop → Files**. Stop any running session and let other installs finish first.
Removal keeps Steam, games, added apps, settings, modified files and shared dependencies. It uses
the pinned desktop file inventory and only removes matching files. Unknown desktop versions and
missing runtime package ownership cause removal to fail before deleting files.
An interrupted desktop install also offers Uninstall. Successful removal clears that desktop
installation's recovery record and cached download so the next guest launch cannot reinstall it
through package recovery. If removal is interrupted, choose Uninstall again to retry. Open desktop
installs the desktop again when needed.
+1 -1
View File
@@ -95,7 +95,7 @@ scan (`Library.launchableGames`) compares the folder with what was last written
(`grid-<slot>` in the game's art folder): a file Steam changed becomes the choice (source Steam),
a file removed in Steam drops it, and files the shortcuts writer placed itself
(`.droiddeck-art.json`) are not mistaken for choices. A chosen image is stored as
`chosen-<slot>-<time>.<ext>`, so a new choice has a new path and shows at once. Installed GOG, Epic and Amazon games get the same rows through `StoreGameArtEditor`.
`chosen-<slot>-<time>.<ext>`, so a new choice has a new path and shows at once. Installed GOG, Epic, Amazon, Xbox and itch games get the same rows through `StoreGameArtEditor`.
"Adjust logo" (last row of every art editor, `LogoPositionDialog`) shows the game's Background with
its Logo on top and lets the logo be pinned to one of Steam's five places (top left / top center /
+38
View File
@@ -0,0 +1,38 @@
# Boot movies
Settings → Boot movie has four tabs.
- **Installed**: "Browse" lists every movie Steam can play: DroidDeck's two, plus every `.webm` in Steam's
`config/uioverrides/movies` folder (imported, installed from SteamDeckRepo, or put there by Steam). The list is re-read
every two seconds, so a movie picked or removed inside Steam shows up, and a movie picked inside Steam becomes the choice.
- **Import**: the same importer as before (copy, remux or on-device transcode to VP8/Opus). The result is written into
Steam's movies folder, so Steam lists it as well.
- **SteamDeckRepo**: browses `https://steamdeckrepo.com/api/posts` (`sort`, `device`, `search`, `page`; 12 posts a page).
Installing downloads the movie through the site's own download address and imports it like any other movie. Tapping a
thumbnail plays the movie from the site (`MediaPlayer` on a `TextureView`) before it is installed. The site does not
say how many pages there are, so the last page is found by asking for pages until one comes back empty or short; the
pager shows the current page (tap it to type another), three pages either side, the first and last page numbers, and
Previous and Next. Search and "go to page" use a small dialog with the app's native text field (`AdbTextField`),
because that field is what brings up the Android keyboard in these screens.
- **Sound**: sound on/off, volume, and how many seconds of the movie play. Anything other than full volume and the whole
movie is built into `files/boot-movie/variants` (audio re-encoded as Opus, video copied) and staged instead.
Imported and installed movies are kept in `files/boot-movie/library` (with their list, `files/boot-movie/movies.json`) and
copied into Steam's movies folder, so resetting the Linux runtime does not lose them; the copy is put back when it is
missing. The list is changed under one lock, so imports at the same time cannot overwrite each other. Every movie in Steam's custom movies
folder (`config/uioverrides/movies`) can be removed after a confirmation, whether DroidDeck put it there or it was added by
hand or by Steam's own picker. Steam's own three startup movies (`deck_startup`, `oled_startup`, `startup_machine` in
`steamui/movies`) and points shop movies (any other `.webm` below Steam's `config`, `userdata`, `appcache` and `steamui`
folders, plus whatever path `StartupMovie.LocalPath` names) are listed as Steam movies, adopted when picked in Steam, and
never deleted. Bought movies live in `config/communityitemscache/startupmovies/<item number>_<hash>.webm`; their titles
come from the `GetStartupMovies` list in `userdata/<id>/config/localconfig.vdf`. Other videos in `steamui/movies` are not startup movies and are not listed.
Only one processed copy (volume or length change) is kept in `files/boot-movie/variants`; a volume that cannot be applied
plays without sound rather than louder, and plays nothing if that fails too. Covers are cached in `files/boot-movie/thumbs`. Steam reads its startup movie from the `StartupMovie` section inside the `Customization` section of
`config/config.vdf` (`MovieID`, and `LocalPath` relative to `config`; a Points Shop movie has its item number as
`MovieID`). The `StartupMovie` section under `Software/Valve/Steam` is where older clients read it, and DroidDeck writes both.
Selecting a movie here sets `bootMovieApplyNext`, so the next session stages the movie as `bigpicture_startup.webm` and
points both sections at it, over a movie Steam had picked; otherwise a movie picked in Steam is left alone and taken over as
the choice here without being staged over Steam's own setting. Settings > Boot movie > Installed has a report button that
writes what Steam and DroidDeck know to `Download/DroidDeck/boot-movie-report.txt`; it only shows while Debugging tools is on.
A movie larger than 1920x1080 (4K and the like) is never copied or remuxed as it is: import and staging always convert it
(the converter scales to at most 1280x720), because such movies have made Steam crash while it starts.
+4 -1
View File
@@ -133,7 +133,10 @@ OpenVR to SteamVR's ARM64 `vrclient.so`, so no x86 SteamVR is involved.
waits for its blit before it presents.
- **Flat games under SteamVR.** With SteamVR running, Steam lists a flat game after its own window in
gamescope's base layer, so Big Picture keeps the focus and the game never shows, theatre setting or
not. SteamVR is therefore started only by Play SteamVR, never with the glasses alone.
not. SteamVR is therefore started only by Play SteamVR, never with the glasses alone. A flat game
launched while SteamVR runs now opens as a SteamVR panel instead (`droiddeck-steamvr-flat`). Games
launched from the SteamVR dashboard do not pass through a `SteamClient.Apps.RunGame` hook installed
later, so the launcher asks Steam at run time rather than marking the click.
- **A new projection needs an event.** `SetDisplayProjectionRaw` changed what `vrserver` reports, but
`vrcompositor` kept the frustum it started with, so the glasses' field of view did nothing until
SteamVR restarted. The driver now follows it with `VREvent_LensDistortionChanged`.
+3 -1
View File
@@ -10,7 +10,9 @@ Changes apply on the next game launch, including when Steam is already running.
A running game must be restarted. Native Linux games and Steam itself are outside
this editor's scope.
The Components page also has a **Configuration** dropdown. **Default profile** owns the
Opening **Components** from a game's launch settings selects that game's profile.
Opening Components from the navigation rail selects **Default profile**. Use the
**Configuration** dropdown to switch profiles explicitly. **Default profile** owns the
default Proton and FEX preset. An installed game can inherit those defaults or
choose its own Proton and FEX preset. Proton choices are applied through Steam's
per-app compatibility mapping, including while Steam is running when its live
@@ -106,7 +106,7 @@ The optional Lite bundle can be rebuilt with `mediapipe==0.10.21` using:
python tools/build_hand_lite.py --palm palm_detection_lite.tflite --lite hand_landmark_lite.tflite
```
Source URLs and hashes are in `app/src/main/assets/models/hand_landmarker_lite.provenance.json`.
Source URLs and hashes are in `tools/packs/tracking/hand_landmarker_lite.provenance.json`.
These changes still need live moving-hand, closed-fist, gesture-continuity, and latency validation.
Earlier Lite/normalized-input validation passed 52 focused JVM tests, and bundle rebuild and label-archive reproducibility
checks passed. Desktop MediaPipe 0.10.21 inference succeeded on color hand fixtures. All six
+1 -1
View File
@@ -13,7 +13,7 @@ The base enables experimental hand tracking without requiring every user to repe
Use the existing optional `droiddeck.vitureSdk` local property with the external VITURE Android SDK 2.4.0. No vendor headers or libraries are checked into the repository. `-PvitureSdkDir=` explicitly builds without the SDK. The ordinary runtime freshness checks remain enabled. Rebuild the ARM64 VR components with `tools/vr/build_windows.py`; its manifest includes `spatialpose_shm.h`.
The hand pipeline pins MediaPipe Tasks Vision 1.0.0, OpenCV 4.13.0, and the model and SHA-256 recorded in `app/src/main/assets/models/hand_landmarker.provenance.json`. Both Gradle and the inference worker verify the model checksum. CPU inference, the full model, concurrent camera inference, scheduled hand discovery, and automatic input-rate adjustment are the defaults, including after app restarts, reconnects, and provider restarts. **Show diagnostics → GPU hand inference** temporarily enables GPU until the next tracking restart; GPU remains experimental because SteamVR restarts and Vulkan device loss were observed during testing. Diagnostics report the selection as `handGpuEnabled` and the initialized detectors as `handInferenceBackend`; `not initialized` means detector startup has not completed. Sustained performance acceptance remains unresolved.
The hand pipeline pins MediaPipe Tasks Vision 1.0.0, OpenCV 4.13.0, and the model and SHA-256 recorded in `tools/packs/tracking/hand_landmarker.provenance.json`. The model, OpenCV and MediaPipe native libraries are downloaded on first use as the tracking pack (`tools/packs`); the pack build and the inference worker verify the model checksum. CPU inference, the full model, concurrent camera inference, scheduled hand discovery, and automatic input-rate adjustment are the defaults, including after app restarts, reconnects, and provider restarts. **Show diagnostics → GPU hand inference** temporarily enables GPU until the next tracking restart; GPU remains experimental because SteamVR restarts and Vulkan device loss were observed during testing. Diagnostics report the selection as `handGpuEnabled` and the initialized detectors as `handInferenceBackend`; `not initialized` means detector startup has not completed. Sustained performance acceptance remains unresolved.
Hand input starts by copying 500 permille of stereo callbacks, approximately 12.5 pairs per second at the SDK's documented 25 Hz camera rate. On CPU, automatic adjustment can raise this to 600 or 800 permille (about 15 or 20 Hz) only after eight consecutive valid observations have sufficient processing and freshness headroom. Promotion requires average processing at most 55 ms and observation age at most 110 ms for 15 Hz, then at most 40 ms and 90 ms for 20 Hz. A moving average allows occasional scheduled discovery frames while preserving a sustained processing budget. An average above the selected period reduces the rate; any single processing cost of 80 ms or observation age of 140 ms immediately returns it to 500 permille. Tracking failure and detector resets also return it to 500. This policy requests more input only when processing can accommodate it; it does not guarantee that many completed or valid hand updates.
+28 -9
View File
@@ -39,6 +39,11 @@ arm64 client down first.
standalone launcher honours up to five times, as `steam.sh` does).
- Before each start `x64_sync_client` brings the client to Valve's current build, downloading only the
changed parts (9 of 28 on a device). If that fails, the client updates itself.
- The client is the `steamrt64` platform (`steamrt64/steam`, the manifest it checks for updates), so
the install, the sync and the web-helper build check read `steam_client_<channel>_steamrt64`. The
`ubuntu12` manifest lags it (device: 1792108788 against 1792192922): an install from it was always
one build behind the arm64 client, so the arm64 web helper was never used, and the client updated
itself in place at its first start (506 MB) after the helper had already been chosen.
- `.steam-enable-steamrt64-client` in the client folder opts into the SteamRT3 build
(`steamrt64/steam`). Without it the client re-executes itself in the scout environment through
`steam.sh`, whose start-up checks need what proot cannot give; the session stalled before the
@@ -119,6 +124,11 @@ The client's web helper draws its whole UI. There are two:
backend through FEX's GL thunk to zink and Turnip. On ANGLE's Vulkan backend the x86 compositor
thread was the bottleneck (16 fps against 60). Never `--in-process-gpu`, the preload's default: a
GPU crash there took the whole helper down (102 restarts). `BL_X64_CEF_GPU=0` keeps it in software.
Its GPU process loads libpci, which exits when `/sys/bus/pci/devices` lists a device whose files
the app may not read (a RedMagic's PCIe root ports): every GPU process exited with status 1 in about
50 ms, software ones too, until Chromium gave up ("GPU process isn't usable") and the menus stayed
blank. `LinuxRuntime` binds an empty folder over `/sys/bus/pci/devices` on such devices; device:
0 GPU process exits, ANGLE on zink and Turnip.
The session shim (`preload/net.c`) turns `steamrt64/steamwebhelper.sh`'s exec of `./steamwebhelper`
into `BL_X64_ARM_WEBHELPER`. Nothing in the client's folder is edited: the client checksums its files
@@ -217,7 +227,7 @@ alone would then read as an installed client.
- **What a session log shows.** `FEX ready (<tag>, <source>)` names the build and where it came from
(`catalog`, `built-in`, or `kept` when a newer one did not install, with the reason a line above);
`x86-64 rootfs:` names the image; `x86-64 client:` the client's ubuntu12 and steamrt64 builds at start
`x86-64 rootfs:` names the image; `x86-64 client:` the client's steamrt64 build at start
(it may update itself after). The rootfs download reports every tenth of its size as a step. When the
web helper's GPU process keeps exiting until Chromium gives up on the GPU (the menus then never appear),
one line says so with the exit codes, followed by x86 `glxinfo -B` and `vulkaninfo --summary` through
@@ -301,15 +311,24 @@ alone would then read as an installed client.
in 51 s.
- **Sign-in.** Before either client starts, the newer sign-in (`config/loginusers.vdf`, the login token
in `local.vdf`, `AutoLoginUser` and `RememberPassword` in `registry.vdf`) is copied to the other, so
signing in or switching accounts in one counts for both. Steam renews its token every few days and
refuses an old copy (a 3-day-old one asked for the password), so the newest is copied at every start,
never while either client runs, since each rewrites these files. A client that refused its token
rewrites `local.vdf` with an empty `ConnectCache`: newest, but copied over the other it would sign
that one out too (seen after the x86 client's "Invalid Password"), so it is never the source. The copy keeps
the time stamp, so both match until one client signs in again. The rest of `registry.vdf`
(language, skin) stays each client's.
signing in or switching accounts in one counts for both; never while either client runs, since each
rewrites these files. A client that refused its token rewrites `local.vdf` with an empty
`ConnectCache`, so it is never the source. The copy keeps the time stamp, so both match until one
client signs in again. The rest of `registry.vdf` (language, skin) stays each client's.
- **Account IDs.** A client logs on with the token only once it knows the account's SteamID, which it
takes from `Accounts` in `config/config.vdf`. The x86 client's `config.vdf` is made by this script
without one, so it logged on as `[U:1:0]` with the arm64 token and Steam answered "Invalid Password"
(and the client then dropped the token and `AutoLoginUser`): every switch asked for the password.
Each start adds the accounts either client knows to the other's `Accounts`, and an `AutoLoginUser` or
`RememberPassword` one client has and the other lacks. Device: the x86 client signed in with the
arm64 token (`RecvMsgClientLogOnResponse ... 'OK'`).
- **App side.** The library, art picker, grid sync and boot movie follow the running client, else the
selected one; a changed client applies from the next session. Offline Mode is written to both
selected one; a changed client applies from the next session. A game is listed once per client: an added game
whose folder a Steam install already covers (its `DroidDeck-<appid>` import) is shown as that Steam
game only, and a client switch drops the old client's imported entries with its Steam games. In
Steam, an import stays one when its ownership cannot be confirmed that session instead of gaining a
shortcut beside it, and only the client's own library folders count as an install (the arm64 card
library made the x86 client skip a game's import and its shortcut). Offline Mode is written to both
clients' `loginusers.vdf`; until the x86 client's first start its sign-in is the arm64 one. The log
redactor learns account names from both clients. The startup movie is staged into the x86 client's
config only once its first start has created it; `--prepare` links the arm64 `config/uioverrides`
+125
View File
@@ -0,0 +1,125 @@
# Xbox / PC Game Pass on Thor
This integrates PC Microsoft Store MSIXVC packages,
not Xbox console emulation or UWP/APPX packages.
## Testing on Thor
1. Open DroidDeck, select Stores, then Xbox and Sign in. Use the Microsoft account
that owns the game or has PC Game Pass access. An isolated Microsoft sign-in
window opens; complete its verification and return to DroidDeck. On later
starts, the saved account should restore without another sign-in prompt;
initial account loading uses a neutral progress indicator.
2. Refresh the Xbox library. Check a known owned PC game and, if applicable, a
Game Pass game. Subscription access is labeled PC Game Pass and does not
become permanent ownership. Console-only and unsupported package types are
filtered out. After the first successful sync, closing/reopening DroidDeck
should restore the saved library without waiting for Microsoft. Metadata is
scoped to account and market; on later starts, snapshots older than 15 minutes
refresh quietly in the background. Refresh checks immediately.
Downloading and launching still perform Microsoft licensing.
A detail page can be opened from a store search result that is not in the
library; it keeps the catalog metadata and, when the product's eligibility
affirmations name a plan that includes PC games (PC Game Pass, Ultimate,
Premium, Essential or Starter Edition), offers Install even before the title
is in the entitlement list. The retired console-only plan does not offer a
Windows install, and Microsoft licensing still decides at download time.
3. Start with a small licensed title such as LIMBO. Search `LIMBO` if needed;
the verified US Product ID is `9PNG83MDD6SH`. Install through the normal store
download queue. If an offer contains several PC base packages, choose the
intended game. A package plan is not a license: Microsoft licensing must
succeed before files can be installed.
4. Pause during transfer, resume, then repeat after closing/reopening DroidDeck.
It should retain partial files, refresh authenticated URLs and resume only
verified checkpoints. An error or cancelled process must never create an
installed/Play entry. Cancel removes a new installation's partial files.
5. Press Play as soon as installation completes, including while the main library
list is still refreshing. It should resolve the completed installation instead
of showing the "Steam picks the game up when it next starts" toast.
A launch taking over 20 seconds should not produce a duplicate Steam launch
or a "Game already running" dialog while licensing is still preparing it.
Steam/session startup uses the selected ARM64 Proton. Launch the installed
Xbox game from either DroidDeck or Steam; both paths should prepare the same
account-bound game service and licensed view while keeping account credentials
inside the Android-owned backend.
During preparation, opening the Xbox detail/content UI must remain responsive.
Update / verify must report a problem if the game starts after its button was
enabled, rather than crashing the app.
First launch prepares that game's prefix. Check that a window appears, the
game reaches its menu, controller buttons/axes work, and audio is audible.
Record the selected Proton, game/version, and any startup failure.
6. For a game with Xbox identity/cloud saves, check the gamertag, save something,
quit normally, wait for synchronization, then relaunch. Verify the save and,
where available, compare it on another legitimate Xbox PC installation.
In-game identity/cloud/multiplayer success is title-specific.
7. Close the game, then try Update / verify from its Xbox detail page. It uses
fresh licensed streaming and the existing download queue. Interrupted updates
remain resumable; do not judge an interrupted package as a complete install.
8. If you own related PC DLC, open Manage content. Only licensed, unambiguous
MSIXVC content associated with this game's package family is offered. Install
it, then relaunch and check that the game recognizes it. An account with no
such content should get an empty-content message. Base-game uninstall also
removes its managed content.
9. Stop a game and launch it again. A delayed release from the first launch must
not clear the second launch's activity. Suspend/resume while playing; the
launch lease should survive suspension. Stop the session during preparation
and verify both backend processes exit and the host-owned launch directory
under `files/xbox-runtime/views` is removed. A fresh app process recovers
abandoned `launch-*` directories there before preparing another game;
cleanup must preserve installed game files reached through view symlinks.
10. Sign out from Xbox. Installed files should remain, account library data should
clear, and Play/download licensing should require sign-in again.
Do not uninstall DroidDeck or clear application data to troubleshoot this build.
The signed APK is installed in place to retain existing Steam and store data.
## Evidence and limits
Verified during development:
- Native AArch64 CLI execution on Thor's existing Linux runtime.
- Abstract-socket credential transport with a synthetic account on Thor; this
does not establish a real Microsoft sign-in.
- Real Microsoft sign-in completed on Thor through the isolated Android host.
Its credential file is an Android Keystore AES-GCM envelope.
- Signed-in library refresh on Thor returns 13 compatible PC titles. RFC 3339
offset timestamps from the backend are parsed by Android's offset-date parser.
- Two force-stop/reopen tests restored all 13 titles from the saved library
without a native Xbox account request. Cache tests cover account/market
isolation, explicit and stale refreshes, sign-out removal and subscription
metadata remaining distinct from purchases.
- Two further cold-start checks observed no sign-in prompt while the saved
account loaded; both restored all 13 titles and the installed launcher.
- Licensed Minecraft Launcher package download and manifest-selected executable
registration on Thor (`Minecraft.exe`, package version `2.6.2.0`). An initial
Android DOM feature failure was fixed with Android's DTD-rejecting pull parser;
retry reused the downloaded files. This launcher install does not validate
gameplay.
- Public LIMBO package resolution on Thor: a Windows.Desktop MSIXVC package.
- Native AMD64 Windows module loading through Thor's ARM64 Proton/FEX, including
the `InitializeApiImplEx2` Xbox runtime export. The original builtin markers
caused error 126; the reproducible native-marker adaptation resolves that.
- Minecraft Launcher's licensed executable was materialized by Xodus, started
through ARM64 Proton/FEX, completed its self-update, and rendered its full
Windows launcher with a Microsoft account displayed on Thor. The account
service remained running with the executable. Minecraft gameplay and in-game
Xbox services remain unverified.
- Deep Rock Galactic's GDK executable also loads through Xodus/ARM64 Proton.
Its default launch crashes in D3D12 ray-tracing pipeline creation. Disabling
ray tracing in Unreal reaches the rendered title screen on Thor; this workaround
is applied to `FSD-WinGDK-Shipping.exe`. Gameplay and online services remain
unverified.
- Account-free tests cover purchase/subscription separation, stale/wrong-account
responses, malformed parent licenses, manifest traversal/XXE rejection,
fail-closed encrypted credential writes, download checkpoint behavior,
private temporary launch views, bridge authentication, and ordinary store
launch regressions.
Game rendering/input/audio, in-game account identity, cloud synchronization,
DLC activation and multiplayer require the account/game tests above. DLL
loading alone is not evidence of a playable game.
Native-module tests use a disposable prefix under
`/data/local/tmp/droiddeck-xbox-probe`; existing game prefixes are not used.
Build recipes, pinned source revisions, hashes, notices and runtime architecture
are documented in [tools/xbox](../../tools/xbox/README.md).
+52
View File
@@ -358,6 +358,58 @@ stay as they were (`afa479ee`).
- **Open:** newer-runtime Linux games (sniper) untested; the arm64 client untested on this build; the
Steam import watcher untested; an SD-card library for the x86 client deferred.
## 2026-10-14 - `gog-library-listing`: the GOG library is drawn from the account listing, details follow
- **The listing** (`GogLibrary`): the library came from `embed.gog.com/user/data/games`, which is the owned
ids and nothing else - no title, no art - so the tab stayed empty until every product had been asked about
one by one. It now comes from `account/getFilteredProducts` (`mediaType=1`, `hiddenFlag=0`, `sortBy=title`),
a hundred to a page, which carries the title, the category and the release date. Its `image` is a bare
hash the CDN serves only through Galaxy's own formatters, so a listing entry's card art is
`<hash>_glx_vertical_cover.webp` until the per-product fetch brings the wide background.
- **The listing can fail** (`GogLibrary`): when it cannot be read the sync falls back to the older
owned-ids endpoint and keeps the old behaviour - there are no titles to draw, so nothing is painted
until the products come back.
- **The tab paints first** (`GogLibrary.sync`): the whole library goes to `GogBackend` the moment the listing
is in, so the grid is on screen in seconds instead of after the last product.
- **Each card fills itself in** (`GogLibrary.sync`, `GogBackend`): every product that comes back is handed
over on its own and only that entry is replaced, so a card swaps to its own art and title as soon as its
product has been asked about while the cards around it keep their objects - no list-wide repaint, no reset
of the scroll or the focus. A product this round finds uninstallable is dropped when the round ends, not in
the middle of it. The progress bar is gone once the grid has games, so a sync in progress no longer reads
as a list still loading.
- **The art swap has no gap** (`GogLibrary.sync`, `StoresPage`): a card that swaps from the listing's cover to
the wide background keeps the cover while the new one decodes - the fetched record carries the cover the
card already shows, and the card's request names it as the memory-cache placeholder - so no card goes dark
in the middle of a sync.
- **The per-product fetch stays** (`fetchGame`): `api.gog.com` is what has the description, the developer,
the publisher, the Galaxy portrait and the build generation, and the detail page reads all of those from
the library entry, so the listing alone cannot replace it.
- **The cache keeps only what was fetched**: a listing entry that never got its details is asked about again
next sync rather than kept as a bare title, and a product the last sync found uninstallable stays out of
the list while it is re-checked. The cache's own entry stays on screen even while it is re-fetched, so a
forced refresh does not drop back to box art.
- **A card patch adds what it brought** (`patchItems`, `GogBackend`): a product that comes back is patched into the
grid where its title belongs, whether or not the grid already had that card. Replacing only the entries already
there left a sync with nothing painted - the owned-ids fallback - showing an empty grid for the whole round. An
empty listing is no longer posted either: that dropped the cards already on screen.
- **A bar needs an empty tab** (`StoresPage`): the bar is drawn only for a sync line that carries a count ("25/55")
and only where the tab has nothing else on it - the storefront's shelves and the Installed tab's own cards are
content - so a library sync no longer creeps along above cards that are already there, and a line that only says
what it is doing leaves the empty state to say it.
- **A page that fails keeps the pages that came** (`GogLibrary`): a listing page that cannot be read ends the
listing instead of discarding it, so a page lost to a flaky request no longer costs the whole early paint. The
cache is saved as the round goes, so a sync the user closes the app on still leaves a library to paint next launch.
- **The hero waits under the card's art** (`StoresDetail`): the library's hero asked for the wide art with no
placeholder of its own, so a card that opened showed its own bitmap only for the length of the opening
animation and then fell back to the title's colour until 300-540KB had been decoded. It now builds the same
request a card does, naming the card's art as the memory-cache placeholder, so the cover stays under the hero
until the wide one lands.
- **The listing says what it gave** (`GogLibrary`, `StoreNet`): one line per sync in the stores' log - how many
games the listing carried, or the page that could not be read - and every failed store GET, which used to
reach logcat only. A shared log can now show whether the account listing came back at all.
- **Tests** (`GogListingTest`, `StoreCatalogPatchTest`): the filters - movies, other platforms, Galaxy's own entry, empty titles - the
fields a card needs, and a response that is not a listing.
## 2026-10-10 - `feat/wincomp-auto-sources`: Windows components picked by the game's source
- **Per source** (`WinCompSources`): Steam - Steamworks Shared depots from the appmanifest or the
+6 -2
View File
@@ -195,8 +195,12 @@ rendering changes.
### Experimental flat games in SteamVR
Start SteamVR first, then add `droiddeck-steamvr-game %command%` to a flat
game's Steam launch options. Remove that prefix to restore normal panel launch.
A game Steam lists without any VR support, launched while SteamVR runs, opens as
a SteamVR panel automatically: the Proton and FEX launchers ask Steam whether the
app supports VR (`droiddeck-agent --steam-supports-vr`; optional-VR games such as
Thumper launch normally) and wrap it in
`droiddeck-steamvr-game` (`droiddeck-steamvr-flat`). Adding
`droiddeck-steamvr-game %command%` to a game's launch options does the same by hand.
This runs a nested, unmodified Gamescope OpenVR backend for that game. Gamescope
owns the GPU overlay, placement and input routing; no CPU screen capture or
PipeWire service is used. The existing DroidDeck Vulkan synchronization layer
+5 -2
View File
@@ -23,9 +23,10 @@ This describes the integrations implemented in DroidDeck as of 2026-10-17. A rec
| Recognized RayNeo / TCL Air-series devices | Integrated RayNeo USB transport | Yes, with orientation calibration controls | No | No |
| RayNeo GT-series devices matching the supported USB identity, including GT Max identification | Integrated GT USB/IMU path | Yes, with orientation calibration controls | No | No |
| **XREAL 1S** | **Experimental**; exact USB identity plus the device's USB-Ethernet control/IMU connection | Yes, when that connection is ready | No | No |
| Rokid Max; Rokid Air under the same USB identity | Integrated Rokid USB transport (vendor control requests and HID IMU reports) | Yes | No | No |
| Other XREAL models; unrecognized glasses; display adapters and docks | Display-only where Android exposes a usable display; automatic glasses routing also requires display recognition | No supported app tracking connection | No | No |
RayNeo's Air-series recognition uses its known USB identity or a RayNeo/TCL Air name under the accepted vendor IDs; it is not a per-model certification list. The GT vendor path requires the specific supported product ID. XREAL support currently targets **1S only**: One, One Pro, Air-family devices, and recovery-mode products are not enabled by the 1S transport. VITURE Pro 2 is identified through SDK validation rather than a guessed product ID. A dock does not supply the connected glasses' sensors by itself.
RayNeo's Air-series recognition uses its known USB identity or a RayNeo/TCL Air name under the accepted vendor IDs; it is not a per-model certification list. The GT vendor path requires the specific supported product ID. Rokid recognition requires USB 04d2:162f plus a Rokid product name, since that vendor ID is shared with unrelated devices; it was verified on a Rokid Max, and the Air follows the same published protocol untested. XREAL support currently targets **1S only**: One, One Pro, Air-family devices, and recovery-mode products are not enabled by the 1S transport. VITURE Pro 2 is identified through SDK validation rather than a guessed product ID. A dock does not supply the connected glasses' sensors by itself.
The final column refers specifically to Luma Ultra's stereo tracking cameras. DroidDeck's separate phone-camera and physical-controller features are independent of this matrix.
@@ -42,6 +43,8 @@ All display modes depend on the phone's video output, the cable/adapter, and And
| VITURE Pro 2 | 1080p per eye; 2D and SBS | Brightness and volume; no electrochromic-film control |
| RayNeo Air/GT | 2D/SBS switching; resolution and refresh follow available Android modes | Orientation calibration; no app brightness, volume, or dimming commands |
| XREAL 1S | Supported 1S display-mode commands, including native 1200p/60 Hz and SBS | Brightness and dimming toggle; no app volume command |
| Rokid Max | 1080p at 60 or 120 Hz in 2D; SBS at 1080p/60, 1200p/60, or 1200p/90 | Brightness; volume follows Android's USB audio volume; no dimming film |
| Rokid Air | 1080p/60 in 2D and SBS | Brightness; volume follows Android's USB audio volume |
DroidDeck saves separate **2D resolution**, **3D resolution**, and **VR resolution** preferences. Unsupported saved choices fall back to the connected model's automatic behavior. Native **30 Hz** is offered only when Android advertises a matching mode and glasses presentation output is enabled. Higher refresh selections are constrained by the active 2D/SBS layout and model; a firmware-rejected switch is not treated as successful until the physical display confirms it.
@@ -78,4 +81,4 @@ If only a flat picture is available, check video output first, then the control
- [Agent diagnostics and capture commands](agent-control.md)
- [RayNeo attribution and protocol references](third-party/rayneo/README.md)
The capability definitions are maintained in [VITURE models](../app/src/main/java/com/droiddeck/launcher/glasses/VitureProtocol.kt), [RayNeo models](../app/src/main/java/com/droiddeck/launcher/glasses/RayNeoModel.kt), [XREAL 1S](../app/src/main/java/com/droiddeck/launcher/glasses/XrealModel.kt), and [connection capability routing](../app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt). Update this matrix when those integrations change.
The capability definitions are maintained in [VITURE models](../app/src/main/java/com/droiddeck/launcher/glasses/VitureProtocol.kt), [RayNeo models](../app/src/main/java/com/droiddeck/launcher/glasses/RayNeoModel.kt), [XREAL 1S](../app/src/main/java/com/droiddeck/launcher/glasses/XrealModel.kt), [Rokid](../app/src/main/java/com/droiddeck/launcher/glasses/RokidModel.kt), and [connection capability routing](../app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt). Update this matrix when those integrations change.
+10 -6
View File
@@ -2,13 +2,18 @@
## Included
None of these files ship in the APK. The app downloads them on first use as one tracking pack
(`tracking.tar.zst`), built in CI by `tools/packs/build.sh` from the pinned sources
below, together with `libopencv_java4.so` and `libmediapipe_tasks_jni.so` taken unchanged from
the OpenCV and MediaPipe Maven AARs.
[MediaPipe](https://github.com/google-ai-edge/mediapipe) Tasks Vision 1.0.0
(`com.google.mediapipe:tasks-vision`, shared with the Luma stereo tracking pipeline;
copyright Google LLC and the MediaPipe authors, Apache License 2.0, `LICENSE_MEDIAPIPE` here) finds
the player's body in each camera frame. It comes from Maven Central with its dependencies
(Guava, Flogger, protobuf-javalite and Google's `datatransport`), all Apache-2.0.
`app/src/main/assets/handtracking/pose_landmarker_lite.task` is MediaPipe's Pose Landmarker (Lite)
`pose_landmarker_lite.task` in the tracking pack (below) is MediaPipe's Pose Landmarker (Lite)
model, BlazePose GHUM 3D, unchanged from
`https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_lite/float16/1/pose_landmarker_lite.task`
(SHA-256 `59929e1d1ee95287735ddd833b19cf4ac46d29bc7afddbbf6753c459690d574a`). Its
@@ -16,7 +21,7 @@ model, BlazePose GHUM 3D, unchanged from
licenses it under the Apache License 2.0 and lists its limits: one person, up to about 4 metres
from the camera, the head in view, and depth that is approximate rather than metric.
`app/src/main/assets/handtracking/hand_landmarker.task` is MediaPipe's Hand Landmarker (full) model
`hand_landmarker.task` in the tracking pack is MediaPipe's Hand Landmarker (full) model
bundle, a palm detector and a hand landmark model, unchanged from
`https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task`
(SHA-256 `fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1`). Its
@@ -24,14 +29,13 @@ bundle, a palm detector and a hand landmark model, unchanged from
licenses it under the Apache License 2.0; it gives 21 landmarks per hand in the picture and in metres,
based on the GHUM hand model, and is meant for prominently shown hands.
The Luma stereo pipeline defaults to the Full bundle at
`app/src/main/assets/models/hand_landmarker.task`, with the same checksum as the Full bundle
above. The optional `app/src/main/assets/models/hand_landmarker_lite.task` is built from
The Luma stereo pipeline defaults to the same Full bundle. The optional
`hand_landmarker_lite.task` is built from
the official `palm_detection_lite.tflite` and `hand_landmark_lite.tflite` assets at
`https://storage.googleapis.com/mediapipe-assets/`. It uses the matching tensor metadata and
associated labels from the Full task bundle. These models share the MediaPipe hand tracking
model card and Apache License 2.0. Source checksums and the generated bundle checksum are in
`app/src/main/assets/models/hand_landmarker_lite.provenance.json`; `tools/build_hand_lite.py`
`tools/packs/tracking/hand_landmarker_lite.provenance.json`; `tools/build_hand_lite.py`
reproduces the bundle with MediaPipe 0.10.21 metadata tooling.
[CameraX](https://developer.android.com/jetpack/androidx/releases/camera) 1.4.2