VR roadmap: step 2's second part built on feature/vr-comfort

Buttons remapped, the flashlight by tapping the head, finer turning and
vignette steps, the transparent geometry groups raised: what they do, the
settings, what the emulator showed and the headset tests for the Quest 3
and the Steam Frame.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.github/workflows/build.yml

@@ -237,13 +237,6 @@ jobs:
       GH_TOKEN: ${{ github.token }}
       GH_REPO: ${{ github.repository }}
     steps:
-      - uses: actions/checkout@v4
-        with:
-          sparse-checkout: |
-            port/android
-            port/third_party/extract-xiso
-            tools
-
       - uses: actions/download-artifact@v4
         with:
           pattern: halo-*
@@ -256,9 +249,6 @@ jobs:
             name="$(basename "$build")"
             (cd "$build" && zip -qr "$GITHUB_WORKSPACE/release/$name.zip" .)
           done
-          # the Steam Frame's installer (port/android/STEAM_FRAME.md): its
-          # bundle with the release APK, and the desktop file that fetches it
-          python3 tools/steam_frame_bundle.py artifacts/halo-android-release/app-release.apk release "$GH_REPO"
           ls -l release
 
       - name: Publish
@@ -272,7 +262,7 @@ jobs:
           subject="$(printf '%s' "${MESSAGE:-manual run}" | head -n 1)"
           printf '%s\n\nCommit: %s\nBuild: %s\n\nThe release builds are for playing; the debug builds stop at the first failed assertion and log it.\n' \
             "$subject" "$COMMIT_URL" "$RUN_URL" > notes.md
-          gh release create "$tag" release/* --target "$GITHUB_SHA" --latest \
+          gh release create "$tag" release/*.zip --target "$GITHUB_SHA" --latest \
             --title "Build $GITHUB_RUN_NUMBER (${GITHUB_SHA:0:7})" --notes-file notes.md
           echo "tag=$tag" >> "$GITHUB_OUTPUT"
 

.gitignore

@@ -30,8 +30,3 @@ original/
 
 # CI build outputs (tools/ci_build.py)
 dist/
-
-# The app signing key's local settings and keys (port/android/app/build.gradle; never commit)
-port/android/signing.properties
-*.jks
-*.keystore

port/android/README.md

@@ -155,15 +155,7 @@ select "Yes":
 To install over the previous version, each build must have the same
 signature. GitHub Actions signs each build with the key in the
 `ANDROID_KEYSTORE_BASE64` and `ANDROID_KEYSTORE_PASSWORD` secrets of the
-repository. A computer that builds for its own devices signs with the same
-key when `port/android/signing.properties` (not in the repository) names it:
-
-    storeFile=/path/to/halo-vr-release.jks
-    password=<the keystore's password>
-    keyAlias=halo
-
-Keep the keystore and its password safe: a lost key means every player must
-remove the app before the next version. If you installed a build that has a different signature, remove
+repository. If you installed a build that has a different signature, remove
 that build before you install a new build. Removing the app deletes its data
 folder: first make a copy of `maps/` and `save/`.
 

port/android/STEAM_FRAME.md

@@ -4,35 +4,6 @@ The same APK as for the Quest runs on the Steam Frame, in Lepton (SteamOS's
 Android, a Waydroid fork: Android 11, arm64), with SteamVR's OpenXR runtime.
 What differs is found at run time, not by a build of its own.
 
-## Installing it (players)
-
-On the Frame, in Desktop Mode (Steam menu > Power > Switch to Desktop):
-1. Put a disc image of Halo: Combat Evolved for the Xbox (`.iso` or
-   `.xiso`, any version) in Downloads (or Documents, the Desktop, a memory
-   card).
-2. Download `Install-Halo-VR.desktop` from the latest release and open it
-   (double-click; confirm running it).
-3. Answer the dialogs: the installer finds the disc image (or asks for it),
-   copies the game data out of it, adds "Halo VR" to the Steam library and
-   switches back to Gaming Mode. Start Halo VR from the library there.
-
-Opening the same file again updates the game (settings, saves and game data
-stay).
-
-The desktop file (`steam_frame_installer.desktop`) downloads the latest
-release's `halo-vr-steam-frame.zip` (`tools/steam_frame_bundle.py`, made by
-the release job of `.github/workflows/build.yml`) and runs its
-`install.sh` (`steam_frame_install.sh`), with zenity dialogs:
-- `~/Documents/HaloCE`: the launcher (`halo-vr.sh`) and the release APK;
-- the maps folder out of the disc image (`steam_frame_xiso.py`, the app's
-  `XisoExtractor.java` in Python), unless `maps/ui.map` is there;
-- the Steam shortcut (`shortcuts.vdf` as below, with `OpenVR` set, and the
-  library pictures), unless it is there: Steam is closed for that, as it
-  writes its shortcuts back when it quits.
-
-`HALO_VR_UNATTENDED=1` (and `HALO_VR_IMAGE=<image>`) runs it without
-dialogs, for testing over adb; it leaves Steam and its shortcuts alone.
-
 ## The device
 
 - Steam Settings > System > Enable Developer Mode; then start "Lepton
@@ -104,11 +75,9 @@ beside Lepton's `<frame-ip>:5555`.
 
 Lepton uninstalls the app and empties its folders whenever it starts again.
 The game's data lives in the SteamOS user's Documents instead: when
-`/home/steamos/Documents` can be written, the launcher makes
-`/home/steamos/Documents/HaloCE` and the launcher and the game take it as
-their data folder (config.toml, saves and debug.txt go there too), so a
-disc image imported in the app stays as well. The installer above fills it;
-by hand, once:
+`/home/steamos/Documents/HaloCE` holds `maps/ui.map` and is writable, the
+launcher and the game take it as their data folder (config.toml, saves and
+debug.txt go there too). Once:
 
     adb -s <frame-ip>:5555 shell mkdir -p /home/steamos/Documents/HaloCE/maps
     adb -s <frame-ip>:5555 push assets/maps/. /home/steamos/Documents/HaloCE/maps/

port/android/VR_ROADMAP.md

@@ -35,11 +35,11 @@ named where code is taken over.
 | --- | --- | --- |
 | 1 | Steam Frame CPU time: Mesa's trace markers off (after astromaddie/HaloCE-VR), no `glGet` stalls in the visibility counters' copies | **done** (in `main` 2026-10-06): markers quieted, no problems; the frame's work about unchanged (11-12.5 ms of 13.9 in a bot game) |
 | 3a | Visible arms and hands: the arms by IK to the controllers, fingers by trigger and grip | **done** (in `main` 2026-10-06; Quest 3 and Steam Frame good; 0.02 ms a frame) |
-| 2 | Controls and comfort: left-handed mode, buttons remapped, flashlight by tapping the head, finer turning and vignette choices, graphics presets and refresh rate in the VR options | first part **done** (in `main` 2026-10-06; Quest 3 and Steam Frame good): left-handed mode, graphics presets, refresh rate and resolution in the VR options. Left: buttons remapped, flashlight by tapping the head, finer turning and vignette choices |
+| 2 | Controls and comfort: left-handed mode, buttons remapped, flashlight by tapping the head, finer turning and vignette choices, graphics presets and refresh rate in the VR options | first part **done** (in `main` 2026-10-06; Quest 3 and Steam Frame good): left-handed mode, graphics presets, refresh rate and resolution in the VR options. Second part **built** (branch `feature/vr-comfort`, headset test pending): buttons remapped, flashlight by tapping the head, finer turning and vignette choices |
 | 3b | The whole body: torso from head and hands, legs and feet following in the room; full / arms only / hands only | |
 | 3c | Weapons held physically, holsters at shoulder and hip (the buttons stay) | |
 | 3d | Other VR players shown with their heads, hands and bodies (today their bodies move as flat players' do: only their aim and throws come from their hands) | |
-| 4 | Later: disc image import in the launcher, sprint by arm swing (offline) | import **built** (branch `feature/release-install`): the app's import (Quest; on the Frame now kept in `~/Documents/HaloCE`), a Steam Frame installer from Desktop Mode (`STEAM_FRAME.md`), a release signing key; test pending |
+| 4 | Later: disc image import in the launcher, sprint by arm swing (offline) | |
 
 ## Step 2, first part (done)
 
@@ -106,7 +106,7 @@ the GPU's fill.
 
 VR options (Y): two pages, PLAY (the comfort rows, "Weapon hand",
 "Mirrored controls") and MORE ("Graphics", "Refresh rate", "Resolution",
-the controller buttons page, Quit). The refresh rate steps through what
+the controller buttons page, Quit); four since the second part (below). The refresh rate steps through what
 the runtime offers and changes at once; on the Steam Frame the row shows
 SteamOS's rate. The resolution (`vr.resolution_scale`, 70-120%) takes a
 restart. The controller buttons page shows the layout as set.
@@ -136,6 +136,100 @@ To try in the headset (Quest 3 and Steam Frame):
    in a bot game; Max on the Quest at 90 Hz; refresh rates 72/80/90/120
    on the Quest; the Frame's row.
 
+## Step 2, second part (built)
+
+On branch `feature/vr-comfort`, not yet tried in the headset. The VR
+options (Y) have four pages: PLAY ("Weapon hand", "Mirrored controls",
+laser, crosshair, motion tracker, body, fingers, the Warthog's wheel),
+COMFORT (turning, the vignettes), BUTTONS (the actions' buttons, the
+flashlight's tap, "Reset buttons to defaults", the controller buttons
+page) and MORE (graphics, refresh rate, resolution, Quit).
+
+Buttons remapped (BUTTONS page; `vr.c` `controls_remapped`):
+- Jump, the flashlight (held: switch grenades), action/reload, switch
+  weapon, crouch, zoom and melee each go on one of seven buttons: A, B,
+  X, Y, the move stick's click, the turning stick's, the weapon hand's
+  grip. Moving an action to a button swaps it with the action there, so
+  none is ever left without one.
+- The triggers, the free hand's grip, the menu button, the Steam Frame's
+  bumpers, D-pad and View button keep theirs; the menus keep the buttons
+  as they are.
+- Applied after the left-handed mirroring, on the gamepad's sides: the
+  same on the Touch and the Frame controllers, and a left-handed player's
+  buttons are the mirror image of the right-handed ones (on the Frame,
+  mirrored, the left D-pad's). The defaults are the old layout, the
+  host's bindings and the ABI unchanged.
+- The melee's aim and jab follow its button; the grips on a Warthog's
+  wheel press nothing, whatever the grip does.
+- The controller buttons page shows each action where its button is.
+
+Flashlight by tapping the head (`vr.c` `flashlight_gesture_update`,
+after HaloCE-Quest-VR, CC0): either hand to the side or the top of the
+head and away, as a tap, toggles it; the button still does. A zone in
+the head's axes beside or over the head, never more than 6 cm in front
+of the eyes (a scope at the eye, a two-handed weapon, a punch and the
+wrist's tracker are in front of the face); the hand comes from 35 cm
+away, slower than 3 m/s, stays 40 to 600 ms, alone, and leaves; a second
+between toggles. None in the menus, with a grenade held or just thrown,
+just after a melee, with both hands on the weapon, the weapon hand while
+the scope is drawn, a hand on the wheel. A short rumble in the tapping
+hand. Its logic was run in a harness off the headset; the feel is the
+headset's to judge.
+
+Comfort (COMFORT page): snap turns 10 to 45 degrees by 5, 60, 75, 90;
+smooth turning 30 to 150 degrees a second by 15, then to 300 by 30; the
+vehicle vignette Off, 15 to 100%; the on-foot vignette (off by default)
+while the stick turns smoothly, or also while the move stick moves, as
+far as the sticks are pushed, with its own strength. The old values are
+among the steps; defaults unchanged.
+
+Transparent geometry: room for 2048 groups a window (the Xbox's 384,
+below).
+
+| Setting | Values |
+| --- | --- |
+| `vr.button_jump` | `"a"` (default), `"b"`, `"x"`, `"y"`, `"move_stick"`, `"turn_stick"`, `"grip"`: as right-handed, mirrored with `vr.mirror_controls` |
+| `vr.button_light` | the flashlight, held switch grenades; `"b"` (default) |
+| `vr.button_action` | action, reload; `"x"` (default) |
+| `vr.button_weapon` | switch weapon; `"y"` (default) |
+| `vr.button_crouch` | `"move_stick"` (default) |
+| `vr.button_zoom` | `"turn_stick"` (default) |
+| `vr.button_melee` | `"grip"` (default) |
+| `vr.flashlight_gesture` | `true` (default): a tap of the head toggles the flashlight |
+| `vr.foot_vignette` | `"off"` (default), `"turning"` (smooth turns), `"moving"` (and moving) |
+| `vr.foot_vignette_strength` | 0.15 to 1, `0.7` (default) |
+| `debug.vr_options` | `false` (default); `true` shows the VR options off the headset (the emulator) |
+
+Checked in the emulator (`debug.vr_options`): the four pages without
+overlaps, each row's values, swaps and reset, the controller buttons page
+right- and left-handed after swaps, the settings kept over a restart, a
+15-bot game as before.
+
+To try in the headset (Quest 3 and Steam Frame):
+1. Defaults: every button as before (jump, light/held grenades, action,
+   switch weapon, crouch, zoom, melee by grip and by swing), right- and
+   left-handed, mirrored and not; the menus' A and B.
+2. BUTTONS: swap jump and melee (jump on the grip, melee on A): both work,
+   the melee jabs and aims where the head looks; light on a stick click
+   (tap: light, hold: grenades); the controller buttons page says so.
+   At the Warthog's wheel with jump on the grip: no jump while holding
+   the wheel. Reset: all back.
+3. The same left-handed with mirrored controls (on the Frame the left
+   D-pad), and with `Mirrored controls: Off`.
+4. Flashlight tap with either hand, beside the head and over it; the
+   rumble; the flashlight button still works. No toggle while: aiming
+   through the sniper's and the pistol's scope, holding the weapon with
+   both hands, holding and throwing a grenade (overhand past the ear),
+   punching and swinging, putting on or adjusting the headset with both
+   hands or one, looking at the wrist's tracker, at the wheel.
+5. COMFORT: snap 10 and 90, smooth 30 and 300; vehicle vignette 15% and
+   100%; on-foot vignette "Smooth turns" (nothing with snap turns),
+   "Moving, turning", strength 15% and 100%; no vignette in a vehicle
+   from the on-foot one, none in the menus.
+6. A game of 30 and more players: effects, glass and water stay; the log
+   (`adb logcat -s halo`) says `rasterizer: N transparent geometry groups
+   in a window` once a window passes 384; frame time as before.
+
 ## Step 3a (done)
 
 Tried on the Quest 3 and the Steam Frame, in `main`. The arm IK,
@@ -194,10 +288,11 @@ the left hand animated through reloads.
 - Multiview on the Steam Frame: why the eyes do not fuse there (suspected
   Mesa zink/Turnip); tools in branch `frame/doubled-images` (86335828),
   not merged.
-- Transparent geometry groups: the Xbox's 384 a window overflow in games
-  of 30 and more players.
-- The VR on-screen keyboard shows a password in the clear while it is
-  typed.
+- Transparent geometry groups: the Xbox's 384 a window overflowed in
+  games of 30 and more players (the last submitted, glass, water,
+  particles, contrails, vanished). Raised to 2048 (320 KB) on
+  `feature/vr-comfort`, to check in a large game (step 2, second part,
+  test 6); upstream still has 384.
 
 ## Headset tests (2026-10-06, all three in `main`)
 

port/android/app/build.gradle

@@ -13,22 +13,9 @@ def buildNumberText = System.getenv("HALO_BUILD_NUMBER") ?: "0"
 def buildNumber = buildNumberText.isInteger() ? buildNumberText.toInteger() : 0
 
 // the workflow's signing key (.github/workflows/build.yml): every build of
-// main signed with it can install over the one before; on a computer that
-// builds for its own devices, the same key from port/android/signing.properties
-// (not in the repository: storeFile, password, keyAlias), so that its
-// builds and the releases install over each other; without either, the
+// main signed with it can install over the one before; without it, the
 // debug key of the computer that builds
 def signingKey = System.getenv("HALO_ANDROID_KEYSTORE")
-def signingPassword = System.getenv("HALO_ANDROID_KEYSTORE_PASSWORD")
-def signingAlias = System.getenv("HALO_ANDROID_KEY_ALIAS") ?: "halo"
-def signingProperties = new File(rootDir, "signing.properties")
-if (!signingKey && signingProperties.isFile()) {
-    def properties = new Properties()
-    signingProperties.withInputStream { properties.load(it) }
-    signingKey = properties.getProperty("storeFile")
-    signingPassword = properties.getProperty("password")
-    signingAlias = properties.getProperty("keyAlias", "halo")
-}
 
 android {
     namespace "com.halo.decomp"
@@ -73,9 +60,9 @@ android {
         if (signingKey) {
             halo {
                 storeFile file(signingKey)
-                storePassword signingPassword
-                keyAlias signingAlias
-                keyPassword signingPassword
+                storePassword System.getenv("HALO_ANDROID_KEYSTORE_PASSWORD")
+                keyAlias System.getenv("HALO_ANDROID_KEY_ALIAS") ?: "halo"
+                keyPassword System.getenv("HALO_ANDROID_KEYSTORE_PASSWORD")
             }
         }
     }

port/android/app/src/main/java/com/halo/decomp/LauncherActivity.java

@@ -49,15 +49,10 @@ public class LauncherActivity extends Activity {
         dataRoot = getExternalFilesDir(null);
         // the Steam Frame: Lepton empties the app's own folders whenever it
         // starts again; the game's data lives in the SteamOS user's
-        // Documents instead, whenever they can be written, so that a disc
-        // image imported here stays too (port/android/STEAM_FRAME.md; the
-        // same choice as host_main.c's)
-        File shared = new File(SHARED_DATA_ROOT);
-        if (shared.getParentFile().canWrite() || shared.canWrite()) {
-            shared.mkdirs();
-            if (shared.canWrite())
-                dataRoot = shared;
-        }
+        // Documents instead, when it is there (port/android/STEAM_FRAME.md;
+        // the same choice as host_main.c's)
+        if (new File(SHARED_DATA_ROOT, "maps/ui.map").isFile() && new File(SHARED_DATA_ROOT).canWrite())
+            dataRoot = new File(SHARED_DATA_ROOT);
         // created by the app, so that files pushed into it with adb stay
         // readable (a directory adb creates there belongs to the shell user)
         if (dataRoot != null)

port/android/host/host_main.c

@@ -273,9 +273,9 @@ static void *game_main(void *unused)
 		host_fatal("Android storage is unavailable: %s", SDL_GetError());
 	/* the Steam Frame: Lepton empties the app's own folders whenever it
 	starts again; the game's data lives in the SteamOS user's Documents
-	instead, whenever they can be written (port/android/STEAM_FRAME.md; the
-	same choice as LauncherActivity's, which makes the folder) */
-	if (access(SHARED_DATA_ROOT, W_OK) == 0)
+	instead, when it is there (port/android/STEAM_FRAME.md; the same choice
+	as LauncherActivity's) */
+	if (directory_has_maps(SHARED_DATA_ROOT) && access(SHARED_DATA_ROOT, W_OK) == 0)
 		external = SHARED_DATA_ROOT;
 	snprintf(data_root, sizeof(data_root), "%s", external);
 	snprintf(save_root, sizeof(save_root), "%s/save", external);

port/android/steam_frame_install.sh

@@ -1,266 +0,0 @@
-#!/bin/bash
-# Halo VR's installer for the Steam Frame, run in its Desktop Mode from the
-# bundle the release's "Install Halo VR" desktop file downloads
-# (steam_frame_installer.desktop; the bundle: this script, HaloVR.apk,
-# halo-vr.sh = steam_frame_launch.sh, steam_frame_xiso.py and the library
-# pictures in grid/). Everything is answered with dialogs, no keyboard:
-# - the game in ~/Documents/HaloCE (port/android/STEAM_FRAME.md), its APK
-#   replaced (Lepton installs a newer one at the next start), so running the
-#   installer again updates the game;
-# - the game data: the maps folder copied out of a disc image of Halo
-#   (.iso or .xiso) found in Downloads, Documents, the Desktop or on a
-#   memory card, or chosen, unless it is there already;
-# - "Halo VR" in the Steam library, with its pictures, unless it is there
-#   already: Steam is closed for that (it keeps its shortcuts in memory and
-#   writes them back when it quits), and started again in Gaming Mode.
-# HALO_VR_UNATTENDED=1 answers every question with its default and prints
-# instead of showing dialogs (HALO_VR_IMAGE: the disc image to use), for
-# testing over adb; it never closes Steam.
-
-BUNDLE="$(cd "$(dirname "$0")" && pwd)"
-HALO_DIR="$HOME/Documents/HaloCE"
-STEAM_DIR="$HOME/.local/share/Steam"
-LEPTON="$STEAM_DIR/steamapps/common/Lepton/lepton"
-TITLE="Halo VR"
-NAME="Halo VR"
-EXE="\"$HALO_DIR/halo-vr.sh\""
-
-unattended() { [ "${HALO_VR_UNATTENDED:-0}" = 1 ] || ! command -v zenity >/dev/null; }
-
-info()
-{
-    if unattended; then printf "info: %b\n" "$1"; else zenity --info --title="$TITLE" --width=460 --text="$1"; fi
-}
-
-fail()
-{
-    if unattended; then printf "error: %b\n" "$1" >&2; else zenity --error --title="$TITLE" --width=460 --text="$1"; fi
-    exit 1
-}
-
-# yes/no; unattended: the default given ($2, "yes" or "no")
-ask()
-{
-    if unattended; then [ "$2" = yes ]; return; fi
-    zenity --question --title="$TITLE" --width=460 --text="$1"
-}
-
-# the disc image the player chooses
-choose_image()
-{
-    if unattended; then return 1; fi
-    zenity --file-selection --title="Choose a disc image of Halo: Combat Evolved (.iso or .xiso)" \
-        --filename="$HOME/Downloads/" --file-filter="Disc images | *.iso *.ISO *.xiso *.XISO" \
-        --file-filter="All files | *"
-}
-
-# the disc images near at hand, largest first (a Halo image is a few GB;
-# anything under 500 MB is not one)
-find_images()
-{
-    find "$HOME/Downloads" "$HOME/Documents" "$HOME/Desktop" /run/media -maxdepth 3 -type f \
-        \( -iname '*.iso' -o -iname '*.xiso' \) -size +500M -printf '%s\t%p\n' 2>/dev/null |
-        sort -rn | cut -f2-
-}
-
-extract_maps()
-{
-    local image="$1" log
-    log="$(mktemp)"
-    if unattended; then
-        python3 "$BUNDLE/steam_frame_xiso.py" "$image" "$HALO_DIR" 2>"$log" | grep '^#' | tail -n 1
-        status=${PIPESTATUS[0]}
-    else
-        python3 "$BUNDLE/steam_frame_xiso.py" "$image" "$HALO_DIR" 2>"$log" |
-            zenity --progress --title="$TITLE" --width=460 --auto-close --no-cancel \
-                --text="Copying the game data out of the disc image..."
-        status=${PIPESTATUS[0]}
-    fi
-    if [ "$status" != 0 ]; then
-        reason="$(sed -n 's/^error: //p' "$log" | head -n 1)"
-        rm -f "$log"
-        fail "The game data could not be copied out of\n$image\n\n${reason:-Unknown error.}"
-    fi
-    rm -f "$log"
-}
-
-# the shortcut's id as Steam makes it for a non-Steam game: its pictures in
-# config/grid are named after it
-shortcut_id()
-{
-    python3 -c 'import sys, zlib; print(zlib.crc32((sys.argv[1] + sys.argv[2]).encode()) | 0x80000000)' "$EXE" "$NAME"
-}
-
-# whether every Steam user's shortcuts.vdf already holds the game
-have_shortcut()
-{
-    local found=1 config
-    for config in "$STEAM_DIR"/userdata/*/config; do
-        [ -d "$config" ] || continue
-        case "$config" in */userdata/0/*) continue ;; esac
-        grep -qaF "$HALO_DIR/halo-vr.sh" "$config/shortcuts.vdf" 2>/dev/null || return 1
-        found=0
-    done
-    return $found
-}
-
-# "Halo VR" added to every Steam user's shortcuts.vdf (Steam closed), as a VR
-# title, with its pictures
-add_shortcut()
-{
-    local id config
-    id="$(shortcut_id)"
-    for config in "$STEAM_DIR"/userdata/*/config; do
-        [ -d "$config" ] || continue
-        case "$config" in */userdata/0/*) continue ;; esac
-        python3 - "$config/shortcuts.vdf" "$id" "$NAME" "$EXE" "\"$HALO_DIR/\"" <<'PYTHON' || return 1
-import os, struct, sys
-
-path, appid, name, exe, start = sys.argv[1], int(sys.argv[2]), sys.argv[3], sys.argv[4], sys.argv[5]
-
-# Steam's binary VDF: 0x00 a map, 0x01 a string, 0x02 an int32, 0x08 a map's end
-def read_map(data, at):
-    items = []
-    while True:
-        kind = data[at]; at += 1
-        if kind == 0x08:
-            return items, at
-        end = data.index(b"\0", at); key = data[at:end]; at = end + 1
-        if kind == 0x00:
-            value, at = read_map(data, at)
-        elif kind == 0x01:
-            end = data.index(b"\0", at); value = data[at:end]; at = end + 1
-        elif kind == 0x02:
-            value = struct.unpack_from("<I", data, at)[0]; at += 4
-        else:
-            raise ValueError("unknown VDF type %d" % kind)
-        items.append((kind, key, value))
-
-def write_map(items):
-    out = b""
-    for kind, key, value in items:
-        out += bytes([kind]) + key + b"\0"
-        if kind == 0x00:
-            out += write_map(value)
-        elif kind == 0x01:
-            out += value + b"\0"
-        else:
-            out += struct.pack("<I", value)
-    return out + b"\x08"
-
-shortcuts = []
-if os.path.exists(path):
-    with open(path, "rb") as file:
-        data = file.read()
-    if data:
-        top, _ = read_map(data, 0)
-        for kind, key, value in top:
-            if key.lower() == b"shortcuts" and kind == 0x00:
-                shortcuts = [entry for entry in value if entry[0] == 0x00]
-# (an older entry of the game's replaced)
-shortcuts = [entry for entry in shortcuts
-    if not any(k.lower() == b"exe" and v == exe.encode() for _, k, v in entry[2])]
-
-def text(key, value):
-    return (0x01, key.encode(), value.encode())
-
-def number(key, value):
-    return (0x02, key.encode(), value)
-
-entry = [
-    number("appid", appid), text("AppName", name), text("Exe", exe), text("StartDir", start),
-    text("icon", ""), text("ShortcutPath", ""), text("LaunchOptions", ""), number("IsHidden", 0),
-    number("AllowDesktopConfig", 1), number("AllowOverlay", 1), number("OpenVR", 1), number("Devkit", 0),
-    text("DevkitGameID", ""), number("DevkitOverrideAppID", 0), number("LastPlayTime", 0),
-    text("FlatpakAppID", ""), text("sortas", ""), (0x00, b"tags", []),
-]
-shortcuts.append((0x00, b"", entry))
-shortcuts = [(0x00, str(index).encode(), value) for index, (_, _, value) in enumerate(shortcuts)]
-data = write_map([(0x00, b"shortcuts", shortcuts)])
-with open(path + ".tmp", "wb") as file:
-    file.write(data)
-os.replace(path + ".tmp", path)
-PYTHON
-        mkdir -p "$config/grid"
-        cp "$BUNDLE/grid/library.png" "$config/grid/${id}.png"
-        cp "$BUNDLE/grid/libraryp.png" "$config/grid/${id}p.png"
-        cp "$BUNDLE/grid/library_hero.png" "$config/grid/${id}_hero.png"
-        cp "$BUNDLE/grid/library_logo.png" "$config/grid/${id}_logo.png"
-    done
-}
-
-# --- the game
-
-[ -x "$LEPTON" ] || fail "Lepton, which runs Android games on the Steam Frame, was not found.\n\nStart any Android game from the Steam store once, then run this installer again."
-for file in HaloVR.apk halo-vr.sh steam_frame_xiso.py grid/library.png; do
-    [ -f "$BUNDLE/$file" ] || fail "The installer is incomplete ($file is missing). Download it again."
-done
-
-if [ -f "$HALO_DIR/HaloVR.apk" ]; then
-    ask "Halo VR is installed already. Update it to this version?\n\n(Your settings, saves and game data stay.)" yes || exit 0
-else
-    ask "This installs Halo VR on your Steam Frame.\n\nYou need your own disc image of Halo: Combat Evolved for the Xbox (an .iso or .xiso file, any version), for example in Downloads.\n\nContinue?" yes || exit 0
-fi
-
-mkdir -p "$HALO_DIR/maps" || fail "Could not create $HALO_DIR."
-# (the game runs in Lepton's container as a user of its own)
-chmod 777 "$HALO_DIR" "$HALO_DIR/maps"
-cp "$BUNDLE/halo-vr.sh" "$HALO_DIR/halo-vr.sh.tmp" && chmod 755 "$HALO_DIR/halo-vr.sh.tmp" &&
-    mv -f "$HALO_DIR/halo-vr.sh.tmp" "$HALO_DIR/halo-vr.sh" || fail "Could not write $HALO_DIR/halo-vr.sh."
-# (newer than the installed one: Lepton installs it at the next start)
-cp "$BUNDLE/HaloVR.apk" "$HALO_DIR/HaloVR.apk.tmp" && chmod 666 "$HALO_DIR/HaloVR.apk.tmp" &&
-    mv -f "$HALO_DIR/HaloVR.apk.tmp" "$HALO_DIR/HaloVR.apk" && touch "$HALO_DIR/HaloVR.apk" ||
-    fail "Could not write $HALO_DIR/HaloVR.apk (is the storage full?)."
-
-# --- the game data
-
-if [ ! -f "$HALO_DIR/maps/ui.map" ]; then
-    image="${HALO_VR_IMAGE:-}"
-    if [ -z "$image" ]; then
-        mapfile -t images < <(find_images)
-        for candidate in "${images[@]}"; do
-            if ask "Use this disc image?\n\n$candidate" yes; then
-                image="$candidate"
-                break
-            fi
-        done
-    fi
-    if [ -z "$image" ]; then
-        if [ ${#images[@]} = 0 ]; then
-            info "No disc image was found in Downloads, Documents, on the Desktop or a memory card.\n\nChoose it in the next window."
-        fi
-        image="$(choose_image)" || fail "No disc image was chosen. Run the installer again once it is on the Frame (for example in Downloads)."
-    fi
-    extract_maps "$image"
-    chmod -R a+rwX "$HALO_DIR/maps"
-    image_note="\n\nThe disc image itself is no longer needed:\n$image"
-fi
-
-# --- Steam
-
-steam_closed=0
-if ! have_shortcut; then
-    if unattended; then
-        echo "info: the Steam shortcut is missing (not added unattended)"
-    else
-        info "Halo VR is now added to your Steam library. Steam closes for a moment for that."
-        if pgrep -x steam >/dev/null; then
-            steam -shutdown >/dev/null 2>&1 &
-            for _ in $(seq 60); do pgrep -x steam >/dev/null || break; sleep 1; done
-            pgrep -x steam >/dev/null && fail "Steam did not close. Close it (Steam menu > Exit) and run the installer again."
-        fi
-        steam_closed=1
-        add_shortcut || fail "Could not add Halo VR to the Steam library."
-    fi
-fi
-
-if unattended; then
-    echo "info: installed in $HALO_DIR"
-    exit 0
-fi
-if ask "Halo VR is installed.${image_note:-}\n\nSwitch to Gaming Mode now? Start Halo VR from your library there." yes; then
-    steamos-session-select gamescope >/dev/null 2>&1 ||
-        info "Switch to Gaming Mode yourself (the \"Return to Gaming Mode\" icon or the power menu)."
-elif [ "$steam_closed" = 1 ]; then
-    setsid steam >/dev/null 2>&1 < /dev/null &
-fi

port/android/steam_frame_installer.desktop

@@ -1,13 +0,0 @@
-[Desktop Entry]
-# Halo VR's installer for the Steam Frame (port/android/STEAM_FRAME.md): a
-# release asset, "Install-Halo-VR.desktop", opened in Desktop Mode. It
-# downloads the latest release's bundle (tools/steam_frame_bundle.py, which
-# fills in the repository) and runs its installer, steam_frame_install.sh.
-# (no "$", "\" or "%" in Exec: the desktop entry format would need them
-# escaped)
-Type=Application
-Name=Install Halo VR
-Comment=Installs Halo VR for the Steam Frame, or updates it
-Icon=steam
-Terminal=false
-Exec=bash -c "if curl -fL --retry 3 -o /tmp/halo-vr-steam-frame.zip https://github.com/@REPOSITORY@/releases/latest/download/halo-vr-steam-frame.zip && rm -rf /tmp/halo-vr-install && python3 -m zipfile -e /tmp/halo-vr-steam-frame.zip /tmp/halo-vr-install; then exec bash /tmp/halo-vr-install/install.sh; else zenity --error --width=460 --title='Halo VR' --text='Halo VR could not be downloaded. Is the Steam Frame online?'; fi"

port/android/steam_frame_xiso.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-"""
-Copies the maps folder out of an Xbox disc image (an "xiso", or a whole
-disc's ".iso") on the Steam Frame's SteamOS side, for its installer
-(steam_frame_install.sh). It reads the image as the app's own import does
-(app/src/main/java/com/halo/decomp/XisoExtractor.java, which this follows;
-the desktop games' is port/linux/src/xiso.c).
-
-    steam_frame_xiso.py <image> <destination>
-
-writes <destination>/maps (through maps.partial, so an interrupted copy
-never leaves maps/ui.map behind) and prints its progress for zenity
---progress: a percentage on a line of its own, and "# <text>" lines. On
-failure it prints "error: <reason the player can act on>" to stderr and
-exits 1.
-
-The image's file system is XDVDFS, read as extract-xiso does
-(https://github.com/XboxDev/extract-xiso, extract-xiso.c, whose format
-handling this follows; its license is below and in
-port/third_party/extract-xiso/LICENSE.TXT): 2048-byte sectors; a volume
-descriptor at 0x10000 that starts and ends with "MICROSOFT*XBOX*MEDIA" and
-gives the root directory's sector and size; and directories whose entries
-form a binary tree (each entry: left and right subtree offsets in 4-byte
-units, the start sector, the size, attributes, the name's length and the
-name). Images made from a whole disc put the game partition further in, at
-one of the offsets below.
-
-Some parts of this code are copyright in@fishtank.com. This product
-includes software developed by in <in@fishtank.com>.
-
-Copyright (c) 2003 in <in@fishtank.com>
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-3. All advertising materials mentioning features or use of this software
-   must display the following acknowledgement:
-
-   This product includes software developed by in <in@fishtank.com>.
-
-4. Neither the name of "in" nor the email address "in@fishtank.com"
-   may be used to endorse or promote products derived from this software
-   without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED `AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES
-INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
-AUTHOR OR ANY CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"""
-
-import os
-import struct
-import sys
-
-SECTOR_SIZE = 2048
-VOLUME_DESCRIPTOR_OFFSET = 0x10000
-ENTRY_HEADER_SIZE = 14
-ATTRIBUTE_DIRECTORY = 0x10
-# directory tables are a few sectors; anything much larger is not one
-MAXIMUM_DIRECTORY_SIZE = 4 << 20
-MAXIMUM_FILES = 256
-COPY_BUFFER_SIZE = 1 << 20
-VOLUME_MAGIC = b"MICROSOFT*XBOX*MEDIA"
-# where the game partition starts: a plain image, and whole-disc images
-# (extract-xiso's GLOBAL, XGD3 and XGD1 offsets)
-PARTITION_OFFSETS = (0, 0x0FD90000, 0x02080000, 0x18300000)
-
-
-class ExtractError(Exception):
-    """a reason the player can act on"""
-
-
-def read_at(image, offset, size):
-    image.seek(offset)
-    data = image.read(size)
-    if len(data) != size:
-        raise ExtractError("Could not read the disc image (is it complete?).")
-    return data
-
-
-def find_volume(image):
-    """the game partition's offset, and the root directory's sector and size"""
-    for offset in PARTITION_OFFSETS:
-        try:
-            descriptor = read_at(image, offset + VOLUME_DESCRIPTOR_OFFSET, SECTOR_SIZE)
-        except ExtractError:
-            continue
-        if descriptor[:20] != VOLUME_MAGIC or descriptor[0x7EC:0x7EC + 20] != VOLUME_MAGIC:
-            continue
-        sector, size = struct.unpack_from("<II", descriptor, 20)
-        return offset, sector, size
-    raise ExtractError("This is not an Xbox disc image.")
-
-
-def read_directory(image, partition, sector, size, what):
-    if size <= 0 or size > MAXIMUM_DIRECTORY_SIZE:
-        raise ExtractError(what)
-    return read_at(image, partition + sector * SECTOR_SIZE, size)
-
-
-def walk(table, offset, depth, directories, out, visited):
-    """collects the entries (name, sector, size) of the subtree at offset
-    (4-byte units), files or directories as asked"""
-    at = offset * 4
-    # a malformed table must not loop or run off its end
-    visited[0] += 1
-    if depth > 64 or visited[0] > 4096 or at + ENTRY_HEADER_SIZE > len(table):
-        return
-    left, right, sector, size, attributes, name_length = struct.unpack_from("<HHIIBB", table, at)
-    # 0xFFFF: padding, an empty directory
-    if left == 0xFFFF:
-        return
-    if left:
-        walk(table, left, depth + 1, directories, out, visited)
-    is_directory = bool(attributes & ATTRIBUTE_DIRECTORY)
-    if (at + ENTRY_HEADER_SIZE + name_length <= len(table) and name_length > 0
-            and is_directory == directories and len(out) < MAXIMUM_FILES):
-        name = table[at + ENTRY_HEADER_SIZE:at + ENTRY_HEADER_SIZE + name_length].decode("latin-1")
-        # (as extract-xiso refuses them: no name may leave the folder)
-        if name not in (".", "..") and "/" not in name and "\\" not in name:
-            out.append((name, sector, size))
-    if right:
-        walk(table, right, depth + 1, directories, out, visited)
-
-
-def extract(image_path, destination):
-    with open(image_path, "rb") as image:
-        partition, root_sector, root_size = find_volume(image)
-
-        # the root's maps folder
-        table = read_directory(image, partition, root_sector, root_size,
-            "The disc image's file system is damaged.")
-        directories = []
-        walk(table, 0, 0, True, directories, [0])
-        maps = [entry for entry in directories if entry[0].lower() == "maps"]
-        if not maps:
-            raise ExtractError("The disc image has no maps folder: it is not a Halo disc.")
-
-        # its files
-        table = read_directory(image, partition, maps[-1][1], maps[-1][2],
-            "The disc image's maps folder is damaged.")
-        files = []
-        walk(table, 0, 0, False, files, [0])
-        if not any(name.lower() == "ui.map" for name, _, _ in files):
-            raise ExtractError("The disc image's maps folder has no ui.map: it is not a Halo disc.")
-        total = sum(size for _, _, size in files) or 1
-
-        partial = os.path.join(destination, "maps.partial")
-        finished = os.path.join(destination, "maps")
-        try:
-            os.makedirs(partial, exist_ok=True)
-        except OSError:
-            raise ExtractError("Could not create %s." % partial)
-        done = 0
-        shown = -1
-        for name, sector, size in files:
-            path = os.path.join(partial, name)
-            offset = partition + sector * SECTOR_SIZE
-            remaining = size
-            print("# Copying maps/%s" % name, flush=True)
-            try:
-                with open(path, "wb") as out:
-                    while remaining > 0:
-                        count = min(remaining, COPY_BUFFER_SIZE)
-                        out.write(read_at(image, offset, count))
-                        offset += count
-                        remaining -= count
-                        done += count
-                        # (zenity closes at 100: that is left to the caller)
-                        percent = min(99, done * 100 // total)
-                        if percent != shown:
-                            print(percent, flush=True)
-                            shown = percent
-            except ExtractError:
-                raise ExtractError("Could not read %s from the disc image (is it complete?)." % name)
-            except OSError:
-                raise ExtractError("Could not write %s (is the storage full?)." % path)
-
-    # (the maps folder may be there, empty)
-    try:
-        os.makedirs(finished, exist_ok=True)
-        for name, _, _ in files:
-            os.replace(os.path.join(partial, name), os.path.join(finished, name))
-        os.rmdir(partial)
-    except OSError as error:
-        raise ExtractError("Could not move the maps into %s (%s)." % (finished, error.strerror))
-
-
-def main():
-    if len(sys.argv) != 3:
-        print("usage: steam_frame_xiso.py <image> <destination>", file=sys.stderr)
-        return 2
-    try:
-        extract(sys.argv[1], sys.argv[2])
-    except ExtractError as error:
-        print("error: %s" % error, file=sys.stderr)
-        return 1
-    except OSError as error:
-        print("error: Could not open the disc image (%s)." % error.strerror, file=sys.stderr)
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

port/linux/include/halo_vr.h

@@ -162,6 +162,9 @@ enum
 int halo_vr_body_mode(void);
 /* a hand has just been thrust forward: a melee attack (xinput_sdl.c) */
 int halo_vr_melee(void);
+/* a hand has just tapped the head (vr.flashlight_gesture): the flashlight's
+button, for a moment (xinput_sdl.c) */
+int halo_vr_flashlight_tap(void);
 /* the weight of the melee attack under way, from the swing's speed (0..1;
 0 with none): the game scales melee damage by the player's run instead,
 and in VR a player punches standing (units.c) */
@@ -252,6 +255,39 @@ int halo_vr_controller_layout(void);
 /* the hand that holds the weapon (HALO_XR_HAND_*: 1 the right, 0 the left,
 vr.handedness) */
 int halo_vr_weapon_hand(void);
+/* The game's actions on the controllers' buttons (vr.button_*; the VR
+options' BUTTONS page): each action on one of seven buttons, named as
+right-handed (A and B on the right controller, X and Y, the Quest's, on
+the left; the move stick's click, the turning stick's, the weapon hand's
+grip); left-handed with vr.mirror_controls, their mirror images. The
+actions are numbered by the button each has by default. The triggers, the
+free hand's grip, the menu button and the Steam Frame's bumpers, D-pad and
+View button keep theirs; the menus keep the buttons as they are. */
+enum
+{
+	HALO_VR_INPUT_A = 0,
+	HALO_VR_INPUT_B,
+	HALO_VR_INPUT_X,
+	HALO_VR_INPUT_Y,
+	HALO_VR_INPUT_MOVE_STICK,
+	HALO_VR_INPUT_TURN_STICK,
+	HALO_VR_INPUT_GRIP,
+	HALO_VR_INPUT_COUNT,
+
+	HALO_VR_ACTION_JUMP = HALO_VR_INPUT_A,
+	HALO_VR_ACTION_LIGHT = HALO_VR_INPUT_B,   /* a tap the flashlight; held, switch grenades */
+	HALO_VR_ACTION_ACTION = HALO_VR_INPUT_X,  /* action, reload */
+	HALO_VR_ACTION_WEAPON = HALO_VR_INPUT_Y,  /* switch weapon */
+	HALO_VR_ACTION_CROUCH = HALO_VR_INPUT_MOVE_STICK,
+	HALO_VR_ACTION_ZOOM = HALO_VR_INPUT_TURN_STICK,
+	HALO_VR_ACTION_MELEE = HALO_VR_INPUT_GRIP,
+	HALO_VR_ACTION_COUNT = HALO_VR_INPUT_COUNT,
+};
+/* an action's setting ("vr.button_jump"), a button's value in it ("a"),
+and the button an action is on, as set */
+const char *halo_vr_action_setting(int action);
+const char *halo_vr_input_value(int input);
+int halo_vr_action_input(int action);
 /* the graphics preset (vr.graphics; HALO_VR_GRAPHICS_HIGH outside VR): which
 effects are drawn (port/linux/game/vr_graphics.c), and with "max" the
 models lit for each pixel and larger shadows (d3d8_gl.c) */

port/linux/src/port_config.c

@@ -201,6 +201,28 @@ static const struct config_setting config_settings[] =
 		"and the left one turns, X jumps and A reloads (on the Steam Frame the\n"
 		"D-pad takes A, B, X and Y as their mirror image); false keeps them as\n"
 		"right-handed. The menus keep their buttons either way." },
+	{ "vr.button_jump", _config_string, "\"a\"", "HALO_VR_BUTTON_JUMP", _environment_value, _platform_android,
+		"The button each of the game's actions is on (the VR options' BUTTONS\n"
+		"page swaps them): \"a\", \"b\", \"x\", \"y\" (A and B on the right\n"
+		"controller, X and Y the Quest's on the left; the Steam Frame has all\n"
+		"four on the right), \"move_stick\" and \"turn_stick\" (their clicks),\n"
+		"\"grip\" (the weapon hand's), named as right-handed: left-handed with\n"
+		"mirror_controls, their mirror images. Jump," },
+	{ "vr.button_light", _config_string, "\"b\"", "HALO_VR_BUTTON_LIGHT", _environment_value, _platform_android,
+		"the flashlight (held: switch grenades)," },
+	{ "vr.button_action", _config_string, "\"x\"", "HALO_VR_BUTTON_ACTION", _environment_value, _platform_android,
+		"action and reload," },
+	{ "vr.button_weapon", _config_string, "\"y\"", "HALO_VR_BUTTON_WEAPON", _environment_value, _platform_android,
+		"switch weapon," },
+	{ "vr.button_crouch", _config_string, "\"move_stick\"", "HALO_VR_BUTTON_CROUCH", _environment_value,
+		_platform_android,
+		"crouch," },
+	{ "vr.button_zoom", _config_string, "\"turn_stick\"", "HALO_VR_BUTTON_ZOOM", _environment_value,
+		_platform_android,
+		"zoom" },
+	{ "vr.button_melee", _config_string, "\"grip\"", "HALO_VR_BUTTON_MELEE", _environment_value, _platform_android,
+		"and melee. The triggers, the free hand's grip and the menu button keep\n"
+		"theirs, as do the menus." },
 	{ "vr.laser", _config_boolean, "false", "HALO_VR_LASER", _environment_value, _platform_android,
 		"A laser from the weapon to what it aims at (with aim_with = \"controller\")." },
 	{ "vr.crosshair", _config_boolean, "true", "HALO_VR_CROSSHAIR", _environment_value, _platform_android,
@@ -229,6 +251,13 @@ static const struct config_setting config_settings[] =
 	{ "vr.arm_ik", _config_boolean, "true", "HALO_VR_ARM_IK", _environment_value, _platform_android,
 		"The free hand's arm bends at the elbow to reach it from the shoulder;\n"
 		"false keeps the arm's shape as on the weapon, pointed at the shoulder." },
+	{ "vr.flashlight_gesture", _config_boolean, "true", "HALO_VR_FLASHLIGHT_GESTURE", _environment_value,
+		_platform_android,
+		"Tapping the side or the top of your head with either hand (to it and\n"
+		"away again) turns the flashlight on or off; the flashlight's button\n"
+		"still does. Not while aiming through a scope, holding the weapon with\n"
+		"both hands, holding or throwing a grenade, just after a melee, or with\n"
+		"both hands at the head." },
 	{ "vr.melee_swing_speed", _config_real, "2.0", "HALO_VR_MELEE_SWING", _environment_value, _platform_android,
 		"Thrusting a hand forward faster than this, in metres per second, is a\n"
 		"melee attack (the weapon hand's grip is too); 0 turns it off." },
@@ -304,6 +333,13 @@ static const struct config_setting config_settings[] =
 	{ "vr.comfort_vignette", _config_real, "0.7", "HALO_VR_COMFORT_VIGNETTE", _environment_value, _platform_android,
 		"How far the view darkens from its edges while a vehicle turns you\n"
 		"(0 never, 1 to a small window)." },
+	{ "vr.foot_vignette", _config_string, "\"off\"", "HALO_VR_FOOT_VIGNETTE", _environment_value, _platform_android,
+		"On foot, the view darkens from its edges too: \"turning\" while the stick\n"
+		"turns you smoothly (smooth_turn), \"moving\" while a stick turns or moves\n"
+		"you, as far as it is pushed; \"off\" never." },
+	{ "vr.foot_vignette_strength", _config_real, "0.7", "HALO_VR_FOOT_VIGNETTE_STRENGTH", _environment_value,
+		_platform_android,
+		"How far it darkens then (as comfort_vignette)." },
 	{ "vr.motion_tracker_on_wrist", _config_boolean, "true", "HALO_VR_MOTION_TRACKER_WRIST", _environment_value,
 		_platform_android,
 		"Show the motion tracker on the back of the left wrist, like a watch (turn\n"
@@ -324,9 +360,11 @@ static const struct config_setting config_settings[] =
 	{ "vr.smooth_turn", _config_boolean, "false", "HALO_VR_SMOOTH_TURN", _environment_value, _platform_android,
 		"The right stick turns smoothly; false turns in steps (snap_turn_degrees)." },
 	{ "vr.snap_turn_degrees", _config_real, "30.0", "HALO_VR_SNAP_TURN", _environment_value, _platform_android,
-		"How far a flick of the right stick turns." },
+		"How far a flick of the right stick turns, in degrees (the VR options step\n"
+		"through 10 to 45 by 5, 60, 75 and 90)." },
 	{ "vr.smooth_turn_speed", _config_real, "120.0", "HALO_VR_SMOOTH_TURN_SPEED", _environment_value, _platform_android,
-		"Degrees per second the right stick turns at, fully pushed, with smooth_turn." },
+		"Degrees per second the right stick turns at, fully pushed, with smooth_turn\n"
+		"(the VR options step through 30 to 150 by 15, then to 300 by 30)." },
 	{ "vr.cinematics_in_3d", _config_boolean, "false", "HALO_VR_CINEMATICS_3D", _environment_value, _platform_android,
 		"Show cinematics around you, from the cinematic camera; false shows them\n"
 		"on the screen in front of you (easier on the stomach)." },
@@ -573,6 +611,9 @@ static const struct config_setting config_settings[] =
 		"The headset's layer copies: 1 deferred (no waits for the GL thread or the\n"
 		"GPU in the middle of the frame), 0 each one restored and released at once,\n"
 		"-1 as the runtime needs (deferred on SteamVR). Read when the app starts." },
+	{ "debug.vr_options", _config_boolean, "false", "HALO_DEBUG_VR_OPTIONS", _environment_value, _platform_android,
+		"Off the headset (the emulator), show the VR options panel on the main\n"
+		"and pause menus all the same, for checking its pages." },
 	{ "debug.mirror_first_person", _config_boolean, "false", "HALO_MIRROR_FIRST_PERSON", _environment_value,
 		_platform_android,
 		"Off the headset (flat), the first-person weapon drawn mirrored, as the\n"

port/linux/src/vr.c

@@ -17,6 +17,28 @@ yaw plus the head's.
 
 #include "halo_vr.h"
 
+/* the actions' settings and the buttons' values in them (halo_vr.h's
+HALO_VR_ACTION_* and HALO_VR_INPUT_*), by number */
+static const char *const vr_action_settings[HALO_VR_ACTION_COUNT] =
+{
+	"vr.button_jump", "vr.button_light", "vr.button_action", "vr.button_weapon", "vr.button_crouch",
+	"vr.button_zoom", "vr.button_melee",
+};
+static const char *const vr_input_values[HALO_VR_INPUT_COUNT] =
+{
+	"a", "b", "x", "y", "move_stick", "turn_stick", "grip",
+};
+
+const char *halo_vr_action_setting(int action)
+{
+	return action >= 0 && action < HALO_VR_ACTION_COUNT ? vr_action_settings[action] : "";
+}
+
+const char *halo_vr_input_value(int input)
+{
+	return input >= 0 && input < HALO_VR_INPUT_COUNT ? vr_input_values[input] : "";
+}
+
 #ifdef HALO_ANDROID
 
 #include "platform.h"
@@ -36,6 +58,14 @@ yaw plus the head's.
 /* the facing the game changes itself by more than this (a respawn, a
 teleport, a vehicle's seat) turns the body with it */
 #define FACING_JUMP (10.0f * PI / 180.0f)
+/* vr.foot_vignette: none on foot, while the stick turns smoothly, and
+while a stick turns smoothly or moves */
+enum
+{
+	FOOT_VIGNETTE_OFF = 0,
+	FOOT_VIGNETTE_TURNING,
+	FOOT_VIGNETTE_MOVING,
+};
 
 static struct
 {
@@ -133,9 +163,13 @@ static struct
 	float vehicle_steer_smoothing; /* seconds */
 	float steer[2];             /* the steering as smoothed: aside, up (-1..1) */
 	unsigned long long steer_last_us;
-	/* the comfort vignette: how strong at most, now, and the heading it
-	last saw */
+	/* the comfort vignette: how strong at most in a vehicle, on foot
+	(vr.foot_vignette: FOOT_VIGNETTE_*) and how strong there, now, and the
+	heading it last saw */
 	float comfort_vignette;
+	int foot_vignette;
+	float foot_vignette_strength;
+	int seated;                 /* in a vehicle's seat, whatever the view */
 	float vignette;
 	float vignette_last_yaw;
 	int vignette_yaw_valid;
@@ -178,6 +212,7 @@ static struct
 	captured, and where its disc is in LOCAL space */
 	int scope_pass;
 	int scope_captured;
+	int scope_last_frame;    /* the scope was drawn the frame before */
 	struct halo_xr_pose scope_pose;
 	int motion_tracker_on_wrist;
 	float motion_tracker_size;
@@ -220,9 +255,23 @@ static struct
 	/* until when a melee attack aims where the head looks: its damage is
 	dealt some ticks into the attack, along the unit's aim */
 	unsigned long long melee_aim_until_us;
-	int melee_grip_down;
+	int melee_button_down;
 	float melee_strength;    /* 0..1, the last attack's swing */
-	unsigned long long melee_jab_start_us; /* the weapon hand's grip's attack: the weapon jabs */
+	/* the flashlight by tapping the head (flashlight_gesture_update,
+	vr.flashlight_gesture): each hand where it was (the head's axes) and
+	whether it has been away from the head since its last tap; the hand at
+	the head now and since when (-1: none); when the next toggle may come,
+	and until when the game sees the flashlight's button */
+	int flashlight_gesture;
+	float tap_last[HALO_XR_HAND_COUNT][3];
+	int tap_last_valid[HALO_XR_HAND_COUNT];
+	int tap_armed[HALO_XR_HAND_COUNT];
+	int tap_hand;
+	unsigned long long tap_entered_us;
+	unsigned long long tap_last_us;
+	unsigned long long tap_ready_us;
+	unsigned long long flashlight_until_us;
+	unsigned long long melee_jab_start_us; /* the melee button's attack: the weapon jabs */
 	/* the laser along the barrel, for the frame it was set in */
 	unsigned long frame_number;
 	unsigned long laser_frame;
@@ -250,6 +299,9 @@ static struct
 	vr.mirror_controls the sticks and face buttons mirrored too */
 	int left_handed;
 	int mirror_controls;
+	/* the button each action is on (vr.button_*: HALO_VR_INPUT_* by
+	HALO_VR_ACTION_*) */
+	int action_inputs[HALO_VR_ACTION_COUNT];
 	/* vr.refresh_rate as last asked for (the VR options change it), and
 	vr.resolution_scale as the app started with it */
 	float refresh_rate_wanted;
@@ -307,6 +359,7 @@ static int name_pose(const float point[3], struct halo_xr_pose *pose, float *wid
 static int weapon_hand_tracked(short local_player_index);
 static void controller_axes(float forward[3], float up[3], float right[3]);
 static void hand_offset(float out[3]);
+static void controls_in_play(struct halo_xr_hand hands[HALO_XR_HAND_COUNT]);
 
 /* the hand that holds the weapon, the free one (the grenade, the
 foregrip), and the one whose stick turns the body and steers */
@@ -494,6 +547,14 @@ static void vr_read_live_settings(void)
 	vr.laser = config_boolean("vr.laser");
 	vr.vehicle_wheel = config_boolean("vr.vehicle_wheel");
 	vr.comfort_vignette = (float)config_real("vr.comfort_vignette");
+	{
+		const char *foot = config_string("vr.foot_vignette");
+
+		vr.foot_vignette = !strcmp(foot, "moving") ? FOOT_VIGNETTE_MOVING :
+			!strcmp(foot, "turning") ? FOOT_VIGNETTE_TURNING : FOOT_VIGNETTE_OFF;
+	}
+	vr.foot_vignette_strength = (float)config_real("vr.foot_vignette_strength");
+	vr.flashlight_gesture = config_boolean("vr.flashlight_gesture");
 	vr.fingers = config_boolean("vr.fingers");
 	vr.arm_ik = config_boolean("vr.arm_ik");
 	{
@@ -517,6 +578,12 @@ static void vr_read_live_settings(void)
 		vr.left_handed = left_handed;
 		vr.mirror_controls = config_boolean("vr.mirror_controls");
 	}
+	{
+		int action;
+
+		for (action = 0; action < HALO_VR_ACTION_COUNT; action++)
+			vr.action_inputs[action] = halo_vr_action_input(action);
+	}
 	{
 		/* (the refresh rate changes at once where the runtime lets it) */
 		float refresh_rate = (float)config_real("vr.refresh_rate");
@@ -535,6 +602,7 @@ void halo_vr_initialize(void)
 	if (vr.active || !getenv("HALO_VR"))
 		return;
 	vr_read_live_settings();
+	vr.tap_hand = -1;
 	vr.cinematics_3d = config_boolean("vr.cinematics_in_3d");
 	vr.hud_distance = (float)config_real("vr.hud_distance");
 	vr.hud_width = 2.0f * vr.hud_distance * tanf((float)config_real("vr.hud_field_of_view") * PI / 360.0f);
@@ -619,6 +687,22 @@ int halo_vr_weapon_hand(void)
 	return weapon_hand();
 }
 
+int halo_vr_action_input(int action)
+{
+	const char *value;
+	int input;
+
+	if (action < 0 || action >= HALO_VR_ACTION_COUNT)
+		return HALO_VR_INPUT_A;
+	value = config_string(vr_action_settings[action]);
+	for (input = 0; input < HALO_VR_INPUT_COUNT; input++)
+	{
+		if (!strcmp(value, vr_input_values[input]))
+			return input;
+	}
+	return action;
+}
+
 int halo_vr_refresh_rates(float *rates, int maximum, float *current)
 {
 	*current = 0.0f;
@@ -980,18 +1064,21 @@ static void melee_update(void)
 
 	vr.hand_last_us = now;
 	{
-		/* the weapon hand's grip's melee attack (xinput_sdl.c) aims the
-		same way */
-		int grip_down = vr.frame.hands[weapon_hand()].active &&
-			(vr.frame.hands[weapon_hand()].buttons & HALO_XR_BUTTON_SQUEEZE);
+		/* the melee button's attack (xinput_sdl.c; the weapon hand's grip
+		unless vr.button_melee moves it) aims the same way */
+		struct halo_xr_hand hands[HALO_XR_HAND_COUNT];
+		int button_down;
 
-		if (grip_down && !vr.melee_grip_down)
+		memcpy(hands, vr.frame.hands, sizeof(hands));
+		controls_in_play(hands);
+		button_down = (hands[HALO_XR_HAND_RIGHT].buttons & HALO_XR_BUTTON_SQUEEZE) != 0;
+		if (button_down && !vr.melee_button_down)
 		{
 			vr.melee_aim_until_us = now + 700000;
 			vr.melee_strength = 0.75f;
 			vr.melee_jab_start_us = now;
 		}
-		vr.melee_grip_down = grip_down;
+		vr.melee_button_down = button_down;
 	}
 	quaternion_rotate(vr.frame.head.orientation, look, facing);
 	facing[1] = 0.0f;
@@ -1038,6 +1125,148 @@ static void melee_update(void)
 	}
 }
 
+/* The flashlight by tapping the head (vr.flashlight_gesture; after
+HaloCE-Quest-VR, CC0, whose off hand brought near the head's middle
+toggles it): either hand brought to the side or the top of the head and
+away again, as a tap, toggles the flashlight; its button still does.
+
+The zone is in the head's axes (metres from between the eyes; x right,
+y up, z back): beside the head, from 7 to 24 cm out, 10 cm below the eyes
+to 18 cm above them; or over it, within 12 cm of its middle line, 8 to
+30 cm up; either way no further forward than 6 cm before the eyes, so a
+scope held to the eye, a two-handed weapon and a punch, all in front of
+the face, are not in it. A tap is a hand coming from 35 cm or more from
+the head's middle into the zone, slower than 3 m/s (a grenade's throw
+past the ear is faster), staying 40 to 600 ms (adjusting the headset
+takes longer) alone (both hands at the head adjust it), and leaving it 4
+cm past its edges; toggles are a second apart. No taps while the menus
+are up, while a grenade is held or just thrown, after a melee, with both
+hands on the weapon, with the weapon hand at the scope, or with a hand on
+a Warthog's wheel. */
+#define TAP_SPEED 3.0f
+#define TAP_AWAY 0.35f
+#define TAP_MARGIN 0.04f
+#define TAP_DWELL_SHORTEST 40000ULL
+#define TAP_DWELL_LONGEST 600000ULL
+#define TAP_COOLDOWN 1000000ULL
+
+static int tap_zone(const float local[3], float margin)
+{
+	float x = fabsf(local[0]), y = local[1], z = local[2];
+
+	if (z < -0.06f - margin || z > 0.18f + margin)
+		return 0;
+	if (x >= 0.07f - margin && x <= 0.24f + margin && y >= -0.10f - margin && y <= 0.18f + margin)
+		return 1;
+	return x <= 0.12f + margin && y >= 0.08f - margin && y <= 0.30f + margin;
+}
+
+static void flashlight_gesture_update(void)
+{
+	unsigned long long now = now_us();
+	float seconds = vr.tap_last_us ? (float)(now - vr.tap_last_us) * 1e-6f : 0.0f;
+	float inverse[4];
+	int blocked, hand;
+
+	vr.tap_last_us = now;
+	inverse[0] = -vr.frame.head.orientation[0];
+	inverse[1] = -vr.frame.head.orientation[1];
+	inverse[2] = -vr.frame.head.orientation[2];
+	inverse[3] = vr.frame.head.orientation[3];
+	blocked = !vr.flashlight_gesture || !vr.frame.focused || vr.last_overlay_mode == HALO_XR_OVERLAY_SCREEN ||
+		vr.recentre_frames > 0 || vr.grenade_held || now - vr.grenade_released_us < 600000 ||
+		now < vr.melee_ready_us || vr.two_hand_latched;
+	for (hand = 0; hand < HALO_XR_HAND_COUNT; hand++)
+	{
+		const struct halo_xr_hand *state = &vr.frame.hands[hand];
+		float relative[3], local[3], away[3], speed = 0.0f;
+		int axis, inside, outside;
+
+		if (!state->active || !(state->flags & HALO_XR_POSE_VALID))
+		{
+			vr.tap_last_valid[hand] = 0;
+			vr.tap_armed[hand] = 0;
+			if (vr.tap_hand == hand)
+				vr.tap_hand = -1;
+			continue;
+		}
+		for (axis = 0; axis < 3; axis++)
+			relative[axis] = state->grip.position[axis] - vr.frame.head.position[axis];
+		quaternion_rotate(inverse, relative, local);
+		if (vr.tap_last_valid[hand] && seconds > 0.0f && seconds < 0.1f)
+		{
+			float moved[3];
+
+			for (axis = 0; axis < 3; axis++)
+				moved[axis] = local[axis] - vr.tap_last[hand][axis];
+			speed = sqrtf(moved[0] * moved[0] + moved[1] * moved[1] + moved[2] * moved[2]) / seconds;
+		}
+		memcpy(vr.tap_last[hand], local, sizeof(vr.tap_last[hand]));
+		vr.tap_last_valid[hand] = 1;
+		away[0] = local[0];
+		away[1] = local[1];
+		away[2] = local[2] - 0.10f;
+		if (sqrtf(away[0] * away[0] + away[1] * away[1] + away[2] * away[2]) > TAP_AWAY)
+			vr.tap_armed[hand] = 1;
+		inside = tap_zone(local, 0.0f);
+		outside = !tap_zone(local, TAP_MARGIN);
+		if (blocked || (vr.wheel_hands & (1 << hand)) || (hand == weapon_hand() && vr.scope_last_frame))
+		{
+			/* (a hand that may be at the head for another reason taps
+			only once it has been away again) */
+			if (inside)
+				vr.tap_armed[hand] = 0;
+			if (vr.tap_hand == hand)
+				vr.tap_hand = -1;
+			continue;
+		}
+		if (vr.tap_hand == hand)
+		{
+			unsigned long long dwell = now - vr.tap_entered_us;
+
+			if (dwell > TAP_DWELL_LONGEST)
+			{
+				vr.tap_hand = -1;
+			}
+			else if (outside)
+			{
+				vr.tap_hand = -1;
+				if (dwell >= TAP_DWELL_SHORTEST && now >= vr.tap_ready_us)
+				{
+					vr.flashlight_until_us = now + 100000;
+					vr.tap_ready_us = now + TAP_COOLDOWN;
+					host_xr_haptic(hand, 0.5f, 0.05f);
+					platform_log("VR: flashlight, %s hand at the head for %llu ms", hand ? "right" : "left",
+						dwell / 1000);
+				}
+			}
+		}
+		else if (inside && vr.tap_armed[hand])
+		{
+			vr.tap_armed[hand] = 0;
+			if (vr.tap_hand >= 0)
+			{
+				/* (both hands at the head: the headset adjusted) */
+				vr.tap_hand = -1;
+			}
+			else if (speed <= TAP_SPEED)
+			{
+				vr.tap_hand = hand;
+				vr.tap_entered_us = now;
+			}
+		}
+		else if (inside && vr.tap_hand >= 0)
+		{
+			vr.tap_hand = -1;
+		}
+	}
+}
+
+int halo_vr_flashlight_tap(void)
+{
+	return vr.active && now_us() < vr.flashlight_until_us;
+}
+
 /* The fingers, from where they rest on the controller (after
 HaloCE-Quest-VR, CC0, its vr_frame.c): the thumb curled while it touches
 the stick, a button or the rest, half curled where the controller does not
@@ -1378,13 +1607,45 @@ int halo_vr_wheel_held(void)
 }
 
 /* The comfort vignette: while a vehicle turns the player (from 15 degrees a
-second, fully at 60), the eye images darken from their edges; it comes in
-quickly and goes slowly. */
+second, fully at 60), the eye images darken from their edges; on foot
+(vr.foot_vignette), while the turning stick turns smoothly and, with
+"moving", the move stick moves, as far as they are pushed (fully at three
+quarters). It comes in quickly and goes slowly. */
+static float foot_vignette_target(void)
+{
+	const struct halo_xr_hand *turn = &vr.frame.hands[turn_hand()];
+	const struct halo_xr_hand *move = &vr.frame.hands[turn_hand() == HALO_XR_HAND_RIGHT ? HALO_XR_HAND_LEFT :
+		HALO_XR_HAND_RIGHT];
+	float push = 0.0f;
+
+	if (vr.foot_vignette == FOOT_VIGNETTE_OFF || vr.foot_vignette_strength <= 0.0f || vr.seated ||
+		!vr.frame.focused || vr.last_overlay_mode == HALO_XR_OVERLAY_SCREEN)
+	{
+		return 0.0f;
+	}
+	if (vr.smooth_turn && turn->active)
+		push = fabsf(turn->thumbstick[0]);
+	if (vr.foot_vignette == FOOT_VIGNETTE_MOVING && move->active)
+	{
+		float moving = sqrtf(move->thumbstick[0] * move->thumbstick[0] + move->thumbstick[1] * move->thumbstick[1]);
+
+		if (moving > push)
+			push = moving;
+	}
+	/* (beyond the sticks' dead zone, 0.15) */
+	push = (push - 0.15f) / 0.6f;
+	if (push < 0.0f)
+		push = 0.0f;
+	if (push > 1.0f)
+		push = 1.0f;
+	return push * (vr.foot_vignette_strength > 1.0f ? 1.0f : vr.foot_vignette_strength);
+}
+
 static void vignette_update(void)
 {
 	unsigned long long now = now_us();
 	float seconds = vr.vignette_last_us ? (float)(now - vr.vignette_last_us) * 1e-6f : 0.0f;
-	float target = 0.0f, rate;
+	float target = foot_vignette_target(), rate;
 
 	vr.vignette_last_us = now;
 	if (seconds > 0.1f)
@@ -1396,13 +1657,15 @@ static void vignette_update(void)
 		if (vr.vignette_yaw_valid && seconds > 0.0f)
 		{
 			float turning = fabsf(wrap_angle(yaw - vr.vignette_last_yaw)) / seconds;
+			float vehicle = (turning - 15.0f * PI / 180.0f) / (45.0f * PI / 180.0f);
 
-			target = (turning - 15.0f * PI / 180.0f) / (45.0f * PI / 180.0f);
-			if (target < 0.0f)
-				target = 0.0f;
-			if (target > 1.0f)
-				target = 1.0f;
-			target *= vr.comfort_vignette;
+			if (vehicle < 0.0f)
+				vehicle = 0.0f;
+			if (vehicle > 1.0f)
+				vehicle = 1.0f;
+			vehicle *= vr.comfort_vignette;
+			if (vehicle > target)
+				target = vehicle;
 		}
 		vr.vignette_last_yaw = yaw;
 		vr.vignette_yaw_valid = 1;
@@ -1423,6 +1686,7 @@ void halo_vr_set_seat(short local_player_index, int seat, int armed, float vehic
 {
 	if (!vr.active || local_player_index != 0)
 		return;
+	vr.seated = seat != HALO_VR_SEAT_NONE;
 	if (!vr.vehicle_first_person)
 		seat = HALO_VR_SEAT_NONE;
 	vr.seat_yaw = vehicle_yaw;
@@ -1581,6 +1845,7 @@ void halo_vr_frame_begin(void)
 	vr.frame_begun = 1;
 	vr.frame_number++;
 	vr.eyes_captured = 0;
+	vr.scope_last_frame = vr.scope_captured;
 	vr.scope_captured = 0;
 	vr.crosshair_captured = 0;
 	vr.name_count = 0;
@@ -1607,6 +1872,7 @@ void halo_vr_frame_begin(void)
 	look_update();
 	grenade_update();
 	melee_update();
+	flashlight_gesture_update();
 	fingers_update();
 	torso_update();
 }
@@ -3046,6 +3312,51 @@ static void controllers_mirrored(struct halo_xr_hand hands[HALO_XR_HAND_COUNT])
 	}
 }
 
+/* The buttons the actions are on (vr.button_*), as the gamepad's sides
+have them once mirrored: A and B the right hand's, X and Y the left's
+A and B, the move stick's click the left's, the turning stick's the
+right's, the grip the right's (the weapon hand's). Each action's button
+is read and handed on as the button the action has by default, which
+xinput_sdl.c turns into it; with the defaults nothing changes. The grips
+holding a Warthog's wheel press nothing. */
+static const int input_hands[HALO_VR_INPUT_COUNT] =
+{
+	HALO_XR_HAND_RIGHT, HALO_XR_HAND_RIGHT, HALO_XR_HAND_LEFT, HALO_XR_HAND_LEFT, HALO_XR_HAND_LEFT,
+	HALO_XR_HAND_RIGHT, HALO_XR_HAND_RIGHT,
+};
+static const int input_buttons[HALO_VR_INPUT_COUNT] =
+{
+	HALO_XR_BUTTON_A, HALO_XR_BUTTON_B, HALO_XR_BUTTON_A, HALO_XR_BUTTON_B, HALO_XR_BUTTON_THUMBSTICK,
+	HALO_XR_BUTTON_THUMBSTICK, HALO_XR_BUTTON_SQUEEZE,
+};
+
+static void controls_remapped(struct halo_xr_hand hands[HALO_XR_HAND_COUNT])
+{
+	int down[HALO_VR_INPUT_COUNT];
+	int input, action;
+
+	for (input = 0; input < HALO_VR_INPUT_COUNT; input++)
+		down[input] = (hands[input_hands[input]].buttons & input_buttons[input]) != 0;
+	if (vr.wheel_hands)
+		down[HALO_VR_INPUT_GRIP] = 0;
+	for (input = 0; input < HALO_VR_INPUT_COUNT; input++)
+		hands[input_hands[input]].buttons &= ~input_buttons[input];
+	for (action = 0; action < HALO_VR_ACTION_COUNT; action++)
+	{
+		if (down[vr.action_inputs[action]])
+			hands[input_hands[action]].buttons |= input_buttons[action];
+	}
+}
+
+/* the controllers as the game is played with them: mirrored (left-handed)
+and the actions on their buttons */
+static void controls_in_play(struct halo_xr_hand hands[HALO_XR_HAND_COUNT])
+{
+	if (vr.left_handed)
+		controllers_mirrored(hands);
+	controls_remapped(hands);
+}
+
 /* the controllers, for the gamepad the game reads (xinput_sdl.c) */
 int halo_vr_controllers(struct halo_xr_hand hands[HALO_XR_HAND_COUNT], int *menus)
 {
@@ -3053,8 +3364,8 @@ int halo_vr_controllers(struct halo_xr_hand hands[HALO_XR_HAND_COUNT], int *menu
 		return 0;
 	memcpy(hands, vr.frame.hands, sizeof(vr.frame.hands));
 	*menus = vr.last_overlay_mode == HALO_XR_OVERLAY_SCREEN;
-	if (vr.left_handed && !*menus)
-		controllers_mirrored(hands);
+	if (!*menus)
+		controls_in_play(hands);
 	return 1;
 }
 
@@ -3062,6 +3373,7 @@ int halo_vr_controllers(struct halo_xr_hand hands[HALO_XR_HAND_COUNT], int *menu
 
 int halo_vr_controller_layout(void) { return 0; }
 int halo_vr_weapon_hand(void) { return 1; }
+int halo_vr_action_input(int action) { return action; }
 int halo_vr_graphics(void) { return HALO_VR_GRAPHICS_HIGH; }
 int halo_vr_refresh_rates(float *rates, int maximum, float *current)
 {
@@ -3128,6 +3440,7 @@ void halo_vr_debug_look(short local_player_index, const float unit_looking[3], i
 	(void)local_player_index; (void)unit_looking; (void)in_vehicle;
 }
 int halo_vr_melee(void) { return 0; }
+int halo_vr_flashlight_tap(void) { return 0; }
 int halo_vr_finger_curls(short local_player_index, int hand, float curls[4])
 {
 	(void)local_player_index; (void)hand; (void)curls;

port/linux/src/xinput_sdl.c

@@ -840,7 +840,9 @@ In play, laid out for VR shooters rather than by position:
 
 	right trigger  fire                 left trigger   grenade: held in the hand, thrown as it lets go (vr.c)
 	right grip     melee (B)            left grip      hold the weapon with both hands (vr.c)
-	(a hand thrust forward, vr.melee_swing_speed, is a melee attack too)
+	(a hand thrust forward, vr.melee_swing_speed, is a melee attack too;
+	a hand tapped on the side or top of the head, vr.flashlight_gesture,
+	the flashlight)
 	A              jump                 X              action, reload (X), as the game's prompts say
 	B              flashlight (white); held, switch grenade (black)
 	                                    Y              switch weapon (Y)
@@ -859,6 +861,11 @@ face buttons too (the right stick moves, X jumps, A reloads; on the Steam
 Frame the left D-pad takes A, B, X and Y). Here "right" and "left" are the
 sides so handed over.
 
+The VR options' BUTTONS page (vr.button_*) moves jump, the flashlight,
+action, switch weapon, crouch, zoom and melee between A, B, X, Y, the
+stick clicks and the weapon hand's grip: vr.c hands each action's button
+over as the one above, so "A" here is the jump wherever it is.
+
 In the menus the buttons are the Xbox's by position: A accepts, B goes back. */
 
 #include "guest_host.h"
@@ -866,6 +873,7 @@ In the menus the buttons are the Xbox's by position: A accepts, B goes back. */
 
 int halo_vr_controllers(struct halo_xr_hand hands[HALO_XR_HAND_COUNT], int *menus);
 int halo_vr_wheel_held(void);
+int halo_vr_flashlight_tap(void);
 
 /* a click that stands for the pad's A (ui_widget.c: the screen where
 controllers join by pressing it), held a moment */
@@ -937,14 +945,15 @@ static void vr_gamepad_state(XINPUT_GAMEPAD *pad)
 	}
 	merge_button(pad, XINPUT_GAMEPAD_A, (right->buttons & HALO_XR_BUTTON_A) != 0);
 	merge_button(pad, XINPUT_GAMEPAD_X, (left->buttons & HALO_XR_BUTTON_A) != 0);
-	/* (the grips holding a Warthog's wheel are not a blow) */
-	merge_button(pad, XINPUT_GAMEPAD_B,
-		((right->buttons & HALO_XR_BUTTON_SQUEEZE) != 0 && !halo_vr_wheel_held()) || halo_vr_melee());
+	/* (the grips holding a Warthog's wheel are not a blow: vr.c) */
+	merge_button(pad, XINPUT_GAMEPAD_B, (right->buttons & HALO_XR_BUTTON_SQUEEZE) != 0 || halo_vr_melee());
 	merge_button(pad, XINPUT_GAMEPAD_Y, (left->buttons & HALO_XR_BUTTON_B) != 0);
 	/* (the Steam Frame's bumpers: the left switches grenades, the right is
 	the flashlight) */
 	merge_button(pad, XINPUT_GAMEPAD_BLACK, (left->buttons & HALO_XR_BUTTON_BUMPER) != 0);
-	merge_button(pad, XINPUT_GAMEPAD_WHITE, (right->buttons & HALO_XR_BUTTON_BUMPER) != 0);
+	/* (and a tap of the head, vr.flashlight_gesture: vr.c) */
+	merge_button(pad, XINPUT_GAMEPAD_WHITE,
+		(right->buttons & HALO_XR_BUTTON_BUMPER) != 0 || halo_vr_flashlight_tap());
 	{
 		/* B: a tap is the flashlight, holding it switches grenades; the
 		game sees a short press of either */

source/interface/ui_widget.c

@@ -6648,6 +6648,7 @@ double config_real(char const *name);
 char const *config_string(char const *name);
 int config_write(char const *name, char const *value);
 int config_write_boolean(char const *name, int value);
+int config_default(char const *name, char *text, size_t size);
 
 enum
 {
@@ -6655,6 +6656,8 @@ enum
 	_vr_option_snap_angle,
 	_vr_option_smooth_speed,
 	_vr_option_vignette,
+	_vr_option_foot_vignette,
+	_vr_option_foot_vignette_strength,
 	_vr_option_wheel,
 	_vr_option_handedness,
 	_vr_option_mirror_controls,
@@ -6663,6 +6666,11 @@ enum
 	_vr_option_motion_tracker,
 	_vr_option_body,
 	_vr_option_fingers,
+	/* (the game's actions on the buttons, HALO_VR_ACTION_*'s order) */
+	_vr_option_button_first,
+	_vr_option_button_last = _vr_option_button_first + HALO_VR_ACTION_COUNT - 1,
+	_vr_option_flashlight_gesture,
+	_vr_option_buttons_reset,
 	_vr_option_graphics,
 	_vr_option_refresh_rate,
 	_vr_option_resolution,
@@ -6675,7 +6683,17 @@ enum
 	VR_OPTIONS_ROW_HEIGHT = 22,
 	VR_OPTIONS_FOOTER = 362,
 	VR_OPTIONS_PER_PAGE = 12,
-	NUMBER_OF_VR_OPTION_PAGES = 2,
+
+	_vr_options_page_play = 0,
+	_vr_options_page_comfort,
+	_vr_options_page_buttons,
+	_vr_options_page_more,
+	NUMBER_OF_VR_OPTION_PAGES,
+
+	/* (the pages' tabs, beside the title, as wide as there is room) */
+	VR_OPTIONS_TABS_LEFT = 216,
+	VR_OPTIONS_TABS_RIGHT = 528,
+	VR_OPTIONS_TAB_WIDTH = (VR_OPTIONS_TABS_RIGHT - VR_OPTIONS_TABS_LEFT) / NUMBER_OF_VR_OPTION_PAGES,
 
 	_vr_controls_on_foot = 0,
 	_vr_controls_vehicles,
@@ -6694,14 +6712,22 @@ static struct
 } ui_vr_options_globals;
 
 /* the panel's pages (its tabs), their rows in order (NONE past the last) */
-static char const *const vr_option_page_names[NUMBER_OF_VR_OPTION_PAGES] = { "PLAY", "MORE" };
+static char const *const vr_option_page_names[NUMBER_OF_VR_OPTION_PAGES] = { "PLAY", "COMFORT", "BUTTONS", "MORE" };
 static short const vr_option_pages[NUMBER_OF_VR_OPTION_PAGES][VR_OPTIONS_PER_PAGE] =
 {
-	{ _vr_option_turning, _vr_option_snap_angle, _vr_option_smooth_speed, _vr_option_vignette, _vr_option_wheel,
-		_vr_option_handedness, _vr_option_mirror_controls, _vr_option_laser, _vr_option_crosshair,
-		_vr_option_motion_tracker, _vr_option_body, _vr_option_fingers },
-	{ _vr_option_graphics, _vr_option_refresh_rate, _vr_option_resolution, _vr_option_controls, _vr_option_quit,
-		NONE, NONE, NONE, NONE, NONE, NONE, NONE },
+	{ _vr_option_handedness, _vr_option_mirror_controls, _vr_option_laser, _vr_option_crosshair,
+		_vr_option_motion_tracker, _vr_option_body, _vr_option_fingers, _vr_option_wheel,
+		NONE, NONE, NONE, NONE },
+	{ _vr_option_turning, _vr_option_snap_angle, _vr_option_smooth_speed, _vr_option_vignette,
+		_vr_option_foot_vignette, _vr_option_foot_vignette_strength,
+		NONE, NONE, NONE, NONE, NONE, NONE },
+	{ _vr_option_button_first + HALO_VR_ACTION_JUMP, _vr_option_button_first + HALO_VR_ACTION_LIGHT,
+		_vr_option_button_first + HALO_VR_ACTION_ACTION, _vr_option_button_first + HALO_VR_ACTION_WEAPON,
+		_vr_option_button_first + HALO_VR_ACTION_CROUCH, _vr_option_button_first + HALO_VR_ACTION_ZOOM,
+		_vr_option_button_first + HALO_VR_ACTION_MELEE, _vr_option_flashlight_gesture, _vr_option_buttons_reset,
+		_vr_option_controls, NONE, NONE },
+	{ _vr_option_graphics, _vr_option_refresh_rate, _vr_option_resolution, _vr_option_quit,
+		NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE },
 };
 
 /* the page a row is on, and its place there */
@@ -6754,12 +6780,151 @@ static boolean ui_vr_controls_mirrored(
 	return ui_vr_left_handed() && config_boolean("vr.mirror_controls");
 }
 
+/* Where a button the game's actions go on (HALO_VR_INPUT_*) is, as the
+hands are set: its controller (0 the left, 1 the right) and its name,
+short under its controller on the controls page, or full in the
+options' rows. On the Quest A and B are on the right, X and Y on the
+left, and mirrored the other way round; on the Steam Frame all four are
+on the right, and mirrored the left D-pad takes them (down, left, right,
+up). The sticks' clicks change sides with them; the grip is the weapon
+hand's. */
+static char const *ui_vr_input_name(
+	short input,
+	boolean full,
+	short *column)
+{
+	static char const *const buttons[] = { "A", "B", "X", "Y" };
+	static char const *const quest_mirrored[] = { "X", "Y", "A", "B" };
+	static char const *const frame_mirrored[] = { "D-pad down", "D-pad left", "D-pad right", "D-pad up" };
+	boolean frame = halo_vr_controller_layout() == 1;
+	boolean mirrored = ui_vr_controls_mirrored();
+	short side;
+	char const *name;
+
+	switch (input)
+	{
+	case HALO_VR_INPUT_MOVE_STICK:
+	case HALO_VR_INPUT_TURN_STICK:
+		side = (short)((input == HALO_VR_INPUT_TURN_STICK) != (mirrored != 0));
+		name = full ? (side ? "Right stick click" : "Left stick click") : "Stick click";
+		break;
+	case HALO_VR_INPUT_GRIP:
+		side = (short)(ui_vr_left_handed() ? 0 : 1);
+		name = full ? (side ? "Right grip" : "Left grip") : "Grip";
+		break;
+	default:
+		input = (short)PIN(input, HALO_VR_INPUT_A, HALO_VR_INPUT_Y);
+		if (frame)
+		{
+			side = (short)(mirrored ? 0 : 1);
+			name = mirrored ? frame_mirrored[input] : buttons[input];
+		}
+		else
+		{
+			side = (short)((input <= HALO_VR_INPUT_B) != (mirrored != 0));
+			name = mirrored ? quest_mirrored[input] : buttons[input];
+		}
+		break;
+	}
+	if (column)
+		*column = side;
+	return name;
+}
+
+/* the game's actions on the buttons (HALO_VR_ACTION_*'s order): as the
+options' rows name them, and in short (the Steam Frame's stick lines) */
+static char const *const vr_action_names[HALO_VR_ACTION_COUNT] =
+{
+	"Jump", "Light; held: grenades", "Action, reload", "Switch weapon", "Crouch", "Zoom", "Melee",
+};
+static char const *const vr_action_short_names[HALO_VR_ACTION_COUNT] =
+{
+	"jump", "light", "action", "weapon", "crouch", "zoom", "melee",
+};
+
+/* an action moved to the next button or the one before: the action that
+was there takes its old one (so that every action keeps a button) */
+static void ui_vr_options_button_change(
+	short action,
+	short change)
+{
+	short input = (short)halo_vr_action_input(action);
+	short wanted = (short)((input + change + HALO_VR_INPUT_COUNT) % HALO_VR_INPUT_COUNT);
+	short other;
+
+	for (other = 0; other < HALO_VR_ACTION_COUNT; other++)
+	{
+		if (other != action && halo_vr_action_input(other) == wanted)
+			config_write(halo_vr_action_setting(other), halo_vr_input_value(input));
+	}
+	config_write(halo_vr_action_setting(action), halo_vr_input_value(wanted));
+}
+
+static boolean ui_vr_options_buttons_default(
+	void)
+{
+	short action;
+
+	for (action = 0; action < HALO_VR_ACTION_COUNT; action++)
+	{
+		if (halo_vr_action_input(action) != action)
+			return FALSE;
+	}
+	return TRUE;
+}
+
+static void ui_vr_options_buttons_reset(
+	void)
+{
+	short action;
+
+	for (action = 0; action < HALO_VR_ACTION_COUNT; action++)
+	{
+		char text[32];
+
+		if (config_default(halo_vr_action_setting(action), text, sizeof(text)))
+			config_write(halo_vr_action_setting(action), text);
+	}
+}
+
 void platform_request_quit(void);
 
-static real const vr_snap_angles[] = { 30.0f, 45.0f, 60.0f, 90.0f };
-static real const vr_smooth_speeds[] = { 60.0f, 90.0f, 120.0f, 150.0f, 180.0f };
-static real const vr_vignettes[] = { 0.0f, 0.35f, 0.7f, 1.0f };
-static char const *const vr_vignette_names[] = { "Off", "Light", "Medium", "Strong" };
+/* (in finer steps than they had: the old values among them) */
+static real const vr_snap_angles[] = { 10.0f, 15.0f, 20.0f, 25.0f, 30.0f, 35.0f, 40.0f, 45.0f, 60.0f, 75.0f, 90.0f };
+static real const vr_smooth_speeds[] = { 30.0f, 45.0f, 60.0f, 75.0f, 90.0f, 105.0f, 120.0f, 135.0f, 150.0f, 180.0f,
+	210.0f, 240.0f, 270.0f, 300.0f };
+static real const vr_vignettes[] = { 0.0f, 0.15f, 0.25f, 0.35f, 0.5f, 0.6f, 0.7f, 0.85f, 1.0f };
+/* the on-foot vignette's strengths (vr.foot_vignette_strength: the
+vignettes' without Off), and vr.foot_vignette's values */
+static real const vr_foot_vignette_strengths[] = { 0.15f, 0.25f, 0.35f, 0.5f, 0.6f, 0.7f, 0.85f, 1.0f };
+static char const *const vr_foot_vignettes[] = { "off", "turning", "moving" };
+static char const *const vr_foot_vignette_names[] = { "Off", "Smooth turns", "Moving, turning" };
+
+static short ui_vr_options_foot_vignette(
+	void)
+{
+	char const *mode = config_string("vr.foot_vignette");
+	short index;
+
+	for (index = 0; index < (short)NUMBEROF(vr_foot_vignettes); index++)
+	{
+		if (mode && strcmp(mode, vr_foot_vignettes[index]) == 0)
+			return index;
+	}
+	return 0;
+}
+
+/* a vignette's strength as the rows show it: Off, or how far it darkens */
+static void ui_vr_options_vignette_text(
+	char *text,
+	size_t size,
+	real strength)
+{
+	if (strength <= 0.0f)
+		snprintf(text, size, "Off");
+	else
+		snprintf(text, size, "%.0f%%", strength * 100.0f);
+}
 /* vr.body's values, and as the panel shows them */
 static char const *const vr_bodies[] = { "arms", "hands", "off" };
 static char const *const vr_body_names[] = { "Arms and hands", "Hands only", "Weapon only" };
@@ -6838,8 +7003,9 @@ static boolean ui_vr_options_screen(
 {
 	struct widget_instance *screen = widget_globals.active_widgets[0];
 
-	/* (the Xbox's main menu, or the PC version's: vr.menus) */
-	return halo_vr_active() && screen && screen->name &&
+	/* (the Xbox's main menu, or the PC version's: vr.menus; off the
+	headset with debug.vr_options, to check the pages) */
+	return (halo_vr_active() || config_boolean("debug.vr_options")) && screen && screen->name &&
 		(main_menu_screen_is_active() || strstr(screen->name, "pause_game") != NULL ||
 			strcmp(screen->name, "main_menu") == 0);
 }
@@ -6891,6 +7057,14 @@ static void ui_vr_options_change(
 	case _vr_option_vignette:
 		ui_vr_options_step("vr.comfort_vignette", vr_vignettes, NUMBEROF(vr_vignettes), change);
 		break;
+	case _vr_option_foot_vignette:
+		config_write("vr.foot_vignette", vr_foot_vignettes[(ui_vr_options_foot_vignette() + change +
+			(short)NUMBEROF(vr_foot_vignettes)) % (short)NUMBEROF(vr_foot_vignettes)]);
+		break;
+	case _vr_option_foot_vignette_strength:
+		ui_vr_options_step("vr.foot_vignette_strength", vr_foot_vignette_strengths,
+			NUMBEROF(vr_foot_vignette_strengths), change);
+		break;
 	case _vr_option_wheel: config_write_boolean("vr.vehicle_wheel", !config_boolean("vr.vehicle_wheel")); break;
 	case _vr_option_handedness: config_write("vr.handedness", ui_vr_left_handed() ? "right" : "left"); break;
 	case _vr_option_mirror_controls:
@@ -6928,6 +7102,12 @@ static void ui_vr_options_change(
 	case _vr_option_resolution:
 		ui_vr_options_step("vr.resolution_scale", vr_resolution_scales, NUMBEROF(vr_resolution_scales), change);
 		break;
+	case _vr_option_flashlight_gesture:
+		config_write_boolean("vr.flashlight_gesture", !config_boolean("vr.flashlight_gesture"));
+		break;
+	case _vr_option_buttons_reset:
+		ui_vr_options_buttons_reset();
+		break;
 	case _vr_option_controls:
 		ui_vr_options_globals.controls = TRUE;
 		ui_vr_options_globals.page = _vr_controls_on_foot;
@@ -6940,6 +7120,11 @@ static void ui_vr_options_change(
 		ui_vr_options_globals.quit_armed = TRUE;
 		break;
 	}
+	if (ui_vr_options_globals.selection >= _vr_option_button_first &&
+		ui_vr_options_globals.selection <= _vr_option_button_last)
+	{
+		ui_vr_options_button_change((short)(ui_vr_options_globals.selection - _vr_option_button_first), change);
+	}
 	ui_play_audio_feedback_sound(_ui_audio_feedback_forward);
 }
 
@@ -7056,7 +7241,8 @@ static boolean ui_vr_options_take_event(
 	{
 		ui_vr_options_change(1);
 	}
-	else if (change && ui_vr_options_globals.selection != _vr_option_controls)
+	else if (change && ui_vr_options_globals.selection != _vr_option_controls &&
+		ui_vr_options_globals.selection != _vr_option_buttons_reset)
 	{
 		ui_vr_options_change(change);
 	}
@@ -7113,10 +7299,11 @@ static boolean ui_vr_options_take_pointer(
 	{
 		short page = ui_vr_options_page_of(ui_vr_options_globals.selection, NULL);
 
-		if (pointer->left_clicks && y >= 68 && y < 88 && x >= 330 && x < 514)
+		if (pointer->left_clicks && y >= 68 && y < 88 && x >= VR_OPTIONS_TABS_LEFT && x < VR_OPTIONS_TABS_RIGHT)
 		{
 			/* (a tab: its page) */
-			short tab = (short)PIN((x - 330) / 92, 0, NUMBER_OF_VR_OPTION_PAGES - 1);
+			short tab = (short)PIN((x - VR_OPTIONS_TABS_LEFT) / VR_OPTIONS_TAB_WIDTH, 0,
+				NUMBER_OF_VR_OPTION_PAGES - 1);
 
 			if (tab != page)
 			{
@@ -7196,6 +7383,77 @@ static void ui_vr_controls_add(
 	}
 }
 
+/* the action on a button (vr.button_*; the swaps keep one on each) */
+static short ui_vr_input_action(
+	short input)
+{
+	short action;
+
+	for (action = 0; action < HALO_VR_ACTION_COUNT; action++)
+	{
+		if (halo_vr_action_input(action) == input)
+			return action;
+	}
+	return input;
+}
+
+/* in a vehicle: the action button gets in and out, the light's is the
+flashlight */
+static void ui_vr_controls_add_vehicle_actions(
+	struct ui_vr_controls_column columns[2])
+{
+	short column;
+	char const *name = ui_vr_input_name((short)halo_vr_action_input(HALO_VR_ACTION_ACTION), FALSE, &column);
+
+	ui_vr_controls_add(&columns[column], name, "Get in, get out");
+	name = ui_vr_input_name((short)halo_vr_action_input(HALO_VR_ACTION_LIGHT), FALSE, &column);
+	ui_vr_controls_add(&columns[column], name, "Flashlight");
+}
+
+/* an action's line under the controller its button is on (vr.button_*), as
+the Quest's page words it or, shorter, the Steam Frame's (whose page has
+more lines) */
+static void ui_vr_controls_add_action(
+	struct ui_vr_controls_column columns[2],
+	short action,
+	boolean frame)
+{
+	/* (one action is held: its name lives on with the column) */
+	static char held[24];
+	short column;
+	char const *name = ui_vr_input_name((short)halo_vr_action_input(action), FALSE, &column);
+
+	switch (action)
+	{
+	case HALO_VR_ACTION_LIGHT:
+		if (frame)
+		{
+			ui_vr_controls_add(&columns[column], name, "Light; held: grenades");
+		}
+		else
+		{
+			snprintf(held, sizeof(held), "%s held", strcmp(name, "Stick click") == 0 ? "Click" : name);
+			ui_vr_controls_add(&columns[column], name, "Flashlight");
+			ui_vr_controls_add(&columns[column], held, "Switch grenades");
+		}
+		break;
+	case HALO_VR_ACTION_MELEE:
+		if (frame)
+		{
+			ui_vr_controls_add(&columns[column], name, "Melee (or punch)");
+		}
+		else
+		{
+			ui_vr_controls_add(&columns[column], name, "Melee (or punch");
+			ui_vr_controls_add(&columns[column], "", "forward)");
+		}
+		break;
+	default:
+		ui_vr_controls_add(&columns[column], name, vr_action_names[action]);
+		break;
+	}
+}
+
 static void ui_vr_controls_column_render(
 	short x,
 	short y,
@@ -7264,26 +7522,27 @@ static void ui_vr_controls_render(
 	{
 		/* the Steam Frame's controllers: A, B, X, Y and a menu button on the
 		right one, a D-pad and a View button on the left one; mirrored, the
-		D-pad does what A, B, X and Y do (down, left, right, up) */
-		char const *jump = mirrored ? "D-pad down" : "A";
-		char const *light = mirrored ? "D-pad left" : "B";
-		char const *act = mirrored ? "D-pad right" : "X";
-		char const *weapon = mirrored ? "D-pad up" : "Y";
-		short buttons = mirrored ? 0 : 1;
+		D-pad does what A, B, X and Y do (down, left, right, up). The sticks'
+		clicks on the sticks' lines, to keep to the page's lines */
+		static char move_line[32], turn_line[32];
 
 		switch (ui_vr_options_globals.page)
 		{
 		case _vr_controls_on_foot:
-			ui_vr_controls_add(&columns[move], "Stick", "Move; click: crouch");
-			ui_vr_controls_add(&columns[turn], "Stick", "Turn; click: zoom");
+			snprintf(move_line, sizeof(move_line), "Move; click: %s",
+				vr_action_short_names[ui_vr_input_action(HALO_VR_INPUT_MOVE_STICK)]);
+			snprintf(turn_line, sizeof(turn_line), "Turn; click: %s",
+				vr_action_short_names[ui_vr_input_action(HALO_VR_INPUT_TURN_STICK)]);
+			ui_vr_controls_add(&columns[move], "Stick", move_line);
+			ui_vr_controls_add(&columns[turn], "Stick", turn_line);
 			ui_vr_controls_add(&columns[gun], "Trigger", "Fire");
 			ui_vr_controls_add(&columns[free_column], "Trigger", "Grenade: hold, throw");
-			ui_vr_controls_add(&columns[gun], "Grip", "Melee (or punch)");
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_GRIP), TRUE);
 			ui_vr_controls_add(&columns[free_column], "Grip", "Weapon in both hands");
-			ui_vr_controls_add(&columns[buttons], jump, "Jump");
-			ui_vr_controls_add(&columns[buttons], light, "Light; held: grenades");
-			ui_vr_controls_add(&columns[buttons], act, "Action, reload");
-			ui_vr_controls_add(&columns[buttons], weapon, "Switch weapon");
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_A), TRUE);
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_B), TRUE);
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_X), TRUE);
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_Y), TRUE);
 			ui_vr_controls_add(&columns[mirrored ? 0 : 1], "Bumper", "Flashlight");
 			ui_vr_controls_add(&columns[mirrored ? 1 : 0], "Bumper", "Switch grenades");
 			ui_vr_controls_add(&columns[0], "View", "Scores");
@@ -7294,6 +7553,8 @@ static void ui_vr_controls_render(
 			ui_vr_controls_add(&columns[1], "Menu", "Pause");
 			ui_vr_controls_note(320, wrist_note);
 			ui_vr_controls_note(340, "Scope: zoom, and look through the disc above the weapon.");
+			if (config_boolean("vr.flashlight_gesture"))
+				ui_vr_controls_note(360, "Tap the side or top of your head: the flashlight.");
 			break;
 		case _vr_controls_vehicles:
 			ui_vr_controls_add(&columns[move], "Stick", "Drive");
@@ -7302,8 +7563,7 @@ static void ui_vr_controls_render(
 			ui_vr_controls_add(&columns[gun], "Trigger", "Fire");
 			ui_vr_controls_add(&columns[free_column], "Trigger", "Second weapon");
 			ui_vr_controls_add(&columns[free_column], "", "(Banshee, tank)");
-			ui_vr_controls_add(&columns[buttons], act, "Get in, get out");
-			ui_vr_controls_add(&columns[buttons], light, "Flashlight");
+			ui_vr_controls_add_vehicle_actions(columns);
 			break;
 		default:
 			ui_vr_controls_add(&columns[0], "Stick", "Choose");
@@ -7322,31 +7582,28 @@ static void ui_vr_controls_render(
 		/* the Quest's: A and B on the right controller, X, Y and the menu
 		button on the left; mirrored, X and Y do what A and B do, and the
 		other way round */
-		short jumps = mirrored ? 0 : 1;
-		short acts = (short)(1 - jumps);
-
 		switch (ui_vr_options_globals.page)
 		{
 		case _vr_controls_on_foot:
 			ui_vr_controls_add(&columns[move], "Stick", "Move");
-			ui_vr_controls_add(&columns[move], "Stick click", "Crouch");
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_MOVE_STICK), FALSE);
 			ui_vr_controls_add(&columns[turn], "Stick", "Turn");
-			ui_vr_controls_add(&columns[turn], "Stick click", "Zoom");
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_TURN_STICK), FALSE);
 			ui_vr_controls_add(&columns[gun], "Trigger", "Fire");
-			ui_vr_controls_add(&columns[gun], "Grip", "Melee (or punch");
-			ui_vr_controls_add(&columns[gun], "", "forward)");
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_GRIP), FALSE);
 			ui_vr_controls_add(&columns[free_column], "Trigger", "Grenade: hold it,");
 			ui_vr_controls_add(&columns[free_column], "", "let go as you throw");
 			ui_vr_controls_add(&columns[free_column], "Grip", "Weapon in both hands");
-			ui_vr_controls_add(&columns[jumps], jumps ? "A" : "X", "Jump");
-			ui_vr_controls_add(&columns[jumps], jumps ? "B" : "Y", "Flashlight");
-			ui_vr_controls_add(&columns[jumps], jumps ? "B held" : "Y held", "Switch grenades");
-			ui_vr_controls_add(&columns[acts], acts ? "A" : "X", "Action, reload");
-			ui_vr_controls_add(&columns[acts], acts ? "B" : "Y", "Switch weapon");
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_A), FALSE);
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_B), FALSE);
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_X), FALSE);
+			ui_vr_controls_add_action(columns, ui_vr_input_action(HALO_VR_INPUT_Y), FALSE);
 			ui_vr_controls_add(&columns[0], "Menu", "Pause");
 			ui_vr_controls_note(320, wrist_note);
 			ui_vr_controls_note(340, "Scope: zoom, and look through the disc above the weapon.");
 			ui_vr_controls_note(360, "Hold the Meta button to recentre the view.");
+			if (config_boolean("vr.flashlight_gesture"))
+				ui_vr_controls_note(380, "Tap the side or top of your head: the flashlight.");
 			break;
 		case _vr_controls_vehicles:
 			ui_vr_controls_add(&columns[move], "Stick", "Drive");
@@ -7355,8 +7612,7 @@ static void ui_vr_controls_render(
 			ui_vr_controls_add(&columns[gun], "Trigger", "Fire");
 			ui_vr_controls_add(&columns[free_column], "Trigger", "Second weapon");
 			ui_vr_controls_add(&columns[free_column], "", "(Banshee, tank)");
-			ui_vr_controls_add(&columns[acts], acts ? "A" : "X", "Get in, get out");
-			ui_vr_controls_add(&columns[jumps], jumps ? "B" : "Y", "Flashlight");
+			ui_vr_controls_add_vehicle_actions(columns);
 			break;
 		default:
 			ui_vr_controls_add(&columns[0], "Stick", "Choose");
@@ -7373,6 +7629,9 @@ static void ui_vr_controls_render(
 	ui_vr_controls_column_render(right, y, &columns[1]);
 	switch (ui_vr_options_globals.page)
 	{
+	case _vr_controls_on_foot:
+		/* (its notes are with its lines, above) */
+		break;
 	case _vr_controls_vehicles:
 		ui_vr_controls_note(300, "Warthog: grip the wheel with one hand or both and turn it.");
 		ui_vr_controls_note(320, left_handed ? "Holding it, the left trigger accelerates, the right one brakes" :
@@ -7429,15 +7688,15 @@ static void ui_vr_options_render(
 	ui_join_code_draw_quad(110, 62, 530, 396, 0xFF050A18);
 	ui_join_code_draw_quad(110, 62, 530, 64, 0xFF3A6EA5);
 	ui_join_code_draw_quad(110, 394, 530, 396, 0xFF3A6EA5);
-	ui_join_code_draw_text(126, 330, 72, "VR OPTIONS", FALSE, 0, &title_color);
+	ui_join_code_draw_text(126, VR_OPTIONS_TABS_LEFT, 72, "VR OPTIONS", FALSE, 0, &title_color);
 	/* (the pages' tabs, beside the title) */
 	for (tab = 0; tab < NUMBER_OF_VR_OPTION_PAGES; tab++)
 	{
-		short x0 = (short)(330 + tab * 92);
+		short x0 = (short)(VR_OPTIONS_TABS_LEFT + tab * VR_OPTIONS_TAB_WIDTH);
 
 		if (tab == page)
-			ui_join_code_draw_quad(x0, 68, (short)(x0 + 88), 88, 0x803A6EA5);
-		ui_join_code_draw_text(x0, (short)(x0 + 88), 72, vr_option_page_names[tab], FALSE, 2,
+			ui_join_code_draw_quad(x0, 68, (short)(x0 + VR_OPTIONS_TAB_WIDTH - 4), 88, 0x803A6EA5);
+		ui_join_code_draw_text(x0, (short)(x0 + VR_OPTIONS_TAB_WIDTH - 4), 72, vr_option_page_names[tab], FALSE, 2,
 			tab == page ? &text_color : &dim_color);
 	}
 	for (row = 0; row < ui_vr_options_page_rows(page); row++)
@@ -7467,10 +7726,23 @@ static void ui_vr_options_render(
 			unused = !smooth;
 			break;
 		case _vr_option_vignette:
-			label = "Vehicle comfort vignette";
-			snprintf(value, sizeof(value), "%s", vr_vignette_names[ui_vr_options_nearest(
+			label = "Vehicle vignette";
+			ui_vr_options_vignette_text(value, sizeof(value), vr_vignettes[ui_vr_options_nearest(
 				(real)config_real("vr.comfort_vignette"), vr_vignettes, NUMBEROF(vr_vignettes))]);
 			break;
+		case _vr_option_foot_vignette:
+			label = "On-foot vignette";
+			snprintf(value, sizeof(value), "%s", vr_foot_vignette_names[ui_vr_options_foot_vignette()]);
+			/* (smooth turns alone, with snap turning: nothing to darken) */
+			unused = ui_vr_options_foot_vignette() == 1 && !smooth;
+			break;
+		case _vr_option_foot_vignette_strength:
+			label = "On-foot vignette strength";
+			ui_vr_options_vignette_text(value, sizeof(value), vr_foot_vignette_strengths[ui_vr_options_nearest(
+				(real)config_real("vr.foot_vignette_strength"), vr_foot_vignette_strengths,
+				NUMBEROF(vr_foot_vignette_strengths))]);
+			unused = ui_vr_options_foot_vignette() == 0;
+			break;
 		case _vr_option_wheel:
 			label = "Warthog steering wheel";
 			snprintf(value, sizeof(value), "%s", config_boolean("vr.vehicle_wheel") ? "On" : "Off (stick)");
@@ -7537,9 +7809,27 @@ static void ui_vr_options_render(
 				snprintf(value, sizeof(value), "%.0f%%", scale * 100.0f);
 			break;
 		}
+		case _vr_option_flashlight_gesture:
+			label = "Light by tapping the head";
+			snprintf(value, sizeof(value), "%s", config_boolean("vr.flashlight_gesture") ? "On" : "Off");
+			break;
+		case _vr_option_buttons_reset:
+			label = "Reset buttons to defaults";
+			unused = ui_vr_options_buttons_default();
+			break;
 		case _vr_option_controls:
 			label = "Controller buttons...";
 			break;
+		default:
+			if (option >= _vr_option_button_first && option <= _vr_option_button_last)
+			{
+				short action = (short)(option - _vr_option_button_first);
+
+				label = vr_action_names[action];
+				snprintf(value, sizeof(value), "%s", ui_vr_input_name((short)halo_vr_action_input(action), TRUE,
+					NULL));
+			}
+			break;
 		case _vr_option_quit:
 			label = ui_vr_options_globals.quit_armed && ui_vr_options_globals.selection == _vr_option_quit ?
 				"Quit Halo? Once more to quit" : "Quit Halo";
@@ -7556,7 +7846,25 @@ static void ui_vr_options_render(
 			ui_join_code_draw_text(330, 512, y, shown, FALSE, 1, unused ? &dim_color : &text_color);
 		}
 	}
-	if (page == 1)
+	if (page == _vr_options_page_comfort)
+	{
+		/* (what the vignettes do) */
+		ui_join_code_draw_text(128, 512, 248, "The vignette darkens the view from its edges while the", FALSE, 0,
+			&dim_color);
+		ui_join_code_draw_text(128, 512, 266, "game moves you: in a vehicle as it turns you; on foot, if", FALSE, 0,
+			&dim_color);
+		ui_join_code_draw_text(128, 512, 284, "on, as the sticks turn you smoothly (and move you).", FALSE, 0,
+			&dim_color);
+	}
+	if (page == _vr_options_page_buttons)
+	{
+		/* (what the buttons' rows do) */
+		ui_join_code_draw_text(128, 512, 320, "An action moved to a button swaps with the one there;", FALSE, 0,
+			&dim_color);
+		ui_join_code_draw_text(128, 512, 338, "left-handed and mirrored, the buttons are mirrored too.", FALSE, 0,
+			&dim_color);
+	}
+	if (page == _vr_options_page_more)
 	{
 		/* (what the graphics rows do) */
 		ui_join_code_draw_text(128, 512, 230, "Graphics: Medium and Low leave effects out (shadows,", FALSE, 0,

source/rasterizer/rasterizer.h

@@ -31,7 +31,14 @@ enum
 	RASTERIZER_MAXIMUM_TRIANGLES_PER_TRIANGLE_BUFFER = 24576,
 	RASTERIZER_MAXIMUM_DEBUG_PRIMITIVES = 131072,
 	RASTERIZER_MAXIMUM_DEBUG_VERTICES = 393216,
-	RASTERIZER_MAXIMUM_TRANSPARENT_GEOMETRY_GROUPS = 384,
+	/* port: the Xbox's 384 groups a window (each a model's transparent part,
+	a particle system, a contrail, a light volume, a window's or water's
+	surface) are spent in games of 30 and more players, and whatever is
+	submitted after the last is dropped, the structure's glass and water
+	and the particles first (render_window submits the objects before
+	them). Their indices are shorts, the pending flags a bit vector of
+	this size: 2048 groups take 320 KB. */
+	RASTERIZER_MAXIMUM_TRANSPARENT_GEOMETRY_GROUPS = 2048,
 	RASTERIZER_MAXIMUM_TRANSPARENT_GEOMETRY_GROUPS2 = 32,
 	RASTERIZER_MAXIMUM_DYNAMIC_TRIANGLES = 32768,
 	RASTERIZER_MAXIMUM_DYNAMIC_TRIANGLE_BUFFERS = 1024,

source/rasterizer/rasterizer_transparent_geometry.c

@@ -150,6 +150,7 @@ typedef char transparent_geometry_group_cortana_hack_offset_assert[
 /* ---------- prototypes */
 static void rasterizer_sort_external(
 	void);
+void platform_log(char const *format, ...);
 
 /* ---------- globals */
 
@@ -162,6 +163,9 @@ static long transparent_geometry_group_count = 0;
 static long transparent_geometry_group_count2 = 0;
 static short *transparent_geometry_group_sorted_indices = NULL;
 static short transparent_geometry_next_group_sorted_index = 0;
+/* port: the most groups a window has had, logged as it passes the Xbox's
+384 and every 128 beyond (rasterizer.h) */
+static long transparent_geometry_group_count_logged = 384;
 
 
 /* ---------- public code */
@@ -200,6 +204,12 @@ boolean rasterizer_transparent_geometry_initialize(
 void rasterizer_transparent_geometry_begin(
 	void)
 {
+	if (transparent_geometry_group_count>transparent_geometry_group_count_logged)
+	{
+		platform_log("rasterizer: %ld transparent geometry groups in a window (the Xbox had room for 384, the port %d)",
+			transparent_geometry_group_count, RASTERIZER_MAXIMUM_TRANSPARENT_GEOMETRY_GROUPS);
+		transparent_geometry_group_count_logged = (transparent_geometry_group_count/128 + 1)*128;
+	}
 	transparent_geometry_group_count = 0;
 	transparent_geometry_next_group_sorted_index = 0;
 	memset(transparent_geometry_group_pending_flags, 0,

tools/steam_frame_bundle.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-"""
-The Steam Frame's installer as release assets (port/android/STEAM_FRAME.md):
-
-    python3 tools/steam_frame_bundle.py <apk> <output folder> <owner/repository>
-
-writes into the output folder
-- halo-vr-steam-frame.zip: the installer (port/android/steam_frame_install.sh,
-  as install.sh), the APK (HaloVR.apk), the launcher (steam_frame_launch.sh,
-  as halo-vr.sh), the disc image reader (steam_frame_xiso.py, with
-  extract-xiso's license) and the library pictures (grid/);
-- Install-Halo-VR.desktop (port/android/steam_frame_installer.desktop): what
-  the player downloads and opens in Desktop Mode; it fetches the latest
-  release's zip from the repository named.
-"""
-
-import sys
-import zipfile
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parent.parent
-ANDROID = ROOT / "port/android"
-
-
-def main():
-    if len(sys.argv) != 4 or "/" not in sys.argv[3]:
-        print(__doc__.strip(), file=sys.stderr)
-        return 2
-    apk, output, repository = Path(sys.argv[1]), Path(sys.argv[2]), sys.argv[3]
-    output.mkdir(parents=True, exist_ok=True)
-
-    files = [
-        (ANDROID / "steam_frame_install.sh", "install.sh", 0o755),
-        (ANDROID / "steam_frame_launch.sh", "halo-vr.sh", 0o755),
-        (ANDROID / "steam_frame_xiso.py", "steam_frame_xiso.py", 0o755),
-        (ROOT / "port/third_party/extract-xiso/LICENSE.TXT", "extract-xiso-LICENSE.txt", 0o644),
-        (apk, "HaloVR.apk", 0o644),
-    ]
-    files += [(picture, "grid/" + picture.name, 0o644)
-        for picture in sorted((ANDROID / "steam_frame_grid").glob("*.png"))]
-    bundle = output / "halo-vr-steam-frame.zip"
-    with zipfile.ZipFile(bundle, "w", zipfile.ZIP_DEFLATED) as archive:
-        for path, name, mode in files:
-            info = zipfile.ZipInfo.from_file(path, name)
-            info.external_attr = (0o100000 | mode) << 16
-            info.compress_type = zipfile.ZIP_STORED if name.endswith((".apk", ".png")) else zipfile.ZIP_DEFLATED
-            archive.writestr(info, path.read_bytes())
-    print(f"{bundle.relative_to(Path.cwd()) if bundle.is_relative_to(Path.cwd()) else bundle}")
-
-    desktop = (ANDROID / "steam_frame_installer.desktop").read_text().replace("@REPOSITORY@", repository)
-    installer = output / "Install-Halo-VR.desktop"
-    installer.write_text(desktop)
-    installer.chmod(0o755)
-    print(installer)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())